python列表元素所有位置 python 列表 元素

5 Lists 列表型

列表是 Python 的主力数据类型。在 Python 程序中，会大量使用列表对象。

列表与字符串类似，它也是一系列对象的有序集合。所不同的是，列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表。事实上，列表中的对象可以是任何类型。列表中的值称为元素（element），也可称为列表项（item）。

5.1 列表声明

创建列表时，使用中括号包裹一系列以逗号分割的值即可，也可使用 list() 函数.

>>> a_list = ['a', 'b', 'example']        # 推荐方式
>>> a_list = list(('a', 'b', 'example'))  # list（）函数中的参数必须是一个元组

列表中可以嵌套列表

>>> b_list = [1, 2.0, 'a', [10, 20]]

5.2 列表索引、切片

列表可当做以零为基点的数组使用。列表索引总是以零为基点的。可通过指定索引位置获取列表中的元素。

>>> a_list[0] 
'a'
>>> a_list[2]
'example'

使用负索引值可从列表的尾部向前计数访问元素。任何非空列表的最后一个元素总是 a_list[-1] 。

>>> a_list[-1] 
'example'
>>> a_list[-3]
'a'

如果负数令你混淆，可将其视为如下方式：a_list[-n] == a_list[len(a_list) - n] 。因此在此列表中， a_list[-3] == a_list[3 - 3] == 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']

切片操作放在等号左侧，还可进行赋值操作，表示在切片的位置增加新的值。

>>> t =['a','b','c','d','e']
>>> t[1:3] = ['x','y']
>>> t
>>> ['a','x','y','b','c','d','e']

5.3 列表拼接

列表的拼接可以使用 “+” 运算符、append 函数、extend 函数以及 insert 函数。

“+” 运算符连接列表以创建一个新列表。列表可包含任何数量的元素，没有大小限制，除非超出类内存的限制。

>>> a_list = ['a']
>>> a_list = a_list + [2.0, 3]
>>> a_list 
['a', 2.0, 3]

实际上，在进行连接操作时，将在内存中创建第二个列表。此时，新列表将会立即被赋值给已有变量 a_list。因此，实际上该行代码包含两个步骤：先连接并创建新的列表，在将新列表赋值给原变量。当处理大型列表时，该操作可能会暂时消耗大量内存。

append() 方法向列表的尾部添加一个新的元素，该方法中的参数是单个对象，这个对象可以使任何类型，甚至可以是列表类型。

>>> a_list.append(True)
>>> a_list
['a', 2.0, 3, True]

extend() 方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。

>>> a_list.extend(['four', 'Ω'])
>>> a_list
['a', 2.0, 3, True, 'four', 'Ω']

insert() 方法将单个元素插入到列表中。它接受两个参数，第一个参数是列表中将被顶离原位的第一个元素的位置索引，第二个参数是要插入的对象。

>>> a_list.insert(0, 'Ω')
>>> a_list
['Ω', 'a', 2.0, 3, True, 'four', 'Ω']

列表中的元素并不一定要是唯一的；比如说现有两个各自独立的元素，其值均为 'Ω':，第一个元素 a_list[0] 以及最后一个元素 a_list[6] 。

进一步看看 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.append(['g', 'h', 'i'])
>>> a_list
['a', 'b', 'c', 'd', 'e', 'f', ['g', 'h', 'i']]
>>> len(a_list)
7

extend() 方法只接受一个参数，而该参数总是一个列表，并将列表 a_list 中所有的元素都添加到该列表中。append() 方法只接受一个参数，但可以是任何数据类型，如果餐数是列表，它会将列表整体插入到原对象中。在上面的例子中，a_list 在 append 之前有 6 个元素，然后将一个包含 3 个元素的列表 append 上去，结果得到一个 7 元素列表。为什么是 7 个而不是 9 个？因为最后一个元素（刚刚 append 的元素） 是当做列表对象整体添加到原对象中的，它没有进行拆分 。

