2016年10月26日 12:00:53

今天开始着手python的学习，希望能高效快速的学完！

Python基础（上）... 7

实验简介... 7

一、实验说明... 8

1. 环境登录... 8

2. 环境介绍... 8

3. 环境使用... 8

二、Hello World! 8

1、Python命令行... 8

2、写一段小程序... 9

3、脚本... 10

三、基本数据类型... 11

1、变量不需要声明... 11

2、回收变量名... 12

3、常用数据类型... 12

四、序列... 13

1、元素的引用... 14

2、其他引用方式... 15

3、字符串是元组... 15

五、运算... 16

1、数学运算... 16

2、判断... 16

3、逻辑运算... 17

六、缩进和选择... 17

1、缩进... 17

2、if语句... 18

作业... 20

Python基础（下）... 20

一、循环... 20

1、for循环... 20

2、while循环... 22

3、中断循环... 22

二、函数... 23

1、函数的定义... 23

2、函数调用和参数传递... 24

三、面向对象的基本概念... 26

1、相近对象，归为类... 26

2、动作... 27

3、子类... 29

四、面向对象的进一步拓展... 30

1、调用类的其它信息... 30

2、__init__() 方法... 31

3、对象的性质... 32

五、反过头来看看... 33

1、list是一个类... 33

2、运算符是特殊方法... 34

3、下一步... 36

作业... 36

Python进阶（上）... 37

一、词典... 37

1、基本概念... 38

2、词典元素的循环调用... 39

3、词典的常用方法... 39

二、文本文件的输入输出... 40

1、创建文件对象... 40

2、文件对象的方法... 40

三、模块... 41

1、引入模块... 41

2、搜索路径... 42

3、模块包... 43

四、函数的参数传递... 43

1、关键字传递... 43

2、参数默认值... 44

3、包裹传递... 44

4、解包裹... 45

5、混合... 46

作业... 46

Python进阶（下）... 47

一、循环设计... 47

1、range() 47

2、enumerate() 47

3、zip() 48

二、循环对象... 49

1、什么是循环对象... 49

2、迭代器... 50

3、生成器... 50

4、表推导... 52

三、函数对象... 52

1、lambda函数... 52

2、函数作为参数传递... 53

3、map()函数... 53

4、filter()函数... 54

5、reduce()函数... 54

四、错误处理... 55

1、异常处理... 55

2、抛出异常... 58

五、动态类型... 59

1、动态类型... 59

2、从动态类型看函数的参数传递... 61

作业... 62

Python深入（上）... 62

一、特殊方法与多范式... 63

1、运算符... 63

2、内置函数... 64

3、表（list）元素引用... 64

4、函数... 64

二、上下文管理器... 65

1、关闭文件... 65

2、自定义... 66

三、对象的属性... 67

1、属性的__dict__系统... 68

2、特性... 70

3、使用特殊方法__getattr__. 72

4、即时生成属性的其他方式... 73

作业... 73

Python深入（下）... 73

一、闭包... 74

1、函数对象的作用域... 74

2、闭包... 75

3、闭包与并行运算... 77

二、装饰器... 78

1、装饰函数和方法... 78

2、含参的装饰器... 81

3、装饰类... 82

三、内存管理... 83

1、对象的内存使用... 83

2、对象引用对象... 88

3、引用减少... 91

4、垃圾回收... 92

5、分代回收... 94

6、孤立的引用环... 96

作业... 97

Python补充... 98

一、序列的方法... 98

二、Python小技巧... 102

1、import模块... 102

2、查询... 104

3、使用中文(以及其它非ASCII编码) 105

4、表示2进制，8进制和16进制数字... 105

5、注释... 105

6、搜索路径... 106

7、脚本与命令行结合... 107

8、安装非标准包... 107

三、Python内置函数清单... 108

1、数学运算... 108

2、类型转换... 109

3、序列操作... 110

4、类、对象、属性... 110

5、编译、执行... 111

6、其他... 111

四、字符串格式化（%操作符）... 111

1、模板... 111

2、格式符... 112

作业... 114

Python标准库（上）... 114

一、正则表达式 (re包) 114

1、语法... 114

2、正则表达式的函数... 116

3、写一个正则表达式... 117

二、时间与日期 (time, datetime包) 119

1、time包... 119

2、datetime包... 120

三、路径与文件 (os.path包, glob包) 122

1、os.path包... 122

2、glob包... 123

四、文件管理 (部分os包，shutil包) 124

1、os包... 125

2、shutil包... 126

五、存储对象 (pickle包，cPickle包) 126

1、pickle包... 127

2、cPickle包... 128

作业... 129

Python标准库（中）... 129

一、子进程 (subprocess包) 129

1、subprocess以及常用的封装函数... 129

2、Popen() 131

3、子进程的文本流控制... 132

二、信号 (signal包) 134

1、定义信号名... 134

2、预设信号处理函数... 135

3、定时发出SIGALRM信号... 136

4、发送信号... 137

三、多线程与同步 (threading包) 137

1、多线程售票以及同步... 138

2、OOP创建线程... 140

3、其他... 142

四、进程信息 (部分os包) 143

1、进程信息... 143

2、saved UID和saved GID.. 144

五、多进程初步 (multiprocessing包) 146

1、threading和multiprocessing. 146

2、Pipe和Queue. 149

作业... 152

Python标准库（下）... 152

一、多进程探索 (multiprocessing包) 152

1、进程池... 153

2、共享资源... 155

二、数学与随机数 (math包，random包) 158

1、math包... 158

2、random包... 159

三、循环器 (itertools) 161

1、无穷循环器... 161

2、函数式工具... 162

3、组合工具... 163

4、groupby() 163

5、其它工具... 164

四、数据库 (sqlite3) 165

1、创建数据库... 165

2、插入数据... 167

3、查询... 168

4、更新与删除... 169

作业... 169

Python网络... 170

一、原始Python服务器... 170

1、TCP/IP和socket 171

2、TCP socket 173

3、基于TCP socket的HTTP服务器... 175

4、深入HTTP服务器程序... 178

5、使用浏览器实验... 179

6、探索的方向... 183

二、Python服务器进化... 183

1、支持POST.. 183

2、使用SocketServer 188

3、SimpleHTTPServer: 使用静态文件来回应请求... 191

4、CGIHTTPServer：使用静态文件或者CGI来回应请求... 194

作业... 198

Django（上）... 198

一、安装Django. 199

二、启动... 199

三、第一个网页... 201

四、增加APP.. 204

五、增加APP页面... 206

六、连接数据库... 207

七、创立模型... 209

八、显示数据... 211

作业... 214

Django（中）... 214

一、模板初体验... 214

... 216

二、流程... 216

三、循环与选择... 217

四、模板继承... 219

五、html表格... 220

六、POST方法... 222

七、存储数据... 224

八、表格对象... 226

作业... 228

Django（下）... 229

一、默认界面... 229

二、复杂模型... 230

三、自定义界面... 232

四、Inline显示... 235

五、列表页的显示... 237

六、创建用户... 240

七、用户登录... 242

八、登出... 244

九、views.py中的用户... 244

十、模板中的用户... 247

十一、用户注册... 247

十二、apache安装... 248

十三、静态文件... 250

作业... 252

Python基础（上）

实验简介

小提醒

教程将专注于Python基础，语法基于Python 2.7 (我会提醒Python 3.x中有变化的地方，以方便读者适应3.X的情况)。测试环境为Linux。标准库的一些包不适用于Windows平台。如果文中的程序无法在你的平台上运行，欢迎讨论。
我将专注于Python的主干，以便读者能以最快时间对Python形成概念。
Linux命令行将以 \$ 开始，比如 \$ls, $python
Python命令行将以 >>> 开始，比如 >>>print 'Hello World!'
注释会以 # 开始

建议

将教程中的命令敲到Python中看看效果。
看过教程之后，可以进行一些练习。
参与实验楼讨论区的讨论，可以更好的积累经验。

一、实验说明

1. 环境登录

无需密码自动登录，系统用户名shiyanlou

2. 环境介绍

本实验环境采用Ubuntu Linux桌面环境，实验中会用到桌面上的程序：

1.命令行终端: Linux命令行终端，打开后会进入Bash环境，可以使用Linux命令；

2.Python：实验楼环境已经安装好Python 2.7.6；

3.GVim：非常好用的Vim编辑器，最简单的用法可以参考课程Vim编辑器；

4.Gedit及Brackets：如果您对GVim的使用不熟悉，可以用这两个作为代码编辑器，其中Brackets非常适用于前端代码开发。

3. 环境使用

使用命令行终端运行所需命令进行操作，使用编辑器输入实验所需的代码及文件。

“实验记录”页面可以在“我的主页”中查看，每次实验的截图及笔记，以及有效学习时间（指的是在实验桌面内操作的时间，如果没有操作，系统会记录为发呆时间）。这些都是您在实验楼学习的真实性证明。

二、Hello World!

1、Python命令行

实验环境已经安装好了Python, 在Linux命令行输入:

$python

将直接进入python。然后在命令行提示符>>>后面输入:

>>>print('Hello World!')

可以看到，随后在屏幕上输出:

Hello World!

print是一个常用函数，其功能就是输出括号中得字符串。

（在Python 2.x中，print还可以是一个关键字，可写成print 'Hello World!'，但这在3.x中行不通）

2、写一段小程序

另一个使用Python的方法，是写一个Python程序。用文本编辑器写一个 .py 结尾的文件，比如说 hello.py

在hello.py中写入如下，并保存:

print('Hello World!')

退出文本编辑器，然后在命令行输入:

$python hello.py

来运行hello.py。可以看到Python随后输出:

Hello World!

3、脚本

我们还可以把Python程序hello.py改成一个可执行的脚本，可以直接执行：

#!/usr/bin/env python

print('Hello World!')

需要修改上面程序的权限为可执行：

chmod 755 hello.py

然后再命令行中，输入：

./hello.py

就可以直接运行了：

三、基本数据类型

1、变量不需要声明

Python的变量不需要声明，你可以直接输入：

>>>a = 10

那么你的内存里就有了一个变量a，它的值是10，它的类型是integer (整数)。在此之前你不需要做什么特别的声明，而数据类型是Python自动决定的。

>>>print a

>>>print type(a)

那么会有如下输出：

这里，我们学到一个内置函数type(), 用以查询变量的类型。

2、回收变量名

如果你想让 a 存储不同的数据，你不需要删除原有变量就可以直接赋值。

>>>a = 1.3

>>>print a,type(a)

会有如下输出：

1.3 <type 'float'>

我们看到print的另一个用法，也就是print后跟多个输出，以逗号分隔。

3、常用数据类型

变量	数据类型
a=10	int 整数
a=1.3	float 浮点数
a=True	真值(True/False)
a='Hello!'	字符串

以上是最常用的数据类型，对于字符串来说，也可以用双引号。

（此外还有分数，字符，复数等其他数据类型，有兴趣的可以学习一下）

四、序列

sequence(序列)是一组有顺序的元素的集合

(严格的说，是对象的集合，但鉴于我们还没有引入“对象”概念，暂时说元素)

序列可以包含一个或多个元素，也可以没有任何元素。

我们之前所说的基本数据类型，都可以作为序列的元素。元素还可以是另一个序列，以及我们以后要介绍的其他对象。

序列有两种：tuple（定值表；也有翻译为元组）和 list (表)

>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False) # s1是一个tuple

>>>s2 = [True, 5, 'smile'] # s2是一个list

>>>print s1,type(s1)

>>>print s2,type(s2)

tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更。

dh tuple类似于静态数组，已经定下来了，而list像动态数组，至于怎么加，里面有多少个内容，再看看

一个序列作为另一个序列的元素：

>>>s3 = [1,[3,4,5]]

空序列：

>>>s4 = []

1、元素的引用

序列元素的下标从0开始：

>>>print s1[0]

>>>print s2[2]

>>>print s3[1][2] #dh这是提取子数组里的序号

由于list的元素可变更，你可以对list的某个元素赋值：

>>>s2[1] = 3.0

>>>print s2

如果你对tuple做这样的操作，会得到错误提示。

所以，可以看到，序列的引用通过s[int]实现，(int为下标)。

2、其他引用方式

范围引用：基本样式 [下限:上限:步长]

>>>print s1[:5] # 从开始到下标4 （下标5的元素不包括在内）

>>>print s1[2:] # 从下标2到最后

>>>print s1[0:5:2] # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素（下标为0，2，4的元素）

>>>print s1[2:0:-1] # 从下标2到下标1

dh这里如果要到底，可以这样写：print s1[3::-1],意思是不加这个上限

从上面可以看到，在范围引用的时候，如果写明上限，那么这个上限本身不包括在内。

尾部元素引用：

>>>print s1[-1] # 序列最后一个元素

>>>print s1[-3] # 序列倒数第三个元素

同样，如果s1[0:-1], 那么最后一个元素不会被引用（再一次，不包括上限元素本身）。

3、字符串是元组

字符串是一种特殊的元素，因此可以执行元组的相关操作。

>>>str = 'abcdef'

>>>print str[2:4]

五、运算

暂时只介绍这些运算符的基本用法，方便我们展开后面的内容，高级应用暂时不介绍。

1、数学运算

>>>print 1+9 # 加法

>>>print 1.3-4 # 减法

>>>print 3*5 # 乘法

>>>print 4.5/1.5 # 除法

>>>print 3**2 # 乘方

>>>print 10%3 # 求余数

2、判断

判断是真还是假，返回True/False:

>>>print 5==6 # =，相等

>>>print 8.0!=8.0 # !=, 不等

>>>print 3<3, 3<=3 # <, 小于; <=, 小于等于

>>>print 4>5, 4>=0 # >, 大于; >=, 大于等于

>>>print 5 in [1,3,5] # 5是list [1,3,5]的一个元素

还有is, is not等, 暂时不深入。

3、逻辑运算

True/False之间的运算：

>>>print True and True, True and False # and, “与”运算，两者都为真才是真

>>>print True or False # or, "或"运算，其中之一为真即为真

>>>print not True # not, “非”运算，取反

可以和上一部分结合做一些练习，比如：

>>>print 5==6 or 3>=3

六、缩进和选择

1、缩进

Python最具特色的是用缩进来标明成块的代码。我下面以if选择结构来举例。if后面跟随条件，如果条件成立，则执行归属于 if 的一个代码块。

先看C语言的表达方式（注意，这是C，不是Python!）

if ( i > 0 )

{

x = 1;

y = 2;

}

如果i > 0的话，我们将进行括号中所包括的两个赋值操作。括号中包含的就是块操作，它隶属于if。

在Python中，同样的目的，这段话是这样的：

if i > 0:

x = 1

y = 2

在Python中，去掉了i > 0周围的括号，去除了每个语句句尾的分号，表示块的花括号也消失了。

多出来了if ...之后的 :(冒号), 还有就是x = 1 和 y =2前面有四个空格的缩进。通过缩进，Python识别出这两个语句是隶属于if。

Python这样设计的理由纯粹是为了程序好看。

2、if语句

写一个完整的程序，命名为ifDemo.py。这个程序用于实现if结构。

i = 1

x = 1

if i > 0:

x = x+1

print x

用cd命令进入该文件所在目录，然后输入命令运行它：

$python ifDemo.py # 运行

程序运行到 if 的时候，条件为True，因此执行x = x+1。

print x语句没有缩进，那么就是if之外。

如果将第一句改成i = -1，那么 if 遇到假值 (False), x = x+1隶属于 if , 这一句跳过。print x没有缩进，是 if 之外，不跳过，继续执行。

这种以四个空格的缩进来表示隶属关系的书写方式，以后还会看到。强制缩进增强了程序的可读性。

复杂一些的 if 选择：

i = 1

if i > 0:

print 'positive i'

i = i + 1

elif i == 0:

print 'i is 0'

i = i * 10

else:

print 'negative i'

i = i - 1

print 'new i:',i

这里有三个块，分别属于if，elif，else引领。

Python检测条件，如果发现 if 的条件为假，那么跳过后面紧跟的块，检测下一个 elif 的条件；如果还是假，那么执行else块。

通过上面的结构将程序分出三个分支。程序根据条件，只执行三个分支中的一个。

整个 if 可以放在另一个 if 语句中，也就是 if 结构的嵌套使用：

i = 5

if i > 1:

print 'i bigger than 1'

print 'good'

if i > 2:

print 'i bigger than 2'

print 'even better'

if i > 2 后面的块相对于该 if 缩进了四个空格，以表明其隶属于该 if ，而不是外层的 if 。

作业

按照过程在实验楼环境中把本节内容中的Python代码全部运行一遍，并截图保存。

Python基础（下）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、循环

1、for循环

for循环需要预先设定好循环的次数(n)，然后执行隶属于for的语句n次。

基本构造是：

for 元素 in 序列:

    statement

举例来说，我们编辑一个叫forDemo.py的文件：

for a in [3,4.4,'life']:

    print a

这个循环就是每次从表[3,4.4,'life'] 中取出一个元素（回忆：表是一种序列），然后将这个元素赋值给a，之后执行隶属于for的操作(print)。

介绍一个新的Python函数range()，来帮助你建立表。

idx = range(5)

print idx

可以看到idx是[0,1,2,3,4]

这个函数的功能是新建一个表。这个表的元素都是整数，从0开始，下一个元素比前一个大1，直到函数中所写的上限（不包括该上限本身）。

(关于range()，还有丰富用法，有兴趣可以查阅， Python 3中， range()用法有变化)

dh  n1=range(1,6)#这里注意range的使用，可以按照想要的范围来搞

>>> n1

[1, 2, 3, 4, 5]

>>> n1=range(6)

>>> n1

[0, 1, 2, 3, 4, 5]

举例：

for a in range(10):

    print a**2

2、while循环

while的用法是：

while 条件:

    statement

while会不停地循环执行隶属于它的语句，直到条件为假(False)。

举例：

i = 0

while i < 10:

    print i

    i = i + 1

3、中断循环

continue 在循环的某一次执行中，如果遇到continue, 那么跳过这一次执行，进行下一次的操作
break 停止执行整个循环

for i in range(10):

    if i == 2:

        continue

    print i

当循环执行到 i = 2 的时候，if 条件成立，触发continue, 跳过本次执行(不执行print)，继续进行下一次执行(i = 3)。

for i in range(10):

    if i == 2:

        break

    print i

当循环执行到i = 2的时候，if条件成立，触发break, 整个循环停止。

二、函数

函数最重要的目的是方便我们重复使用相同的一段程序。

将一些操作隶属于一个函数，以后你想实现相同的操作的时候，只用调用函数名就可以，而不需要重复敲所有的语句。

1、函数的定义

首先，我们要定义一个函数, 以说明这个函数的功能。

def square_sum(a,b):

    c = a**2 + b**2

    return c

这个函数的功能是求两个数的平方和。

首先，def，这个关键字通知python：我在定义一个函数。square_sum是函数名。

括号中的a, b是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。

我们已经在循环和选择中见过冒号和缩进来表示的隶属关系。

c = a2 + b2 # 这一句是函数内部进行的运算
return c # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。
return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。
return a,b,c # 相当于 return (a,b,c) 在python中#代表注释，编译器将跳过#后的内容。
在Python中，当程序执行到return的时候，程序将停止执行函数内余下的语句。return并不是必须的，当没有return, 或者return后面没有返回值时，函数将自动返回None。None是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。None多用于关键字参数传递的默认值。

2、函数调用和参数传递

定义过函数后，就可以在后面程序中使用这一函数：

print square_sum(3,4)

Python通过位置，知道3对应的是函数定义中的第一个参数a， 4对应第二个参数b，然后把参数传递给函数square_sum。

（Python有丰富的参数传递方式，还有关键字传递、表传递、字典传递等，基础教程将只涉及位置传递）

函数经过运算，返回值25, 这个25被print打印出来。

我们再看下面两个例子：

a = 1

def change_integer(a):

    a = a + 1

    return a

print change_integer(a)      #注意观察结果

print a      #注意观察结果

#===(Python中 "#" 后面跟的内容是注释，不执行 )

b = [1,2,3]

def change_list(b):

    b[0] = b[0] + 1

    return b

print change_list(b)      #注意观察结果

print b      #注意观察结果

第一个例子，我们将一个整数变量传递给函数，函数对它进行操作，但原整数变量a不发生变化。

第二个例子，我们将一个表传递给函数，函数进行操作，原来的表b发生变化。

对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为值传递）

但是对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。（我们称此为指针传递），指针是C/C++语言中的重要概念，有关指针的概念可以到网上搜索相关资料。

三、面向对象的基本概念

Python使用类(class)和对象(object)，进行面向对象（object-oriented programming，简称OOP）的编程。

面向对象的最主要目的是提高程序的重复使用性。我们这么早切入面向对象编程的原因是，Python的整个概念是基于对象的。了解OOP是进一步学习Python的关键。

下面是对面向对象的一种理解，基于分类。

1、相近对象，归为类

在人类认知中，会根据属性相近把东西归类，并且给类别命名。比如说，鸟类的共同属性是有羽毛，通过产卵生育后代。任何一只特别的鸟都在鸟类的原型基础上的。

面向对象就是模拟了以上人类认知过程。在Python语言，为了听起来酷，我们把上面说的“东西”称为对象（object）。

先定义鸟类：

class Bird(object):

    have_feather = True

    way_of_reproduction  = 'egg'

我们定义了一个类别（class），就是鸟（Bird）。在隶属于这个类比的语句块中，我们定义了两个变量，一个是有羽毛（have_feather），一个是生殖方式（way_of_reproduction）,这两个变量对应我们刚才说的属性（attribute）。我们暂时先不说明括号以及其中的内容，记为问题1。

假设我养了一只小鸡，叫summer。它是个对象，且属于鸟类。使用前面定义的类：

summer = Bird()

print summer.way_of_reproduction

通过第一句创建对象，并说明summer是类别鸟中的一个对象，summer就有了鸟的类属性，对属性的引用是通过对象.属性（object.attribute）的形式实现的。

可怜的summer，你就是个有毛产的蛋货，好不精致。

2、动作

日常认知中，我们在通过属性识别类别的时候，有时根据这个东西能做什么事情来区分类别。比如说，鸟会移动。这样，鸟就和房屋的类别区分开了。这些动作会带来一定的结果，比如移动导致位置的变化。

这样的一些“行为”属性为方法（method）。Python中通过在类的内部定义函数，来说明方法。

class Bird(object):

    have_feather = True

    way_of_reproduction = 'egg'

    def move(self, dx, dy):

        position = [0,0]

        position[0] = position[0] + dx

        position[1] = position[1] + dy

        return position

summer = Bird()

print 'after move:',summer.move(5,8)

我们重新定义了鸟这个类别。鸟新增一个方法属性，就是表示移动的方法move。（我承认这个方法很傻，你可以在看过下一讲之后定义个有趣些的方法）

（它的参数中有一个self，它是为了方便我们引用对象自身。方法的第一个参数必须是self，无论是否用到。有关self的内容稍后介绍）

另外两个参数，dx, dy表示在x、y两个方向移动的距离。move方法会最终返回运算过的position。

在最后调用move方法的时候，我们只传递了dx和dy两个参数，不需要传递self参数（因为self只是为了内部使用）。

我的summer可以跑了。

3、子类

类别本身还可以进一步细分成子类。

比如说，鸟类可以进一步分成鸡，大雁，黄鹂。

在OOP中，我们通过继承(inheritance)来表达上述概念。

class Chicken(Bird):

    way_of_move = 'walk'

    possible_in_KFC = True

class Oriole(Bird):

    way_of_move = 'fly'

    possible_in_KFC = False

summer = Chicken()

print summer.have_feather

print summer.move(5,8)

新定义的鸡（Chicken）类的，增加了两个属性：移动方式（way_of_move），可能在KFC找到（possible_in_KFC）。

在类定义时，括号里为了Bird。这说明，Chicken是属于鸟类（Bird）的一个子类，即Chicken继承自Bird。自然而然，Bird就是Chicken的父类。Chicken将享有Bird的所有属性。尽管我只声明了summer是鸡类，它通过继承享有了父类的属性（无论是变量属性have_feather还是方法属性move）

新定义的黄鹂(Oriole)类，同样继承自鸟类。在创建一个黄鹂对象时，该对象自动拥有鸟类的属性。

通过继承制度，我们可以减少程序中的重复信息和重复语句。如果我们分别定义两个类，而不继承自鸟类，就必须把鸟类的属性分别输入到鸡类和黄鹂类的定义中。整个过程会变得繁琐，因此，面向对象提高了程序的可重复使用性。

（回到问题1, 括号中的object，当括号中为object时，说明这个类没有父类（到头了））

将各种各样的东西分类，从而了解世界，从人类祖先开始，我们就在练习了这个认知过程，面向对象是符合人类思维习惯的。所谓面向过程，也就是执行完一个语句再执行下一个，更多的是机器思维。通过面向对象的编程，我们可以更方便的表达思维中的复杂想法。

四、面向对象的进一步拓展

1、调用类的其它信息

刚才提到，在定义方法时，必须有self这一参数。这个参数表示某个对象。对象拥有类的所有性质(如果学习过Java 或C++等语言的便会知道，self相当于this)，那么我们可以通过self，调用类属性。

class Human(object):

    laugh = 'hahahaha'

    def show_laugh(self):

        print self.laugh

    def laugh_100th(self):

        for i in range(100):

            self.show_laugh()

li_lei = Human()

li_lei.laugh_100th()

这里有一个类属性laugh。在方法show_laugh()中，通过self.laugh，调用了该属性的值。

还可以用相同的方式调用其它方法。方法show_laugh()，在方法laugh_100th中()被调用。

在对象中对类属性进行赋值的时候，实际上会在对象定义的作用域中添加一个属性（如果还不存在的话），并不会影响到相应类中定义的同名类属性。但如果是修改类属性的内容（比如类属性是个字典，修改字典内容）时会影响到所有对象实例，因为这个类属性的内容是共享的。

2、init() 方法

__init__() 是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。

如果你在类中定义了__init__() 这个方法，创建对象时，Python会自动调用这个方法。这个过程也叫初始化。

class happyBird(Bird):

    def __init__(self,more_words):

        print 'We are happy birds.',more_words

summer = happyBird('Happy,Happy!')

