Python 文本和字节序列

　　Python 3 明确区分了人类可读的文本字符串和原始的字节序列。隐式地把字节序列转换成 Unicode 文本已成过去。

　　深入理解 Unicode 对你可能十分重要，也可能无关紧要，这取决于Python 编程的场景。说到底，本章涵盖的问题对只处理 ASCII 文本的程序员没有影响。但是即便如此，也不能避而不谈字符串和字节序列的区别。此外，你会发现专门的二进制序列类型所提供的功能，有些是Python 2 中“全功能”的 str 类型不具有的。

 

字符问题

　　在 2015 年，“字符”的最佳定义是 Unicode 字符。因此，从 Python 3 的str 对象中获取的元素是 Unicode 字符，这相当于从 Python 2 的unicode 对象中获取的元素，而不是从 Python 2 的 str 对象中获取的原始字节序列。

举个🌰  编码和解码

>>> s = 'café'
>>> len(s)
4
>>> b = s.encode('utf-8')
>>> b
b'caf\xc3\xa9'
>>> len(b)
5
>>> b.decode('utf-8')
'café'

　　如果想帮助自己记住 .decode() 和 .encode() 的区别，可以把字节序列想成晦涩难懂的机器磁芯转储，把 Unicode 字符串想成“人类可读”的文本。那么，把字节序列变成人类可读的文本字符串就是解码，而把字符串变成用于存储或传输的字节序列就是编码。

 

字节概要

　　新的二进制序列类型在很多方面与 Python 2 的 str 类型不同。首先要知道，Python 内置了两种基本的二进制序列类型：Python 3 引入的不可变bytes 类型和 Python 2.6 添加的可变 bytearray 类型。（Python 2.6 也引入了 bytes 类型，但那只不过是 str 类型的别名，与 Python 3 的bytes 类型不同。）

　　bytes 或 bytearray 对象的各个元素是介于 0~255（含）之间的整数，而不像 Python 2 的 str 对象那样是单个的字符。然而，二进制序列的切片始终是同一类型的二进制序列，包括长度为 1 的切片，如示例：

>>> cafe = bytes('café', encoding='utf_8')
>>> cafe
b'caf\xc3\xa9'
>>> cafe[0]
99
>>> cafe[:1]
b'c'
>>> cafe_arr = bytearray(cafe)
>>> cafe_arr
bytearray(b'caf\xc3\xa9')
>>> cafe_arr[-1:]
bytearray(b'\xa9')

二进制序列有个类方法是 str 没有的，名为 fromhex，它的作用是解析十六进制数字对（数字对之间的空格是可选的），构建二进制序列：

>>> bytes.fromhex('31 4B CE A9')
b'1K\xce\xa9'
>>> bytes.fromhex('31 4B CE A9').decode('utf-8')
'1KΩ'

使用数组中的原始数据初始化 bytes 对象

>>> import array
>>> numbers = array.array('h', [-2, -1, 0, 1, 2])
>>> octets = bytes(numbers)
>>> octets
b'\xfe\xff\xff\xff\x00\x00\x01\x00\x02\x00'

 

结构体和内存视图 

　　struct 模块提供了一些函数，把打包的字节序列转换成不同类型字段组成的元组，还有一些函数用于执行反向转换，把元组转换成打包的字节序列。struct 模块能处理 bytes、bytearray 和 memoryview 对象。

使用 memoryview 和 struct 查看一个 GIF 图像的首部

>>> import struct
>>> fmt = '<3s3sHH' # ➊
>>> with open('filter.gif', 'rb') as fp:
... img = memoryview(fp.read()) # ➋
...
>>> header = img[:10] # ➌
>>> bytes(header) # ➍
b'GIF89a+\x02\xe6\x00'
>>> struct.unpack(fmt, header) # ➎
(b'GIF', b'89a', 555, 230)
>>> del header # ➏
>>> del img