5.4 在列表中检索值

count() 方法返回了列表中某个特定值出现的次数。

>>> a_list = ['a', 'b', 'new', 'mpilgrim', 'new']
>>> a_list.count('new')
2

in 运算符 用于判断某个值是否出现在列表中。

它比 count() 方法要略快一些。in 运算符总是返回 True 或 False，它不会告诉你该值出现在什么位置。

>>> 'new' in a_list
True
>>> 'c' in a_list
False

index() 方法将查找某值在列表中的第一次出现。

在该情况下，'new' 在列表中出现了两次，分别为 a_list[2] 和 a_list[4]，但 index() 方法将只返回第一次出现的位置索引值。缺省情况下它将搜索整个列表。如果在列表中没有找到该值，index() 方法将会引发一个异常。

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

index() 方法可以通过第二个参数（以 0 为基点的）索引值来指定起点，通过第三个参数（以 0 基点的）索引来指定搜索终点。检索式包括起点，不包括终点。这和数组切片是类似的。

>>> a_list.index('new',3,5)
4
>>> a_list.index('new',3,4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'new' is not in list

5.5 从列表中删除元素

列表中间永远不会有缝隙。如果删除或添加了列表中的值，它会自动拓展或者收缩。您已经看到了拓展部分。也有几种方法可从列表中删除元素。

可使用 del 语句从列表中删除某个特定元素。

>>> 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 之后再访问索引 1 将 不会 导致错误。被删除元素之后的所有元素将移动它们的位置以“填补”被删除元素所产生的“缝隙”。

也可以通过值而非索引来删除元素。使用 remove() 方法从列表中删除某个元素。remove() 方法接受一个 value 参数，并删除列表中该值的第一次出现。同样，被删除元素之后的所有元素将会将索引位置下移，以“填补缝隙”。

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

如果试图删除列表中不存在的元素，它将引发一个异常。

另一有趣的列表方法是 pop() 。pop() 方法是从列表删除元素的另一方法，但与 remove() 有所不同。

pop() 方法将删除列表中最后的元素，并返回所删除的值。

>>> a_list = ['a', 'b', 'new', 'mpilgrim']
>>> a_list.pop()
'mpilgrim'
>>> a_list
['a', 'b', 'new']

可以从列表中 pop 任何元素。只需传给 pop() 方法一个位置索引值。它将删除该元素，将其后所有元素移位以“填补缝隙”,然后返回它删除的值。

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

空列表调用 pop() 将会引发一个异常。

5.6 布尔上下文环境中的列表

前一篇提到了布尔类型的上下文环境，即在 Python 所预期的是一个布尔类型值的环境中（例如 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

任何至少包含一个及以上元素的列表为真值。元素的值无关紧要。

6 tuples 元组型

元组是不可变的列表。一旦创建之后，用任何方法都不可以修改其中的元素。

6.1 元组声明

元组的定义方式和列表类似，但整个元素的集合都用圆括号包起来，而非使用方括号。

>>> a_tuple = ("a", "b", "mpilgrim", "z", "example")
>>> a_tuple
('a', 'b', 'mpilgrim', 'z', 'example')

为创建单元素元组，需要在值之后加上一个逗号。没有逗号，Python 会假定这只是一对没用的圆括号，虽然没有害处，但并不创建元组。

>>> is_it_true((False,))
yes, it's true
>>> type((False))
<class 'bool'>
>>> type((False,))
<class 'tuple'>

6.2 元组常用操作

和列表一样，元组的元素都有确定的顺序。元组的索引也是以零为基点的，和列表一样，因此非空元组的第一个元素总是 a_tuple[0] 。

>>> a_tuple[0]
'a'

负的索引从元组的尾部开始计数，这和列表也是一样的。元组也可以进行切片操作。对列表切片可以得到新的列表；对元组切片可以得到新的元组。

>>> a_tuple[-1]
'example'
>>> a_tuple[1:3]
('b', 'mpilgrim')

元组和列表的主要区别是元组不能进行修改。用技术术语来说，元组是不可变更的。从实践的角度来说，没有可用于修改元组的方法。列表有像 append()、 extend()、 insert()、remove() 和 pop() 这样的方法。这些方法，元组都没有。可以对元组进行切片操作（因为该方法创建一个新的元组），可以检查元组是否包含了特定的值（因为该操作不修改元组），等等。

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

元组可转换成列表，列表也可以转换成元组。内建的 tuple() 函数接受一个列表参数，并返回一个包含同样元素的元组，而 list() 函数接受一个元组参数并返回一个列表（在列表那一节，我们已经看到过例子了）。从效果上看，tuple() 冻结列表，而 list() 融化元组。

6.3 同时赋多个值

以下是一种很酷的编程捷径：在 Python 中，可使用元组来一次赋多值。

>>> v = ('a', 2, True)
>>> (x, y, z) = v
>>> x
'a'
>>> y
2
>>> z
True

v 是一个三元素的元组，而 (x, y, z) 是包含三个变量的元组。将其中一个赋值给另一个将会把 v 中的每个值按顺序赋值给每一个变量。

假设需要将某个名称指定某个特定范围的值。可以使用内建的 range() 函数进行多变量赋值以快速地进行连续变量赋值。

>>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)
>>> MONDAY 
0
>>> TUESDAY
1
>>> SUNDAY
6