这里继承了Bird类。屏幕上打印：

We are happy birds.Happy,Happy!

我们看到，尽管我们只是创建了summer对象，但__init__() 方法被自动调用了。最后一行的语句(summer = happyBird...)先创建了对象，然后执行：

summer.__init__(more_words)

'Happy,Happy!' 被传递给了__init__() 的参数more_words

3、对象的性质

我们讲到了许多属性，但这些属性是类的属性。所有属于该类的对象会共享这些属性。比如说，鸟都有羽毛，鸡都不会飞。

在一些情况下，我们定义对象的性质，用于记录该对象的特别信息。比如说，人这个类。性别是某个人的一个性质，不是所有的人类都是男，或者都是女。这个性质的值随着对象的不同而不同。李雷是人类的一个对象，性别是男；韩美美也是人类的一个对象，性别是女。

当定义类的方法时，必须要传递一个self的参数。这个参数指代的就是类的一个对象。我们可以通过操纵self，来修改某个对象的性质。比如用类来新建一个对象，即下面例子中的li_lei, 那么li_lei就被self表示。我们通过赋值给self.attribute，给li_lei这一对象增加一些性质，比如说性别的男女。self会传递给各个方法。在方法内部，可以通过引用self.attribute，查询或修改对象的性质。

这样，在类属性的之外，又给每个对象增添了各自特色的性质，从而能描述多样的世界。

class Human(object):

    def __init__(self, input_gender):

        self.gender = input_gender

    def printGender(self):

        print self.gender

li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的input_gender变量。

print li_lei.gender   #这一行结果与下一行对比

li_lei.printGender()   #这一行结果与上一行对比

在初始化中，将参数input_gender，赋值给对象的性质，即self.gender。

li_lei拥有了对象性质gender。gender不是一个类属性。Python在建立了li_lei这一对象之后，使用li_lei.gender这一对象性质，专门储存属于对象li_lei的特有信息。

对象的性质也可以被其它方法调用，调用方法与类属性的调用相似，正如在printGender()方法中的调用。

五、反过头来看看

从最初的“Hello World”，走到面向对象。该回过头来看看，教程中是否遗漏了什么。

我们之前提到一句话，"Everything is Object". 那么我们就深入体验一下这句话。

需要先要介绍两个内置函数：dir() 和 help() 。

dir()用来查询一个类或者对象所有属性。你可以尝试一下：

>>>print dir(list)

help()用来查询的说明文档。你可以尝试一下：

>>>print help(list)

(list是Python内置的一个类，对应于我们之前讲解过的列表)

1、list是一个类

在上面以及看到，表是Python已经定义好的一个类。当我们新建一个表时，比如：

>>>nl = [1,2,5,3,5]

实际上，nl是类list的一个对象。

实验一些list的方法：

>>>print nl.count(5)       # 计数，看总共有多少个5

>>>print nl.index(3)       # 查询 nl 的第一个3的下标

>>>nl.append(6)            # 在 nl 的最后增添一个新元素6

>>>nl.sort()               # 对nl的元素排序

>>>print nl.pop()          # 从nl中去除最后一个元素，并将该元素返回。

>>>nl.remove(2)            # 从nl中去除第一个2

>>>nl.insert(0,9)          # 在下标为0的位置插入9

总之，list是一个类。每个列表都属于该类。

Python补充中有list常用方法的附录。

2、运算符是特殊方法

使用dir(list)的时候，能看到一个属性，是add()。从形式上看是特殊方法（下划线，下划线）。它特殊在哪呢？

这个方法定义了"+"运算符对于list对象的意义，两个list的对象相加时，会进行的操作。

>>>print [1,2,3] + [5,6,9]

运算符，比如+, -, >, <, 以及下标引用[start:end]等等，从根本上都是定义在类内部的方法。

尝试一下：

>>>print [1,2,3] - [3,4]

会有错误信息，说明该运算符“-”没有定义。现在我们继承list类，添加对"-"的定义：

class superList(list):

    def __sub__(self, b):

        a = self[:]     # 这里，self是supeList的对象。由于superList继承于list，它可以利用和list[:]相同的引用方法来表示整个对象。

        b = b[:]

        while len(b) > 0:

            element_b = b.pop()

            if element_b in a:

                a.remove(element_b)

        return a

print superList([1,2,3]) - superList([3,4])

内置函数len()用来返回list所包含的元素的总数。内置函数__sub__() 定义了“-”的操作：从第一个表中去掉第二个表中出现的元素。如果__sub__() 已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。

（教程最后也会给出一个特殊方法的清单）

定义运算符对于复杂的对象非常有用。举例来说，人类有多个属性，比如姓名，年龄和身高。我们可以把人类的比较（>, <, =）定义成只看年龄。这样就可以根据自己的目的，将原本不存在的运算增加在对象上了。

3、下一步

希望你已经对Python有了一个基本了解。你可能跃跃欲试，要写一些程序练习一下。这会对你很有好处。

但是，Python的强大很大一部分原因在于，它提供有很多已经写好的，可以现成用的对象。我们已经看到了内置的比如说list，还有tuple等等。它们用起来很方便。在Python的标准库里，还有大量可以用于操作系统互动，Internet开发，多线程，文本处理的对象。而在所有的这些的这些的基础上，又有很多外部的库包，定义了更丰富的对象，比如numpy, tkinter, django等用于科学计算，GUI开发，web开发的库，定义了各种各样的对象。对于一般用户来说，使用这些库，要比自己去从头开始容易得多。我们要开始攀登巨人的肩膀了。

谢谢你的关注，

欢迎来到Python的世界。

作业

1、写一个判断闰年的函数，参数为年、月、日。若是是闰年，返回True，并截图。

2、使用help(list)或dir(list)仔细查询list类的属性和文档。

dh做到这里，因为已经编辑了很多.py的文件，批量移动，复习下之前的linux知识

Python进阶（上）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

Python基础介绍了基本概念，特别是对象和类。

进阶教程对基础教程的进一步拓展，说明Python的细节。希望在进阶教程之后，你对Python有一个更全面的认识。

一、词典

之前我们说了，列表是Python里的一个类。一个特定的表，比如说nl = [1,3,8]，就是这个类的一个对象。我们可以调用这个对象的一些方法，比如 nl.append(15)。我们要介绍一个新的类，词典 (dictionary)。与列表相似，词典也可以储存多个元素。这种储存多个元素的对象称为容器(container)。

1、基本概念

常见的创建词典的方法:

>>>dic = {'tom':11, 'sam':57,'lily':100}

>>>print type(dic)

词典和表类似的地方，是包含有多个元素，每个元素以逗号分隔。但词典的元素包含有两部分，键和值，常见的是以字符串来表示键，也可以使用数字或者真值来表示键（不可变的对象可以作为键）。值可以是任意对象。键和值两者一一对应。

比如上面的例子中，‘tom’对应11，'sam对应57，'lily'对应100

与表不同的是，词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用。

>>>print dic['tom']

>>>dic['tom'] = 30

>>>print dic

构建一个新的空的词典：

>>>dic = {}

>>>print dic

在词典中增添一个新元素的方法：

>>>dic['lilei'] = 99

>>>print dic

这里，我们引用一个新的键，并赋予它对应的值。

2、词典元素的循环调用

dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}

for key in dic:

    print dic[key]

在循环中，dict的每个键，被提取出来，赋予给key变量。

通过print的结果，我们可以再次确认，dic中的元素是没有顺序的。

3、词典的常用方法

>>>print dic.keys()           # 返回dic所有的键

>>>print dic.values()         # 返回dic所有的值

>>>print dic.items()          # 返回dic所有的元素（键值对）

>>>dic.clear()                # 清空dic，dict变为{}

另外有一个很常用的用法：

>>>del dic['tom']             # 删除 dic 的‘tom’元素

del是Python中保留的关键字，用于删除对象。

与表类似，你可以用len()查询词典中的元素总数。

>>>print len(dic)

二、文本文件的输入输出

Python具有基本的文本文件读写功能。Python的标准库提供有更丰富的读写功能。

文本文件的读写主要通过open()所构建的文件对象来实现。

1、创建文件对象

我们打开一个文件，并使用一个对象来表示该文件：

对象名 = open(文件名，模式)

最常用的模式有：

r 打开只读文件，该文件必须存在。
r+ 打开可读写的文件，该文件必须存在。
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。
a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。
上述的形态字符串都可以再加一个b字符，如rb、w+b或ab＋等组合，加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。

比如：

>>>f = open("test.txt","r")

2、文件对象的方法

读取：

content = f.read(N)          # 读取N bytes的数据

content = f.readline()       # 读取一行

content = f.readlines()      # 读取所有行，储存在列表中，每个元素是一行。

写入：

f.write('I like apple!\n')      # 将'I like apple'写入文件并换行

关闭文件：

f.close()   # 不要忘记关闭文件

三、模块

我们之前看到了函数和对象。从本质上来说，它们都是为了更好的组织已经有的程序，以方便重复利用。

模块(module)也是为了同样的目的。在Python中，一个.py文件就构成一个模块。通过模块，你可以调用其它文件中的程序。

1、引入模块

我们先写一个first.py文件，内容如下：

def laugh():

    print 'HaHaHaHa'

再写一个second.py，并引入first中的程序：

import first   #将first文件引入

for i in range(10):

    first.laugh()

在second.py中，我们使用了first.py中定义的laugh()函数。

引入模块后，可以通过模块.对象的方式来调用引入模块中的某个对象。上面例子中，first为引入的模块，laugh()是我们所引入的对象。

Python中还有其它的引入方式：

import a as b             # 引入模块a，并将模块a重命名为b

from a import function1   # 从模块a中引入function1对象。调用a中对象时，我们不用再说明模块，即直接使用function1，而不是a.function1。

from a import *           # 从模块a中引入所有对象。调用a中对象时，我们不用再说明模块，即直接使用对象，而不是a.对象。

这些引用方式，可以方便后面的程序书写。

2、搜索路径

Python会在以下路径中搜索它想要寻找的模块：

程序所在的文件夹
操作系统环境变量PYTHONPATH所包含的路径
标准库的安装路径

如果你有自定义的模块，或者下载的模块，可以根据情况放在相应的路径，以便Python可以找到。

3、模块包

可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。通过

import this_dir.module

引入this_dir文件夹中的module模块。

该文件夹中必须包含一个 __init__.py 的文件，提醒Python，该文件夹为一个模块包。__init__.py 可以是一个空文件。

四、函数的参数传递

我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置，传递对应的参数。我们将接触更多的参数传递方式。

回忆一下位置传递：

def f(a,b,c):

    return a+b+c

print(f(1,2,3))

在调用 f 时，1，2，3根据位置分别传递给了a,b,c。

1、关键字传递

有些情况下，用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面f的定义，更改调用方式：

print(f(c=3,b=2,a=1))

关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前：

print(f(1,c=3,b=2))

2、参数默认值

在定义函数的时候，使用形如a=19的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。

def f(a,b,c=10):

    return a+b+c

print(f(3,2))

print(f(3,2,1))

在第一次调用函数f时，我们并没有足够的值，c没有被赋值，c将使用默认值10.

第二次调用函数的时候，c被赋值为1，不再使用默认值。

3、包裹传递

在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。

下面是包裹位置传递的例子：

def func(*name):

    print type(name)

    print name

func(1,4,6)

func(5,6,7,1,2,3)

两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。

为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。

下面是包裹关键字传递的例子：

def func(**dict):

    print type(dict)

    print dict

func(a=1,b=9)

func(m=2,n=1,c=11)

与上面一个例子类似，dict是一个字典，收集所有的关键字，传递给函数func。为了提醒Python，参数dict是包裹关键字传递所用的字典，在dict前加* *。

包裹传递的关键在于定义函数时，在相应元组或字典前加 * 或 * * 。

4、解包裹

* 和 **，也可以在调用的时候使用，即解包裹(unpacking), 下面为例：

def func(a,b,c):

    print a,b,c

args = (1,3,4)

func(*args)

在这个例子中，所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数。在调用func时使用 * ，是为了提醒Python：我想要把args拆成分散的三个元素，分别传递给a,b,c。（设想一下在调用func时，args前面没有 * 会是什么后果？）

相应的，也存在对词典的解包裹，使用相同的func定义，然后：

dict = {'a':1,'b':2,'c':3}

func(**dict)

在传递词典dict时，让词典的每个键值对作为一个关键字传递给func。

5、混合

在定义或者调用参数时，参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是：先位置，再关键字，再包裹位置，再包裹关键字，并且根据上面所说的原理细细分辨。

注意：请注意定义时和调用时的区分。包裹和解包裹并不是相反操作，是两个相对独立的过程。

作业

1、按照过程，在实验楼环境下运行本节所有代码，并截图。

2、建立一个record.txt的文档，写入内容如下:

tom, 12, 86

Lee, 15, 99

Lucy, 11, 58

Joseph, 19, 56

再从 record.txt 中读取文件并打印。

Python进阶（下）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、循环设计

在“Python基础（下）”一节，我们已经讨论了Python基本的循环语法。这一节，我们将接触更加灵活的循环方式。

1、range()

在Python中，for循环后的in跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。

之前我们已经使用过 range() 来控制for循环。现在，我们继续开发range的功能，以实现下标对循环的控制：

S = 'abcdefghijk'

for i in range(0,len(S),2):

    print S[i]

在该例子中，我们利用 len() 函数和 range() 函数，用 i 作为 S 序列的下标来控制循环。在range函数中，分别定义上限，下限和每次循环的步长。这就和C语言中的for循环相类似了。

2、enumerate()

利用enumerate()函数，可以在每次循环中同时得到下标和元素：

S = 'abcdefghijk'

for (index,char) in enumerate(S):

    print index

    print char

实际上，enumerate()在每次循环中，返回的是一个包含两个元素的定值表(tuple)，两个元素分别赋予index和char。

3、zip()

如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：

ta = [1,2,3]

tb = [9,8,7]

tc = ['a','b','c']

for (a,b,c) in zip(ta,tb,tc):

    print(a,b,c)

每次循环时，从各个序列分别从左到右取出一个元素，合并成一个tuple，然后tuple的元素赋予给a,b,c 。

zip()函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。

我们可以分解聚合后的列表，如下:

ta = [1,2,3]

tb = [9,8,7]

# cluster

zipped = zip(ta,tb)

print(zipped)

# decompose

na, nb = zip(*zipped)

print(na, nb)

二、循环对象

这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。

循环对象的并不是随着Python的诞生就存在的，但它的发展迅速，特别是Python 3x的时代，循环对象正在成为循环的标准形式。

dh循环对象的核心机制，作用什么的，还不是完全领会

1、什么是循环对象

循环对象是这样一个对象，它包含有一个next()方法 ( __next__() 方法，在python 3x中 )，这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration错误。

当一个循环结构（比如for）调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()。

假设我们有一个test.txt的文件:

abcd

efg

我们运行一下python命令行：

>>>f = open('test.txt')

>>>f.next()

>>>f.next()

...

不断输入f.next()，直到最后出现StopIteration 。

open()返回的实际上是一个循环对象，包含有next()方法。而该next()方法每次返回的就是新的一行的内容，到达文件结尾时举出StopIteration。这样，我们相当于手工进行了循环。

自动进行的话，就是：

for line in open('test.txt'):

    print line

在这里，for结构自动调用next()方法，将该方法的返回值赋予给line。循环知道出现StopIteration的时候结束。

相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。

2、迭代器

从技术上来说，循环对象和for循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。

3、生成器

生成器(generator)的主要目的是构成一个用户自定义的循环对象。

生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。

下面是一个生成器:

def gen():

    a = 100

    yield a

    a = a*8

    yield a

    yield 1000

该生成器共有三个yield，如果用作循环器时，会进行三次循环。

for i in gen():

    print i

再考虑如下一个生成器:

def gen():

    for i in range(4):

        yield i

它又可以写成生成器表达式(Generator Expression)：

G = (x for x in range(4))

生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。

4、表推导

表推导(list comprehension)是快速生成表的方法。它的语法简单，很有实用价值。

假设我们生成表 L ：

L = []

for x in range(10):

    L.append(x**2)

以上产生了表L，但实际上有快捷的写法，也就是表推导的方式:

L = [x**2 for x in range(10)]

这与生成器表达式类似，只不过用的是中括号。

（表推导的机制实际上是利用循环对象，有兴趣可以查阅。）

三、函数对象

秉承着一切皆对象的理念，我们再次回头来看函数(function)。函数也是一个对象，具有属性（可以使用dir()查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。

1、lambda函数

在展开之前，我们先提一下lambda函数。可以利用lambda函数的语法，定义函数。lambda例子如下：

func = lambda x,y: x + y

print func(3,4)

lambda生成一个函数对象。该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。

以上定义可以写成以下形式：

def func(x, y):

    return x + y

2、函数作为参数传递

函数可以作为一个对象，进行参数传递。函数名(比如func)即该对象。比如说:

def test(f, a, b):

    print 'test'

    print f(a, b)

test(func, 3, 5)

test函数的第一个参数f就是一个函数对象。将func传递给f，test中的f()就拥有了func()的功能。

我们因此可以提高程序的灵活性。可以使用上面的test函数，带入不同的函数参数。比如:

dh，这里存疑，因为运行有问题，以后回来再看

test((lambda x,y: x**2 + y), 6, 9)

3、map()函数

map()是Python的内置函数。它的第一个参数是一个函数对象。

re = map((lambda x: x+3),[1,3,5,6])

这里，map()有两个参数，一个是lambda所定义的函数对象，一个是包含有多个元素的表。map()的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表re中。map通过读入的函数(这里是lambda函数)来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加3）。

在Python 3.X中，map()的返回值是一个循环对象。可以利用list()函数，将该循环对象转换成表。

如果作为参数的函数对象有多个参数，可使用下面的方式，向map()传递函数参数的多个参数：

re = map((lambda x,y: x+y),[1,2,3],[6,7,9])

map()将每次从两个表中分别取出一个元素，带入lambda所定义的函数。

4、filter()函数

filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True，则该次的元素被储存于返回的表中。 filter通过读入的函数来筛选数据。同样，在Python 3.X中，filter返回的不是表，而是循环对象。

filter函数的使用如下例:

def func(a):

    if a > 100:

        return True

    else:

        return False

print filter(func,[10,56,101,500])

5、reduce()函数

reduce函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。如下例：

print reduce((lambda x,y: x+y),[1,2,5,7,9])

reduce的第一个参数是lambda函数，它接收两个参数x,y, 返回x+y。

reduce将表中的前两个元素(1和2)传递给lambda函数，得到3。该返回值(3)将作为lambda函数的第一个参数，而表中的下一个元素(5)作为lambda函数的第二个参数，进行下一次的对lambda函数的调用，得到8。依次调用lambda函数，每次lambda函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。

上面例子，相当于(((1+2)+5)+7)+9

提醒： reduce()函数在3.0里面不能直接用的，它被定义在了functools包里面，需要引入包。

四、错误处理

1、异常处理

在项目开发中，异常处理是不可或缺的。异常处理帮助人们debug，通过更加丰富的信息，让人们更容易找到bug的所在。异常处理还可以提高程序的容错性。

我们之前在讲循环对象的时候，曾提到一个StopIteration的异常，该异常是在循环对象穷尽所有元素时的报错。

我们以它为例，来说明基本的异常处理。

一个包含异常的程序:

re = iter(range(5))

for i in range(100):

    print re.next()

print 'HaHaHaHa'

首先，我们定义了一个循环对象re，该循环对象将进行5次循环，每次使用序列的一个元素。

在随后的for循环中，我们手工调用next()函数。当循环进行到第6次的时候，re.next()不会再返回元素，而是抛出(raise)StopIteration的异常。整个程序将会中断。

我们可以修改以上异常程序，直到完美的没有bug。但另一方面，如果我们在写程序的时候，知道这里可能犯错以及可能的犯错类型，我们可以针对该异常类型定义好”应急预案“。

re = iter(range(5))

try:

    for i in range(100):

        print re.next()

except StopIteration:

    print 'here is end ',i

print 'HaHaHaHa'

在try程序段中，我们放入容易犯错的部分。我们可以跟上except，来说明如果在try部分的语句发生StopIteration时，程序该做的事情。如果没有发生异常，则except部分被跳过。

随后，程序将继续运行，而不是彻底中断。

完整的语法结构如下：

try:

...

except exception1:

...

except exception2:

...

except:

...

else:

...

finally:

...

如果try中有异常发生时，将执行异常的归属，执行except。异常层层比较，看是否是exception1, exception2...，直到找到其归属，执行相应的except中的语句。如果except后面没有任何参数，那么表示所有的exception都交给这段程序处理。比如:

try:

    print(a*2)

except TypeError:

    print("TypeError")

except:

    print("Not Type Error & Error noted")

由于a没有定义，所以是NameError。异常最终被except:部分的程序捕捉。

如果无法将异常交给合适的对象，异常将继续向上层抛出，直到被捕捉或者造成主程序报错。比如下面的程序：

def test_func():

    try:

        m = 1/0

    except NameError:

        print("Catch NameError in the sub-function")

try:

    test_func()

except ZeroDivisionError:

    print("Catch error in the main program")

子程序的try...except...结构无法处理相应的除以0的错误，所以错误被抛给上层的主程序。

如果try中没有异常，那么except部分将跳过，执行else中的语句。

finally是无论是否有异常，最后都要做的一些事情。

流程如下:

try->异常->except->finally
try->无异常->else->finally

2、抛出异常

我们也可以自己写一个抛出异常的例子:

print 'Lalala'

raise StopIteration

print 'Hahaha'

这个例子不具备任何实际意义。只是为了说明raise语句的作用。

StopIteration是一个类。抛出异常时，会自动有一个中间环节，就是生成StopIteration的一个对象。Python实际上抛出的，是这个对象。当然，也可以自行生成对象:

raise StopIteration()

五、动态类型

动态类型(dynamic typing)是Python另一个重要的核心概念。我们之前说过，Python的变量(variable)不需要声明，而在赋值时，变量可以重新赋值为任意值。这些都与动态类型的概念相关。

1、动态类型

在我们接触的对象中，有一类特殊的对象，是用于存储数据的。常见的该类对象包括各种数字，字符串，表，词典。在C语言中，我们称这样一些数据结构为变量。而在Python中，这些是对象。

对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名，只是指向这一对象的引用(reference)。

引用和对象分离，是动态类型的核心。引用可以随时指向一个新的对象：

a = 3

a = 'at'

第一个语句中，3是储存在内存中的一个整数对象。通过赋值，引用a指向对象3。

第二个语句中，内存中建立对象‘at’，是一个字符串(string)。引用a指向了'at'。此时，对象3不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct)，释放相应内存。

(对于小的整数和短字符串，Python会缓存这些对象，而不是频繁的建立和销毁。)

a = 5

b = a

a = a + 2

再看这个例子。通过前两个句子，我们让a,b指向同一个整数对象5( b = a的含义是让引用b指向引用a所指的那一个对象)。但第三个句子实际上对引用a重新赋值，让a指向一个新的对象7。此时a,b分别指向不同的对象。我们看到，即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。

其它数据对象也是如此:

L1 = [1,2,3]

L2 = L1

L1 = 1

但注意以下情况:

L1 = [1,2,3]

L2 = L1

L1[0] = 10

print L2

在该情况下，我们不再对L1这一引用赋值，而是对L1所指向的表的元素赋值。结果是，L2也同时发生变化。

原因何在呢？因为L1，L2的指向没有发生变化，依然指向那个表。表实际上是包含了多个引用的对象（每个引用是一个元素，比如L1[0]，L1[1]..., 每个引用指向一个对象，比如1,2,3), 。而L1[0] = 10这一赋值操作，并不是改变L1的指向，而是对L1[0], 也就是表对象的一部份(一个元素)，进行操作，所以所有指向该对象的引用都受到影响。

（与之形成对比的是，我们之前的赋值操作都没有对对象自身发生作用，只是改变引用指向。）

列表可以通过引用其元素，改变对象自身(in-place change)。这种对象类型，称为可变数据对象(mutable object)，词典也是这样的数据类型。

而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。

我们之前学的元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object。

2、从动态类型看函数的参数传递

函数的参数传递，本质上传递的是引用。比如说：

def f(x):

    x = 100

    print x

a = 1

f(a)

print a

参数x是一个新的引用，指向a所指的对象。如果参数是不可变(immutable)的对象，a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。

如果传递的是可变(mutable)的对象，那么改变函数参数，有可能改变原对象。所有指向原对象的引用都会受影响，编程的时候要对此问题留心。比如说：

def f(x):

    x[0] = 100

    print x

a = [1,2,3]

f(a)

print a

动态类型是Python的核心机制之一。可以在应用中慢慢熟悉。

作业

1、练习下面的表推导会生成什么？

xl = [1,3,5]

yl = [9,12,13]

L  = [ x**2 for (x,y) in zip(xl,yl) if y > 10]

2、通过参数传递，判断数字、字符串、list、tuple、词典等数据类型是否为可变数据对象。

Python深入（上）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

到现在为止，Python学习已经可以告一段落。下面的部分，我想讨论Python的高级语法和底层实现。这一部分的内容并不是使用Python所必须的。但如果你想从事一些大型的Python开发(比如制作Python工具、写一个框架等)，你会希望对这一部分内容有所的了解。

一、特殊方法与多范式

Python 一切皆对象，但同时，Python还是一个多范式语言(multi-paradigm),你不仅可以使用面向对象的方式来编写程序，还可以用面向过程的方式来编写相同功能的程序(还有函数式、声明式等，我们暂不深入)。Python的多范式依赖于Python对象中的特殊方法(special method)。

特殊方法名的前后各有两个下划线。特殊方法又被成为魔法方法(magic method)，定义了许多Python 语法和表达方式，正如我们在下面的例子中将要看到的。当对象中定义了特殊方法的时候，Python也会对它们有“特殊优待”。比如定义了__init__()方法的类，会在创建对象的时候自动执行__init__()方法中的操作。

(可以通过dir()来查看对象所拥有的特殊方法，比如dir(1))。

1、运算符

Python的运算符是通过调用对象的特殊方法实现的。比如：

'abc' + 'xyz'               # 连接字符串

实际执行了如下操作：

'abc'.__add__('xyz')

