Python 快速语法参考（二）

原文：The Python Quick Syntax Reference

协议：CC BY-NC-SA 4.0

六、数据结构

数据结构对于大多数严肃的(和一些不那么严肃的)程序都很重要。它们允许我们在单个变量名下存储相关数据组，并快速、逻辑地访问它们。在 Python 下有许多类型的数据结构可用，每一种都将在下面的章节中解释。

数据结构示例

假设我们需要保存一个可供最终用户使用的颜色名称列表，该列表包含以下值:

Red, Orange, Yellow, Green, Blue, Purple

我们可以简单地创建一些不同的独立变量来保存每个值。另一方面，我们可以使用列表数据结构在单个变量下跟踪它们。

ColorList = ['Red','Orange','Yellow','Green','Blue','Purple']

通过这种方式，我们可以通过简单地使用 ColorList 变量的索引来轻松地访问我们想要的任何颜色名称。

print ColorList[2]

会返回“黄色”。请记住，索引是从零开始的。

深入挖掘

如果我们需要为我们正在创建的程序保留数据，如注册信息，我们需要这样的信息:

First Name, Last Name, Address, City, State, Postal Code

首先想到的是使用数据库来存储这些信息。然而，更快的方法是使用字典结构。字典(您将在下面看到)允许我们存储与“键”相关的数据。通过使用字典，我们没有处理数据库的开销。我们将在本章稍后讨论字典时对此进行研究。

列表

在其他语言中，有一种数据结构叫做数组。回到我在第二章中使用的鞋盒类比，数组只是一堆“粘”在一起的鞋盒，它们在一个变量名下保存类似的数据。Python 不提供原生数组类型。相反，我们有列表对象。

列表只是一个可以通过索引号访问的项目集合，类似于数组。与数组不同，列表可以包含任何值，如字符串、整数、浮点数或其他对象，如字典或其他列表。您也可以在列表中混合不同类型的数据。列表是动态的，所以可以随时修改。

要手动创建列表，可以使用方括号字符“[”和“]”。列表中的每一项都用逗号分隔。

MyList = ['This','is','a','list']
NumberList = [0,1,2,3,4,5,6]
MyEmptyList = []
SillyList = [3,'A String',42,'42',5,'The End']

要访问列表中的单个项目，可以通过索引值来访问列表。列表具有从零开始的索引，因此列表中的第一项是索引 0，第二项是索引 1，依此类推。使用上面的例子 MyList :

>>> print MyList[2]
`a`
>>> print MyList[3]
`list`
>>> print MyList[0]
`This`

如果您试图访问一个不存在的列表的索引(例如，MyList 中的索引位置 4)，您将得到一个错误。

要从头到尾遍历(或迭代)整个列表，可以使用一个简单的 for 循环:

for i in range(0,len(MyList)):
    print MyList[i]

This
is
a
list

另一种方法是使用类似下面的代码，一些程序员认为它更简单、更“pythonic 化”,同时产生相同的输出:

for elem in MyList:
    print elem

您也可以将其他类型的数据结构转换成列表。在下面的例子中，变量t是一个元组。

>>> t = (1,2,3)
>>> l = list(t)
>>> l
`[1, 2, 3]`

列表功能

下列内置运算符可用于 List 对象。

len(L)

返回列表中的项目数。

>>> l = [1,2,3,4,5,6,7]
>>> len(l)
7

最小(L)

返回列表中的最小值。

>>> l = [1,2,3,4,5,6,7]
>>> min(l)
1

max(L) 功能

返回列表中的最大值。

>>> l = [1,2,3,4,5,6,7]
>>> max(l)
7

L 中的 x

如果 x 在列表 l 中，则返回 True。

>>> l = [1,2,3,4,5,6,7]
>>> 42 in l
`False`
>>> 3 in l
`True`

x 不在 L 中

如果 x 不在列表 l 中，则返回 True。

>>> l = [1,2,3,4,5,6,7]
>>> 42 not in l
`True`

L1 + L2

将 L2 连接到 L1 的尽头。

>>> l = [1,2,3,4,5,6,7]
>>> l2 = [9,10,11,12]
>>> l+l2
`[1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12]`

L[x]

检索列表中索引位置 x 处的项(从零开始)。这与在另一种语言中使用数组非常相似。如果你需要像多维数组一样的东西，这在 Python 中是不可用的，你可以使用列表的列表。

>>> l = [1,2,3,4,5,6,7]
>>>l[3]
4

L[x1:x2]

列表 L 从索引位置 x1 到 x2 的切片(从零开始)。

>>> l = [1,2,3,4,5,6,7]
>>> l[2:4]
[3, 4]

del(L[x])

从列表 L 中移除索引位置 x 处的项(从零开始)。

>>> l = ['F', 'E', 'D', 'C', 'B', 'A']
>>> del(l[2])
>>> l
`['F', 'E', 'C', 'B', 'A']`

列出方法

列表可以使用以下方法。

。追加(x)

将 x 中的值追加到列表中。

>>> l = [0,1,2,3,4]
>>> l.append(5)
>>> l
`[0, 1, 2, 3, 4, 5]`

。延伸(L)

将列表追加到另一个列表。在下面的例子中，l 被修改，l2 没有被修改。

>>> l = [0,1,2,3,4]
>>> l2 = [5,6,7]
>>> l.extend(l2)
>>> l
`[0, 1, 2, 3, 4, 5, 6, 7]`

。插入(I，x)

将值 x 插入列表中的索引 I 处，以下示例将值 5 插入列表中的位置 2。

>>> l = [0,1,2,3,4]
>>> l.insert(2,5)
>>> l
`[0, 1, 5, 2, 3, 4]`

如果小心使用，会列出。插入()和。pop()方法是实现 LIFO(后进先出)队列或堆栈的一种快速简单的方法。

。删除(x)

移除列表中匹配“x”的第一项。如果该项不存在，将会出现错误。下面的示例从列表中删除值 2。第二个示例尝试再次这样做，但得到一个错误。

>>> l = [0,1,2,3,4,5]
>>> l.remove(2)
>>> l
`[0, 1, 3, 4, 5]`
>>> l.remove(2)
`Traceback (most recent call last):`
`File "<stdin>", line 1, in <module>`
`ValueError: list.remove(x): x not in list`

.pop（[i]）

如果不包括可选的索引号，则返回并删除列表中的最后一项。如果是，它将移除该索引处的项(从零开始)。以下示例使用 pop()移除列表中的最后一项，然后移除索引位置 2 处的项。

>>> l = [0,1,2,3,4,5]
>>> l.pop()
5
>>> l.pop()
4
>>> l.pop(2)
2
>>> l
`[0, 1, 3]`

如果小心使用，会列出。插入()和。pop()方法是实现 LIFO(后进先出)队列或堆栈的一种快速简单的方法。

。索引(x)

返回项目在列表中的位置。

以下示例首先显示值 3 在示例列表中的索引位置(即 3)。第二个示例显示了列表中项“Oranges”的索引位置。

>>> l = [0,1,2,3,4,5]
>>> l.index(3)
3
>>> l1 = ['Apples','Oranges','Kiwi','Peach']
>>> l1
`['Apples', 'Oranges', 'Kiwi', 'Peach']`
>>> l1.index('Oranges')
1

。计数(x)

