programming python

Unicode và byte trong python là gì?

Các chuỗi Unicode có thể được mã hóa thành các chuỗi đơn giản theo nhiều cách khác nhau, tùy theo cách mã hóa bạn chọn

# Convert Unicode to plain Python string: "encode"
unicodestring = u"Hello world"
utf8string = unicodestring.encode["utf-8"]
asciistring = unicodestring.encode["ascii"]
isostring = unicodestring.encode["ISO-8859-1"]
utf16string = unicodestring.encode["utf-16"]

# Convert plain Python string to Unicode: "decode"
plainstring1 = unicode[utf8string, "utf-8"]
plainstring2 = unicode[asciistring, "ascii"]
plainstring3 = unicode[isostring, "ISO-8859-1"]
plainstring4 = unicode[utf16string, "utf-16"]

assert plainstring1==plainstring2==plainstring3==plainstring4

Nếu bạn thấy mình đang xử lý văn bản chứa các ký tự không phải ASCII, bạn phải tìm hiểu về Unicode—nó là gì, nó hoạt động như thế nào và Python sử dụng nó như thế nào

Unicode là một chủ đề lớn. May mắn thay, bạn không cần phải biết mọi thứ về Unicode để có thể giải quyết các vấn đề trong thế giới thực với nó. một vài kiến ​​thức cơ bản là đủ. Trước tiên, bạn phải hiểu sự khác biệt giữa byte và ký tự. Trong các ngôn ngữ và môi trường cũ hơn, lấy ASCII làm trung tâm, byte và ký tự được coi là giống nhau. Vì một byte có thể chứa tối đa 256 giá trị nên các môi trường này bị giới hạn ở 256 ký tự. Mặt khác, Unicode có hàng chục nghìn ký tự. Điều đó có nghĩa là mỗi ký tự Unicode chiếm nhiều hơn một byte, vì vậy bạn cần phân biệt giữa ký tự và byte

Các chuỗi Python tiêu chuẩn thực sự là các chuỗi byte và một ký tự Python thực sự là một byte. Các thuật ngữ khác cho loại Python tiêu chuẩn là “chuỗi 8 bit” và “chuỗi đơn giản. ” Trong công thức này, chúng tôi sẽ gọi chúng là các chuỗi byte, để nhắc bạn về hướng byte của chúng

Ngược lại, một ký tự Unicode trong Python là một đối tượng trừu tượng đủ lớn để chứa ký tự đó, tương tự như các số nguyên dài của Python. Bạn không phải lo lắng về đại diện nội bộ; . Khi đó, bạn phải chọn cách biểu diễn các ký tự dưới dạng byte. Chuyển đổi từ Unicode sang chuỗi byte được gọi là mã hóa chuỗi. Tương tự, khi bạn tải chuỗi Unicode từ tệp, ổ cắm hoặc đối tượng hướng byte khác, bạn cần giải mã chuỗi từ byte thành ký tự

Có nhiều cách chuyển đổi đối tượng Unicode thành chuỗi byte, mỗi cách được gọi là mã hóa. Vì nhiều lý do lịch sử, chính trị và kỹ thuật, không có một mã hóa “đúng” nào. Mọi mã hóa đều có tên không phân biệt chữ hoa chữ thường và tên đó được chuyển cho phương thức giải mã dưới dạng tham số. Dưới đây là một số bạn nên biết về

  • Mã hóa UTF-8 có thể xử lý bất kỳ ký tự Unicode nào. Nó cũng tương thích ngược với ASCII, do đó, tệp ASCII thuần túy cũng có thể được coi là tệp UTF-8 và tệp UTF-8 chỉ sử dụng các ký tự ASCII giống hệt với tệp ASCII có cùng ký tự. Thuộc tính này làm cho UTF-8 rất tương thích ngược, đặc biệt là với các công cụ Unix cũ hơn. UTF-8 là mã hóa thống trị trên Unix. Điểm yếu chính của nó là nó khá kém hiệu quả đối với các văn bản phương Đông

  • Mã hóa UTF-16 được ưa chuộng bởi hệ điều hành Microsoft và môi trường Java. Nó kém hiệu quả hơn đối với các ngôn ngữ phương Tây nhưng hiệu quả hơn đối với các ngôn ngữ phương Đông. Một biến thể của UTF-16 đôi khi được gọi là UCS-2

  • Chuỗi mã hóa ISO-8859 là siêu tập hợp ASCII 256 ký tự. Chúng không thể hỗ trợ tất cả các ký tự Unicode; . ISO-8859-1, còn được gọi là Latin-1, bao gồm hầu hết các ngôn ngữ Tây Âu và Châu Phi, trừ tiếng Ả Rập. ISO-8859-2, còn được gọi là Latin-2, bao gồm nhiều ngôn ngữ Đông Âu như tiếng Hungary và tiếng Ba Lan

