python 简明教程_学习笔记（一）

时间 2019-11-13

原文原文链接

基本概念：html

1，常量python

2，数,web

3，字符串express

使用单引号（'）数据结构
你能够用单引号指示字符串，就如同'Quote me on this'这样。全部的空白，即空格和制表符都照原样保留。编辑器
使用双引号（"）函数
在双引号中的字符串与单引号中的字符串的使用彻底相同，例如"What's your name?"。工具
使用三引号（'''或"""）oop
利用三引号，你能够指示一个多行的字符串。你能够在三引号中自由的使用单引号和双引号。例如：学习

#!/user/bin/python 
# -*- coding: utf8 -*- 
print '''This is a multi-line string. This is the first line.
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''

输出结果为：

This is a multi-line string. This is the first line.
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."

转义符
如果你想输出的一个字符串中包含一个单引号（'），你确定不会用'What's your name?'来指示它，由于Python会弄不明白这个字符串从何处开始，何处结束。那么此时你能够选用双引号号，"What's your name?"表示，同时也能够经过转义符来完成这个任务。你用\'来指示单引号——注意这个反斜杠。如今你能够把字符串表示为'What\'s your name?'。
相似地，要在双引号字符串中使用双引号自己的时候，也能够借助于转义符。另外，你能够用转义符\\来指示反斜杠自己。
值得注意的一件事是，在一个字符串中，行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行。例如：

print "This is the first sentence.\
This is the second sentence."

输出的结果为：

This is the first sentence.This is the second sentence.

天然字符串
若是你想要指示某些不须要如转义符那样的特别处理的字符串，那么你须要指定一个天然字符串。天然字符串经过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by \n"。

print "Newlines are indicated by \n"

输出：

Newlines are indicated by

print r"Newlines are indicated by \n"

输出：

Newlines are indicated by \n

Unicode字符串
Unicode是书写国际文本的标准方法。若是你想要用你的母语如北印度语或阿拉伯语写文本，那么你须要有一个支持Unicode的编辑器。相似地，Python容许你处理Unicode文本——你只须要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。
记住，在你处理文本文件的时候使用Unicode字符串，特别是当你知道这个文件含有用非英语的语言写的文本。
字符串是不可变的
这意味着一旦你创造了一个字符串，你就不能再改变它了。虽然这看起来像是一件坏事，但实际上它不是。咱们将会在后面的程序中看到为何咱们说它不是一个缺点。
按字面意义级连字符串
若是你把两个字符串按字面意义相邻放着，他们会被Python自动级连。例如，'What\'s' 'your name?'会被自动转为"What's your name?"。

4，变量

5，标示符的命名

变量是标识符的例子。标识符是用来标识某样东西的名字。在命名标识符的时候，你要遵循这些规则：

标识符的第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（‘ _ ’）。
标识符名称的其余部分能够由字母（大写或小写）、下划线（‘ _ ’）或数字（0-9）组成。
标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。注意前者中的小写n和后者中的大写N。
有效标识符名称的例子有i、__my_name、name_23和a1b2_c3。
无效标识符名称的例子有2things、this is spaced out和my-name。,

9，缩进

空白在Python中是重要的。事实上行首的空白是重要的。它称为缩进。在逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。

这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。

如何缩进
不要混合使用制表符和空格来缩进，由于这在跨越不一样的平台的时候，没法正常工做。我强烈建议你在每一个缩进层次使用单个制表符或两个或四个空格。
选择这三种缩进风格之一。更加剧要的是，选择一种风格，而后一向地使用它，即只使用这一种风格。

运算符与表达式：

1，简介

2，运算符

表5.1 运算符与它们的用法