返回列表中匹配项的计数。如果项目不在列表中，则返回 0。

>>> l = [3,1,3,4,3,6,7,8]
>>> l.count(3)
3
>>> l.count(2)
0

。sort( )

将列表从低到高排序。

>>> l2 = [0,1,2,3,2,5,7,3,1,2,5]
>>> l2.sort()
>>> l2
`[0, 1, 1, 2, 2, 2, 3, 3, 5, 5, 7]`

。反向()

反转列表。

>>> l = [0,1,2,3,4,5,6,7,8]
>>> l.reverse()
>>> l
`[8, 7, 6, 5, 4, 3, 2, 1, 0]`
>>> l = ['A','B','C','D','E','F']
>>> l.reverse()
>>> l
`['F', 'E', 'D', 'C', 'B', 'A']`

字典

字典是我们 Python 库中非常有价值的工具。字典就像一个列表，但是它允许你存储带有关键字的数据，作为数据的匹配对。在本书的前面，我谈到了在一个假想的程序中注册信息的必要性。需要的信息是:

First Name, Last Name, Address, City, State, Postal Code

字典让我们能够很容易地保存信息。对于每一条数据，我们都有一个与之相关联的键。键/值对的结构是:

{Key:Value}

字典中的每个键必须是唯一的，但是如果需要，该值可以重复。花括号用于建立字典。密钥可以是字符串或数字。

dict = {"Fname":"Jack","LName":"Sprat"}

你可以创建一个空白的字典,只需将一个变量赋给一组空的花括号。

Names = {}

您可以向字典添加新的键/值对。

>>> names = {'fname':'Fred','lname':'Frackel','city':'Aurora','state':'CO'}>>> names['phone'] = '222-222-2222'
>>> names
`{'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}`

要迭代(遍历)字典，可以使用内置函数.iteritems() 。请注意，字典不会以任何预定义的顺序存储键/值对，因此项目可能不会以输入的顺序出现:

>>> names = {'fname':'Fred','lname':'Frackel','city':'Aurora','state':'CO'}
>>> for key,value in names.iteritems():
...    print key,value
...
lname Frackel
city Aurora
state CO
fname Fred
>>>

字典功能

词典有以下内置功能。

len(字典)

返回字典中的条目数。

>>> d = {'lname':'Frackel','fname':'Fred','city':'Aurora','state':'CO'}
>>> len(d)
4

字典(列表)

从提供的列表创建字典，并且该列表必须包含至少一个二元元组。元组中的第一个元素是键，第二个元素是值。

>>> d2 = dict([('one',1),('two',2),('three',3)])
>>> d2
`{'three': 3, 'two': 2, 'one': 1}`

字典方法

字典有以下内置方法:

。clear( )

从字典中删除所有条目。

>>> test = {'one':'1','two':'2','three':'3'}
>>> test
`{'three': '3', 'two': '2', 'one': '1'}`
>>> test.clear()
>>> test
{}

。复制( )

要复制一个字典，使用.copy()方法。这是一个浅层复制，意思是字典的内容不是直接按值复制，而是按引用复制，指向实际的原始字典。

>>> first = {'a':1,'b':2,'c':3}
>>> clone = first.copy()
>>> first
`{'a': 1, 'b': 2, 'c': 3}`
`>>> clone`
`{'a': 1, 'b': 2, 'c': 3}`

。get(key[，default])

从字典中按键返回单个值。与.pop()方法不同，这不会从字典中删除键/值对。如果字典中不存在关键字，则返回可选默认参数的值。如果未给出默认值，则返回 None。