Nếu bạn muốn có thể mã hóa tất cả các ký tự Unicode, có lẽ bạn muốn sử dụng UTF-8. Bạn có thể sẽ chỉ cần xử lý các mã hóa khác khi bạn được cung cấp dữ liệu trong các mã hóa đó được tạo bởi một số ứng dụng khác

So sánh chuỗi rất phức tạp bởi thực tế là Unicode có các ký tự kết hợp. dấu phụ và các dấu khác gắn vào ký tự trước đó, xuất hiện dưới dạng ký tự khi được in

Ví dụ: từ “café” có thể được soạn theo hai cách, sử dụng bốn hoặc năm điểm mã, nhưng kết quả trông giống hệt nhau

>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> s1, s2
['café', 'café']
>>> len[s1], len[s2]
[4, 5]
>>> s1 == s2
False

Đặt 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
3 [U+0301] sau “e” sẽ hiển thị “é”. Trong tiêu chuẩn Unicode, các chuỗi như 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
4 và 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
5 được gọi là "tương đương chính tắc" và các ứng dụng được coi là giống nhau. Nhưng Python thấy hai chuỗi điểm mã khác nhau và coi chúng không bằng nhau

Giải pháp là 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
6. Đối số đầu tiên của hàm đó là một trong bốn chuỗi. 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
7, 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
8, 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
9 và 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
0. Hãy bắt đầu với hai cái đầu tiên

Biểu mẫu chuẩn hóa C [NFC] tổng hợp các điểm mã để tạo ra chuỗi tương đương ngắn nhất, trong khi NFD phân tách, mở rộng các ký tự được tổng hợp thành các ký tự cơ sở và các ký tự kết hợp riêng biệt. Cả hai cách chuẩn hóa này đều làm cho phép so sánh hoạt động như mong đợi, như ví dụ tiếp theo cho thấy

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True

Trình điều khiển bàn phím thường tạo ra các ký tự được soạn thảo, vì vậy văn bản do người dùng nhập sẽ ở dạng NFC theo mặc định. Tuy nhiên, để an toàn, có thể tốt hơn là chuẩn hóa các chuỗi bằng 

>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
1 trước khi lưu. NFC cũng là dạng chuẩn hóa được W3C đề xuất trong “Mô hình ký tự cho World Wide Web. So khớp chuỗi và tìm kiếm”

Một số ký tự đơn được NFC chuẩn hóa thành một ký tự đơn khác. Biểu tượng cho đơn vị điện trở ohm [Ω] được chuẩn hóa thành chữ hoa Hy Lạp omega. Chúng giống hệt nhau về mặt hình ảnh, nhưng chúng so sánh không bằng nhau, vì vậy điều cần thiết là phải chuẩn hóa để tránh bất ngờ

>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True

Hai dạng chuẩn hóa khác là NFKC và NFKD, trong đó chữ K là viết tắt của “khả năng tương thích. ” Đây là những hình thức chuẩn hóa mạnh mẽ hơn, ảnh hưởng đến cái gọi là “ký tự tương thích. ” Mặc dù một mục tiêu của Unicode là có một điểm mã “chuẩn” duy nhất cho mỗi ký tự, một số ký tự xuất hiện nhiều lần để tương thích với các tiêu chuẩn có sẵn. Ví dụ: 