所以，在Python中，两个对象是否能进行加法运算，首先就要看相应的对象是否有__add__()方法。一旦相应的对象有__add__()方法，即使这个对象从数学上不可加，我们都可以用加法的形式，来表达obj.__add__()所定义的操作。在Python中，运算符起到简化书写的功能，但它依靠特殊方法实现。

Python不强制用户使用面向对象的编程方法。用户可以选择自己喜欢的使用方式(比如选择使用+符号，还是使用更加面向对象的__add__()方法)。特殊方法写起来总是要更费事一点。

2、内置函数

与运算符类似，许多内置函数也都是调用对象的特殊方法。比如：

len([1,2,3])      # 返回表中元素的总数

实际上做的是：

[1,2,3].__len__()

相对与__len__()，内置函数len()也起到了简化书写的作用。

3、表（list）元素引用

下面是我们常见的表元素引用方式：

li = [1, 2, 3, 4, 5, 6]

print(li[3])

上面的程序运行到li[3]的时候，Python发现并理解[]符号，然后调用__getitem__()方法。

li = [1, 2, 3, 4, 5, 6]

print(li.__getitem__(3))

4、函数

我们已经说过，在Python中，函数也是一种对象。实际上，任何一个有__call__()特殊方法的对象都被当作是函数。比如下面的例子:

class SampleMore(object):

    def __call__(self, a):

        return a + 5

add = SampleMore()     # A function object

print(add(2))          # Call function

map(add, [2, 4, 5])    # Pass around function object

add为SampleMore类的一个对象，当被调用时，add执行加5的操作。add还可以作为函数对象，被传递给map()函数。

当然，我们还可以使用更“优美”的方式，想想是什么。

二、上下文管理器

上下文管理器(context manager)是Python2.5开始支持的一种语法，用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是with...as...

1、关闭文件

我们会进行这样的操作：打开文件，读写，关闭文件。程序员经常会忘记关闭文件。上下文管理器可以在不需要文件的时候，自动关闭文件。

下面我们看一下两段程序：

# without context manager

f = open("new.txt", "w")

print(f.closed)               # whether the file is open

f.write("Hello World!")

f.close()

print(f.closed)

以及：

# with context manager

with open("new.txt", "w") as f:

    print(f.closed)

    f.write("Hello World!")

print(f.closed)

两段程序实际上执行的是相同的操作。我们的第二段程序就使用了上下文管理器 (with...as...)。上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候(也就是不再缩进)，上下文管理器自动关闭了文件 (我们通过f.closed来查询文件是否关闭)。我们相当于使用缩进规定了文件对象f的使用范围。

上面的上下文管理器基于f对象的__exit__()特殊方法(还记得我们如何利用特殊方法来实现各种语法？参看特殊方法与多范式)。当我们使用上下文管理器的语法时，我们实际上要求Python在进入程序块之前调用对象的__enter__()方法，在结束程序块的时候调用__exit__()方法。对于文件对象f来说，它定义了__enter__()和__exit__()方法(可以通过dir(f)看到)。在f的__exit__()方法中，有self.close()语句。所以在使用上下文管理器时，我们就不用明文关闭f文件了。

2、自定义

任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器。文件对象f是内置对象，所以f自动带有这两个特殊方法，不需要自定义。

下面，我们自定义用于上下文管理器的对象，就是下面的myvow：

# customized object

class VOW(object):

    def __init__(self, text):

        self.text = text

    def __enter__(self):

        self.text = "I say: " + self.text    # add prefix

        return self                          # note: return an object

    def __exit__(self,exc_type,exc_value,traceback):

        self.text = self.text + "!"          # add suffix

with VOW("I'm fine") as myvow:

    print(myvow.text)

print(myvow.text)

我们的运行结果如下:

I say: I'm fine

I say: I'm fine!

我们可以看到，在进入上下文和离开上下文时，对象的text属性发生了改变(最初的text属性是"I'm fine")。

__enter__()返回一个对象。上下文管理器会使用这一对象作为as所指的变量，也就是myvow。在__enter__()中，我们为myvow.text增加了前缀 ("I say: ")。在__exit__()中，我们为myvow.text增加了后缀("!")。

注意: __exit__()中有四个参数。当程序块中出现异常(exception)，__exit__()的参数中exc_type, exc_value, traceback用于描述异常。我们可以根据这三个参数进行相应的处理。如果正常运行结束，这三个参数都是None。在我们的程序中，我们并没有用到这一特性。

由于上下文管理器带来的便利，它是一个值得使用的工具。

三、对象的属性

Python一切皆对象(object)，每个对象都可能有多个属性(attribute)。Python的属性有一套统一的管理方案。

1、属性的dict系统

对象的属性可能来自于其类定义，叫做类属性(class attribute)。类属性可能来自类定义自身，也可能根据类定义继承来的。一个对象的属性还可能是该对象实例定义的，叫做对象属性(object attribute)。

对象的属性储存在对象的__dict__属性中。__dict__为一个词典，键为属性名，对应的值为属性本身。我们看下面的类和对象。chicken类继承自bird类，而summer为chicken类的一个对象。

class bird(object):

    feather = True

class chicken(bird):

    fly = False

    def __init__(self, age):

        self.age = age

summer = chicken(2)

print(bird.__dict__)

print(chicken.__dict__)

print(summer.__dict__)

下面为我们的输出结果：

{'__dict__': <attribute '__dict__' of 'bird' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'bird' objects>, 'feather': True, '__doc__': None}

{'fly': False, '__module__': '__main__', '__doc__': None, '__init__': <function __init__ at 0x2b91db476d70>}

{'age': 2}

第一行为bird类的属性，比如feather。第二行为chicken类的属性，比如fly和__init__方法。第三行为summer对象的属性，也就是age。有一些属性，比如__doc__，并不是由我们定义的，而是由Python自动生成。此外，bird类也有父类，是object类(正如我们的bird定义，class bird(object))。这个object类是Python中所有类的父类。

可以看到，Python中的属性是分层定义的，比如这里分为object/bird/chicken/summer这四层。当我们需要调用某个属性的时候，Python会一层层向上遍历，直到找到那个属性。(某个属性可能出现再不同的层被重复定义，Python向上的过程中，会选取先遇到的那一个，也就是比较低层的属性定义)。

当我们有一个summer对象的时候，分别查询summer对象、chicken类、bird类以及object类的属性，就可以知道summer对象所有的__dict__，就可以找到通过对象summer可以调用和修改的所有属性了。下面两种属性修改方法等效：

summer.__dict__['age'] = 3

print(summer.__dict__['age'])

summer.age = 5

print(summer.age)

(上面的情况中，我们已经知道了summer对象的类为chicken，而chicken类的父类为bird。如果只有一个对象，而不知道它的类以及其他信息的时候，我们可以利用__class__属性找到对象的类，然后调用类的__base__属性来查询父类) 。

2、特性

同一个对象的不同属性之间可能存在依赖关系。当某个属性被修改时，我们希望依赖于该属性的其他属性也同时变化。这时，我们不能通过__dict__的方式来静态的储存属性。Python提供了多种即时生成属性的方法。其中一种称为特性(property)。特性是特殊的属性。比如我们为chicken类增加一个特性adult。当对象的age超过1时，adult为True；否则为False：

class bird(object):

    feather = True

class chicken(bird):

    fly = False

    def __init__(self, age):

        self.age = age

    def getAdult(self):

        if self.age > 1.0: return True

        else: return False

    adult = property(getAdult)   # property is built-in

summer = chicken(2)

print(summer.adult)

summer.age = 0.5

print(summer.adult)

特性使用内置函数property()来创建。property()最多可以加载四个参数。前三个参数为函数，分别用于处理查询特性、修改特性、删除特性。最后一个参数为特性的文档，可以为一个字符串，起说明作用。

我们使用下面一个例子进一步说明:

class num(object):

    def __init__(self, value):

        self.value = value

    def getNeg(self):

        return -self.value

    def setNeg(self, value):

        self.value = -value

    def delNeg(self):

        print("value also deleted")

        del self.value

    neg = property(getNeg, setNeg, delNeg, "I'm negative")

x = num(1.1)

print(x.neg)

x.neg = -22

print(x.value)

print(num.neg.__doc__)

del x.neg

上面的num为一个数字，而neg为一个特性，用来表示数字的负数。当一个数字确定的时候，它的负数总是确定的；而当我们修改一个数的负数时，它本身的值也应该变化。这两点由getNeg和setNeg来实现。而delNeg表示的是，如果删除特性neg，那么应该执行的操作是删除属性value。property()的最后一个参数("I'm negative")为特性negative的说明文档。

3、使用特殊方法getattr

我们可以用__getattr__(self, name)来查询即时生成的属性。当我们查询一个属性时，如果通过__dict__方法无法找到该属性，那么Python会调用对象的__getattr__方法，来即时生成该属性。比如:

class bird(object):

    feather = True

class chicken(bird):

    fly = False

    def __init__(self, age):

        self.age = age

    def __getattr__(self, name):

        if name == 'adult':

            if self.age > 1.0: return True

            else: return False

        else: raise AttributeError(name)

summer = chicken(2)

print(summer.adult)

summer.age = 0.5

print(summer.adult)

print(summer.male)

每个特性需要有自己的处理函数，而__getattr__可以将所有的即时生成属性放在同一个函数中处理。__getattr__可以根据函数名区别处理不同的属性。比如上面我们查询属性名male的时候，raise AttributeError。

(Python中还有一个__getattribute__特殊方法，用于查询任意属性。__getattr__只能用来查询不在__dict__系统中的属性)

__setattr__(self, name, value)和__delattr__(self, name)可用于修改和删除属性。它们的应用面更广，可用于任意属性。

4、即时生成属性的其他方式

即时生成属性还可以使用其他的方式，比如descriptor ( descriptor类实际上是property()函数的底层，property()实际上创建了一个该类的对象 ) 。有兴趣可以进一步查阅。

作业

尝试下面的操作，看看效果，再想想它的对应运算符：

(1.8).__mul__(2.0)

True.__or__(False)

尝试下面的操作，想一下它的对应内置函数：

(-1).__abs__()

(2.3).__int__()

尝试看下面的操作，想想它的对应：

li.__setitem__(3, 0)

{'a':1, 'b':2}.__delitem__('a')

Python深入（下）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、闭包

闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。在面向过程编程中，我们见到过函数(function)；在面向对象编程中，我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。

不同的语言实现闭包的方式不同。Python以函数对象为基础，为闭包这一语法结构提供支持的 (我们在特殊方法与多范式中，已经多次看到Python使用对象来实现一些特殊的语法)。Python一切皆对象，函数这一语法结构也是一个对象。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。

1、函数对象的作用域

和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用def语句定义的，函数对象的作用域与def所在的层级相同。比如下面代码，我们在 line_conf 函数的隶属范围内定义的函数line，就只能在 line_conf 的隶属范围内调用。

def line_conf():

    def line(x):

        return 2*x+1

    print(line(5))   # within the scope

line_conf()

print(line(5))       # out of the scope

line函数定义了一条直线(y = 2x + 1)。可以看到，在 line_conf() 中可以调用line函数，而在作用域之外调用line将会有下面的错误：

NameError: name 'line' is not defined

说明这时已经在作用域之外。

同样，如果使用lambda定义函数，那么函数对象的作用域与lambda所在的层级相同。

2、闭包

函数是一个对象，所以可以作为某个函数的返回结果。

def line_conf():

    def line(x):

        return 2*x+1

    return line       # return a function object

my_line = line_conf()

print(my_line(5))

上面的代码可以成功运行。line_conf 的返回结果被赋给line对象。上面的代码将打印11。

如果line()的定义中引用了外部的变量，会发生什么呢？

def line_conf():

    b = 15

    def line(x):

        return 2*x+b

    return line       # return a function object

b = 5

my_line = line_conf()

print(my_line(5))

我们可以看到，line定义的隶属程序块中引用了高层级的变量b，但b信息存在于line的定义之外 (b的定义并不在line的隶属程序块中)。我们称b为line的环境变量。事实上，line作为line_conf 的返回值时，line中已经包括b的取值(尽管b并不隶属于line)。

上面的代码将打印25，也就是说，line所参照的b值是函数对象定义时可供参考的b值，而不是使用时的b值。

一个函数和它的环境变量合在一起，就构成了一个闭包(closure)。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的__closure__属性中。比如下面的代码：

def line_conf():

    b = 15

    def line(x):

        return 2*x+b

    return line       # return a function object

b = 5

my_line = line_conf()

print(my_line.__closure__)

print(my_line.__closure__[0].cell_contents)

__closure__里包含了一个元组(tuple)。这个元组中的每个元素是cell类型的对象。我们看到第一个cell包含的就是整数15，也就是我们创建闭包时的环境变量b的取值。

下面看一个闭包的实际例子：

def line_conf(a, b):

    def line(x):

        return a*x + b

    return line

line1 = line_conf(1, 1)

line2 = line_conf(4, 5)

print(line1(5), line2(5))

这个例子中，函数line与环境变量a,b构成闭包。在创建闭包的时候，我们通过line_conf 的参数a,b说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。

如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。利用闭包，我们实际上创建了泛函。line函数定义一种广泛意义的函数。这个函数的一些方面已经确定(必须是直线)，但另一些方面(比如a和b参数待定)。随后，我们根据line_conf传递来的参数，通过闭包的形式，将最终函数确定下来。

dh既然这样，那么闭包的应用满足其形式即可，日常的很多函数都可以借用此

3、闭包与并行运算

闭包有效的减少了函数所需定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下，我们可以让每台电脑负责一个函数，然后将一台电脑的输出和下一台电脑的输入串联起来。最终，我们像流水线一样工作，从串联的电脑集群一端输入数据，从另一端输出数据。这样的情境最适合只有一个参数输入的函数。闭包就可以实现这一目的。

并行运算正称为一个热点。这也是函数式编程又热起来的一个重要原因。函数式编程早在1950年代就已经存在，但应用并不广泛。然而，我们上面描述的流水线式的工作并行集群过程，正适合函数式编程。由于函数式编程这一天然优势，越来越多的语言也开始加入对函数式编程范式的支持。

二、装饰器

装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数和类进行加工，比如在Python闭包中，我们见到函数对象作为某一个函数的返回结果。相对于其它方式，装饰器语法简单，代码可读性高。因此，装饰器在Python项目中有广泛的应用。

装饰器最早在Python 2.5中出现，它最初被用于加工函数和方法这样的可调用对象(callable object，这样的对象定义有__call__方法)。在Python 2.6以及之后的Python版本中，装饰器被进一步用于加工类。

1、装饰函数和方法

我们先定义两个简单的数学函数，一个用来计算平方和，一个用来计算平方差：

# get square sum

def square_sum(a, b):

    return a**2 + b**2

# get square diff

def square_diff(a, b):

    return a**2 - b**2

print(square_sum(3, 4))

print(square_diff(3, 4))

在拥有了基本的数学功能之后，我们可能想为函数增加其它的功能，比如打印输入。我们可以改写函数来实现这一点：

# modify: print input

# get square sum

def square_sum(a, b):

    print("intput:", a, b)

    return a**2 + b**2

# get square diff

def square_diff(a, b):

    print("input", a, b)

    return a**2 - b**2

print(square_sum(3, 4))

print(square_diff(3, 4))

我们修改了函数的定义，为函数增加了功能。

现在，我们使用装饰器来实现上述修改：

def decorator(F):

    def new_F(a, b):

        print("input", a, b)

        return F(a, b)

    return new_F

# get square sum

@decorator

def square_sum(a, b):

    return a**2 + b**2

# get square diff

@decorator

def square_diff(a, b):

    return a**2 - b**2

print(square_sum(3, 4))

print(square_diff(3, 4))

装饰器可以用def的形式定义，如上面代码中的decorator。装饰器接收一个可调用对象作为输入参数，并返回一个新的可调用对象。装饰器新建了一个可调用对象，也就是上面的new_F。new_F中，我们增加了打印的功能，并通过调用F(a, b)来实现原有函数的功能。

dh这里decorator用别的来代替也是可行的

定义好装饰器后，我们就可以通过@语法使用了。在函数square_sum和square_diff定义之前调用@decorator，我们实际上将square_sum或square_diff传递给decorator，并将decorator返回的新的可调用对象赋给原来的函数名(square_sum或square_diff)。所以，当我们调用square_sum(3, 4)的时候，就相当于：

square_sum = decorator(square_sum)

square_sum(3, 4)

我们知道，Python中的变量名和对象是分离的。变量名可以指向任意一个对象。从本质上，装饰器起到的就是这样一个重新指向变量名的作用(name binding)，让同一个变量名指向一个新返回的可调用对象，从而达到修改可调用对象的目的。

与加工函数类似，我们可以使用装饰器加工类的方法。

如果我们有其他的类似函数，我们可以继续调用decorator来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

2、含参的装饰器

在上面的装饰器调用中，比如@decorator，该装饰器默认它后面的函数是唯一的参数。装饰器的语法允许我们调用decorator时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

# a new wrapper layer

def pre_str(pre=''):

    # old decorator

    def decorator(F):

        def new_F(a, b):

            print(pre + "input", a, b)

            return F(a, b)

        return new_F

    return decorator

# get square sum

@pre_str('^_^')

def square_sum(a, b):

    return a**2 + b**2

# get square diff

@pre_str('T_T')

def square_diff(a, b):

    return a**2 - b**2

print(square_sum(3, 4))

print(square_diff(3, 4))

上面的pre_str是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用@pre_str('^_^')调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。该调用相当于:

square_sum = pre_str('^_^') (square_sum)

3、装饰类

在上面的例子中，装饰器接收一个函数，并返回一个函数，从而起到加工函数的效果。在Python 2.6以后，装饰器被拓展到类。一个装饰器可以接收一个类，并返回一个类，从而起到加工类的效果。

def decorator(aClass):

    class newClass:

        def __init__(self, age):

            self.total_display   = 0

            self.wrapped         = aClass(age)

        def display(self):

            self.total_display += 1

            print("total display", self.total_display)

            self.wrapped.display()

    return newClass

@decorator

class Bird:

    def __init__(self, age):

        self.age = age

    def display(self):

        print("My age is",self.age)

eagleLord = Bird(5)

for i in range(3):

    eagleLord.display()

在decorator中，我们返回了一个新类newClass。在新类中，我们记录了原来类生成的对象（self.wrapped），并附加了新的属性total_display，用于记录调用display的次数。我们也同时更改了display方法。

通过修改，我们的Bird类可以显示调用display的次数了。

装饰器的核心作用是name binding。这种语法是Python多编程范式的又一个体现。大部分Python用户都不怎么需要定义装饰器，但有可能会使用装饰器。鉴于装饰器在Python项目中的广泛使用，了解这一语法是非常有益的。

三、内存管理

语言的内存管理是语言设计的一个重要方面。它是决定语言性能的重要因素。无论是C语言的手工管理，还是Java的垃圾回收，都成为语言最重要的特征。这里以Python语言为例子，说明一门动态类型的、面向对象的语言的内存管理方式。

1、对象的内存使用

赋值语句是语言最常见的功能了。但即使是最简单的赋值语句，也可以很有内涵。Python的赋值语句就很值得研究。

a = 1

整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。Python是动态类型的语言(参考动态类型)，对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。

引用和对象:

为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。

a = 1

print(id(a))

print(hex(id(a)))

在我的计算机上，它们返回的是:

11246696

'0xab9c68'

分别为内存地址的十进制和十六进制表示。

在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。

a = 1

b = 1

print(id(a))

print(id(b))

上面程序返回：

11246696

11246696

可见a和b实际上是指向同一个对象的两个引用。

为了检验两个引用指向同一个对象，我们可以用is关键字。is用于判断两个引用所指的对象是否相同。

# True

a = 1

b = 1

print(a is b)

# True

a = "good"

b = "good"

print(a is b)

# False

a = "very good morning"

b = "very good morning"

print(a is b)

# False

a = []

b = []

print(a is b)

上面的注释为相应的运行结果。可以看到，由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。

在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。

我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。

from sys import getrefcount

a = [1, 2, 3]

print(getrefcount(a))

b = a

print(getrefcount(b))

由于上述原因，两个getrefcount将返回2和3，而不是期望的1和2。

2、对象引用对象

Python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。

我们也可以自定义一个对象，并引用其它对象:

class from_obj(object):

    def __init__(self, to_obj):

        self.to_obj = to_obj

b = [1,2,3]

a = from_obj(b)

print(id(a.to_obj))

print(id(b))

可以看到，a引用了对象b。

对象引用对象，是Python最基本的构成方式。即使是a = 1这一赋值方式，实际上是让词典的一个键值"a"的元素引用整数对象1。该词典对象用于记录所有的全局引用。该词典引用了整数对象1。我们可以通过内置函数globals()来查看该词典。

当一个对象A被另一个对象B引用时，A的引用计数将增加1。

from sys import getrefcount

a = [1, 2, 3]

print(getrefcount(a))

b = [a, a]

print(getrefcount(a))

由于对象b引用了两次a，a的引用计数增加了2。

容器对象的引用可能构成很复杂的拓扑结构。我们可以用objgraph包来绘制其引用关系，比如：

x = [1, 2, 3]

y = [x, dict(key1=x)]

z = [y, (x, y)]

import objgraph

objgraph.show_refs([z], filename='ref_topo.png')

objgraph是Python的一个第三方包。安装之前需要安装xdot。

sudo apt-get install xdot

sudo pip install -i http://mirrors.aliyuncs.com/pypi/simple objgraph

objgraph官网

两个对象可能相互引用，从而构成所谓的引用环(reference cycle)。

a = []

b = [a]

a.append(b)

即使是一个对象，只需要自己引用自己，也能构成引用环。

a = []

a.append(a)

print(getrefcount(a))

引用环会给垃圾回收机制带来很大的麻烦，我将在后面详细叙述这一点。

3、引用减少

某个对象的引用计数可能减少。比如，可以使用del关键字删除某个引用:

from sys import getrefcount

a = [1, 2, 3]

b = a

print(getrefcount(b))

del a

print(getrefcount(b))

del也可以用于删除容器元素中的元素，比如:

a = [1,2,3]

del a[0]

print(a)

如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少:

from sys import getrefcount

a = [1, 2, 3]

b = a

print(getrefcount(b))

a = 1

print(getrefcount(b))

4、垃圾回收

吃太多，总会变胖，Python也是这样。当Python中的对象越来越多，它们将占据越来越大的内存。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥”，启动垃圾回收(garbage collection)，将没用的对象清除。在许多语言中都有垃圾回收机制，比如Java和Ruby。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收)。

从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表:

a = [1, 2, 3]

del a

del a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。

然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。

我们可以通过gc模块的get_threshold()方法，查看该阈值:

import gc

print(gc.get_threshold())

返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。

我们也可以手动启动垃圾回收，即使用gc.collect()。

5、分代回收

Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。

小家伙要多检查：

Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。

这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。

同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。

import gc

gc.set_threshold(700, 10, 5)

6、孤立的引用环

引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用，但引用计数不为0的一些对象。

a = []

b = [a]

a.append(b)

del a

del b

上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。

孤立的引用环：

为了回收这样的引用环，Python复制每个对象的引用计数，可以记为gc_ref。假设，每个对象i，该计数为gc_ref_i。Python会遍历所有的对象i。对于每个对象i引用的对象j，将相应的gc_ref_j减1。

遍历后的结果：

在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。

作业

1、通过闭包对一个数据 x 做“流水线操作”，至少三层闭包，每一层依次进行一项操作，（如先求绝对值，再开方，再求相反数）。

参考答案：

def xiangfan(x):

    def kaifang(x):

        def juedui(x):

            return abs(x)

        return juedui(x)**0.5

    return -kaifang(x)

print xiangfan(-4)

2、用装饰器实现第1题。

参考答案：

def juedui(x):

    return abs(x)

def kaifang(F):

    def new_F(x):

        return F(x)**0.5

    return new_F

def xiangfan(F):

    def new_F(x):

        return -F(x)

    return new_F

func=xiangfan(kaifang(juedui))

print func(-4)

Python补充

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、序列的方法

在快速教程中，我们了解了最基本的序列(sequence)。回忆一下，序列包含有定值表(tuple)和表(list)。此外，字符串(string)是一种特殊的定值表。表的元素可以更改，定值表一旦建立，其元素不可更改。

任何的序列都可以引用其中的元素(item)。

下面的内建函数(built-in function)可用于序列(表，定值表，字符串)：

# s为一个序列

len(s)         返回： 序列中包含元素的个数

min(s)         返回： 序列中最小的元素

max(s)         返回： 序列中最大的元素

all(s)         返回： True, 如果所有元素都为True的话

any(s)         返回： True, 如果任一元素为True的话

下面的方法主要起查询功能，不改变序列本身, 可用于表和定值表：

sum(s)         返回：序列中所有元素的和

# x为元素值，i为下标(元素在序列中的位置)

s.count(x)     返回： x在s中出现的次数

s.index(x)     返回： x在s中第一次出现的下标

由于定值表的元素不可变更，下面方法只适用于表：

# l为一个表, l2为另一个表

l.extend(l2)        在表l的末尾添加表l2的所有元素

l.append(x)         在l的末尾附加x元素

l.sort()            对l中的元素排序

l.reverse()         将l中的元素逆序

l.pop()             返回：表l的最后一个元素，并在表l中删除该元素

del l[i]            删除该元素

(以上这些方法都是在原来的表的上进行操作，会对原来的表产生影响，而不是返回一个新表。)

下面是一些用于字符串的方法。尽管字符串是定值表的特殊的一种，但字符串(string)类有一些方法是改变字符串的。这些方法的本质不是对原有字符串进行操作，而是删除原有字符串，再建立一个新的字符串，所以并不与定值表的特点相矛盾。

#str为一个字符串，sub为str的一个子字符串。s为一个序列，它的元素都是字符串。width为一个整数，用于说明新生成字符串的宽度。

str.count(sub)       返回：sub在str中出现的次数

str.find(sub)        返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1

str.index(sub)       返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误

str.rfind(sub)       返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1

str.rindex(sub)      返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误

str.isalnum()        返回：True， 如果所有的字符都是字母或数字

str.isalpha()        返回：True，如果所有的字符都是字母

