Python-快速语法参考-全-
Python 快速语法参考（全）
零、简介
Python 提供的最好的东西之一是一个广泛的标准库，它提供了广泛的包含特性，从网络功能、数据库处理和 XML 处理一直到 zip 文件处理。有数百个额外的库扩展了 Python 的能力。
撰写本文时可用的 Python 当前版本是 2.7 和 3.2.5。其原因是 3.x 版本并不完全向后兼容早期版本，而且由于目前每天都在使用大量的现有代码和库，这两个版本都是可用的。你可以在 www.python.org 找到 Windows、Linux/Unix 和 Mac OS X 操作系统的这些版本。如果您运行的是 Linux，您可以检查您的正态分布，它将有一个可用的 Python 版本。它可能已经安装在您的系统上。您可以在网上搜索适用于其他操作系统的版本。
尽管 Python 有许多免费和收费的 ide(集成开发编辑器),但所有代码都可以在标准文本编辑器中编写，并在标准终端或命令框中从命令行运行。我个人比较喜欢的是一个名为 Geany 的免费 IDE，Linux 和 Windows 都有。
本书的目标是提供(顾名思义)Python 语言语法的快速指南。有时，程序员需要了解多种语言，而一种编程语言与另一种编程语言之间的差异可能足以引起问题。本指南旨在提供一种快速获得答案的方式，而不是放在书架上，而是放在桌子上。
你会找到关于数据结构、关键字、字符串、变量等的章节。几乎每一个 Python 发行版都有一章介绍一些更有用的标准库。
本书中使用的约定
这里介绍的几乎所有代码都是显示如何使用特定命令或函数的简单示例，并且可以在解释器 shell 中运行。代码如下所示，shell 的输出或响应以粗体显示。
print('This is a test')
This is a test
如果您看到一行以“> > >”开头的代码，这将显示来自解释器 shell 的提示。不要把它插入你的代码，只插入它后面的部分。如果你看到一行以“，”开头的代码。。."，这表明 shell 认为这是一个应该缩进的行。同样，不要在代码中插入点。请记住，您必须缩进这部分代码。
一、你好 Python
让我们回顾一个简单的 Python 程序，它将解释 Python 交互式 Shell 的使用以及一些技巧。
Python 的交互外壳
一旦在您的系统上安装了 Python，您就可以使用交互式 Shell 来尝试简单的代码行，调试一些有问题的代码，甚至可以将它用作简单的计算器。
在终端(Linux)或命令提示符(Windows)中，只需键入:
python
如果你运行在 Linux 上，你会看到类似这样的东西:
Python 2.7.3 (default, Apr 10 2013, 05:09:49)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
或者，如果您运行的是 Windows ，您会看到类似这样的内容:
Python 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
如你所见，两者没有太大的区别。
命令
一旦你看到三个“右箭头”符号(>>>)，你就进入了用户提示界面。从这里您可以输入命令:
>>> 3+23
26
>>> print "This is a test of the interactive mode"
This is a test of the interactive mode
>>> a = 3
>>> b = 4
>>> print a * b
12
>>> print a + b
7
>>> exit()
多行语句
你也可以输入缩进的多行语句，如循环的或 if 语句(这将在后面的章节中讨论)。例如:
>>> for i in range(0,3):
... print i
...
0
1
2
当您在多行语句中时，解释器将自动识别这一点(通过":"冒号)并用三个点而不是三个右箭头提示您。确保使用空格来缩进下一行。要结束多行模式，只需在空白行上按“enter”。然后将对您的多行语句进行评估(如果可能)，并显示结果。
如前所示，要退出交互式 shell，请键入“exit()”。
代码
我知道你正迫不及待地想写你的第一个程序，所以我们从一个简单的例子开始。假设您的机器上安装了 Python，启动您最喜欢的文本编辑器输入以下几行:
print 'Hello. I am a Python program.'
name = raw_input("What is your name? ")
print 'Hello there ' + name + '!'
你可以把它保存为“hello.py”。我建议您在主目录下创建一个子文件夹来存储所有的测试代码，如下所示:
C:\
|-Development
|-Tests
现在，在命令或终端窗口中，切换到保存上述文件的文件夹，并键入:
python hello.py
你应该看到这样的东西:
`greg@earth:∼$ python hello.py`
`Hello. I am a Python program.`
`What is your name?` *Greg* (The program pauses here for you to enter your name)
`Hello there Greg!`
或者在 Windows 下:
`C:\> python hello.py`
`Hello. I am a Python program.`
`What is your name?` *Greg* (The program pauses here for you to enter your name)
`Hello there Greg!`
解码代码
让我们看看每一行代码。
print 'Hello. I am a Python program.'
print 命令将输出到终端或命令提示符框中。
在这种情况下，我们告诉 Python 显示“Hello。我是 Python 程序。”请注意，我们想要显示的内容在代码的单引号中。可以用单引号或双引号将字符串括起来。但是，当您想要在显示字符串中显示单引号时，应该使用双引号将整个字符串括起来。如果要在显示字符串中显示双引号，应该用单引号将字符串括起来。我们将在第四章中讨论这个问题。
name = raw_input("What is your name? ")
这里我们做两件事。首先，我们使用 raw_input 命令告诉 Python 向用户显示一个提示(“你叫什么名字？”部分)然后等待用户输入一些东西，哪怕是简单的“enter”键输入一个空白输入。对你来说，在问号之后和结束引用之前包含空格是很重要的。这给了程序一个更清晰的外观，因为最终用户知道他们需要做些什么。我们正在做的第二件事是将用户的响应分配给一个名为“name”的变量。我们将在第二章中进一步讨论变量。现在，把变量想象成一个简单的盒子，里面装着一些东西。在这种情况下，它将保存用户的姓名:
print 'Hello there ' + name + '!'
同样，我们告诉 Python 在终端窗口中显示一行，但是这一次我们用三个文本字符串来创建这一行。这叫做串联。加号(“+”)用于将线条的各个部分连接在一起。所以我们有“你好”和用户名和 a "！"。
评论
注释允许我们在代码中添加注释。当解释器遇到一个注释时，它会忽略该行的其余部分。很好地注释你的代码来解释它背后的思想过程被认为是一个好的实践。如果你不得不在一周左右后回到你的代码，这些注释将帮助你记住你在做什么。它也允许其他人理解你的代码。
要创建注释行，只需用散列符号(#)开始注释。以下行是注释行的示例:
# This is a full line comment.
aVariable = 23 # this is an in-line comment.
重要的是要记住，哈希符号后面的任何内容都被视为注释。您还可以使用三重双引号(" ")将多行注释括起来。
"""
This is an example of a multiline comment.
Everything between the sets of triple double quotes is considered a comment.
"""
注释还允许我们告诉解释器忽略可能给我们带来问题的代码行或不完整的代码块。
二、变量
变量是我们可以存储数据的“插槽”。一些语言，如 C#、Visual Basic 和其他语言，要求您在使用变量之前声明变量以及变量的类型，例如 Integer 或 String。Python 并不要求你这样做。正如我在介绍中所说的，Python 使用了一种叫做“鸭子类型化”的方案。这意味着您不必在使用变量之前声明它们，也不必指定什么是类型变量。关于这件事是好是坏，众说纷纭。
区分大小写
变量名必须以字母(大写或小写)或下划线字符开头。它们不能以数字、空格或符号字符开头。
Python 中的一切都是区分大小写的:不仅是 Python 提供的关键字和函数，而且是您碰巧创建的任何变量。例如:
“打印”和“印刷”不一样。
因此，您可以使用单词“print”作为变量，但不能使用单词“Print”话虽如此，使用“重新封装”的函数名或关键字并不是一个好主意。
正确的变量命名
变量名应该解释变量的用途。如果您使用诸如“x”或“q”之类的变量名，它不会告诉您任何关于变量的作用或用途的信息。这被称为“自我记录”很久以前，尽可能使用单字符变量名是“正常”的做法。很多时候是为了节省内存。虽然没有规定不能使用单个字母或一些晦涩的变量名(而且在键入大量代码时确实可以节省时间和手指的力量)，但这将使您或其他人很难在事后阅读和维护您的代码。
因为变量名中不允许有空格，所以很多人使用所谓的骆驼大小写来使变量名更容易理解。骆驼大小写(有时也称为帕斯卡大小写)表示您将每个单词的第一个字母大写，其余字母小写:
ThisIsAnExampleOfCamelCasingForVariables.
CounterVariable
ReturnedValue
另一种方法是用下划线代替空格:
this_is_an_example_of_a_long_variable_name
counter_variable
returned_value
任何一种方式都是“可以接受的”主要看你想用什么或者你的作品用什么作为标准。正如我前面提到的，使用“自我记录”的变量名是很重要的
转让
要为变量赋值，请使用等号(“=”):
AnInteger = 3
AFloatValue = 3.14159
AString = “The time has come for all good men…”
TheList = [1,2,3,4,5]
您也可以在一行中对一个值进行多次赋值。在下面的代码片段中，变量“a”被赋值为 1。那么变量‘b’和‘c’被赋值为等于变量‘a:’
>>> a = 1
>>> b = c = a
>>> print('a=%d, b=%d, c=%d') % (a,b,c)
`a=1, b=1, c=1`
数据类型
Python 有五种“标准”数据类型:数字、字符串、列表、元组和字典。
数字
数字数据类型用于存储数值。在 Python 2.x 中，有四种类型的数字数据:整数(有符号)、长整型(有符号)、浮点型(浮点数)和复数。在 2.x 版中，布尔值(0 或 1)是整数的子类型。可以存储在任何不同数字类型中的值的实际范围会因系统而异。在我的 Windows 机器上，一个整数的最大值是 2，147，483，647。通过在 Python 交互式 Shell 会话中使用以下代码，可以找到系统中某个整数的实际最大值:
import sys
print sys.maxint
2147483647 *(My system)*
十六进制、八进制和二进制数字也属于数字数据类型。
十六进制数以 16 为基数。它们的范围从 0 到 9 和 A 到 f。八进制数是以 8 为基数的数。它们的范围从 0 到 7。二进制数是以 2 为基数的数，只包括 0 和 1。以下是每种方法的示例:
十六进制 - 1B = 27（十进制）
八进制 - 033 = 27（十进制）
二进制- 00011011 = 27(十进制)
字符串
字符串数据类型是由引号(单引号或双引号)分隔的一系列字符。字符串将在第四章中单独讨论。字符串的示例包括:
'This is a string'
"3.14159"
列表、元组和字典将在第六章中讨论，但是现在这里有一个快速的描述。
列表
列表是一种创建多个值的方法，这些值由具有从零开始的索引的单个变量名引用，类似于其他编程语言中的数组。列表使用方括号(“[ ]”)来定义它们。一个例子是:
ColorList = ['Red','Orange','Yellow','Green','Blue','Purple']
ColorList[2]将是值“黄色”
元组
元组是由逗号分隔的多个值。元组中的数据可以由数字、字符串甚至其他对象组成:
t = 3,42,'The time has come for all good men'
像列表一样，元组由从零开始的索引引用。t[1]将是值“42”。
词典
字典就像记忆中的迷你数据库。字典中的每个条目都有两个部分:一个键和值。每个条目(通常)通过它的键来引用。字典用花括号来定义它们:
dict = {"Fname":"Jack","LName":"Sprat"}
在这个例子中,‘dict’字典中有两组数据。“Fname”是值“Jack”的键,“LName”是值“Sprat”的键。
数据类型转换
有几个内置函数可以执行从一种数据类型到另一种数据类型的转换。
int(s，[base])
从字符串 s 返回一个整数，如果提供了 base，则指定用于转换的基数。如果字符串不是一个值(二进制、十六进制、八进制、整数、长整型等。)，你会收到一个错误。
>>> int('1001',2)
9
>>> int('FA',16)
250
long(s，[base])
从字符串 s 中返回一个长整数，如果提供了 base，它将指定转换时使用的基数。如果字符串不是有效的数字，它将返回一个错误。
>>> long(30219568420)
30219568420L
浮动
从字符串 s 中返回一个浮点数，如果该字符串不是有效数字，将返回一个错误。
>>> d = '3.14159'
>>> e = float(d)
>>> e
3.14159
复杂的(实的[，虚的])
创建一个复数。
>>> complex(3.14159)
`(3.14159+0j)`
>>> complex(-123.45)
(-123.45+0j)
`>>> complex(32,43)`
`(32+43j)`
str(x)
基于数值 x 返回一个字符串。如果(x)不是一个有效的数字，该函数将返回一个错误。
>>> str(3.14159)
'3.14159'
元组
基于序列 s 返回一个元组，该序列应该类似于字符串或列表。
>>> tuple([3,5,7])
`(3, 5, 7)`
`>>> tuple('abcd')`
`('a', 'b', 'c', 'd')`
列表
返回一个基于序列的列表，该序列应该类似于字符串或元组。
>>> list((1,2,3))
`[1, 2, 3]`
`>>> list('abcd')`
`['a', 'b', 'c', 'd']`
设定(l)
返回基于序列 l 的集合。序列 l 必须是列表。
>>> set([7,3,11])
`set([11, 3, 7])`
字典(必须是(键，值)元组序列)
从元组列表中返回字典。
>>> dict([('fname','fred'),('value',1)])
`{'value': 1, 'fname': 'fred'}`
冰冻圈
返回从集合 s 创建的 frozenset。
>>> s = set([7,3,1])
>>> frozenset(s)
`frozenset([1, 3, 7])`
chr(x)
返回从 0 到 255 范围内的整数 x 创建的字符。
>>> chr(65)
'A'
unihr(x)
返回从 0 到 0x10000 范围内(在大多数机器上)的整数 x 创建的 unicode 字符。
>>> unichr(1000)
`u'\u03e8'`
字数（c）
返回字符 c 的 ascii 值。
>>> ord('M')
77
十六进制
返回从整数 x 创建的十六进制字符串。
>>> hex(23)
'0x17'
十月十日
返回从整数 x 创建的八进制字符串。
>>> oct(32)
'040'
三、运算符
Python 支持几个运算符。在这里，我们回顾一些关键的。
算术运算符
我们使用算术运算符对两个变量或文字进行简单的数学运算。确保只尝试在相似的类型上使用算术运算符。例如，如果您试图将一个字符串值加到一个整数上(3 +“是一个数字”)，您将会得到一个错误。
+加法
将左边的值加到右边:
>>> lvariable = 5
>>> sum = lvariable + 3
>>> sum
8
—减法
从左减去右值:
>>> lvariable = 5
>>> difference = lvariable - 3
>>> difference
2
*乘法
将左值乘以右值:
>>> lvariable = 5
>>> product = lvariable * 3
>>> product
15
/分部
将左值除以右值。整数除以整数得出一个整数。右侧值不能为零:
>>> quotient = 5 / 3 # integer/integer
>>> quotient
1
>>> quotient = 5.2 / 3.1 # float/float
>>> quotient
1.6774193548387097
>>> quotient = 3.14159 / 7 # float/integer
>>> quotient
0.44879857142857144
>>> quotient = 7 / 3.14159 # integer/float
>>> quotient
2.2281710853421357
>>> quotient = 5 / 0
`Traceback (most recent call last):`
`File "<stdin>", line 1, in <module>`
`ZeroDivisionError: integer division or modulo by zero`
%模量
将左值除以右并返回余数:
>>> remainder = 5 % 3
>>> remainder
2
>>> remainder = 3 % 5
>>> remainder
3
**指数
左值的右幂:
>>> exp = 2 ** 3
>>> exp
8
>>> exp = 2.1 ** 3
>>> exp
9.261000000000001
//楼层划分
除法，但小数值向下舍入到最接近的整数:
>>> quotient = 5.2 // 3.1
>>> quotient
1.0
比较运算符
当我们想要比较两个值时，比如在等式中(a 等于 b)，我们使用比较运算符。与许多其他编程语言不同，Python 比较运算符可能会有所不同。
在以下示例中，假设如下:
a = 5
b = 3
==
检查左变量是否等于右变量。请注意，在使用浮点数(floats)时，由于浮点数在 Python 中的存储方式，计算有时会不像您预期的那样进行。当您需要精确计算时，请使用十进制库:
>>> print(a == b)
`False`
>>> test = 1.1+2.2
>>> test == 3.3
`False # test is actually 3.3000000000000003`
==(字符串)
字符串、列表和其他对象的比较与数字的比较非常相似:
Str1 = "This is a test"
Str2 = "This was a test"
Str1 == Str2
`False`
Lst1 = [1,2,3,4]
Lst2 = Lst1
Lst2 == Lst1
`True`
！=
检查左变量是否不等于右变量(3.x 和 2.x):
Python 2.x
>>> print(a != b)
True
Python 3.x
>>> print(a != b)
True
<>
检查左变量是否不等于右变量(仅限 2.x):
Python 2.x
>>> print(a <> b)
True
Python 3.x (use !=)
>>> print(a <> b)
`File "<stdin>", line 1`
`print(a <> b)`
`^`
`SyntaxError: invalid syntax`
检查左侧变量是否大于右侧变量:
>>> print(a > b)
True
<
检查左侧变量是否小于右侧变量:
>>> print(a < b)
False
=
检查左侧变量是否大于或等于右侧变量:
>>> print(a >= b)
`True`
<=
检查左侧变量是否小于或等于右侧变量:
>>> print(a <= b)
`False`
赋值运算符
正如我们前面看到的，赋值操作符给变量赋值和/或修改变量的值。
=
赋值运算符。将右边的值赋给左边的变量:
>>> a = 3
>>> a
3
+=
添加、赋值或递增运算符。从右向左变量添加值:
>>> a = 3
>>> a += 3
>>> a
6
−=
减法和赋值或减量运算符。从左侧变量中减去右侧的值:
>>> a = 3
>>> a -= 2
>>> a
1
*=
乘法和赋值。将右值乘以左值:
>>> a = 3
>>> a *= 2
>>> a
6
/=
分而治之。将右值除以左值:
>>> a = 3
>>> a /= 2.0
>>> a
1.5
%=
模数和赋值:
>>> a = 3
>>> a %= 2
>>> a
1
**=
指数和赋值:
>>> a = 3
>>> a **= 2
>>> a
9
//=
楼层划分和分配:
>>> a = 5.0
>>> a //= 3.0
>>> a
1.0
逻辑运算符
Python 为逻辑运算提供了三种运算符:and、or 和 not。这些运算符允许我们比较两个值，而不必依赖正常的等式考虑。你可以把逻辑运算符看作是一种高级的二进制计算。
和
逻辑 AND–如果两个值都为真(或在许多情况下为非零)，则返回真值:
a = 0
b = 8
if (a and b):
print 'true'
else:
print 'false'
`False`
或者
逻辑 OR–如果任一值为真，则返回真值:
a = 0
b = 8
if (a or b):
print 'true'
else:
print 'false'
`True`
没有
逻辑非–反转运算符。真变假，假变真:
a = 0
b = 8
if not(a and b):
print 'true'
else:
print 'false'
`True`
成员和身份操作符
我们使用成员操作符来测试一个特定的值是否是一个特定对象(比如一个列表或字典)的成员。identity 运算符检查这两个对象是否相同。
在…里
如果 x 在 y 中，则返回 True:
>>> a = "This is the time"
>>> 'is' in a
`True`
>>> lst = [1,2,4,7,9]
>>> 2 in lst
`True`
>>> 8 in lst
`False`
不在
如果 x 不在 y 中，则返回 True:
>>> a = "This is the time"
>>> 'frog' not in a
`True`
存在
如果两边的变量引用同一个对象，则返回 True:
>>> c = list(['a','b','c'])
>>> d = c
>>> c is d
`True`
不是
如果每一侧的变量都引用同一个对象，则返回 False:
>>> c = list(['a','b','c'])
>>> d = c
>>> c is not d
`False`
按位运算符
这些运算符对二进制值执行逐位运算。
二进制数由称为位的 1 和 0 组成。在 4 位二进制数中，该值的范围是从 0 到 15。在 8 位数字中，该值的范围是从 0 到 255。每个位位置都有一个从右到左的值。任何位置的 1 都会被计算成标准的十进制数。对于 4 位数字，位置是 1，2，4，8。很容易看出每个位置的值都加倍了。
0000 0
0001 1
0010 2
0011 3
0100 4
…
在以下示例中，假设如下:
a = 00011000 (24)
b = 00001000 (8)
&
二进制与
逐位比较这两个值；如果在任一给定位置两位都为 1，则该位位置的结果为 1:
>>> a & b
`8 (00001000)`
00011000
00001000
`Equals`
`00001000 (8)`
|
二元或
逐位比较这两个值，如果在任何给定位置任一位为 1，则该位位置的结果为 1:
>>> a | b
`24 (00011000)`
00011000
00001000
`Equals`
`00011000 (24)`
^
二进制异或。
逐位比较两个值，如果任一位为 1 but not both bits，则该位的结果为 1:
>>> a ^ b
`16 (00010000)`
00011000
00001000
`Equals`
`00010000 (16)`
你是谁
二进制一补码。
一补码定义为通过反转数字中的所有位获得的值。这在某些算术运算中表现为原始值的负值:
a = 24 (00011000)
>>> ∼a
`-25`
`(11100111)`
<<
二进制左移。
将所有位向左移位。在右侧插入零:
>>> a << 2
`96 (00011000 Shift Left 2 = 01100000 = 64 + 32 = 96)`
二进制右移。
将所有位向右移动 x 个位置。在左侧插入零:
>>> a >> 2
`6 (00011000 Shift Right 2 = 00000110 = 2 + 4 = 6)`
运算符的优先级
运算符的优先级是各种运算符在计算中的处理顺序。
例如:如果计算结果是 3 + 5 * 4 + 6，那么答案就是 29。乘法优先于加法，所以这个公式分解为 20 + 9 (5 * 4) + (3 + 6)。
使用括号总是会覆盖求值的优先级:
(3 + 5) * (4 + 6) = 112
3+5*4+10 = 33 (3 + 20 (5*4) + 10)
以下列表显示了运算符的优先级，从最低到最高:
- λ(在第七章的中讨论)
- If - else(在第五章中讨论)
- 或者
- 和
- 不是 x
- 在，不在，是，不是
- |
- ^
- &
- << , >>
-
- , −
- *, / , //, %
- +x，-
- x[索引]，x[索引:索引]，x(参数…)，x .属性
- (表达式…)，[表达式…]，{key:值…}，'表达式…'
- ()
四、字符串
字符串对象实际上存在于每一种编程语言中。字符串就是赋给变量的一系列字符。Python 字符串是不可变的，这意味着一旦创建，就不能更改。字符串赋值如下所示:
s = 'Abcdefg'
附加到字符串
尽管 Python 字符串是不可变的，但我们可以对它们执行许多操作，包括向字符串追加其他信息。>>> a = "This is a test"
>>> a = a + " of strings"
>>> a
'This is a test of strings'
在这种情况下，会制作字符串的副本，将第二个字符串追加到副本中，然后删除原始字符串，并将新字符串重命名为旧名称。
字符串函数
有许多内置函数可用于字符串。请注意，这些函数中的大多数也适用于其他类型的对象。
len()
返回字符串的长度。
>>> a = "The time has come"
>>> len(a)
17
min()
返回字符串中的最小(最低 ascii 值)字符。
>>> a = "The time has come"
>>> min(a)
' '
max()
返回字符串中的最大值(最高 ascii 值)字符。
>>> a = "The time has come"
>>> max(a)
't'
s2 中的 S1
如果 s1 在字符串中，则返回 True。
>>> a = "The time has come"
>>> "has" in a
`True`
>>> "not" in a
`False`
s1 不在 s2 中
>>> a = "The time has come"
>>> "not" not in a
`True`
s1 + s2
将 s2 连接到 s1。
>>> a = "The time has come"
>>> b = " for all good men"
>>> c = a + b
>>> c
'The time has come for all good men'
s[x]
返回字符串中位置 x 处的单个字符(从零开始)。也称为切片功能。要获得从位置 x 开始到字符串末尾的切片，请使用 s[x:]。
>>> c
'The time has come for all good men'
>>> c[7]
'e'
>>> c[7:]
'e has come for all good men'
s[x1:x2]
返回从 x1 到 x2 的字符串片段(从零开始)。X2 应该被认为是起点+要返回的字符串长度。
如果我们想从以单词“time”开始的字符串“time has come for all good men”中获得 8 个字符，我们将使用c[4:12]，因为 4 是字符串中从零开始的第四个字符，我们想要 8 个字符，这是位置 12。这可能会让新手感到困惑。
>>> c
'The time has come for all good men'
>>> c[4:12] # Want 8 characters (4 + 8 = 12)
'time has'
s[x1:x2:x3]
类似于 s[x1:x2],但增加了一个步进字符数的参数。也可以使用负数作为步长参数。A -1 会从最后一个字符开始反转字符串。A -2 表示从末尾开始每隔一个字符。
>>> c
'The time has come for all good men'
>>> c[4:12:2]
'tm a'
>>> c[::-1]
'nem doog lla rof emoc sah emit ehT'
>>> c[::-2]
'nmdo l o mcshei h'
字符串方法
方法不同于函数，因为方法属于一个特定的对象。例如，字符串的长度使用len()函数。为了获得字母“t”在变量 str1 中出现的次数，也就是字符串“This is the time”，我们将使用str1.count('t')。
str . capital()
返回一个字符串，其中第一个字符设置为大写，其余字符设置为小写。
>>> d = "this is a test"
>>> d.capitalize()
'This is a test'
str.center(width[，fillchar])
返回一个字符串，其中原始字符串居中对齐，并用 fillchar 填充到 width 的宽度。默认填充字符是一个空格。如果原始字符串长度大于或等于宽度，则返回原始字符串。这类似于 ljust()和 rjust()。
>>> c = "A Test"
>>> c.center(10)
' A Test '
>>> c.center(10,"*")
'**A Test**'
str.count(sub[，start[，end]])
返回 sub 的实例数。可选的开始和结束参数将搜索限制在字符串内。
>>> s = "This is the time"
>>> s.count("t")
2
>>> s.count("T")
1
str . decode([编码[，错误]])
使用编码解码器返回解码后的字符串。通常用于 Unicode 字符串。errors 参数的可能参数是“ignore”、“replace”、“xmlcharrefreplace”、“backslashreplace”、“strict”以及在 codecs.register_error()中注册的其他参数。默认为“严格”
Python 2.x:
>>> s = "This is the time"
>>> d = s.encode('UTF-8',errors='strict')
>>> d
'This is the time'
>>> d.decode('UTF-8',errors='strict')
`u'This is the time' # the leading 'u' denotes unicode.`
Python 3.x:
>>> s = "This is the time"
>>> d = s.encode('UTF-8',errors='strict')
>>> d
`b'This is the time' # the leading 'b' denotes a byte array.`
>>> d.decode('UTF-8',errors='strict')
'This is the time'
str . encode([编码[，错误]])
使用编码解码器返回编码字符串。通常用于 Unicode 字符串。
>>> d = s.encode('UTF-8',errors='strict')
>>> d
'This is the time'
str . endcon(后缀[、开始[、结束]]
如果字符串以后缀结尾，则返回 True。可选的开始和结束将搜索限制在字符串内。后缀可以是要搜索的后缀元组。
>>> s
'This is the time'
>>> s.endswith('time')
`True`
str .展开制表符([制表符])
返回所有制表符都被一个或多个空格字符替换的字符串的副本。默认选项卡大小为 8。在以下示例中，“\t”字符等同于制表符。
>>> t = "Item1\tItem2\tItem3\tItem4"
>>> t
'Item1\tItem2\tItem3\tItem4'
>>> t.expandtabs(6)
'Item1 Item2 Item3 Item4'
str.find(substring[，start[，end]])
返回子字符串中第一个实例的索引。如果找不到 sub，则返回-1。索引从零开始。开始和结束参数允许您缩小查找范围。
>>> b = "This is the time of the party"
>>> b.find("the")
8
>>> b.find("the",11)
20
str.format(*args、**kwargs)
返回使用格式化操作格式化的字符串。这是一个变量替换函数。替换%格式化操作。请参阅本章后面的格式化一节。当可能提供一组未知的参数和/或需要传递一个关键字/值集时，需要*args 和**kwargs 参数。
>>> a = 3.14159
>>> b = "PI = {0}".format(a)
>>> b
'PI = 3.14159'
str.format_map(映射)仅限 Python 3.x
类似于 str.format，但是映射参数是直接使用的，而不是复制到字典中。在下面的示例中，字符串中将替换两个项目，一个是{职业}，另一个是{位置}。我们已经创建了一个名为 Helper 的类，它需要一个字典键/值对。如果提供了键/值对，那么我们得到那个值。如果没有，调用 missing 例程并返回密钥。使用。format_map 例程，格式函数定义中的每个键都被发送到 Helper 类中。因为我们只传递{职业}的字典信息，所以当它到达{位置}时，助手例程返回字符串中使用的“位置”。
>>> class Helper(dict):
... def __missing__(self,key):
... return key
>>> a = 'Fred is a {vocation} at {location}'.format_map(Helper(vocation='teacher'))
>>> a
'Fred is a teacher at location'
str.index(substring[，start[，end]])
类似于 find，但如果未找到子字符串，将引发 ValueError 错误。因为如果找不到子字符串，这将引发错误，所以它被认为是比。find()方法。
p . isaln()的缩写形式
如果字符串中的所有字符都是字母数字，则返回 True。
>>> f = "This is the time" # includes white space, so false
>>> f.isalnum()
`False`
>>> e = "abcdef1234"
>>> e.isalnum()
`True`
str.isalpha（）
如果字符串中的所有字符都是字母，则返回 True。
>>> e = "abcdef1234" # includes numerics, so false
>>> e.isalpha()
`False`
>>> g = "abcdef"
>>> g.isalpha()
`True`
仅适用于 Python 3.x
如果字符串中的所有字符都是十进制字符，则返回 True。处理十进制数的 Unicode 表示。
e = 12.34
e.isdecimal()
`False`
e = "\u00B2"
e.isdecimal()
`True`
str . isdigt()
如果字符串中的所有字符都是数字，则返回 True。
>>> a
3.14159
>>> str(a).isdigit() # contains a decimal point, so false
`False`
>>> b = "12345"
>>> b.isdigit()
`True`
仅适用于 Python 3.x
如果字符串是有效的标识符，则返回 True。有效的标识符就像我们命名变量的方式。以“%”开头的字符串就是无效标识符的一个例子。
>>> a = "print"
>>> a.isidentifier()
`True`
>>> a = "$"
>>> a.isidentifier()
`False`
str . ispower()
如果字符串中的所有字符都是小写，则返回 True。
>>> a = 'the time has come for'
>>> a.islower()
`True`
str.isprintable() 仅限 Python 3.x
如果字符串中的所有字符都是可打印的，或者字符串为空，则返回 True。
str.isspace()
如果字符串中的所有字符都是空白，则返回 True。
p.istitle（）
如果整个字符串都是大写字符串(只有每个单词的第一个字符是大写的)，则返回 True。
>>> a = 'The Time Has Come'
>>> a.istitle()
`True`
>>> b = 'The TIme Has Come'
>>> b.istitle()
`False`
str . ispers()
如果整个字符串是大写字符串，则返回 True。
>>> c = "ABCDEFGH"
>>> c.isupper()
`True`
>>> b
'The TIme Has Come'
>>> b[4].isupper() # Is the 5th character in 'b' uppercased?
`True`
str.join(iterable)
返回一个字符串，该字符串使用分隔符将 iterable 中的每个值连接到字符串中。很多时候，用“+”号连接字符串可能更容易。
>>> a = ","
>>> a.join(["a","b","c"])
'a,b,c'
p 光源(宽度[，填充图案]]
返回一个字符串，其中原始字符串左对齐并用 fillchar 填充到 width 的宽度。如果原始字符串长度大于或等于宽度，则返回原始字符串。类似于 center()，rjust()。
>>> a = "The time"
>>> a.ljust(15,"*")
'The time*******'
str.lower()
返回所有字符都转换为小写的字符串的副本。
>>> a
'The time'
>>> a.lower()
'the time'
str . lsrip([chars])
返回移除了前导[chars]的字符串副本。如果省略[chars],任何前导空白字符都将被删除。
>>> a = " This is a test"
>>> a.lstrip()
'This is a test'
>>> a.lstrip(" This")
'a test'
仅限于 Python 3.x
返回翻译方法的翻译表。translate 方法可以使用该表(请参阅本章后面的内容)。在这里的示例中，inalpha 字符串中的任何字符都将被更改或转换为 outalpha 字符串中的相应字符。所以 a=1，b=2，c=3，以此类推。
>>> inalpha = "abcde"
>>> outalpha = "12345"
>>> tex = "This is the time for all good men"
>>> trantab = str.maketrans(inalpha,outalpha)
>>> print(tex.translate(trantab))
This is th5 tim5 for 1ll goo4 m5n
字符串分区(sep)
返回一个三元组，包含分隔符之前的部分、分隔符本身和分隔符之后的部分。如果没有找到分隔符，则三元组包含字符串，后跟两个空字符串。
>>> b = "This is a song.mp3"
>>> b.partition(".")
`('This is a song', '.', 'mp3')`
str.replace(old，new[，count])
返回字符串的副本，所有出现的旧字符串都被新字符串替换。如果提供了可选计数，则只替换第一个计数。请注意，示例中“This”中的“is”也被替换为“Thwas”
>>> b = "This is a song.mp3"
>>> b.replace('is','was')
'Thwas was a song.mp3'
str.rfind(sub[，start[，end]])
返回字符串中子字符串的最后一个实例的索引。如果找不到 sub，则返回-1。索引从零开始。
>>> b = "This is the time of the party"
>>> b.rfind("the")
20
str.rindex(sub[，start[，end]])
与 rfind 类似，但如果找不到 substring sub，将引发 ValueError 错误。
str.rjust(width[，fillchar])
返回一个字符串，其中原始字符串右对齐并用 fillchar 填充到 width 的宽度。如果原始字符串长度大于或等于宽度，则返回原始字符串。类似于 center()，ljust()。
>>> a = "The time"
>>> a.rjust(15,"*")
'*******The time'
str.rpartition(sep)
类似于 partition()，但是返回 sep 最后一次出现之前的字符串部分，作为三元组的第一部分。
>>> b = 'This is a song.mp3'
>>> b.rpartition(' ')
`('This is a', ' ', 'song.mp3')`
str . rslit([sep[、maxsplit]]t 0]
使用 sep 作为分隔符字符串返回字符串中的标记列表。如果提供了 maxsplit，列表将是最右边的集合。类似于 split()。
>>> a = "This is the time"
>>> a.rsplit(" ",2)
`['This is', 'the', 'time']`
str.rstrip([chars])
返回删除了尾随字符[chars]的字符串副本。如果[chars]为空或未提供，则删除空白。
>>> a = " This is a test "
>>> a.rstrip()
'This is a test'
str.split([sep[、maxsplit]]t0]
使用 sep 作为分隔符字符串返回字符串中的单词列表。如果提供了 maxsplit，列表将是最左边的集合。类似于 rsplit()。
>>> a = "This is the time"
>>> a.split()
`['This', 'is', 'the', 'time']`
str.splitlines ([keepends])
返回字符串中的行列表，在行边界处断开字符串。除非[keepends]给定并且为 True，否则换行符不会包含在结果列表中。
>>> t = "The time has come\r\nFor all good men"
>>> t.splitlines()
`['The time has come', 'For all good men']`
`>>> t.splitlines(True)`
`['The time has come\r\n', 'For all good men']`
str.startswith(前缀[，开始[，结束]])
如果字符串以前缀开头，则返回 True，否则返回 false。使用可选的 start、end 参数将搜索限制在字符串的该部分。类似于 endswith()。
>>> a = "This is a test"
>>> a.startswith('This')
`True`
>>> a.startswith('This',4)
`False`
字符串带([字符])
返回字符串的副本，其中删除了所有前导和尾随字符。如果参数为空，则删除所有空白字符。如果提供了参数，则参数中的所有值都将被删除。
>>> c = "thedesignatedgeek.net"
>>> c.strip('thenet')
'designatedgeek.'
str.swapcase()
返回字符串的副本，其中大写字符转换为小写字符，小写字符转换为大写字符。
>>> a = "The Time Has Come"
>>> a.swapcase()
'tHE tIME hAS cOME'
str.title()
返回字符串的副本，其中每个单词的第一个字符都是大写的。带撇号的单词可能会导致意想不到的结果。
>>> a = "Fred said they're mine."
>>> a.title()
`"Fred Said They'Re Mine."`
str.translate(table[，deletechars])python 2 . x
返回一个替换了翻译表中所有字符的字符串。使用字符串库中的 maketrans 方法创建翻译表。可选的 deletechars 参数将从返回字符串中删除参数字符串中的任何字符。要仅删除某些字符，请为 table 参数传递 None。
>>> from string import maketrans # Import the maketrans function from the string library.
>>> intable = 'aeiou'
>>> outtable = '12345'
>>> trantable = maketrans(intable,outtable)
>>> a = "The time has come"
>>> a.translate(trantable)
'Th2 t3m2 h1s c4m2'
>>> a.translate(None,'aeiou')
'Th tm hs cm'
str . translate(table)python 3 . x
非常类似于 Python 2.x 版本的。translate()有以下例外。
- 没有 deletechars 可选参数。
- Maketrans 是一个不需要从字符串库中导入的方法。
str.upper()
返回所有字符都转换为大写的字符串的副本。
>>> a = "The time has come"
>>> a.upper()
'THE TIME HAS COME'
str.zfill(宽度)
返回一个数值字符串的副本，该字符串的宽度(长度)用零填充。如果字符串的长度小于或等于宽度，则返回原始字符串。
>>> b = "3.1415"
>>> b.zfill(10)
'00003.1415'
>>> b.zfill(5) # the width of b (length) is 6
'3.1415'
打印声明
Python 2.x 允许您在使用 print 语句时使用以下格式:
>>> print 'The time has come for all good men'
`The time has come for all good men`
但是，Python 3.x 不接受这种格式。Python 3.x 格式要求在要打印的字符串两边加上括号。
>>> print('The time has come for all good men')
`The time has come for all good men`
为了便于两个版本之间的转换，Python 2.7 向后移植了 Python 3.x 打印格式。
Python 2.x 字符串格式化
Python 2.x 中的格式使用“字符串%值”类型字段替换格式选项。这就允许对最终输出进行更多的控制，而不是简单地将不同的字符串和变量连接起来用于打印或其他输出功能。
>>> print '%s uses this type of formatting system' % "Python 2.7"
`Python 2.7 uses this type of formatting system`
“%s”表示应该在该位置放置一个字符串，行尾的“%”提供应该替换的值。这可以是一个文字(如上例)或变量。
若要提供整数值，请使用“%d”字段。您还可以随字段指示符一起提供某些格式选项。在这里的例子中，' %03d '意味着将一个整数格式化为宽度为 3，并在左边填充 0。
>>> print '%03d goodies in this bag' % 8
`008 goodies in this bag`
若要为替换组提供多个值，请将这些值括在括号中。
>>> print '%d - %f Numbers' % (3,3.14159)
`3 - 3.141590 Numbers`
您还可以在输出中使用命名变量。在下面的示例中，“%(frog)s”使用所提供的字典中键“frog”的值“Python”。
>>> print '%(frog)s can print nicely %(num)d ways' % {'frog':'Python','num':2}
`Python can print nicely 2 ways`
表 4-1 列出了可用于修改替代工作方式的各种标志。
表 4-1 。print 语句的替换标志
|
旗
|
意义
|
| --- | --- |
| # | 值转换将使用替代形式(十六进制、八进制、二进制等)。参见表 4-2 。 |
| Zero | 对于数值，转换将使用零填充。 |
| − | 转换值向左调整(覆盖“0”转换)。 |
| | 空格—正数前应该留有空格。 |
| + | 符号字符(+或-)将出现在转换之前(覆盖空格转换)。 |
表 4-2 显示了替换键的可能格式。
表 4-2 。print 语句的替换键
|
转换
|
意义
|
| --- | --- |
| 迪 | 有符号整数小数 |
| 我 | 有符号整数小数 |
| 你好 | 过时—等同于“d” |
| 的 | 有符号八进制值 |
| x ' | 有符号十六进制—小写 |
| x ' | 有符号十六进制—大写 |
| f ' | 浮点小数 |
| ' e ' | 浮点指数型—小写 |
| ' e ' | 浮点指数—大写 |
| ' g ' | 浮点格式-如果指数小于-4 或不小于精度，则使用小写指数格式，否则使用十进制格式 |
| ' g ' | 浮点格式-如果指数小于-4 或不小于精度，则使用大写指数格式，否则使用十进制格式 |
| c′ | 单字符 |
| r′ | 字符串(使用 repr()转换有效的 Python 对象) |
| s | 字符串(使用 str()转换有效的 Python 对象) |
| '%' | 不转换任何参数，导致“%”字符 |
Python 3.x 字符串格式化
Python 3.x 使用不同的格式化系统，比 Python 2.x 使用的系统更强大。print 语句现在是一个函数。格式字符串使用花括号“{}”来创建替换字段。括号内没有包含的任何内容都将被视为文字，不会对其进行任何转换。如果您需要包含花括号作为文字，您可以使用' {{ '和' }} '对其进行转义。这个格式化系统已经被反向移植到 Python 2.6 和 Python 2.7。
基本格式字符串如下:
print('This is a value - {0}, as is this - {1}'.format(3,4))
其中数字 0 和 1 指的是值列表中的索引，将打印如下:
`This is a value - 3, as is this - 4`
没有必要将数字放在括号内。参数表中显示的值将按顺序替换。
>>> print('Test {} of {}'.format(1,2))
`Test 1 of 2`
您还可以使用字典中的键作为括号内的引用，就像 Python 2.x 中一样。
浮点值的零填充格式示例。{:[零填充][宽度]。[精度]}
>>> a = "This is pi - {:06.2f}".format(3.14159)
>>> a
'This is pi - 003.14'
您可以使用以下对齐标志来对齐文本并指定宽度:
:< x 左对齐，宽度为 x
:> x 右对齐，宽度为 x
:^x 中心与宽度 x 对齐
>>> a = '{:<20}'.format('left')
>>> a
'left '
>>> a = '{:>20}'.format('right')
>>> a
' right'
>>> a = '{:²⁰}'.format('center')
>>> a
' center '
您也可以指定填充字符。
>>> a = '{:*>10}'.format(3.14)
>>> a
'******3.14'
日期和时间格式示例。
>>> import datetime
>>> d = datetime.datetime(2013,9,4,9,54,15)
>>> print('{:%m/%d/%y %H:%M:%S}'.format(d))
`09/04/13 09:54:15`
千位分隔符。
>>> a = 'big number {:,}'.format(72819183)
>>> a
'big number 72,819,183'
表 4-3。使用示例的格式说明符
|
分类符
|
描述
|
| --- | --- |
| :<20 | 左对齐，宽度为 20。 |
| :>20 | 右对齐，宽度为 20。 |
| :²⁰ | 居中对齐，宽度为 20。 |
| :06.2 层 | 浮点数的精确补零。 |
| :*>10 | 星号填充右对齐，宽度为 10。 |
| :=10 | 填充符放在符号之后，如果有的话，但在数字之前。仅适用于数值类型。 |
| :+20 | 强制在左边的数字前加一个符号，填充宽度为 20。 |
| :−20 | 仅在负数前强制使用符号，左侧填充宽度为 20。 |
| : 20 | 在正数上强制一个前导空格，在负数上强制一个“-”，左填充宽度为 20。 |
| :, | 强制用千位逗号表示数值。 |
| :.2% | 表示百分比(. 975 的结果为 97.50%) |
| 用法:%M/%d/%Y | 类型特定用法。在本例中为日期时间。 |
| 0:#x | 将整数格式化为十六进制值 0xhh。 |
| 0:#o | 将整数格式化为八进制值 0oxx。 |
| 0:#b | 将整数格式化为二进制值 0bxxxxxx。 |
五、条件语句
条件语句是许多程序的重要组成部分。它们允许对我们的程序进行逻辑控制。Python 中有三种主要的条件语句类型。If / Elif / Else 条件句，For 循环和 While 循环。
IF / ELIF / ELSE 语句
if 语句允许我们检查一个或多个语句的真实性，并将逻辑应用于各种可能性。if 语句的核心很简单。
if (statement) :
# do the following code
# do this line as well
# This line is NOT part of the if statement.
该语句以“if”关键字开始(“if”必须是小写的),后面是条件表达式，然后是冒号字符。如果语句为真，您希望执行的代码行必须缩进。
假设变量 a = 3，变量 b = 7。
if a < b:
print("a less than b")
`a less than b`
您还可以添加第二个选项，这样，如果第一个语句不为真，程序将运行替代代码。这是else选项。“else”短语不允许任何附加逻辑，并且必须后跟冒号。
if b < a:
print("b less than a")
else:
print("a less than b")
`a less than b`
如果有两个以上的选项，可以使用if / else语句的elif选项。您可以根据需要拥有任意多的elif语句。elif 选项必须有某种逻辑，后跟一个冒号。
if a == 3:
print('a=3')
elif a == 4:
print('a=4')
else:
print('a not 3 or 4')
a=4
if / elif / else语句必须在主缩进级别，逻辑缩进。
a = 3
b = 4
c = 6
if a<b:
d = 5
if (c<b) or (b<a):
d = 2
e = 5
elif (c<a):
c = a
a = 7
print a,b,c,d,e
`7 4 6 5 5`
对于
for 关键字创建一个由赋值后的参数控制的循环，并将运行给定的次数。像 if 语句一样，关键字后面是一个将被“单步执行”(迭代)的序列，后面是一个冒号。循环中要完成的所有逻辑都是缩进的。最简单的 for 循环如下所示:
for x in range(3):
print(x)
0
1
2
range 函数将根据参数中的数字创建一个列表。在前面的例子中，列表应该是[0,1,2]。在 Python 2.x 下，可以使用 xrange 函数代替 range。Xrange 创建了一个生成器，该生成器根据需要创建数字，而不是创建列表，使用的内存更少，循环速度更快，因为数字是根据需要生成的。如果您使用的是 Python 3.x，则 xrange 函数被移除，但实际上被重命名为 range。
for x in xrange(3):
print(x)
0
1
2
如前所述，range 函数将基于参数值创建一个值列表。因此，您可以在 for 语句中直接使用列表。
for x in [1,2,3,4,5,6,7,8,9,10]:
print x
1
2
3
4
5
6
7
8
9
10
您还可以遍历或迭代值列表中的字符串。
for char in "The time has come":
print char
`T`
`h`
`e`
`t`
`i`
`m`
`e`
`h`
`a`
`s`
`c`
`o`
`m`
`e`
如果您正在遍历一个字典，您可以。字典对象的iteritems()方法。
d = {'Key1':1,'Key2':2,'Key3':3}
for key,value in d.iteritems():
print key,value
`Key3 3`
`Key2 2`
`Key1 1`
另一个有用的选项是使用enumerate()函数。这将允许您遍历一个列表，计数和列表值将作为一个元组返回。
mounts = ['Evans','Grays Peak','Longs Peak','Quandary']
for m in enumerate(mounts):
print m
`(0, 'Evans')`
`(1, 'Grays Peak')`
`(2, 'Longs Peak')`
`(3, 'Quandary')`
破裂
中断语句 ?? 允许提前终止循环(for或while)。在这个代码片段中，for 循环应该从 0 运行到 4，但是当循环达到值 3 时，循环终止。
for x in range(5):
if x == 3:
break
else:
print(x)
0
1
2
继续
for 循环中的 continue 可选语句允许正常的循环操作，但是在指定的条件下，对于该迭代，其余的逻辑将被跳过。在这里的代码片段中，当 for 循环中的值达到 3 时，print(x)逻辑将被跳过，循环继续。
for x in range(5):
if x == 3:
continue
else:
print(x)
0
1
2
4
其他
for 循环还支持可选的 else 语句。与 if 条件语句使用的 else 语句不同，它更像是try语句中的 else，因为它总是在循环结束时运行。
for x in range(5):
print x
else:
print "The else"
0
1
2
3
4
`The else`
及格
pass 语句将什么都不做，这看起来是一件愚蠢的事情。然而，当您需要一个语句(比如 if 子句中的一个选项)或“存根”一个稍后要填充的例程时，它实际上是有价值的。
a = 3
if a == 2:
pass
else:
print("A != 2")
`A != 2`
def testfunction():
pass
正在…
当您需要重复您的逻辑直到满足某个条件时，使用 while 循环,通常是因为您不知道需要多少次。这可能是因为您正在等待某些条件得到满足，比如计时器超时或某个按键。
cntr = 0
while cntr < 11:
print cntr
cntr += 1
0
1
2
3
4
5
6
7
8
9
10
您也可以创建一个无限循环，所以您可能要小心，并创建一个方法来中断循环。如果在无限循环中结束，可以按 Ctrl + C 结束代码的执行。
cntr = 1
while cntr == 1:
#do something forever.
六、数据结构
数据结构对于大多数严肃的(和一些不那么严肃的)程序都很重要。它们允许我们在单个变量名下存储相关数据组，并快速、逻辑地访问它们。在 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)
这是程序应该做的事情，然后是它的输出。
- 定义一个名为“a”的变量，并将其赋值为 5。
- 定义一个名为 test 的函数，该函数采用一个也称为“a”的参数。注意，这不是同一个变量。
- 一旦我们在函数中，我们打印 a 的值(这里假设 a 是一个十进制数)。
- 在该值上加 10 并打印新值。这是函数的结尾，我们不返回任何值。
- 程序实际上是从第一行(a = 5)开始，然后跳过函数，从下一个非缩进的行继续(' print('A 开始。。。').所以我们给变量 A 赋值 5，然后打印“A 以 5 开始”。
- 用变量 a 调用函数 test，变量 a 是 5，作为参数。
- 在函数内部，我们打印“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)
- 首先我们定义一个变量
'a'，并给它赋值 1。 - 接下来我们定义两个函数，
test1和test2。它们都不接受参数 - 在
test1函数中，我们给一个变量'a'赋值，并给它赋值 42，然后打印这个值。记住这个变量'a'有一个不同的作用域，严格来说只能在这个函数中使用。 - 在
test2中，我们在定义变量'a'时使用了全局关键字。这一次，因为我们使用了global关键字，所以我们说任何时候我们使用变量'a'，它应该指的是全局变量，而不是局部变量。现在，例程中变量'a'的任何变化都会改变第一行代码中声明的变量。 - 现在代码继续并将打印“
a starts at 1”，继续调用函数test1，它创建自己的变量'a'，给它赋值 42 并打印。 - 当我们从那回来时，我们打印“
After test1, a is now 1”。 - 接下来调用函数
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)
- 您可以看到，我们只添加了一行(“
return a”行)，并通过分配变量来获取返回值，从而修改了对测试函数的调用。 - 当这个程序运行时。。。我们给变量
'a'赋值 5，把它传递给test函数。 - 它打印刚刚传入的值，将其递增 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()
在这个程序示例中:
- 我们声明变量
'a'和'b',使它们在范围上是全局的。 - 接下来我们声明两个函数，一个叫做'
function1'，一个叫做'main'。 - 带有省略号的注释行只是表明在它下面可能有更多的函数。
- 最后一行调用函数'
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 中移除。
十、类
类是我们创建对象的方式。我们使用对象来尝试在计算机代码中模拟真实世界。对象是封装编程代码的一种方式，不仅可以重用，而且可以在不影响原始对象的情况下进行复制和修改。对象通常具有属性和修改这些属性的函数。类还允许您编写一组可在多个项目中使用的代码，而无需像库一样将代码重写或复制到每个项目中。在这一章中，我们将集中讨论对象，尽管简单类的概念是相同的。
什么是物体？
当试图解释什么是物体时，我喜欢用汽车的例子。什么是汽车？它有一个身体，一个框架，一个引擎，一些轮子，等等。车身类型、车架类型、发动机类型、车轮数量、车身颜色以及其他东西都是汽车属性的例子。例如，所有的汽车都有门。然而，车门的数量可能会因车型而异。有些有两个门，有些有四个门，有些有五个门(如果你认为行李箱盖是门的话)。我们可以创建一个“通用”汽车(称为实例)，然后对于我们想要的任何类型的汽车，我们可以修改汽车实例的属性以适应我们自己的目的。这叫继承。我们通过修改属性创建的新汽车“模型”继承了父汽车的属性。
创建一个类
当我们创建一个类时，我们使用一个类定义，非常类似于一个函数定义。类定义以单词'class'开始，以冒号结束。类中的任何代码行都是缩进的。代码中第一个未缩进的行被视为在类之外(不是类的一部分)。
class ClassName:
{Any accessable class variables}
{initialization routine}
{Any functions you may need}
...
这里有一个例子:
class Car:
__init__(self,attrib1,attrib2):
pass
def Function1(self):
pass
def Function2(self):
pass
除了每个函数定义中的单词“self”之外，这都是不言自明的。单词“??”指的是我们在类或对象的特定实例中使用变量或函数的事实。
真实的例子
让我们看一个类和由该类创建的对象的例子。我们将创建一个名为“狗”的类。该类将具有以下属性:
- 名称（狗名）
- 颜色（狗色）
- 高度(狗高度)
- 构建(dogbuild)
- 心情(狗狗心情)
- 年龄(消歧义)
class Dog(): # The class definition
def __init__(self,dogname,dogcolor,dogheight,dogbuild,dogmood,dogage):
#here we setup the attributes of our dog
self.name = dogname
self.color = dogcolor
self.height = dogheight
self.build = dogbuild
self.mood = dogmood
self.age = dogage
self.Hungry = False
self.Tired = False
大多数类(和对象)都有一个初始化函数。这是在我们创建类的实例时运行的automatically。为了定义初始化例程，我们将其命名为__init__ (这是两个下划线字符，后面是单词“init”，再后面是两个下划线)，然后是参数列表(如果有的话)，最后是一个冒号，就像我们通常编写的任何函数一样。
在初始化例程中，我们设置并定义任何内部变量，在本例中是属性。注意，我们还定义了两个属性变量Hungry和Tired，它们不属于参数列表。通常，我们不会向外界“暴露”或透露这些内容，而只允许内部功能对它们进行更改。为了对对象的用户隐藏变量或属性，我们以两个下划线字符开始变量名。例如__Hungry 和__Tired。然而，因为我们保持事情简单，我们将暴露一切。
我们类中的函数
在这个类中，我们编写函数就像编写其他函数一样。我们用关键字开始参数表。如果你不使用self关键字，你会得到一些奇怪的错误。当我们提到任何内部变量时，我们使用.self关键字。以下三个函数用于“告诉狗对象做什么”。当然还可能有更多，但是对于这个例子，我们将坚持使用这些。
def Eat(self):
if self.Hungry:
print 'Yum Yum...Num Num'
self.Hungry = False
else:
print 'Sniff Sniff...Not Hungry'
def Sleep(self):
print 'ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ'
self.Tired = False
def Bark(self):
if self.mood == 'Grumpy':
print 'GRRRRR...Woof Woof'
elif self.mood == 'Laid Back':
print 'Yawn...ok...Woof'
elif self.mood == 'Crazy':
print 'Bark Bark Bark Bark Bark Bark Bark'
else:
print 'Woof Woof'
您可以看到这三个函数的代码非常简单。
Eat函数只是检查Hungry属性。如果Hungry为真，那么狗对象“吃”然后设置属性为假。如果没有，它只是打印它的行。
Sleep函数简单地打印鼾声，然后将属性Tired设置为 False。
Bark函数遍历一条if/elif/else语句，并基于 mood 属性打印出适当的内容。
使用狗对象
下面的代码行将创建类/对象的一个实例(也称为实例化)，并将正确的信息传递给类初始化函数，如果有的话。请注意，这是“main”代码的一部分，而不是类的一部分。
Beagle = Dog('Archie','Brown','Short','Chubby','Grumpy',12)
我们现在有一个名为“Beagle”的狗对象。如你所见，他(可能是男的，因为名字叫阿奇)棕色，矮矮胖胖，脾气暴躁。现在我们使用对象。为了访问他的任何功能或属性，我们使用对象名(Beagle )后跟一个点(。)然后是函数名或属性名。
在接下来的五行代码中，我们将访问他的属性。
print 'My name is %s' % Beagle.name
print 'My color is %s' % Beagle.color
print 'My mood is %s' % Beagle.mood
print 'I am hungry = %s' % Beagle.Hungry
最后四行代码会让他做事，或者在第二行的情况下，让他感到饥饿。
Beagle.Eat()
Beagle.Hungry = True
Beagle.Eat()
Beagle.Bark()
当我们运行这个程序时，我们得到以下输出:
My name is Archie
My color is Brown
My mood is Grumpy
I am hungry = False
Sniff Sniff...Not Hungry
Yum Yum...Num Num
GRRRRR...Woof Woof
更进一步
我们可以通过创建 Dog 类的多个实例来扩展这个例子。在我们初始化 Beagle 对象的那一行之后，用这些行替换下面所有的代码行:
Lab = Dog('Nina','Black','Medium','Chubby','Laid Back',8)
Shepherd = Dog('Bear','Black','Big','Skinny','Crazy',14)
Lab.Hungry = True
print 'My name is %s' % Beagle.name
print 'My color is %s' % Beagle.color
print 'My mood is %s' % Beagle.mood
print 'I am hungry = %s' % Beagle.Hungry
Beagle.Eat()
Beagle.Hungry = True
Beagle.Eat()
Beagle.Bark()
print 'My name is %s' % Lab.name
print 'My mood is %s' % Lab.mood
if Lab.Hungry == True:
print 'I am starving!'
Lab.Eat()
Lab.Sleep()
Lab.Bark()
else:
print 'No...not hungry.'
这又创建了两个狗对象。一个叫做 Lab ，另一个叫做 Shepherd，加上 Beagle 对象，一共三个。运行代码会产生以下输出:
My name is Archie
My color is Brown
My mood is Grumpy
I am hungry = False
Sniff Sniff...Not Hungry
Yum Yum...Num Num
GRRRRR...Woof Woof
My name is Nina
My mood is Laid Back
I am starving!
Yum Yum...Num Num
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
Yawn...ok...Woof
显然，对于这个例子，您可以做更多的事情。然而，我们将继续前进。
真实的东西
现在我们将专注于一些有用的东西。我们将创建一个查询 WeatherUnderground 网站的类，并通过使用邮政编码获取美国任何给定位置的当前天气情况。在我们继续之前，让我们为该课程安排一系列要求:
- 获取当前的天气状况
- 获取当前温度
- 获取当前大气压力
- 获取相对湿度
- 获取当前的风向和风速。
- 在命令窗口(Windows)或终端(Linux)中运行
现在我们应该看看程序将执行的过程:
- 获取邮政编码。
- 实例化该类，将邮政编码传递给该类。
- 打开一个指向网站 URL 的套接字，获取 XML 文件形式的信息。
- 解析返回的 XML 文件，提取我们需要的信息。
- 打印解析过程中的信息。
在我们可以编码之前，我们需要知道网站会给我们什么信息。
查看信息
XML 文件太大，无法在这里打印，所以我只给出 XML 数据的部分转储。省略号表示为了简洁起见，有更多的数据被删除。
<current_observation>
<credit>Weather Underground NOAA Weather Station</credit>
<credit_URL>http://wunderground.com/</credit_URL>
...
<display_location>
<full>Aurora, CO</full>
<city>Aurora</city>
<state>CO</state>
<state_name>Colorado</state_name>
<country>US</country>
...
</display_location>
<observation_location>
<full>Aurora, Colorado</full>
<city>Aurora</city>
<state>Colorado</state>
<country>US</country>
...
</observation_location>
<station_id>KBKF</station_id>
<observation_time>Last Updated on November 14, 12:55 PM MST
</observation_time>
...
<weather>Partly Cloudy</weather>
<temperature_string>54 F (12 C)</temperature_string>
<temp_f>54</temp_f>
<temp_c>12</temp_c>
<relative_humidity>41%</relative_humidity>
<wind_string>From the SSW at 5 MPH </wind_string>
<wind_dir>SSW</wind_dir>
<wind_degrees>200</wind_degrees>
...
</current_observation>
正如你所看到的，有大量的信息提供给我们，而其中大部分我们不会使用。感兴趣的项目有:
为位置文本。 - <observation_time>为读数的时间。</observation_time>
对于当前情况(部分多云、晴朗等。). - <temperature_string>为温度。</temperature_string>
- <relative_humidity>为湿度。</relative_humidity>
- <wind_string>为风向和风速。</wind_string>
- <pressure_string>为大气压力。</pressure_string>
如果您不熟悉 XML 数据，我可以给你一个快速的教程。
XML 刷新程序
XML 是许多基于 HTML 的标记语言之一。XML 基于标签、文本和属性的概念。标签的工作方式类似于字典键/值对中的键(见第六章),文本是对的值。如果有标签的数据，就会有开始标签和结束标签。结束标记与开始标记完全相同，只是它以斜杠开头。它看起来会像这样:
<tag>text</tag>
其中</tag>是结束标签。属性是标签的一部分，包含额外的信息。在这段代码中，我们不必担心 XML 文件中的属性。在上面的示例数据中，当我们寻找<weather>信息时，我们正在寻找标签<weather>，并且文本是“部分多云”。
编码时间。。。
现在我们知道我们在寻找什么，我们可以开始我们的编码。
导入库
我们将从导入我们需要的库开始:
from xml.etree import ElementTree as ET
import urllib
import sys
这三个库都是普通 Python 发行版附带的标准库。
创建类
接下来，我们需要创建我们的类。它将被命名为'CurrentInfo' ，包含三个功能。按顺序，它们是:
- get currents—web 访问和解析 XML 数据
- 输出—打印到终端窗口。
- DoIt—以正确的顺序调用上述函数。
虽然我之前说过大多数类都有初始化函数，但是这个类不会有，因为在这种情况下真的没有什么需要初始化的。我们将从我们的类定义和第一个函数开始:
class CurrentInfo:
def getCurrents(self,debuglevel,Location):
getCurrents功能有三个参数。self参数不接受参数或数据。debuglevel?? 为 0 或 1，是否有打印调试信息的标志。Location 是将邮政编码传递给函数的地方。接下来，我们检查调试模式是否打开，如果打开，我们打印传递给函数的位置邮政编码:
if debuglevel > 0:
print "Location = %s" % Location
连接到网站
接下来，我们尝试连接 WeatherUnderground 网站来获取 XML 数据。我们使用try/except错误处理集来实现这一点。这是在我们没有互联网连接或网站没有及时响应的情况下。在关键字try之后，我们将名为CurrentConditions 的变量设置为网站 URL，并在末尾包含邮政编码:
try:
CurrentConditions = _ 'http://api.wunderground.com/auto/wui/geo/WXCurrentObXML/index.xml?query=%s' % Location
现在，我们将连接的默认超时设置为 8 秒，并使用CurrentConditions变量打开一个到我们设置的 URL 的套接字。如果没有错误，我们告诉 XML 解析例程从套接字获取 XML 数据，然后关闭套接字:
urllib.socket.setdefaulttimeout(8)
usock = urllib.urlopen(CurrentConditions)
tree = ET.parse(usock)
usock.close()
如果有一个错误，那么我们打印一个错误消息到终端窗口，如果调试模式设置为真，我们打印位置并使用 sys 库中的exit例程来终止程序。sys.exit(1)行中的数字 1 表示有一个错误导致我们提前终止。通常代码 0 表示一切正常，代码 1 表示“发生了一些奇怪的事情”，代码 2 表示发生了命令行错误。
except:
print 'ERROR - Current Conditions - Could not get information from server...'
if debuglevel > 0:
print Location
sys.exit(1)
现在，我们假设一切工作正常，解析器已经获得了 XML 数据。我将解释前两个解析命令，因为除了我们要查找的内容和我们将数据赋给的变量之外，它们都是相同的。
getcurrent 函数
第一行(for loc in tree.findall(".//full":)告诉 XML 解析器寻找名为 < full > 的标签。具有该名称的每个标签都被放入一个名为‘loc’的列表中。对于列表中的每一项，我们将该项文本赋给变量self.location。在这个数据的情况下，有很多 <满> 标签，但是它们都持有相同的数据。在下一个中，我们想得到观察时间。以防有多个实例，我们使用一个 for 循环将文本赋给self.obtime变量。这一部分的代码如下:
# Get Display Location
for loc in tree.findall(".//full"):
self.location = loc.text
# Get Observation time
for tim in tree.findall(".//observation_time"):
self.obtime = tim.text
# Get Current conditions
for weather in tree.findall(".//weather"):
self.we = weather.text
# Get Temp
for TempF in tree.findall(".//temperature_string"):
self.tmpB = TempF.text
#Get Humidity
for hum in tree.findall(".//relative_humidity"):
self.relhum = hum.text
# Get Wind info
for windstring in tree.findall(".//wind_string"):
self.winds = windstring.text
# Get Barometric Pressure
for pressure in tree.findall(".//pressure_string"):
self.baroB = pressure.text
getCurrents功能到此结束。现在我们将研究输出函数。
输出功能
这只是在终端窗口中将我们从 XML 文件中提取的信息打印成“人类友好”的格式:
def output(self):
print 'Weather Information From Wunderground.com'
print 'Weather info for %s ' % self.location
print self.obtime
print 'Current Weather - %s' % self.we
print 'Current Temp - %s' % self.tmpB
print 'Barometric Pressure - %s' % self.baroB
print 'Relative Humidity - %s' % self.relhum
print 'Winds %s' % self.winds
DoIt 函数接受一个参数，位置邮政编码。然后它调用getCurrents函数，关闭调试模式并定位。然后它调用output函数:
def DoIt(self,Location):
self.getCurrents(0,Location)
self.output()
我们的课到此结束。这非常简单，但是让您知道创建一个类是多么容易。
主要功能
下一段代码是主函数。同样，它对这个特定的程序没有太大作用，但它给了我们程序一个起点。第一行将把邮政编码分配给location变量。第二行将创建我们类的一个实例。如果它有一个__init__函数，那么在创建类实例时会自动调用这个函数。最后，我们调用DoIt函数来启动整个过程:
def main():
location = '80013'
currents = CurrentInfo()
currents.DoIt(location)
添加程序入口点
我们要做的最后一件事是添加程序入口点。我们使用以 if __name__开始，以main()结束的两行。Python 为我们处理了两个内置变量。第一个是__name__(这是两个下划线字符，单词‘name’和另外两个下划线字符)。另一个就像我们刚刚描述的那个，但是是__main__(同样是两个下划线，单词‘main’，和另外两个下划线)。当你从命令行启动一个 Python 程序时，__name__变量被 Python 设置为__main__，所以解释器知道它应该调用main()函数。然而，因为我们创建了一个完成所有工作的类，所以我们实际上可以将它视为一个库，并将CurrentInfo 类导入另一个程序。在这种情况下，main()函数将不会运行，因为__name__将不是__main__而是调用它的程序的名称。
#===========================================================
# Main loop
#===========================================================
if __name__ == "__main__":
main()
我们的程序类的输出如下:
Weather Information From Wunderground.com
Weather info for Aurora, Colorado
Last Updated on November 14, 12:55 PM MST
Current Weather - Partly Cloudy
Current Temp - 54 F (12 C)
Barometric Pressure - 29.86 in (1011 mb)
Relative Humidity - 41%
Winds From the SSW at 5 MPH
顺便说一下，我已经通过将位置变量数据从“80013”改为“W11 2BQ”测试了源代码。一切都像预期的那样工作。
