Cách giải mã byte trong Python

Định nghĩa

Các chương trình ngày nay cần có khả năng xử lý nhiều loại ký tự. Các ứng dụng thường được quốc tế hóa để hiển thị thông báo và xuất ra nhiều ngôn ngữ do người dùng lựa chọn; . Nội dung web có thể được viết bằng bất kỳ ngôn ngữ nào trong số này và cũng có thể bao gồm nhiều biểu tượng cảm xúc. Kiểu chuỗi của Python sử dụng Tiêu chuẩn Unicode để biểu diễn các ký tự, cho phép các chương trình Python hoạt động với tất cả các ký tự có thể khác nhau này

Unicode (https. //www. unicode. org/) là một đặc điểm kỹ thuật nhằm mục đích liệt kê mọi ký tự được sử dụng bởi ngôn ngữ của con người và cung cấp cho mỗi ký tự một mã duy nhất của riêng nó. Các thông số kỹ thuật Unicode liên tục được sửa đổi và cập nhật để thêm các ngôn ngữ và ký hiệu mới

Một ký tự là thành phần nhỏ nhất có thể có của một văn bản. 'A', 'B', 'C', v.v. , đều là các ký tự khác nhau. 'È' và 'Í' cũng vậy. Các ký tự khác nhau tùy thuộc vào ngôn ngữ hoặc ngữ cảnh mà bạn đang nói đến. Ví dụ: có một ký tự cho “Số một La Mã”, 'Ⅰ', tách biệt với chữ hoa 'I'. Chúng thường trông giống nhau, nhưng đây là hai ký tự khác nhau có ý nghĩa khác nhau

Tiêu chuẩn Unicode mô tả cách các ký tự được biểu thị bằng các điểm mã. Giá trị điểm mã là một số nguyên trong phạm vi từ 0 đến 0x10FFFF (khoảng 1. 1 triệu giá trị, ít hơn thế). Trong tiêu chuẩn và trong tài liệu này, một điểm mã được viết bằng cách sử dụng ký hiệu

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

Tiêu chuẩn Unicode chứa rất nhiều bảng liệt kê các ký tự và điểm mã tương ứng của chúng

0061    'a'; LATIN SMALL LETTER A
0062    'b'; LATIN SMALL LETTER B
0063    'c'; LATIN SMALL LETTER C
...
007B    '{'; LEFT CURLY BRACKET
...
2167    'Ⅷ'; ROMAN NUMERAL EIGHT
2168    'Ⅸ'; ROMAN NUMERAL NINE
...
265E    '♞'; BLACK CHESS KNIGHT
265F    '♟'; BLACK CHESS PAWN
...
1F600   '😀'; GRINNING FACE
1F609   '😉'; WINKING FACE
...

Nghiêm túc mà nói, những định nghĩa này ngụ ý rằng thật vô nghĩa khi nói 'đây là ký tự

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

Một ký tự được thể hiện trên màn hình hoặc trên giấy bằng một tập hợp các thành phần đồ họa được gọi là glyph. Ví dụ, nét chữ cho chữ hoa A là hai nét chéo và một nét ngang, mặc dù các chi tiết chính xác sẽ phụ thuộc vào phông chữ được sử dụng. Hầu hết các mã Python không cần phải lo lắng về glyphs;

mã hóa

Để 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

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

Mã hóa đầu tiên bạn có thể nghĩ đến là sử dụng số nguyên 32 bit làm đơn vị mã, sau đó sử dụng biểu diễn của CPU về số nguyên 32 bit. Trong biểu diễn này, chuỗi “Python” có thể trông như thế này

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Biểu diễn này rất đơn giản nhưng sử dụng nó gây ra một số vấn đề

1. Nó không di động;

2. Rất lãng phí không gian. Trong hầu hết các văn bản, phần lớn các điểm mã nhỏ hơn 127 hoặc nhỏ hơn 255, vì vậy rất nhiều không gian bị chiếm dụng bởi

   try:
       with open('/tmp/input.txt', 'r') as f:
           ...
   except OSError:
       # 'File not found' error message.
       print("Fichier non trouvé")
   

   9 byte. Chuỗi trên chiếm 24 byte so với 6 byte cần thiết cho biểu diễn ASCII. Mức sử dụng RAM tăng lên không quá quan trọng (máy tính để bàn có RAM hàng gigabyte và các chuỗi thường không lớn như vậy), nhưng việc mở rộng mức sử dụng băng thông mạng và đĩa của chúng tôi lên hệ số 4 là không thể chấp nhận được

3. Nó không tương thích với các hàm C hiện có như

   répertoire = "/tmp/records.log"
   with open(répertoire, "w") as f:
       f.write("test\n")
   

   0, vì vậy cần phải sử dụng một nhóm hàm chuỗi rộng mới

Do đó, bảng mã này không được sử dụng nhiều và thay vào đó mọi người chọn các bảng mã khác hiệu quả và tiện lợi hơn, chẳng hạn như UTF-8

UTF-8 là một trong những bảng mã được sử dụng phổ biến nhất và Python thường mặc định sử dụng nó. UTF là viết tắt của "Định dạng chuyển đổi Unicode" và '8' có nghĩa là các giá trị 8 bit được sử dụng trong mã hóa. (Cũng có bảng mã UTF-16 và UTF-32, nhưng chúng ít được sử dụng hơn UTF-8. ) UTF-8 sử dụng các quy tắc sau

1. Nếu điểm mã < 128, thì nó được biểu thị bằng giá trị byte tương ứng

2. Nếu điểm mã >= 128, thì nó được chuyển thành một chuỗi gồm hai, ba hoặc bốn byte, trong đó mỗi byte của chuỗi nằm trong khoảng từ 128 đến 255

UTF-8 có một số thuộc tính tiện lợi

1. Nó có thể xử lý bất kỳ điểm mã Unicode nào

2. Một chuỗi Unicode được biến thành một chuỗi byte chỉ chứa các byte 0 được nhúng khi chúng đại diện cho ký tự null (U+0000). Điều này có nghĩa là các chuỗi UTF-8 có thể được xử lý bởi các hàm C chẳng hạn như

   répertoire = "/tmp/records.log"
   with open(répertoire, "w") as f:
       f.write("test\n")
   

   1 và được gửi qua các giao thức không thể xử lý các byte bằng 0 cho bất kỳ thứ gì khác ngoài các điểm đánh dấu cuối chuỗi

3. Một chuỗi văn bản ASCII cũng là văn bản UTF-8 hợp lệ

4. UTF-8 khá nhỏ gọn;

5. Nếu byte bị hỏng hoặc bị mất, có thể xác định điểm bắt đầu của điểm mã được mã hóa UTF-8 tiếp theo và đồng bộ hóa lại. Cũng không chắc rằng dữ liệu 8-bit ngẫu nhiên sẽ giống như UTF-8 hợp lệ

6. UTF-8 là mã hóa hướng byte. Mã hóa chỉ định rằng mỗi ký tự được biểu thị bằng một chuỗi cụ thể gồm một hoặc nhiều byte. Điều này giúp tránh các vấn đề về thứ tự byte có thể xảy ra với mã hóa hướng số nguyên và từ, như UTF-16 và UTF-32, trong đó chuỗi byte thay đổi tùy thuộc vào phần cứng mà chuỗi được mã hóa

Người giới thiệu

Trang Unicode Consortium có các biểu đồ ký tự, bảng thuật ngữ và các phiên bản PDF của đặc tả Unicode. Hãy chuẩn bị cho một số bài đọc khó. Niên đại về nguồn gốc và sự phát triển của Unicode cũng có sẵn trên trang web

Trên kênh Youtube Computerphile, Tom Scott nói ngắn gọn về lịch sử của Unicode và UTF-8 (9 phút 36 giây)

Để giúp hiểu tiêu chuẩn, Jukka Korpela đã viết một hướng dẫn giới thiệu để đọc các bảng ký tự Unicode

Một bài giới thiệu hay khác được viết bởi Joel Spolsky. Nếu phần giới thiệu này không làm rõ mọi thứ với bạn, bạn nên thử đọc bài viết thay thế này trước khi tiếp tục

Các mục Wikipedia thường hữu ích;

Loại chuỗi

Kể từ Python 3. 0, loại ngôn ngữ chứa các ký tự Unicode, nghĩa là bất kỳ chuỗi nào được tạo bằng cách sử dụng

répertoire = "/tmp/records.log"
with open(répertoire, "w") as f:
    f.write("test\n")

répertoire = "/tmp/records.log"
with open(répertoire, "w") as f:
    f.write("test\n")

Mã hóa mặc định cho mã nguồn Python là UTF-8, vì vậy bạn chỉ cần đưa một ký tự Unicode vào một chuỗi ký tự

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

lưu ý bên lề. Python 3 cũng hỗ trợ sử dụng các ký tự Unicode trong mã định danh

________số 8_______

Nếu bạn không thể nhập một ký tự cụ thể trong trình chỉnh sửa của mình hoặc muốn giữ mã nguồn chỉ ở dạng ASCII vì lý do nào đó, bạn cũng có thể sử dụng các chuỗi thoát trong chuỗi ký tự. (Tùy thuộc vào hệ thống của bạn, bạn có thể thấy nét chữ hoa-đồng bằng thực tế thay vì chữ u thoát. )

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

Ngoài ra, người ta có thể tạo một chuỗi bằng cách sử dụng phương pháp. Phương thức này nhận một đối số mã hóa, chẳng hạn như

répertoire = "/tmp/records.log"
with open(répertoire, "w") as f:
    f.write("test\n")

Đối số lỗi chỉ định phản hồi khi chuỗi đầu vào không thể được chuyển đổi theo quy tắc mã hóa. Các giá trị pháp lý cho đối số này là

répertoire = "/tmp/records.log"
with open(répertoire, "w") as f:
    f.write("test\n")

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> b'\x80abc'.decode("utf-8", "strict")  
Traceback (most recent call last):
    ...
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:
  invalid start byte
>>> b'\x80abc'.decode("utf-8", "replace")
'\ufffdabc'
>>> b'\x80abc'.decode("utf-8", "backslashreplace")
'\\x80abc'
>>> b'\x80abc'.decode("utf-8", "ignore")
'abc'

Mã hóa được chỉ định dưới dạng chuỗi chứa tên mã hóa. Python đi kèm với khoảng 100 bảng mã khác nhau; . Một số bảng mã có nhiều tên;

Chuỗi Unicode một ký tự cũng có thể được tạo bằng hàm tích hợp, lấy số nguyên và trả về chuỗi Unicode có độ dài 1 chứa điểm mã tương ứng. Thao tác ngược lại là hàm tích hợp nhận chuỗi Unicode một ký tự và trả về giá trị điểm mã

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

Chuyển đổi sang byte

Phương thức ngược lại của is , trả về một đại diện của chuỗi Unicode, được mã hóa theo mã hóa được yêu cầu

Tham số lỗi giống như tham số của phương thức nhưng hỗ trợ thêm một số trình xử lý có thể. Cũng như

répertoire = "/tmp/records.log"
with open(répertoire, "w") as f:
    f.write("test\n")

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> "\N{GREEK CAPITAL LETTER DELTA}"  # Using the character name
'\u0394'
>>> "\u0394"                          # Using a 16-bit hex value
'\u0394'
>>> "\U00000394"                      # Using a 32-bit hex value
'\u0394'

>>> b'\x80abc'.decode("utf-8", "strict")  
Traceback (most recent call last):
    ...
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:
  invalid start byte
>>> b'\x80abc'.decode("utf-8", "replace")
'\ufffdabc'
>>> b'\x80abc'.decode("utf-8", "backslashreplace")
'\\x80abc'
>>> b'\x80abc'.decode("utf-8", "ignore")
'abc'

>>> b'\x80abc'.decode("utf-8", "strict")  
Traceback (most recent call last):
    ...
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0:
  invalid start byte
>>> b'\x80abc'.decode("utf-8", "replace")
'\ufffdabc'
>>> b'\x80abc'.decode("utf-8", "backslashreplace")
'\\x80abc'
>>> b'\x80abc'.decode("utf-8", "ignore")
'abc'

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

Ví dụ sau đây cho thấy các kết quả khác nhau

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

Các quy trình cấp thấp để đăng ký và truy cập các mã hóa có sẵn được tìm thấy trong mô-đun. Việc triển khai mã hóa mới cũng yêu cầu hiểu mô-đun. Tuy nhiên, các chức năng mã hóa và giải mã do mô-đun này trả về thường ở mức độ thấp hơn là thoải mái và việc viết mã hóa mới là một nhiệm vụ chuyên biệt, vì vậy mô-đun sẽ không được đề cập trong tài liệu HOWTO này

Chữ Unicode trong mã nguồn Python

Trong mã nguồn Python, các điểm mã Unicode cụ thể có thể được viết bằng cách sử dụng chuỗi thoát

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

Sử dụng chuỗi thoát cho các điểm mã lớn hơn 127 là tốt với liều lượng nhỏ, nhưng sẽ gây khó chịu nếu bạn đang sử dụng nhiều ký tự có dấu, giống như trong một chương trình có thông báo bằng tiếng Pháp hoặc một số ngôn ngữ sử dụng dấu khác. Bạn cũng có thể tập hợp các chuỗi bằng hàm có sẵn, nhưng điều này thậm chí còn tẻ nhạt hơn

Lý tưởng nhất là bạn muốn có thể viết chữ bằng mã hóa tự nhiên của ngôn ngữ của mình. Sau đó, bạn có thể chỉnh sửa mã nguồn Python bằng trình chỉnh sửa yêu thích của mình, trình chỉnh sửa này sẽ hiển thị các ký tự có dấu một cách tự nhiên và có các ký tự phù hợp được sử dụng khi chạy

Python hỗ trợ viết mã nguồn bằng UTF-8 theo mặc định, nhưng bạn có thể sử dụng hầu hết mọi mã hóa nếu bạn khai báo mã hóa đang được sử dụng. Điều này được thực hiện bằng cách bao gồm một nhận xét đặc biệt ở dòng đầu tiên hoặc dòng thứ hai của tệp nguồn

#!/usr/bin/env python
# -*- coding: latin-1 -*-

u = 'abcdé'
print(ord(u[-1]))

Cú pháp được lấy cảm hứng từ ký hiệu của Emacs để chỉ định các biến cục bộ cho một tệp. Emacs hỗ trợ nhiều biến khác nhau, nhưng Python chỉ hỗ trợ 'viết mã'. Các ký hiệu

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

>>> chr(57344)
'\ue000'
>>> ord('\ue000')
57344

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

Nếu bạn không bao gồm nhận xét như vậy, mã hóa mặc định được sử dụng sẽ là UTF-8 như đã đề cập. Xem thêm PEP 263 để biết thêm thông tin

Thuộc tính Unicode

Đặc tả Unicode bao gồm một cơ sở dữ liệu thông tin về các điểm mã. Đối với mỗi điểm mã được xác định, thông tin bao gồm tên của ký tự, loại của nó, giá trị số nếu có (đối với các ký tự đại diện cho các khái niệm số như chữ số La Mã, phân số như một phần ba và bốn phần năm, v.v. ). Ngoài ra còn có các thuộc tính liên quan đến hiển thị, chẳng hạn như cách sử dụng điểm mã trong văn bản hai chiều

Chương trình sau hiển thị một số thông tin về một số ký tự và in giá trị số của một ký tự cụ thể

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Khi chạy, bản in này

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Mã danh mục là chữ viết tắt mô tả bản chất của ký tự. Chúng được nhóm thành các danh mục như “Thư”, “Số”, “Dấu chấm câu” hoặc “Ký hiệu”, lần lượt được chia thành các danh mục con. Để lấy các mã từ đầu ra ở trên,

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

So sánh chuỗi

Unicode thêm một số phức tạp để so sánh các chuỗi, bởi vì cùng một bộ ký tự có thể được biểu thị bằng các chuỗi điểm mã khác nhau. Ví dụ: một chữ cái như 'ê' có thể được biểu thị dưới dạng một điểm mã U+00EA hoặc U+0065 U+0302, là điểm mã cho 'e' theo sau là điểm mã cho 'DẤU VÒNG KẾT HỢP'. Chúng sẽ tạo ra cùng một đầu ra khi được in, nhưng một là chuỗi có độ dài 1 và chuỗi kia có độ dài 2

Một công cụ để so sánh không phân biệt chữ hoa chữ thường là phương thức chuỗi chuyển đổi một chuỗi thành dạng không phân biệt chữ hoa chữ thường theo thuật toán được mô tả bởi Tiêu chuẩn Unicode. Thuật toán này có cách xử lý đặc biệt đối với các ký tự như chữ cái tiếng Đức 'ß' (điểm mã U+00DF), ký tự này trở thành cặp chữ cái viết thường 'ss'

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Công cụ thứ hai là chức năng của mô-đun chuyển đổi các chuỗi thành một trong số các dạng thông thường, trong đó các chữ cái theo sau bởi một ký tự kết hợp được thay thế bằng các ký tự đơn lẻ.

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Khi chạy, kết quả này xuất ra

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Đối số đầu tiên của hàm là một chuỗi cung cấp dạng chuẩn hóa mong muốn, có thể là một trong 'NFC', 'NFKC', 'NFD' và 'NFKD'

Tiêu chuẩn Unicode cũng chỉ định cách thực hiện so sánh không phân biệt chữ hoa chữ thường

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Điều này sẽ in

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> u = chr(40960) + 'abcd' + chr(1972)
>>> u.encode('utf-8')
b'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')  
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\ua000' in
  position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