str.isdigit()        返回：True，如果所有的字符都是数字

str.istitle()        返回：True，如果所有的词的首字母都是大写

str.isspace()        返回：True，如果所有的字符都是空格

str.islower()        返回：True，如果所有的字符都是小写字母

str.isupper()        返回：True，如果所有的字符都是大写字母

str.split([sep, [max]])    返回：从左开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。可以str.split(',')的方式使用逗号或者其它分割符

str.rsplit([sep, [max]])   返回：从右开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。可以str.rsplit(',')的方式使用逗号或者其它分割符

str.join(s)                返回：将s中的元素，以str为分割符，合并成为一个字符串。

str.strip([sub])           返回：去掉字符串开头和结尾的空格。也可以提供参数sub，去掉位于字符串开头和结尾的sub

str.replace(sub, new_sub)  返回：用一个新的字符串new_sub替换str中的sub

str.capitalize()           返回：将str第一个字母大写

str.lower()                返回：将str全部字母改为小写

str.upper()                返回：将str全部字母改为大写

str.swapcase()             返回：将str大写字母改为小写，小写改为大写

str.title()                返回：将str的每个词(以空格分隔)的首字母大写

str.center(width)          返回：长度为width的字符串，将原字符串放入该字符串中心，其它空余位置为空格。

str.ljust(width)           返回：长度为width的字符串，将原字符串左对齐放入该字符串，其它空余位置为空格。

str.rjust(width)           返回：长度为width的字符串，将原字符串右对齐放入该字符串，其它空余位置为空格。

二、Python小技巧

在这里列举一些我使用Python时积累的小技巧。这些技巧是我在使用Python过程中经常使用的。之前很零碎的记在笔记本中，现在整理出来，和大家分享，也作为Python快速教程的一个补充。

1、import模块

在Python经常使用import声明，以使用其他模块(也就是其它.py文件)中定义的对象。

(1)、使用name

当我们编写Python库模块的时候，我们往往运行一些测试语句。当这个程序作为库被import的时候，我们并不需要运行这些测试语句。一种解决方法是在import之前，将模块中的测试语句注释掉。Python有一种更优美的解决方法，就是使用__name__。

下面是一个简单的库程序TestLib.py。当直接运行TestLib.py时，__name__为"__main__"。如果被import的话，__name__为"TestLib"。

def lib_func(a):

    return a + 10

def lib_func_another(b):

    return b + 20

if __name__ == '__main__':

    test = 101

    print(lib_func(test))

print '__name__: ',__name__   #注意观察

我们在user.py中import上面的TestLib：

import TestLib

print(TestLib.lib_func(120))

你可以尝试不在TestLib.py中使用if __name__=='__main__'，并对比运行结果。

(2)、更多import使用方式

import TestLib as test # 引用TestLib模块，并将它改名为t

比如：

import TestLib as t

print(t.lib_func(120))

from TestLib import lib_func # 只引用TestLib中的lib_func对象，并跳过TestLib引用字段

这样的好处是减小所引用模块的内存占用。

比如：

from TestLib import lib_func

print(lib_func(120))

from TestLib import * # 引用所有TestLib中的对象，并跳过TestLib引用字段

比如：

from TestLib import *

print(lib_func(120))

2、查询

(1)、查询函数的参数

当我们想要知道某个函数会接收哪些参数的时候，可以使用下面方法查询。

import inspect

print(inspect.getargspec(func))

(2)、查询对象的属性

除了使用dir()来查询对象的属性之外，我们可以使用下面内置(built-in)函数来确认一个对象是否具有某个属性：

hasattr(obj, attr_name)   # attr_name是一个字符串

例如：

a = [1,2,3]

print(hasattr(a,'append'))

(3)、查询对象所属的类和类名称

a = [1, 2, 3]

print a.__class__

print a.__class__.__name__

(4)、查询父类

我们可以用 __base__ 属性来查询某个类的父类：

cls.__base__

例如：

print(list.__base__)

3、使用中文(以及其它非ASCII编码)

在Python程序的第一行加入#coding=utf8，例如:

#coding=utf8

print("你好吗？")

也能用以下方式：

#-*- coding: UTF-8 -*-

print("你好吗？")

4、表示2进制，8进制和16进制数字

在2.6以上版本，以如下方式表示：

print(0b1110)     # 二进制，以0b开头

print(0o10)       # 八进制，以0o开头

print(0x2A)       # 十六进制，以0x开头

如果是更早版本，可以用如下方式：

print(int("1110", 2))

print(int("10", 8))

print(int("2A", 16))

5、注释

一行内的注释可以以#开始。

多行的注释可以以'''开始，以'''结束，比如：

'''

This is demo

'''

def func():

    # print something

    print("Hello world!")  # use print() function

# main

func()

注释应该和所在的程序块对齐。

6、搜索路径

当我们import的时候，Python会在搜索路径中查找模块(module)。比如上面import TestLib，就要求TestLib.py在搜索路径中。

我们可以通过下面方法来查看搜索路径：

import sys

print(sys.path)

我们可以在Python运行的时候增加或者删除sys.path中的元素。另一方面，我们可以通过在shell中增加PYTHONPATH环境变量，来为Python增加搜索路径。

下面我们增加/home/vamei/mylib到搜索路径中：

$export PYTHONPATH=$PYTHONPATH:/home/vamei/mylib

你可以将正面的这行命令加入到～/.bashrc中。这样，我们就长期的改变了搜索路径。

7、脚本与命令行结合

可以使用下面方法运行一个Python脚本，在脚本运行结束后，直接进入Python命令行。这样做的好处是脚本的对象不会被清空，可以通过命令行直接调用。dh直接进入命令行，原来脚本的内容还在

$python -i script.py

8、安装非标准包

Python的标准库随着Python一起安装。当我们需要非标准包时，就要先安装。

(1)、使用Linux repository (Linux环境)

这是安装Python附加包的一个好的起点。你可以在Linux repository中查找可能存在的Python包 (比如在Ubuntu Software Center中搜索matplot)。

(2)、使用pip。pip是Python自带的包管理程序，它连接Python repository，并查找其中可能存在的包。

比如使用如下方法来安装、卸载或者升级web.py：

$pip install -i http://mirrors.aliyuncs.com/pypi/simple web.py

$pip uninstall web.py

$pip install -i http://mirrors.aliyuncs.com/pypi/simple --upgrade web.py

如果你的Python安装在一个非标准的路径(使用$which python来确认python可执行文件的路径)中，比如/home/vamei/util/python/bin中，你可以使用下面方法设置pip的安装包的路径:

$pip install -i http://mirrors.aliyuncs.com/pypi/simple --install-option="--prefix=/home/vamei/util/" web.py

(3)、从源码编译

如果上面方法都没法找到你想要的库，你可能需要从源码开始编译。Google往往是最好的起点。

三、Python内置函数清单

Python内置(built-in)函数随着python解释器的运行而创建。在Python的程序中，你可以随时调用这些函数，不需要定义。最常见的内置函数是:

print("Hello World!")

在Python教程中，我们已经提到下面一些内置函数:

type() dir() help() len() len() open() range() enumerate() zip() iter() map() filter() reduce()

下面我采取的都是实际的参数，你可以直接在命令行尝试效果。

1、数学运算

abs(-5)                          # 取绝对值，也就是5

round(2.6)                       # 四舍五入取整，也就是3.0

pow(2, 3)                        # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5

cmp(2.3, 3.2)                    # 比较两个数的大小

divmod(9,2)                      # 返回除法结果和余数

max([1,5,2,9])                   # 求最大值

min([9,2,-4,2])                  # 求最小值

sum([2,-1,9,12])                 # 求和

2、类型转换

dh>>> bin(0)

'0b0'

>>> bin(2)

'0b10'

>>> bin(002)

'0b10'

>>> bin(200)

'0b11001000'

>>> bin(20000)

'0b100111000100000'

>>> hex(20)

'0x14'

>>> hex(15)

'0xf'

>>> hex(16)

'0x10'

>>> oct(8)

'010'

>>> oct(18)

'022'

int("5")                         # 转换为整数 integer

float(2)                         # 转换为浮点数 float

long("23")                       # 转换为长整数 long integer

str(2.3)                         # 转换为字符串 string

complex(3, 9)                    # 返回复数 3 + 9i

ord("A")                         # "A"字符对应的数值

chr(65)                          # 数值65对应的字符

unichr(65)                       # 数值65对应的unicode字符

bool(0)                          # 转换为相应的真假值，在Python中，0相当于False .在Python中，下列对象都相当于False：** [], (), {}, 0, None, 0.0, '' **

bin(56)                          # 返回一个字符串，表示56的二进制数

hex(56)                          # 返回一个字符串，表示56的十六进制数

oct(56)                          # 返回一个字符串，表示56的八进制数

list((1,2,3))                    # 转换为表 list

tuple([2,3,4])                   # 转换为定值表 tuple

slice(5,2,-1)                    # 构建下标对象 slice

dict(a=1,b="hello",c=[1,2,3])    # 构建词典 dictionary

3、序列操作

all([True, 1, "hello!"])         # 是否所有的元素都相当于True值

any(["", 0, False, [], None])    # 是否有任意一个元素相当于True值

sorted([1,5,3])                  # 返回正序的序列，也就是[1,3,5]

reversed([1,5,3])                # 返回反序的序列，也就是[3,5,1]

4、类、对象、属性

# define class

class Me(object):

    def test(self):

        print "Hello!"

def new_test():

    print "New Hello!"

me = Me()

hasattr(me, "test")               # 检查me对象是否有test属性

getattr(me, "test")               # 返回test属性

setattr(me, "test", new_test)     # 将test属性设置为new_test

delattr(me, "test")               # 删除test属性

isinstance(me, Me)                # me对象是否为Me类生成的对象 (一个instance)

issubclass(Me, object)            # Me类是否为object类的子类

5、编译、执行

repr(me)                          # 返回对象的字符串表达

compile("print('Hello')",'test.py','exec')       # 编译字符串成为code对象

eval("1 + 1")                     # 解释字符串表达式。参数也可以是compile()返回的code对象

exec("print('Hello')")            # 解释并执行字符串，print('Hello')。参数也可以是compile()返回的code对象

6、其他

input("Please input:")            # 等待输入

globals()                         # 返回全局命名空间，比如全局变量名，全局函数名

locals()                          # 返回局部命名空间

四、字符串格式化（%操作符）

在许多编程语言中都包含有格式化字符串的功能，比如C和Fortran语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作%。

1、模板

格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个tuple将多个值传递给模板，每个值对应一个格式符。

比如下面的例子：

print("I'm %s. I'm %d year old" % ('Vamei', 99))

上面的例子中，"I'm %s. I'm %d year old" 为我们的模板。%s为第一个格式符，表示一个字符串。%d为第二个格式符，表示一个整数。('Vamei', 99)的两个元素'Vamei'和99为替换%s和%d的真实值。

在模板和tuple之间，有一个%号分隔，它代表了格式化操作。

整个"I'm %s. I'm %d year old" % ('Vamei', 99) 实际上构成一个字符串表达式。我们可以像一个正常的字符串那样，将它赋值给某个变量。比如:

a = "I'm %s. I'm %d year old" % ('Vamei', 99)

print(a)

我们还可以用词典来传递真实值。如下：

print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})

可以看到，我们对两个格式符进行了命名。命名使用()括起来。每个命名对应词典的一个key。

2、格式符

格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:

%s    字符串 (采用str()的显示)

%r    字符串 (采用repr()的显示)

%c    单个字符

%b    二进制整数

%d    十进制整数

%i    十进制整数

%o    八进制整数

%x    十六进制整数

%e    指数 (基底写为e)

%E    指数 (基底写为E)

%f    浮点数

%F    浮点数，与上相同

%g    指数(e)或浮点数 (根据显示长度)

%G    指数(E)或浮点数 (根据显示长度)

%%    字符"%"

可以用如下的方式，对格式进行进一步的控制：

%[(name)][flags][width].[precision]typecode

(name)为命名

flags可以有+,-,' '或0。+表示右对齐。-表示左对齐。' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。

width表示显示宽度

precision表示小数点后精度

比如：

print("%+10x" % 10)

print("%04d" % 5)

print("%6.3f" % 2.3)

上面的width, precision为两个整数。我们可以利用*，来动态代入这两个量。比如：

print("%.*f" % (4, 1.2))

Python实际上用4来替换*。所以实际的模板为"%.4f"。

作业

1、按照过程，在实验楼环境运行本节内容的代码，并截图。

2、熟练使用本节内容介绍的技巧、内置函数。

Python标准库（上）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

Python有一套很有用的标准库(standard library)。标准库会随着Python解释器，一起安装在你的电脑中的。它是Python的一个组成部分。这些标准库是Python为你准备好的利器，可以让编程事半功倍。

我将根据我个人的使用经验中，挑选出标准库比较常用的包(package)介绍。

一、正则表达式 (re包)

我将从正则表达式开始讲Python的标准库。正则表达式是文字处理中常用的工具，而且不需要额外的系统知识或经验。我们会把系统相关的包放在后面讲解。

正则表达式(regular expression)主要功能是从字符串(string)中通过特定的模式(pattern)，搜索想要找到的内容。

1、语法

之前，我们简介了字符串相关的处理函数。我们可以通过这些函数实现简单的搜索功能，比如说从字符串“I love you”中搜索是否有“you”这一子字符串。但有些时候，我们只是模糊地知道我们想要找什么，而不能具体说出我是在找“you”，比如说，我想找出字符串中包含的数字，这些数字可以是0到9中的任何一个。这些模糊的目标可以作为信息写入正则表达式，传递给Python，从而让Python知道我们想要找的是什么。

官方documentation

在Python中使用正则表达式需要标准库中的一个包re。

import re

m = re.search('[0-9]','abcd4ef')

print(m.group(0))

re.search()接收两个参数，第一个'[0-9]'就是我们所说的正则表达式，它告诉Python的是：“听着，我从字符串想要找的是从0到9的一个数字字符”。

re.search()如果从第二个参数找到符合要求的子字符串，就返回一个对象m，你可以通过m.group()的方法查看搜索到的结果。如果没有找到符合要求的字符，re.search()会返回None。

如果你熟悉Linux或者Perl, 你应该已经熟悉正则表达式。当我们打开Linux shell的时候，可以用正则表达式去查找或着删除我们想要的文件，比如说：

$rm book[0-9][0-9].txt

这就是要删除类似于book02.txt的文件。book[0-9][0-9].txt所包含的信息是，以book开头，后面跟两个数字字符，之后跟有".txt"的文件名。如果不符合条件的文件名，比如说:

bo12.txt

book1.txt

book99.text

都不会被选中。

Perl中内建有正则表达式的功能，据说是所有正则表达式系统中最强的，这也是Perl成为系统管理员利器的一个原因。

2、正则表达式的函数

m = re.search(pattern, string)  # 搜索整个字符串，直到发现符合的子字符串。#dh这个时候还没有完全匹配所有的，

m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式。必须从字符串的第一个字符开始就相符。

可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用re.match()的话，则会得到None，因为字符串的起始为‘a’，不符合'[0-9]'的要求。

对于返回的m, 我们使用m.group()来调用结果。（我们会在后面更详细解释m.group()）

我们还可以在搜索之后将搜索到的子字符串进行替换：

str = re.sub(pattern, replacement, string)

# 在string中利用正则变换pattern进行搜索，对于搜索到的字符串，用另一字符串replacement替换。返回替换后的字符串。

此外，常用的正则表达式函数还有：

re.split()    # 根据正则表达式分割字符串， 将分割后的所有子字符串放在一个表(list)中返回

re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字符串放在一个表(list)中返回

(在熟悉了上面的函数后，可以看一下re.compile()，以便于提高搜索效率。)

3、写一个正则表达式

关键在于将信息写成一个正则表达式。我们先看正则表达式的常用语法：

(1)、单个字符:

.          任意的一个字符

a|b        字符a或字符b

[afg]      a或者f或者g的一个字符

[0-4]      0-4范围内的一个字符

[a-f]      a-f范围内的一个字符

[^m]       不是m的一个字符

\s         一个空格

\S         一个非空格

\d         [0-9]

\D         [^0-9]

\w         [0-9a-zA-Z]

\W         [^0-9a-zA-Z]

(2)、重复

紧跟在单个字符之后，表示多个这样类似的字符：

*         重复 >=0 次

+         重复 >=1 次

?         重复 0或者1 次

{m}       重复m次。比如说 a{4}相当于aaaa，再比如说[1-3]{2}相当于[1-3][1-3]

{m, n}    重复m到n次。比如说a{2, 5}表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。

正则表达	相符的字符串举例
[0-9]{3,5}	9678
a?b	b
a+b	aaaaab

(3)、位置

^ 字符串的起始位置

$ 字符串的结尾位置

正则表达	相符的字符串举例	不相符字符串
^ab.*c$	abeec	cabeec (如果用re.search(), 将无法找到。)

(4)、返回控制

我们有可能对搜索的结果进行进一步精简信息。比如下面一个正则表达式：

output_(\d{4})

该正则表达式用括号()包围了一个小的正则表达式，\d{4}。这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。

我们可以m.group(number)的方法来查询群。group(0)是整个正则表达的搜索结果，group(1)是第一个群……

import re

m = re.search("output_(\d{4})", "output_1986.txt")

print(m.group(1))

我们还可以将群命名，以便更好地使用m.group查询:

import re

m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   #(?P<name>...) 为group命名

print(m.group("year"))

二、时间与日期 (time, datetime包)

Python具有良好的时间和日期管理功能。实际上，计算机只会维护一个挂钟时间(wall clock time)，这个时间是从某个固定时间起点到现在的时间间隔。时间起点的选择与计算机相关，但一台计算机的话，这一时间起点是固定的。其它的日期信息都是从这一时间计算得到的。此外，计算机还可以测量CPU实际上运行的时间，也就是处理器时间(processor clock time)，以测量计算机性能。当CPU处于闲置状态时，处理器时间会暂停。

1、time包

time包基于C语言的库函数(library functions)。Python的解释器通常是用C编写的，Python的一些函数也会直接调用C语言的库函数。

import time

print(time.time())   # wall clock time, unit: second

print(time.clock())  # processor clock time, unit: second

time.sleep()可以将程序置于休眠状态，直到某时间间隔之后再唤醒程序，让程序继续运行。

import time

print('start')

time.sleep(10)     # sleep for 10 seconds

print('wake up')

当我们需要定时地查看程序运行状态时，就可以利用该方法。

time包还定义了struct_time对象。该对象实际上是将挂钟时间转换为年、月、日、时、分、秒……等日期信息，存储在该对象的各个属性中(tm_year, tm_mon, tm_mday...)。下面方法可以将挂钟时间转换为struct_time对象:

st = time.gmtime()      # 返回struct_time格式的UTC时间

st = time.localtime()   # 返回struct_time格式的当地时间, 当地时区根据系统环境决定。

s  = time.mktime(st)    # 将struct_time格式转换成wall clock time

2、datetime包

(1)、简介

datetime包是基于time包的一个高级包，为我们提供了多一层的便利。

datetime可以理解为date和time两个组成部分。date是指年月日构成的日期(相当于日历)，time是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)。你可以将这两个分开管理(datetime.date类，datetime.time类)，也可以将两者合在一起(datetime.datetime类)。由于其构造大同小异，我们将只介绍datetime.datetime类。

比如说我现在看到的时间，是2012年9月3日21时30分，我们可以用如下方式表达：

import datetime

t = datetime.datetime(2012,9,3,21,30)

print(t)

所返回的t有如下属性:

hour, minute, second, microsecond

year, month, day, weekday   # weekday表示周几

(2)、运算

datetime包还定义了时间间隔对象(timedelta)。一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。

import datetime

t      = datetime.datetime(2012,9,3,21,30)

t_next = datetime.datetime(2012,9,5,23,30)

delta1 = datetime.timedelta(seconds = 600)

delta2 = datetime.timedelta(weeks = 3)

print(t + delta1)

print(t + delta2)

print(t_next - t)

在给datetime.timedelta传递参数（如上的seconds和weeks）的时候，还可以是days, hours, milliseconds, microseconds。

两个datetime对象还可以进行比较。比如使用上面的t和t_next:

print(t > t_next)

(3)、datetime对象与字符串转换

假如我们有一个的字符串，我们如何将它转换成为datetime对象呢？

一个方法是用上一讲的正则表达式来搜索字符串。但时间信息实际上有很明显的特征，我们可以用格式化读取的方式读取时间信息。

from datetime import datetime

format = "output-%Y-%m-%d-%H%M%S.txt"

str    = "output-1997-12-23-030000.txt"

t      = datetime.strptime(str, format)

我们通过format来告知Python我们的str字符串中包含的日期的格式。在format中，%Y表示年所出现的位置, %m表示月份所出现的位置……。

反过来，我们也可以调用datetime对象的strftime()方法，来将datetime对象转换为特定格式的字符串。比如上面所定义的t_next,

print(t_next.strftime(format))

具体的格式写法可参阅官方文档。如果是Linux系统，也可查阅date命令的手册($man date)，两者相通。

三、路径与文件 (os.path包, glob包)

1、os.path包

os.path包主要是处理路径字符串，比如说'/home/vamei/doc/file.txt'，提取出有用信息。

import os.path

path = '/home/vamei/doc/file.txt'

print(os.path.basename(path))    # 查询路径中包含的文件名

print(os.path.dirname(path))     # 查询路径中包含的目录

info = os.path.split(path)       # 将路径分割成文件名和目录两个部分，放在一个表中返回

path2 = os.path.join('/', 'home', 'vamei', 'doc', 'file1.txt')  # 使用目录名和文件名构成一个路径字符串

p_list = [path, path2]

print(os.path.commonprefix(p_list))    # 查询多个路径的共同部分

此外，还有下面的方法：

os.path.normpath(path)   # 去除路径path中的冗余。比如'/home/vamei/../.'被转化为'/home'

os.path还可以查询文件的相关信息(metadata)。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息(比如文件类型，大小，修改时间)。

import os.path

path = '/home/vamei/doc/file.txt'

print(os.path.exists(path))    # 查询文件是否存在

print(os.path.getsize(path))   # 查询文件大小

print(os.path.getatime(path))  # 查询文件上一次读取的时间

print(os.path.getmtime(path))  # 查询文件上一次修改的时间

print(os.path.isfile(path))    # 路径是否指向常规文件

print(os.path.isdir(path))     # 路径是否指向目录文件

(实际上，这一部份类似于Linux中的ls命令的某些功能)

2、glob包

glob包最常用的方法只有一个, glob.glob()。该方法的功能与Linux中的ls相似，接受一个Linux式的文件名格式表达式(filename pattern expression)，列出所有符合该表达式的文件（与正则表达式类似），将所有文件名放在一个表中返回。所以glob.glob()是一个查询目录下文件的好方法。

该文件名表达式的语法与Python自身的正则表达式不同 (你可以同时看一下fnmatch包，它的功能是检测一个文件名是否符合Linux的文件名格式表达式)。如下：

Filename Pattern Expression	Python Regular Expression
*	.*
?	.
[0-9]	same
[a-e]	same
[^mnp]	same

我们可以用该命令找出/home/vamei下的所有文件:

import glob

print(glob.glob('/home/vamei/*'))

四、文件管理 (部分os包，shutil包)

在操作系统下，用户可以通过操作系统的命令来管理文件。Python标准库则允许我们从Python内部管理文件。相同的目的，我们有了两条途径。尽管在Python调用标准库的方式不如操作系统命令直接，但有它自己的优势。你可以利用Python语言，并发挥其他Python工具，形成组合的文件管理功能。Python or Shell? 这是留给用户的选择。本文中会尽量将两者相似的功能相对应。

1、os包

os包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。os包的一些命令就是用于文件管理。我们这里列出最常用的:

mkdir(path) 创建新目录，path为一个字符串，表示新目录的路径。相当于$mkdir命令
rmdir(path) 删除空的目录，path为一个字符串，表示想要删除的目录的路径。相当于$rmdir命令
listdir(path) 返回目录中所有文件。相当于$ls命令。
remove(path) 删除 path指向的文件。
rename(src, dst) 重命名文件，src和dst为两个路径，分别表示重命名之前和之后的路径。
chmod(path, mode) 改变path指向的文件的权限。相当于$chmod命令。
chown(path, uid, gid) 改变path所指向文件的拥有者和拥有组。相当于$chown命令。
stat(path) 查看path所指向文件的附加信息，相当于$ls -l命令。
symlink(src, dst) 为文件dst创建软链接，src为软链接文件的路径。相当于$ln -s命令。
getcwd() 查询当前工作路径 (cwd, current working directory)，相当于$pwd命令。

比如说我们要新建目录new：

import os

os.mkdir('/home/vamei/new')

2、shutil包

copy(src, dst) 复制文件，从src到dst。相当于$cp命令。
move(src, dst) 移动文件，从src到dst。相当于$mv命令。

比如我们想复制文件a.txt:

import shutil

shutil.copy('a.txt', 'b.txt')

想深入细节，请参照官方文档os, shutil。

结合本章以及之前的内容，我们把Python打造成一个文件管理的利器了。

五、存储对象 (pickle包，cPickle包)

在之前对Python对象的介绍中，我提到过Python“一切皆对象”的哲学，在Python中，无论是变量还是函数，都是一个对象。当Python运行时，对象存储在内存中，随时等待系统的调用。然而，内存里的数据会随着计算机关机和消失，如何将对象保存到文件，并储存在硬盘上呢？

计算机的内存中存储的是二进制的序列 (当然，在Linux眼中，是文本流)。我们可以直接将某个对象所对应位置的数据抓取下来，转换成文本流 (这个过程叫做serialize)，然后将文本流存入到文件中。由于Python在创建对象时，要参考对象的类定义，所以当我们从文本中读取对象时，必须在手边要有该对象的类定义，才能懂得如何去重建这一对象。从文件读取时，对于Python的内建(built-in)对象 (比如说整数、词典、表等等)，由于其类定义已经载入内存，所以不需要我们再在程序中定义类。但对于用户自行定义的对象，就必须要先定义类，然后才能从文件中载入对象 (比如面向对象的基本概念中的对象那个summer)。

1、pickle包

对于上述过程，最常用的工具是Python中的pickle包。