运算符	名称	说明	例子
+	加	两个对象相加	3 + 5获得8。'a' + 'b'获得'ab'。
-	减	获得负数或是一个数减去另外一个数	-5.2获得一个负数。50 - 24获得26。
*	乘	两个数相乘或是返回一个被重复若干次的字符串	2 * 3获得6。'la' * 3获得'lalala'。
**	幂	返回x的y次幂	3 ** 4获得81（即3 * 3 * 3 * 3）
/	除	x除以y	4/3获得1（整数的除法获得整数结果）。4.0/3或4/3.0获得1.3333333333333333
//	取整除	返回商的整数部分	4 // 3.0获得1.0
%	取模	返回除法的余数	8%3获得2。-25.5%2.25获得1.5
<<	左移	把一个数的比特向左移必定数目（每一个数在内存中都表示为比特或二进制数字，即0和1）	2 << 2获得8。——2按比特表示为10
>>	右移	把一个数的比特向右移必定数目	11 >> 1获得5。——11按比特表示为1011，向右移动1比特后获得101，即十进制的5。
&	按位与	数的按位与	5 & 3获得1。
\|	按位或	数的按位或	5 \| 3获得7。
^	按位异或	数的按位异或	5 ^ 3获得6
~	按位翻转	x的按位翻转是-(x+1)	~5获得-6。
<	小于	返回x是否小于y。全部比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	5 < 3返回0（即False）而3 < 5返回1（即True）。比较能够被任意链接：3 < 5 < 7返回True。
>	大于	返回x是否大于y	5 > 3返回True。若是两个操做数都是数字，它们首先被转换为一个共同的类型。不然，它老是返回False。
<=	小于等于	返回x是否小于等于y	x = 3; y = 6; x <= y返回True。
>=	大于等于	返回x是否大于等于y	x = 4; y = 3; x >= y返回True。
==	等于	比较对象是否相等	x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!=	不等于	比较两个对象是否不相等	x = 2; y = 3; x != y返回True。
not	布尔“非”	若是x为True，返回False。若是x为False，它返回True。	x = True; not x返回False。
and	布尔“与”	若是x为False，x and y返回False，不然它返回y的计算值。	x = False; y = True; x and y，因为x是False，返回False。在这里，Python不会计算y，由于它知道这个表达式的值确定是False（由于x是False）。这个现象称为短路计算。
or	布尔“或”	若是x是True，它返回True，不然它返回y的计算值。	x = True; y = False; x or y返回True。短路计算在这里也适用。

3，运算符优先级

下面这张表（与Python参考手册中的那个表如出一辙）已经顾及了完整的须要。事实上，我建议你使用圆括号来分组运算符和操做数，以便可以明确地指出运算的前后顺序，使程序尽量地易读。例如，2 + (3 * 4)显然比2 + 3 * 4清晰。与此同时，圆括号也应该正确使用，而不该该用得过滥（好比2 + (3 + 4)）。

表5.2 运算符优先级

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
\|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments...)	函数调用
(experession,...)	绑定或元组显示
[expression,...]	列表显示
{key:datum,...}	字典显示
'expression,...'	字符串转换

其中咱们尚未接触过的运算符将在后面的章节中介绍。

在表中列在同一行的运算符具备相同优先级。例如，+和-有相同的优先级。

计算顺序

默认地，运算符优先级表决定了哪一个运算符在别的运算符以前计算。然而，若是你想要改变它们的计算顺序，你得使用圆括号。例如，你想要在一个表达式中让加法在乘法以前计算，那么你就得写成相似(2 + 3) * 4的样子。

结合规律

运算符一般由左向右结合，即具备相同优先级的运算符按照从左向右的顺序计算。例如，2 + 3 + 4被计算成(2 + 3) + 4。一些如赋值运算符那样的运算符是由右向左结合的，即a = b = c被处理为a = (b = c)。

控制流：

1,简介

2,if语句

使用if语句

#!/user/bin/python 
# -*- coding: utf8 -*- 
number = 23
guess = int(raw_input('Enter an integer : '))
if guess == number:
    print 'Congratulations, you guessed it.' # New block starts here
    print "(but you do not win any prizes!)" # New block ends here
elif guess < number:
    print 'No, it is a little higher than that' # Another block
    # You can do whatever you want in a block ...
else:
    print 'No, it is a little lower than that' 
    # you must have guess > number to reach here