>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
2, 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
3 [_______94], đã được thêm vào Unicode để hỗ trợ chuyển đổi khứ hồi thành 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
5, bao gồm cả nó, mặc dù cùng một ký tự là một phần của bảng chữ cái Hy Lạp với mã điểm 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
6 [
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
7]. Vì vậy, dấu hiệu vi mô được coi là “ký tự tương thích. ”

Trong các biểu mẫu NFKC và NFKD, mỗi ký tự tương thích được thay thế bằng "sự phân tách khả năng tương thích" của một hoặc nhiều ký tự được coi là biểu diễn "ưu tiên", ngay cả khi có một số mất định dạng—lý tưởng nhất là định dạng phải do bên ngoài chịu trách nhiệm. . Để làm ví dụ, phân tách tương thích của phân số một nửa 

>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
8 [
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
9] là chuỗi ba ký tự 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
10 và phân tách tương thích của ký hiệu vi mô 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
11 [
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
4] là chữ thường mu 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
13 [_______96]. 7

Đây là cách NFKC hoạt động trong thực tế

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
1

Mặc dù 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
15 là một sự thay thế hợp lý cho 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
8 và ký hiệu vi mô thực sự là một chữ thường trong tiếng Hy Lạp mu, việc chuyển đổi 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
17 thành 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
18 sẽ thay đổi ý nghĩa. Một ứng dụng có thể lưu trữ 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
17 dưới dạng 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
18, nhưng hàm 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
31 không biết gì về định dạng. Do đó, NFKC hoặc NFKD có thể làm mất hoặc bóp méo thông tin, nhưng chúng có thể tạo ra các biểu diễn trung gian thuận tiện để tìm kiếm và lập chỉ mục

Thật không may, với Unicode, mọi thứ luôn phức tạp hơn lúc đầu. Đối với 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
32, quá trình chuẩn hóa NFKC đã tạo ra 1 và 2 được nối bởi 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
33, thay vì 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
34, một. k. a. “dấu gạch chéo”—ký tự quen thuộc với mã ASCII thập phân 47. Do đó, tìm kiếm chuỗi ASCII ba ký tự 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
10 sẽ không tìm thấy chuỗi Unicode chuẩn hóa

Cảnh báo

Chuẩn hóa NFKC và NFKD gây mất dữ liệu và chỉ nên được áp dụng trong các trường hợp đặc biệt như tìm kiếm và lập chỉ mục chứ không phải để lưu trữ văn bản vĩnh viễn

Khi chuẩn bị văn bản để tìm kiếm hoặc lập chỉ mục, một thao tác khác sẽ hữu ích. gấp trường hợp, chủ đề tiếp theo của chúng tôi

Trường hợp gấp

Trường hợp gấp về cơ bản là chuyển đổi tất cả văn bản thành chữ thường, với một số biến đổi bổ sung. Nó được hỗ trợ bởi phương pháp 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36

Đối với bất kỳ chuỗi 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
37 nào chỉ chứa 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
5 ký tự, 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
39 tạo ra kết quả giống như 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
20, chỉ có hai ngoại lệ—ký hiệu vi mô 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
11 được đổi thành chữ thường mu của Hy Lạp [trông giống nhau ở hầu hết các phông chữ] và chữ Eszett của Đức hoặc “sharp s 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
3

Có gần 300 điểm mã mà 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 và 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
23 trả về các kết quả khác nhau

Như thường lệ với bất cứ điều gì liên quan đến Unicode, trường hợp gấp là một vấn đề khó khăn với nhiều trường hợp đặc biệt về ngôn ngữ, nhưng nhóm cốt lõi của Python đã nỗ lực cung cấp một giải pháp hy vọng sẽ phù hợp với hầu hết người dùng

Trong vài phần tiếp theo, chúng ta sẽ sử dụng kiến ​​thức chuẩn hóa của mình để phát triển các hàm tiện ích

Các chức năng tiện ích để so khớp văn bản được chuẩn hóa

Như chúng ta đã thấy, NFC và NFD an toàn khi sử dụng và cho phép so sánh hợp lý giữa các chuỗi Unicode. NFC là hình thức chuẩn hóa tốt nhất cho hầu hết các ứng dụng. 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 là cách để so sánh không phân biệt chữ hoa chữ thường

