3. Python 简介

在下面的例子中，输入和输出分别由大于号和句号提示符（ >>> 和 ... ）标注：如果想重现这些例子，就要在解释器的提示符后，输入（提示符后面的）那些不包含提示符的代码行。需要注意的是在练习中遇到的从属提示符表示你需要在最后多输入一个空行，解释器才能知道这是一个多行命令的结束。

本手册中的很多示例，包括那些带有交互提示符的，都含有注释。Python 中的注释以 # 字符起始，直至实际的行尾。注释可以从行首开始，也可以在空白或代码之后，但是不出现在字符串中。文本字符串中的 # 字符仅仅表示 # 。代码中的注释不会被 Python 解释，录入示例的时候可以忽略它们。

如下示例:

# 这是第一个注释
spam = 1 # 这个是第二个注释
 # ... 这是第三个注释
text = "# 这个不是一个注释，因为是在双引号里。"

3.1. 将 Python 当做计算器

我们先来尝试一些简单的 Python 命令。启动解释器然后等待主提示符 >>> 出现（不需要很久）。

3.1.1. 数字

解释器表现得就像一个简单的计算器：可以向其录入一些表达式，它会给出返回值。表达式语法很直白：运算符 +，-，* 和 / 与其它语言一样（例如：Pascal 或 C）；括号 (()) 用于分组。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 除法运算永远返回浮点数
1.6

整数（例如，2， 4， 20 ）的类型是 int，带有小数部分的数字（例如，5.0， 1.6）的类型是 float。在本教程的后面我们会看到更多关于数字类型的内容。

除法（/）永远返回一个浮点数。如要使用 floor 除法 并且得到整数结果（丢掉任何小数部分），你可以使用 // 运算符；要计算余数你可以使用 %：

>>> 17 / 3 # 一般除法返回浮点数
5.666666666666667
>>>
>>> 17 // 3 # floor 除法丢掉分数部分
5
>>> 17 % 3 # % 操作符来取余数
2
>>> 5 * 3 + 2 # 结果 * 除数 + 余数
17

通过 Python，还可以使用 ** 运算符计算幂乘方 [1]：

>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2 的 7 次方
128

等号（ = ）用于给变量赋值。赋值之后，在下一个提示符之前不会有任何结果显示：

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

变量在使用前必须 定义 (赋值)，否则会出错：

>>> n # 尝试访问未定义的变量
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

对浮点数有完整的支持；整数和浮点数的混合计算中，整数会被转换为浮点数：

>>> 4 * 3.75 - 1
14.0

交互模式中，最近一个表达式的值赋给变量 _。这样我们就可以把它当作一个桌面计算器，很方便的用于连续计算，例如:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内置变量的魔术效果。

除了 int 和 float，Python 还支持其它数字类型，例如 Decimal 和 Fraction。Python 还内置支持 复数，使用后缀 j 或 J 表示虚数部分（例如，3+5j）。

3.1.2. 字符串

相比数值，Python 也提供了可以通过几种不同方式表示的字符串。它们可以用单引号（'...'）或双引号（"..."）标识 [2]。\ 可以用来转义引号：

>>> 'spam eggs' # 单引号
'spam eggs'
>>> 'doesn\'t' # 使用转义符 \
"doesn't"
>>> "doesn't" # ...或者使用双引号
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

在交互式解释器中，输出的字符串会用引号引起来，特殊字符会用反斜杠转义。虽然可能和输入看上去不太一样，但是两个字符串是相等的。如果字符串中只有单引号而没有双引号，就用双引号引用，否则用单引号引用。print() 函数生成可读性更好的输出，它会省去引号并且打印出转义后的特殊字符：

>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.' # \n 意味着换行
>>> s # 不使用 print() 的话 \n 会被直接输出
'First line.\nSecond line.'
>>> print(s) # 使用 print() 的话 \n 会应用为换行
First line.
Second line.

如果你不想 \ 开头的字符被解释为特殊字符的话，你可以在 原始字符串 第一个引号前加 r ：

>>> print('C:\some\name') # 这里的 \n 意味着换行
C:\some
ame
>>> print(r'C:\some\name') # 注意单引号前的 r
C:\some\name