print 'Done'
# This last statement is always executed, after the if statement is executed

输出结果：（每执行一次只会有一次结果，我整合到一起了）

$ python if.py
Enter an integer : 50
No, it is a 
little lower than that
Done
$ python if.py
Enter an integer : 22
No, 
it is a little higher than that
Done
$ python if.py
Enter an integer : 23
Congratulations, you guessed it.
(but you do not win any prizes!)
Done

3,while语句

使用while语句

只要在一个条件为真的状况下，while语句容许你重复执行一块语句。while语句是所谓循环语句的一个例子。while语句有一个可选的else从句。

#!/user/bin/python 
# -*- coding: utf8 -*- 
number = 23
running = True
while running:
    guess = int(raw_input('Enter an integer : '))
    if guess == number:
        print 'Congratulations, you guessed it.' 
        running = False # this causes the while loop to stop
    elif guess < number:
        print 'No, it is a little higher than that' 
    else:
        print 'No, it is a little lower than that' 
else:
    print 'The while loop is over.' 
    # Do anything else you want to do here
print 'Done'

输出结果：

Enter an integer : 50
No, it is a little lower than that
Enter an integer : 22
No, it is a little higher than that
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done

它如何工做

在这个程序中，咱们仍然使用了猜数游戏做为例子，可是这个例子的优点在于用户能够不断的猜数，直到他猜对为止——这样就不须要像前面那个例子那样为每次猜想重复执行一遍程序。这个例子恰当地说明了while语句的使用。

咱们把raw_input和if语句移到了while循环内，而且在while循环开始前把running变量设置为True。首先，咱们检验变量running是否为True，而后执行后面的while-块。在执行了这块程序以后，再次检验条件，在这个例子中，条件是running变量。若是它是真的，咱们再次执行while-块，不然，咱们继续执行可选的else-块，并接着执行下一个语句。

当while循环条件变为False的时候，else块才被执行——这甚至也多是在条件第一次被检验的时候。若是while循环有一个else从句，它将始终被执行，除非你的while循环将永远循环下去不会结束！

True和False被称为布尔类型。你能够分别把它们等效地理解为值1和0。在检验重要条件的时候，布尔类型十分重要，它们并非真实的值1。

else块事实上是多余的，由于你能够把其中的语句放在同一块（与while相同）中，跟在while语句以后，这样能够取得相同的效果。

去除else：

#!/user/bin/python 
# -*- coding: utf8 -*- 
number = 23
running = True
while running:
    guess = int(raw_input('Enter an integer : '))
    if guess == number:
        print 'Congratulations, you guessed it.' 
        running = False # this causes the while loop to stop
    elif guess < number:
        print 'No, it is a little higher than that' 
    else:
        print 'No, it is a little lower than that' 
print 'The while loop is over.' 
print 'Done'

结果：

Enter an integer : 50
No, it is a little lower than that
Enter an integer : 22
No, it is a little higher than that
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done

或者：

number = 23
running = True
while running:
    guess = int(raw_input('Enter an integer : '))
    if guess == number:
        print 'Congratulations, you guessed it.' 
        running = False # this causes the while loop to stop
    elif guess < number:
        print 'No, it is a little higher than that' 
    else:
        print 'No, it is a little lower than that' 
    print 'The while loop is over.' 
    # Do anything else you want to do here
print 'Done'

结果：

Enter an integer : 50
No, it is a little lower than that
The while loop is over.
Enter an integer : 22
No, it is a little higher than that
The while loop is over.
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done

不一样的缩进，不一样的结果：

number = 23
running = True
while running:
    guess = int(raw_input('Enter an integer : '))
    if guess == number:
        print 'Congratulations, you guessed it.' 
        running = False # this causes the while loop to stop
    elif guess < number:
        print 'No, it is a little higher than that' 
    else:
        print 'No, it is a little lower than that' 
        print 'The while loop is over.' 
    # Do anything else you want to do here
print 'Done'

结果：