1. 结构体的格式：< 是小字节序，3s3s 是两个 3 字节序列，HH 是两个16 位二进制整数
2. 使用内存中的文件内容创建一个memoryview对象
3. 然后使用它的切片在创建一个memoryview对象，这里不会复制字节序列
4. 转换成字节序列，这里只是为了显示，这里复制了是个字节
5. 拆包memoryview对象，得到一个元祖，包含类型、版本、宽度和高度
6. 删除引用，释放memoryview实例所占用的内存

 

处理UnicodeEncodeError

　　多数非 UTF 编解码器只能处理 Unicode 字符的一小部分子集。把文本转换成字节序列时，如果目标编码中没有定义某个字符，那就会抛出UnicodeEncodeError 异常，除非把 errors 参数传给编码方法或函数，对错误进行特殊处理。

举个🌰  编码成字节序列：成功和错误处理

city = 'São Paulo'

#'utf_?' 编码能处理任何字符串
u8 = city.encode('utf_8')
print('utf-8:', u8)

u16 = city.encode('utf_16')
print('utf-16:', u16)

#'iso8859_1' 编码也能处理字符串 'São Paulo
iso = city.encode('iso8859_1')
print('iso:', iso)

#报错咯，'cp437' 无法编码 'ã'（带波形符的“a”）
#city.encode('cp437')

#解决方法如下
cp_ig = city.encode('cp437', errors='ignore')
print('cp ignore:', cp_ig)

cp_rp = city.encode('cp437', errors='replace')
print('cp replace:', cp_rp)

以上代码执行的结果为：

utf-8: b'S\xc3\xa3o Paulo'
utf-16: b'\xff\xfeS\x00\xe3\x00o\x00 \x00P\x00a\x00u\x00l\x00o\x00'
iso: b'S\xe3o Paulo'
cp ignore: b'So Paulo'
cp replace: b'S?o Paulo'

注意：

1. error='ignore' 处理方式悄无声息地跳过无法编码的字符；这样做通常很是不妥
2. 编码时指定error='replace'，把无法编码的字符替换成'?'；数据损坏了，但是用户知道出现了问题

 

处理文本文件 

　　处理文本的最佳实践是“Unicode 三明治”（如图下图所示）。 意思是，要尽早把输入（例如读取文件时）的字节序列解码成字符串。这种三明治中的“肉片”是程序的业务逻辑，在这里只能处理字符串对象。在其他处理过程中，一定不能编码或解码。对输出来说，则要尽量晚地把字符串编码成字节序列。多数 Web 框架都是这样做的，使用框架时很少接触字节序列。例如，在 Django 中，视图应该输出 Unicode 字符串；Django 会负责把响应编码成字节序列，而且默认使用 UTF-8 编码。

处理文本文件很简单。但是，如果依赖默认编码，你会遇到麻烦。举个🌰

#打开一个文件cafe.txt并写入内容，w是对文件的模式操作(写操作)， encoding是对文件操作的编码
fp = open('cafe.txt', 'w', encoding='utf_8')
fp_len = fp.write('café')
print('fp的io信息：', fp)
print('写入到文件中内容的长度：', fp_len)
fp.close()

#获取文件的内容
fp2 = open('cafe.txt')
print('fp2的io信息：', fp2)
'''
因为和上面的写入的编码不同，所以直接以默认的编码打开，无法处理é而引发异常
'''
#print(fp2.read())
fp2.close()

#解决fp2无法或许文件内容的方法指定打开的时候编码
fp3 = open('cafe.txt', encoding='utf-8')
print('fp3的io信息：', fp3)
print('fp3中的文件内容：', fp3.read())
fp3.close()

fp4 = open('cafe.txt', 'rb')
print('fp4的io信息：', fp4)
print('fp4的文件内容：', fp4.read().decode('utf-8'))
fp4.close()

#另外一种不太可取的解决方案, errors可以设置成replace或者ignore
fp5 = open('cafe.txt', 'r', errors='ignore')
print('fp5的io信息：', fp5)
print('fp5的文件内容：', fp5.read())

以上代码执行的结果为：

