14. Chuỗi, byte và Unicode

Dữ liệu văn bản và nhị phân là các họ đối tượng riêng biệt trong Python.strđại diện cho văn bản Unicode.bytesđại diện cho dữ liệu nhị phân bất biến.bytearrayđại diện cho dữ liệu nhị phân có thể thay đổi.

Sự tách biệt này là một trong những lựa chọn thiết kế thời gian chạy quan trọng nhất của Python 3. Văn bản có các ký tự và mã hóa. Dữ liệu nhị phân có byte. CPython triển khai các khái niệm này với các bố cục đối tượng, API và bất biến khác nhau.

14.1 Văn bản và Dữ liệu nhị phân

Một chuỗi là văn bản:python id="ly45du" s = "hello" Đối tượng byte là dữ liệu nhị phân:python id="1wh8hi" b = b"hello" Chúng có thể trông giống nhau đối với nội dung ASCII nhưng chúng thuộc các loại khác nhau.python id="iqtxra" print(type("hello")) # <class 'str'> print(type(b"hello")) # <class 'bytes'> Python không ngầm trộn lẫn chúng:python id="8bzmko" "hello" + b"world" # TypeError Đây là cố ý. Việc kết hợp văn bản và byte yêu cầu quyết định mã hóa.```python id="8w5t7o" text = "hello" data = text.encode("utf-8")

again = data.decode("utf-8")

## 14.2`str`Đại diện cho văn bản Unicode

một con trăn`str`là một chuỗi các điểm mã Unicode.```python id="tq2xfz"
s = "Python 🐍"
print(len(s))

len(s)đếm điểm mã, không mã hóa byte.```python id="lxgm2u" s = "é"

print(len(s)) # 1 print(len(s.encode("utf-8"))) # 2

Sự khác biệt này xuất hiện xuyên suốt nội bộ CPython:```text id="c3cd4w"
str
    logical Unicode text

bytes
    encoded or arbitrary binary data
```## 14.3 Điểm mã Unicode

Điểm mã Unicode là một giá trị nguyên được gán theo tiêu chuẩn Unicode.

Ví dụ:

| Nhân vật | Điểm mã |
| --------- | ---------- |
|`A`       | `U+0041`   |
| `é`       | `U+00E9`   |
| `中`       | `U+4E2D`   |
| `🐍`      | `U+1F40D`|

Python phơi bày điều này thông qua`ord`Và`chr`.

```python id="cvt38d"
print(ord("A"))        # 65
print(hex(ord("🐍")))  # 0x1f40d

print(chr(0x1f40d))    # 🐍
```Một chuỗi không được lưu trữ dưới dạng byte UTF-8 bên trong theo nghĩa phổ quát đơn giản. CPython chọn bố cục bên trong được tối ưu hóa cho nội dung của chuỗi.

## 14.4 Biểu diễn chuỗi linh hoạt

CPython sử dụng cách biểu diễn nội bộ linh hoạt cho chuỗi Unicode.

Ý tưởng chính rất đơn giản:```text id="hj5qoo"
Use the smallest fixed-width storage that can represent every code point in the string.
```Về mặt khái niệm:

| Điểm mã tối đa trong chuỗi |         Chiều rộng lưu trữ |
| ---------------------------- | --------------------: |
| chỉ ASCII |  1 byte mỗi ký tự |
| Lên đến`U+00FF`|  1 byte mỗi ký tự |
| Lên đến`U+FFFF`| 2 byte mỗi ký tự |
| Bên trên`U+FFFF`| 4 byte mỗi ký tự |

Ví dụ:```python id="k8wqod"
"abc"       # compact ASCII path
"café"      # may fit in 1-byte storage
"中"        # needs 2-byte storage
"🐍"        # needs 4-byte storage
```Thiết kế này tránh lãng phí bốn byte cho mỗi ký tự đối với văn bản nặng ASCII thông thường trong khi vẫn hỗ trợ tất cả các điểm mã Unicode.

## 14.5 Siêu dữ liệu đối tượng chuỗi

Chuỗi CPython không chỉ lưu trữ dữ liệu ký tự.

