第7章 像高手一样玩转数据

本章将学到许多操作数据的方法，它们大多与下面这两种内置的 Python 数据类型有关。
• 字符串
Unicode 字符组成的序列，用于存储文本数据。
• 字节和字节数组
8 比特整数组成的序列，用于存储二进制数据。

7.1　文本字符串
对大多数读者来说，文本应该是最熟悉的数据类型了，因此我们从文本入手，首先介绍一
些 Python 中有关字符串操作的强大特性。
7.1.1　Unicode
到目前为止，书中例子使用的都是用原始 ASCII 编码的字符串。ASCII 诞生于 20 世纪 60
年代，那时的计算机还和冰箱差不多大，运算速度也仅仅比人力稍快一些。众所周知，计
算机的基本存储单元是字节（byte），它包含 8 位 / 比特（bit），可以存储 256 种不同的值。
出于一些设计目的，ASCII 只使用了 7 位（128 种取值）：26 个大写字母、26 个小写字母、
10 个阿拉伯数字、一些标点符号、空白符以及一些不可打印的控制符。
不幸的是，世界上现存的字符远远超过了 ASCII 所能支持的 128 个。设想在一个只
有 ASCII 字符的世界中，你可以在咖啡厅点个热狗作为晚餐，但永远也点不到美味的
Gewürztraminer 酒1 。为了支持更多的字母及符号，人们已经做出了许多努力，其中有些成

果你可能见到过。例如下面这两个：
• Latin-1 或 ISO 8859-1
• Windows code page 1252
上面这些编码规则使用全 8 比特（ASCII 只使用了 7 比特）进行编码，但这明显不够用，
尤其是当你需要表示非印欧语系的语言符号时。Unicode 编码是一种正在发展中的国际化
规范，它可以包含世界上所有语言以及来自数学领域和其他领域的各种符号。

Unicode 为每个字符赋予了一个特殊的数字编码，这些编码与具体平台、程序、
语言均无关。
—— Unicode 协会

Unicode Code Charts 页面（http://www.unicode.org/charts/）包含了通往目前已定义的所有
字符集的链接，且包含字符图示。最新的版本（6.2）定义了超过 110 000 种字符，每一种
都有自己独特的名字和标识数。这些字符被分成了若干个 8 比特的集合，我们称之为平面
（plane）。前 256 个平面为基本多语言平面（basic multilingual plane）。你可以在维基百科中
查看更多关于 Unicode 平面的信息（http://en.wikipedia.org/wiki/Plane_(Unicode)）。
1. Python 3中的Unicode字符串
Python 3 中的字符串是 Unicode 字符串而不是字节数组。这是与 Python 2 相比最大的差别。
在 Python 2 中，我们需要区分普通的以字节为单位的字符串以及 Unicode 字符串。
如果你知道某个字符的 Unicode ID，可以直接在 Python 字符串中引用这个 ID 获得对应字
符。下面是几个例子。
• 用 \u 及 4 个十六进制的数字 2 可以从 Unicode 256 个基本多语言平面中指定某一特定字
符。其中，前两个十六进制数字用于指定平面号（ 00 到 FF ），后面两个数字用于指定该
字符位于平面中的位置索引。 00 号平面即为原始的 ASCII 字符集，字符在该平面的位
置索引与它的 ASCII 编码一致。
• 我们需要使用更多的比特位来存储那些位于更高平面的字符。Python 为此而设计的转义
序列以 \U 开头，后面紧跟着 8 个十六进制的数字，其中最左一位需为 0 。
• 你也可以通过 \N{name} 来引用某一字符，其中 name 为该字符的标准名称，这对所有平
面的字符均适用。在 Unicode 字符名称索引页（http://www.unicode.org/charts/charindex.
html）可以查到字符对应的标准名称。
Python 中的 unicodedata 模块提供了下面两个方向的转换函数：
•  lookup() ——接受不区分大小写的标准名称，返回一个 Unicode 字符；
•  name() ——接受一个 Unicode 字符，返回大写形式的名称。

下面的例子中，我们将编写一个测试函数，它接受一个 Python Unicode 字符，查找它对应
的名称，再用这个名称查找对应的 Unicode 字符（它应该与原始字符相同）：

In [1]: def unicode_test(value):
   ...:     import unicodedata
   ...:     name = unicodedata.name(value)
   ...:     value2 = unicodedata.lookup(name)
   ...:     print('value="%s", name="%s", value2="%s"' % (value, name, value2))
   ...:

'''用一些字符来测试一下吧。首先试一下纯 ASCII 字符：'''
In [2]: unicode_test('A')
value="A", name="LATIN CAPITAL LETTER A", value2="A"

'''ASCII 标点符号'''
In [3]: unicode_test('$')
value="$", name="DOLLAR SIGN", value2="$"

'''Unicode 货币字符：'''
In [4]: unicode_test('\u00a2')
value="¢", name="CENT SIGN", value2="¢"

'''另一个 Unicode 货币字符'''
In [5]: unicode_test('\u20ac')
value="€", name="EURO SIGN", value2="€"

'''这些例子唯一可能遇到的问题来源于使用的字体自身的限制。没有任何一种字体涵盖了所
有 Unicode 字符，当缺失对应字符的图片时，会以占位符的形式显示。例如下面是尝试打
印 SNOWMAN 字符得到的结果，这里使用的是 dingbat 字体：'''
In [6]: unicode_test('\u2603')
value="☃", name="SNOWMAN", value2="☃"

'''假设想在 Python 字符串中存储 café 这个词。一种方式是从其他文件或者网站中复制粘贴出来，但这并不一定成功，只能祈祷一切正常：'''
In [7]: place = 'café'

In [8]: place
Out[8]: 'café'

'''示例中之所以成功是因为我是从以 UTF-8 编码（马上你就会了解）的文本源复制粘贴过
来的。
有没有什么办法能够直接指定末尾的 é 字符呢？如果你查看了 E 索引（http://www.unicode.
org/charts/charindex.html#E）下的字符会发现，我们所需字符 E WITH ACUTE, LATIN SMALL
LETTER 对应的 Unicode 值为 00E9 。我们用刚刚的 name() 函数和 lookup() 函数来检测一下，
首先用编码值查询字符名称：'''