Nếu bạn làm việc với văn bản ở nhiều ngôn ngữ, thì một cặp hàm như 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
25 và 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
26 trong Ví dụ 4-13 là những bổ sung hữu ích cho hộp công cụ của bạn

Ví dụ 4-13. bình thường. py. so sánh chuỗi Unicode chuẩn hóa

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
2

Ngoài chuẩn hóa Unicode và gấp trường hợp—cả hai đều là một phần của tiêu chuẩn Unicode—đôi khi áp dụng các phép biến đổi sâu hơn, chẳng hạn như thay đổi 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
27 thành 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
28 là điều hợp lý. Chúng ta sẽ xem khi nào và như thế nào trong phần tiếp theo

Cực kỳ “bình thường hóa”. Loại bỏ dấu phụ

Nước sốt bí mật của Google Tìm kiếm liên quan đến nhiều thủ thuật, nhưng một trong số đó rõ ràng là bỏ qua các dấu phụ [e. g. , trọng âm, cedillas, v.v. ], ít nhất là trong một số bối cảnh. Xóa dấu phụ không phải là một hình thức chuẩn hóa thích hợp vì nó thường làm thay đổi nghĩa của từ và có thể tạo ra kết quả dương tính giả khi tìm kiếm. Nhưng nó giúp đối phó với một số sự thật của cuộc sống. mọi người đôi khi lười biếng hoặc không biết gì về việc sử dụng đúng các dấu phụ và các quy tắc chính tả thay đổi theo thời gian, có nghĩa là các dấu xuất hiện và biến mất trong ngôn ngữ sống

Ngoài việc tìm kiếm, việc loại bỏ các dấu phụ cũng giúp các URL dễ đọc hơn, ít nhất là bằng các ngôn ngữ gốc Latinh. Hãy xem URL của bài viết trên Wikipedia về thành phố São Paulo

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
3

Phần 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
29 là kết xuất UTF-8 thoát URL của chữ cái đơn “ã” [“a” có dấu ngã]. Những điều sau đây dễ nhận ra hơn nhiều, ngay cả khi nó không đúng chính tả

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
5

Để xóa tất cả các dấu phụ khỏi 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
30, bạn có thể sử dụng hàm như Ví dụ 4-14

Ví dụ 4-14. đơn giản hóa. py. chức năng loại bỏ tất cả các dấu kết hợp

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
7

Phân tách tất cả các ký tự thành các ký tự cơ bản và kết hợp các dấu

Lọc ra tất cả các dấu kết hợp

Soạn lại tất cả các ký tự

Ví dụ 4-15 cho thấy một số cách sử dụng của 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
31

Ví dụ 4-15. Hai ví dụ sử dụng 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
31 từ Ví dụ 4-14
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
0

Chỉ có các chữ cái “è”, “ç” và “í” được thay thế

Cả “έ” và “é” đều được thay thế

Hàm 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
31 từ Ví dụ 4-14 hoạt động bình thường, nhưng có lẽ nó đi quá xa. Thông thường, lý do để loại bỏ các dấu phụ là để thay đổi văn bản Latinh thành ASCII thuần túy, nhưng 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
31 cũng thay đổi các ký tự không phải là Latinh—như các chữ cái Hy Lạp—sẽ không bao giờ trở thành ASCII chỉ bằng cách mất dấu của chúng. Vì vậy, thật hợp lý khi phân tích từng ký tự cơ bản và chỉ xóa các dấu đính kèm nếu ký tự cơ sở là một chữ cái trong bảng chữ cái Latinh. Đây là những gì Ví dụ 4-16 thực hiện

Ví dụ 4-16. Chức năng loại bỏ các dấu kết hợp khỏi các ký tự Latinh [các câu lệnh nhập được bỏ qua vì đây là một phần của chức năng đơn giản hóa. py từ Ví dụ 4-14]

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
0

Phân tách tất cả các ký tự thành các ký tự cơ bản và kết hợp các dấu

Bỏ qua các dấu kết hợp khi ký tự cơ sở là tiếng Latinh

Nếu không, hãy giữ ký tự hiện tại