(1)、将内存中的对象转换成为文本流：

import pickle

# define class

class Bird(object):

    have_feather = True

    way_of_reproduction  = 'egg'

summer       = Bird()                 # construct an object

picklestring = pickle.dumps(summer)   # serialize object

使用pickle.dumps()方法可以将对象summer转换成了字符串 picklestring(也就是文本流)。随后我们可以用普通文本的存储方法来将该字符串储存在文件(文本文件的输入输出)。

当然，我们也可以使用pickle.dump()的方法，将上面两部合二为一:

import pickle

# define class

class Bird(object):

    have_feather = True

    way_of_reproduction  = 'egg'

summer       = Bird()                        # construct an object

fn           = 'a.pkl'

with open(fn, 'w') as f:                     # open file with write-mode

    picklestring = pickle.dump(summer, f)   # serialize and save object

对象summer存储在文件a.pkl

(2)、重建对象

首先，我们要从文本中读出文本，存储到字符串 (文本文件的输入输出)。然后使用pickle.loads(str)的方法，将字符串转换成为对象。要记得，此时我们的程序中必须已经有了该对象的类定义。

此外，我们也可以使用pickle.load()的方法，将上面步骤合并:

import pickle

# define the class before unpickle

class Bird(object):

    have_feather = True

    way_of_reproduction  = 'egg'

fn     = 'a.pkl'

with open(fn, 'r') as f:

    summer = pickle.load(f)   # read file and build object

2、cPickle包

cPickle包的功能和用法与pickle包几乎完全相同 (其存在差别的地方实际上很少用到)，不同在于cPickle是基于c语言编写的，速度是pickle包的1000倍。对于上面的例子，如果想使用cPickle包，我们都可以将import语句改为:

import cPickle as pickle

就不需要再做任何改动了。

作业

有一个文件，文件名为output_1981.10.21.txt 。下面使用Python：读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为output_YYYY-MM-DD-W.txt (YYYY:四位的年，MM：两位的月份，DD：两位的日，W：一位的周几，并假设周一为一周第一天)。

Python标准库（中）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、子进程 (subprocess包)

这里的内容以Linux进程基础和Linux文本流为基础。subprocess包主要功能是执行外部的命令和程序。比如说，我需要使用wget下载文件。我在Python中调用wget程序。从这个意义上来说，subprocess的功能与shell类似。

1、subprocess以及常用的封装函数

当我们运行python的时候，我们都是在创建并运行一个进程。一个进程可以fork一个子进程，并让这个子进程exec另外一个程序。在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序。

subprocess包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所以我们可以根据需要来从中选取一个使用。另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。

使用subprocess包中的函数创建子进程的时候，要注意:

1 在创建子进程之后，父进程是否暂停，并等待子进程运行。
2 函数返回什么
3 当returncode不为0时，父进程如何处理。

(1)、subprocess.call()

父进程等待子进程完成

返回退出信息(returncode，相当于exit code)

(2)、subprocess.check_call()

父进程等待子进程完成

返回0

检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性，可用try...except...来检查(见Python错误处理)。

(3)、subprocess.check_output()

父进程等待子进程完成

返回子进程向标准输出的输出结果

检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性和output属性，output属性为标准输出的输出结果，可用try...except...来检查。

这三个函数的使用方法相类似，我们以subprocess.call()来说明:

import subprocess

rc = subprocess.call(["ls","-l"])

我们将程序名(ls)和所带的参数(-l)一起放在一个表中传递给subprocess.call()

可以通过一个shell来解释一整个字符串:

import subprocess

out = subprocess.call("ls -l", shell=True)

out = subprocess.call("cd ..", shell=True)

我们使用了shell=True这个参数。这个时候，我们使用一整个字符串，而不是一个表来运行子进程。Python将先运行一个shell，再用这个shell来解释这整个字符串。

shell命令中有一些是shell的内建命令，这些命令必须通过shell运行，$cd。shell=True允许我们运行这样一些命令。

2、Popen()

实际上，我们上面的三个函数都是基于Popen()的封装(wrapper)。这些封装的目的在于让我们容易使用子进程。当我们想要更个性化我们的需求的时候，就要转向Popen类，该类生成的对象用来代表子进程。

与上面的封装不同，Popen对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待 (也就是阻塞block)：

import subprocess

child = subprocess.Popen(["ping","-c","5","www.google.com"])

print("parent process")

从运行结果中看到，父进程在开启子进程之后并没有等待child的完成，而是直接运行print。

对比等待的情况:

import subprocess

child = subprocess.Popen(["ping","-c","5","www.google.com"])

child.wait()

print("parent process")

此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的child对象:

child.poll() # 检查子进程状态
child.kill() # 终止子进程
child.send_signal() # 向子进程发送信号
child.terminate() # 终止子进程

子进程的PID存储在child.pid。

3、子进程的文本流控制

(沿用child子进程) 子进程的标准输入，标准输出和标准错误也可以通过如下属性表示:

child.stdin

child.stdout

child.stderr

我们可以在Popen()建立子进程的时候改变标准输入、标准输出和标准错误，并可以利用subprocess.PIPE将多个子进程的输入和输出连接在一起，构成管道(pipe):

import subprocess

child1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)

child2 = subprocess.Popen(["wc"], stdin=child1.stdout,stdout=subprocess.PIPE)

out = child2.communicate()

print(out)

subprocess.PIPE实际上为文本流提供一个缓存区。child1的stdout将文本输出到缓存区，随后child2的stdin从该PIPE中将文本读取走。child2的输出文本也被存放在PIPE中，直到communicate()方法从PIPE中读取出PIPE中的文本。

dh这里，我觉得PIPE就是连接两个进程之间的输入输出，命令是有效的，但是测试了linux环境，win7环境失效，还得再找找原因。

要注意的是，communicate()是Popen对象的一个方法，该方法会阻塞父进程，直到子进程完成。

我们还可以利用communicate()方法来使用PIPE给子进程输入:

import subprocess

child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)

child.communicate("vamei")

我们启动子进程之后，cat会等待输入，直到我们用communicate()输入"vamei"。

dh我觉得管道内外交互、管道之间交互，不仅仅是文字流还有命令，这个还要再好好学一学

通过使用subprocess包，我们可以运行外部程序。这极大的拓展了Python的功能。如果你已经了解了操作系统的某些应用，你可以从Python中直接调用该应用(而不是完全依赖Python)，并将应用的结果输出给Python，并让Python继续处理。shell的功能(比如利用文本流连接各个应用)，就可以在Python中实现。

二、信号 (signal包)

signal包负责在Python程序内部处理信号，典型的操作包括预设信号处理函数，暂停并等待信号，以及定时发出SIGALRM等。要注意，signal包主要是针对UNIX平台(比如Linux, MAC OS)，而Windows内核中由于对信号机制的支持不充分，所以在Windows上的Python不能发挥信号系统的功能。

1、定义信号名

signal包定义了各个信号名及其对应的整数，比如：

import signal

print signal.SIGALRM

print signal.SIGCONT

Python所用的信号名和Linux一致。你可以通过以下命令查询：

$man 7 signal

2、预设信号处理函数

signal包的核心是使用signal.signal()函数来预设(register)信号处理函数，如下所示：

singnal.signal(signalnum, handler)

signalnum为某个信号，handler为该信号的处理函数。我们在信号基础里提到，进程可以无视信号，可以采取默认操作，还可以自定义操作。当handler为signal.SIG_IGN时，信号被无视(ignore)。当handler为singal.SIG_DFL，进程采取默认操作(default)。当handler为一个函数名时，进程采取函数中定义的操作。

import signal

# Define signal handler function

def myHandler(signum, frame):

    print('I received: ', signum)

# register signal.SIGTSTP's handler

signal.signal(signal.SIGTSTP, myHandler)

signal.pause()

print('End of Signal Demo')

在主程序中，我们首先使用signal.signal()函数来预设信号处理函数。然后我们执行signal.pause()来让该进程暂停以等待信号，以等待信号。当信号SIGUSR1被传递给该进程时，进程从暂停中恢复，并根据预设，执行SIGTSTP的信号处理函数myHandler()。myHandler的两个参数一个用来识别信号(signum)，另一个用来获得信号发生时，进程栈的状况(stack frame)。这两个参数都是由signal.singnal()函数来传递的。

上面的程序可以保存在一个文件中(比如test.py)。我们使用如下方法运行:

$python test.py

以便让进程运行。当程序运行到signal.pause()的时候，进程暂停并等待信号。此时，通过按下CTRL+Z向该进程发送SIGTSTP信号。我们可以看到，进程执行了myHandle()函数, 随后返回主程序，继续执行。(当然，也可以用\$ps查询process ID, 再使用$kill来发出信号。)

(进程并不一定要使用signal.pause()暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的signal.pause()改为一个需要长时间工作的循环。)

我们可以根据自己的需要更改myHandler()中的操作，以针对不同的信号实现个性化的处理。

3、定时发出SIGALRM信号

一个有用的函数是signal.alarm()，它被用于在一定时间之后，向进程自身发送SIGALRM信号:

import signal

# Define signal handler function

def myHandler(signum, frame):

    print("Now, it's the time")

    exit()

# register signal.SIGALRM's handler

signal.signal(signal.SIGALRM, myHandler)

signal.alarm(5)

while True:

    print('not yet')

我们这里用了一个无限循环以便让进程持续运行。在signal.alarm()执行5秒之后，进程将向自己发出SIGALRM信号，随后，信号处理函数myHandler开始执行。

4、发送信号

signal包的核心是设置信号处理函数。除了signal.alarm()向自身发送信号之外，并没有其他发送信号的功能。但在os包中，有类似于linux的kill命令的函数，分别为：

os.kill(pid, sid)

os.killpg(pgid, sid)

分别向进程和进程组发送信号。sid为信号所对应的整数或者singal.SIG*。

实际上signal, pause，kill和alarm都是Linux应用编程中常见的C库函数，在这里，我们只不过是用Python语言来实现了一下。实际上，Python 的解释器是使用C语言来编写的，所以有此相似性也并不意外。此外，在Python 3.4中，signal包被增强，信号阻塞等功能被加入到该包中。我们暂时不深入到该包中。

三、多线程与同步 (threading包)

Python主要通过标准库中的threading包来实现多线程。在当今网络时代，每个服务器都会接收到大量的请求。服务器可以利用多线程的方式来处理这些请求，以提高对网络端口的读写效率。Python是一种网络服务器的后台工作语言，所以多线程也就很自然被Python语言支持。

(关于多线程的原理和C实现方法，请参考Linux多线程与同步，要了解race condition, mutex和condition variable的概念)

1、多线程售票以及同步

我们使用Python来实现Linux多线程与同步文中的售票程序。我们使用mutex (也就是Python中的Lock类对象) 来实现线程的同步:

# A program to simulate selling tickets in multi-thread way

# Written by Vamei

import threading

import time

import os

# This function could be any function to do other chores.

def doChore():

    time.sleep(0.5)

# Function for each thread

def booth(tid):

    global i

    global lock

    while True:

        lock.acquire()                # Lock; or wait if other thread is holding the lock

        if i != 0:

            i = i - 1                 # Sell tickets

            print(tid,':now left:',i) # Tickets left

            doChore()                 # Other critical operations

        else:

            print("Thread_id",tid," No more tickets")

            os._exit(0)              # Exit the whole process immediately

        lock.release()               # Unblock

        doChore()                    # Non-critical operations

# Start of the main function

i    = 100                           # Available ticket number

lock = threading.Lock()              # Lock (i.e., mutex)

# Start 10 threads

for k in range(10):

    new_thread = threading.Thread(target=booth,args=(k,))   # Set up thread; target: the callable (function) to be run, args: the argument for the callable

    new_thread.start()                                      # run the thread

我们使用了两个全局变量，一个是i，用以储存剩余票数；一个是lock对象，用于同步线程对i的修改。此外，在最后的for循环中，我们总共设置了10个线程。每个线程都执行booth()函数。线程在调用start()方法的时候正式启动 (实际上，计算机中最多会有11个线程，因为主程序本身也会占用一个线程)。Python使用threading.Thread对象来代表线程，用threading.Lock对象来代表一个互斥锁 (mutex)。

有两点需要注意:

我们在函数中使用global来声明变量为全局变量，从而让多线程共享i和lock (在C语言中，我们通过将变量放在所有函数外面来让它成为全局变量)。如果不这么声明，由于i和lock是不可变数据对象，它们将被当作一个局部变量。如果是可变数据对象的话，则不需要global声明。我们甚至可以将可变数据对象作为参数来传递给线程函数。这些线程将共享这些可变数据对象。
我们在booth中使用了两个doChore()函数。可以在未来改进程序，以便让线程除了进行i=i-1之外，做更多的操作，比如打印剩余票数，找钱，或者喝口水之类的。第一个doChore()依然在Lock内部，所以可以安全地使用共享资源 (critical operations, 比如打印剩余票数)。第二个doChore()时，Lock已经被释放，所以不能再去使用共享资源。这时候可以做一些不使用共享资源的操作 (non-critical operation, 比如找钱、喝水)。我故意让doChore()等待了0.5秒，以代表这些额外的操作可能花费的时间。你可以定义的函数来代替doChore()。

2、OOP创建线程

上面的Python程序非常类似于一个面向过程的C程序。我们下面介绍如何通过面向对象 (OOP， object-oriented programming) 的方法实现多线程，其核心是继承threading.Thread类。我们上面的for循环中已经利用了threading.Thread()的方法来创建一个Thread对象，并将函数booth()以及其参数传递给改对象，并调用start()方法来运行线程。OOP的话，通过修改Thread类的run()方法来定义线程所要执行的命令。

# A program to simulate selling tickets in multi-thread way

# Written by Vamei

import threading

import time

import os

# This function could be any function to do other chores.

def doChore():

    time.sleep(0.5)

# Function for each thread

class BoothThread(threading.Thread):

    def __init__(self, tid, monitor):

        self.tid          = tid

        self.monitor = monitor

        threading.Thread.__init__(self)

    def run(self):

        while True:

            monitor['lock'].acquire()                          # Lock; or wait if other thread is holding the lock

            if monitor['tick'] != 0:

                monitor['tick'] = monitor['tick'] - 1          # Sell tickets

                print(self.tid,':now left:',monitor['tick'])   # Tickets left

                doChore()                                      # Other critical operations

            else:

                print("Thread_id",self.tid," No more tickets")

                os._exit(0)                                    # Exit the whole process immediately

            monitor['lock'].release()                          # Unblock

            doChore()                                          # Non-critical operations

# Start of the main function

monitor = {'tick':100, 'lock':threading.Lock()}

# Start 10 threads

for k in range(10):

    new_thread = BoothThread(k, monitor)

    new_thread.start()

我们自己定义了一个类BoothThread, 这个类继承自thread.Threading类。然后我们把上面的booth()所进行的操作统统放入到BoothThread类的run()方法中。注意，我们没有使用全局变量声明global，而是使用了一个词典 monitor存放全局变量，然后把词典作为参数传递给线程函数。由于词典是可变数据对象，所以当它被传递给函数的时候，函数所使用的依然是同一个对象，相当于被多个线程所共享。这也是多线程乃至于多进程编程的一个技巧 (应尽量避免上面的global声明的用法，因为它并不适用于windows平台)。

上面OOP编程方法与面向过程的编程方法相比，并没有带来太大实质性的差别。

3、其他

threading.Thread对象：我们已经介绍了该对象的start()和run(), 此外：

join()方法，调用该方法的线程将等待直到该Thread对象完成，再恢复运行。这与进程间调用wait()函数相类似。

下面的对象用于处理多线程同步。对象一旦被建立，可以被多个线程共享，并根据情况阻塞某些进程。

threading.Lock对象: mutex, 有acquire()和release()方法。

threading.Condition对象: condition variable，建立该对象时，会包含一个Lock对象 (因为condition variable总是和mutex一起使用)。可以对Condition对象调用acquire()和release()方法，以控制潜在的Lock对象。此外:

wait()方法，相当于cond_wait()
notify_all()，相当与cond_broadcast()
nofify()，与notify_all()功能类似，但只唤醒一个等待的线程，而不是全部

threading.Semaphore对象: semaphore，也就是计数锁(semaphore传统意义上是一种进程间同步工具)。创建对象的时候，可以传递一个整数作为计数上限 (sema = threading.Semaphore(5))。它与Lock类似，也有Lock的两个方法。

threading.Event对象: 与threading.Condition相类似，相当于没有潜在的Lock保护的condition variable。对象有True和False两个状态。可以多个线程使用wait()等待，直到某个线程调用该对象的set()方法，将对象设置为True。线程可以调用对象的clear()方法来重置对象为False状态。

四、进程信息 (部分os包)

Python的os包中有查询和修改进程信息的函数。学习Python的这些工具也有助于理解Linux体系。

1、进程信息

os包中相关函数如下：

(1)、uname() 返回操作系统相关信息。类似于Linux上的uname命令。

(2)、umask() 设置该进程创建文件时的权限mask。类似于Linux上的umask命令

(3)、get() 查询 (由以下代替)

uid, euid, resuid, gid, egid, resgid ：权限相关，其中resuid主要用来返回saved UID

pid, pgid, ppid, sid                 ：进程相关

(4)、put*() 设置 (*由以下代替)

euid, egid： 用于更改euid，egid。

uid, gid  ： 改变进程的uid, gid。只有super user才有权改变进程uid和gid (意味着要以$sudo python的方式运行Python)。

pgid, sid ： 改变进程所在的进程组(process group)和会话(session)。

(5)、getenviron()：获得进程的环境变量

(6)、setenviron()：更改进程的环境变量

例1，进程的real UID和real GID：

import os

print(os.getuid())

print(os.getgid())

将上面的程序保存为py_id.py文件，分别用\$python py_id.py和\$sudo python py_id.py看一下运行结果。

2、saved UID和saved GID

我们希望saved UID和saved GID如我们在Linux用户与“最小权限”原则中描述的那样工作，但这很难。原因在于，当我们写一个Python脚本后，我们实际运行的是python这个解释器，而不是Python脚本文件。对比C，C语言直接运行由C语言编译成的执行文件。我们必须更改python解释器本身的权限来运用saved UID机制，然而这么做又是异常危险的。

比如说，我们的python执行文件为/usr/bin/python (你可以通过$which python获知)

我们先看一下：

$ls -l /usr/bin/python

的结果：

-rwxr-xr-x root root

我们修改权限以设置set UID和set GID位 (参考Linux用户与“最小权限”原则)：

$sudo chmod 6755 /usr/bin/python

/usr/bin/python的权限成为:

-rwsr-sr-x root root

随后，我们运行文件下面test.py文件，这个文件可以是由普通用户所有:

import os

print(os.getresuid())

我们得到结果：(1000, 0, 0)

上面分别是UID，EUID，saved UID。我们只用执行一个由普通用户拥有的python脚本，就可以得到super user的权限！所以，这样做是极度危险的，我们相当于交出了系统的保护系统。想像一下Python强大的功能，别人现在可以用这些强大的功能作为攻击你的武器了！使用下面命令来恢复到从前:

$sudo chmod 0755 /usr/bin/python

关于脚本文件的saved UID/GID，更加详细的讨论见：http://www.faqs.org/faqs/unix-faq/faq/part4/section-7.html

五、多进程初步 (multiprocessing包)

我们已经见过了使用subprocess包来创建子进程，但这个包有两个很大的局限性：

(1) 我们总是让subprocess运行外部的程序，而不是运行一个Python脚本内部编写的函数。

(2) 进程间只通过管道进行文本交流。以上限制了我们将subprocess包应用到更广泛的多进程任务。(这样的比较实际是不公平的，因为subprocessing本身就是设计成为一个shell，而不是一个多进程管理包)。

1、threading和multiprocessing

multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。

但在使用这些共享API的时候，我们要注意以下几点:

在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性。
multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。
多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。

Process.PID中保存有PID，如果进程还没有start()，则PID为None。

我们可以从下面的程序中看到Thread对象和Process对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出(stdout)输出。这样输出的字符会混合在一起，无法阅读。使用Lock同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。

# Similarity and difference of multi thread vs. multi process

# Written by Vamei

import os

import threading

import multiprocessing

# worker function

def worker(sign, lock):

    lock.acquire()

    print(sign, os.getpid())

    lock.release()

# Main

print('Main:',os.getpid())

# Multi-thread

record = []

lock  = threading.Lock()

for i in range(5):

    thread = threading.Thread(target=worker,args=('thread',lock))

    thread.start()

    record.append(thread)

for thread in record:

    thread.join()

# Multi-process

record = []

lock = multiprocessing.Lock()

for i in range(5):

    process = multiprocessing.Process(target=worker,args=('process',lock))

    process.start()

    record.append(process)

for process in record:

    process.join()

所有Thread的PID都与主程序相同，而每个Process都有一个不同的PID。

2、Pipe和Queue

管道PIPE和消息队列message queue，multiprocessing包中有Pipe类和Queue类来分别支持这两种IPC机制。Pipe和Queue可以用来传送常见的对象。

(1)、 Pipe可以是单向(half-duplex)，也可以是双向(duplex)。我们通过mutiprocessing.Pipe(duplex=False)创建单向管道 (默认为双向)。一个进程从PIPE一端输入对象，然后被PIPE另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。

下面的程序展示了Pipe的使用:

# Multiprocessing with Pipe

# Written by Vamei

import multiprocessing as mul

def proc1(pipe):

    pipe.send('hello')

    print('proc1 rec:',pipe.recv())

def proc2(pipe):

    print('proc2 rec:',pipe.recv())

    pipe.send('hello, too')

# Build a pipe

pipe = mul.Pipe()

# Pass an end of the pipe to process 1

p1   = mul.Process(target=proc1, args=(pipe[0],))

# Pass the other end of the pipe to process 2

p2   = mul.Process(target=proc2, args=(pipe[1],))

p1.start()

p2.start()

p1.join()

p2.join()

这里的Pipe是双向的。

Pipe对象建立的时候，返回一个含有两个元素的表，每个元素代表Pipe的一端(Connection对象)。我们对Pipe的某一端调用send()方法来传送对象，在另一端使用recv()来接收。

(2)、 Queue与Pipe相类似，都是先进先出的结构。但Queue允许多个进程放入，多个进程从队列取出对象。Queue使用mutiprocessing.Queue(maxsize)创建，maxsize表示队列中可以存放对象的最大数量。

下面的程序展示了Queue的使用:

# Written by Vamei

import os

import multiprocessing

import time

#==================

# input worker

def inputQ(queue):

    info = str(os.getpid()) + '(put):' + str(time.time())

    queue.put(info)

# output worker

def outputQ(queue,lock):

    info = queue.get()

    lock.acquire()

    print (str(os.getpid()) + '(get):' + info)

    lock.release()

#===================

# Main

record1 = []   # store input processes

record2 = []   # store output processes

lock  = multiprocessing.Lock()    # To prevent messy print

queue = multiprocessing.Queue(3)

# input processes

for i in range(10):

    process = multiprocessing.Process(target=inputQ,args=(queue,))

    process.start()

    record1.append(process)

# output processes

for i in range(10):

    process = multiprocessing.Process(target=outputQ,args=(queue,lock))

    process.start()

    record2.append(process)

for p in record1:

    p.join()

queue.close()  # No more object will come, close the queue

for p in record2:

    p.join()

一些进程使用put()在Queue中放入字符串，这个字符串中包含PID和时间。另一些进程从Queue中取出，并打印自己的PID以及get()的字符串。

作业

1、参照Linux多线程与同步中的condition variable的例子，使用Python实现。同时考虑使用面向过程和面向对象的编程方法。

2、使用mutiprocessing包将本节内容中“多线程与同步 (threading包)”的多线程程序更改为多进程程序。

Python标准库（下）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、多进程探索 (multiprocessing包)

上一节的最后，初步了解Python多进程，现在我们可以继续探索multiprocessing包中更加高级的工具。这些工具可以让我们更加便利地实现多进程。

1、进程池

进程池 (Process Pool)可以创建多个进程。这些进程就像是随时待命的士兵，准备执行任务(程序)。一个进程池中可以容纳多个待命的士兵：

比如下面的程序:

import multiprocessing as mul

def f(x):

    return x**2

pool = mul.Pool(5)

rel  = pool.map(f,[1,2,3,4,5,6,7,8,9,10])

print(rel)

我们创建了一个容许5个进程的进程池 (Process Pool) 。Pool运行的每个进程都执行f()函数。我们利用map()方法，将f()函数作用到表的每个元素上。这与built-in的map()函数类似，只是这里用5个进程并行处理。如果进程运行结束后，还有需要处理的元素，那么的进程会被用于重新运行f()函数。除了map()方法外，Pool还有下面的常用方法。

apply_async(func,args) 从进程池中取出一个进程执行func，args为func的参数。它将返回一个AsyncResult的对象，你可以对该对象调用get()方法以获得结果。
close() 进程池不再创建新的进程
join() wait进程池中的全部进程。必须对Pool先调用close()方法才能join。

2、共享资源

我们在Python多进程初步已经提到，我们应该尽量避免多进程共享资源。多进程共享资源必然会带来进程间相互竞争。而这种竞争又会造成race condition，我们的结果有可能被竞争的不确定性所影响。但如果需要，我们依然可以通过共享内存和Manager对象这么做。

共享内存

我们已经讲述了共享内存(shared memory)的原理，这里给出用Python实现的例子:

# modified from official documentation

import multiprocessing

def f(n, a):

    n.value   = 3.14

    a[0]      = 5

num   = multiprocessing.Value('d', 0.0)

arr   = multiprocessing.Array('i', range(10))

p = multiprocessing.Process(target=f, args=(num, arr))

p.start()

p.join()

print num.value

print arr[:]

这里我们实际上只有主进程和Process对象代表的进程。我们在主进程的内存空间中创建共享的内存，也就是Value和Array两个对象。对象Value被设置成为双精度数(d), 并初始化为0.0。而Array则类似于C中的数组，有固定的类型(i, 也就是整数)。在Process进程中，我们修改了Value和Array对象。回到主程序，打印出结果，主程序也看到了两个对象的改变，说明资源确实在两个进程之间共享。

Manager