b'abcd'
>>> u.encode('ascii', 'replace')
b'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
b'ꀀabcd޴'
>>> u.encode('ascii', 'backslashreplace')
b'\\ua000abcd\\u07b4'
>>> u.encode('ascii', 'namereplace')
b'\\N{YI SYLLABLE IT}abcd\\u07b4'

Biểu thức chính quy Unicode

Các biểu thức chính quy được mô-đun hỗ trợ có thể được cung cấp dưới dạng byte hoặc chuỗi. Một số chuỗi ký tự đặc biệt như

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

Chuỗi trong ví dụ này có số 57 được viết bằng cả chữ số Thái Lan và Ả Rập

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Khi thực hiện,

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

Tương tự,

>>> s = "a\xac\u1234\u20ac\U00008000"
.. #     ^^^^ two-digit hex escape
.. #         ^^^^^^ four-digit Unicode escape
.. #                     ^^^^^^^^^^ eight-digit Unicode escape
>>> [ord(c) for c in s]
[97, 172, 4660, 8364, 32768]

#!/usr/bin/env python
# -*- coding: latin-1 -*-

u = 'abcdé'
print(ord(u[-1]))

#!/usr/bin/env python
# -*- coding: latin-1 -*-

u = 'abcdé'
print(ord(u[-1]))