Phát hiện ký tự cơ sở mới và xác định xem đó có phải là tiếng Latinh không

Soạn lại tất cả các ký tự

Một bước thậm chí triệt để hơn sẽ là thay thế các ký hiệu phổ biến trong các văn bản phương Tây [e. g. , dấu ngoặc kép, dấu gạch ngang, dấu đầu dòng, v.v. ] thành 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
35 tương đương. Đây là chức năng của hàm 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 trong Ví dụ 4-17

Ví dụ 4-17. Chuyển đổi một số ký hiệu đánh máy phương Tây thành ASCII [đoạn mã này cũng là một phần của công cụ đơn giản hóa. py từ Ví dụ 4-14]

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
1

Xây dựng bảng ánh xạ để thay thế char-to-char

Xây dựng bảng ánh xạ để thay thế chuỗi ký tự

Hợp nhất các bảng ánh xạ

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
37 không ảnh hưởng đến văn bản 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
35 hoặc 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
5, chỉ những phần bổ sung của Microsoft cho 
>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name[ohm]
'OHM SIGN'
>>> ohm_c = normalize['NFC', ohm]
>>> name[ohm_c]
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize['NFC', ohm] == normalize['NFC', ohm_c]
True
5 trong 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
51

Áp dụng 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
37 và xóa dấu phụ

Thay thế Eszett bằng “ss” [chúng tôi không sử dụng trường hợp gấp ở đây vì chúng tôi muốn giữ nguyên trường hợp]

Áp dụng chuẩn hóa NFKC để soạn các ký tự với các điểm mã tương thích của chúng

Ví dụ 4-18 hiển thị 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 đang được sử dụng

Ví dụ 4-18. Hai ví dụ sử dụng 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 từ Ví dụ 4-17
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
2

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
37 thay thế dấu nháy kép, dấu đầu dòng và ™ [ký hiệu nhãn hiệu]

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 áp dụng 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
37, bỏ dấu và thay thế 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
58

Cảnh báo

Các ngôn ngữ khác nhau có quy tắc riêng để loại bỏ dấu phụ. Ví dụ, người Đức đổi 

>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
59 thành 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
70. Hàm 
>>> from unicodedata import normalize
>>> s1 = 'café'
>>> s2 = 'cafe\N{COMBINING ACUTE ACCENT}'
>>> len[s1], len[s2]
[4, 5]
>>> len[normalize['NFC', s1]], len[normalize['NFC', s2]]
[4, 4]
>>> len[normalize['NFD', s1]], len[normalize['NFD', s2]]
[5, 5]
>>> normalize['NFC', s1] == normalize['NFC', s2]
True
>>> normalize['NFD', s1] == normalize['NFD', s2]
True
36 của chúng tôi không được tinh chỉnh, vì vậy nó có thể phù hợp hoặc không phù hợp với ngôn ngữ của bạn. Nó hoạt động chấp nhận được đối với tiếng Bồ Đào Nha, mặc dù

Tóm lại, các chức năng trong đơn giản hóa. py vượt xa sự chuẩn hóa tiêu chuẩn và thực hiện phẫu thuật sâu trên văn bản, với cơ hội tốt để thay đổi ý nghĩa của nó. Chỉ bạn mới có thể quyết định có đi xa hay không, biết ngôn ngữ mục tiêu, người dùng của bạn và cách sử dụng văn bản đã chuyển đổi

Unicode và byte là gì?

Unicode sử dụng hai dạng mã hóa. 8 bit và 16 bit, dựa trên loại dữ liệu của dữ liệu đang được mã hóa . Dạng mã hóa mặc định là 16 bit, trong đó mỗi ký tự rộng 16 bit [2 byte]. Dạng mã hóa mười sáu bit thường được hiển thị dưới dạng U+hhhh, trong đó hhhh là điểm mã thập lục phân của ký tự.

Unicode trong Python là gì?

Tóm tắt phần trước. một chuỗi Unicode là một chuỗi các điểm mã, là các số từ 0 đến 0x10FFFF [1.114.111 thập phân] . Chuỗi điểm mã này cần được biểu diễn trong bộ nhớ dưới dạng một tập hợp các đơn vị mã và sau đó các đơn vị mã được ánh xạ tới các byte 8 bit.

