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.