#!/usr/bin/env python
# -*- coding: latin-1 -*-

u = 'abcdé'
print(ord(u[-1]))

Người giới thiệu

Một số cuộc thảo luận thay thế tốt về hỗ trợ Unicode của Python là

• Xử lý tệp văn bản trong Python 3, bởi Nick Coghlan

• Pragmatic Unicode, một bản trình bày PyCon 2012 của Ned Batchelder

Loại được mô tả trong tài liệu tham khảo thư viện Python tại

Tài liệu về mô-đun

Tài liệu về mô-đun

Marc-André Lemburg đã thuyết trình với tiêu đề “Python và Unicode” (PDF slide) tại EuroPython 2002. Các trang trình bày là một tổng quan tuyệt vời về thiết kế các tính năng Unicode của Python 2 (trong đó loại chuỗi Unicode được gọi là

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

tên tệp Unicode

Hầu hết các hệ điều hành được sử dụng phổ biến hiện nay đều hỗ trợ tên tệp chứa các ký tự Unicode tùy ý. Thông thường, điều này được thực hiện bằng cách chuyển đổi chuỗi Unicode thành một số mã hóa khác nhau tùy thuộc vào hệ thống. Hôm nay Python đang tập trung vào việc sử dụng UTF-8. Python trên MacOS đã sử dụng UTF-8 cho một số phiên bản và Python 3. 6 cũng chuyển sang sử dụng UTF-8 trên Windows. Trên các hệ thống Unix, sẽ chỉ có một. nếu bạn đã đặt các biến môi trường

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Hàm trả về mã hóa để sử dụng trên hệ thống hiện tại của bạn, trong trường hợp bạn muốn thực hiện mã hóa theo cách thủ công nhưng không có nhiều lý do để bận tâm. Khi mở một tệp để đọc hoặc ghi, thông thường bạn chỉ cần cung cấp chuỗi Unicode làm tên tệp và nó sẽ tự động được chuyển đổi sang bảng mã phù hợp với bạn

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Các chức năng trong mô-đun như cũng sẽ chấp nhận tên tệp Unicode

Hàm trả về tên tệp, điều này gây ra sự cố. nó nên trả về phiên bản Unicode của tên tệp hay nó nên trả về các byte chứa các phiên bản được mã hóa? . Nếu bạn chuyển một chuỗi Unicode làm đường dẫn, tên tệp sẽ được giải mã bằng mã hóa của hệ thống tệp và một danh sách các chuỗi Unicode sẽ được trả về, trong khi chuyển một đường dẫn byte sẽ trả về tên tệp dưới dạng byte. Ví dụ: giả sử mặc định là UTF-8, hãy chạy chương trình sau

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

sẽ tạo ra đầu ra sau

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

Danh sách đầu tiên chứa tên tệp được mã hóa UTF-8 và danh sách thứ hai chứa các phiên bản Unicode

Lưu ý rằng trong hầu hết các trường hợp, bạn chỉ nên sử dụng Unicode với các API này. API byte chỉ nên được sử dụng trên các hệ thống có tên tệp không thể giải mã được;

Mẹo viết chương trình nhận biết Unicode

Phần này cung cấp một số gợi ý về cách viết phần mềm xử lý Unicode

Mẹo quan trọng nhất là

Phần mềm chỉ nên hoạt động với các chuỗi Unicode bên trong, giải mã dữ liệu đầu vào càng sớm càng tốt và chỉ mã hóa đầu ra khi kết thúc

Nếu bạn cố gắng viết các hàm xử lý chấp nhận cả chuỗi Unicode và chuỗi byte, bạn sẽ thấy chương trình của mình dễ bị lỗi bất cứ khi nào bạn kết hợp hai loại chuỗi khác nhau. Không có mã hóa hoặc giải mã tự động. nếu bạn làm e. g.

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Khi sử dụng dữ liệu đến từ trình duyệt web hoặc một số nguồn không đáng tin cậy khác, một kỹ thuật phổ biến là kiểm tra các ký tự không hợp lệ trong chuỗi trước khi sử dụng chuỗi trong dòng lệnh được tạo hoặc lưu trữ trong cơ sở dữ liệu. Nếu bạn đang làm điều này, hãy cẩn thận kiểm tra chuỗi đã giải mã, không phải dữ liệu byte được mã hóa; . Điều này đặc biệt đúng nếu dữ liệu đầu vào cũng chỉ định mã hóa, vì sau đó kẻ tấn công có thể chọn một cách thông minh để ẩn văn bản độc hại trong dòng byte được mã hóa

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

try:
    with open('/tmp/input.txt', 'r') as f:
        ...
except OSError:
    # 'File not found' error message.
    print("Fichier non trouvé")

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Người giới thiệu

Một phần của Mastering Python 3 Input/Output, một bài nói chuyện về PyCon 2010 của David Beazley, thảo luận về xử lý văn bản và xử lý dữ liệu nhị phân

Các slide PDF cho bài thuyết trình của Marc-André Lemburg “Viết ứng dụng nhận biết Unicode bằng Python” thảo luận về các câu hỏi về mã hóa ký tự cũng như cách quốc tế hóa và bản địa hóa ứng dụng. Các slide này bao gồm Python 2. chỉ x

The Guts of Unicode in Python là một bài nói chuyện tại PyCon 2013 của Benjamin Peterson thảo luận về cách biểu diễn Unicode bên trong trong Python 3. 3