Sự khác biệt giữa Unicode và mã byte là gì?

Mã byte chỉ đơn giản là mã nguồn được chuyển đổi thành các mảng byte và được tạo sau khi biên dịch mã nguồn và chỉ có thể hiểu được đối với trình thông dịch hoặc bạn có thể nói môi trường thời gian chạy java. Unicode là tiêu chuẩn ký tự để đại diện cho bảng chữ cái của tất cả các ngôn ngữ trên thế giới

Byte trong Python là gì?

Byte trong Python là gì? . Một byte là một thuật ngữ kiến ​​trúc máy tính để lưu trữ bộ nhớ mã hóa một ký tự văn bản trong máy tính. a digital information unit that typically consists of 8 bits each of which consists of either a 0 or 1. A byte is a computer architecture term for memory storage that encodes a single character of text in a computer.

Bài Viết Liên Quan

Làm cách nào tôi có thể viết văn bản html bằng php?
Ngày 2 tháng 5 năm 2023 có phải là ngày lễ của ngân hàng không?
Các chuỗi Python có phải là ASCII không?
Cách gắn nhãn huyền thoại trong excel
Mc trong linux là gì
Bài kiểm tra Alabama có bắt buộc vào năm 2023 không
Gọi lại đồng bộ và không đồng bộ trong JavaScript
Các tệp PHP có thể thực thi được không?
Cách dừng vòng lặp trong Scratch
HTML CSS lịch đáp ứng
Excel kết hợp văn bản hàng trùng lặp
Có bao nhiêu lần trăng tròn sẽ xảy ra vào năm 2023?
Sắp xếp trong ứng dụng Google Trang tính iPhone
Ứng dụng di động python
Mô tả về cách bảo mật php đúng cách khi sử dụng apache
Phân tích bản đồ mongodb
Tương quan một phần Python numpy
Nội thất ford f350 2024
Visual Studio có thể được sử dụng cho Python không
Python ghi dòng trống vào tệp

Toplist mới

#1
Top 7 tết mậu thân năm 1968 đã diễn ra sự kiện gì ở miền nam nước ta 2023
6 tháng trước
#2
Top 13 luyện từ và câu: dấu gạch ngang lớp 4 trang 45 2023
6 tháng trước
#3
Top 6 trong mặt phẳng oxy ảnh của đường thẳng d 3x y 4=0 2023
6 tháng trước
#4
Top 6 thử thách thần chết thuyết minh phần 2 2023
6 tháng trước
#5
Top 4 vở bài tập tiếng việt lớp 3 tập 2 chính tả trang 15 2023
6 tháng trước
#6
Top 5 áo khoác nam quảng châu cao cấp 2023
6 tháng trước
#7
Top 4 nội dung nào sau đây không phải là trách nhiệm của đơn vị đầu mối cung cấp thông tin 2023
6 tháng trước
#8
Top 9 mẫu đồng phục công sở đẹp 2022 2023
6 tháng trước
#9
Top 5 ốp lưng iphone 13 pro bảo vệ camera 2023
6 tháng trước

Bài mới nhất

Nghệ thuật tự do toàn cầu là ngành gì năm 2024
400/1 lê văn sỹ - p14 - quận 3 năm 2024
Cách làm vở bài tập địa lý lớp 7 năm 2024
Font việt hóa không hiển thị giống như demo năm 2024
Chỉ số cạnh tranh cấp tỉnh là gì năm 2024
Sơ đồ tư duy văn bản đồng chí năm 2024
Vườn quốc gia u minh hạ thuộc tỉnh nào năm 2024
Top điều hòa inverter 9000btu tiết kiệm điện năm 2024
Đặc trưng của mùa hè là gì năm 2024
Lỗi api ltừ git blocked by cors policy năm 2024

Chủ Đề

programming Hỏi Đáp Là gì Mẹo Hay Toplist Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Tiếng anh Top List bao nhieu bao nhiêu hướng dẫn Món Ngon So Sánh Bài tập So sánh Xây Đựng Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Tại sao Máy tính Đại học