Các lĩnh vực khái niệm bao gồm:```text id="xr6949"
object header
length
hash cache
state flags
kind
compact flag
ASCII flag
ready flag
character data
optional UTF-8 cache
```Bố cục C chính xác là dành riêng cho từng phiên bản, nhưng các bất biến quan trọng hơn tên trường.

Siêu dữ liệu quan trọng:

| Siêu dữ liệu | Mục đích |
| ------------ | --------------------------------------------- |
| Chiều dài | Số điểm mã Unicode |
| Bộ nhớ đệm băm | Lưu trữ hàm băm sau lần tính toán đầu tiên |
| Loại | Chiều rộng lưu trữ |
| Cờ ASCII | Đường dẫn nhanh cho chuỗi ASCII |
| Cờ nhỏ gọn | Liệu dữ liệu có được lưu trữ gần tiêu đề đối tượng hay không |
| Bộ đệm UTF-8 | Biểu mẫu được mã hóa trong bộ nhớ đệm để sử dụng API C |

Chuỗi không thể thay đổi nên siêu dữ liệu được lưu trong bộ nhớ đệm sẽ an toàn. Sau khi tính toán, hàm băm vẫn hợp lệ.

## 14.6 Tính bất biến của chuỗi

Chuỗi Python là bất biến.```python id="8lnw2h"
s = "hello"
s[0] = "H"       # TypeError
```Các thao tác tạo chuỗi mới:```python id="q4ux6e"
s = "hello"
t = "H" + s[1:]

print(s)    # hello
print(t)    # Hello
```Tính bất biến mang lại cho CPython một số lợi thế:```text id="ylorrg"
hash values can be cached
strings can be safely interned
strings can be shared across dictionaries
strings can be used as dict keys
substring operations cannot mutate originals
```Cái giá phải trả là việc nối chuỗi lặp đi lặp lại có thể phân bổ nhiều chuỗi trung gian nếu được viết kém.

## 14.7 Băm chuỗi

Chuỗi có thể băm được.```python id="7pmw4s"
hash("name")
```Hàm băm của chuỗi được tính từ nội dung của nó. Vì các chuỗi là bất biến nên CPython có thể lưu trữ kết quả bên trong đối tượng chuỗi.

Điều này quan trọng vì các chuỗi được sử dụng nhiều làm khóa từ điển:```text id="n69066"
module globals
object attribute names
class dictionaries
keyword argument names
JSON-like data
configuration maps
protocol field names
```Nếu không có hàm băm chuỗi được lưu trong bộ nhớ đệm, việc tra cứu thuộc tính và tra cứu từ điển sẽ tốn kém hơn.

## 14.8 Thực tập chuỗi

Thực tập có nghĩa là sử dụng lại một đối tượng chuỗi cho các giá trị chuỗi bằng nhau trong các trường hợp đã chọn.```python id="alsrhm"
a = "identifier"
b = "identifier"

print(a is b)   # may be True
```CPython thực hiện nhiều chuỗi giống như mã định danh vì chúng phổ biến trong tra cứu thuộc tính và không gian tên.

Thực tập rất hữu ích cho:```text id="te68vu"
attribute names
variable names
keyword names
module names
common internal strings
```Với các chuỗi nội bộ, kiểm tra đẳng thức thường có thể trở thành kiểm tra con trỏ sau kiểm tra hàm băm trong các đường dẫn bên trong.

Nhưng mã người dùng không nên phụ thuộc vào nhận dạng chuỗi tùy ý.

Chính xác:```python id="k4ah3b"
if a == b:
    ...
```Không đúng:```python id="tgxz95"
if a is b:
    ...
```Sử dụng`is`chỉ dành cho ngữ nghĩa nhận dạng, đặc biệt là các tài liệu đơn lẻ như`None`.

## 14.9 Mã hóa

Mã hóa chuyển đổi văn bản thành byte.```python id="n587av"
s = "café"
b = s.encode("utf-8")

print(b)        # b'caf\xc3\xa9'
```Chuỗi là văn bản Unicode. UTF-8 là một biểu diễn byte bên ngoài.

Các mã hóa phổ biến:

| Mã hóa | Sử dụng |
| -------- | ----------------------------------- |
| UTF-8 | Web, tệp, API, hệ thống Unix |
| UTF-16 | Một số API nền tảng và định dạng tệp |
| UTF-32 | Bộ nhớ Unicode có chiều rộng cố định |
| Tiếng Latinh-1 | Ánh xạ byte phương Tây kế thừa |
| ASCII | Tập hợp con tiếng Anh 7-bit |

CPython không coi mã hóa là thuộc tính của`str`. Một chuỗi được giải mã văn bản. Mã hóa được sử dụng khi vượt qua ranh giới byte.

Giải mã ## 14.10

Giải mã chuyển đổi byte thành văn bản.```python id="n1sd4m"
b = b"caf\xc3\xa9"
s = b.decode("utf-8")

print(s)        # café
```Nếu các byte không hợp lệ đối với mã hóa đã chọn thì việc giải mã sẽ không thành công trừ khi sử dụng trình xử lý lỗi.```python id="83jkr9"
b = b"\xff"

b.decode("utf-8")                 # UnicodeDecodeError
b.decode("utf-8", errors="ignore")
b.decode("utf-8", errors="replace")
```Trình xử lý lỗi bao gồm:```text id="j4u46t"
strict
ignore
replace
backslashreplace
surrogateescape
surrogatepass
```Lỗi mã hóa là một phần của ranh giới văn bản, không phải các thao tác chuỗi thông thường.

## 14.11 Ranh giới UTF-8

Hầu hết văn bản bên ngoài hiện đại là UTF-8.

Ví dụ:```text id="ps2rks"
source files
JSON
HTTP payloads
HTML
Markdown
logs
configuration files
database text protocols
```Một quy tắc thực tế:```text id="cszoaq"
inside Python
    use str

at file, network, process, and binary protocol boundaries
    encode or decode explicitly
```Ví dụ:```python id="le5dmj"
from pathlib import Path

text = Path("notes.txt").read_text(encoding="utf-8")
data = text.encode("utf-8")
```Điều này giữ cho ranh giới rõ ràng.

## 14.12 Mã hóa mã nguồn

Các tệp nguồn Python được giải mã trước khi phân tích cú pháp.

Mã hóa nguồn mặc định là UTF-8 trừ khi khai báo mã hóa có quy định khác.

Ví dụ:```python id="cndzxu"
# -*- coding: utf-8 -*-

name = "café"
```Trình mã thông báo hoạt động trên văn bản nguồn được giải mã. Chuỗi ký tự sau đó trở thành Python`str`các đối tượng trừ khi chúng là byte bằng chữ.```python id="wu9nv8"
s = "abc"       # str
b = b"abc"      # bytes
```Sự khác biệt này được thực hiện trong quá trình phân tích cú pháp và biên dịch.

## 14.13 Chuỗi ký tự

Python có một số dạng chuỗi ký tự.```python id="9uk2iv"
"hello"
'hello'
"""hello"""
'''hello'''
r"\n"
f"value = {x}"
```Tiền tố chữ ảnh hưởng đến việc phân tích cú pháp:

| Tiền tố | Ý nghĩa |
| ------------ | ------------------------------- |
|`r`| Chuỗi ký tự thô |
|`f`| Chuỗi ký tự được định dạng |
|`b`| Byte theo nghĩa đen |
|`u`| Tiền tố tương thích lịch sử |
| kết hợp |`fr`, `rf`, `br`, `rb`|

Một chuỗi thô thay đổi cách trình phân tích cú pháp giải thích các ký tự thoát.```python id="5il9aw"
s = r"\n"
print(s)        # \n
```Nó vẫn tạo bình thường`str`.

## Đối tượng 14,14 byte`bytes`đại diện cho dữ liệu nhị phân bất biến.```python id="rdc547"
b = b"hello"
```Đối tượng byte là một chuỗi các số nguyên trong phạm vi từ 0 đến 255.```python id="a55532"
b = b"ABC"