In [9]: import unicodedata

In [10]: unicodedata.name('\u00e9')
Out[10]: 'LATIN SMALL LETTER E WITH ACUTE'

'''接着，通过名称查询对应的编码值：'''
In [11]: unicodedata.lookup('E WITH ACUTE, LATIN SMALL LETTER')
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-11-9702931d144a> in <module>
----> 1 unicodedata.lookup('E WITH ACUTE, LATIN SMALL LETTER')

KeyError: "undefined character name 'E WITH ACUTE, LATIN SMALL LETTER'"

'''为了方便查阅，Unicode 字符名称索引页列出的字符名称是经过修改的，因
此与由 name() 函数得到的名称有所不同。如果需要将它们转化为真实的
Unicode 名称（Python 使用的），只需将逗号舍去，并将逗号后面的内容移到
最前面即可。据此，我们应将 E WITH ACUTE, LATIN SMALL LETTER 改为 LATIN
SMALL LETTER E WITH ACUTE ：'''
In [12]: unicodedata.lookup('LATIN SMALL LETTER E WITH ACUTE')
Out[12]: 'é'

'''现在，可以通过字符名称或者编码值来指定 café 这个词了：'''
In [13]: place = 'caf\u00e9'

In [14]: place
Out[14]: 'café'

In [17]: place = 'caf\N{LATIN SMALL LETTER E WITH ACUTE}'

In [18]: place
Out[18]: 'café'

'''上面的代码中，我们将 é 直接插入了字符串中。也可以使用拼接来构造字符串：'''
In [19]: u_umlaut = '\N{LATIN SMALL LETTER U WITH DIAERESIS}'

In [20]: u_umlaut
Out[20]: 'ü'

In [21]: drink = 'Gew' + u_umlaut + 'rztraminer'

In [22]: print('Now I can finally have my', drink, 'in a', place)
Now I can finally have my Gewürztraminer in a café

字符串函数 len 可以计算字符串中 Unicode 字符的个数，而不是字节数：

In [23]: len('$')
Out[23]: 1

In [24]: len('\U0001f47b')
Out[24]: 1

 

2. 使用UTF-8编码和解码
对字符串进行处理时，并不需要在意 Python 中 Unicode 字符的存储细节。
但当需要与外界进行数据交互时则需要完成两件事情：
• 将字符串编码为字节；
• 将字节解码为字符串。
如果 Unicode 包含的字符种类不超过 64 000 种，我们就可以将字符 ID 统一存储在 2 字节
中。遗憾的是，Unicode 所包含的字符种类远不止于此。诚然，我们可以将字符 ID 统一编
码在 3 或 4 字节中，但这会使空间开销（内存和硬盘）增加 3 到 4 倍。
两位为 Unix 开发者所熟知的大神 Ken Thompson 和 Rob Pike 在新泽西共用晚餐时解决了

这个问题，他们在餐桌垫上设计出了 UTF-8 动态编码方案。这种方案会动态地为每一个
Unicode 字符分配 1 到 4 字节不等：
• 为 ASCII 字符分配 1 字节；
• 为拉丁语系（除西里尔语）的语言分配 2 字节；
• 为其他的位于基本多语言平面的字符分配 3 字节；
• 为剩下的字符集分配 4 字节，这包括一些亚洲语言及符号。
UTF-8 是 Python、Linux 以及 HTML 的标准文本编码格式。这种编码方式简单快速、字符
覆盖面广、出错率低。在代码中全都使用 UTF-8 编码会是一种非常棒的体验，你再也不需
要不停地转化各种编码格式。

如果你创建 Python 字符串时使用了从别的文本源（例如网页）复制粘贴
过来的字符串，一定要确保文本源使用的是 UTF-8 编码。将 Latin-1 或者
Windows 1252 复制粘贴为 Python 字符串的错误极其常见，这样得到的字节
序列是无效的，会产生许多后续隐患。

3. 编码
编码是将字符串转化为一系列字节的过程。字符串的 encode() 函数所接收的第一个参数是
编码方式名。可选的编码方式列在了表 7-1 中。

 

 

'''你可以将任何 Unicode 数据以 UTF-8 的方式进行编码。我们试着将 Unicode 字符串 '\u2603'赋值给 snowman ：'''
In [25]: snowman = '\u2603'

'''snowman 是一个仅包含一个字符的 Unicode 字符串，这与它存储所需的字节数没有任何关系：'''
In [26]: len(snowman)
Out[26]: 1

'''下一步将这个 Unicode 字符编码为字节序列：'''
In [27]: ds = snowman.encode('utf-8')

'''就像我之前提到的，UTF-8 是一种变长编码方式。在这个例子中，单个 Unicode 字符
snowman 占用了 3 字节的空间：'''
In [28]: len(ds)
Out[28]: 3

In [29]: ds
Out[29]: b'\xe2\x98\x83'
'''现在， len() 返回了字节数（3），因为 ds 是一个 bytes 类型的变量。'''

当然，你也可以使用 UTF-8 以外的编码方式，但该 Unicode 字符串有可能无法被指定的编
码方式处理，此时 Python 会抛出异常。例如，如果你想要使用 ascii 方式进行编码，必须
保证待编码的字符串仅包含 ASCII 字符集里的字符，不含有任何其他的 Unicode 字符，否
则会出现错误：

In [30]: ds = snowman.encode('ascii')
---------------------------------------------------------------------------
UnicodeEncodeError                        Traceback (most recent call last)
<ipython-input-30-5f5dc414d940> in <module>
----> 1 ds = snowman.encode('ascii')

UnicodeEncodeError: 'ascii' codec can't encode character '\u2603' in position 0: ordinal not in range(128)