Enter an integer : 50
No, it is a little lower than that
The while loop is over.
Enter an integer : 22
No, it is a little higher than that
Enter an integer : 23
Congratulations, you guessed it.
Done

4,for循环

使用for语句

for..in是另一个循环语句，它在一序列的对象上递归即逐一使用队列中的每一个项目。咱们会在后面的章节中更加详细地学习序列。

for i in range(1, 5):
    print i
else:
    print 'The for loop is over'

输出：

1
2
3
4
The for loop is over

它如何工做

在这个程序中，咱们打印了一个序列的数。咱们使用内建的range函数生成这个数的序列。

咱们所作的只是提供两个数，range返回一个序列的数。这个序列从第一个数开始到第二个数为止。例如，range(1,5)给出序列[1, 2, 3, 4],不包括5。默认地，range的步长为1。若是咱们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range向上延伸到第二个数，即它不包含第二个数。

for循环在这个范围内递归——for i in range(1,5)等价于for i in [1, 2, 3, 4]，这就如同把序列中的每一个数（或对象）赋值给i，一次一个，而后以每一个i的值执行这个程序块。在这个例子中，咱们只是打印i的值。

记住，else部分是可选的。若是包含else，它老是在for循环结束后执行一次，除非遇到break语句。

记住，for..in循环对于任何序列都适用。这里咱们使用的是一个由内建range函数生成的数的列表，可是广义说来咱们可使用任何种类的由任何对象组成的序列！咱们会在后面的章节中详细探索这个观点。

5,break语句

break语句是用来终止循环语句的，即哪怕循环条件没有称为False或序列尚未被彻底递归，也中止执行循环语句。

一个重要的注释是，若是你从for或while循环中终止，任何对应的循环else块将不执行。

使用break语句

while True:
    s = raw_input('Enter something : ')
    if s == 'quit':
        break
    print 'Length of the string is', len(s)
print 'Done'

输出结果:

Enter something : fs
Length of the string is 2
Enter something : dafdfasfsa
Length of the string is 10
Enter something : quit
Done

6,continue语句

continue语句被用来告诉Python跳过当前循环块中的剩余语句，而后继续进行下一轮循环。

使用continue语句

while True:
    s = raw_input('Enter something : ')
    if s == 'quit':
        break
    if len(s) < 3:
        continue
    print 'Input is of sufficient length'
    # Do other kinds of processing here...

结果：

Enter something : a
Enter something : 12
Enter something : abb
Input is of sufficient length
Enter something : quit

它如何工做

在这个程序中，咱们从用户处取得输入，可是咱们仅仅当它们有至少3个字符长的时候才处理它们。因此，咱们使用内建的len函数来取得长度。若是长度小于3，咱们将使用continue语句忽略块中的剩余的语句。不然，这个循环中的剩余语句将被执行，咱们能够在这里作咱们但愿的任何处理。

注意，continue语句对于for循环也有效。

七，函数

简介

函数是重用的程序段。它们容许你给一块语句一个名称，而后你能够在你的程序的任何地方使用这个名称任意屡次地运行这个语句块。这被称为调用函数。咱们已经使用了许多内建的函数，好比len和range。

函数经过def关键字定义。def关键字后跟一个函数的标识符名称，而后跟一对圆括号。圆括号之中能够包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。下面这个例子将说明这事实上是十分简单的：

定义函数

def sayHello():
    print 'Hello World!' # block belonging to the function
sayHello() # call the function

输出：

Hello World!

它如何工做

咱们使用上面解释的语法定义了一个称为sayHello的函数。这个函数不使用任何参数，所以在圆括号中没有声明任何变量。参数对于函数而言，只是给函数的输入，以便于咱们能够传递不一样的值给函数，而后获得相应的结果。

函数形参

函数取得的参数是你提供给函数的值，这样函数就能够利用这些值作一些事情。这些参数就像变量同样，只不过它们的值是在咱们调用函数的时候定义的，而非在函数自己内赋值。