print(b[0])     # 65
print(b[1])     # 66
```Cắt lát trả về một đối tượng byte khác:```python id="ry5nl7"
print(b[1:])    # b'BC'
```Bởi vì`bytes`là bất biến, nó có thể băm được.```python id="524c01"
d = {b"key": "value"}
```Byte rất hữu ích cho:```text id="ujfy6z"
network protocols
binary files
cryptographic data
compressed data
encoded text
database wire formats
image and audio formats
```## Bố cục đối tượng 14,15 byte

Đối tượng byte có kích thước thay đổi.

Về mặt khái niệm:```text id="kr49t3"
PyBytesObject
    PyVarObject header
        ob_size = number of bytes
    hash cache
    byte data
    trailing NUL byte for C compatibility
```Byte NUL ở cuối giúp ích khi truyền dữ liệu tới các API C có chuỗi C, nhưng byte có thể chứa byte NUL được nhúng:```python id="z96jr9"
b = b"a\0b"
print(len(b))   # 3
```Vì vậy, byte không được coi là chuỗi kết thúc bằng NUL thông thường trừ khi API đặc biệt cho phép điều đó và nội dung được xác định là an toàn.

## 14.16 Đối tượng Bytearray`bytearray`là dữ liệu nhị phân có thể thay đổi.```python id="cltuuo"
buf = bytearray(b"hello")
buf[0] = ord("H")

print(buf)      # bytearray(b'Hello')
```Một bytearray hỗ trợ sửa đổi tại chỗ:```python id="vf2c2m"
buf.append(33)
buf.extend(b" world")
```Nó không thể băm được vì nội dung của nó có thể thay đổi.```python id="2mamf7"
hash(bytearray(b"abc"))     # TypeError
```Về mặt khái niệm, bytearray gần giống với danh sách byte có thể thay đổi hơn, nhưng được triển khai dưới dạng bộ đệm byte nhỏ gọn hơn là một mảng tham chiếu đối tượng số nguyên Python.

## 14,17 Byte so với Danh sách Int

So sánh:```python id="mm43w3"
b = b"abc"
xs = [97, 98, 99]
```Đối tượng bytes lưu trữ byte thô một cách gọn gàng.

Danh sách lưu trữ các tham chiếu đến các đối tượng số nguyên Python.

Về mặt khái niệm:```text id="6zghb9"
bytes
    [97][98][99]

list
    [ptr][ptr][ptr]
      |    |    |
      v    v    v
     int  int  int
```Đối với dữ liệu nhị phân,`bytes`Và`bytearray`bộ nhớ hiệu quả hơn nhiều.

## 14.18 Chế độ xem bộ nhớ`memoryview`hiển thị bộ đệm của đối tượng khác.```python id="lk88r7"
buf = bytearray(b"hello")
view = memoryview(buf)

view[0] = ord("H")

print(buf)      # bytearray(b'Hello')
```Chế độ xem bộ nhớ tránh sao chép.

Nó rất hữu ích khi cắt hoặc truyền dữ liệu nhị phân giữa các API:```python id="fmmfbg"
data = bytearray(b"abcdef")
view = memoryview(data)[2:5]

print(view.tobytes())     # b'cde'
```Chế độ xem giữ cho nhà xuất khẩu tồn tại và thực thi các quy tắc trọn đời của bộ đệm.

## 14.19 Giao thức bộ đệm

Giao thức đệm là giao thức cấp C đằng sau`memoryview`.

Nó cho phép các đối tượng hiển thị bộ nhớ thô cho các đối tượng khác.

Các nhà xuất khẩu đệm phổ biến:```text id="yt656l"
bytes
bytearray
array.array
memoryview
mmap
third-party arrays such as NumPy arrays
custom extension objects
```Giao thức mô tả:```text id="va15hu"
pointer to memory
length
item size
format
number of dimensions
shape
strides
readonly flag
lifetime callbacks
```Điều này làm cho việc xử lý nhị phân không sao chép có thể thực hiện được.

## 14.20 I/O văn bản và I/O nhị phân

Tập tin có thể được mở ở chế độ văn bản hoặc chế độ nhị phân.

Chế độ văn bản giải mã byte thành chuỗi:```python id="ztfr4f"
with open("notes.txt", "r", encoding="utf-8") as f:
    text = f.read()