encode() 函数可以接受额外的第二个参数来帮助你避免编码异常。它的默认值是
'strict' ，如上例所示，当函数检测到需要处理的字符串包含非 ASCII 字符时，会抛出
UnicodeEncodeError 异常。当然，该参数还有别的可选值，例如 'ignore' 会抛弃任何无法
进行编码的字符：

In [31]:  snowman.encode('ascii', 'ignore')
Out[31]: b''

'''' replace ' 会将所有无法进行编码的字符替换为 ? ：'''
In [32]: snowman.encode('ascii', 'replace')
Out[32]: b'?'

'''' backslashreplace ' 则会创建一个和 unicode-escape 类似的 Unicode 字符串：'''
In [33]: snowman.encode('ascii', 'backslashreplace')
Out[33]: b'\\u2603'
'''如果你需要一份 Unicode 转义符序列的可打印版本，可以考虑使用上面这种方式。'''

下面的代码可以用于创建网页中使用的字符实体串：
In [34]: snowman.encode('ascii', 'xmlcharrefreplace')
Out[34]: b'☃'

 

4. 解码
解码是将字节序列转化为 Unicode 字符串的过程。我们从外界文本源（文件、数据库、网
站、网络 API 等）获得的所有文本都是经过编码的字节串。重要的是需要知道它是以何种
方式编码的，这样才能逆转编码过程以获得 Unicode 字符串。
问题是字节串本身不带有任何指明编码方式的信息。之前我也提到过从网站随意复制粘贴
文本的风险，你也可能遇到过网页乱码的情况，本应是 ASCII 字符的位置却被奇怪的字符
占据了，这些都是编码和解码的方式不一致导致的。

'''创建一个 place 字符串，赋值为 'café' ：'''
In [35]: place = 'caf\u00e9'

In [36]: place
Out[36]: 'café'

In [37]: type(place)
Out[37]: str


'''将它以 UTF-8 格式编码为 bytes 型变量，命名为 place_bytes ：'''
In [38]: place_byte = place.encode('utf-8')

In [39]: place_byte
Out[39]: b'caf\xc3\xa9'

In [40]: type(place_byte)
Out[40]: bytes
'''注意， place_bytes 包含 5 个字节。前 3 个字节的内容与 ASCII 一样（UTF-8 的强大之
处），最后两个字节用于编码 'é' 。'''

'''现在，将字节串转换回 Unicode 字符串：'''
In [41]: place2 = place_byte.decode('utf-8')

In [42]: place2
Out[42]: 'café

一切正常，这是因为编码和解码使用的都是 UTF-8 格式。如果使用其他格式进行解码会发生什么？

In [43]: place3 = place_byte.decode('ascii')
---------------------------------------------------------------------------
UnicodeDecodeError                        Traceback (most recent call last)
<ipython-input-43-3d875afbdba7> in <module>
----> 1 place3 = place_byte.decode('ascii')

UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 3: ordinal not in range(128)

'''ASCII 解码器会抛出异常，因为字节值 0xc3 在 ASCII 编码中是非法值。对于另一些使用 8
比特编码的方式而言，位于 128（十六进制 80 ）到 255（十六进制 FF ）之间的 8 比特的字
符集可能是合法的，但解码得到的结果显然与 UTF-8 不同：'''

In [44]: place4 = place_byte.decode('latin-1')

In [45]: place4
Out[45]: 'café'

In [46]: place5 = place_byte.decode('windows-1252')

In [47]: place5
Out[47]: 'café'

'''这个故事告诉我们：尽可能统一使用 UTF-8 编码。况且它出错率低，兼容性好，可以表达
所有的 Unicode 字符，编码和解码的速度又快，这么多优点，何乐而不为？'''

 7.1.2　格式化
之前几乎都没有提到过文本格式化的问题，现在有必要关注一下这方面的内容了。第 2 章
曾经用过一些字符串排版函数，那些示例代码要么简单地使用 print() 语句，要么直接在
交互式解释器显示。现在是时候看看如何使用不同的格式化方法将变量插值（interpolate）
到字符串中了，即将变量的值嵌入字符串中。你可以用这种方法来生成那些格式框架看起
来一样的报告或者其他固定格式的输出。
Python 有两种格式化字符串的方式，我们习惯简单地称之为旧式（old style）和新式（new
style）。这两种方式在 Python 2 和 Python 3 中都适用（新式格式化方法适用于 Python 2.6 及
以上）。旧式格式化相对简单些，因此我们从它开始。

1. 使用 % 的旧式格式化
旧式格式化的形式为 string % data 。其中 string 包含的是待插值的序列。表 7-2 展示了
最简单的插值序列，它仅由 % 以及一个用于指定数据类型的字母组成。

'''下面是一些简单的例子。首先格式化一个整数：'''
In [48]: '%s' % 42
Out[48]: '42'

In [49]: '%d' % 42
Out[49]: '42'

In [51]: '%x' % 42
Out[51]: '2a'

In [52]: '%o' % 42
Out[52]: '52'

'''接着是浮点数：'''
In [53]: '%s' % 7.03
Out[53]: '7.03'

In [54]: '%f' % 7.03
Out[54]: '7.030000'

In [55]: '%e' % 7.03
Out[55]: '7.030000e+00'

In [56]: '%g' % 7.03
Out[56]: '7.03'

'''整数和字面值 % ：'''
In [57]: '%d%%' % 100
Out[57]: '100%'

'''下面是一些关于字符串和整数的插值操作：'''
In [58]: actor = 'Richard Gere'

In [59]: cat = 'Chester'

In [60]: weight = 28

In [61]: "My wife's favorite actor is %s" % actor
Out[61]: "My wife's favorite actor is Richard Gere"

In [62]: "Our cat %s weighs %s pounds" % (cat, weight)
Out[62]: 'Our cat Chester weighs 28 pounds'

字符串内的 %s 意味着需要插入一个字符串。字符串中出现 % 的次数需要与 % 之后所提供的
数据项个数相同。如果只需插入一个数据，例如前面的 actor ， 直接将需要插入的数据置于
% 后即可。如果需要插入多个数据，则需要将它们封装进一个元组（以圆括号为界，逗号
分开），例如上例中的 (cat, weight) 。
尽管 weight 是一个整数，格式化串中的 %s 也会将它转化为字符串型。