fp的io信息： <_io.TextIOWrapper name='cafe.txt' mode='w' encoding='utf_8'>
写入到文件中内容的长度： 4
fp2的io信息： <_io.TextIOWrapper name='cafe.txt' mode='r' encoding='US-ASCII'>
fp3的io信息： <_io.TextIOWrapper name='cafe.txt' mode='r' encoding='utf-8'>
fp3中的文件内容： café
fp4的io信息： <_io.BufferedReader name='cafe.txt'>
fp4的文件内容： café
fp5的io信息： <_io.TextIOWrapper name='cafe.txt' mode='r' encoding='US-ASCII'>
fp5的文件内容： caf

探索编码默认值

import  sys, locale


expressions = """
    locale.getpreferredencoding()       
    type(my_file)                       
    my_file.encoding                    
    sys.stdout.isatty()                 
    sys.stdout.encoding                 
    sys.stdin.isatty()                  
    sys.stdin.encoding
    sys.stderr.isatty()
    sys.stderr.encoding
    sys.getdefaultencoding()
    sys.getfilesystemencoding()
"""

with open('dummy', 'w') as my_file:
    for expression in expressions.split():
        value = eval(expression)
        print('{:>30}'.format(expression), '->', repr(value))
        
'''
locale.getpreferredencoding() 是最重要的设置
文本文件默认使用 locale.getpreferredencoding()
输出到控制台中，因此 sys.stdout.isatty() 返回 True
因此，sys.stdout.encoding 与控制台的编码相同
'''

以上代码执行的结果为(终端运行)：

ocale.getpreferredencoding() -> 'UTF-8'
                 type(my_file) -> <class '_io.TextIOWrapper'>
              my_file.encoding -> 'UTF-8'
           sys.stdout.isatty() -> True
           sys.stdout.encoding -> 'UTF-8'
            sys.stdin.isatty() -> True
            sys.stdin.encoding -> 'UTF-8'
           sys.stderr.isatty() -> True
           sys.stderr.encoding -> 'UTF-8'
      sys.getdefaultencoding() -> 'utf-8'
   sys.getfilesystemencoding() -> 'utf-8'

 

为了正确比较而规范化Unicode字符串

　　因为 Unicode 有组合字符（变音符号和附加到前一个字符上的记号，打印时作为一个整体），所以字符串比较起来很复杂。

🌰  例如，“café”这个词可以使用两种方式构成，分别有 4 个和 5 个码位，但是结果完全一样：

>>> s1 = 'café'
>>> s2 = 'cafe\u0301'
>>> s1, s2
('café', 'café')
>>> len(s1), len(s2)
(4, 5)
>>> s1 == s2
False 

　　'é' 和 'e\u0301' 这样的序列叫“标准等价物”（canonical equivalent），应用程序应该把它们视作相同的字符。但是，Python 看到的是不同的码位序列，因此判定二者不相等。

  　  解决方案是使用 unicodedata.normalize 函数提供的Unicode 规范化。这个函数的第一个参数是这 4 个字符串中的一个：'NFC'、'NFD'、'NFKC' 和 'NFKD'。下面先说明前两个。

　　NFC（Normalization Form C）使用最少的码位构成等价的字符串，而NFD 把组合字符分解成基字符和单独的组合字符。这两种规范化方式都能让比较行为符合预期：

from unicodedata import normalize


s1 = 'café' # 把"e"和重音符组合在一起
s2 = 'cafe\u0301' # 分解成"e"和重音符
print('s1和s2的长度：', len(s1), len(s2))

print('NFC标准化处理以后的s1,s2的长度：', len(normalize('NFC', s1)), len(normalize('NFC', s2)))
print('NFD标准化处理以后的s1,s2的长度：', len(normalize('NFD', s1)), len(normalize('NFD', s2)))
print(normalize('NFC', s1), normalize('NFC', s2))

以上代码执行的结果为：

s1和s2的长度： 4 5
NFC标准化处理以后的s1,s2的长度： 4 4
NFD标准化处理以后的s1,s2的长度： 5 5
café café

