3 Python简介
在下面的例子中，输入和输出是通过提示(的存在或不存在区别>>>和...)：重复的例子中，您必须在提示符后输入所有的一切，出现提示时; 没有以提示符开始的行，是解释器输出。请注意，在上一个例子的线本身的从属提示符意味着你必须输入一个空行; 这是用来结束一个多行命令。
许多本手册中的例子，甚至有一些在交互提示符中，包括注释。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命令。启动解释器然后等(它不应该需要很长时间)待主提示符>>>ssss
3.1.1。数字
解释器的行为就像是一个计算器：你可以向它输入一个表达式，它会返回结果。表达式的语法很简单：运营商+，- ，*和/就像在大多数其他语言的工作(例如，C或Pascal); 括号(()) 可用于分组。例如：
>>> 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)具有类型整型，那些带有小数部分(例如5.0，1.6)的类型为 浮动。我们将看到更多关于数字类型后面的教程。
司(/)总是返回一个浮点数。做地板事业部，并得到一个整数的结果(不考虑任何小数结果)，你可以使用/ / 操作符; 计算剩余可使用％：
>>> 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
>>> 5 * 3 + 2 # result * divisor + remainder
17
等号(=)，用于分配一个值给一个变量。事后，没有结果的下一个交互式的提示之前显示：
>>> 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
有浮点全力支持; 混合型的操作数运算符将整数操作数为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.55
在交互模式下，最近一次表达式赋值给变量 _。这意味着，当你在使用Python当做桌面计算器，它是比较容易的进行连续计算，例如：
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
这个变量应该由用户被视为只读。不要一个明确的值赋给它 - 你将创建一个独立的局部变量同名屏蔽内置有它的魔力的行为变量。
除了INT和浮动，Python支持其它类型的数字，如小数和分数。Python还内置了支持复数，并使用Ĵ或Ĵ后缀来表示虚部(如3 +5Ĵ)。
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.'
在交互式解释器，输出字符串括在引号和特殊字符进行转义用的反斜杠。虽然这可能看起来有时从输入(封闭引号可能会改变)不同，这两个字符串是等效的。该字符串括在双引号如果字符串包含一个单引号，没有双引号，否则是单引号括起来。在打印()函数产生一个更可读的输出，通过省略引号括和印刷转义和特殊字符：
>>> '"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.
如果您不希望通过开头的字符\被解释为特殊字符，则可以使用原始字符串通过添加ř第一次报价之前：
>>> 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.'
字符串可以被索引(下标)，具有索引0的第一个字符。没有单独的字符类型; 一个字符仅仅是大小为一的字符串：
>>> 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。那么字符串的最后一个字符的右边缘Ñ个字符的索引Ñ，例如：
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
数字的第一行给出了指数0 ... 6字符串中的位置; 第二行是对应的负索引。切片从我到 Ĵ由标记的边缘之间的所有字符我和Ĵ分别。
对于非负索引，切片的长度是指数的差异，如果两者都在一定范围内。例如，长度字[1:3]是2。
尝试使用一个索引过大，将导致一个错误：
>>> word[42] # the word only has 7 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字符串不能被改变-它们是不可变的。因此，分配给在一个错误的结果字符串索引位置：
>>> 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
另请参阅 文本序列类型 - str 字符串是实例序列类型，并支持这些类型所支持的常用操作。 字符串方法 弦乐支持大量的方法基本变换和搜索。 字符串格式化 关于使用字符串格式化信息str.format()是描述在这里。 printf风格的格式化字符串 旧的格式化操作时调用字符串和Unicode字符串是左操作数％运营商更详细描述。
3.1.3。清单
Python知道了一些复合数据类型，用于组织其它的值。最通用的是列表，可以写成方括号之间用逗号分隔值(项目)列表。列表可能包含不同类型的物品，但通常的项目都具有相同的类型。
>>> 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
这个例子引入了一些新的功能。
第一行包含一个多重赋值：变量一和b 同时被赋值为0和1。在最后一行此再次使用，这表明在右手侧的表达式都计算一次前的任何指配的发生。右手侧的表达式求值从左边到右边。
的，而循环只要条件执行(这里：b < 10)，仍是如此。在Python和C一样，任何非零整数值为true; 零是假的。这种状况也可以是字符串或链表，事实上任何序列; 具有非零长度事情是真实的，空序列为假。在这个例子中使用的测试是一个简单的比较。标准的比较运算符写法相同，The standard comparison operators are written the same as in C: < less than, > greater than, == equal to, <= less than or equal to, >= greater than or equal to , != not equal to.
在身体循环被缩进：缩进是Python对语句分组的方法。在交互提示符中，你必须在每一个缩线制表符或空格(S)。在实践中你将准备为Python更复杂的输入用文本编辑器; 所有像样的文本编辑器有自动缩进功能。当一个复合语句交互式的输入，它必须跟一个空行表示完成(因为当你输入最后一行解析器无法猜测)。请注意，一个基本块内的每一行必须以相同的量缩进。
在打印()函数将参数(S)的它被赋予的价值。它不同于只写你想写(正如我们在前面的计算器示例一样)，在它处理多个参数，浮点运算量的方式表达，和字符串。字符串输出时没有引号，并插入一个空格的项目之间，所以你可以格式化的东西很好，像这样：
>>> 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,
脚注
[1] 由于**的优先级高于- ，-3**2将被解释为-(3**2) ，从而导致-9。为了避免这种情况，并得到9中，可以使用(-3)**2。
[2] 不像其他的语言，特殊字符，如\n具有相同的含义既包含单('...' )和双("..." )引号。两者之间的唯一区别是，单引号内你不需要逃避"(但你必须逃离\' )，反之亦然。