你可以在 % 和指定类型的字母之间设定最大和最小宽度、排版以及填充字符，等等。
我们来定义一个整数 n 、一个浮点数 f 以及一个字符串 s ：

'''我们来定义一个整数 n 、一个浮点数 f 以及一个字符串 s ：'''
In [63]: n = 42

In [64]: f = 7.03

In [65]: s = 'string cheese'

'''使用默认宽度格式化它们：'''
In [66]: '%d %f %s' % (n, f, s)
Out[66]: '42 7.030000 string cheese'

'''为每个变量设定最小域宽为 10 个字符，右对齐，左侧不够用空格填充：'''
In [67]: '%10d %10f %10s' % (n, f, s)
Out[67]: '        42   7.030000 string cheese'

'''和上面的例子使用同样的域宽，但改成左对齐：'''
In [68]: '%-10d %-10f %-10s' % (n, f, s)
Out[68]: '42         7.030000   string cheese'

'''这次仍然使用之前的域宽，但是设定最大字符宽度为 4，右对齐。这样的设置会截断超过
长度限制的字符串，并且将浮点数的精度限制在小数点后 4 位：'''
In [69]: '%10.4d %10.4f %10.4s' % (n, f, s)
Out[69]: '      0042     7.0300       stri'

'''去掉最小域宽为 10 的限制：'''
In [70]: '%.4d %.4f %.4s' % (n, f, s)
Out[70]: '0042 7.0300 stri'

'''最后，改变一下上面例子的硬编码方式，将域宽、字符宽度等设定作为参数：'''
In [71]: '%*.*d %*.*f %*.*s' % (10, 4, n, 10, 4, f, 10, 4, s)
Out[71]: '      0042     7.0300       stri'

2. 使用 {} 和format的新式格式化
旧式格式化方式现在仍然兼容。Python 2（将永远停止在 2.7 版本）会永远提供对旧式格式
化的支持。然而，如果你在使用 Python 3，新式格式化更值得推荐。

'''新式格式化最简单的用法如下所示'''
In [72]: '{} {} {}'.format(n, f, s)
Out[72]: '42 7.03 string cheese'

'''旧式格式化中传入参数的顺序需要与 % 占位符出现的顺序完全一致，但在新式格式化里，
可以自己指定插入的顺序：'''
In [73]: '{2}, {0}, {1}'.format(f, s, n)
Out[73]: '42, 7.03, string cheese'

'''0 代表第一个参数 f ； 1 代表字符串 s ； 2 代表最后一个参数，整数 n 。
参数可以是字典或者命名变量，格式串中的标识符可以引用这些名称'''

In [74]: '{n}, {f}, {s}'.format(n=42, f=7.03, s='string cheese')
Out[74]: '42, 7.03, string cheese'

'''下面的例子中，我们试着将之前作为参数的 3 个值存到一个字典中，如下所示：'''
In [75]: d = {'n': 42, 'f': 7.03, 's': 'string cheese'}

In [76]: '{0[n]} {0[f]} {0[s]} {1}'.format(d, 'other')
Out[76]: '42 7.03 string cheese other'

上面这些例子都是以默认格式打印结果的。旧式格式化允许在 % 后指定参数格式，但在新
式格式化里，将这些格式标识符放在 : 后。首先使用位置参数的例子：

'''首先使用位置参数的例子：'''
In [77]: '{0:d} {1:f} {2:s}'.format(n, f, s)
Out[77]: '42 7.030000 string cheese'

'''接着使用相同的值，但这次它们作为命名参数：'''
In [78]: '{n:d} {f:f} {s:s}'.format(n=42, f=7.03, s='string cheese')
Out[78]: '42 7.030000 string cheese'


'''新式格式化也支持其他各类设置（最小域宽、最大字符宽、排版，等等）。
下面是一个最小域宽设为 10、右对齐（默认）的例子：'''
In [79]: '{0:10d} {1:10f} {2:10s}'.format(n, f, s)
Out[79]: '        42   7.030000 string cheese'

'''与上面例子一样，但使用 > 字符设定右对齐显然要更为直观：'''
In [80]: '{0:>10d} {1:>10f} {2:>10s}'.format(n, f, s)
Out[80]: '        42   7.030000 string cheese'

'''最小域宽为 10，左对齐：'''
In [81]: '{0:<10d} {1:<10f} {2:<10s}'.format(n, f, s)
Out[81]: '42         7.030000   string cheese'

'''最小域宽为 10，居中：'''
In [82]: '{0:^10d} {1:^10f} {2:^10s}'.format(n, f, s)
Out[82]: '    42      7.030000  string cheese'

'''新式格式化与旧式格式化相比有一处明显的不同：精度（precision，小数点后面的数字）
对于浮点数而言仍然代表着小数点后的数字个数，对于字符串而言则代表着最大字符个
数，但在新式格式化中你无法对整数设定精度：'''
In [83]: '{0:>10.4d} {1:>10.4f} {2:10.4s}'.format(n, f, s)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-83-f52a97892439> in <module>
----> 1 '{0:>10.4d} {1:>10.4f} {2:10.4s}'.format(n, f, s)

ValueError: Precision not allowed in integer format specifier


'''最后一个可设定的值是填充字符。如果想要使用空格以外的字符进行填充，只需把它放
在 : 之后，其余任何排版符（ < 、 > 、 ^ ）和宽度标识符之前即可：'''
In [84]: '{0:!^20s}'.format('BIG SALE')
Out[84]: '!!!!!!BIG SALE!!!!!!'

 

7.1.3　使用正则表达式匹配
第 2 章接触到一些简单的字符串操作。有了这些知识，你可能已经会在命令行里使用一些
简单的“通配符”模式了，例如 ls*.py，这条命令的意思是“列出当前目录下所有以 .py
结尾的文件名”。
是时候使用正则表达式（regular expression）探索一些复杂模式匹配的方法了。与之相关
的功能都位于标准库模块 re 中，因此首先需要引用它。你需要定义一个用于匹配的模式
（pattern）字符串以及一个匹配的对象：源（source）字符串。简单的匹配，如下所示：