字符串文本能够分成多行。一种方法是使用三引号："""...""" 或者 '''...'''。行尾换行符会被自动包含到字符串中，但是可以在行尾加上 \ 来避免这个行为。下面的示例：可以使用反斜杠为行结尾的连续字符串，它表示下一行在逻辑上是本行的后续内容：

print("""\
Usage: thingy [OPTIONS]
 -h Display this usage message
 -H hostname Hostname to connect to
""")

将生成以下输出（注意，没有开始的第一行）：

Usage: thingy [OPTIONS]
 -h Display this usage message
 -H hostname Hostname to connect to

字符串可以由 + 操作符连接（粘到一起），可以由 * 表示重复：

>>> # 3 次 'un'，紧跟着 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

相邻的两个及其以上的字符串文本（例如由引号包围的子串）会自动合并在一起：

>>> 'Py' 'thon'
'Python'

你可以使用此功能来切分大块的文本：

>>> text = ('Put several strings within parentheses '
... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

它只能作用于纯字符串文本，不能用于字符串表达式：

>>> prefix = 'Py'
>>> prefix 'thon' # 变量和字符串文本无法合并
 ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
 ...
SyntaxError: invalid syntax

如果你想连接多个变量或者一个变量和一个字符串文本，使用 + ：

>>> prefix + 'thon'
'Python'

字符串也可以被检索（截取）。类似于 C，字符串的第一个字符索引为 0。Python 没有单独的字符类型；一个字符就是一个简单的长度为 1 的字符串：

>>> word = 'Python'
>>> word[0] # 位置 0 的字符
'P'
>>> word[5] # 位置 5 的字符
'n'

索引也可以是负数，这将导致从右边开始计算。例如:

>>> word[-1] # 最后一个字符
'n'
>>> word[-2] # 倒数第二个字符
'o'
>>> word[-6]
'P'

请注意 -0 实际上就是 0，所以它不会导致从右边开始计算，负索引从-1开始。

除了索引，还支持 切片。索引用于获得单个字符，切片 让你获得一个子字符串:

>>> word[0:2] # 从 0 （包含） 到 2 （排除）
'Py'
>>> word[2:5] # 从 2 （包含） 到 5 （排除）
'tho'

注意，包含起始的字符，不包含末尾的字符。这使得 s[:i] + s[i:] 永远等于 s:

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

切片的索引拥有默认值；省略的第一个索引默认为零，省略的第二个索引默认为被切片的字符串的大小:

>>> word[:2] # 从开始到 2 （排除）的字符串
'Py'
>>> word[4:] # 从 4 （包含）到结束的字符串
'on'
>>> word[-2:] # 从倒数第二（包含）到结束的字符串
'on'

有个办法可以很容易地记住切片的工作方式：切片时的索引是在两个字符 之间 。左边第一个字符的索引为 0，而长度为 n 的字符串其最后一个字符的右界索引为 n。例如:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

文本中的第一行数字给出字符串中的索引点 0...6。第二行给出相应的负索引。切片是从 i 到 j 两个数值标示的边界之间的所有字符。

对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如，word[1:3] 是 2 。

试图使用太大的索引会导致错误：

>>> word[42] # word 变量的内容长度只有 6 个字符串
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: string index out of range

不过，索引溢出在切片时会被和谐地处理：

>>> word[4:42]
'on'
>>> word[42:]
''

Python 字符串不可以被更改 —— 它们是 不可变的 。因此，赋值给字符串索引的位置会导致错误:

>>> word[0] = 'J'
 ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
 ...
TypeError: 'str' object does not support item assignment

如果你需要一个不同的字符串，你应该创建一个新的：

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

内置函数 len() 返回字符串长度：

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

参阅

Text Sequence Type --- str

字符串是 序列类型 的例子，它们支持这种类型共同的操作。

String Methods

字符串和 Unicode 字符串都支持大量的方法用于基本的转换和查找。

Formatted string literals

内置表达式的字符串文本。

Format String Syntax

使用 str.format() 字符串格式化相关的信息。

printf-style String Formatting

这里描述了旧式的字符串格式化操作，它们在字符串和 Unicode 字符串是 % 操作符的左操作数时调用。

3.1.3. 列表

Python 有几个 复合 数据类型，用于将一些值组合在一起。最通用的是 list （列表） ，它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型，尽管它们通常如此：

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

就像字符串（以及其它所有内置的 序列 类型）一样，列表可以被索引和切片：

>>> squares[0] # 索引返回元素
1
>>> squares[-1]
25
>>> squares[-3:] # 切片返回新列表
[9, 16, 25]

所有的切片操作都会返回一个包含请求的元素的新列表。这意味着下面的切片操作返回列表一个新的（浅）拷贝副本:

>>> squares[:]
[1, 4, 9, 16, 25]

列表也支持连接这样的操作:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

不像 不可变的 字符串，列表是 可变的，它允许修改元素：

>>> cubes = [1, 8, 27, 65, 125] # 这里有错
>>> 4 ** 3 # 4 的立方是 64 ，不是 65 ！
64
>>> cubes[3] = 64 # 替换错误的值
>>> cubes
[1, 8, 27, 64, 125]

你还可以使用 append() 方法 （后面我们会看到更多关于列表的方法的内容）在列表的末尾添加新的元素：

>>> cubes.append(216) # 添加 6 的 立方
>>> cubes.append(7 ** 3) # 7 的立方
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

也可以对切片赋值，此操作可以改变列表的尺寸，或整个的清空它：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # 替换一些值
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # 移除他们
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # 替换一个空的列表可以清空整个列表的数据
>>> letters[:] = []
>>> letters
[]

内置函数 len() 同样适用于列表:

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

允许嵌套列表（创建一个包含其它列表的列表），例如:

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2. 编程的第一步

当然，我们可以使用 Python 完成比二加二更复杂的任务。例如，我们可以写一个 斐波那契序列 初始子序列的程序，如下所示:

>>> # 斐波那契序列：
... # 两个元素的和定义下一元素
... a, b = 0, 1
>>> while a < 10:
... print(a)
... a, b = b, a+b
...
0
1
1
2
3
5
8

这个例子介绍了几个新功能。

· 第一行包括了一个 多重赋值 ：变量 a 和 b 同时获得了新的值 0 和 1 。并且最后一行又使用了一次。这个演示中，在变量赋值前，首先会完成右边的计算。右边的表达式从左到右计算。

· while 循环在条件（这里是 b < 10 ）为 true 时执行。在 Python 中，类似于 C，任何非零整数都是 true；0 是 false。条件也可以是字符串或列表，实际上可以是任何序列；所有长度不为零的是 true，空序列是 false。示例中的测试是一个简单的比较。标准比较操作符与 C 相同： < （小于）， > （大于）， == （等于）， <= （小于或等于）， >= （大于或等于）和 != （不等于）。

· 循环 体 是 缩进 的：缩进是 Python 组织语句的方法。Python (还)不提供集成的行编辑功能，所以你要为每一个缩进行输入 TAB 或空格。

实践中建议你找个文本编辑来录入复杂的 Python 程序，大多数正经的文本编辑器提供自动缩进。交互式录入复合语句时，必须在最后输入一个空行来标识结束（因为解释器没办法猜测你输入的哪一行是最后一行），需要注意的是同一个语句块中的每一行必须缩进同样数量的空白。

· print() 方法输出指定参数的值。与直接书写表达式来输出你想要的字符串的方式不同（就像我们在早前在计算器例子中那样），它会处理多个参数，浮点数，以及字符串。

字符串打印时不用引号包围，每两个子项之间会插入一个空格，所以你可以把格式弄得很漂亮，像这样：

· >>> i = 256*256
· >>> print('The value of i is', i)
· The value of i is 65536

关键字 end 可以禁止输出换行，或者用一个不同的字符串结束输出。用一个逗号结尾禁止输出换行:

>>> a, b = 0, 1
>>> while a < 1000:
... print(a, end=',')
... a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

脚注：

[1]

因为 ** 的优先级高于 -，所以 -3**2 将解释为 -(3**2) 且结果为 -9。为了避免这点并得到 9，你可以使用 (-3)**2。

[2]

与其它语言不同，特殊字符例如 \n 在单引号（'...'）和双引号（"..."）中具有相同的含义。两者唯一的区别是在单引号中，你不需要转义 " （但你必须转义 \' )，反之亦然。