参数在函数定义的圆括号对内指定，用逗号分割。当咱们调用函数的时候，咱们以一样的方式提供值。注意咱们使用过的术语——函数中的参数名称为形参而你提供给函数调用的值称为实参。

使用参数形参

def printMax(a, b):
    if a > b:
        print a, 'is maximum'
    else:
        print b, 'is maximum'
printMax(3, 4) 
# directly give literal values
x = 5
y = 7
printMax(x, y) 
# give variables as arguments

结果为：

4 is maximum
7 is maximum

它如何工做

这里，咱们定义了一个称为printMax的函数，这个函数须要两个形参，叫作a和b。咱们使用if..else语句找出二者之中较大的一个数，而且打印较大的那个数。

在第一个printMax使用中，咱们直接把数，即实参，提供给函数。在第二个使用中，咱们使用变量调用函数。printMax(x, y)使实参x的值赋给形参a，实参y的值赋给形参b。在两次调用中，printMax函数的工做彻底相同。

局部变量

当你在函数定义内声明变量的时候，它们与函数外具备相同名称的其余变量没有任何关系，即变量名称对于函数来讲是局部的。这称为变量的做用域。全部变量的做用域是它们被定义的块，从它们的名称被定义的那点开始。

使用局部变量

def func(x):
    print 'x is', x
    x = 2
    print 'Changed local x to', x
x = 50
func(x)
print 'x is still', x

结果：

x is 50
Changed local x to 2
x is still 50

它如何工做

在函数中，咱们第一次使用x的值的时候，Python使用函数声明的形参的值。

接下来，咱们把值2赋给x。x是函数的局部变量。因此，当咱们在函数内改变x的值的时候，在主块中定义的x不受影响。

在最后一个print语句中，咱们证实了主块中的x的值确实没有受到影响。

使用global语句

若是你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是全局的。咱们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。

你可使用定义在函数外的变量的值（假设在函数内没有同名的变量）。然而，我并不鼓励你这样作，而且你应该尽可能避免这样作，由于这使得程序的读者会不清楚这个变量是在哪里定义的。使用global语句能够清楚地代表变量是在外面的块定义的。

def func():
    global x
    print 'x is', x
    x = 2
    print 'Changed local x to', x
x = 50
func()
print 'Value of x is', x

结果：

x is 50
Changed local x to 2
Value of x is 2

它如何工做

global语句被用来声明x是全局的——所以，当咱们在函数内把值赋给x的时候，这个变化也反映在咱们在主块中使用x的值的时候。

你可使用同一个global语句指定多个全局变量。例如global x, y, z。

默认参数值

使用默认参数值

def say(message, times = 1):
    print message * times
say('Hello')
say('World', 5)

输出结果为：

Hello
WorldWorldWorldWorldWorld

DocStrings

Python有一个很奇妙的特性，称为文档字符串，它一般被简称为 docstrings

使用DocStrings