>>> names = {'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}
>>> names
`{'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}`
>>> names.get('lname')
'Frackel'

。has_key(键)

如果字典中存在该键，则返回 True。该方法已被弃用，建议使用key in d进行检查。

>>> names = {'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}
>>> names.has_key('city')
`True`
>>> names.has_key('address')
`False`

。items( )

返回字典中所有键/值对的列表。请注意，这是一个未排序的列表，并且没有按照数据输入的顺序排序。

>>> names = {'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}
>>> names.items()
`[('lname', 'Frackel'), ('city', 'Aurora'), ('state', 'CO'), ('fname', 'Fred'), ('phone', '222-222-2222')]`

。按键()

要从字典中获取键的列表，使用内置函数.keys()。请注意，这是一个未排序的列表，没有按照键的输入顺序排序。

>>> names = {'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred'}
>>> names.keys()
`['lname', 'city', 'state', 'fname']`

要从一个已排序的字典中获取一个键列表，将来自.keys()函数的返回值分配给一个列表，然后将.sort()函数应用于该变量。

>>> names={'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred'}
>>> namekeys = names.keys()
>>> namekeys.sort()
>>> namekeys
`['city', 'fname', 'lname', 'state']`

。pop(键[，默认])

基于提供的键移除并返回字典中某项的值。如果没有给定default并且密钥不存在，则产生一个 KeyError。

>>> names = {'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred','address':'123 Main Street'}
>>> names.pop('address')
'123 Main Street'
>>> names
`{'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}`

.setdefault（key[，default]）

从提供的键中返回一个值(如果存在)。如果没有，它将使用提供的默认值作为新项输入该键。

>>> d1
`{'a': 1, 'c': 3, 'b': 2, 'e': 0, 'd': 4}`
>>> d1.setdefault('c',6)
3
>>> d1.setdefault('f',6)
6
>>> d1
`{'a': 1, 'c': 3, 'b': 2, 'e': 0, 'd': 4, 'f': 6}`

。【更新(其他)】

用 other 中提供的键/值对更新字典。这将覆盖现有密钥。返回 None。另一个参数可以是提供键/值对的元组或列表，也可以是另一个字典。

>>> names = {'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred'}
>>> names.update({'address':'123 Main Street'})
>>> names
`{'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222', 'address': '123 Main Street'}`

。values( )

返回字典中所有值的列表。返回的列表没有排序，可能没有按照数据输入的顺序排序。使用上述更新后的列表:

>>> names
`{'lname': 'Frackel', 'city': 'Aurora', 'state': 'CO', 'fname': 'Fred', 'phone':'222-222-2222'}`
>>> names.values()

`['Frackel', 'Aurora', 'CO', 'Fred', '222-222-2222']`

元组

元组是另一种序列数据类型。元组是由逗号分隔的多个值。元组中的数据可能由数字、字符串甚至其他对象组成。

>>> t = 3,42,'The time has come for all good men'
>>> t
`(3, 42, 'The time has come for all good men')`
>>> t[0]
3
>>> t[2]
'The time has come for all good men'

元组是不可变的对象，这意味着一旦它被创建，就不能被改变。

>>> t[0] = 73
`Traceback (most recent call last):`
 `File "<stdin>", line 1, in <module>`
`TypeError: 'tuple' object does not support item assignment`

尽管元组是不可变的，但它可以包含可变对象，如列表。

>>> t1 = [1,2,3],['a','b','c']
>>> t1
`([1, 2, 3], ['a', 'b', 'c'])`
>>> t1[0]
`[1, 2, 3]`
>>> t1[0][1] = 4
>>> t1
`([1, 4, 3], ['a', 'b', 'c'])`

还可以将元组中的值赋给可变变量。

>>> x,y = t1
>>> x
`[1, 4, 3]`
>>> y
`['a', 'b', 'c']`

设置

集合是一个没有重复元素的无序集合。集合是可变的(可以被改变)。

在下面的代码片段中，您将看到我们使用字符串“This is a test”作为数据集的数据。当我们得到集合中使用的实际数据时，只有八个值。所有其他值都被丢弃，因为它们是重复的。还要注意，当显示集合时，它实际上是一个列表。

>>> settest = set('This is a test')
>>> settest
`set(['a', ' ', 'e', 'i', 'h', 's', 'T', 't'])`

>>> 'a' in settest
`True`
>>> 'b' in settest
`False`

设置功能

The following functions are available for sets.

镜头(套)

返回集合中项目的长度或计数。

>>> c
`set([2, 3, 4, 5, 6, 7, 8, 9, 11])`
>>> len(c)
9

心态

返回集合中的最小值。

>>> c
`set([2, 3, 4, 5, 6, 7, 8, 9, 11])`
>>> min(c)
2

最大值(设置)

返回集合中的最大值。

>>> c
`set([2, 3, 4, 5, 6, 7, 8, 9, 11])`
>>> max(c)
11

设置方法

以下方法可用于集合。

。clear( )

从集合中删除所有数据。

>>> b = set([1,2,3,4,5])
>>> b
`set([1, 2, 3, 4, 5])`
>>> b.clear()
>>> b
`set([])`

。copy( )

通过进行浅层复制来创建新的集合。

>>> b
`set([3, 4, 5, 6])`
>>> c = b.copy()
>>> c
`set([3, 4, 5, 6])`

。pop( )

从集合中移除任意项。如果集合为空，则会引发一个 KeyError 异常。

>>> b = set([1,2,3,4,5])
>>> b
`set([1, 2, 3, 4, 5])`
>>> b.pop()
1
>>> b.pop()
2
>>> b.pop()
3
>>> b
`set([4, 5])`

。添加(项目)

将项目添加到集合中。由于集合不能包含重复项，因此如果项目已经存在，将不会执行任何操作。

>>> b
`set([4, 5])`
>>> b.add(3)
>>> b
`set([3, 4, 5])`
>>> b.add(4)
>>> b
`set([3, 4, 5])`

。删除(项)

从集合中删除一个项目。如果该项不存在，将引发 KeyError 异常。

>>> b
`set([3, 4, 5])`
>>> b.remove(4)
>>> b
`set([3, 5])`
>>> b.remove(4)
`Traceback (most recent call last):`
 `File "<stdin>", line 1, in <module>`
`KeyError: 4`

。丢弃(物品)

从集合中移除项目。如果该项不在集合中，将不会引发错误。

>>> b
`set([3, 5])`
>>> b.discard(4)
>>> b.discard(5)
>>> b
`set([3])`

。【更新(set)】或者交替地 x|=y

将新集中的值合并到旧集中。如果值存在，它将被忽略。

>>> b
`set([3])`
>>> b.update([3,2,1,4,5])
>>> b
`set([1, 2, 3, 4, 5])`

。或者 x & =y 交集 _ 更新

更新集合 x，丢弃不在集合 x 和 y 中的任何元素。

>>> a = set([1,2,3,4,5])
>>> b = set([2,3,4])
>>> a.intersection_update(b)
>>> a
`set([2, 3, 4])`

。【差异 _ 更新(设定)】或者 x-=y

将集合 x 更新为一个新集合，其值不在集合 x 和 y 中。

>>> a = set([1,2,3,4,5])
>>> b = set([2,3,4])
>>> a.difference_update(b)
>>> a
`set([1, 5])`

。对称 _ 差异 _ 更新(set)或者 x^=y

更新集合 x，使其只包含那些不在集合 x 和 y 中的值。

>>> a = set([1,2,3])
>>> b = set([3,4,5])
>>> a.symmetric_difference_update(b)
>>> a
`set([1, 2, 4, 5])`

。issubset(set) 或者 x < =y

如果集合 y 是集合 x 的子集，则返回 True 否则，它返回 False。

>>> a = set([1,2,3])
>>> b = set([3,4,5])
>>> c = set([2,3])
>>> c.issubset(a)
`True`

。issuperset(set) 或者 x > =y

如果集合 x 是集合 y 的超集，则返回 True 否则，它返回 False。

>>> a = set([1,2,3])
>>> c = set([2,3])
>>> a.issubset(c)
`True`

。并集(set)或者 x|y

返回包含集合 x 和 y 中所有唯一值的集合。

>>> a = set([1,2,3])
>>> c = set([5,6,7])
>>> a.union(c)
`set([1, 2, 3, 5, 6, 7])`

。交点(set)或者交替地 x & y

返回一个新集合，其中包含集合 x 和 y 中的值。

>>> a
`set([1, 2, 3])`
>>> b
`set([2, 3])`
>>> a.intersection(b)
`set([2, 3])`

。【差(set)】或 x-y 交替

返回一个新的集合，其中包含的值不在集合 x 和 y 中。

>>> a
`set([1, 2, 3])`
>>> b
`set([2, 3])`
>>> a.difference(b)
`set([1])`

。对称 _ 差分(set)或者 x^y

返回一个新集合，该集合包含不在集合 x 和 y 中的值，但不更新集合 x。

>>> a
`set([1, 2, 3])`
>>> b = set([3,4,5])
>>> a.symmetric_difference(b)
`set([1, 2, 4, 5])`

冷冻装置

Frozensets 在很大程度上与集合相同，除了它们是不可变的(它们不能被改变)。这意味着.add和.update方法将返回一个错误。

七、关键字

关键字是特殊的保留字，不能用作变量名。随着 Python 版本的变化，关键字也会随着时间而变化。下面是一个简短的程序，它将允许您获得特定于您的 Python 版本的关键字列表。它是使用 Python 3.x 语法编写的，但也适用于 2.7 版本。

Import keyword
print(keyword.kwlist)

Python 关键字列表

下面是 2.7.1 版的 Python 关键字列表，按字母顺序排列。

and             as               assert          break
class           continue         def             del
elif            else             except          exec
finally         for              from            global
if              import           in              is
lambda          not              or              pass
print           raise            return          try
while           with             yield

另外，Python 3.x 增加了四个关键字，去掉了一个。其他关键字包括:

False            None            True             nonlocal

关键字exec已经从 Python 3.x 中移除。

下面的列表是按类型排序的。

解释的关键字

下面我们将检查每个关键字，它做什么和如何使用它。Python 2.x 的关键字按字母顺序排列，以便于参考，后面是 Python 3.x 的附加关键字。每个关键字将使用以下格式:

• 关键字
• 用于或用于
• 解释和代码(如适用)

和

布尔评估

关键字和计算两个等式，如果两个等式都为真，则返回真。如果两者之一为假，则返回假。

>>> a = 1
>>> b = 2
>>> a > 1 and b == 2
`False`
>>> b == 2 and a > 1
`False`
>>> a > 0 and b == 2
`True`
>>> a < b and b == 2
`True`

作为

库，模块

允许我们为导入到程序中的模块或函数创建不同的引用名或别名。

>>> import sys as s
>>> print s.version
2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)]

断言

排除故障

断言关键字强制测试一个表达式，如果表达式为假，编译器将出错。

>>> c = 3
>>> assert c<1
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AssertionError
>>> assert c > 4
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AssertionError
>>> assert c == 3
>>>

突围

环

break 关键字允许当前循环提前中止。下面的代码片段显示，当计数器变量’i’达到 5 时，将退出循环。

for i in range(10):
    print i
    if i == 5:
        break

0
1
2
3
4
5

阶级

杂项

class 关键字允许你创建一个新的类，这对于面向对象编程很重要。

必须通过将类赋给变量来实例化该类。然后我们可以调用类中的任何函数。

class test1:
    def __init__(self,inval):
        self.a = inval #dummy statement

    def run(self):
        for cntr in range(self.a):
          print cntr

t = test1(20)
t.run()

继续

条件语句、循环

在循环中使用 continue 关键字来跳过循环中的剩余代码，以进行循环的迭代。在下面的代码片段中，注意如果cntr变量命中数字 5，它将跳过 print 语句并继续返回到循环的顶部。

for cntr in range(10):
    if cntr == 5:
        continue
    print cntr

0
1
2
3
4
6
7
8
9

定义

功能

关键字允许我们创建一个函数。

def log(strng):
    print(strng)

log("This is a test...")

This is a test...

del

混杂的

关键字从给定索引的列表中删除一个或多个值。

>>> lst = [1,2,3,4,5,6]
>>> lst
[1, 2, 3, 4, 5, 6]
>>> del lst[3]
>>> lst
[1, 2, 3, 5, 6]

在上面的例子中，我们请求删除列表lst中索引位置 3 的项目。记住，所有的索引都是从零开始的，所以那就是数字 4。

您也可以使用切片删除列表中的项目。命令del lst[:2]将删除列表中的前两项，留下(在第一个命令之后)[3,5,6].

elif

条件语句

elif 语句是 if 条件语句的可选部分。当它上面的表达式计算结果为 False 并且您想要测试其他表达式时，可以使用它。 elif 语句与 if 语句行的缩进级别相同，后面跟一个要求值的附加语句，然后是一个冒号。代码块必须缩进。根据需要，可以有任意多的 elif 语句，如果需要，后面可以跟一个 else 语句(见下文)。

a = 3
if a == 1:
    print("Variable A = 1")
elif a == 2:
    print("Variable A = 2")
elif a == 3:
    print("Variable A = 3")
else:
    print("Variable is greater than 3")

别的

条件语句

else 关键字是 if 条件语句的可选部分。当 if 语句(或任何 elif 语句)的计算结果为 false 时，将使用它。这可以被认为是“所有其他的都失败了，所以做下面的代码。” else 关键字与 if 语句行的缩进级别相同，后面紧跟一个冒号。在包含 else 关键字的行中不允许出现任何表达式。需要执行的逻辑块与主 if 语句的逻辑块缩进在同一级别。 else 关键字也是和循环时的可选部分。**

a = 3
if a > 5:
    print("Variable a is greater than 5")
else:
    print("Variable a is less than 5")

除

错误处理

except 关键字与 try 关键字一起用于错误捕获。如果 try 块内的代码由于任何原因失败，将执行除块外的块内的代码。这段代码可以是一个简单的 pass 语句，或者是记录或输出错误信息的内容。除了语句之外，还可能有几个不同的语句，每个语句处理一个特定的错误。

try:
    # try block code here
except:
    # except block code here

except 子句可能包含对遇到的错误类型的某种测试。

try:
    # try block code here
except TypeError:
    # except block code here

执行

杂项

执行存储在字符串或文件中的 Python 语句。(仅限 2.x 版)。这可能会造成安全问题，只能作为最后的手段使用。

>>> code = 'print "This is a test"'
>>> exec code
'print "This is a test"'

最后

错误处理

finally 关键字是 try / except 错误处理系统的一部分。无论是否遇到错误， finally 块中的代码将一直运行，离开 try 代码块。这是放置关闭文件或释放网络资源的代码的好地方。

try:
    # try block code here
except:
    # except block code here
finally:
    # finally block code here that will always run.

对于

环

关键字的创建一个由关键字后面的参数控制的循环，类似于 if 语句，关键字后面是一个序列(可迭代的，如列表或字符串),后面是一个冒号。所有要在循环中执行的编程语句都是缩进的。最简单的循环的如下所示:

for I in range(10):
    print(i)

更多关于循环的可以在第五章中找到。

来自

库

关键字的允许我们直接从一个特定的库模块导入一个变量或函数，而不必限定库名(如 sys.path)。它还只从库中导入请求的例程。如果你想从一个库中导入所有的函数，你可以使用类似于“import sys”或者“from sys import *”的东西。

>>> from sys import path
>>> path
['', 'C:\\WINDOWS\\system32\\python27.zip', 'C:\\Python27\\DLLs', 'C:\\Python27\
\lib', 'C:\\Python27\\lib\\plat-win', 'C:\\Python27\\lib\\lib-tk', 'C:\\Python27
', 'C:\\Python27\\lib\\site-packages']

全球

变量

正如我在第二章中所讨论的，变量的范围是有限的。如果变量是在函数中声明的，那么对该变量的任何操作都仅限于该函数中的代码块，即使该变量的名称与该函数外部使用的名称相同。全局关键字允许操作影响该例程范围之外的其他变量。

x = 3
def tryit():
    global x
    x = 6
def tryit2():
    global x
    x = x * 3
>>> x
6
>>> tryit2()
>>> x
18
>>> tryit()
>>> x
6

如果

条件语句

if 关键字用于条件语句。最简单的形式是， if 语句由一个在运行时求值的表达式和一段代码(可以由单行代码组成)组成，如果表达式为真，这段代码将在运行时执行。 if 语句可以由前面解释的 elif 和 else 关键字扩展。 if 语句的格式以 if 关键字开头，后跟表达式和冒号。表达式为真时要执行的代码块必须缩进。所有缩进的代码都将被视为逻辑块的一部分。如果表达式不为真，代码将传递到下一个未缩进的代码行，这可能是一个 elif、else 或只是程序代码的下一行。

a = 3
if a > 2:
    print("Variable A is greater than 2")

导入

库

import 关键字允许外部库的代码包含在我们的代码中。

>>> import sys
>>> print(sys.version)
2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)]