内建的 range() 函数构造了一个整数序列。MONDAY、 TUESDAY、 WEDNESDAY、 THURSDAY、 FRIDAY、 SATURDAY 和 SUNDAY 是您所定义的变量。现在，每个变量都有其值了： MONDAY 为 0， TUESDAY 为 1，如此类推。

还可以使用多变量赋值创建返回多值的函数，只需返回一个包含所有值的元组。调用者可将返回值视为一个简单的元组，或将其赋值给不同的变量。这一特性将在涉及函数相关的内容时具体讲述。

6.4 布尔上下文环境中的元组

可以在 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

与列表类似，元组中的元素无论是什么值，只要包含一个或以上的元素，该元组即为真。

7 Sets 集合型

集合 set 就像是一个装有不重复的、无序的对象的“袋子”。注意两个特性，一个是不重复，另一个是无序。

7.1 集合类型对象声明

使用一对花括号包裹元素，即可声明一个集合对象。多个元素，用逗号分开。

如果有两个集合，则可以执行像联合、交集以及集合求差等标准集合运算。

>>> a_set = {1}
>>> a_set
{1}
>>> type(a_set)
<class 'set'>
>>> a_set = {1, 2}
>>> a_set
{1, 2}

还可以列表为基础创建集合。从列表创建集合，使用 set() 函数。

>>> 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]

简单的集合可以包括任何数据类型的值。而且，正如之前所提到的，集合是无序的。该集合并不记得用于创建它的列表中元素的最初顺序。如果向集合中添加元素，它也不会记得添加的顺序。创建集合之后，初始的列表并不会发生变化。

如果没有指定任何值，可以创建一个空的集合。

>>> a_set = set()
>>> a_set
set()
>>> type(a_set)
<class 'set'>
>>> len(a_set)
0

打印出来的空集合表现形式看起来有点儿怪。也许，你期望看到一个 {} ，实际上该符号表示一个空的字典，而不是一个空的集合。稍后将讲述关于字典的内容。

你可以推想得到，不能使用两个花括号来创建空集合。该操作实际创建一个空字典。

>>> not_sure = {}
>>> type(not_sure)
<class 'dict'>

7.2 修改集合

有两种方法可向现有集合中添加值： add() 方法和 update() 方法。

add() 方法接受单个可以是任何数据类型的参数，并将该值添加到集合之中。

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

update() 方法仅接受一个集合作为参数，并将其所有成员添加到初始列表中。其行为方式就像是对参数集合中的每个成员调用 add() 方法。