Manager对象类似于服务器与客户之间的通信 (server-client)，与我们在Internet上的活动很类似。我们用一个进程作为服务器，建立Manager来真正存放资源。其它的进程可以通过参数传递或者根据地址来访问Manager，建立连接后，操作服务器上的资源。在防火墙允许的情况下，我们完全可以将Manager运用于多计算机，从而模仿了一个真实的网络情境。下面的例子中，我们对Manager的使用类似于shared memory，但可以共享更丰富的对象类型。

import multiprocessing

def f(x, arr, l):

    x.value = 3.14

    arr[0] = 5

    l.append('Hello')

server = multiprocessing.Manager()

x    = server.Value('d', 0.0)

arr  = server.Array('i', range(10))

l    = server.list()

proc = multiprocessing.Process(target=f, args=(x, arr, l))

proc.start()

proc.join()

print(x.value)

print(arr)

print(l)

Manager利用list()方法提供了表的共享方式。实际上你可以利用dict()来共享词典，Lock()来共享threading.Lock(注意，我们共享的是threading.Lock，而不是进程的mutiprocessing.Lock。后者本身已经实现了进程共享)等。这样Manager就允许我们共享更多样的对象。

二、数学与随机数 (math包，random包)

我们已经在Python运算中看到Python最基本的数学运算功能。此外，math包补充了更多的函数。当然，如果想要更加高级的数学功能，可以考虑选择标准库之外的numpy和scipy项目，它们不但支持数组和矩阵运算，还有丰富的数学和物理方程可供使用。

此外，random包可以用来生成随机数。随机数不仅可以用于数学用途，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

1、math包

math包主要处理数学相关的运算。math包定义了两个常数:

math.e   # 自然常数e

math.pi  # 圆周率pi

此外，math包还有各种运算函数 (下面函数的功能可以参考数学手册)：

math.ceil(x)       # 对x向上取整，比如x=1.2，返回2

math.floor(x)      # 对x向下取整，比如x=1.2，返回1

math.pow(x,y)      # 指数运算，得到x的y次方

math.log(x)        # 对数，默认基底为e。可以使用base参数，来改变对数的基地。比如math.log(100,base=10)

math.sqrt(x)       # 平方根

三角函数: math.sin(x), math.cos(x), math.tan(x), math.asin(x), math.acos(x), math.atan(x)

这些函数都接收一个弧度(radian)为单位的x作为参数。

角度和弧度互换: math.degrees(x), math.radians(x)

双曲函数: math.sinh(x), math.cosh(x), math.tanh(x), math.asinh(x), math.acosh(x), math.atanh(x)

特殊函数： math.erf(x), math.gamma(x)

2、random包

如果你已经了解伪随机数(psudo-random number)的原理，那么你可以使用如下:

random.seed(x)

来改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

(1)、随机挑选和排序

random.choice(seq)   # 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

random.sample(seq,k) # 从序列中随机挑选k个元素

random.shuffle(seq)  # 将序列的所有元素随机排序

(2)、随机生成实数

下面生成的实数符合均匀分布(uniform distribution)，意味着某个范围内的每个数字出现的概率相等:

random.random()          # 随机生成下一个实数，它在[0,1)范围内。

random.uniform(a,b)      # 随机生成下一个实数，它在[a,b]范围内。

下面生成的实数符合其它的分布 (你可以参考一些统计方面的书籍来了解这些分布):

random.gauss(mu,sigma)    # 随机生成符合高斯分布的随机数，mu,sigma为高斯分布的两个参数。

random.expovariate(lambd) # 随机生成符合指数分布的随机数，lambd为指数分布的参数。

此外还有对数分布，正态分布，Pareto分布，Weibull分布，可参考下面链接:

http://docs.python.org/library/random.html

假设我们有一群人参加舞蹈比赛，为了公平起见，我们要随机排列他们的出场顺序。我们下面利用random包实现：

import random

all_people = ['Tom', 'Vivian', 'Paul', 'Liya', 'Manu', 'Daniel', 'Shawn']

random.shuffle(all_people)

for i,name in enumerate(all_people):

    print(i,':'+name)

三、循环器 (itertools)

在循环对象和函数对象中，我们了解了循环器(iterator)的功能。循环器是对象的容器，包含有多个对象。通过调用循环器的next()方法 (__next__()方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。

itertools的工具都可以自行实现。itertools只是提供了更加成形的解决方案。

在for i in iterator结构中，循环器每次返回的对象将赋予给i，直到循环结束。使用iter()内置函数，我们可以将诸如表、字典等容器变为循环器。比如：

for i in iter([2, 4, 5, 6]):

    print(i)

标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。

# import the tools

from itertools import *

1、无穷循环器

count(5, 2)     #从5开始的整数循环器，每次增加2，即5, 7, 9, 11, 13, 15 ...

cycle('abc')    #重复序列的元素，既a, b, c, a, b, c ...

repeat(1.2)     #重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...

repeat也可以有一个次数限制:

repeat(10, 5)   #重复10，共重复5次

2、函数式工具

函数式编程是将函数本身作为处理对象的编程范式。在Python中，函数也是对象，因此可以轻松的进行一些函数式的处理，比如map(), filter(), reduce()函数。

itertools包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。

比如：

from itertools import *

rlt = imap(pow, [1, 2, 3], [1, 2, 3])

for num in rlt:

    print(num)

上面显示了imap函数。该函数与map()函数功能相似，只不过返回的不是序列，而是一个循环器。包含元素1, 4, 27，即1**1, 2**2, 3**3的结果。函数pow(内置的乘方函数)作为第一个参数。pow()依次作用于后面两个列表的每个元素，并收集函数结果，组成返回的循环器。

此外，还可以用下面的函数:

starmap(pow, [(1, 1), (2, 2), (3, 3)])     #pow将依次作用于表的每个tuple。

ifilter函数与filter()函数类似，只是返回的是一个循环器。

ifilter(lambda x: x > 5, [2, 3, 5, 6, 7]) #将lambda函数依次作用于每个元素，如果函数返回True，则收集原来的元素。6, 7。

此外：

ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7])     #与上面类似，但收集返回False的元素。2, 3, 5

takewhile(lambda x: x < 5, [1, 3, 6, 7, 1])     #当函数返回True时，收集元素到循环器。一旦函数返回False，则停止。1, 3

dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])     #当函数返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器。6, 7, 1

3、组合工具

我们可以通过组合原有循环器，来获得新的循环器。

chain([1, 2, 3], [4, 5, 7])      # 连接两个循环器成为一个。1, 2, 3, 4, 5, 7

product('abc', [1, 2])   # 多个循环器集合的笛卡尔积。相当于嵌套循环

for m, n in product('abc', [1, 2]):

    print m, n

permutations('abc', 2)   # 从'abc'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。

注意，上面的组合分顺序，即ab, ba都返回。

combinations('abc', 2)   # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。

注意，上面的组合不分顺序，即ab, ba的话，只返回一个ab。

combinations_with_replacement('abc', 2) # 与上面类似，但允许两次选出的元素重复。即多了aa, bb, cc

4、groupby()

将key函数作用于原循环器的各个元素。根据key函数结果，将拥有相同函数结果的元素分到一个新的循环器。每个新的循环器以函数返回结果为标签。

这就好像一群人的身高作为循环器。我们可以使用这样一个key函数: 如果身高大于180，返回"tall"；如果身高底于160，返回"short";中间的返回"middle"。最终，所有身高将分为三个循环器，即"tall", "short", "middle"。

def height_class(h):

    if h > 180:

        return "tall"

    elif h < 160:

        return "short"

    else:

        return "middle"

friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]

friends = sorted(friends, key = height_class)

for m, n in groupby(friends, key = height_class):

    print(m)

    print(list(n))

注意，groupby的功能类似于UNIX中的uniq命令。分组之前需要使用sorted()对原循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。

5、其它工具

compress('ABCD', [1, 1, 1, 0])  # 根据[1, 1, 1, 0]的真假值情况，选择第一个参数'ABCD'中的元素。A, B, C

islice()                        # 类似于slice()函数，只是返回的是一个循环器

izip()                          # 类似于zip()函数，只是返回的是一个循环器。

四、数据库 (sqlite3)

Python自带一个轻量级的关系型数据库SQLite。这一数据库使用SQL语言。SQLite作为后端数据库，可以搭配Python建网站，或者制作有数据存储需求的工具。SQLite还在其它领域有广泛的应用，比如HTML5和移动端。Python标准库中的sqlite3提供该数据库的接口。

我将创建一个简单的关系型数据库，为一个书店存储书的分类和价格。数据库中包含两个表：category用于记录分类，book用于记录某个书的信息。一本书归属于某一个分类，因此book有一个外键(foreign key)，指向catogory表的主键id。

sqlite3只是一个SQLite的接口。想要熟练的使用SQLite数据库，还需要学习更多的关系型数据库的知识。

1、创建数据库

我首先来创建数据库，以及数据库中的表。在使用connect()连接数据库后，我就可以通过定位指针cursor，来执行SQL命令：

import sqlite3

# test.db is a file in the working directory.

conn = sqlite3.connect("test.db")

c = conn.cursor()

# create tables

c.execute('''CREATE TABLE category

      (id int primary key, sort int, name text)''')

c.execute('''CREATE TABLE book

      (id int primary key,

       sort int,

       name text,

       price real,

       category int,

       FOREIGN KEY (category) REFERENCES category(id))''')

# save the changes

conn.commit()

# close the connection with the database

conn.close()

SQLite的数据库是一个磁盘上的文件，如上面的test.db，因此整个数据库可以方便的移动或复制。test.db一开始不存在，所以SQLite将自动创建一个新文件。

利用execute()命令，我执行了两个SQL命令，创建数据库中的两个表。创建完成后，保存并断开数据库连接。

2、插入数据

上面创建了数据库和表，确立了数据库的抽象结构。下面将在同一数据库中插入数据：

import sqlite3

conn = sqlite3.connect("test.db")

c    = conn.cursor()

books = [(1, 1, 'Cook Recipe', 3.12, 1),

            (2, 3, 'Python Intro', 17.5, 2),

            (3, 2, 'OS Intro', 13.6, 2),

# execute "INSERT"

c.execute("INSERT INTO category VALUES (1, 1, 'kitchen')")

# using the placeholder

c.execute("INSERT INTO category VALUES (?, ?, ?)", [(2, 2, 'computer')])

# execute multiple commands

c.executemany('INSERT INTO book VALUES (?, ?, ?, ?, ?)', books)

conn.commit()

conn.close()

插入数据同样可以使用execute()来执行完整的SQL语句。SQL语句中的参数，使用"?"作为替代符号，并在后面的参数中给出具体值。这里不能用Python的格式化字符串，如"%s"，因为这一用法容易受到SQL注入攻击。

我也可以用executemany()的方法来执行多次插入，增加多个记录。每个记录是表中的一个元素，如上面的books表中的元素。

3、查询

在执行查询语句后，Python将返回一个循环器，包含有查询获得的多个记录。你循环读取，也可以使用sqlite3提供的fetchone()和fetchall()方法读取记录：

import sqlite3

conn = sqlite3.connect('test.db')

c = conn.cursor()

# retrieve one record

c.execute('SELECT name FROM category ORDER BY sort')

print(c.fetchone())

print(c.fetchone())

# retrieve all records as a list

c.execute('SELECT * FROM book WHERE book.category=1')

print(c.fetchall())

# iterate through the records

for row in c.execute('SELECT name, price FROM book ORDER BY sort'):

    print(row)

4、更新与删除

你可以更新某个记录，或者删除记录：

conn = sqlite3.connect("test.db")

c = conn.cursor()

c.execute('UPDATE book SET price=? WHERE id=?',(1000, 1))

c.execute('DELETE FROM book WHERE id=2')

conn.commit()

conn.close()

你也可以直接删除整张表：

c.execute('DROP TABLE book')

如果删除test.db，那么整个数据库会被删除。

作业

1、有下面一个文件download.txt：

www.shiyanlou.com

www.163.com

www.baidu.com

www.36kr.com

www.cnblogs.com

www.douban.com

使用包含3个进程的进程池下载文件中网站的首页。(你可以使用subprocess调用wget或者curl等下载工具执行具体的下载任务)

2、设计下面两种彩票号码生成器:

从1到22中随机抽取5个整数（这5个数字不重复）
随机产生一个8位数字，每位数字都可以是1到6中的任意一个整数。

Python网络

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

一、原始Python服务器

有人表示，只学Python没有用，必须学会一个框架(比如Django和web.py)才能找到工作。而我的想法是，掌握一个类似于框架的高级工具是有用的，但是基础的东西可以让你永远不被淘汰。不要被工具限制了自己的发展。今天，我在这里想要展示的，就是不使用框架，甚至不使用Python标准库中的高级包，只使用标准库中的socket接口，写一个Python服务器。

在当今Python服务器框架 (framework, 比如Django, Twisted, web.py等等) 横行的时代，从底层的socket开始写服务器似乎是一个出力不讨好的笨方法。框架的意义在于掩盖底层的细节，提供一套对于开发人员更加友好的API，并处理诸如MVC的布局问题。框架允许我们快速的构建一个成型而且成熟的Python服务器。然而，框架本身也是依赖于底层(比如socket)。对于底层socket的了解，不仅可以帮助我们更好的使用框架，更可以让我们明白框架是如何设计的。更进一步，如果拥有良好的底层socket编程知识和其他系统编程知识，你完全可以设计并开发一款自己的框架。如果你可以从底层socket开始，实现一个完整的Python服务器，支持用户层的协议，并处理好诸如MVC(Model-View-Control)、多线程(threading)等问题，并整理出一套清晰的函数或者类，作为接口(API)呈现给用户，你就相当于设计了一个框架。

socket接口是实际上是操作系统提供的系统调用。socket的使用并不局限于Python语言，你可以用C或者JAVA来写出同样的socket服务器，而所有语言使用socket的方式都类似(Apache就是使用C实现的服务器)。而你不能跨语言的使用框架。框架的好处在于帮你处理了一些细节，从而实现快速开发，但同时受到Python本身性能的限制。我们已经看到，许多成功的网站都是利用动态语言(比如Python, Ruby或者PHP，比如twitter和facebook)快速开发，在网站成功之后，将代码转换成诸如C和JAVA这样一些效率比较高的语言，从而让服务器能更有效率的面对每天亿万次的请求。在这样一些时间，底层的重要性，就远远超过了框架。

下面的一篇文章虽然是在谈JAVA，但我觉得也适用于Python的框架之争：http://yakovfain.com/2012/10/11/the-degradation-of-java-developers/

1、TCP/IP和socket

我们需要对网络传输，特别是TCP/IP协议和socket有一定的了解。socket是进程间通信的一种方法，它是基于网络传输协议的上层接口。socket有许多种类型，比如基于TCP协议或者UDP协议(两种网络传输协议)。其中又以TCP socket最为常用。TCP socket与双向管道(duplex PIPE)有些类似，一个进程向socket的一端写入或读取文本流，而另一个进程可以从socket的另一端读取或写入，比较特别是，这两个建立socket通信的进程可以分别属于两台不同的计算机。所谓的TCP协议，就是规定了一些通信的守则，以便在网络环境下能够有效实现上述进程间通信过程。双向管道(duplex PIPE)存活于同一台电脑中，所以不必区分两个进程的所在计算机的地址，而socket必须包含有地址信息，以便实现网络通信。一个socket包含四个地址信息: 两台计算机的IP地址和两个进程所使用的端口(port)。IP地址用于定位计算机，而port用于定位进程 (一台计算机上可以有多个进程分别使用不同的端口)。

一个TCP socket连接的网络：

2、TCP socket

在互联网上，我们可以让某台计算机作为服务器。服务器开放自己的端口，被动等待其他计算机连接。当其他计算机作为客户，主动使用socket连接到服务器的时候，服务器就开始为客户提供服务。

在Python中，我们使用标准库中的socket包来进行底层的socket编程。

首先是服务器端，我们使用bind()方法来赋予socket以固定的地址和端口，并使用listen()方法来被动的监听该端口。当有客户尝试用connect()方法连接的时候，服务器使用accept()接受连接，从而建立一个连接的socket：

# Written by Vamei

# Server side

import socket

# Address

HOST = ''

PORT = 8000

reply = 'Yes'

# Configure socket

s      = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((HOST, PORT))

# passively wait, 3: maximum number of connections in the queue

s.listen(3)

# accept and establish connection

conn, addr = s.accept()

# receive message

request    = conn.recv(1024)

print 'request is: ',request

print 'Connected by', addr

# send message

conn.sendall(reply)

# close connection

conn.close()

socket.socket()创建一个socket对象，并说明socket使用的是IPv4(AF_INET，IP version 4)和TCP协议(SOCK_STREAM)。

然后用另一台电脑作为客户，我们主动使用connect()方法来搜索服务器端的IP地址(在Linux中，你可以用$ifconfig来查询自己的IP地址)和端口，以便客户可以找到服务器，并建立连接:

# Written by Vamei

# Client side

import socket

# Address

HOST = '172.20.202.155'

PORT = 8000

request = 'can you hear me?'

# configure socket

s       = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST, PORT))

# send message

s.sendall(request)

# receive message

reply   = s.recv(1024)

print 'reply is: ',reply

# close connection

s.close()

在上面的例子中，我们对socket的两端都可以调用recv()方法来接收信息，调用sendall()方法来发送信息。这样，我们就可以在分处于两台计算机的两个进程间进行通信了。当通信结束的时候，我们使用close()方法来关闭socket连接。

(如果没有两台计算机做实验，也可以将客户端IP想要connect的IP改为"127.0.0.1"，这是个特殊的IP地址，用来连接当地主机。)

3、基于TCP socket的HTTP服务器

上面的例子中，我们已经可以使用TCP socket来为两台远程计算机建立连接。然而，socket传输*度太高，从而带来很多安全和兼容的问题。我们往往利用一些应用层的协议(比如HTTP协议)来规定socket 使用规则，以及所传输信息的格式。

HTTP协议利用请求-回应(request-response)的方式来使用TCP socket。客户端向服务器发一段文本作为request，服务器端在接收到request之后，向客户端发送一段文本作为response。在完成了这样一次request-response交易之后，TCP socket被废弃。下次的request将建立新的socket。request和response本质上说是两个文本，只是HTTP协议对这两个文本都有一定的格式要求。

request-response cycle：

现在，我们写出一个HTTP服务器端：

import socket

# Address

HOST = ''

PORT = 8000

# Prepare HTTP response

text_content = '''HTTP/1.x 200 OK

Content-Type: text/html

<head>

<title>WOW</title>

</head>

<html>

<p>Wow, Python Server</p>

<IMG src="test.jpg"/>

</html>

'''

# Read picture, put into HTTP format

f = open('test.jpg','rb')

pic_content = '''

HTTP/1.x 200 OK

Content-Type: image/jpg

'''

pic_content = pic_content + f.read()

f.close()

# Configure socket

s    = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((HOST, PORT))

# infinite loop, server forever

while True:

    # 3: maximum number of requests waiting

    s.listen(3)

    conn, addr = s.accept()

    request    = conn.recv(1024)

    method    = request.split(' ')[0]

    src            = request.split(' ')[1]

    # deal with GET method

    if method == 'GET':

        # ULR

        if src == '/test.jpg':

            content = pic_content

        else: content = text_content

        print 'Connected by', addr

        print 'Request is:', request

        conn.sendall(content)

    # close connection

    conn.close()

4、深入HTTP服务器程序

如我们上面所看到的，服务器会根据request向客户传输的两条信息text_content和pic_content中的一条，作为response文本。整个response分为起始行(start line), 头信息(head)和主体(body)三部分。起始行就是第一行:

HTTP/1.x 200 OK

它实际上又由空格分为三个片段，HTTP/1.x表示所使用的HTTP版本，200表示状态(status code)，200是HTTP协议规定的，表示服务器正常接收并处理请求，OK是供人来阅读的status code。

头信息跟随起始行，它和主体之间有一个空行。这里的text_content或者pic_content都只有一行的头信息，text_content用来表示主体信息的类型为html文本：

Content-Type: text/html

而pic_content的头信息(Content-Type: image/jpg)说明主体的类型为jpg图片(image/jpg)。

主体信息为html或者jpg文件的内容。

(注意，对于jpg文件，我们使用'rb'模式打开，是为了与windows兼容。因为在windows下，jpg被认为是二进制(binary)文件，在UNIX系统下，则不需要区分文本文件和二进制文件。)

我们并没有写客户端程序，后面我们会用浏览器作为客户端。request由客户端程序发给服务器。尽管request也可以像response那样分为三部分，request的格式与response的格式并不相同。request由客户发送给服务器，比如下面是一个request：

GET /test.jpg HTTP/1.x

Accept: text/*

起始行可以分为三部分，第一部分为请求方法(request method)，第二部分是URL，第三部分为HTTP版本。request method可以有GET， PUT， POST， DELETE， HEAD。最常用的为GET和POST。GET是请求服务器发送资源给客户，POST是请求服务器接收客户送来的数据。当我们打开一个网页时，我们通常是使用GET方法；当我们填写表格并提交时，我们通常使用POST方法。第二部分为URL，它通常指向一个资源(服务器上的资源或者其它地方的资源)。像现在这样，就是指向当前服务器的当前目录的test.jpg。

按照HTTP协议的规定，服务器需要根据请求执行一定的操作。正如我们在服务器程序中看到的，我们的Python程序先检查了request的方法，随后根据URL的不同，来生成不同的response(text_content或者pic_content)。随后，这个response被发送回给客户端。

5、使用浏览器实验

为了配合上面的服务器程序，我已经在放置Python程序的文件夹里，保存了一个test.jpg图片文件。我们在终端运行上面的Python程序，作为服务器端，再打开一个浏览器作为客户端。(如果有时间，你也完全可以用Python写一个客户端。原理与上面的TCP socket的客户端程序相类似。)

在浏览器的地址栏输入：127.0.0.1:8000

(当然，你也可以用另一台电脑，并输入服务器的IP地址。) 我得到下面的结果:

OK，我已经有了一个用Python实现的，并从socket写起的服务器了。

从终端，我们可以看到，浏览器实际上发出了两个请求。第一个请求为 (关键信息在起始行，这一个请求的主体为空):

GET / HTTP/1.1

Host: 127.0.0.1:8000

User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:14.0) Gecko/20100101 Firefox/14.0.1

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

Accept-Language: en-us,en;q=0.5

Accept-Encoding: gzip, deflate

Connection: keep-alive

我们的Python程序根据这个请求，发送给服务器text_content的内容。

浏览器接收到text_content之后，发现正文的html文本中有，知道需要获得text.jpg文件来补充为图片，立即发出了第二个请求:

GET /test.jpg HTTP/1.1

Host: 127.0.0.1:8000

User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:14.0) Gecko/20100101 Firefox/14.0.1

Accept: image/png,image/*;q=0.8,*/*;q=0.5

Accept-Language: en-us,en;q=0.5

Accept-Encoding: gzip, deflate

Connection: keep-alive

Referer: http://127.0.0.1:8000/

我们的Python程序分析过起始行之后，发现/test.jpg符合if条件，所以将pic_content发送给客户。

最后，浏览器根据html语言的语法，将html文本和图画以适当的方式显示出来。(html可参考http://www.w3schools.com/html/default.asp)

6、探索的方向

1) 在我们上面的服务器程序中，我们用while循环来让服务器一直工作下去。实际上，我们还可以根据我之前介绍的多线程的知识，将while循环中的内容改为多进程或者多线程工作。
2) 我们的服务器程序还不完善，我们还可以让我们的Python程序调用Python的其他功能，以实现更复杂的功能。比如说制作一个时间服务器，让服务器向客户返回日期和时间。你还可以使用Python自带的数据库，来实现一个完整的LAMP服务器。
3) socket包是比较底层的包。Python标准库中还有高层的包，比如SocketServer，SimpleHTTPServer，CGIHTTPServer，cgi。这些都包都是在帮助我们更容易的使用socket。如果你已经了解了socket，那么这些包就很容易明白了。利用这些高层的包，你可以写一个相当成熟的服务器。
4) 在经历了所有的辛苦和麻烦之后，你可能发现，框架是那么的方便，所以决定去使用框架。或者，你已经有了参与到框架开发的热情。

二、Python服务器进化

注意，在Python 3.x中，BaseHTTPServer, SimpleHTTPServer, CGIHTTPServer整合到http.server包，SocketServer改名为socketserver，请注意查阅官方文档。

刚才，我们使用socket接口，制作了一个处理HTTP请求的Python服务器。任何一台装有操作系统和Python解释器的计算机，都可以作为HTTP服务器使用。我将在这里不断改写上一篇文章中的程序，引入更高级的Python包，以写出更成熟的Python服务器。

1、支持POST

我首先增加该服务器的功能。这里增添了表格，以及处理表格提交数据的"POST"方法。你会发现这里只是比刚才用socket写的Python服务器增加很少的一点内容。

原始程序:

# A messy HTTP server based on TCP socket

import socket

# Address

HOST = ''

PORT = 8000

text_content = '''

HTTP/1.x 200 OK

Content-Type: text/html

<head>

<title>WOW</title>

</head>

<html>

<p>Wow, Python Server</p>

<IMG src="test.jpg"/>

<form name="input" action="/" method="post">

First name:<input type="text" name="firstname"><br>

<input type="submit" value="Submit">

</form>

</html>

'''

f = open('test.jpg','rb')

pic_content = '''

HTTP/1.x 200 OK

Content-Type: image/jpg

'''

pic_content = pic_content + f.read()

# Configure socket

s    = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind((HOST, PORT))

# Serve forever

while True:

    s.listen(3)

    conn, addr = s.accept()

    request    = conn.recv(1024)         # 1024 is the receiving buffer size

    method     = request.split(' ')[0]

    src        = request.split(' ')[1]

    print 'Connected by', addr

    print 'Request is:', request

    # if GET method request

    if method == 'GET':

        # if ULR is /test.jpg

        if src == '/test.jpg':

            content = pic_content

        else: content = text_content

        # send message

        conn.sendall(content)

    # if POST method request

    if method == 'POST':

        form = request.split('\r\n')

        idx = form.index('')             # Find the empty line

        entry = form[idx:]               # Main content of the request

        value = entry[-1].split('=')[-1]

        conn.sendall(text_content + '\n <p>' + value + '</p>')

        ######

        # More operations, such as put the form into database

        # ...

        ######

    # close connection

    conn.close()

