上面的例子中，输出和输入别离由大于号和句号提示符（>>> 和 …）标注：如果想重现这些例子，就要在解释器的提示符后，输出（提示符前面的）那些不蕴含提示符的代码行。须要留神的是在练习中遇到的隶属提示符示意你须要在最初多输出一个空行，解释器能力晓得这是一个多行命令的完结。

本手册中的很多示例——包含那些带有交互提示符的——都含有正文。Python 中的正文以 # 字符起始，直至理论的行尾（译注——这里原作者用了 physical line 以示意理论的换行而非编辑器的主动换行）。正文能够从行首开始，也能够在空白或代码之后，然而不呈现在字符串中。文本字符串中的 # 字符仅仅示意 #。代码中的正文不会被 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 # 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
变量在应用前必须“定义”(赋值)，否则会出错:

try to access an undefined variable

… n
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
NameError: name ‘n’ is not defined
浮点数有残缺的反对；整数和浮点数的混合计算中，整数会被转换为浮点数:

3 * 3.75 / 1.5
7.5
7.0 / 2
3.5
交互模式中，最近一个表达式的值赋给变量 _。这样咱们就能够把它当作一个桌面计算器，很不便的用于间断计算，例如:

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’ # single quotes
‘spam eggs’
‘doesn\’t’ # use \’ to escape the single quote…
“doesn’t”
“doesn’t” # …or use double quotes instead
“doesn’t”
‘”Yes,” he said.’
‘”Yes,” he said.’
“\”Yes,\” he said.”
‘”Yes,” he said.’
‘”Isn\’t,” she said.’
‘”Isn\’t,” she said.’
在交互式解释器中，输入的字符串会用引号引起来，特殊字符会用反斜杠本义。尽管可能和输出看上去不太一样，然而两个字符串是相等的。如果字符串中只有单引号而没有双引号，就用双引号援用，否则用单引号援用。print() 函数生成可读性更好的输入, 它会省去引号并且打印出本义后的特殊字符：

‘”Isn\’t,” she said.’
‘”Isn\’t,” she said.’
print(‘”Isn\’t,” she said.’)
“Isn’t,” she 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’
它只用于两个字符串文本，不能用于字符串表达式:

prefix = ‘Py’
prefix ‘thon’ # can’t concatenate a variable and a string literal
…
SyntaxError: invalid syntax
(‘un’ * 3) ‘ium’
…
SyntaxError: invalid syntax
如果你想连贯多个变量或者连贯一个变量和一个字符串文本，应用 +:

prefix + ‘thon’
‘Python’
这个性能在你想切分很长的字符串的时候特地有用:

text = (‘Put several strings within parentheses ‘

        'to have them joined together.')

text
‘Put several strings within parentheses to have them joined together.’
字符串也能够被截取(检索)。相似于 C，字符串的第一个字符索引为 0。Python 没有独自的字符类型；一个字符就是一个简略的长度为 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，所以它不会导致从左边开始计算。

除了索引，还反对 切片 。索引用于取得单个字符， 切片 让你取得一个子字符串:

>>> 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 两个数值标示的边界之间的所有字符。

对于非负索引，如果高低都在边界内，切片长度就是两个索引之差。例如，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

Python 可能优雅地解决那些没有意义的切片索引：一个过大的索引值 (即下标值大于字符串理论长度) 将被字符串理论长度所代替，当上边界比下边界大时 (即切片左值大于右值) 就返回空字符串:

>>> 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

See also

• [Text Sequence Type — str]

  字符串是 序列类型 的例子，它们反对这种类型独特的操作。

• [String Methods]

  字符串和 Unicode 字符串都反对大量的办法用于根本的转换和查找。

• [String Formatting]

  这里形容了应用 [str.format()] 进行字符串格式化的信息。

• [String Formatting Operations]

  这里形容了新式的字符串格式化操作，它们在字符串和 Unicode 字符串是 % 操作符的左操作数时调用。你要不要也来试试，用 Python 测测你和女神的颜值差距（仅供娱乐，请勿联想）如果真的遇到好的共事, 那算你背运，加油，放松学到手。
  python、爬虫技巧资源分享增加围鑫（同音）:762459510
  蕴含 python, pythonweb、爬虫、数据分析等 Python 技巧, 以及人工智能、大数据、数据挖掘、自动化办公等的学习办法。
  打造从零根底到我的项目开发上手实战全方位解析!

3.1.3. 列表

Python 有几个 复合 数据类型，用于示意其它的值。最通用的是 list (列表)，它能够写作中括号之间的一列逗号分隔的值。列表的元素不用是同一类型:

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

就像字符串 (以及其它所有内建的 [序列] 类型) 一样，列表能够被索引和切片:

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[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]  # 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:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

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

• 第一行包含了一个 多重赋值：变量 a 和 b 同时取得了新的值 0 和 1 最初一行又应用了一次。

  在这个演示中，变量赋值前，左边首先实现计算。左边的表达式从左到右计算。

• 条件（这里是 b < 10）为 true 时，[while] 循环执行。在 Python 中，相似于 C，任何非零整数都是 true；0 是 false。条件也能够是字符串或列表，实际上能够是任何序列；

  所有长度不为零的是 true，空序列是 false。示例中的测试是一个简略的比拟。规范比拟操作符与 C 雷同：<，>，==，<=，>= 和 !=。

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

  实际中倡议你找个文本编辑来录入简单的 Python 程序，大多数文本编辑器提供主动缩进。交互式录入复合语句时，必须在最初输出一个空行来标识完结（因为解释器没方法猜想你输出的哪一行是最初一行），须要 留神的是同一个语句块中的每一行必须缩进同样数量的空白。为了帮忙大家在学习 python 的路上，少走弯路，少掉坑，大家能够去听一位 python 高手的课程，他每天晚上 8 点都会在网上有收费的直播课，会讲到 python，讲的十分的通俗易懂，而且还很好玩风趣，既能从常识的层面深入浅出，更能从思维的角度让咱们意识到 python 到底应该怎么学习，跟高手学习的最大价值就是，听君一席话，胜读十年书，自学的价值在于，自学大半年，不如他人有高手带着学一天，一年 365 天，他每天晚上都会讲课的，有喜爱听的同学，能够去他的的卫鑫 *（同音）：前排的是：762，两头一排是：459，后排的一组是：510 , 把以上三组字母依照程序组合起来即可，十分的简略的，牛顿已经说过，站在他人的肩膀上，能力看的更高更远，海纳百川，去驯服 python 世界的星辰大海吧。

• 关键字 [print()] 语句输入给定表达式的值。它管制多个表达式和字符串输入为你想要字符串（就像咱们在后面计算器的例子中那样）。

  字符串打印时不必引号突围，每两个子项之间插入空间，所以你能够把格局弄得很漂亮，像这样:

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

  用一个逗号结尾就能够禁止输入换行:

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

Footnotes

[Next] “4. 深刻 Python 流程管制 ”)”2. 应用 Python 解释器 ”)

\