英文原文
3. An Informal Introduction to Python
In the following examples, input and output are distinguished by the presence or absence of prompts (>>> and …):
to repeat the example, you must type everything after the prompt, when the prompt appears; lines that do not begin with a prompt are output from the interpreter. Note that a secondary prompt on a line by itself in an example means you must type a blank line; this is used to end a multi-line command.
Many of the examples in this manual, even those entered at the interactive prompt, include comments. Comments in Python start with the hash character, #
, and extend to the end of the physical line. A comment may appear at the start of a line or following whitespace or code, but not within a string literal. A hash character within a string literal is just a hash character. Since comments are to clarify code and are not interpreted by Python, they may be omitted when typing in examples.
Some examples:
# this is the first comment
spam = 1 # and this is the second comment
# ... and now a third!
text = "# This is not a comment because it's inside quotes."
3.1. Using Python as a Calculator
Let’s try some simple Python commands. Start the interpreter and wait for the primary prompt, >>>
. (It shouldn’t take long.)
3.1.1. Numbers
The interpreter acts as a simple calculator: you can type an expression at it and it will write the value. Expression syntax is straightforward: the operators +, -, *
and /
work just like in most other languages (for example, Pascal
or C
); parentheses (()
) can be used for grouping. For example:
>>>
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # division always returns a floating point number
1.6
中文翻译
3. Python简介
以下的示例中,输入和输出通过是否存在提示符(>>> and ...)
来区分:如果要重复该示例,你必须在提示符出现后,输入提示符后面的所有内容;没有以提示符开头的行是解释器的输出。注意示例中出现从提示符意味着你一定要在最后加上一个空行;这用于结束一个多行命令。
本手册中的很多示例,甚至在交互方式下输入的示例,都带有注释。Python 中的注释以井号 #
为开始,直到物理行的末尾结束。注释可以从行首开始,也可以跟在空白或代码之后,但不能包含在字符串内。字符串字面值中的一个#
只是一个#
字符。因为注释只是为了解释代码并且不会被Python解释器解释,所以敲入示例的时候可以忽略它们。
例如:
# this is the first comment
spam = 1 # and this is the second comment
# ... and now a third!
text = "# This is not a comment because it's inside quotes."
3.1. 将Python用作计算
让我们尝试一些简单的 Python 命令。启动解释器然后等待主提示符 >>>
。(应该不需要很长时间。)
3.1.1. 数字
解释器的作用就像一个简单的计算器:你可以在它上面输入一个表达式,它会写出这个值。表达式语法非常简单: 运算符 +, -, *
及 /
的使用方法与其他语言一致 ( 例如 Pascal
或 C
); 括号 (()) 可以用来进行分组。例如:
>>>
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # division always returns a floating point number
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 中的注释以 #
字符起始,直至实际的行尾。注释可以从行首开始,也可以在空白或代码之后,但是不出现在字符串中。文本字符串中的 #
字符仅仅表示 #
。代码中的注释不会被 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,所以它不会导致从右边开始计算。
除了索引,还支持 切片。索引用于获得单个字符,切片 让你获得一个子字符串:
>>> 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
参阅
字符串是 序列类型 的例子,它们支持这种类型共同的操作。
字符串和 Unicode 字符串都支持大量的方法用于基本的转换和查找。
内置表达式的字符串文本。
使用
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
用一个逗号结尾就可以禁止输出换行:
```
>>> 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 在单引号('...' )和双引号("..." )中具有相同的含义。两者唯一的区别是在单引号中,你不需要转义 " (但你必须转义 \' ),反之亦然。 |