3. 关于python的非正式介绍¶
在下面的示例中，输入和输出通过提示的存在或不存在来区分。 (>>> 和 ... ）：要重复该示例，当提示出现时，必须在提示后键入所有内容；不以提示开头的行将从解释器输出。注意，在示例中，行上的第二个提示本身意味着您必须键入空行；这用于结束多行命令。
本手册中的许多示例，甚至是在交互提示下输入的示例，都包含注释。python中的注释以散列字符开头， # ，并延伸到物理行的末尾。注释可以出现在行的开头或后面的空白或代码，但不能出现在字符串文本中。字符串文本中的hash字符只是一个hash字符。由于注释是为了澄清代码，而不是由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. 数字¶
解释器充当一个简单的计算器：您可以在解释器上键入一个表达式，它将写入该值。表达式语法很简单：运算符 +, -, * and / work just like in most other languages (for example, Pascal or C); parentheses (`` （）```）可用于分组。例如：：
>>> 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 division 并得到一个整数结果（丢弃任何分数结果），您可以使用 // 运算符；计算可以使用的余数 % ：：
>>> 17 / 3 # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3 # floor division discards the fractional part
5
>>> 17 % 3 # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2 # result * divisor + remainder
17
对于python，可以使用 ** 计算功率的操作员 1 ：：
>>> 5 ** 2 # 5 squared
25
>>> 2 ** 7 # 2 to the power of 7
128
等号 (= ）用于为变量赋值。之后，在下一个交互式提示前不会显示任何结果：
>>> width = 20
>>> height = 5 * 9
>>> width * height
900
如果一个变量没有“定义”（分配了一个值），尝试使用它会给您一个错误：
>>> n # try to access an undefined variable
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
完全支持浮点；具有混合类型操作数的运算符将整型操作数转换为浮点：
>>> 4 * 3.75 - 1
14.0
在交互模式下，最后一个打印表达式被分配给变量 _ . 这意味着当您将python用作桌面计算器时，继续计算会更容易一些，例如：
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
用户应将此变量视为只读。不要显式地给它赋值——您将创建一个具有相同名称的独立局部变量，用其神奇的行为来掩盖内置变量。
除了 int 和 float ，python支持其他类型的数字，例如 Decimal 和 Fraction . python还内置了对 complex numbers ，并使用 j 或 J 表示虚部的后缀（例如 3+5j ）
3.1.2. 字符串¶
除了数字之外，python还可以操作字符串，这些字符串可以用多种方式表示。它们可以用单引号括起来 ('...' ）或双引号 ("..." ）结果相同 2. \ 可用于转义引号：
>>> 'spam eggs' # single quotes
'spam eggs'
>>> 'doesn\'t' # use \' to escape the single quote...
"doesn't"
>>> "doesn't" # ...or use double quotes instead
"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 means newline
>>> s # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s) # with print(), \n produces a new line
First line.
Second line.
如果您不希望字符由 \ 要解释为特殊字符，可以使用 原始字符串 通过添加一个 r 在第一个引用之前：
>>> print('C:\some\name') # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name') # note the r before the quote
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 times 'un', followed by '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' # can't concatenate a variable and a string literal
File "<stdin>", line 1
prefix 'thon'
^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
File "<stdin>", line 1
('un' * 3) 'ium'
^
SyntaxError: invalid syntax
如果要连接变量或变量和文字，请使用 + ：：
>>> prefix + 'thon'
'Python'
字符串可以是 索引的 （下标），第一个字符的索引为0。没有单独的字符类型；字符只是一个大小为1的字符串：
>>> word = 'Python'
>>> word[0] # character in position 0
'P'
>>> word[5] # character in position 5
'n'
指数也可以是负数，从右边开始计数：
>>> word[-1] # last character
'n'
>>> word[-2] # second-last character
'o'
>>> word[-6]
'P'
注意，由于-0与0相同，负指数从-1开始。
除了索引之外， 切片 也支持。当索引用于获取单个字符时， 切片 允许您获取子字符串：：
>>> word[0:2] # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
'tho'
请注意如何始终包括开始和结束。这确保了 s[:i] + s[i:] 总是等于 s ：：
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
切片索引有有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为要切片的字符串的大小。：：
>>> word[:2] # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:] # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'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 由标记边缘之间的所有字符组成 i 和 j ，分别。
对于非负索引，如果两个索引都在界限内，则切片的长度就是索引的差。例如，长度 word[1:3] 是2。
尝试使用太大的索引将导致错误：：
>>> word[42] # the word only has 6 characters
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
但是，当用于切片时，超出范围的切片索引处理得当：
>>> word[4:42]
'on'
>>> word[42:]
''
不能更改python字符串---它们是 immutable . 因此，分配给字符串中的索引位置会导致错误：：
>>> word[0] = 'J'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
如果需要其他字符串，则应创建一个新字符串：
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
内置功能 len() 返回字符串的长度：：
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
参见
- 文本序列类型--- str
字符串是 序列类型 ，并支持此类类型支持的公共操作。
- 字符串方法
字符串支持大量用于基本转换和搜索的方法。
- 格式化字符串文本
具有嵌入表达式的字符串文本。
- 格式字符串语法
有关字符串格式设置的信息
str.format().- printf -样式字符串格式
当字符串是
%这里更详细地描述了运算符。
3.1.3. 列表¶
Python 知道很多 复合 数据类型，用于将其他值组合在一起。最通用的是 list ，可以写成方括号之间逗号分隔值（项）的列表。列表可能包含不同类型的项，但通常所有项都具有相同的类型。：：
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
像字符串（以及所有其他内置的 sequence 类型），列表可以索引和切片：
>>> squares[0] # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:] # slicing returns a new list
[9, 16, 25]
所有切片操作都返回一个包含所请求元素的新列表。这意味着下面的片段返回 shallow copy 名单的：
>>> squares[:]
[1, 4, 9, 16, 25]
列表还支持连接等操作：
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
不同于字符串 immutable 列表是 mutable 类型，即可以更改其内容：
>>> cubes = [1, 8, 27, 65, 125] # something's wrong here
>>> 4 ** 3 # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64 # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]
也可以在列表末尾添加新项目，方法是使用 append() 方法 （稍后我们将看到更多关于方法的信息）：：
>>> cubes.append(216) # add the cube of 6
>>> cubes.append(7 ** 3) # and the cube of 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']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> 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用于更复杂的任务，而不是将两个和两个添加在一起。例如，我们可以编写 Fibonacci series 如下：
>>> # Fibonacci series:
... # the sum of two elements defines the next
... 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只要条件（此处：a < 10）仍然是真的。在python中，和在c中一样，任何非零整数值都是真的；零是假的。条件也可以是字符串或列表值，实际上是任何序列；任何非零长度的值为真，空序列为假。示例中使用的测试是一个简单的比较。标准比较运算符的编写方式与C:<（小于）>（大于）==（等于）<=（小于或等于）>=（大于或等于）和!=（不等于）这个 body 循环的 缩进的 ：缩进是Python对语句进行分组的方式。在交互式提示下，您必须为每行缩进键入一个选项卡或空格。实际上，您将使用文本编辑器为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,
脚注