python 的几种数据类型

列表 列表是 Python 的主力数据类型。当提到 “ 列表 ” 时，您脑海中可 能会闪现“ 必须进一步声明大小的数组，只能包含同一类对象 “ 等想法。千万别这么想。列表比那要酷得多。 ☞ Python 中的列表类似 Perl 5 中的数组。在 Perl 5 中，存储数组的变量总是以字符 @ 开头；在 Python 中，变量可随意命名，Python 仅在内部对数据类型 进行跟踪。 ☞ Python 中的列表更像 Java 中的数组（尽管可以 把列表当做生命中所需要的一切来使用)。一个更好 的比喻可能是 ArrayList 类，该类可以容纳任何对 象，并可在添加新元素时进行动态拓展。 创建列表 列表创建非常轻松：使用中括号包裹一系列以逗号分割的值即 可。 >>> a_list = ['a', 'b', 'mpilgrim', 'z', 'example'] ① >>> a_list ['a', 'b', 'mpilgrim', 'z', 'example'] >>> a_list[0] ② 'a' >>> a_list[4] ③ 'example' >>> a_list[ ‐1] ④ 'example' >>> a_list[ ‐3] ⑤ 'mpilgrim' 1. 首先，创建一个包含 5 个元素的列表。要注意的是它们保持 了最初的顺序。这并不是偶然的。列表是元素的有序集合。 2. 列表可当做以零为基点的数组使用。非空列表的首个元素始 终是 a_list[0] 。 3. 该 5 元素列表的最后一个元素是 a_list[4] ，因为列表（索 引）总是以零为基点的。 4. 使用负索引值可从列表的尾部向前计数访问元素。任何非空 列表的最后一个元素总是 a_list[ ‐1] 。 5. 如果负数令你混淆，可将其视为如下方式： a_list[ ‐n] == a_list[len(a_list) ‐ n] 。因此在此列表中， a_list[ ‐3] == a_list[5 ‐ 3] == a_list[2] 。 列表切片 a_list[0] 是列表的第一个元素。 定义列表后，可从其中获取任何部分作为新列表。该技术称为 对列表进行 切片 。 >>> a_list ['a', 'b', 'mpilgrim', 'z', 'example'] >>> a_list[1:3] ① ['b', 'mpilgrim'] >>> a_list[1: ‐1] ② ['b', 'mpilgrim', 'z'] >>> a_list[0:3] ③ ['a', 'b', 'mpilgrim'] >>> a_list[:3] ④ ['a', 'b', 'mpilgrim'] >>> a_list[3:] ⑤ ['z', 'example'] >>> a_list[:] ⑥ ['a', 'b', 'mpilgrim', 'z', 'example'] 1. 通过指定两个索引值，可以从列表中获取称作“ 切片” 的某个 部分。返回值是一个新列表，它包含列表(??切片)中所有元素， 按顺序从第一个切片索引开始（本例中为 a_list[1] ），截止但 不包含第二个切片索引（本例中的 a_list[3] ）。 2. 如果切片索引之一或两者均为负数，切片操作仍可进行。如 果有帮助的话，您可以这么思考：自左向右读取列表，第一个 切片索引指明了想要的第一个元素，第二个切片索引指明了第 一个不想要的元素。返回值是两者之间的任何值。 between. 3. 列表是以零为起点的，因此 a_list[0:3] 返回列表的头三个 元素，从 a_list[0] 开始，截止到但不包括 a_list[3] 。 4. 如果左切片索引为零，可以将其留空而将零隐去。因此 a_list[:3] 与 a_list[0:3] 是完全相同的，因为起点 0 被隐去 了。 5. 同样，如果右切片索引为列表的长度，也可以将其留空。因 此 a_list[3:] 与 a_list[3:5] 是完全相同的，因为该列表有五 个元素。此处有个好玩的对称现象。在这个五元素列表中， a_list[:3] 返回头三个元素，而 a_list[3:] 返回最后两个元 素。事实上，无论列表的长度是多少, a_list[:n] 将返回头 n 个 元素，而 a_list[ n:] 返回其余部分。 6. 如果两个切片索引都留空，那么将包括列表所有的元素。但 该返回值与最初的 a_list 变量并不一样。它是一个新列表，只 不过恰好拥有完全相同的元素而已。a_list[:] 是对列表进行复 制的一条捷径。 向列表中新增项 有四种方法可用于向列表中增加元素。 >>> a_list = ['a'] >>> a_list = a_list + [2.0, 3] ① >>> a_list ② ['a', 2.0, 3] >>> a_list.append(True) ③ >>> a_list ['a', 2.0, 3, True] >>> a_list.extend(['four', 'Ω']) ④ >>> a_list ['a', 2.0, 3, True, 'four', 'Ω'] >>> a_list.insert(0, 'Ω') ⑤ >>> a_list ['Ω', 'a', 2.0, 3, True, 'four', 'Ω'] 1. + 运算符连接列表以创建一个新列表。列表可包含任何数量 的元素；没有大小限制（除了可用内存的限制）。然而，如果 内存是个问题，那就必须知道在进行连接操作时，将在内存中 创建第二个列表。在该情况下，新列表将会立即被赋值给已有 变量 a_list 。因此，实际上该行代码包含两个步骤 — 连接然后 赋值 — 当处理大型列表时，该操作可能（暂时）消耗大量内 存。 2. 列表可包含任何数据类型的元素，单个列表中的元素无须全 为同一类型。下面的列表中包含一个字符串、一个浮点数和一 个整数。 3. append() 方法向列表的尾部添加一个新的元素。（现在列表 中有 四种 不同数据类型！） 4. 列表是以类的形式实现的。“ 创建” 列表实际上是将一个类实 例化。因此，列表有多种方法可以操作。extend() 方法只接受 一个列表作为参数，并将该参数的每个元素都添加到原有的列 表中。 5. insert() 方法将单个元素插入到列表中。第一个参数是列表 中将被顶离原位的第一个元素的位置索引。列表中的元素并不 一定要是唯一的；比如说：现有两个各自独立的元素，其值均 为 'Ω':，第一个元素 a_list[0] 以及最后一个元素 a_list[6] 。 ☞a_list.insert(0, value ) 就像是 Perl 中的 unshift() 函数。它将一个元素添加到列表的头 部，所有其它的元素都被顶理原先的位置以腾出空 间。 让我们进一步看看 append() 和 extend() 的区别。 >>> a_list = ['a', 'b', 'c'] >>> a_list.extend(['d', 'e', 'f']) ① >>> a_list ['a', 'b', 'c', 'd', 'e', 'f'] >>> len(a_list) ② 6 >>> a_list[ ‐1] 'f' >>> a_list.append(['g', 'h', 'i']) ③ >>> a_list ['a', 'b', 'c', 'd', 'e', 'f', ['g', 'h', 'i']] >>> len(a_list) ④ 7 >>> a_list[ ‐1] ['g', 'h', 'i'] 1. extend() 方法只接受一个参数，而该参数总是一个列表，并 将列表 a_list 中所有的元素都添加到该列表中。 2. 如果开始有个 3 元素列表，然后将它与另一个 3 元素列表进 行 extend 操作，结果是将获得一个 6 元素列表。 3. 另一方面， append() 方法只接受一个参数，但可以是任何数 据类型。在此，对一个 3 元素列表调用 append() 方法。 4. 如果开始的时候有个 6 元素列表，然后将一个列表 append ［添加］上去，结果就会……得到一个 7 元素列表。为什么是 7 个？因为最后一个元素（刚刚 append［添加］ 的元素） 本身 是个列表 。列表可包含任何类型的数据，包括其它列表。这可 能是你所需要的结果，也许不是。但如果这就是你想要的，那 这就是你所得到的。 在列表中检索值 >>> a_list = ['a', 'b', 'new', 'mpilgrim', 'new'] >>> a_list.count('new') ① 2 >>> 'new' in a_list ② True >>> 'c' in a_list False >>> a_list.index('mpilgrim') ③ 3 >>> a_list.index('new') ④ 2 >>> a_list.index('c') ⑤ Traceback (innermost last): File "<interactive input>", line 1, in ?ValueError: list.index(x): x not in list 1. 如你所期望， count() 方法返回了列表中某个特定值出现的 次数。 2. 如果你想知道的是某个值是否出现在列表中， in 运算符将会 比使用 count() 方法要略快一些。in 运算符总是返回 True 或 False ；它不会告诉你该值出现在什么位置。 3. 如果想知道某个值在列表中的精确位置，可调用 index() 方 法。尽管可以通过第二个参数（以 0 为基点的）索引值来指定 起点，通过第三个参数（以 0 基点的）索引来指定搜索终点， 但缺省情况下它将搜索整个列表， 4. index() 方法将查找某值在列表中的第一次出现。在该情况 下，'new' 在列表中出现了两次，分别为 a_list[2] 和 a_list[4] ，但 index() 方法将只返回第一次出现的位置索引 值。 5. 可能 出乎 您的预期，如果在列表中没有找到该值，index() 方法将会引发一个例外。 等等，什么？是这样的：如果没有在列表中找到该值， index() 方法将会引发一个例外。这是 Python 语言最显著不同之处，其 它多数语言将会返回一些无效的索引值（像是 ‐1）。当然，一 开始这一点看起来比较讨厌，但我想您会逐渐欣赏它。这意味 着您的程序将会在问题的源头处崩溃，而不是之后奇怪地、默 默地崩溃。请记住， ‐1 是合法的列表索引值。如果 index() 方 法返回 ‐1，可能会导致调整过程变得不那么有趣！ 从列表中删除元素 列表永远不会有缝隙。 列表可以自动拓展或者收缩。您已经看到了拓展部分。也有几 种方法可从列表中删除元素。 >>> a_list = ['a', 'b', 'new', 'mpilgrim', 'new'] >>> a_list[1] 'b' >>> del a_list[1] ① >>> a_list ['a', 'new', 'mpilgrim', 'new'] >>> a_list[1] ② 'new' 1. 可使用 del 语句从列表中删除某个特定元素。 2. 删除索引 1 之后再访问索引 1 将 不会 导致错误。被删除元素 之后的所有元素将移动它们的位置以“ 填补” 被删除元素所产生 的“ 缝隙” 。 不知道位置索引？这不成问题，您可以通过值而不是索引删除 元素。 >>> a_list.remove('new') ① >>> a_list ['a', 'mpilgrim', 'new'] >>> a_list.remove('new') ② >>> a_list ['a', 'mpilgrim'] >>> a_list.remove('new') Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: list.remove(x): x not in list 1. 还可以通过 remove() 方法从列表中删除某个元素。remove() 方法接受一个 value 参数，并删除列表中该值的第一次出现。同 样，被删除元素之后的所有元素将会将索引位置下移，以“ 填补 缝隙” 。列表永远不会有“ 缝隙” 。 2. 您可以尽情地调用 remove() 方法，但如果试图删除列表中不 存在的元素，它将引发一个例外。 R EMOVING I TEMS FROM A LIST : BONUS R OUND 另一有趣的列表方法是 pop() 。pop() 方法是从列表删除元素的 另一方法，但有点变化。 >>> a_list = ['a', 'b', 'new', 'mpilgrim'] >>> a_list.pop() ① 'mpilgrim' >>> a_list ['a', 'b', 'new'] >>> a_list.pop(1) ② 'b' >>> a_list ['a', 'new'] >>> a_list.pop() 'new' >>> a_list.pop() 'a' >>> a_list.pop() ③ Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: pop from empty list 1. 如果不带参数调用， pop() 列表方法将删除列表中最后的元 素，并返回所删除的值。 2. 可以从列表中 pop ［弹出］任何元素。只需传给 pop() 方法 一个位置索引值。它将删除该元素，将其后所有元素移位以“ 填 补缝隙”, 然后返回它删除的值。 3. 对空列表调用 pop() 将会引发一个例外。 ☞不带参数调用的 pop() 列表方法就像 Perl 中的 pop() 函数。它从列表中删除最后一个元素并返回 所删除元素的值。Perl 还有另一个函数 shift() ， 可用于删除第一个元素并返回其值；在 Python 中，该函数相当于 a_list.pop(0) 。 布尔上下文环境中的列表 空列表为假；其它所有列表为真。 可以在 if 这样的 布尔类型上下文环境中 使用列表。 >>> def is_it_true(anything): ... if anything: ... print("yes, it's true") ... else: ... print("no, it's false") ... >>> is_it_true([]) ① no, it's false >>> is_it_true(['a']) ② yes, it's true >>> is_it_true([False]) ③ yes, it's true 1. 在布尔类型上下文环境中，空列表为假值。 2. 任何至少包含一个上元素的列表为真值。 3. 任何至少包含一个上元素的列表为真值。元素的值无关紧 要。 ⁂ 元组 元素 是不可变的列表。一旦创建之后，用任何方法都不可以修 改元素。 >>> a_tuple = ("a", "b", "mpilgrim", "z", "example") ① >>> a_tuple ('a', 'b', 'mpilgrim', 'z', 'example') >>> a_tuple[0] ② 'a' >>> a_tuple[‐1] ③ 'example' >>> a_tuple[1:3] ④ ('b', 'mpilgrim') 1. 元组的定义方式和列表相同，除了整个元素的集合都用圆括 号，而不是方括号闭合。 2. 和列表一样，元组的元素都有确定的顺序。元组的索引也是 以零为基点的，和列表一样，因此非空元组的第一个元素总是 a_tuple[0] 。 3. 负的索引从元组的尾部开始计数，这和列表也是一样的。 4. 和列表一样，元组也可以进行切片操作。对列表切片可以得 到新的列表；对元组切片可以得到新的元组。 元组和列表的主要区别是元组不能进行修改。用技术术语来 说，元组是 不可变更 的。从实践的角度来说，没有可用于修改 元组的方法。列表有像 append()、 extend()、 insert()、 remove() 和 pop() 这样的方法。这些方法，元组都没有。可以 对元组进行切片操作（因为该方法创建一个新的元组），可以 检查元组是否包含了特定的值（因为该操作不修改元组），还 可以……就那么多了。 # continued from the previous example >>> a_tuple ('a', 'b', 'mpilgrim', 'z', 'example') >>> a_tuple.append("new") ① Traceback (innermost last): File "<interactive input>", line 1, in ?AttributeError: 'tuple' object has no attribute 'append' >>> a_tuple.remove("z") ② Traceback (innermost last): File "<interactive input>", line 1, in ?AttributeError: 'tuple' object has no attribute 'remove' >>> a_tuple.index("example") ③ 4 >>> "z" in a_tuple ④ True 1. 无法向元组添加元素。元组没有 append() 或 extend() 方 法。 2. 不能从元组中删除元素。元组没有 remove() 或 pop() 方法。 3. 可以 在元组中查找元素，由于该操作不改变元组。 4. 还可以使用 in 运算符检查某元素是否存在于元组中。 那么元组有什么好处呢？ • 元组的速度比列表更快。如果定义了一系列常量值，而所需 做的仅是对它进行遍历，那么请使用元组替代列表。 • 对不需要改变的数据进行“ 写保护” 将使得代码更加安全。使 用元组替代列表就像是有一条隐含的 assert 语句显示该数据是 常量，特别的想法（及特别的功能）必须重写。（？？） • 一些元组可用作字典键（特别是包含字符串、数值和其它元 组这样的不可变数据的元组）。列表永远不能当做字典键使 用，因为列表不是不可变的。 ☞元组可转换成列表，反之亦然。内建 的 tuple() 函数接受一个列表参数，并返回 一个包含同样元素的元组，而 list() 函数 接受一个元组参数并返回一个列表。从效 果上看， tuple() 冻结列表，而 list() 融 化元组。 布尔上下文环境中的元组 可以在 if 这样的 布尔类型上下文环境中 使用元组。 >>> def is_it_true(anything): ... if anything: ... print("yes, it's true") ... else: ... print("no, it's false") ... >>> is_it_true(()) ① no, it's false >>> is_it_true(('a', 'b')) ② yes, it's true >>> is_it_true((False,)) ③ yes, it's true >>> type((False)) ④ <class 'bool'> >>> type((False,)) <class 'tuple'> 1. 在布尔类型上下文环境中，空元组为假值。 2. 任何至少包含一个上元素的元组为真值。 3. 任何至少包含一个上元素的元组为真值。元素的值无关紧 要。不过此处的逗号起什么作用呢？ 4. 为创建单元素元组，需要在值之后加上一个逗号。没有逗 号，Python 会假定这只是一对额外的圆括号，虽然没有害处， 但并不创建元组。 同时赋多个值 以下是一种很酷的编程捷径：在 Python 中，可使用元组来一次 赋多值。 >>> v = ('a', 2, True) >>> (x, y, z) = v ① >>> x 'a' >>> y 2 >>> z True 1. v 是一个三元素的元组，而 (x, y, z) 是包含三个变量的元 组。将其中一个赋值给另一个将会把 v 中的每个值按顺序赋值 给每一个变量。 该特性有多种用途。假设需要将某个名称指定某个特定范围的 值。可以使用内建的 range() 函数进行多变量赋值以快速地进 行连续变量赋值。 >>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7) ① >>> MONDAY ② 0 >>> TUESDAY 1 >>> SUNDAY 6 1. 内建的 range() 函数构造了一个整数序列。（从技术上来 说， range() 函数返回的既不是列表也不是元组，而是一个 迭 代器，但稍后您将学到它们的区别。） MONDAY、 TUESDAY 、 WEDNESDAY 、 THURSDAY、 FRIDAY、 SATURDAY 和 SUNDAY 是您所定 义的变量。（本例来自于 calendar 模块，该短小而有趣的模块 打印日历，有点像 UNIX 程序 cal 。该 calendar 模块为星期数 定义了整数常量。 2. 现在，每个变量都有其值了： MONDAY 为 0 ， TUESDAY 为 1， 如此类推。 还可以使用多变量赋值创建返回多值的函数，只需返回一个包 含所有值的元组。调用者可将返回值视为一个简单的元组，或 将其赋值给不同的变量。许多标准 Python 类库这么干，包括在 下一章将学到的 os 模块。 ⁂ 集合 集合set 是装有独特值的无序“ 袋子” 。一个简单的集合可以包含 任何数据类型的值。如果有两个集合，则可以执行像联合、交 集以及集合求差等标准集合运算。 创建集合 重中之重。创建集合非常简单。 >>> a_set = {1} ① >>> a_set {1} >>> type(a_set) ② <class 'set'> >>> a_set = {1, 2} ③ >>> a_set {1, 2} 1. 要创建只包含一个值的集合，仅需将该值放置于花括号之 间。（{}）。 2. 实际上，集合以 类 的形式实现，但目前还无须考虑这一点。 3. 要创建多值集合，请将值用逗号分开，并用花括号将所有值 包裹起来。 还可以 列表 为基础创建集合。 >>> a_list = ['a', 'b', 'mpilgrim', True, False, 42] >>> a_set = set(a_list) ① >>> a_set ② {'a', False, 'b', True, 'mpilgrim', 42} >>> a_list ③ ['a', 'b', 'mpilgrim', True, False, 42] 1. 要从列表创建集合，可使用 set() 函数。（懂得如何实现集 合的学究可能指出这实际上并不是调用某个函数，而是对某个 类进行实例化。我保证在本书稍后的地方将会学到其中的区 别。目前而言，仅需知道 set() 行为与函数类似，以及它返回 一个集合。） 2. 正如我之前提到的，简单的集合可以包括任何数据类型的 值。而且，如我之前所提到的，集合是 无序的。该集合并不记 得用于创建它的列表中元素的最初顺序。如果向集合中添加元 素，它也不会记得添加的顺序。 3. 初始的列表并不会发生变化。 还没有任何值？没有问题。可以创建一个空的集合。 >>> a_set = set() ① >>> a_set ② set() >>> type(a_set) ③ <class 'set'> >>> len(a_set) ④ 0 >>> not_sure = {} ⑤ >>> type(not_sure) <class 'dict'> 1. 要创建空集合，可不带参数调用 set() 。 2. 打印出来的空集合表现形式看起来有点儿怪。也许，您期望 看到一个 {} 吧 ？该符号表示一个空的字典，而不是一个空的集 合。本章稍后您将学到关于字典的内容。 3. 尽管打印出的形式奇怪，这 确实是 一个集合…… 4. …… 同时该集合没有任何成员。 5. 由于从 Python 2 沿袭而来历史的古怪规定，不能使用两个花 括号来创建空集合。该操作实际创建一个空字典，而不是一个 空集合。 修改集合 有两种方法可向现有集合中添加值： add() 方法和 update() 方 法。 >>> a_set = {1, 2} >>> a_set.add(4) ① >>> a_set {1, 2, 4} >>> len(a_set) ② 3 >>> a_set.add(1) ③ >>> a_set {1, 2, 4} >>> len(a_set) ④ 3 1. add() 方法接受单个可以是任何数据类型的参数，并将该值 添加到集合之中。 2. 该集合现在有三个成员了。 3. 集合是装 唯一值 的袋子。如果试图添加一个集合中已有的 值，将不会发生任何事情。将不会引发一个错误；只是一条空 操作。 4. 该集合 仍然 只有三个成员。 >>> a_set = {1, 2, 3} >>> a_set {1, 2, 3} >>> a_set.update({2, 4, 6}) ① >>> a_set ② {1, 2, 3, 4, 6} >>> a_set.update({3, 6, 9}, {1, 2, 3, 5, 8, 13}) ③ >>> a_set {1, 2, 3, 4, 5, 6, 8, 9, 13} >>> a_set.update([10, 20, 30]) ④ >>> a_set {1, 2, 3, 4, 5, 6, 8, 9, 10, 13, 20, 30} 1. update() 方法仅接受一个集合作为参数，并将其所有成员添 加到初始列表中。其行为方式就像是对参数集合中的每个成员 调用 add() 方法。 2. 由于集合不能包含重复的值，因此重复的值将会被忽略。 3. 实际上，可以带任何数量的参数调用 update() 方法。如果调 用时传递了两个集合， update() 将会被每个集合中的每个成员 添加到初始的集合当中（丢弃重复值）。 4. update() 方法还可接受一些其它数据类型的对象作为参数， 包括列表。如果调用时传入列表，update() 将会把列表中所有 的元素添加到初始集合中。 从集合中删除元素 有三种方法可以用来从集合中删除某个值。前两种，discard() 和 remove() 有细微的差异。 >>> a_set = {1, 3, 6, 10, 15, 21, 28, 36, 45} >>> a_set {1, 3, 36, 6, 10, 45, 15, 21, 28} >>> a_set.discard(10) ① >>> a_set {1, 3, 36, 6, 45, 15, 21, 28} >>> a_set.discard(10) ② >>> a_set {1, 3, 36, 6, 45, 15, 21, 28} >>> a_set.remove(21) ③ >>> a_set {1, 3, 36, 6, 45, 15, 28} >>> a_set.remove(21) ④ Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 21 1. discard() 接受一个单值作为参数，并从集合中删除该值。 2. 如果针对一个集合中不存在的值调用 discard() 方法，它不 进行任何操作。不产生错误；只是一条空指令。 3. remove() 方法也接受一个单值作为参数，也从集合中将其删 除。 4. 区别在这里：如果该值不在集合中，remove() 方法引发一个 KeyError 例外。 就像列表，集合也有个 pop() 方法。 >>> a_set = {1, 3, 6, 10, 15, 21, 28, 36, 45} >>> a_set.pop() ① 1 >>> a_set.pop() 3 >>> a_set.pop() 36 >>> a_set {6, 10, 45, 15, 21, 28} >>> a_set.clear() ② >>> a_set set() >>> a_set.pop() ③ Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'pop from an empty set' 1. pop() 方法从集合中删除某个值，并返回该值。然而，由于 集合是无序的，并没有“ 最后一个” 值的概念，因此无法控制删 除的是哪一个值。它基本上是随机的。 2. clear() 方法删除集合中 所有 的值，留下一个空集合。它等 价于 a_set = set() ，该语句创建一个新的空集合，并用之覆盖 a_set 变量的之前的值。 3. 试图从空集合中弹出某值将会引发 KeyError 例外。 常见集合操作 Python 的 集合 类型支持几种常见的运算。 >>> a_set = {2, 4, 5, 9, 12, 21, 30, 51, 76, 127, 195} >>> 30 in a_set ① True >>> 31 in a_set False >>> b_set = {1, 2, 3, 5, 6, 8, 9, 12, 15, 17, 18, 21} >>> a_set.union(b_set) ② {1, 2, 195, 4, 5, 6, 8, 12, 76, 15, 17, 18, 3, 21, 30, 51, 9, 127} >>> a_set.intersection(b_set) ③ {9, 2, 12, 5, 21} >>> a_set.difference(b_set) ④ {195, 4, 76, 51, 30, 127} >>> a_set.symmetric_difference(b_set) ⑤ {1, 3, 4, 6, 8, 76, 15, 17, 18, 195, 127, 30, 51} 1. 要检测某值是否是集合的成员，可使用 in 运算符。其工作原 理和列表的一样。 2. union() 方法返回一个新集合，其中装着 在两个 集合中出现 的元素。 3. intersection() 方法返回一个新集合，其中装着 同时 在两个 集合中出现的所有元素。 4. difference() 方法返回的新集合中，装着所有在 a_set 出现 但未在 b_set 中的元素。 5. symmetric_difference() 方法返回一个新集合，其中装着所 有 只在其中一个 集合中出现的元素。 这三种方法是对称的。 # continued from the previous example >>> b_set.symmetric_difference(a_set) ① {3, 1, 195, 4, 6, 8, 76, 15, 17, 18, 51, 30, 127} >>> b_set.symmetric_difference(a_set) == a_set.symmetric_difference(b_set) ② True >>> b_set.union(a_set) == a_set.union(b_set) ③ True >>> b_set.intersection(a_set) == a_set.intersection(b_set) ④ True >>> b_set.difference(a_set) == a_set.difference(b_set) ⑤ False 1. a_set 与 b_set 的对称差分 看起来 和b_set 与 a_set 的对称 差分不同，但请记住：集合是无序的。任何两个包含所有同样 值（无一遗漏）的集合可认为是相等的。 2. 而这正是这里发生的事情。不要被 Python Shell 对这些集合 的输出形式所愚弄了。它们包含相同的值，因此是相等的。 3. 对两个集合的 Union［并集］操作也是对称的。 4. 对两个集合的 Intersection ［交集］操作也是对称的。 5. 对两个集合的 Difference［求差］操作不是对称的。这是有意 义的；它类似于从一个数中减去另一个数。操作数的顺序会导 致结果不同。 最后，有几个您可能会问到的问题。 >>> a_set = {1, 2, 3} >>> b_set = {1, 2, 3, 4} >>> a_set.issubset(b_set) ① True >>> b_set.issuperset(a_set) ② True >>> a_set.add(5) ③ >>> a_set.issubset(b_set) False >>> b_set.issuperset(a_set) False 1. a_set 是 b_set 的 子集 — 所有 a_set 的成员均为 b_set 的成 员。 2. 同样的问题反过来说， b_set 是 a_set 的 超集，因为 a_set 的所有成员均为 b_set 的成员。 3. 一旦向 a_set 添加一个未在 b_set 中出现的值，两项测试均 返回 False 。 布尔上下文环境中的集合 可在 if 这样的 布尔类型上下文环境中 使用集合。 >>> def is_it_true(anything): ... if anything: ... print("yes, it's true") ... else: ... print("no, it's false") ... >>> is_it_true(set()) ① no, it's false >>> is_it_true({'a'}) ② yes, it's true >>> is_it_true({False}) ③ yes, it's true 1. 在布尔类型上下文环境中，空集合为假值。 2. 任何至少包含一个上元素的集合为真值。 3. 任何至少包含一个上元素的集合为真值。元素的值无关紧 要。 ⁂ 字典 字典 是键值对的无序集合。向字典添加一个键的同时，必须为 该键增添一个值。（之后可随时修改该值。） Python 的字典为 通过键获取值进行了优化，而不是反过来。 ☞Python 中的字典与 Perl 5 中的 hash [ 散列] 类似。 在 Perl 5 中，散列存储的变量总是以一个 % 符开 头。在 Python 中，变量可以随意命名，而 Python 内部跟踪其数据类型。 创建字典 创建字典非常简单。其语法与 集合 的类似，但应当指定键值对 而不是值。有了字典后，可以通过键来查找值。 >>> a_dict = {'server': 'db.diveintopython3.org', 'database': 'mysql'} ① >>> a_dict {'server': 'db.diveintopython3.org', 'database': 'mysql'} >>> a_dict['server'] ② 'db.diveintopython3.org' >>> a_dict['database'] ③ 'mysql' >>> a_dict['db.diveintopython3.org'] ④ Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'db.diveintopython3.org' 1. 首先，通过将两个字典项指定给 a_dict 变量创建了一个新字 典。每个字典项都是一组键值对，整个字典项集合都被大括号 包裹在内。 2. 'server' 为键，通过 a_dict['server'] 引用的关联值为 'db.diveintopython3.org' 。 3. 'database' 为键，通过 a_dict['database'] 引用的关联值为 'mysql' 。 4. 可以通过键获取值，但不能通过值获取键。因此 a_dict['server'] 为 'db.diveintopython3.org'，而 a_dict['db.diveintopython3.org'] 会引发例外，因为 'db.diveintopython3.org' 并不是键。 修改字典 字典没有预定义的大小限制。可以随时向字典中添加新的键值 对，或者修改现有键所关联的值。继续前面的例子： >>> a_dict {'server': 'db.diveintopython3.org', 'database': 'mysql'} >>> a_dict['database'] = 'blog' ① >>> a_dict {'server': 'db.diveintopython3.org', 'database': 'blog'} >>> a_dict['user'] = 'mark' ② >>> a_dict ③ {'server': 'db.diveintopython3.org', 'user': 'mark', 'database': 'blog'} >>> a_dict['user'] = 'dora' ④ >>> a_dict {'server': 'db.diveintopython3.org', 'user': 'dora', 'database': 'blog'} >>> a_dict['User'] = 'mark' ⑤ >>> a_dict {'User': 'mark', 'server': 'db.diveintopython3.org', 'user': 'dora', 'database': 'blog'} 1. 在字典中不允许有重复的键。对现有的键赋值将会覆盖旧 值。 2. 可随时添加新的键值对。该语法与修改现有值相同。 3. 新字典项（键为 'user'，值为 'mark'）出现在中间。事实 上，在第一个例子中字典项按顺序出现是个巧合；现在它们不 按顺序出现同样也是个巧合。 4. 对既有字典键进行赋值只会用新值替代旧值。 5. 该操作会将 user 键的值改回 "mark" 吗？不会！仔细看看该 键——有个大写的 U 出现在 "User" 中。字典键是区分大小写 的，因此该语句创建了一组新的键值对，而不是覆盖既有的字 典项。对你来说它们可能是一样的，但对于 Python 而言它们是 完全不同的。 混合值字典 字典并非只能用于字符串。字典的值可以是任何数据类型，包 括整数、布尔值、任何对象，甚至是其它的字典。而且就算在 同一字典中，所有的值也无须是同一类型，您可根据需要混合 匹配。字典的键要严格得多，可以是字符串、整数和其它一些 类型。在同一字典中也可混合、匹配使用不同数据类型的键。 实际上，您已经在 your first Python program 见过一个将非字符 串用作键的字典了。 SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']} 让我们在交互式 shell 中剖析一下： >>> SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], ... 1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']} >>> len(SUFFIXES) ① 2 >>> 1000 in SUFFIXES ② True >>> SUFFIXES[1000] ③ ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] >>> SUFFIXES[1024] ④ ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'] >>> SUFFIXES[1000][3] ⑤ 'TB' 1. 类似 列表 和 集合 ，len() 函数将返回字典中键的数量。 2. 而且像列表和集合一样，可使用 in 运算符以测试某个特定的 键是否在字典中。 3. 1000 是 字典 SUFFIXES 的一个键；其值为一个 8 元素列表 （确切地说，是 8 个字符串）。 4. 同样， 1024 是字典 SUFFIXES 的键；其值也是一个 8 元素列 表。 5. 由于 SUFFIXES[1000] 是列表，可以通过它们的 0 基点索引来 获取列表中的单个元素。 布尔上下文环境中的字典 空字典为假值；所有其它字典为真值。 可以在 if 这样的 布尔类型上下文环境中 使用字典。 >>> def is_it_true(anything): ... if anything: ... print("yes, it's true") ... else: ... print("no, it's false") ... >>> is_it_true({}) ① no, it's false >>> is_it_true({'a': 1}) ② yes, it's true 1. 在布尔类型上下文环境中，空字典为假值。 2. 至少包含一个键值对的字典为真值。 ⁂ NONE None 是 Python 的一个特殊常量。它是一个 空 值。None 与 False 不同。None 不是 0 。None 不是空字符串。将 None 与任何 非 None 的东西进行比较将总是返回 False 。 None 是唯一的空值。它有着自己的数据类型（NoneType）。可 将 None 赋值给任何变量，但不能创建其它 NoneType 对象。所 有值为 None 变量是相等的。 >>> type(None) <class 'NoneType'> >>> None == False False >>> None == 0 False >>> None == '' False >>> None == None True >>> x = None >>> x == None True >>> y = None >>> x == y True 布尔上下文环境中的 NONE 在 布尔类型上下文环境中， None 为假值，而 not None 为真 值。 >>> def is_it_true(anything): ... if anything: ... print("yes, it's true") ... else: ... print("no, it's false") ... >>> is_it_true(None) no, it's false >>> is_it_true(not None) yes, it's true