服务器进行的操作很简单，即从POST请求中提取数据，再显示在屏幕上。

运行上面Python服务器，使用一个浏览器打开：

页面新增了表格和提交(submit)按钮。在表格中输入aa并提交，页面显示出aa。

下一步要用一些高级包，来简化之前的代码。

2、使用SocketServer

首先使用SocketServer包来方便的架设服务器。在上面使用socket的过程中，我们先设置了socket的类型，然后依次调用bind(),listen(),accept()，最后使用while循环来让服务器不断的接受请求。上面的这些步骤可以通过SocketServer包来简化。

SocketServer：

# Written by Vamei

# use TCPServer

import SocketServer

HOST = ''

PORT = 8000

text_content = '''

HTTP/1.x 200 OK

Content-Type: text/html

<head>

<title>WOW</title>

</head>

<html>

<p>Wow, Python Server</p>

<IMG src="test.jpg"/>

<form name="input" action="/" method="post">

First name:<input type="text" name="firstname"><br>

<input type="submit" value="Submit">

</form>

</html>

'''

f = open('test.jpg','rb')

pic_content = '''

HTTP/1.x 200 OK

Content-Type: image/jpg

'''

pic_content = pic_content + f.read()

# This class defines response to each request

class MyTCPHandler(SocketServer.BaseRequestHandler):

    def handle(self):

        # self.request is the TCP socket connected to the client

        request = self.request.recv(1024)

        print 'Connected by',self.client_address[0]

        print 'Request is', request

        method     = request.split(' ')[0]

        src        = request.split(' ')[1]

        if method == 'GET':

            if src == '/test.jpg':

                content = pic_content

            else: content = text_content

            self.request.sendall(content)

        if method == 'POST':

            form = request.split('\r\n')

            idx = form.index('')             # Find the empty line

            entry = form[idx:]               # Main content of the request

            value = entry[-1].split('=')[-1]

            self.request.sendall(text_content + '\n <p>' + value + '</p>')

            ######

            # More operations, such as put the form into database

            # ...

            ######

# Create the server

server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

# Start the server, and work forever

server.serve_forever()

我建立了一个TCPServer对象，即一个使用TCP socket的服务器。在建立TCPServe的同时，设置该服务器的IP地址和端口。使用server_forever()方法来让服务器不断工作(就像原始程序中的while循环一样)。

我们传递给TCPServer一个MyTCPHandler类。这个类定义了如何操作socket。MyTCPHandler继承自BaseRequestHandler。改写handler()方法，来具体规定不同情况下服务器的操作。

在handler()中，通过self.request来查询通过socket进入服务器的请求 (正如我们在handler()中对socket进行recv()和sendall()操作)，还使用self.address来引用socket的客户端地址。

经过SocketServer的改造之后，代码还是不够简单。我们上面的通信基于TCP协议，而不是HTTP协议。因此，我们必须手动的解析HTTP协议。我们将建立基于HTTP协议的服务器。

3、SimpleHTTPServer: 使用静态文件来回应请求

HTTP协议基于TCP协议，但增加了更多的规范。这些规范，虽然限制了TCP协议的功能，但大大提高了信息封装和提取的方便程度。

对于一个HTTP请求(request)来说，它包含有两个重要信息：请求方法和URL。

请求方法(request method)	URL	操作
GET	/	发送text_content
GET	/text.jpg	发送pic_content
POST	/	分析request主体中包含的value(实际上是我们填入表格的内容); 发送text_content和value

根据请求方法和URL的不同，一个大型的HTTP服务器可以应付成千上万种不同的请求。在Python中，我们可以使用SimpleHTTPServer包和CGIHTTPServer包来规定针对不同请求的操作。其中，SimpleHTTPServer可以用于处理GET方法和HEAD方法的请求。它读取request中的URL地址，找到对应的静态文件，分析文件类型，用HTTP协议将文件发送给客户。

SimpleHTTPServer：

我们将text_content放置在index.html中，并单独存储text.jpg文件。如果URL指向index_html的母文件夹时，SimpleHTTPServer会读取该文件夹下的index.html文件。

我在当前目录下生成index.html文件:

<head>

<title>WOW</title>

</head>

<html>

<p>Wow, Python Server</p>

<IMG src="test.jpg"/>

<form name="input" action="/" method="post">

First name:<input type="text" name="firstname"><br>

<input type="submit" value="Submit">

</form>

</html>

改写Python服务器程序。使用SimpleHTTPServer包中唯一的类SimpleHTTPRequestHandler:

# Written by Vamei

# Simple HTTPsERVER

import SocketServer

import SimpleHTTPServer

HOST = ''

PORT = 8000

# Create the server, SimpleHTTPRequestHander is pre-defined handler in SimpleHTTPServer package

server = SocketServer.TCPServer((HOST, PORT), SimpleHTTPServer.SimpleHTTPRequestHandler)

# Start the server

server.serve_forever()

这里的程序不能处理POST请求。我会在后面使用CGI来弥补这个缺陷。值得注意的是，Python服务器程序变得非常简单。将内容存放于静态文件，并根据URL为客户端提供内容，这让内容和服务器逻辑分离。每次更新内容时，我可以只修改静态文件，而不用停止整个Python服务器。

这些改进也付出代价。在原始程序中，request中的URL只具有指导意义，我可以规定任意的操作。在SimpleHTTPServer中，操作与URL的指向密切相关。我用*度，换来了更加简洁的程序。

4、CGIHTTPServer：使用静态文件或者CGI来回应请求

CGIHTTPServer包中的CGIHTTPRequestHandler类继承自SimpleHTTPRequestHandler类，所以可以用来代替上面的例子，来提供静态文件的服务。此外，CGIHTTPRequestHandler类还可以用来运行CGI脚本。

CGIHTTPServer：

先看看什么是CGI (Common Gateway Interface)。CGI是服务器和应用脚本之间的一套接口标准。它的功能是让服务器程序运行脚本程序，将程序的输出作为response发送给客户。总体的效果，是允许服务器动态的生成回复内容，而不必局限于静态文件。

支持CGI的服务器程接收到客户的请求，根据请求中的URL，运行对应的脚本文件。服务器会将HTTP请求的信息和socket信息传递给脚本文件，并等待脚本的输出。脚本的输出封装成合法的HTTP回复，发送给客户。CGI可以充分发挥服务器的可编程性，让服务器变得“更聪明”。

服务器和CGI脚本之间的通信要符合CGI标准。CGI的实现方式有很多，比如说使用Apache服务器与Perl写的CGI脚本，或者Python服务器与shell写的CGI脚本。

为了使用CGI，我们需要使用BaseHTTPServer包中的HTTPServer类来构建服务器。Python服务器的改动很简单。

CGIHTTPServer:

# Written by Vamei

# A messy HTTP server based on TCP socket

import BaseHTTPServer

import CGIHTTPServer

HOST = ''

PORT = 8000

# Create the server, CGIHTTPRequestHandler is pre-defined handler

server = BaseHTTPServer.HTTPServer((HOST, PORT), CGIHTTPServer.CGIHTTPRequestHandler)

# Start the server

server.serve_forever()

CGIHTTPRequestHandler默认当前目录下的cgi-bin和ht-bin文件夹中的文件为CGI脚本，而存放于其他地方的文件被认为是静态文件。因此，我们需要修改一下index.html，将其中form元素指向的action改为cgi-bin/post.py。

<head>

<title>WOW</title>

</head>

<html>

<p>Wow, Python Server</p>

<IMG src="test.jpg"/>

<form name="input" action="cgi-bin/post.py" method="post">

First name:<input type="text" name="firstname"><br>

<input type="submit" value="Submit">

</form>

</html>

我创建一个cgi-bin的文件夹，并在cgi-bin中放入如下post.py文件，也就是我们的CGI脚本：

#!/usr/bin/env python

# Written by Vamei

import cgi

form = cgi.FieldStorage()

# Output to stdout, CGIHttpServer will take this as response to the client

print "Content-Type: text/html"     # HTML is following

print                               # blank line, end of headers

print "<p>Hello world!</p>"         # Start of content

print "<p>" +  repr(form['firstname']) + "</p>"

(post.py需要有执行权限，chmod +x cgi-bin/post.py)

第一行说明了脚本所使用的语言，即Python。 cgi包用于提取请求中包含的表格信息。脚本只负责将所有的结果输出到标准输出(使用print)。CGIHTTPRequestHandler会收集这些输出，封装成HTTP回复，传送给客户端。

对于POST方法的请求，它的URL需要指向一个CGI脚本(也就是在cgi-bin或者ht-bin中的文件)。CGIHTTPRequestHandler继承自SimpleHTTPRequestHandler，所以也可以处理GET方法和HEAD方法的请求。此时，如果URL指向CGI脚本时，服务器将脚本的运行结果传送到客户端；当此时URL指向静态文件时，服务器将文件的内容传送到客户端。

更进一步，我可以让CGI脚本执行数据库操作，比如将接收到的数据放入到数据库中，以及更丰富的程序操作。相关内容从略。

我使用了Python标准库中的一些高级包简化了Python服务器。最终的效果分离静态内容、CGI应用和服务器，降低三者之间的耦合，让代码变得简单而容易维护。

希望你享受在自己的电脑上架设服务器的过程。

作业

将本节内容里的两种Python服务器在实验楼环境中运行实现，并截图。

Django（上）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

Django是Python下的一款网络服务器框架。Python下有许多款不同的框架。Django是重量级选手中最有代表性的一位。许多成功的网站和APP都基于Django。虽然Django之于Python，达不到Rail之于Ruby的一统江湖的地位，但Django无疑也是Python在网络应用方面的一位主将。使用Django，可以方便的实现一个功能全面、管理简便的网站或App后端。这里从实用的角度出发，介绍如何使用Django框架。

一、安装Django

启动计算机中的Python，尝试载入Django模块。如果可以成功载入，那么说明Django已经安装好：

import django

print(django.VERSION)

但是实验楼环境里Django还没有安装，可以在命令行，尝试使用pip安装:

sudo pip install -i http://mirrors.aliyuncs.com/pypi/simple django

或者使用easy_install:

sudo easy_install django

二、启动

在命令行使用下面的命令创建项目：

django-admin.py startproject mysite

在当前目录下，将生成mysite文件夹。其文件树结构如下:

mysite

├── manage.py

└── mysite

    ├── __init__.py

    ├── settings.py

    ├── urls.py

    └── wsgi.py

1 directory, 5 files

进入mysite目录，启动服务器：

cd mysite

python manage.py runserver 8000

上面的8000为端口号。如果不说明，那么端口号默认为8000。

打开浏览器，访问http://127.0.0.1:8000，可以看到服务器已经在运行：

虽然有一个能跑的服务器，但什么内容都没有。

三、第一个网页

在http协议中可以看到，网络服务器是“请求-回应”的工作模式。客户向URL发送请求，服务器根据请求，开动后厨，并最终为客人上菜。Django采用的MVC结构，即点单、厨房、储藏室分离。

我们需要一个指挥员，将URL对应分配给某个对象处理，这需要在mysite/mysite下的urls.py设定。Python会根据该程序，将URL请求分给某个厨师。

mysite

├── manage.py

└── mysite

    ├── __init__.py

    ├── settings.py

    ├── urls.py

    └── wsgi.py

1 directory, 5 files

将urls.py修改为:

from django.conf.urls import patterns, include, url

from django.contrib import admin

admin.autodiscover()