```Chế độ nhị phân trả về byte:```python id="2vcxb8"
with open("notes.txt", "rb") as f:
    data = f.read()
```Chế độ văn bản xử lý mã hóa, giải mã và dịch dòng mới.

Chế độ nhị phân cung cấp byte thô.

Chọn dựa trên mô hình dữ liệu:```text id="ifzmcj"
human-readable text
    text mode, str

protocol bytes or exact file bytes
    binary mode, bytes
```## 14.21 Lỗi ranh giới phổ biến

Một lỗi phổ biến là trộn văn bản và byte ở ranh giới.

Không đúng:```python id="zctul0"
def send(sock, message):
    sock.sendall(message)       # fails if message is str
```Chính xác:```python id="daxwma"
def send(sock, message):
    data = message.encode("utf-8")
    sock.sendall(data)
```Để nhận:```python id="jynmly"
data = sock.recv(4096)
text = data.decode("utf-8")
```Giữ chuyển đổi rõ ràng để mã hóa hiển thị.

## 14.22 Nối chuỗi

Chuỗi là bất biến nên việc nối chuỗi sẽ tạo ra một chuỗi mới.```python id="fnu5rd"
s = "a"
s = s + "b"
s = s + "c"
```Điều này có thể phân bổ nhiều lần.

Đối với nhiều phần, thích`join`:

```python id="xnzlkg"
parts = ["a", "b", "c"]
s = "".join(parts)
```Để truyền phát văn bản, hãy sử dụng`io.StringIO`:

```python id="1icewe"
from io import StringIO

buf = StringIO()
buf.write("a")
buf.write("b")
buf.write("c")

s = buf.getvalue()
```CPython có các tối ưu hóa cho một số trường hợp nối cục bộ, nhưng mã không nên phụ thuộc vào chúng để có hiệu suất chung.

## Tòa nhà 14,23 byte

Byte cũng không thay đổi được.

Việc nối các byte lặp đi lặp lại có cùng một vấn đề về phân bổ.```python id="bufv11"
data = b""
for chunk in chunks:
    data += chunk
```Tốt hơn:```python id="5ojx6g"
data = b"".join(chunks)
```Đối với xây dựng gia tăng có thể thay đổi:```python id="bpfowr"
buf = bytearray()
for chunk in chunks:
    buf.extend(chunk)

data = bytes(buf)
```Đối với việc xây dựng nhị phân giống như tập tin:```python id="s6mtb3"
from io import BytesIO

buf = BytesIO()
buf.write(b"abc")
buf.write(b"def")

data = buf.getvalue()
```## 14.24 Chuẩn hóa Unicode

Các chuỗi Unicode khác nhau có thể trông giống nhau.

Ví dụ:```python id="d3pxs7"
a = "é"          # single code point U+00E9
b = "e\u0301"    # e plus combining acute accent

print(a == b)    # False
```Chúng có thể hiển thị tương tự nhau, nhưng chúng là các chuỗi điểm mã khác nhau.

Bình thường hóa khi so sánh văn bản của con người:```python id="7m77tv"
import unicodedata

a = unicodedata.normalize("NFC", a)
b = unicodedata.normalize("NFC", b)

print(a == b)    # True
```Các hình thức chuẩn hóa phổ biến:

| Mẫu | Ý nghĩa |
| ---- | ----------------------------- |
| NFC | Thành phần kinh điển |
| NFD | Phân hủy kinh điển |
| NFKC | Thành phần tương thích |
| NFKD | Phân hủy khả năng tương thích |

Chuẩn hóa là mối quan tâm ở cấp độ Unicode, không phải là mối quan tâm về bố cục đối tượng CPython. Nhưng nó quan trọng để xử lý văn bản chính xác.

## 14.25 Trường hợp gấp

So sánh không phân biệt chữ hoa chữ thường nên sử dụng`casefold`, không`lower`.

```python id="xo53gl"
a = "Straße"
b = "strasse"

print(a.lower() == b.lower())       # often False
print(a.casefold() == b.casefold()) # True