在

评估，循环

关键字中的可用于测试元组、列表或其他可迭代对象中值的存在性。

>>> a = (1,2,3)
>>> 4 in a
`False`
>>> 3 in a
`True`

您也可以使用 in 关键字作为循环的的一部分。在下面的代码片段中，一个包含从 0 到 9 的值的列表由“range”函数创建，该列表被迭代或遍历以进行循环。

for i in range(10):
    print i,

0 1 2 3 4 5 6 7 8 9

是

布尔评估

is 关键字评估两个表达式，检查它们是否是同一个对象。不能对两个空列表(x = []和 y = [])求值，因为它们不是同一个对象。

>>> m = 2
>>> x = 2
>>> m is x
`True`
>>> m is 2
`True`

λ

功能

允许创建匿名内联函数。

>>> a = lambda d,e,f : d+e+f+3
>>> a(1,2,3)
9
>>> t = (lambda a='one',b='two',c='three' : a+b+c)
>>> t('four','five')
'fourfivethree'

没有

布尔评估

not 关键字对布尔值求反。真变假，假变真。

>>> a = 1
>>> b = 2
>>> not(a == b) # a==b is false. not(False) becomes True
`True`

或者

布尔评估

测试所有表达式，如果至少有一个为真，则返回真，否则返回假。