urlpatterns = patterns('',

    # Examples:

    # url(r'^$', 'mysite.views.home', name='home'),

    # url(r'^blog/', include('blog.urls')),

    url(r'^admin/', include(admin.site.urls)),

    url(r'^$', 'mysite.views.first_page'),

我们添加了最后一行。它将根目录的URL分配给一个对象进行处理，这个对象是mysite.views.first_page。

用以处理HTTP请求的这一对象还不存在，我们在mysite/mysite下创建views.py，并在其中定义first_page函数:

# -*- coding: utf-8 -*-

from django.http import HttpResponse

def first_page(request):

    return HttpResponse("<p>世界好</p>")

第一行说明字符编码为utf-8，为下面使用中文做准备。first_page函数的功能，是返回http回复，即这里的

世界好

。first_page有一个参数request，该参数包含有请求的具体信息，比如请求的类型等，这里并没有用到。

页面效果如下：

四、增加APP

一个网站可能有多个功能。我们可以在Django下，以app为单位，模块化的管理，而不是将所有的东西都丢到一个文件夹中。在mysite目录下，运行manange.py，创建新的app：

$python manage.py startapp west

这个新的app叫做west，用来处理西餐。

我们的根目录下，出现了一个新的叫做west的文件夹。

mysite/

├── manage.py

├── mysite

│   ├── __init__.py

│   ├── __init__.pyc

│   ├── settings.py

│   ├── settings.pyc

│   ├── urls.py

│   ├── views.py

│   └── wsgi.py

└── west

    ├── admin.py

    ├── __init__.py

    ├── models.py

    ├── tests.py

    └── views.py

我们还需要修改项目设置，说明我们要使用west。在mysite/mysite/settings.py中，在INSTALLED_APPS中，增加"west"：

INSTALLED_APPS = (

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'west',

可以看到，除了新增加的west，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。

五、增加APP页面

我们下面为APP增加首页。我们之前是在mysite/urls.py中设置的URL访问对象。依然采用类似的方式设置。

另一方面，为了去耦合，实现模块化，我们应该在west/urls.py中设置URL访问对象。具体如下：

首先，修改mysite/urls.py：

from django.conf.urls import patterns, include, url

from django.contrib import admin

admin.autodiscover()

urlpatterns = patterns('',

    # Examples:

    # url(r'^$', 'mysite.views.home', name='home'),

    # url(r'^blog/', include('blog.urls')),

    url(r'^admin/', include(admin.site.urls)),

    url(r'^$', 'mysite.views.first_page'),

    url(r'^west/', include('west.urls')),

注意新增加的最后一行。这里，我们提醒指挥员，对于west/的访问，要参考west/urls.py。

随后，我们创建west/urls.py，添加内容：

from django.conf.urls import patterns, include, url

urlpatterns = patterns('',

    url(r'^$', 'west.views.first_page'),

将URL对应west下，views.py中的first_page函数。

最后，在west下，修改views.py为:

# -*- coding: utf-8 -*-

from django.http import HttpResponse

def first_page(request):

    return HttpResponse("<p>西餐</p>")

访问http://127.0.0.1:8000/west，查看效果。

可以看到，Django的创建过程非常简单。但这只是初次尝试Django。为了创建一个完整功能的网站，还需要调用Django许多其它的功能。

六、连接数据库

Django为多种数据库后台提供了统一的调用API。根据需求不同，Django可以选择不同的数据库后台。MySQL算是最常用的数据库。我们这里将Django和MySQL连接。

安装MYSQLdb：

sudo apt-get install python-mysqldb

在Linux终端下启动mysql:

sudo service mysql start

mysql -u root

在MySQL中创立Django项目的数据库：

mysql> CREATE DATABASE villa DEFAULT CHARSET=utf8;

这里使用utf8作为默认字符集，以便支持中文。

在MySQL中创立用户，并授予相关权限:

mysql> GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES ON villa.* TO 'vamei'@'localhost' IDENTIFIED BY 'shiyanlou';

在settings.py中，将DATABASES对象更改为:

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql',

        'NAME': 'villa',

        'USER': 'root',

        'HOST':'localhost',

        'PORT':'3306',

后台类型为mysql。上面包含数据库名称和用户的信息，它们与MySQL中对应数据库和用户的设置相同。Django根据这一设置，与MySQL中相应的数据库和用户连接起来。此后，Django就可以在数据库中读写了。

七、创立模型

MySQL是关系型数据库。但在Django的帮助下，我们不用直接编写SQL语句。Django将关系型的表(table)转换成为一个类(class)。而每个记录(record)是该类下的一个对象(object)。我们可以使用基于对象的方法，来操纵关系型的MySQL数据库。

在传统的MySQL中，数据模型是表。在Django下，一个表为一个类。表的每一列是该类的一个属性。在models.py中，我们创建一个只有一列的表，即只有一个属性的类：

from django.db import models

class Character(models.Model):

    name = models.CharField(max_length=200)

    def __unicode__(self):

        return self.name

类Character定义了数据模型，它需要继承自models.Model。在MySQL中，这个类实际上是一个表。表只有一列，为name。可以看到，name属性是字符类型，最大长度为200。

类Character有一个__unicode__()方法，用来说明对象的字符表达方式。如果是Python 3，定义__str__()方法，实现相同的功能。

命令Django同步数据库。Django根据west/models.py中描述的数据模型，在MySQL中真正的创建各个关系表：

python manage.py syncdb

python manage.py makemigrations west

python manage.py migrate

同步数据库后，Django将建立相关的MySQL表格，并要求你创建一个超级用户:

Creating tables ...

Creating table django_admin_log

Creating table auth_permission

Creating table auth_group_permissions

Creating table auth_group

Creating table auth_user_groups

Creating table auth_user_user_permissions

Creating table auth_user

Creating table django_content_type

Creating table django_session

Creating table west_character

You just installed Django's auth system, which means you don't have any superusers defined.

Would you like to create one now? (yes/no): yes

Username (leave blank to use 'tommy'): root

Email address: xxxxx@xmail.com

Password:

Password (again):

Superuser created successfully.

Installing custom SQL ...

Installing indexes ...

Installed 0 object(s) from 0 fixture(s)

数据模型建立了。打开MySQL命令行（提示输入密码：shiyanlou）：

$mysql -u root

查看数据模型：

USE villa;

SHOW TABLES;

SHOW COLUMNS FROM west_character;

最后一个命令返回Character类的对应表格:

+-------+--------------+------+-----+---------+----------------+

| Field | Type         | Null | Key | Default | Extra          |

+-------+--------------+------+-----+---------+----------------+

| id    | int(11)      | NO   | PRI | NULL    | auto_increment |

| name  | varchar(200) | NO   |     | NULL    |                |

+-------+--------------+------+-----+---------+----------------+

2 rows in set (0.00 sec)

可以看到，Django还自动增加了一个id列，作为记录的主键(Primary Key)。

八、显示数据

数据模型虽然建立了，但还没有数据输入。为了简便，我们手动添加记录。打开MySQL命令行,并切换到相应数据库。添加记录：

INSERT INTO west_character (name) Values ('Vamei');

INSERT INTO west_character (name) Values ('Django');

INSERT INTO west_character (name) Values ('John');

查看记录：

SELECT * FROM west_character;

可以看到，三个名字已经录入数据库。

下面我们从数据库中取出数据，并返回给http请求。在west/views.py中，添加视图。对于对应的请求，我们将从数据库中读取所有的记录，然后返回给客户端：

# -*- coding: utf-8 -*-

from django.http import HttpResponse

from west.models import Character

def staff(request):

    staff_list = Character.objects.all()

    staff_str  = map(str, staff_list)

    return HttpResponse("<p>" + ' '.join(staff_str) + "</p>")

可以看到，我们从west.models中引入了Character类。通过操作该类，我们可以读取表格中的记录。

为了让http请求能找到上面的程序，在west/urls.py增加url导航：

from django.conf.urls import patterns, include, url

urlpatterns = patterns('',

    url(r'^staff/','west.views.staff'),

运行服务器。在浏览器中输入URL：

127.0.0.1:8000/west/staff

查看效果，从数据库读出数据，显示在页面：

Django使用类和对象接口，来操纵底层的数据库。有了数据库，就有了站点内容的大本营。

作业

按照实验过程操作一遍并截图。

Django（中）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

在之前的程序中，我们直接生成一个字符串，作为http回复，返回给客户端。这一过程中使用了django.http.HttpResponse()。

在这样的一种回复生成过程中，我们实际上将数据和视图的格式混合了到上面的字符串中。看似方便，却为我们的管理带来困难。想像一个成熟的网站，其显示格式会有许多重复的地方。如果可以把数据和视图格式分离，就可以重复使用同一视图格式了。

Django中自带的模板系统，可以将视图格式分离出来，作为模板使用。这样，不但视图可以容易修改，程序也会显得美观大方。

一、模板初体验

我们拿一个独立的templay.html文件作为模板。它放在templates/west/文件夹下。文件系统的结构现在是:

mysite/

├── mysite

├── templates

│   └── west

└── west

templay.html文件的内容是：

<h1>{{ label }}</h1>

可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即

标签，则已经标明在该模板文件中。

我们需要向Django说明模板文件的搜索路径，修改mysite/settings.py，添加:

# Template dir

# This is for django 1.8

TEMPLATES = [

{

'BACKEND': 'django.template.backends.django.DjangoTemplates',

'DIRS': (os.path.join(BASE_DIR, 'templates/west'),),

'APP_DIRS': True,

'OPTIONS': {

'context_processors': [

'django.template.context_processors.debug',

'django.template.context_processors.i18n',

'django.template.context_processors.tz',

'django.template.context_processors.media',

'django.template.context_processors.static',

'django.contrib.auth.context_processors.auth',

'django.contrib.messages.context_processors.messages',

],

},

]

如果还有其它的路径用于存放模板，可以增加该元组中的元素，以便Django可以找到需要的模板。

我们现在修改west/views.py，增加一个新的对象，用于向模板提交数据：

# -*- coding: utf-8 -*-

#from django.http import HttpResponse

from django.shortcuts import render

def templay(request):

context = {}

context['label'] = 'Hello World!'

return render(request, 'templay.html', context)

可以看到，我们这里使用render来替代之前使用的HttpResponse。render还使用了一个词典context作为参数。这就是我们的数据。

context中元素的键值为'label'，正对应刚才的“陌生人”的名字。这样，该context中的‘label’元素值，就会填上模板里的坑，构成一个完整的http回复。

作为上节内容的一个小练习，自行修改west/urls.py，让http://127.0.0.1:8000/west/templay的URL请求可以找到相应的view对象。

访问http://127.0.0.1:8000/west/templay，可以看到页面：

二、流程

再来回顾一下整个流程。west/views.py中的templay()在返回时，将环境数据context传递给模板templay.html。Django根据context元素中的键值，将相应数据放入到模板中的对应位置，生成最终的http回复。

这一模板系统可以与Django的其它功能相互合作。上一回，我们从数据库中提取出了数据。如果将数据库中的数据放入到context中，那么就可以将数据库中的数据传送到模板。

修改上次的west/views.py中的staff:

def staff(request):

    staff_list  = Character.objects.all()

    staff_str  = map(str, staff_list)

    context   = {'label': ' '.join(staff_str)}

    return render(request, 'templay.html', context)

三、循环与选择

Django实际上提供了丰富的模板语言，可以在模板内部有限度的编程，从而更方便的编写视图和传送数据。

我们下面体验一下最常见的循环与选择。

上面的staff中的数据实际上是一个数据容器，有三个元素。刚才我们将三个元素连接成一个字符串传送。

实际上，利用模板语言，我们可以直接传送数据容器本身，再循环显示。修改staff()为:

def staff(request):

    staff_list = Character.objects.all()

    return render(request, 'templay.html', {'staffs': staff_list})

从数据库中查询到的三个对象都在staff_list中。我们直接将staff_list传送给模板。

将模板templay.html修改为：

{% for item in staffs %}

<p>{{ item.id }}, {{item}}</p>

{% endfor %}

我们以类似于Python中for循环的方式来定义模板中的for，以显示staffs中的每个元素。

还可以看到，对象.属性名的引用方式可以直接用于模板中。

选择结构也与Python类似。根据传送来的数据是否为True，Django选择是否显示。使用方式如下：

{% if condition1 %}

   ... display 1

{% elif condiiton2 %}

   ... display 2

{% else %}

   ... display 3

{% endif %}

其中的elif和else和Python中一样，是可以省略的。

四、模板继承

模板可以用继承的方式来实现复用。我们下面用templay.html来继承base.html。这样，我们可以使用base.html的主体，只替换掉特定的部分。

新建templates/west/base.html:

<html>

  <head>

    <title>templay</title>

  </head>

  <body>

    <h1>come from base.html</h1>

    {% block mainbody %}

       <p>original</p>

    {% endblock %}

  </body>

</html>

该页面中，名为mainbody的block标签是可以被继承者们替换掉的部分。

我们在下面的templay.html中继承base.html，并替换特定block：

{% extends "base.html" %}

{% block mainbody %}

{% for item in staffs %}

<p>{{ item.id }},{{ item.name }}</p>

{% endfor %}

{% endblock %}

第一句说明templay.html继承自base.html。可以看到，这里相同名字的block标签用以替换base.html的相应block。

五、html表格

HTTP协议以“请求－回复”的方式工作。客户发送请求时，可以在请求中附加数据。服务器通过解析请求，就可以获得客户传来的数据，并根据URL来提供特定的服务。

HTML文件中可以包含表格标签。HTML表格的目的是帮助用户构成HTTP请求，把数据用GET或者POST的方法，传递给某一URL地址。下面是一个表格的例子：

<form action="/west/investigate/" method="get">

  <input type="text" name="staff">

  <input type="submit" value="Submit">

</form>

这里的form标签有两个属性。action用于说明URL地址，method说明请求的方法。

表格中还包含有两个input标签，即两个输入栏目。根据type的不同，第一个为一个文本框，第二个为一个提交按钮。name为输入栏的名字。服务器在解析数据时，将以name为索引。

我们可以将上面的表格直接存入模板form.html，并在west/views.py中定义一个视图form()来显示表格:

from django.shortcuts import render

def form(request):

    return render(request, 'form.html')

设置urls.py，让对[site]/west/form/的访问，指向该视图。

最后，我们在west/views.py中定义investigate()来处理该表格提交的数据:

from django.shortcuts import render

def investigate(request):

    rlt = request.GET['staff']

    return HttpResponse(rlt)

可以看到，HTTP请求的相关信息，包括请求的方法，提交的数据，都包含在request参数中。

表格是通过GET方法提交的。我们可以通过request.GET['staff']，来获得name为staff的输入栏的数据。该数据是一个字符串。investigate()将直接显示该字符串。

设置urls.py，让该处理函数对应action的URL([site]/west/investigate/)。

当我们访问http://127.0.0.1:8000/west/form时，将显示:

提交表格后，页面将转到[site]/west/investigate。investigate()读取字符串后，在页面上显示出来。

六、POST方法

上面我们使用了GET方法。视图显示和请求处理分成两个函数处理。

提交数据时更常用POST方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。

先创建模板investigate.html

<form action="/west/investigate/" method="post">

  {% csrf_token %}

  <input type="text" name="staff">

  <input type="submit" value="Submit">

</form>

<p>{{ rlt }}</p>

我们修改提交表格的方法为post。在模板的末尾，我们增加一个rlt记号，为表格处理结果预留位置。

表格后面还有一个{% csrf_token %}的标签。csrf全称是Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。POST方法提交的表格，必须有此标签。

在west/views.py中，用investigate()来处理表格：

from django.shortcuts import render

from django.core.context_processors import csrf

def investigate(request):

    ctx ={}

    ctx.update(csrf(request))

    if request.POST:

        ctx['rlt'] = request.POST['staff']

    return render(request, "investigate.html", ctx)

这里的csrf()是和上面的{% csrf_token %}对应。我们在这里不深究。

看程序的其它部分。对于该URL，可能有GET或者POST方法。if的语句有POST方法时，额外的处理，即提取表格中的数据到环境变量。

最终效果如下：

七、存储数据

我们还可以让客户提交的数据存入数据库。使用庄园疑云中创建的模型。我们将客户提交的字符串存入模型Character。

修改west/views.py的investigate():

from django.shortcuts import render

from django.core.context_processors import csrf

from west.models import Character

def investigate(request):

    if request.POST:

        submitted  = request.POST['staff']

        new_record = Character(name = submitted)

        new_record.save()

    ctx ={}

    ctx.update(csrf(request))

    all_records = Character.objects.all()

    ctx['staff'] = all_records

    return render(request, "investigate.html", ctx)

在POST的处理部分，我们调用Character类创建新的对象，并让该对象的属性name等于用户提交的字符串。通过save()方法，我们让该记录入库。

随后，我们从数据库中读出所有的对象，并传递给模板。

我们还需要修改模板investigate.html，以更好的显示：

<form action="/west/investigate/" method="post">

  {% csrf_token %}

  <input type="text" name="staff">

  <input type="submit" value="Submit">

</form>

{% for person in staff %}

<p>{{ person }}</p>

{% endfor %}

我们使用模板语言的for，来显示所有的记录。

效果如下:

八、表格对象

客户提交数据后，服务器往往需要对数据做一些处理。比如检验数据，看是否符合预期的长度和数据类型。在必要的时候，还需要对数据进行转换，比如从字符串转换成整数。这些过程通常都相当的繁琐。

Django提供的数据对象可以大大简化这一过程。该对象用于说明表格所预期的数据类型和其它的一些要求。这样Django在获得数据后，可以自动根据该表格对象的要求，对数据进行处理。

修改west/views.py：

from django.shortcuts import render

from django.core.context_processors import csrf

from west.models import Character

from django import forms

class CharacterForm(forms.Form):

    name = forms.CharField(max_length = 200)

def investigate(request):

    if request.POST:

        form = CharacterForm(request.POST)

        if form.is_valid():

            submitted  = form.cleaned_data['name']

            new_record = Character(name = submitted)

            new_record.save()

    form = CharacterForm()

    ctx ={}

    ctx.update(csrf(request))

    all_records = Character.objects.all()

    ctx['staff'] = all_records

    ctx['form']  = form

    return render(request, "investigate.html", ctx)

上面定义了CharacterForm类，并通过属性name，说明了输入栏name的类型为字符串，最大长度为200。

在investigate()函数中，我们根据POST，直接创立form对象。该对象可以直接判断输入是否有效，并对输入进行预处理。空白输入被视为无效。

后面，我们再次创建一个空的form对象，并将它交给模板显示。

在模板investigate.html中，我们可以直接显示form对象：

<form action="/west/investigate/" method="post">

  {% csrf_token %}

  {{ form.as_p }}

  <input type="submit" value="Submit">

</form>

{% for person in staff %}

<p>{{ person }}</p>

{% endfor %}

如果有多个输入栏，我们可以用相同的方式直接显示整个form，而不是加入许多个标签。

效果如下：

作业

1、显示上面“流程”部分的“staff”页面。

2、按照实验过程操作一遍并截图。

Django（下）

作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！

Django提供一个管理数据库的app，即django.contrib.admin。这是Django最方便的功能之一。通过该app，我们可以直接经由web页面，来管理我们的数据库。这一工具，主要是为网站管理人员使用。

这个app通常已经预装好，你可以在mysite/settings.py中的INSTALLED_APPS看到它。

一、默认界面

admin界面位于[site]/admin这个URL。这通常在mysite/urls.py中已经设置好。比如，下面是我的urls.py:

from django.conf.urls import patterns, include, url

from django.contrib import admin

admin.autodiscover()                            # admin

urlpatterns = patterns('',

    url(r'^admin/', include(admin.site.urls)),  # admin

    url(r'^west/', include('west.urls')),

为了让admin界面管理某个数据模型，我们需要先注册该数据模型到admin。比如，我们之前在west中创建的模型Character。修改west/admin.py:

from django.contrib import admin

from west.models import Character

# Register your models here.

admin.site.register(Character)

访问http://127.0.0.1:8000/admin，登录后，可以看到管理界面：

这个页面除了west.characters外，还有用户和组信息。它们来自Django预装的Auth模块。我们将在以后处理用户管理的问题。

二、复杂模型

管理页面的功能强大，完全有能力处理更加复杂的数据模型。

先在west/models.py中增加一个更复杂的数据模型：

from django.db import models

# Create your models here.

class Contact(models.Model):

    name   = models.CharField(max_length=200)

    age    = models.IntegerField(default=0)

    email  = models.EmailField()

    def __unicode__(self):

        return self.name

class Tag(models.Model):

    contact = models.ForeignKey(Contact)

    name    = models.CharField(max_length=50)

    def __unicode__(self):

        return self.name

这里有两个表。Tag以Contact为外部键。一个Contact可以对应多个Tag。

我们还可以看到许多在之前没有见过的属性类型，比如IntegerField用于存储整数。

同步数据库:

$python manage.py syncdb

在west/admin.py注册多个模型并显示：

from django.contrib import admin

from west.models import Character,Contact,Tag

# Register your models here.

admin.site.register([Character, Contact, Tag])

模型将在管理页面显示。比如Contact的添加条目的页面如下：

三、自定义界面

我们可以自定义管理页面，来取代默认的页面。比如上面的"add"页面。我们想只显示name和email部分。修改west/admin.py:

from django.contrib import admin

from west.models import Character,Contact,Tag

# Register your models here.

class ContactAdmin(admin.ModelAdmin):

    fields = ('name', 'email')

admin.site.register(Contact, ContactAdmin)

admin.site.register([Character, Tag])

上面定义了一个ContactAdmin类，用以说明管理页面的显示格式。里面的fields属性，用以说明要显示的输入栏。我们没有让"age"显示。由于该类对应的是Contact数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：

我们还可以将输入栏分块，给每一块输入栏以自己的显示格式。修改west/admin.py为：

from django.contrib import admin

from west.models import Character,Contact,Tag

# Register your models here.

class ContactAdmin(admin.ModelAdmin):

    fieldsets = (

        ['Main',{

            'fields':('name','email'),

}],

        ['Advance',{

            'classes': ('collapse',), # CSS

            'fields': ('age',),

}]

admin.site.register(Contact, ContactAdmin)

admin.site.register([Character, Tag])

上面的栏目分为了Main和Advance两部分。classes说明它所在的部分的CSS格式。这里让Advance部分收敛起来：

Advance部分旁边有一个Show按钮，用于展开。

四、Inline显示

上面的Contact是Tag的外部键，所以有外部参考的关系。而在默认的页面显示中，将两者分离开来，无法体现出两者的从属关系。我们可以使用Inline显示，让Tag附加在Contact的编辑页面上显示。

修改west/admin.py：

from django.contrib import admin

from west.models import Character,Contact,Tag

# Register your models here.

class TagInline(admin.TabularInline):

    model = Tag

class ContactAdmin(admin.ModelAdmin):

    inlines = [TagInline]  # Inline

    fieldsets = (

        ['Main',{

            'fields':('name','email'),

}],

        ['Advance',{

            'classes': ('collapse',),

            'fields': ('age',),

}]

admin.site.register(Contact, ContactAdmin)

admin.site.register([Character])

效果如下：

五、列表页的显示

在Contact输入数条记录后，Contact的列表页看起来如下:

我们也可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在ContactAdmin中增加list_display属性:

from django.contrib import admin

from west.models import Character,Contact,Tag

# Register your models here.

class ContactAdmin(admin.ModelAdmin):

    list_display = ('name','age', 'email') # list

admin.site.register(Contact, ContactAdmin)

admin.site.register([Character, Tag])

列表页新的显示效果如下：

我们还可以为该列表页增加搜索栏。搜索功能在管理大量记录时非常有用。使用search_fields说明要搜索的属性：

from django.contrib import admin

from west.models import Character,Contact,Tag

# Register your models here.

class ContactAdmin(admin.ModelAdmin):

    list_display = ('name','age', 'email')

    search_fields = ('name',)

admin.site.register(Contact, ContactAdmin)

admin.site.register([Character])

效果如下：

六、创建用户

之前我们了解了：

创建Django项目
数据库
模板
表格提交
admin管理页面

上面的功能模块允许我们做出一个具有互动性的站点，但无法验证用户的身份。我们这次了解用户验证部分。通过用户验证，我们可以根据用户的身份，提供不同的服务。

一个Web应用的用户验证是它的基本组成部分。我们在使用一个应用时，总是从“登录”开始，到“登出”结束。另一方面，用户验证又和网站安全、数据库安全息息相关。HTTP协议是无状态的，但我们可以利用储存在客户端的cookie或者储存在服务器的session来记录用户的访问。

Django有管理用户的模块，即django.contrib.auth。你可以在mysite/settings.py里看到，这个功能模块已经注册在INSTALLED_APPS中。利用该模块，你可以直接在逻辑层面管理用户，不需要为用户建立模型，也不需要手工去实现会话。

你可以在admin页面直接看到用户管理的对话框，即Users。从这里，你可以在这里创建、删除和修改用户。点击Add增加用户daddy，密码为daddyiscool。

在admin页面下，我们还可以控制不同用户组对数据库的访问权限。我们可以在Groups中增加用户组，设置用户组对数据库的访问权限，并将用户加入到某个用户组中。

在这一章节中，我们创立一个新的app，即users。下文的模板和views.py，都针对该app。

七、用户登录

我们建立一个简单的表格。用户通过该表格来提交登陆信息，并在Django服务器上验证。如果用户名和密码正确，那么登入用户。

我们首先增加一个登录表格：

<form role="form" action="/login" method="post">

      <label>Username</label>

      <input type="text" name='username'>

      <label>Password</label>

      <input name="password" type="password">

      <input type="submit" value="Submit">

 </form>

我们在views.py中，定义处理函数user_login()，来登入用户：

# -*- coding: utf-8 -*-

from django.shortcuts import render, redirect

from django.core.context_processors import csrf

from django.contrib.auth import *

def user_login(request):

'''

    login

'''

    if request.POST:

        username = password = ''

        username = request.POST.get('username')

        password = request.POST.get('password')

        user     = authenticate(username=username, password=password)

        if user is not None and user.is_active:

                login(request, user)

                return redirect('/')

    ctx = {}

    ctx.update(csrf(request))

    return render(request, 'login.html',ctx)

上面的authenticate()函数，可以根据用户名和密码，验证用户信息。而login()函数则将用户登入。它们来自于django.contrib.auth。

作为替换，我们可以使用特别的form对象，而不自行定义表格。这将让代码更简单，而且提供一定的完整性检验。

八、登出

有时用户希望能销毁会话。我们可以提供一个登出的URL，即/users/logout。登入用户访问该URL，即可登出。在views.py中，增加该URL的处理函数：

# -*- coding: utf-8 -*-

from django.shortcuts import redirect

def user_logout(request):

'''

    logout

    URL: /users/logout

'''

    logout(request)

    return redirect('/')

我们修改urls.py，让url对应user_logout()。访问http://127.0.0.1/users/logout，就可以登出用户。

九、views.py中的用户

上面说明了如何登入和登出用户，但还没有真正开始享受用户验证带来的好处。用户登陆的最终目的，就是为了让服务器可以区别对待不同的用户。比如说，有些内容只能让登陆用户看到，有些内容则只能让特定登陆用户看到。我们下面将探索如何实现这些效果。

在Django中，对用户身份的检验，主要是在views.py中进行。views.py是连接模型和视图的中间层。HTTP请求会转给views.py中的对应处理函数处理，并发回回复。在views.py的某个处理函数准备HTTP回复的过程中，我们可以检验用户是否登陆。根据用户是否登陆，我们可以给出不同的回复。最原始的方式，是使用if式的选择结构：

# -*- coding: utf-8 -*-

from django.http import HttpResponse

def diff_response(request):

    if request.user.is_authenticated():

        content = "<p>my dear user</p>"

    else:

        content = "<p>you wired stranger</p>"

    return HttpResponse(content)

可以看到，用户的登录信息包含在request.user中，is_authenticated()方法用于判断用户是否登录，如果用户没有登录，那么该方法将返回false。该user对象属于contrib.auth.user类型，还有其它属性可供使用，比如：

属性	功能
get_username()	返回用户名
set_password()	设置密码
get_fullname()	返回姓名
last_login	上次登录时间
date_joined	账户创建时间

在Django中，我们还可以利用装饰器，根据用户的登录状况，来决定views.py中处理函数的显示效果。相对于上面的if结构，装饰器使用起来更加方便。下面的user_only()是views.py中的一个处理函数。

from django.contrib.auth.decorators import login_required

from django.http import HttpResponse

@login_required

def user_only(request):

    return HttpResponse("<p>This message is for logged in user only.</p>")

注意上面的装饰器login_required，它是Django预设的装饰器。user_only()的回复结果只能被登录用户看到，而未登录用户将被引导到其他页面。

Django中还有其它的装饰器，用于修饰处理函数。相应的http回复，只能被特殊的用户看到。比如user_passes_test，允许的用户必须满足特定标准，而这一标准是可以用户自定义的。比如下面，在views.py中增添：

from django.contrib.auth.decorators import user_passes_test

from django.http import HttpResponse

def name_check(user):

    return user.get_username() == 'vamei'

@user_passes_test(name_check)

def specific_user(request):

    return HttpResponse("<p>for Vamei only</p>")

装饰器带有一个参数，该参数是一个函数对象name_check。当name_check返回真值，即用户名为vamei时，specific_user的结果才能被用户看到。

十、模板中的用户

进一步，用户是否登陆这一信息，也可以直接用于模板。比较原始的方式是把用户信息直接作为环境数据，提交给模板。然而，这并不是必须的。事实上，Django为此提供了捷径：我们可以直接在模板中调用用户信息。比如下面的模板：

{% if user.is_authenticated %}

  <p>Welcome, my genuine user, my true love.</p>

{% else %}

  <p>Sorry, not login, you are not yet my sweetheart. </p>

{% endif %}

不需要环境变量中定义，我们就可以直接在模板中引用user。这里，模板中调用了user的一个方法，is_authenticated，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。

十一、用户注册

我们上面利用了admin管理页面来增加和删除用户。这是一种简便的方法，但并不能用于一般的用户注册的情境。我们需要提供让用户自主注册的功能。这可以让站外用户提交自己的信息，生成自己的账户，并开始作为登陆用户使用网站。

用户注册的基本原理非常简单，即建立一个提交用户信息的表格。表格中至少包括用户名和密码。相应的处理函数提取到这些信息后，建立User对象，并存入到数据库中。

我们可以利用Django中的UserCreationForm，比较简洁的生成表格，并在views.py中处理表格：

from django.contrib.auth.forms import UserCreationForm

from django.shortcuts import render, redirect

from django.core.context_processors import csrf

def register(request):

    if request.method == 'POST':

        form = UserCreationForm(request.POST)

        if form.is_valid():

            new_user = form.save()

        return redirect("/")

    else:

        form = UserCreationForm()

        ctx = {'form': form}

        ctx.update(csrf(request))

        return render(request, "register.html", ctx)

相应的模板register.html如下：

<form action="" method="post">

   {% csrf_token %}

   {{ form.as_p }}

   <input type="submit" value="Register">

</form>

十二、apache安装

前面介绍了Django最主要的几个方面：数据库，模板，动态生成页面等。但都是使用python manage.py runserver来运行服务器。这是一个实验性的web服务器，不适用于正常的站点运行。我们需要一个可以稳定而持续的服务器。这个服务器负责监听http端口，将收到的请求交给Django处理，将Django的回复发还给客户端。

这样的持续性服务器可以有很多选择，比如apache, Nginx, lighttpd等。这里将使用最常见的apache服务器。服务器和Django之间通过Python的web服务接口WSGI连接，因此我们同样需要apache下的mod_wsgi模块。

首先需要安装apache2和mod_wsgi。我们可以使用apt-get安装：

sudo apt-get install apache2

sudo apt-get install libapache2-mod-wsgi

在apache的配置文件/etc/apache2/apache2.conf中增加下面的配置：

# Django

WSGIScriptAlias / /home/shiyanlou/mysite/mysite/wsgi.py

WSGIPythonPath /home/shiyanlou/mysite

<Directory /home/shiyanlou/mysite/mysite>

<Files wsgi.py>

  Order deny,allow

  Require all granted

</Files>

</Directory>

上面的配置中/home/shiyanlou/mysite是Django项目所在的位置。而/home/shiyanlou/mysite/mysite/wsgi.py是Django项目中z自动创建的文件。

可以看到，利用WSGIScriptAlias，我们实际上将URL /对应了wsgi接口程序。这样，当我们访问根URL时，访问请求会经由WSGI接口，传递给Django项目mysite。

配置好后，重启apache2：

sudo /etc/init.d/apache2 restart

使用浏览器，可以检查效果：

十三、静态文件

Django的主要功能是动态的生成HTTP回复。很多媒体文件是静态存储的，如.js文件，.css文件和图片文件。这些文件变动的频率较小。我们希望静态的提供这些文件，而不是动态的生成。这样既可以减小服务器的负担，也便于在浏览器缓存，提高用户体验。

我们可以在apache2.conf中添加如下配置：

Alias /media/ /home/shiyanlou/media/

Alias /static/ /home/shiyanlou/static/

<Directory /home/shiyanlou/static/>

Order deny,allow

Require all granted

</Directory>

<Directory /home/shiyanlou/media/>

Order deny,allow

Require all granted

</Directory>

# Django

WSGIScriptAlias / /home/shiyanlou/mysite/mysite/wsgi.py

WSGIPythonPath /home/shiyanlou/mysite

<Directory /home/shiyanlou/mysite/mysite/ >

<Files wsgi.py>

    Order deny,allow

    Require all granted

</Files>

</Directory>

这样，/static/和/media/这两个URL的访问将引导向存有静态文件的/home/shiyanlou/static/和/home/shiyanlou/media/，apache将直接向客户提供这两个文件夹中的静态文件。而剩下的URL访问，将导向WSGI接口，由Django动态处理。

在/home/shiyanlou/static/中放入文件revenge.jpg，访问http://localhost/static/revenge：

云平台或者服务器的部署是一个大的课题，这里无法深入到所有的细节。幸运的是，在网上有丰富的资料。你可以根据自己的平台和问题，搜索相应的资料。

在Django的debug模式下，我们可以在app文件夹中建立static目录，放入静态文件。Django将自动搜索到其中的静态文件。但这一方法有很大的安全隐患，只适用于开发。

作业

1、使用contrib.auth.forms.AuthenticationForm。来简化上面“用户登录”的模板和处理函数。

2、实验上面“views.py中的用户”中的处理函数diff_response()的效果。

3、增加处理函数，显示“模板中的用户”中的模板，然后查看不同登录情况下的显示结果。

python快速教程-vamei的更多相关文章

Python快速教程尾声
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 写了将近两年的Python快速教程,终于大概成形.这一系列文章,包括Python基 ...
【Python大系】Python快速教程
感谢原作者:Vamei 出处:http://www.cnblogs.com/vamei 怎么能快速地掌握Python?这是和朋友闲聊时谈起的问题. Python包含的内容很多,加上各种标准库.拓展库, ...
Python快速教程目录（转）
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 怎么能快速地掌握Python?这是和朋友闲聊时谈起的问题. Python包含的内容 ...
Python快速教程尾声(转)
原文地址: http://www.cnblogs.com/vamei/p/3603046.html 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留 ...
Python快速教程
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 怎么能快速地掌握Python?这是和朋友闲聊时谈起的问题. Python包含的内容 ...
Python快速教程（转载)
Python快速教程作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 怎么能快速地掌握Python?这是和朋友闲聊时谈起的问题 ...
给深度学习入门者的Python快速教程 - 番外篇之Python-OpenCV
这次博客园的排版彻底残了..高清版请移步: https://zhuanlan.zhihu.com/p/24425116 本篇是前面两篇教程: 给深度学习入门者的Python快速教程 - 基础篇给深度 ...
给深度学习入门者的Python快速教程 - numpy和Matplotlib篇
始终无法有效把word排版好的粘贴过来,排版更佳版本请见知乎文章: https://zhuanlan.zhihu.com/p/24309547 实在搞不定博客园的排版,排版更佳的版本在: 给深度学习入 ...
给深度学习入门者的Python快速教程
给深度学习入门者的Python快速教程基础篇 numpy和Matplotlib篇本篇部分代码的下载地址: https://github.com/frombeijingwithlove/dlcv_f ...

随机推荐

mybatis源码分析(1)——SqlSessionFactory实例的产生过程
在使用mybatis框架时,第一步就需要产生SqlSessionFactory类的实例(相当于是产生连接池),通过调用SqlSessionFactoryBuilder类的实例的build方法来完成.下 ...
this 函数内部属性
前言:在javascript中我们会经常碰到this,然后this经常出现在function方法里面,有时候可能因为代码很多,无法判断this指向的是谁,其实很简单,一句话总结:谁点出这个this,这 ...
在游戏中使用keybd&lowbar;event的问题
转自在游戏中使用keybd_event的问题今天发现在游戏中,keybd_event不能使用,结果发现游戏是使用directinput实现读取键盘的,关键还是扫描码的问题,我抄了一段老外的代码,经测 ...
JQuery控制input的readonly和disabled属性
jquery设置元素的readonly和disabled Jquery的api中提供了对元素应用disabled和readonly属性的方法,在这里记录下.如下: 1.readonly $('in ...
MFC上下浮动与渐入渐出消息提示框实现
类似QQ与360软件,消息提示有两种.上下浮动.渐入渐出. 1.上下浮动提示框实现机制,定时器响应上下浮动消息. 主要API:MoveWindow. 源码如下UpDownTipDlg.h.UpDow ...
Leetcode&lowbar;104&lowbar;Maximum Depth of Binary Tree
本文是在学习中的总结,欢迎转载但请注明出处:http://blog.csdn.net/pistolove/article/details/41964475 Maximum Depth of Binar ...
跟我学ASP&period;NET MVC之一：开篇有益
摘要: ASP.NET MVC是微软的Web开发框架,结合了模型-视图-控制器(MVC)架构的有效性和整洁性,敏捷开发最前沿的思想和技术,以及现存的ASP.NET平台最好的部分.它是传统ASP.NET ...
Google I/O 官方应用中的动效设计
版权声明:本文为博主原创文章,未经博主同意不得转载. https://blog.csdn.net/jILRvRTrc/article/details/82881743 作者:Nick Butcher, ...
WIN7环境变量path误删（windows找不到文件&OpenCurlyQuote;&percnt;windir&percnt;\systempropertiesadvanced&period;exe’）的解决办法
一.进入安全模式 1.通过Ctrl+R打开运行窗口,输入Msconfig 2.如上图,选择安全引导,点击确定.重启计算机进入安全模式. 二.在安全模式下,设置环境变量 1.C:\Windows\Sys ...
C++ 反射机制的简单实现
C++并不支持反射机制,只能自己实现. 如果需要实现字字符串到函数到映射,一定要使用到函数指针. 简单实现反射机制,根据字符串来构造相应到类.主要有以下几点: (1) 可以使用map保存字符从到函数指 ...

python快速教程-vamei

Python基础（下）

一、循环

1、for循环

2、while循环

3、中断循环

二、函数

1、函数的定义

2、函数调用和参数传递

三、面向对象的基本概念

1、相近对象，归为类

2、动作

3、子类

四、面向对象的进一步拓展

1、调用类的其它信息

2、__init__() 方法

3、对象的性质

五、反过头来看看

1、list是一个类

2、运算符是特殊方法

3、下一步

作业

Python进阶（上）

Python进阶（上）

一、词典

1、基本概念

2、词典元素的循环调用

3、词典的常用方法

二、文本文件的输入输出

1、创建文件对象

2、文件对象的方法

三、模块

1、引入模块

2、搜索路径

3、模块包

四、函数的参数传递

1、关键字传递

2、参数默认值

3、包裹传递

4、解包裹

5、混合

作业

1、按照过程，在实验楼环境下运行本节所有代码，并截图。

2、建立一个record.txt的文档，写入内容如下:

Python进阶（下）

Python进阶（下）

一、循环设计

1、range()

2、enumerate()

3、zip()

二、循环对象

1、什么是循环对象

2、迭代器

3、生成器

4、表推导

三、函数对象

1、lambda函数

2、函数作为参数传递

3、map()函数

4、filter()函数

5、reduce()函数

四、错误处理

1、异常处理

2、抛出异常

五、动态类型

1、动态类型

2、从动态类型看函数的参数传递

作业

1、练习 下面的表推导会生成什么？

2、通过参数传递，判断数字、字符串、list、tuple、词典等数据类型是否为可变数据对象。

Python深入（上）

一、特殊方法与多范式

1、运算符

2、内置函数

3、表（list）元素引用

4、函数

二、上下文管理器

1、关闭文件

2、自定义

三、对象的属性

2、init() 方法

1、练习下面的表推导会生成什么？

1、属性的dict系统

3、使用特殊方法getattr

(1)、使用name