In [85]: import re

In [86]: result = re.match('You', 'Young Frankenstein')

In [91]: result
Out[91]: <re.Match object; span=(0, 3), match='You'>

这里， 'You' 是模式， 'Young Frankenstein' 是源——你想要检查的字符串。 match() 函数
用于查看源是否以模式开头。

 对于更加复杂的匹配，可以先对模式进行编译以加快匹配速度：

In [89]: youpattern = re.compile('You')

In [90]: result = youpattern.match('Young Frankenstein')

In [91]: result
Out[91]: <re.Match object; span=(0, 3), match='You'>

match() 并不是比较 source 和 pattern 的唯一方法。下面列出了另外一些可用的方法：

•  search() 会返回第一次成功匹配，如果存在的话；
•  findall() 会返回所有不重叠的匹配，如果存在的话；
•  split() 会根据 pattern 将 source 切分成若干段，返回由这些片段组成的列表；
•  sub() 还需一个额外的参数 replacement，它会把 source 中所有匹配的 pattern 改成
replacement。

1. 使用match()进行准确匹配
字符串 'Young Frankenstein' 是以单词 'You' 开头的吗？以下是一些带注释的代码：

In [92]: import re

In [93]: source = 'Young Frankenstein'

In [94]: m = re.match('You', source)  # 从源字符串的开头开始匹配

In [95]: if m:
    ...:     print(m.group())
    ...:
You

In [96]: m = re.match('^You', source)  # 起始锚点也能起到同样作用

In [97]: if m:
    ...:     print(m.group())
    ...:
You

'''尝试匹配 'Frank' 又会如何？'''
In [98]: m = re.match('Frank', source)

In [99]: if m:
    ...:     print(m.group())
    ...:

'''这一次， match() 什么也没有返回， if 也没有执行内部的 print 语句。如前所述， match()
只能检测以模式串作为开头的源字符串。但是 search() 可以检测任何位置的匹配：'''
In [100]: m = re.search('Frank', source)

In [101]: if m:
     ...:     print(m.group())
     ...:
Frank

'''改变一下匹配的模式：'''
In [102]: m = re.match('.*Frank', source)

In [103]: if m:
     ...:     print(m.group())
     ...:
Young Frank

'''以下是对新模式能够匹配成功的简单解释：
•  . 代表任何单一字符；
•  * 代表任意一个它之前的字符， .* 代表任意多个字符（包括 0 个）；
•  Frank 是我们想要在源字符串中某处进行匹配的短语。'''

2. 使用search()寻找首次匹配
你可以使用 search() 在源字符串 'Young Frankenstein' 的任意位置寻找模式 'Frank' ，无
需通配符 .* ：

In [104]: m = re.search('Frank', source)

In [105]: if m: # search返回对象
     ...:     print(m.group())
     ...:
Frank

3. 使用findall()寻找所有匹配
之前的例子都是查找到一个匹配即停止。但如果想要知道一个字符串中出现了多少次字母
'n' 应该怎么办？

'''之前的例子都是查找到一个匹配即停止。但如果想要知道一个字符串中出现了多少次字母
'n' 应该怎么办？'''
In [106]: m = re.findall('n', source)

In [107]: m # findall返回了一个列表
Out[107]: ['n', 'n', 'n', 'n']

In [108]: print('Found', len(m), 'matches')
Found 4 matches

'''将模式改成 'n' ，紧跟着任意一个字符，结果又如何？'''
In [109]: m = re.findall('n.', source)

In [110]: m
Out[110]: ['ng', 'nk', 'ns']

'''注意，上面例子中最后一个 'n' 并没有匹配成功，需要通过 ? 说明 'n' 后面的字符是可
选的：'''
In [111]: m = re.findall('n.?', source)

In [112]: m
Out[112]: ['ng', 'nk', 'ns', 'n']

4. 使用split()按匹配切分
下面的示例展示了如何依据模式而不是简单的字符串（就像普通的 split() 方法做的）将
一个字符串切分成由一系列子串组成的列表：

In [113]: m = re.split('n', source)

In [114]: m
Out[114]: ['You', 'g Fra', 'ke', 'stei', '']

5. 使用sub()替换匹配
这和字符串 replace() 方法有些类似，只不过使用的是模式而不是文本串：

In [115]: m = re.sub('n', '?', source)

In [116]: m
Out[116]: 'You?g Fra?ke?stei?'

6. 模式：特殊的字符
许多书中关于正则表达式的描述都是从如何定义它开始的，我觉得这不太符合学习的逻
辑。正则表达式不是一两句就能说清楚的小语言，它拥有大量的语言细节，会完全占据你
的大脑让你无所适从。它使用的符号实在是太多了，看起来简直就像是幽灵画符一样！

有了上面介绍的方法（ match() 、 search() 、 findall() 和 sub() ）做铺垫，现在可以从应用
讲起并研究如何构造正则表达式了，即上述方法中的模式。
已经见过的一些基本模式：
• 普通的文本值代表自身，用于匹配非特殊字符；
• 使用 . 代表任意除 \n 外的字符；
• 使用 * 表示任意多个字符（包括 0 个）；
• 使用 ? 表示可选字符（0 个或 1 个）。
接下来要介绍一些特殊字符，参见表 7-3。

 

 Python 的 string 模块中预先定义了一些可供我们测试用的字符串常量。我们将使用其中
的 printable 字符串，它包含 100 个可打印的 ASCII 字符，包括大小写字母、数字、空格
符以及标点符号：

In [117]: import string

In [118]: string.printable
Out[118]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

In [119]: printable = string.printable

In [120]: len(printable)
Out[120]: 100

In [121]: printable([0: 50])
  File "<ipython-input-121-7c89959233c0>", line 1
    printable([0: 50])
                ^
SyntaxError: invalid syntax


In [122]: printable[0: 50]
Out[122]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN'