>>> a_set = {1, 2, 3}
>>> a_set
{1, 2, 3}
>>> a_set.update({2, 4, 6})
>>> a_set
{1, 2, 3, 4, 6}

实际上，可以带任何数量的参数调用 update() 方法。如果调用时传递了两个集合， update() 将会被每个集合中的每个成员添加到初始的集合当中（丢弃重复值）。

>>> a_set.update({3, 6, 9}, {1, 2, 3, 5, 8, 13})
>>> a_set
{1, 2, 3, 4, 5, 6, 8, 9, 13}

update() 方法还可接受一些其它数据类型的对象作为参数，包括列表和元组。如果调用时传入列表或元组，update() 将会把其中的所有的元素添加到初始集合中。

>>> a_set.update([10, 20, 30])
>>> a_set
{1, 2, 3, 4, 5, 6, 8, 9, 10, 13, 20, 30}
>>> b = (40,50)
>>> b=(40,50)
>>> a_set.update(b)
>>> a_set
{1, 2, 3, 4, 5, 6, 8, 9, 10, 40, 13, 50, 20, 30}

7.3 从集合中删除元素

从集合中删除某个值，可以使用discard() 和 remove() ，这两种方法有细微的差异。

>>> a_set = {1, 3, 6, 10, 15, 21, 28, 36, 45}
>>> a_set
{1, 3, 36, 6, 10, 45, 15, 21, 28}

discard() 接受一个单值作为参数，并从集合中删除该值。

>>> a_set.discard(10)
>>> a_set
{1, 3, 36, 6, 45, 15, 21, 28}

如果针对一个集合中不存在的值调用 discard() 方法，它不进行任何操作。不产生错误,只是一条空指令。

>>> a_set.discard(10)
>>> a_set
{1, 3, 36, 6, 45, 15, 21, 28}

remove() 方法也接受一个单值作为参数，也从集合中将其删除。和 discard()的区别在于，如果该值不在集合中，remove() 方法引发一个 KeyError 异常。

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

从集合中删除某个值，还有第三种方法pop() 。

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}

还有一个删除集合中值的方法 clear() ，该方法用于删除集合中所有*的值，留下一个空集合。它等价于 a_set = set()，该语句创建一个新的空集合，并用之覆盖 a_set 变量的之前的值。

>>> 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'

从空集合中弹出某值将会引发 KeyError 异常。

7.4 常见集合操作

Python 的集合类型支持几种常见的运算。和数学中的“集合”概念一样，Python 中的集合对象同样支持并集、交集以及集合求差等标准的集合运算。

in 运算符用于检测某值是否是集合中的成员。

>>> a_set = {2, 4, 5, 9, 12, 21, 30, 51, 76, 127, 195}
>>> 30 in a_set
True
>>> 31 in a_set
False

union() 表示并集操作，该方法返回一个新集合，其中装着在两个集合中出现的元素。

>>> 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}

intersection() 表示交集操作，该方法返回一个新集合，其中装着同时在两个集合中出现的所有元素。

>>> a_set.intersection(b_set)
{9, 2, 12, 5, 21}

difference() 表示差集操作，该方法返回的新集合中，装着所有在 a_set 出现但未在 b_set 中的元素。

>>> a_set.difference(b_set)
{195, 4, 76, 51, 30, 127}

symmetric_difference() 方法表示交叉补集操作，该方法返回一个新集合，其中装着所有只在其中一个集合中出现的元素。其结果就是以上操作结果中，并集里去掉交集的部分

>>> a_set.symmetric_difference(b_set)
{1, 3, 4, 6, 8, 76, 15, 17, 18, 195, 127, 30, 51}

子集与父集操作，使用 issubset() 和 issuperset()方法。issubset() 用于判断该集合是否是括号内的参数的子集，issuperset() 用于判断该集合是否是括号内的参数的父集。

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

7.5 布尔上下文环境中的集合