def printMax(x, y):
    '''Prints the maximum of two numbers.
    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)
    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'
printMax(2.3,3.5)
print printMax.__doc__

输出结果：

3 is maximum
Prints the maximum of two numbers.
    The two values must be integers.

它如何工做

在函数的第一个逻辑行的字符串是这个函数的文档字符串。注意，DocStrings也适用于模块和类，咱们会在后面相应的章节学习它们。

文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。强烈建议你在你的函数中使用文档字符串时遵循这个惯例。

你可使用__doc__（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。请记住Python把每同样东西都做为对象，包括这个函数。咱们会在后面的类一章学习更多关于对象的知识。

若是你已经在Python中使用过help()，那么你已经看到过DocStings的使用了！它所作的只是抓取函数的__doc__属性，而后整洁地展现给你。你能够对上面这个函数尝试一下——只是在你的程序中包括help(printMax)。记住按q退出help。

自动化工具也能够以一样的方式从你的程序中提取文档。所以，我强烈建议你对你所写的任何正式函数编写文档字符串。随你的Python发行版附带的pydoc命令，与help()相似地使用DocStrings。

第9章数据结构

使用元组

含有0个或1个项目的元组。

一个空的元组由一对空的圆括号组成，如myempty = ()。然而，含有单个元素的元组就不那么简单了。你必须在第一个（惟一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。即若是你想要的是一个包含项目2的元组的时候，你应该指明singleton = (2 , )。

字典

注意，你只能使用不可变的对象（好比字符串）来做为字典的键，可是你能够不可变或可变的对象做为字典的值。基本说来就是，你应该只使用简单的对象做为键。

键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，全部这些都包括在花括号中。

记住字典中的键/值对是没有顺序的。若是你想要一个特定的顺序，那么你应该在使用前本身对它们排序。

字典是dict类的实例/对象

序列

序列的两个主要特色是索引操做符和切片操做符。索引操做符让咱们能够从序列中抓取一个特定项目。切片操做符让咱们可以获取序列的一个切片，即一部分序列。

索引一样能够是负数，在那样的状况下，位置是从序列尾开始计算的。所以，shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。

切片操做符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。注意这与你使用的索引操做符十分类似。记住数是可选的，而冒号是必须的。

切片操做符中的第一个数（冒号以前）表示切片开始的位置，第二个数（冒号以后）表示切片到哪里结束。若是不指定第一个数，Python就从序列首开始。若是没有指定第二个数，则Python会中止在序列尾。注意，返回的序列从开始位置开始，恰好在结束位置以前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。

这样，shoplist[1:3]返回从位置1开始，包括位置2，可是中止在位置3的一个序列切片，所以返回一个含有两个项目的切片。相似地，shoplist[:]返回整个序列的拷贝。

你能够用负数作切片。负数用在从序列尾开始计算的位置。例如，shoplist[:-1]会返回除了最后一个项目外包含全部项目的序列切片。

使用Python解释器交互地尝试不一样切片指定组合，即在提示符下你可以立刻看到结果。序列的神奇之处在于你能够用相同的方法访问元组、列表和字符串。

字符串的方法

startwith方法是用来测试字符串是否以给定字符串开始

in操做符用来检验一个给定字符串是否为另外一个字符串的一部分

find方法用来找出给定字符串在另外一个字符串中的位置，或者返回-1以表示找不到子字符串

str类也有以一个做为分隔符的字符串join序列的项目的整洁的方法，它返回一个生成的大字符串。

rjust方法来获得一个按必定宽度右对齐的字符串

文件

你能够经过建立一个file类的对象来打开一个文件，分别使用file类的read、readline或write方法来恰当地读写文件。对文件的读写能力依赖于你在打开文件时指定的模式。最后，当你完成对文件的操做的时候，你调用close方法来告诉Python咱们完成了对文件的使用。

模式能够为读模式（'r'）、写模式（'w'）或追加模式（'a'）。事实上还有多得多的模式可使用，你可使用help(file)来了解它们的详情。

注意，由于从文件读到的内容已经以换行符结尾，因此咱们在print语句上使用逗号来消除自动换行。最后，咱们用close关闭这个文件

储存器

Python提供一个标准的模块，称为pickle。使用它你能够在一个文件中储存任何Python对象，以后你又能够把它完好无损地取出来。这被称为持久地储存对象。

还有另外一个模块称为cPickle，它的功能和pickle模块彻底相同，只不过它是用C语言编写的，所以要快得多（比pickle快1000倍）。你可使用它们中的任一个，而咱们在这里将使用cPickle模块。记住，咱们把这两个模块都简称为pickle模块。

为了在文件里储存一个对象，首先以写模式打开一个file对象，而后调用储存器模块的dump函数，把对象储存到打开的文件中。这个过程称为储存。

接下来，咱们使用pickle模块的load函数的返回来取回对象。这个过程称为取储存。

异常处理方法
try..except
引起异常raise
try..finally

exec语句用来执行储存在字符串或文件中的Python语句。例如，咱们能够在运行时生成一个包含Python代码的字符串，而后使用exec语句执行这些语句

eval语句用来计算存储在字符串中的有效Python表达式

pop是删除最后一个元素