　　在另外两个规范化形式（NFKC 和 NFKD）的首字母缩略词中，字母 K表示“compatibility”（兼容性）。这两种是较严格的规范化形式，对“兼容字符”有影响。虽然 Unicode 的目标是为各个字符提供“规范的”码位，但是为了兼容现有的标准，有些字符会出现多次。例如，虽然希腊字母表中有“μ”这个字母（码位是 U+03BC，GREEK SMALL LETTER MU），但是 Unicode 还是加入了微符号 'μ'（U+00B5），以便与 latin1 相互转换。因此，微符号是一个“兼容字符”。

NFC的具体应用🌰

>>> from unicodedata import normalize
>>> half = '½'
>>> normalize('NFKC', half)
'1⁄2'
>>> four_squared = '4²'
>>> normalize('NFKC', four_squared)
'42'
>>> micro = 'μ'
>>> micro_kc = normalize('NFKC', micro)
>>> micro, micro_kc
('μ', 'μ')
>>> ord(micro), ord(micro_kc)
(956, 956)

　　使用 '1/2' 替代 '½' 可以接受，微符号也确实是小写的希腊字母'μ'，但是把 '4²' 转换成 '42' 就改变原意了。某些应用程序可以把'4²' 保存为 '4²'，但是 normalize 函数对格式一无所知。因此，NFKC 或 NFKD 可能会损失或曲解信息，但是可以为搜索和索引提供便利的中间表述：用户搜索 '1 / 2 inch' 时，如果还能找到包含 '½ inch' 的文档，那么用户会感到满意。

注意：

　　使用 NFKC 和 NFKD 规范化形式时要小心，而且只能在特殊情况中使用，例如搜索和索引，而不能用于持久存储，因为这两种转换会导致数据损失。

 

规范化文本匹配实用函数

　　由前文可知，NFC 和 NFD 可以放心使用，而且能合理比较 Unicode 字符串。对大多数应用来说，NFC 是最好的规范化形式。不区分大小写的比较应该使用 str.casefold()。

　　如果要处理多语言文本，工具箱中应用nfc_equal 和fold_equal 函数。

🌰  比较规范化 Unicode 字符串

from unicodedata import normalize


def nfc_equal(str1, str2):
    return normalize('NFC', str1) == normalize('NFC', str2)

def fold_equal(str1, str2):
    return (normalize('NFC', str1).casefold() ==
            normalize('NFC', str2).casefold())

s1 = 'café'
s2 = 'cafe\u0301'
print('s1 equal s2:',nfc_equal(s1, s2))

print(nfc_equal('A', 'a'))

s3 = 'Straße'
s4 = 'strasse'

print('s3 equal s4', nfc_equal(s3, s4))
#转换字符成小写
print(fold_equal(s3, s4)) 

以上代码的执行结果为:

s1 equal s2: True
False
s3 equal s4 False
True

极端“规范化”：去掉变音符号

去掉变音符号还能让 URL 更易于阅读，至少对拉丁语系语言是如此。下面是维基百科中介绍圣保罗市（São Paulo）的文章的URL：

http://en.wikipedia.org/wiki/S%C3%A3o_Paulo

其中，“%C3%A3”是 UTF-8 编码“ã”字母（带有波形符的“a”）转义后得到的结果。下述形式更友好，尽管拼写是错误的：

http://en.wikipedia.org/wiki/Sao_Paulo

如果想把字符串中的所有变音符号都去掉，看 🌰

import unicodedata


def shave_marks(txt):
    """去掉全部变音符号"""

    norm_txt = unicodedata.normalize('NFD', txt)        #把所有字符分解成基字符和组合记号
    shaved = ''.join(c for c in norm_txt
                     if not unicodedata.combining(c))   #过滤掉所有组合记号
    return unicodedata.normalize('NFC', shaved)         #重组所有字符


order = '“Herr Voß: • ½ cup of OEtker™ caffè latte • bowl of açaí.”'
print(shave_marks(order))

Greek = 'Zέφupoς, Zéfiro'
print(shave_marks(Greek))

以上代码执行的结果为：

“Herr Voß: • ½ cup of OEtker™ caffe latte • bowl of acai.”
Zεφupoς, Zefiro

 

Unicode文本排序