In [123]: printable[50:]
Out[123]: 'OPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

In [124]: re.findall('/d', printable)
Out[124]: []

In [125]: re.findall('\d', printable)
Out[125]: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

In [126]: re.findall('\w', printable)
Out[126]:
['0',
 '1',
 '2',
 '3',
 '4',
 '5',
 '6',
 '7',
 '8',
 '9',
 'a',
 'b',
 'c',
 'd',
 'e',
 'f',
 'g',
 'h',
 'i',
 'j',
 'k',
 'l',
 'm',
 'n',
 'o',
 'p',
 'q',
 'r',
 's',
 't',
 'u',
 'v',
 'w',
 'x',
 'y',
 'z',
 'A',
 'B',
 'C',
 'D',
 'E',
 'F',
 'G',
 'H',
 'I',
 'J',
 'K',
 'L',
 'M',
 'N',
 'O',
 'P',
 'Q',
 'R',
 'S',
 'T',
 'U',
 'V',
 'W',
 'X',
 'Y',
 'Z',
 '_']

In [127]: re.findall('\s', printable)
Out[127]: [' ', '\t', '\n', '\r', '\

In [117]: import string

In [118]: string.printable
Out[118]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

In [119]: printable = string.printable

In [120]: len(printable)
Out[120]: 100

In [121]: printable([0: 50])
  File "<ipython-input-121-7c89959233c0>", line 1
    printable([0: 50])
                ^
SyntaxError: invalid syntax


In [122]: printable[0: 50]
Out[122]: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN'

In [123]: printable[50:]
Out[123]: 'OPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

In [124]: re.findall('/d', printable)
Out[124]: []

In [125]: re.findall('\d', printable)
Out[125]: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

In [126]: re.findall('\w', printable)
Out[126]:
['0',
 '1',
 '2',
 '3',
 '4',
 '5',
 '6',
 '7',
 '8',
 '9',
 'a',
 'b',
 'c',
 'd',
 'e',
 'f',
 'g',
 'h',
 'i',
 'j',
 'k',
 'l',
 'm',
 'n',
 'o',
 'p',
 'q',
 'r',
 's',
 't',
 'u',
 'v',
 'w',
 'x',
 'y',
 'z',
 'A',
 'B',
 'C',
 'D',
 'E',
 'F',
 'G',
 'H',
 'I',
 'J',
 'K',
 'L',
 'M',
 'N',
 'O',
 'P',
 'Q',
 'R',
 'S',
 'T',
 'U',
 'V',
 'W',
 'X',
 'Y',
 'Z',
 '_']

In [127]: re.findall('\s', printable)
Out[127]: [' ', '\t', '\n', '\r', '\x0b', '\x0c']

正则表达式不仅仅适用于 ASCII 字符，例如 \d 还可以匹配 Unicode 的数字字符，并不
局 限 于 ASCII 中 的 '0' 到 '9' 。 我 们 从 FileFormat.info（http://www.fileformat.info/info/
unicode/category/Ll/list.htm）中引入两个新的非 ASCII 编码的小写字母。
这个测试例子中，在模式中添加以下内容：
• 三个 ASCII 字母
• 三个不会被 \w 所匹配的标点符号
• Unicode 中的 LATIN SMALL LETTER E WITH CIRCUMFLEX（ \u00ea ）
• Unicode 中的 LATIN SMALL LETTER E WITH BREVE（ \u0115 ）

In [128]: x = 'abc' + '-/*' + '\u00ea' + '\u0115'

In [129]: re.findall('\w', x)
Out[129]: ['a', 'b', 'c', 'ê', 'ĕ']

7. 模式：使用标识符
现在试着用表 7-4 中所包含的一些常用的模式标识符来烹饪一道“符号比萨”大餐。
表中，expr 和其他斜体的单词表示合法的正则表达式。

 

 

 

In [130]: source = '''I wish I may, I wish I might Have a dish of fish tonight.'''

'''首先，在源字符串中检索 wish ：'''
In [131]: re.findall('wish', source)
Out[131]: ['wish', 'wish']

'''接着，对源字符串任意位置查询 wish 或者 fish ：'''
In [132]: re.findall('wish|fish', source)
Out[132]: ['wish', 'wish', 'fish']

'''从字符串开头开始匹配 wish ：'''
In [133]: re.findall('^wish', source)
Out[133]: []

'''从字符串开头开始匹配 I wish ：'''
In [134]: re.findall('^I wish', source)
Out[134]: ['I wish']

'''从字符串结尾开始匹配 fish ：'''
In [135]: re.findall('fish$', source)
Out[135]: []

'''最后，从字符串结尾开始匹配 fish tonight. ：'''
In [136]: re.findall('fish tonight.$', source)
Out[136]: ['fish tonight.']


'''^ 和 $ 叫作锚点（anchor）： ^ 将搜索域定位到源字符串的开头， $ 则定位到末尾。上面例
子中的 .$ 可以匹配末尾的任意字符，包括句号，因此能成功匹配。但更准确地说，上面
的例子应该使用转义符将 . 转义为句号，这才是我们真正想示意的纯文本值匹配：'''
In [137]: re.findall('fish tonight\.$', source)
Out[137]: ['fish tonight.']

'''接下来查询以 w 或 f 开头，后面紧接着 ish 的匹配：'''
In [138]: re.findall('[wf]ish', source)
Out[138]: ['wish', 'wish', 'fish']

'''查询以若干个 w 、 s 或 h 组合的匹配：'''
In [139]: re.findall('[wsh]+', source)
Out[139]: ['w', 'sh', 'w', 'sh', 'h', 'sh', 'sh', 'h']

'''查询以 ght 开头，后面紧跟一个非数字非字母字符的匹配：'''
In [140]: re.findall('ght\W', source)
Out[140]: ['ght ', 'ght.']

'''查询以 I 开头，后面跟着 wish 的匹配（ wish 出现次数尽量少）：'''
In [141]: re.findall('I (?=wish)', source)
Out[141]: ['I ', 'I ']

'''最后查询以 wish 结尾，前面为 I 的匹配（ I 出现的次数尽量少）：'''
In [142]: re.findall('(?<=I) wish', source)
Out[142]: [' wish', ' wish']

'''有时，正则表达式的语法可能会与 Python 本身的语法冲突。例如，我们期望下面例子中的
模式能匹配任何以 fish 开头的词：'''
In [143]: re.findall('\bfish', source)
Out[143]: []

'''为什么没有匹配成功？第 2 章曾提到，Python 字符串会使用一些特殊的转义符。例如上面
的 \b ，它在字符串中代表退格，但在正则表达式中，它代表一个单词的开头位置。因此，
把 Python 的普通字符串用作正则表达式的模式串时需要特别注意，不要像上面一样与转义
符产生冲突。或者在任何使用正则表达式的地方都记着在模式串的前面添加字符 r ，这样
可以告诉 Python 这是一个正则表达式，从而禁用字符串转义符，如下所示：'''
In [144]: re.findall(r'\bfish', source)
Out[144]: ['fish']

8. 模式：定义匹配的输出
当使用 match() 或 search() 时，所有的匹配会以 m.group() 的形式返回到对象 m 中。如果
你用括号将某一模式包裹起来，括号中模式匹配得到的结果归入自己的 group （无名称）
中，而调用 m.groups() 可以得到包含这些匹配的元组，如下所示：

In [145]: m = re.search(r'(. dish\b).*(\bfish)', source)

In [146]: m.group()
Out[146]: 'a dish of fish'

In [147]: m.groups()
Out[147]: ('a dish', 'fish')


'''(?P< name >expr) 这样的模式会匹配 expr ，并将匹配结果存储到名为 name 的组中：'''
In [148]: m = re.search(r'(?P<DISH>. dish\b).*(?P<FISH>\bfish)', source)

In [149]: m.group()
Out[149]: 'a dish of fish'

In [150]: m.groups()
Out[150]: ('a dish', 'fish')

In [151]: m.group('DISH')
Out[151]: 'a dish'

In [152]: m.group('FISH')
Out[152]: 'fish'

7.2　二进制数据
处理文本数据比较晦涩难懂（新旧格式化、正则表达式等），而处理二进制数据就有趣多了。
你需要了解像字节序（endianness，电脑处理器是如何将数据组织存储为字节的）以及整数
的符号位（sign bit）之类的概念。你可能需要研究二进制文件格式、网络包等内容，从而对
其中的数据进行提取甚至修改。本节将了解到 Python 中有关二进制数据的一些基本操作。
7.2.1　字节和字节数组
Python 3 引入了下面两种使用 8 比特序列存储小整数的方式，每 8 比特可以存储从 0~255
的值：
• 字节是不可变的，像字节数据组成的元组；
• 字节数组是可变的，像字节数据组成的列表。
我们的示例从创建列表 blist 开始。接着需使用这个列表创建一个 bytes 类型的变量 the_
bytes 以及一个 bytearray 类型的变量 the_byte_array ：

In [153]: blist = [1, 2, 3, 255]

In [154]: the_bytes = bytes(blist)

In [155]: the_bytes
Out[155]: b'\x01\x02\x03\xff'

In [156]: the_byte_array = bytearray(blist)

In [157]: the_byte_array
Out[157]: bytearray(b'\x01\x02\x03\xff')

bytes 类型值的表示形式比较特殊：以 b 开头，接着是一个单引号，后面跟
着由十六进制数（例如 \x02 ）或 ASCII 码组成的序列，最后以配对的单引号
结束。Python 会将这些十六进制数或者 ASCII 码转换为整数，如果该字节的
值为有效 ASCII 编码则会显示 ASCII 字符。

In [158]: b'\x61'
Out[158]: b'a'

In [159]: b'\x01abc\xff'
Out[159]: b'\x01abc\xff'

下面的例子说明了 bytes 类型的不可变性：

In [160]: the_bytes[1] = 127
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-160-86fbc6adcd1b> in <module>
----> 1 the_bytes[1] = 127

TypeError: 'bytes' object does not support item assignment

但 bytearray 类型的变量是可变的：

In [161]: the_byte_array = bytearray(blist)

In [162]: the_byte_array
Out[162]: bytearray(b'\x01\x02\x03\xff')

In [163]: the_byte_array[1] = 127

In [164]: the_byte_array
Out[164]: bytearray(b'\x01\x7f\x03\xff')

下面两行代码都会创建一个包含 256 个元素的结果，包含 0~255 的所有值：

In [165]: the_bytes = bytes(range(0, 256))

In [166]: the_byte_array = bytearray(range(0, 256))


'''打印 bytes 或 bytearray 数据时，Python 会以 \x xx 的形式表示不可打印的字符，以 ASCII
字符的形式表示可打印的字符（以及一些转义字符，例如 \n 而不是 \x0a ）。下面是 the_
bytes 的打印结果（手动设置为一行显示 16 个字节）：'''
In [167]: the_bytes
Out[167]: b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

In [168]: the_byte_array
Out[168]: bytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff')

看起来可能有些困惑，毕竟上面输出的数据是字节（小整数）而不是字符。

7.2.2　使用 struct 转换二进制数据
如你所见，Python 中有许多文本处理工具（模块、函数等），然而处理二进制数据的工具
则要少得多。标准库里有一个 struct 模块，专门用于处理类似 C 和 C++ 中结构体的数据。
你可以使用 struct 模块的功能将二进制数据转换为 Python 中的数据结构。
以一个 PNG 文件（一种常见的图片格式，其他图片格式还有 GIF、JPEG 等）为例看看
struct 是如何工作的。我们来编写一个小程序，从 PNG 文件中获得图片的宽度和高度信息。
使用 O’Reilly 的经典标志：一只睁大了眼睛的眼镜猴，见图 7-1。

 

 你可以在 Wikipedia（http://upload.wikimedia.org/wikipedia/en/9/95/O’Reilly_logo.png）上获
取这张图片的 PNG 文件。第 8 章之前都不会讨论读取文件的方法，因此这里我仅仅是将
这个文件下载下来，并编写了一个简单的小程序将它的数据以字节形式打印出来，然后将
起始的 30 字节数据存入 Python bytes 型变量 data 中，如下所示。方便起见，你只需复制
这部分数据即可。（PNG 格式规定了图片的宽度和高度信息存储在初始 24 字节中，因此不
需要其他的额外数据。）

In [169]: import struct

In [170]: valid_png_header = b'\x89PNG\r\n\x1a\n'

In [171]: data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR' + \
     ...: b'\x00\x00\x00\x9a\x00\x00\x00\x8d\x08\x02\x00\x00\x00\xc0'

In [172]: if data[:8] == valid_png_header:
     ...:     width, height = struct.unpack('>LL', data[16:24])
     ...:     print('Valid PNG, width', width, 'height', height)
     ...: else:
     ...:     print('Not a valid PNG')
     ...:
Valid PNG, width 154 height 141

以上代码说明：
•  data 包含了 PNG 文件的前 30 字节内容，为了书的排版，我将这 30 字节数据放到了两
行字节串中，并用 + 和续行符（ \ ）将它们连接起来；
•  valid_png_header 包含 8 字节序列，它标志着这是一个有效的 PNG 格式文件；
•  width 值位于第 16~20 字节， height 值则位于第 21~24 字节。
上面代码中的 >LL 是一个格式串，它用于指导 unpack() 正确解读字节序列并将它们组装成
Python 中的数据类型。可以将它分解成下面几个基本格式标志：
•  > 用于指明整数是以大端（big-endian）方案存储的；
• 每个 L 代表一个 4 字节的无符号长（unsigned long）整数。

你可以直接获取 4 字节数据：

In [173]: data[16:20]
Out[173]: b'\x00\x00\x00\x9a'

In [175]: data[20:24]
Out[175]: b'\x00\x00\x00\x8d'


'''大端方案将高字节放在左侧。由于宽度和高度都小于 255，因此它们存储在每一个 4 字节
序列的最后一字节中。不难验证，上面的十六进制数转换为十进制后与我们预期的数值
（图片的宽和高）一致：'''
In [176]: 0x9a
Out[176]: 154

In [177]: 0x8d
Out[177]: 141

表 7-5 和表 7-6 列出了 pack() 和 unpack() 使用的一些格式标识符。
首先是字节序标识符。

 

 

 

 类型标识符紧跟在字节序标识符的后面。任何标识符的前面都可以添加数字用于指定需要
匹配的数量，例如 5B 代表 BBBBB 。

可以使用数量前缀改写 >LL ：

In [178]: struct.unpack('>2L', data[16:24])
Out[178]: (154, 141)

'''之前的例子中使用了切片 data[16:24] 直接获取所需的特定字节，也可以使用 x 标识符来
跳过不需要的字节：'''
In [179]: struct.unpack('>16x2L6x', data)
Out[179]: (154, 141)

• 使用大端方案（ > ）
• 跳过 16 个字节（ 16x ）
• 读取 8 字节内容——两个无符号长整数（ 2L ）
• 跳过最后 6 个字节（ 6x ）

7.2.3　其他二进制数据工具
一些第三方开源包提供了下面这些更加直观地定义和提取二进制数据的方法：
• bitstring（https://code.google.com/p/python-bitstring/）
• construct（http://construct.readthedocs.org/en/latest/）
• hachoir（https://bitbucket.org/haypo/hachoir/wiki/Home）
• binio（http://spika.net/py/binio/）
你可以在附录 D 查看下载和安装外部包的详细过程，这里不再赘述。接下来的几个例子需
要提前安装 construct 包，只需执行下面这行代码即可：
$ pip install construct
下面的例子展示了如何使用 construct 从之前的 data 中提取 PNG 图片的尺寸：
>>> from construct import Struct, Magic, UBInt32, Const, String
>>> # 基于https://github.com/construct上的代码修改而来
>>> fmt = Struct('png',
... Magic(b'\x89PNG\r\n\x1a\n'),
... UBInt32('length'),
... Const(String('type', 4), b'IHDR'),
... UBInt32('width'),
... UBInt32('height')
... )
>>> data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR' + \
... b'\x00\x00\x00\x9a\x00\x00\x00\x8d\x08\x02\x00\x00\x00\xc0'
>>> result = fmt.parse(data)
>>> print(result)
Container:
length = 13
type = b'IHDR'
width = 154
height = 141

>>> print(result.width, result.height)
154, 141

7.2.4　使用 binascii() 转换字节/字符串
标准 binascii 模块提供了在二进制数据和多种字符串表示（十六进制、六十四进制、
uuencoded，等等）之间转换的函数。例如，下面的小例子将 8- 字节的 PNG 头打印为十六
进制值的形式，而不是 Python 默认的打印 bytes 型变量的方式：混合使用 ASCII 和转义的
\x xx。
>>> import binascii
>>> valid_png_header = b'\x89PNG\r\n\x1a\n'
>>> print(binascii.hexlify(valid_png_header))
b'89504e470d0a1a0a'
反过来转换也可以：
>>> print(binascii.unhexlify(b'89504e470d0a1a0a'))
b'\x89PNG\r\n\x1a\n'

 

7.2.5　位运算符
Python 提供了和 C 语言中类似的比特级运算符。表 7-7 列出了这些位运算符并附上了整数
a （十进制 5 ，二进制 0b0101 ）和 b （十进制 1 ，二进制 0b0001 ）的运算示例。

 

 这些运算和第 3 章的集合运算有些类似。 & 返回两个运算数中相同的比特。 | 返回两个运
算数中任意一者有效的比特。 ^ 返回仅在一个运算数中有效的比特。 ~ 将所有比特翻转。
现代计算机都使用二进制补码（two’s complement）进行运算，其中整数的最高位定义为
符号位（0 为正，1 为负），因此翻转操作会改变运算数的符号。 << 和 >> 仅仅将比特向左
或向右移动，左位移操作相当于将数字乘以 2，右位移操作相当于将数字除以 2。