a = "Test"
b = "Of"
c = "OR"
if a == "1" or b == "Three" or c == "ORD":
    print("True")
else:
    print("False")

`False`

if a == "1" or b == "Three" or c == "OR":
    print("True")
else:
    print("False")

`True`

通过

条件语句、循环

pass 关键字允许您“存根”掉一个尚未完成的函数或条件选项。

Def DummyFunction():
    pass

if a > 2:
    pass
else:
    pass

打印

输出，调试

print 关键字允许您在代码执行期间向终端或命令提示符发送输出。在程序的调试阶段，您还可以使用 print 关键字来显示某些变量的值，以帮助您查看代码可能出错的地方。

Python 2.x 允许打印语句的格式如下:

>>> x = 3
>>> y = 4
>>> print x,y
3 4

但是，Python 3.x 将 print 语句更改为函数，因此它要求用括号将 print 语句括起来:

>>> x = 3
>>> y = 4
>>> print(x,y)
3 4

如果您尝试在 3.x 中使用 2.x 格式，将会出现语法错误。Python 2.x 确实允许 3.x 语法，所以在 Python 2.x 下编写新代码时，应该尽可能使用 3.x 格式。

print 关键字通常会在输出中添加一个转义序列换行符(’ \n ')，除非在语句末尾加了一个逗号。

for x in range(10):
    print x,

0 1 2 3 4 5 6 7 8 9

有关转义序列的更多信息，请参见下面的转义序列。

提高

错误处理

关键字 raise 强制指定的错误发生。这有助于测试和调试。

y = 3
if y < 10:
    raise ValueError
Traceback (most recent call last):
 File "<stdin>", line 2, in <module>
ValueError

返回

功能

return 关键字会将一个或多个值传递回调用该函数的代码行。

def returntest():
    a = 4
    b = 2
    return a * b

>>> print(returntest())
8

从一个函数返回多个值是可能的。在这种情况下，返回值是一个元组。

def returntest2():
    a = 4
    b = 2
    c = a * b
    return a,b,c
>>> print(returntest2())
(4, 2, 8)

试一试

错误处理

try 关键字是 Python 提供的一个非常通用的错误处理系统的一部分。除了语句之外， try 语句应该总是与匹配的语句一起使用。一般格式如下所示:

try:
    # code here to attempt to execute
except:
    # code here to attempt to recover from the error

运行尝试和之间的代码，除了关键字。如果没有错误发生，除了程序的部分之外的部分被旁路。如果出现错误，将运行除关键字之外的之后的代码。除了最后的和之外，参见。还有一个可选的 else 子句，它可以包含如果 try 子句没有引发错误时将被执行的代码。else 子句必须跟在 except 子句之后。**

虽然

环

关键字 while 创建一个循环，该循环被反复执行，直到某个条件变为真。

cntr = 0
while cntr < 9:
    print cntr
    cntr += 1
0
1
2
3
4
5
6
7
8

同

非托管资源

带有关键字的允许您处理非托管资源，比如文件。如果您需要快速写入一个文件，并确保在代码自动完成时保存它，您可以使用带有关键字的*。在下面的代码片段中，带有关键字的打开输出文件，然后在下面的代码完成处理后，它自动为您关闭文件。*

with open('output.txt','w') as f:
    f.write('Welcome to Python')

产量

迭代器、生成器

返回一个生成器。生成器是创建迭代器的简单而强大的工具。它们像常规函数一样编写，但是每当它们想要返回数据时就使用 yield 语句。每次调用next()时，生成器从它停止的地方继续(它记住所有数据值和最后执行的语句)。在下面的代码示例中，每次循环执行时，它都会自动调用next()语句。

def CreateGen():
    mylist = range(5)
    print mylist
    for i in mylist:
        yield i*i

mygen = CreateGen()
for cntr in mygen:
    print(cntr)

[0, 1, 2, 3, 4]
0
1
4
9
16

假的

评估版(仅限 3.x 版)

在 Python 2.x 中， False 只是一个内置常量。欢迎您覆盖它，事实上，您可以编写以下内容:

False = True

这完全合法。在 3.x 版本中，它被提升为关键字，用来表示“0”。

无

评估，变量(仅限 3.x 版)

None 关键字代表空无一物的概念。如果变量没有赋值，它会自动被赋予一个值无。当创建一个不显式返回值的函数时，该函数返回一个 None 值。

>>> fred = None
>>> print fred
None

真的

评估版(仅限 3.x 版)

在 Python 2.x 中， True 只是一个内置常量。欢迎您覆盖它，事实上，您可以编写以下内容:

True = False

这完全合法。在 3.x 版本中，它被提升为关键字，用于表示“非 0”。

外地

变量(仅限 3.x 版)

类似于全局关键字，但只与函数相关。函数可以有嵌套函数。如果没有非局部关键字，任何声明的变量都具有普通函数的范围，即使它们嵌套在另一个函数中。通过在嵌套函数中使用非局部关键字，变量值可以在嵌套例程中改变。在下面的示例中，有两个函数，每个函数都有一个嵌套函数。除了 Funct1 中的非本地关键字之外，这两个函数是相同的。Funct2 中的变量 test 在 within 函数中有一个局部作用域，因此外部变量 test 不变。然而，在 Funct1 中，它被设置为一个非局部变量，因此外部变量 test 被嵌套在 Funct1 中的 Within 函数修改。

def Funct1():
    test = 1
    def Within():
        nonlocal test
        test = 2
        print("Routine Funct1|Within- test = ", test)
    Within()
    Print("Routine Funct1 – test = ", test)

def Funct2():
    test = 1
    def Within():
        test = 2
        print("Routine Funct2|Within - test = ", test)
    Within()
    print("Routine Funct2 - test = ",test)

Funct2()
Funct1()

Routine Funct2|Within - test = 2
Routine Funct2 - test = 1
Routine Funct1|Within- test = 2
Routine Funct1 - test = 2

转义序列

Python 允许在字符串中嵌入某些字符，如制表符或回车，以便对打印进行额外的控制。有时，字符串需要单引号或双引号，这通常会引起问题。例如，假设您决定使用单引号作为字符串分隔符来创建一个字符串。如果不使用转义序列，字符串中就不能有单引号。虽然您可以使用双引号来分隔字符串，但这可能是一个问题。

>>> test = 'This is a test of the \' (single quote) character'
>>> test
"This is a test of the ' (single quote) character"

转义序列以反斜杠()字符开始，然后是一个字符。这将被 Python 解释为特殊字符。参见表 7-1 。

表 7-1 。转义序列列表

|

换码顺序

|

意义

|
| — | — |
| \ | 反斜杠() |
| ’ | 单引号(') |
| " | 双引号(") |
| \a | ASCII 贝尔(贝尔) |
| \b | ASCII 退格键 |
| \f | ASCII FormFeed （FF） |
| \n | ASCII 换行(左) |
| \N | Unicode 数据库中名为的字符名称 |
| \r | ASCII 字符返回(CR) |
| \t | ASCII 水平制表符(Tab) |
| \uxxxx | 具有 16 位十六进制值的字符(仅限 Unicode) |
| \Uxxxxxxxx | 具有 32 位十六进制值的字符(仅限 Unicode) |
| \v | ASCII 垂直制表符(VT) |
| \ooo | 八进制值为 ooo 的字符 |
| \xhh | 带十六进制值的字符 hh |

八、函数

我们已经展示了 Python 内置的函数。尽管我们可以使用大量的函数，但有时您需要创建自己的函数。在其他一些编程语言中，函数被称为子例程。

函数通常有两个原因。首先是将代码组织成一种逻辑方式来处理某些任务。另一个是能够重用代码。一般的经验法则是，如果你有一个被调用多次的代码块，把它放在一个函数中。

函数的结构

一个函数的结构很简单但是很重要。

def {FunctionName}[(parameters)]: # Function Header
  Indented code..... # Code begins here

函数的头定义了它被调用的方式。头以 def 关键字开始，后面是函数名，然后是可选的参数列表和一个冒号。即使没有参数，也必须在冒号前加上括号(例如，def Toad():)。函数的所有代码都必须缩进。函数名必须遵循相同的变量命名规则(单个单词，无空格，必须以字母或下划线开头，等等)。可选参数列表包含用逗号分隔的变量名(最好不要在其他地方使用)。标题在冒号处结束。

下一行开始于函数代码，必须缩进。

def CountUp(HowHigh):
  for Cntr in range(1,HowHigh+1):
    print(Cntr)

在这种情况下，函数名为 CountUp，并且有一个参数 HowHigh。注意，我们不必声明参数的类型；这将由翻译决定。我们的代码只有两行，一个for循环和一个打印语句。

一些有其他编程语言经验的人可能会说这是一个过程，而不是一个函数，因为它不返回任何东西。在其他一些编程语言中，这可能是真的，但在 Python 中不是。在这种情况下，函数实际上会返回一些东西，None 值。

返回值

有时你的函数需要返回一个或多个值。我们使用 return 关键字来做到这一点。

在下面的例子中，我们定义了一个名为 TestFunction 的函数，它有两个值。代码只是将值返回给调用行。当我们调用函数时，我们分配两个变量(a 和 b)来保存两个返回值。

def TestFunction(val1,val2):
     return val1,val2

a,b = TestFunction(3,2)
print('Returned from function... a = %d, b = %d' % (a,b))

Returned from function... a = 3, b = 2

可选参数

有时你需要提供可选参数的可能性。例如，如果提供了第二个值，您希望添加函数。很多时候，这可能是代码的标志。我们通过为该参数指定一个默认值来实现这一点。在下面的代码片段中，我们定义了一个带有必需参数(val1)和可选参数(val2)的函数，该参数的默认值为 0。如果用一个参数值调用该函数，val2 将默认为 0。关于使用可选或默认参数，有一点需要注意:它们是在函数定义时计算的，而不是在程序运行时计算的。在下面的例子中，我们是安全的，因为我们使用默认值 0。但是，如果您为另一个函数(比如时间)的结果参数设置了默认值，这可能会引起极大的痛苦，让您在键盘上敲上几个小时。

def TestFunction2(val1, val2=0):
    print('Required value = %d' % val1)
    if val2 != 0: # Only print the line below if val2 was provided
        print('Optional value = %d' % val2)

TestFunction2(1) # call function with only one value
print('')
TestFunction2(1,2) # call function with two values

Required value = 1

Required value = 1
Optional value = 2

您可能会意识到，如果 val2 被传递了一个 0，那么第二行就不会打印出来。您可以通过将 val2 的默认值设置为 None 来解决这个问题，如以下代码所示。

def TestFunction2(val1, val2=None):
    print('Required value = %d' % val1)
    if val2 != None:
        print('Optional value = %d' % val2)

TestFunction2(1)
print('')
TestFunction2(1,0)

函数内外的变量

变量在哪里以及如何定义决定了它们何时可以被改变。如果我们在一个函数中定义一个变量或者传递一个值给一个函数，这个变量的值只有在这个函数中才能被访问。这就叫范围。当我们将一个变量传递给一个函数时，实际传递的是对该变量的引用。

例 1

a = 5
def test(a):
    print('A = %d' % a)
    a += 10
    print('A is now %d' % a)

print('A starts with %d' % a)
test(a)
print('After test function a = %d' % a)

这是程序应该做的事情，然后是它的输出。

1. 定义一个名为“a”的变量，并将其赋值为 5。
2. 定义一个名为 test 的函数，该函数采用一个也称为“a”的参数。注意，这不是同一个变量。
3. 一旦我们在函数中，我们打印 a 的值(这里假设 a 是一个十进制数)。
4. 在该值上加 10 并打印新值。这是函数的结尾，我们不返回任何值。
5. 程序实际上是从第一行(a = 5)开始，然后跳过函数，从下一个非缩进的行继续(’ print(‘A 开始。。。’).所以我们给变量 A 赋值 5，然后打印“A 以 5 开始”。
6. 用变量 a 调用函数 test，变量 a 是 5，作为参数。
7. 在函数内部，我们打印“A = 5”，然后加上 10，打印“A 现在是 15”。当我们退出程序时，我们打印“测试后函数 a =”和‘a’的值。

输出

A starts with 5
A = 5
A is now 15
After test function a = 5

如果你对此感到惊讶，你必须记住两件事。变量“a”是在函数外部定义的，即使我们将传入的值更改为 15，该值也是函数的局部变量。我们实际上并没有改变 a。

这可以被视为一把双刃剑。一方面，传递给函数的任何变量中的值都不会被操纵。另一方面，有时我们实际上需要改变那个值。

示例 2

有两种方法可以更改该值。第一种方法是在函数中使用全局关键字。第二个是返回值。

使用全局关键字

a = 1
def test1():
    a = 42
    print('Inside test1...a = %d' % a)

def test2():
    global a
    a = a + 1
    print('Inside test2...a = %d' % a)
print('a starts at %d' % a)
test1()
print('After test1, a is now %d' % a)
test2()
print('After test2, a is now %d' % a)

1. 首先我们定义一个变量'a'，并给它赋值 1。
2. 接下来我们定义两个函数，test1和test2。它们都不接受参数
3. 在test1函数中，我们给一个变量'a'赋值，并给它赋值 42，然后打印这个值。记住这个变量'a'有一个不同的作用域，严格来说只能在这个函数中使用。
4. 在test2中，我们在定义变量'a'时使用了全局关键字。这一次，因为我们使用了global关键字，所以我们说任何时候我们使用变量'a'，它应该指的是全局变量，而不是局部变量。现在，例程中变量'a'的任何变化都会改变第一行代码中声明的变量。
5. 现在代码继续并将打印“a starts at 1”，继续调用函数test1，它创建自己的变量'a'，给它赋值 42 并打印。
6. 当我们从那回来时，我们打印“After test1, a is now 1”。
7. 接下来调用函数test2。因为我们已经声明了函数中的变量'a'是全局变量，所以它被改为 2，我们进行打印，然后从函数返回时，我们得到“After test2, a is now 2”。

输出

a starts at 1
Inside test1...a = 42
After test1, a is now 1
Inside test2...a = 2
After test2, a is now 2

返回值

这是我们之前使用的同一个程序，但是做了修改以返回改变的变量。

a = 5
def test(a):
    print('A = %d' % a)
    a += 10
    print('A is now %d' % a)
    return a

print('A starts with %d' % a)
a = test(a)
print('After test function a = %d' % a)

1. 您可以看到，我们只添加了一行(“return a”行)，并通过分配变量来获取返回值，从而修改了对测试函数的调用。
2. 当这个程序运行时。。。我们给变量'a'赋值 5，把它传递给test函数。
3. 它打印刚刚传入的值，将其递增 10，打印新值(15)，然后返回新值，该新值由对函数的调用接收，并将值'a'从 5 更改为 15。

输出

A starts with 5
A = 5
A is now 15
After test function a = 15

剖析 Python 程序

让我们回顾一下结构和一个实际的例子。

简单程序的结构

一个简单的 python 程序 有如下结构:

Shared Variable Declarations
Functions
Main Routine

真实的例子

所以它看起来会像这样:

a = 24
b = 42

def function1(varA,varB):
    print(varA,varB)

def main():
    function1(a,b)

#...

main()

在这个程序示例中:

1. 我们声明变量'a'和'b',使它们在范围上是全局的。
2. 接下来我们声明两个函数，一个叫做’function1’，一个叫做'main'。
3. 带有省略号的注释行只是表明在它下面可能有更多的函数。
4. 最后一行调用函数’main’来启动程序。

这个通用模板的例外是，如果我们正在编写一个包含类的程序，这将在第十章详细讨论。

九、库

Python 有大量可用的库，既有标准安装自带的，也有 web 上提供的。在这一章中，我将试着给你一个更“一般”有用的列表。大多数信息都是从官方的 Python 文档页面获得的。

字符串服务

Thes 库提供了各种工具来处理字符串格式、正则表达式、作为文件的字符串、Unicode 字符串等等。

字符串—常见的字符串操作

string library 包含许多有用的常量和类，以及一些不推荐使用的遗留函数，这些函数也可用作 string 上的方法。

正则表达式运算

re 库提供了类似于 Perl 语言中的正则表达式匹配操作。要搜索的模式和字符串可以是 Unicode 字符串，也可以是 8 位字符串。

StringIO—将字符串作为文件读写

StringIO 库实现了一个 filelike 类，用于读写字符串缓冲区或内存文件(仅限 2.x)。

数据类型

这些库 提供了专门的数据类型，比如日期和时间、固定类型数组、队列和集合。

日期时间—基本日期和时间类型

包括时间、日期、时区和格式化的时间/日期信息等对象。

集合-扩展 Python 的集合功能

提供用于构造和操作无序集合的类。

pprint—数据漂亮打印机

提供“漂亮打印”数据的能力。

数字和数学库

提供数字和数学相关的函数和数据类型。

数字—数字抽象基数

定义数值基类的层次结构。

十进制—十进制定点和浮点运算

提供了几个优于普通“浮点”数据类型的优点。

数学—数学函数

提供 floor、ceil、三角函数等函数。

随机—生成伪随机数

随机库还提供随机播放、随机采样等功能。

文件和目录访问

提供用于处理磁盘文件和目录的库。

OS . path—常见的路径名操作

在路径名上实现有用的函数。

fileinput 迭代输入流中的行

提供助手类和函数来快速编写标准输入或文件列表的循环。

日期持久性

支持在磁盘上以持久形式存储 Python 数据。

pickle—Python 对象序列化

实现强大的算法来序列化和反序列化 Python 对象结构。

any dbm——对 DBM 式数据库的通用访问

各种 DBM 数据库的通用接口。这个库在 Python 3.x 中被重命名为 dbm。

SQLite 3—SQLite 数据库的 API 接口

为 SQLite 数据库提供 SQL 接口。

数据压缩和归档

支持 zlib、gzip、bzip2 算法的数据压缩，并创建 zip 和 tar 格式的档案。

zlib—压缩兼容 gzip

允许使用 zlib 库压缩和解压缩档案。

gzip—支持 gzip 文件

压缩和解压缩文件的简单接口，如 gzip 和 gunzip 程序。

bz2—与 bzip2 压缩兼容

为 bz2 压缩库提供了全面的接口。

ZIP file—使用 ZIP 存档

提供创建、读取、写入、追加和列出 ZIP 文件的工具。

文件格式

这些库解析各种各样的文件格式，它们不是标记语言或者与电子邮件无关。

csv—CSV 文件读取和写入

实现类来读写 CSV(逗号分隔变量)文件中的表格数据。

config Parser—配置文件解析器

实现基本的配置文件分析器语言，它提供了类似于 Microsoft Windows INI 文件的结构。这个库在 Python 3.x 中被重命名为 configparser。

加密服务

这组库模块实现了各种密码性质的算法。

hashlib—安全散列和消息摘要算法

为许多不同的安全哈希和消息算法实现一个通用接口。

md5—MD5 消息摘要算法

实现 RSA 的 MD5 算法的接口。

sha—SHA-1 消息摘要算法

实现 NIST 安全哈希算法的接口。

通用操作系统服务

本节中有许多库提供了操作系统功能的接口。

OS—各种操作系统接口。

这个库提供了一种使用操作相关功能的可移植方式。提供 chdir、getenv、文件打开和文件关闭等功能。

io——处理流的核心工具

为流处理提供 Python 接口。

时间—时间访问和转换

提供各种与时间相关的功能。

arg parse—命令行选项、参数和子命令的解析器

提供了一个简单的方法来编写命令行界面处理。

curses—字符显示的终端处理

提供 curses 库的接口，用于便携式高级终端处理。在终端或命令窗口中提供彩色文本、位置打印和屏幕清除等功能。

日志记录 Python 的日志记录库

日志库提供了实现灵活事件日志系统的函数和类。对调试非常有用。

可选的操作系统服务

为通常模仿 Unix 接口的操作系统功能提供接口。

穿线

提供更高级别的线程接口。

多重处理—基于进程的“线程”接口

使用类似于线程库的 API 提供对 spawing 处理的支持。

读取线—GNU 读取线接口

提供了许多功能来帮助完成和读/写历史文件。

进程间通信和网络

socket—低层网络接口

提供对 BSD 套接字接口的访问。

SSL—套接字对象的 TLS/SSL 包装器

为网络套接字提供对传输层安全性(安全套接字层)加密的访问。

popen 2—具有可访问 I/O 流的子进程

提供在 Unix 和 Windows 下产生进程和连接到 IO 管道的例程。

互联网数据处理

提供支持处理 Internet 上常用数据格式的库。

电子邮件—电子邮件和 MIME 处理包

用于管理电子邮件的库。

JSON——基于 JavaScript 子集的轻量级数据交换格式

公开封送和 pickle 库的用户熟悉的 API。

uu—编码和解码 uuencoded 文件

提供编码和解码 uuencode 格式文件的能力。

结构化标记处理工具

为使用各种形式的结构化数据标记提供支持。

HTML 解析器—简单的 HTML 和 XHTML 解析器

为解析 HTML 和 XHTML 格式的文本文件提供基础。HTMLParser 在 Python 3.x 中已重命名为 html.parser。

HTML lib—HTML 文档的解析器

提供一个允许分析 HTML 格式的文本文件的类。在 Python 3 中移除。

XML . etree . element tree-element tree XML API

提供处理 xml 文件的灵活容器对象。

XML . DOM—文档对象模块 API

提供了一种处理 DOM XML 文件的简单方法。

XML . sax—支持 SAX2 解析器

为 SAX 提供了许多库。

互联网协议和支持

提供实现互联网协议和支持相关技术的库。

网络浏览器—便捷的网络浏览器控制器

提供一个高级界面，允许向用户显示基于 Web 的文档。

CGI—通用网关接口支持

通用网关接口(CGI)脚本支持库。

URL lib—通过 URL 打开任意资源

为在万维网上获取数据提供了一个高级接口。在 Python 3 中已拆分为多个部分并重命名，分别命名为 urllib.request、urllib.parse 和 urllib.error. urllib.urlopen()函数在 Python 3.x 中已被删除，取而代之的是 urllib2.urlopen()。

URL lib 2—用于打开 urs 的可扩展库

提供帮助打开 URL 的函数和类。在 Python 3 中被拆分为几个名为 urllib.request 和 urllib.error 的模块。

弹出式菜单—POP3 协议客户端

提供允许连接到 POP3 服务器的类。

多媒体服务

实现对多媒体应用有用的各种算法或接口。

音频操作—处理原始音频数据

为声音片段提供有用的例程。

wave 读写 WAV 文件

为 WAV 声音格式提供一个方便的接口。

国际化

提供独立于语言和区域设置的库。

gettext—多语言国际化服务

用 API 提供国际化和本地化服务。

语言环境—国际化服务

提供对 POSIX 本地数据库和功能的访问。

程序框架

这组库是面向编写命令行界面的框架。

cmd—支持面向行的命令解释器

为编写面向行的命令解释器提供了一个简单的框架。这些通常对测试工具、管理工具和原型很有用。

shlex—简单词法分析

shlex 类使得为类似于 Unix shell 的简单语法编写词法分析器变得容易。

带有 Tk 的图形用户界面

Tk/Tcl 早已成为 Python 不可或缺的一部分。它提供了一个健壮的、独立于平台的窗口工具包。

tkinter——Tcl/Tk 的 Python 接口

Tkinter 库是 Tk GUI 工具包的标准 Python。

ttk—以传统知识为主题的部件

ttk 库提供了对 tk 主题小部件集的访问。

乌龟——代表传统知识的乌龟图形

海龟图形是向孩子们介绍编程的一种流行方式。它是 1966 年由沃利·弗兹格和西蒙·派珀特开发的原始标志编程语言的一部分。

开发工具

pydoc—文档生成器和在线帮助系统

从 Python 库自动生成文档。文档可以在终端或命令窗口中显示为文本页面，也可以保存为 HTML 文件。

单元测试—单元测试框架

支持测试自动化，将测试聚合到集合中。

2to 3—自动化的 Python 2 到 Python 3 代码翻译

一个 Python 程序，它读取 Python 2.x 源代码，并应用一系列“修复程序”将其转换为有效的 Python 3.x 代码集。

调试和分析

本节中的库有助于 Python 开发。调试器使您能够逐句通过代码、分析堆栈帧和设置断点等等。

pdb—Python 调试器

这个库为 Python 程序定义了一个交互式源代码调试器。它支持在源代码行级别设置断点和单步执行。

hot shot—高性能日志探查器

这个库为 hotshot C 库提供了一个更好的接口。

time it—测量小代码片段的执行时间

这个库提供了一种简单的方法来计算 Python 代码的时间。

跟踪-跟踪或追踪 Python 语句的执行

这个库允许你跟踪程序的执行，生成带注释的语句覆盖列表，打印调用者/被调用者的关系，以及列出程序运行过程中执行的函数。

Python 运行时服务

这些库提供了与 Python 解释器及其环境交互相关的广泛服务。

sys—系统特定的参数和功能

这个库提供了对与解释器交互的变量和函数的访问。

警告-警告控制

支持在某些情况下使用警告消息，这有助于提醒用户程序中的某些情况，而这些情况通常不允许引发异常并终止程序。

自定义 Python 解释器

本节中的库允许编写类似于 Pythons 交互式解释器的接口。

codeop

提供可以模拟 Python 读取-评估-打印循环的工具。

代码-解释器基类

提供在 Python 中实现读取-求值-打印循环的工具。

导入库

这些库提供了导入其他 Python 库和钩子的新方法，用于定制导入过程。

Zip Import—从 Zip 存档中导入库

添加了从 Zip 格式的归档文件中导入 Python 库和包的功能。

runpy—定位和执行 Python 库

该库用于定位和运行 Python 库，而无需先导入它们。

Python 语言服务

帮助使用 Python 语言的库。

解析器-访问 Python 解析树

这个库提供了 Python 内部解析器和字节码编译器的接口。

tab nanny—检测不明确的缩进。

这个库旨在作为一个脚本被调用来检查源文件中的空白。

微软视窗特定服务

这些库仅在 MS Windows 平台上可用。

msilib—读取和写入 Microsoft 安装程序文件

支持创建 Microsoft 安装程序(。msi)文件。

_winreg —Windows 注册表访问

这个库向 Python 公开了 Windows 注册表 API。

winsound—Windows 的声音播放界面

提供对 Windows 平台提供的基本声音播放功能的访问。

Unix 特定服务

这些库提供了 Unix 操作系统特有的功能接口。

posix—最常见的 POSIX 系统调用

该库提供对由 C 标准和 POSIX 标准标准化的操作系统功能的访问。不要直接导入此库。相反，导入提供该接口的可移植版本的 os 库。

密码数据库

该库提供对 Unix 用户帐户和密码数据库的访问。

tty 终端控制功能

这个库定义了将 tty 置于 cbrake 和 raw 模式的函数。

Mac OS X

Thes 库仅在 Mac OS X 平台上可用。当 Python 在 64 位模式下执行时，其中许多库不可用，并且在 Python 3.x 中已被移除

MacOs 访问 Mac OS 解释器功能

这个库提供了对 Python 解释器中 MacOS 特定功能的访问。已在 Python 3.x 中移除。

简易对话框—基本的 Macintosh 对话框

包含 Macintosh 的简单对话框。Python 3.x 中已经移除了这个库。

MacPython OSA 库

这些库支持 Python 的开放脚本架构(OSA)的实现。

aetools —OSA 客户支持

此资源库包含 Python AppleScript 客户端的基本功能。在 Python 3.x 中移除。

AE pack—Python 变量和 AppleEvent 数据容器之间的转换

这个库定义了在 Python 变量和 AppleEvent 之间来回转换的函数。在 Python 3.x 中移除。

SGI IRIX 特定服务

Libries 提供 SGI 的 IRIX 操作系统 版本 4 和 5 独有的功能。

GL—图形库接口

提供对硅图形图形库的访问。它只在 SGI 机器上可用，在 Python 3.x 中已经被删除。

al—SGI 上的音频功能

提供对 SGI Indy 和 Indigo 工作站音频设备的访问。已在 Python 3.x 中移除。

SunOS 特定服务

提供特定于 SunOS 5 (又名 Solaris 版本 2)的库。

sunaudiodev—访问 Sun 音频硬件

提供对 Sun 音频接口的访问。已在 Python 3.x 中移除。