　　Python 比较任何类型的序列时，会一一比较序列里的各个元素。对字符串来说，比较的是码位。可是在比较非 ASCII 字符时，得到的结果不尽如人意。

🌰 来了~，对一个生长在 🇧🇷 的水果排序

>>> fruits = ['caju', 'atemoia', 'cajá', 'açaí', 'acerola']
>>> sorted(fruits)
['acerola', 'atemoia', 'açaí', 'caju', 'cajá']

　　不同的区域采用的排序规则有所不同，葡萄牙语等很多语言按照拉丁字母表排序，重音符号和下加符对排序几乎没什么影响。 因此，排序时“cajá”视作“caja”，必定排在“caju”前面。

　　排序后的 fruits 列表应该是：

['açaí', 'acerola', 'atemoia', 'cajá', 'caju']

　　在 Python 中，非 ASCII 文本的标准排序方式是使用 locale.strxfrm函数，根据 locale 模块的文档（https://docs.python.org/3/library/locale.html?highlight=strxfrm#locale.strxfrm），这 个函数会“把字符串转换成适合所在区域进行比较的形式”。

　　 使用 locale.strxfrm 函数之前，必须先为应用设定合适的区域设置，还要祈祷操作系统支持这项设置。在区域设为 pt_BR 的GNU/Linux（Ubuntu 14.04）中，可以使用示例中的命令：

　　使用 locale.strxfrm 函数做排序键

import locale

#设置时区
print(locale.setlocale(locale.LC_COLLATE, 'pt_BR.UTF-8'))

fruits = ['caju', 'atemoia', 'cajá', 'açaí', 'acerola']
fruits_sort = sorted(fruits, key=locale.strxfrm)
print('搞定：', fruits_sort)

以上代码的执行结果为:

pt_BR.UTF-8
搞定： ['acerola', 'atemoia', 'açaí', 'caju', 'cajá']

使用Unicode排序算法排序

🌰  使用 pyuca.Collator.sort_key 方法

>>> import pyuca
>>> coll = pyuca.Collator()
>>> fruits = ['caju', 'atemoia', 'cajá', 'açaí', 'acerola']
>>> sorted_fruits = sorted(fruits, key=coll.sort_key)
>>> sorted_fruits
['açaí', 'acerola', 'atemoia', 'cajá', 'caju']

 

支持字符串和字节序列的双模式API

　　标准库中的一些函数能接受字符串或字节序列为参数，然后根据类型展现不同的行为。re 和 os 模块中就有这样的函数。

正则表达式中的字符串和字节序列

🌰 ramanujan.py：比较简单的字符串正则表达式和字节序列正则表达式的行为

import re


re_numbers_str = re.compile(r'\d+')     #编译匹配字符串的数字的正则，连续数字，至少出现一次
re_words_str = re.compile(r'\w+')
re_numbers_bytes = re.compile(rb'\d+')  #编译匹字节序列配数字的正则，连续数字，至少出现一次
re_words_bytes = re.compile(rb'\w+')

text_str = ("Ramanujan saw \u0be7\u0bed\u0be8\u0bef" 
            " as 1729 = 1³ + 12³ = 9³ + 10³.")

text_bytes = text_str.encode('utf_8')

print('Text', repr(text_str), sep='\n ')
print('Numbers')
print(' str :', re_numbers_str.findall(text_str))
print(' bytes:', re_numbers_bytes.findall(text_bytes))
print('Words')
print(' str :', re_words_str.findall(text_str))
print(' bytes:', re_words_bytes.findall(text_bytes))

以上代码执行的结果为：

Text
 'Ramanujan saw ௧௭௨௯ as 1729 = 1³ + 12³ = 9³ + 10³.'
Numbers
 str : ['௧௭௨௯', '1729', '1', '12', '9', '10']
 bytes: [b'1729', b'1', b'12', b'9', b'10']
Words
 str : ['Ramanujan', 'saw', '௧௭௨௯', 'as', '1729', '1³', '12³', '9³', '10³']
 bytes: [b'Ramanujan', b'saw', b'as', b'1729', b'1', b'12', b'9', b'10']