第三章 简单介绍介绍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 its inside quotes'
3.1 python用做计算器
让我们尝试一下简单的命令，启动解释器并且等待>>>提示符的出现（不会很长时间的）
3.1.1 数学计算
解释器就充当一个简单的计算器，你可以输入一些表达式，并且他回打印一些值，表达式的语法是直接去输出的，运算符包括+，-，*，/，这些都在其他的计算机的高级语言中也会有作用，多重运算也可以用（）来分组，例如：
>>>2+2
4
>>>50-5*6
20
>>>(50-5*6)/4
5.0
>>>8/5 #division always return a floating point number
1.6
一般整数的类型是int，小数的类型为float，我们接下来会看到更多的数值类型在这个文档中。
整除一般返回一个浮点数，地板除一般会得到一个整数类型的数字，你可以使用（//）这个运算符，计算余数的时候你可以用%：
>>> 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中，你可以用**来计算指数的运算。
>>> 5 ** 2 # 5 squared
25
>>> 2 ** 7 # 2 to the power of 7
128
在python中，=的作用是相当于赋值，在下一次赋值之前，都是不会发生改变的。
>>> 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
python也支持整数，浮点数的混合运算。
>>> 4 * 3.75 - 1
14.0
在交互模式下，变量的赋值是在最后一次对变量的调用，这就意味这你使用python的shell作为一个桌面级的计算器的时候，这个很容去用变量计算。例如：
>>> 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 number），用J或者j来表明数字的虚部。
3.1.2 字符串
除过数字类型外，python也支持字符串的处理，可以用很多种形式来表示，可以用单引号，双引号，也可以用反斜线来表示多行的字符串。
>>> '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，这里没有分离的字符，没有字符代表一个元素，占一个索引位置。
>>> 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:]加在一起表示的事整个字符串一样。
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
切片有一些比较有用的默认。可是不写的话一般表示的都是从0开始。
>>> 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
然而，在末尾的索引可以使用无限大的数字，一般无限大的数字可以表示最后一位数字。
>>> word[4:42]
'on'
>>> word[42:]
''
python的索引是不可以被赋值的，他们是不可变类型的。因此， 不能对字符串的索引赋值。
>>> 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
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 a < 10:
... print(a)
... a, b = b, a+b
...
0
1
1
2
3
5
8
这个实例给我们介绍了几个特征：
第一行包含了多变量的赋值，a和b分别赋值了0和1.在最后一行的又被用到了。在表达式对a和b进行计算之后又将他们用变量赋值给了新的值，不停如此。
在while循环中，如果他的值小于10的情况下都会满足，在python中，像C，任何非0的整数的值都为True。0为False。这种情况有可能会是一个字符串或者是一个列表，在任何的序列中，任何非0的数字都是True。空的序列为False。这个可以用一个简单的例子来证明。标准的比较运算符和C的是一样，<less than,>greater than,==equal to,<=less than or equal to,>=greater than or equal to ,!=not equal to.
循环的本身用缩进来表示关系的。python中用缩进来表示代码块的关系，你可以在一段代码大开始用tab或者空格来表示代码的归属关系，在练习中，你可能准备更复杂的输入方式来编写代码。不过在一些编辑其中，它们可以更加轻松的实现自动缩进。
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,
网友评论