在 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

8 Dictionaries 字典型

字典是键值对的无序集合。向字典添加一个键的同时，必须为该键增添一个值，之后可随时修改该值。

8.1 创建字典

创建字典非常简单。其语法与集合的类似，用花括号包裹元素，但应当指定键值对而不是值。

>>> a_dict = {'server': 'db.diveintopython3.org', 'database': 'mysql'} 
>>> a_dict
{'server': 'db.diveintopython3.org', 'database': 'mysql'}

也可以使用 dict() 方法创建字典，参数如下例所示。

>>> b_dict=dict(name='windrivder', age=21)
>>> b_dict
{'name': 'windrivder', 'age': 21}
>>> c_dict = dict([('name', 'windrivder'), ('age', 21)])
>>> c_dict
{'name': 'windrivder', 'age': 21}

字典中为键值对，通过“键”可获取相应的“值”。

>>> 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'

8.2 修改字典

字典没有预定义的大小限制。可以随时向字典中添加新的键值对，或者修改现有键所关联的值。继续前面的例子。

在字典中不允许有重复的键。对现有的键赋值将会覆盖旧值。

>>> 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'}

字典键是区分大小写的。下面的例子中，user 与 User并不是同一个键，因此可以同时存在于字典中。

>>> 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'}

8.3 混合值字典

字典的值可以是任何数据类型，包括整数、布尔值、任何对象，甚至是其它的字典。而且就算在同一字典中，所有的值也无须是同一类型，可根据需要混合匹配。

字典的键要严格得多，可以是字符串、整数和其它一些类型，但必须是不可变类型。因为字典的值的位置是根据键计算出来的，因此键必须是不可变对象，这样才能确保字典的正确使用。

在同一字典中也可混合、匹配使用不同数据类型的键。字典可以嵌套

>>> d_dict = {'windrivder': 21, 'other': {'jack': 22}}  
>>> d_dict
{'windrivder': 21, 'other': {'jack': 22}}

8.4 常见字典操作

此处列举一些常用的字典操作方法，其中很多与列表、集合是类似的

d.keys()          # 遍历字典键
d.values()        # 遍历字典值
d.items()         # 遍历字典键值对
d.setdefault(key[, value])    # 为字典的某一项设置默认值
d.get(key, default)           # 获取字典中的某个值
d.update(newd)                # 合并字典，此方式效率较高
d.pop(key, [d])               # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值d，否则抛出异常
d.popitem()                # 随机删除某一项键值对

循环遍历字典中的键值对

>>> d_dict = {'windrivder': 21, 'other': {'jack': 22}} 
>>> for (k,v) in d_dict.items():
...     print(k,v)
... 
windrivder 21
other {'jack': 22}
>>>

8.5 布尔上下文环境中的字典

在 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

9 None 类型

None 是 Python 中的一个特殊常量，它表示的是一个空值。

9.1 None 值的特性

None 不是空字符串，不是 0，也不是 False，它表示一个什么都没有的空置，其类型是 NoneType。

>>> type(None)
<class 'NoneType'>

将 None 与任何非 None 的东西进行比较将总是返回 False 。

>>> None == False
False
>>> None == 0
False
>>> None == ''
False

可将 None 赋值给任何变量。只有 None 是 NoneType 类型的对象，因此你不能创建其它 NoneType 对象。所有值为 None 的变量都是相等的。

>>> None == None
True
>>> x = None
>>> x == None
True
>>> y = None
>>> x == y
True

9.2 布尔上下文环境中的 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

not None 不代表具体的对象，它只是 None 的逻辑取反。

总结

在 Python 中一切均为对象，每一个对象都有所属的类型，除了上问提到的 9 中类型，还有 像 module［模块］、 function［函数］、 class［类］、 method［方法］、 file［文件］ 等这样的类型。此外，用户还可以自定义类型，并声明属性和方法。在后续的文章中，再进一步讲述。