...) 为group命名。
print(m.group("year"))
```
-对比re.search和re.match
-本节开头我们用re.search实现数字子串的提取；
-m = re.search('[0-9]','abcd4ef')
-使用re.match同样实现上述功能（提取数字子串)，我们需要用到小括号'()':
+##对比`re.search`和`re.match`
+
+本节开头我们用`re.search`实现数字子串的提取：
+
+```python
+m = re.search('[0-9]', 'abcd4ef')
+```
+
+使用`re.match`同样实现上述功能（提取数字子串)，我们需要用到小括号`'()'`：
+
```python
-m = re.match('.*([0-9]+).*','abcd4ef')
-# 注意,我们通过m.group(1)来获取数字字串，下标0处是匹配的整个字符串
+m = re.match('.*([0-9]+).*', 'abcd4ef')
+# 注意，我们通过m.group(1)来获取数字字串，下标0处是匹配的整个字符串。
print m.group(0), m.group(1)
+```
+
+```quote
abcd4ef 4
```
-很明显，这里使用match方法要繁琐一些；体会两个方法的差异，搜索整个字符串中的子串使用re.search，而从头开始检查字符串是否符合正则表达式选用re.match;
-练习
-有一个文件，文件名为output_1981.10.21.txt 。下面使用Python： 读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为output_YYYY-MM-DD-W.txt (YYYY:四位的年，MM：两位的月份，DD：两位的日，W：一位的周几，并假设周一为一周第一天)
+很明显，这里使用`match`方法要繁琐一些；体会两个方法的差异，搜索整个字符串中的子串使用`re.search`，而从头开始检查字符串是否符合正则表达式选用`re.match`。
-
+##练习
-
+有一个文件，文件名为`output_1981.10.21.txt`。下面使用Python： 读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为`output_YYYY-MM-DD-W.txt`(`YYYY`：四位的年，`MM`：两位的月份，`DD`：两位的日，`W`：一位的周几，并假设周一为一周第一天)。
##总结
-re.search() re.match() re.sub() re.findall()
+`re.search()` `re.match()` `re.sub()` `re.findall()`
-正则表达式构成方法
+正则表达式构成方法
\ No newline at end of file
diff --git a/content/STL02.md b/content/STL02.md
index fa9a7ee..9da856b 100644
--- a/content/STL02.md
+++ b/content/STL02.md
@@ -1,115 +1,112 @@
-#Python标准库02 时间与日期 (time, datetime包)
+#Python标准库02 时间与日期（time、datetime包）
-
-
-Python具有良好的时间和日期管理功能。实际上，计算机只会维护一个挂钟时间(wall clock time)，这个时间是从某个固定时间起点到现在的时间间隔。时间起点的选择与计算机相关，但一台计算机的话，这一时间起点是固定的。其它的日期信息都是从这一时间计算得到的。此外，计算机还可以测量CPU实际上运行的时间，也就是处理器时间(processor clock time)，以测量计算机性能。当CPU处于闲置状态时，处理器时间会暂停。
-
-
+Python具有良好的时间和日期管理功能。实际上，计算机只会维护一个挂钟时间（wall clock time），这个时间是从某个固定时间起点到现在的时间间隔。时间起点的选择与计算机相关，但一台计算机的话，这一时间起点是固定的。其它的日期信息都是从这一时间计算得到的。此外，计算机还可以测量CPU实际上运行的时间，也就是处理器时间（processor clock time），以测量计算机性能。当CPU处于闲置状态时，处理器时间会暂停。
##time包
-time包基于C语言的库函数(library functions)。Python的解释器通常是用C编写的，Python的一些函数也会直接调用C语言的库函数。
+`time`包基于C语言的库函数（library functions）。Python的解释器通常是用C编写的，Python的一些函数也会直接调用C语言的库函数。
+
```python
import time
print(time.time()) # wall clock time, unit: second
print(time.clock()) # processor clock time, unit: second
```
-time.sleep()可以将程序置于休眠状态，直到某时间间隔之后再唤醒程序，让程序继续运行。
+`time.sleep()`可以将程序置于休眠状态，直到某时间间隔之后再唤醒程序，让程序继续运行。
+
```python
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`对象：
-time包还定义了struct_time对象。该对象实际上是将挂钟时间转换为年、月、日、时、分、秒……等日期信息，存储在该对象的各个属性中(tm_year, tm_mon, tm_mday...)。下面方法可以将挂钟时间转换为struct_time对象:
```python
-st = time.gmtime() # 返回struct_time格式的UTC时间
-st = time.localtime() # 返回struct_time格式的当地时间, 当地时区根据系统环境决定。
-
-s = time.mktime(st) # 将struct_time格式转换成wall clock time
+st = time.gmtime() # 返回struct_time格式的UTC时间。
+st = time.localtime() # 返回struct_time格式的当地时间，当地时区根据系统环境决定。
+s = time.mktime(st) # 将struct_time格式转换成wall clock time。
```
##datetime包
1) 简介
-datetime包是基于time包的一个高级包， 为我们提供了多一层的便利。
+`datetime`包是基于`time`包的一个高级包， 为我们提供了多一层的便利。
-datetime可以理解为date和time两个组成部分。date是指年月日构成的日期(相当于日历)，time是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)。你可以将这两个分开管理(datetime.date类，datetime.time类)，也可以将两者合在一起(datetime.datetime类)。由于其构造大同小异，我们将只介绍datetime.datetime类。
+`datetime`可以理解为date和time两个组成部分。date是指年月日构成的日期（相当于日历），time是指时分秒微秒构成的一天24小时中的具体时间（相当于手表）。你可以将这两个分开管理（`datetime.date`类、`datetime.time`类），也可以将两者合在一起（`datetime.datetime`类）。由于其构造大同小异，我们将只介绍`datetime.datetime`类。
比如说我现在看到的时间，是2012年9月3日21时30分，我们可以用如下方式表达：
+
```python
import datetime
-t = datetime.datetime(2012,9,3,21,30)
+t = datetime.datetime(2012, 9, 3, 21, 30)
print(t)
```
-所返回的t有如下属性:
-hour, minute, second, microsecond
+所返回的`t`有如下属性：
-year, month, day, weekday # weekday表示周几
+`hour`、`minute`、`second`、`microsecond`
-
+`year`、`month`、`day`、`weekday` # weekday表示周几。
2) 运算
-datetime包还定义了时间间隔对象(timedelta)。一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。
+`datetime`包还定义了时间间隔对象（`timedelta`）。一个时间点（`datetime`）加上一个时间间隔（`timedelta`）可以得到一个新的时间点（`datetime`）。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。
```python
import datetime
-t = datetime.datetime(2012,9,3,21,30)
-t_next = datetime.datetime(2012,9,5,23,30)
+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.timedelta`传递参数（如上的`seconds`和`weeks`）的时候，还可以是`days`、`hours`、`milliseconds`、`microseconds`。
+
+两个`datetime`对象还可以进行比较。比如使用上面的`t`和`t_next`：
-两个datetime对象还可以进行比较。比如使用上面的t和t_next:
```python
print(t > t_next)
```
3) datetime对象与字符串转换
-假如我们有一个的字符串，我们如何将它转换成为datetime对象呢？
+假如我们有一个的字符串，我们如何将它转换成为`datetime`对象呢？
一个方法是用上一讲的正则表达式来搜索字符串。但时间信息实际上有很明显的特征，我们可以用格式化读取的方式读取时间信息。
+
```python
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)
-strptime, p = parsing
```
-我们通过format来告知Python我们的str字符串中包含的日期的格式。在format中，%Y表示年所出现的位置, %m表示月份所出现的位置……。
+`strptime`中的“p”代表解析（parsing）。
+
+我们通过`format`来告知Python我们的str字符串中包含的日期的格式。在`format`中，`%Y`表示年所出现的位置，`%m`表示月份所出现的位置……。
+
+反过来，我们也可以调用`datetime`对象的`strftime()`方法，来将`datetime`对象转换为特定格式的字符串。比如上面所定义的`t_next`：
-反过来，我们也可以调用datetime对象的strftime()方法，来将datetime对象转换为特定格式的字符串。比如上面所定义的t_next,
```python
print(t_next.strftime(format))
```
-strftime, f = formatting
-具体的格式写法可参阅官方文档。 如果是Linux系统，也可查阅date命令的手册($man date)，两者相通。
+`strftime`中的“f”代表格式化（formatting）。
-
+具体的格式写法可参阅官方文档。 如果是Linux系统，也可查阅`date`命令的手册（`$man date`），两者相通。
##总结
-时间，休眠
-
-datetime, timedelta
-
-格式化时间
+时间、休眠
+`datetime`、`timedelta`
+格式化时间
\ No newline at end of file
diff --git a/content/STL03.md b/content/STL03.md
index 1cc81ef..60ca880 100644
--- a/content/STL03.md
+++ b/content/STL03.md
@@ -1,76 +1,86 @@
-#Python标准库03 路径与文件 (os.path包, glob包)
+#Python标准库03 路径与文件（os.path包、glob包）
-
-
-
-
-路径与文件的简介请参看Linux文件系统
-
-
+路径与文件的简介请参看Linux文件系统。
##os.path包
-os.path包主要是处理路径字符串，比如说'/home/vamei/doc/file.txt'，提取出有用信息。
+`os.path`包主要是处理路径字符串，比如说`'/home/vamei/doc/file.txt'`，提取出有用信息。
```python
import os.path
path = '/home/vamei/doc/file.txt'
-print(os.path.basename(path)) # 查询路径中包含的文件名
-print(os.path.dirname(path)) # 查询路径中包含的目录
+print(os.path.basename(path)) # 查询路径中包含的文件名。
+print(os.path.dirname(path)) # 查询路径中包含的目录。
-info = os.path.split(path) # 将路径分割成文件名和目录两个部分，放在一个表中返回
-path2 = os.path.join('/', 'home', 'vamei', 'doc', 'file1.txt') # 使用目录名和文件名构成一个路径字符串
+info = os.path.split(path) # 将路径分割成文件名和目录两个部分，放在一个表中返回。
+path2 = os.path.join('/', 'home', 'vamei', 'doc', 'file1.txt') # 使用目录名和文件名构成一个路径字符串。
p_list = [path, path2]
-print(os.path.commonprefix(p_list)) # 查询多个路径的共同部分
+print(os.path.commonprefix(p_list)) # 查询多个路径的共同部分。
```
-此外，还有下面的方法：
-os.path.normpath(path) # 去除路径path中的冗余。比如'/home/vamei/../.'被转化为'/home'
+此外，还有下面的方法：
-
+```python
+os.path.normpath(path) # 去除路径path中的冗余。比如'/home/vamei/../.'被转化为'/home'。
+```
-os.path还可以查询文件的相关信息(metadata)。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息(比如文件类型，大小，修改时间)。
+`os.path`还可以查询文件的相关信息（metadata）。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息（比如文件类型，大小，修改时间）。
```python
import os.path
path = '/home/vamei/doc/file.txt'
-print(os.path.exists(path)) # 查询文件是否存在
+print(os.path.exists(path)) # 查询文件是否存在。
-print(os.path.getsize(path)) # 查询文件大小
-print(os.path.getatime(path)) # 查询文件上一次读取的时间
-print(os.path.getmtime(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)) # 路径是否指向目录文件
+print(os.path.isfile(path)) # 路径是否指向常规文件。
+print(os.path.isdir(path)) # 路径是否指向目录文件。
```
- (实际上，这一部份类似于Linux中的ls命令的某些功能)
-
+（实际上，这一部份类似于Linux中的`ls`命令的某些功能。）
##glob包
-glob包最常用的方法只有一个, glob.glob()。该方法的功能与Linux中的ls相似(参看Linux文件管理命令)，接受一个Linux式的文件名格式表达式(filename pattern expression)，列出所有符合该表达式的文件（与正则表达式类似），将所有文件名放在一个表中返回。所以glob.glob()是一个查询目录下文件的好方法。
+`glob`包最常用的方法只有一个，`glob.glob()`。该方法的功能与Linux中的`ls`相似（参看Linux文件管理命令），接受一个Linux式的文件名格式表达式（filename pattern expression），列出所有符合该表达式的文件（与正则表达式类似），将所有文件名放在一个表中返回。所以`glob.glob()`是一个查询目录下文件的好方法。
-该文件名表达式的语法与Python自身的正则表达式不同 (你可以同时看一下fnmatch包，它的功能是检测一个文件名是否符合Linux的文件名格式表达式)。 如下：
+该文件名表达式的语法与Python自身的正则表达式不同（你可以同时看一下`fnmatch`包，它的功能是检测一个文件名是否符合Linux的文件名格式表达式）。 如下：
-Filename Pattern Expression Python Regular Expression
+
+
+ | Filename Pattern Expression |
+ Python Regular Expression |
+
-* .*
+
+ | * |
+ .* |
+
-? .
+
+ | ? |
+ . |
+
-[0-9] same
+
+ | [0-9] |
+
-[a-e] same
+
+ | [a-z] |
+
-[^mnp] same
+
+ | [^nmp] |
+
+
-
+我们可以用该命令找出`/home/vamei`下的所有文件：
-我们可以用该命令找出/home/vamei下的所有文件:
```python
import glob
print(glob.glob('/home/vamei/*'))
@@ -80,6 +90,6 @@ print(glob.glob('/home/vamei/*'))
文件系统
-os.path
+`os.path`
-glob.glob
+`glob.glob`
\ No newline at end of file
diff --git a/content/STL04.md b/content/STL04.md
index e05460e..32e00a8 100644
--- a/content/STL04.md
+++ b/content/STL04.md
@@ -1,66 +1,55 @@
-#Python标准库04 文件管理 (部分os包，shutil包)
-
-
+#Python标准库04 文件管理（部分os、shutil包）
在操作系统下，用户可以通过操作系统的命令来管理文件，参考linux文件管理相关命令。Python标准库则允许我们从Python内部管理文件。相同的目的，我们有了两条途径。尽管在Python调用标准库的方式不如操作系统命令直接，但有它自己的优势。你可以利用Python语言，并发挥其他Python工具，形成组合的文件管理功能。Python or Shell? 这是留给用户的选择。本文中会尽量将两者相似的功能相对应。
本文基于linux文件管理背景知识
-
-
##os包
-os包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。os包的一些命令就是用于文件管理。我们这里列出最常用的:
-
-mkdir(path)
+`os`包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。`os`包的一些命令就是用于文件管理。我们这里列出最常用的：
-创建新目录，path为一个字符串，表示新目录的路径。相当于$mkdir命令
+`mkdir(path)`
-rmdir(path)
+创建新目录，`path`为一个字符串，表示新目录的路径。相当于`$mkdir`命令。
-删除空的目录，path为一个字符串，表示想要删除的目录的路径。相当于$rmdir命令
+`rmdir(path)`
-listdir(path)
+删除空的目录，`path`为一个字符串，表示想要删除的目录的路径。相当于`$rmdir`命令。
-返回目录中所有文件。相当于$ls命令。
+`listdir(path)`
-
+返回目录中所有文件。相当于`$ls`命令。
-remove(path)
+`remove(path)`
-删除path指向的文件。
+删除`path`指向的文件。
-rename(src, dst)
+`rename(src, dst)`
-重命名文件，src和dst为两个路径，分别表示重命名之前和之后的路径。
+重命名文件，`src`和`dst`为两个路径，分别表示重命名之前和之后的路径。
-
+`chmod(path, mode)`
-chmod(path, mode)
+改变`path`指向的文件的权限。相当于`$chmod`命令。
-改变path指向的文件的权限。相当于$chmod命令。
+`chown(path, uid, gid)`
-chown(path, uid, gid)
+改变`path`所指向文件的拥有者和拥有组。相当于`$chown`命令。
-改变path所指向文件的拥有者和拥有组。相当于$chown命令。
+`stat(path)`
-stat(path)
+查看`path`所指向文件的附加信息，相当于`$ls -l`命令。
-查看path所指向文件的附加信息，相当于$ls -l命令。
+`symlink(src, dst)`
-symlink(src, dst)
+为文件`dst`创建软链接，`src`为软链接文件的路径。相当于`$ln -s`命令。
-为文件dst创建软链接，src为软链接文件的路径。相当于$ln -s命令。
+`getcwd()`
-
+查询当前工作路径（cwd, current working directory），相当于`$pwd`命令。
-getcwd()
+比如说我们要新建目录`new`：
-查询当前工作路径 (cwd, current working directory)，相当于$pwd命令。
-
-
-
-比如说我们要新建目录new：
```python
import os
os.mkdir('/home/vamei/new')
@@ -68,30 +57,27 @@ os.mkdir('/home/vamei/new')
##shutil包
-copy(src, dst)
+`copy(src, dst)`
-复制文件，从src到dst。相当于$cp命令。
+复制文件，从`src`到`dst`。相当于`$cp`命令。
-move(src, dst)
+`move(src, dst)`
-移动文件，从src到dst。相当于$mv命令。
+移动文件，从`src`到`dst`。相当于`$mv`命令。
-
+比如我们想复制文件`a.txt`：
-比如我们想复制文件a.txt:
```python
import shutil
shutil.copy('a.txt', 'b.txt')
```
-想深入细节，请参照官方文档os, shutil。
+想深入细节，请参照官方文档`os`, `shutil`。
结合本章以及之前的内容，我们把Python打造成一个文件管理的利器了。
-
-
##总结
-os包: rmdir, mkdir, listdir, remove, rename, chmod, chown, stat, symlink
+`os`包：`rmdir`、`mkdir`、`listdir`、`remove`、`rename`、`chmod`、`chown`、`stat`、`symlink`
-shutil包: copy, move
+`shutil`包：`copy`、`move`
\ No newline at end of file
diff --git a/content/STL05.md b/content/STL05.md
index c19bf64..837d137 100644
--- a/content/STL05.md
+++ b/content/STL05.md
@@ -1,18 +1,12 @@
-#Python标准库05 存储对象 (pickle包，cPickle包)
+#Python标准库05 存储对象（pickle包、cPickle包）
+在之前对Python对象的介绍中（面向对象的基本概念，面向对象的进一步拓展），我提到过Python“一切皆对象”的哲学，在Python中，无论是变量还是函数，都是一个对象。当Python运行时，对象存储在内存中，随时等待系统的调用。然而，内存里的数据会随着计算机关机和消失，如何将对象保存到文件，并储存在硬盘上呢？
-
-
-
-在之前对Python对象的介绍中 (面向对象的基本概念，面向对象的进一步拓展)，我提到过Python“一切皆对象”的哲学，在Python中，无论是变量还是函数，都是一个对象。当Python运行时，对象存储在内存中，随时等待系统的调用。然而，内存里的数据会随着计算机关机和消失，如何将对象保存到文件，并储存在硬盘上呢？
-
-计算机的内存中存储的是二进制的序列 (当然，在Linux眼中，是文本流)。我们可以直接将某个对象所对应位置的数据抓取下来，转换成文本流 (这个过程叫做serialize)，然后将文本流存入到文件中。由于Python在创建对象时，要参考对象的类定义，所以当我们从文本中读取对象时，必须在手边要有该对象的类定义，才能懂得如何去重建这一对象。从文件读取时，对于Python的内建(built-in)对象 (比如说整数、词典、表等等)，由于其类定义已经载入内存，所以不需要我们再在程序中定义类。但对于用户自行定义的对象，就必须要先定义类，然后才能从文件中载入对象 (比如面向对象的基本概念中的对象那个summer)。
-
-
+计算机的内存中存储的是二进制的序列（当然，在Linux眼中，是文本流）。我们可以直接将某个对象所对应位置的数据抓取下来，转换成文本流（这个过程叫做序列化（serialize）），然后将文本流存入到文件中。由于Python在创建对象时，要参考对象的类定义，所以当我们从文本中读取对象时，必须在手边要有该对象的类定义，才能懂得如何去重建这一对象。从文件读取时，对于Python的内建（built-in）对象（比如说整数、词典、表等等），由于其类定义已经载入内存，所以不需要我们再在程序中定义类。但对于用户自行定义的对象，就必须要先定义类，然后才能从文件中载入对象 （比如面向对象的基本概念中的对象那个`summer`）。
##pickle包
-对于上述过程，最常用的工具是Python中的pickle包。
+对于上述过程，最常用的工具是Python中的`pickle`包。
1) 将内存中的对象转换成为文本流：
@@ -27,11 +21,10 @@ class Bird(object):
summer = Bird() # construct an object
picklestring = pickle.dumps(summer) # serialize object
```
-使用pickle.dumps()方法可以将对象summer转换成了字符串 picklestring(也就是文本流)。随后我们可以用普通文本的存储方法来将该字符串储存在文件(文本文件的输入输出)。
-
+使用`pickle.dumps()`方法可以将对象`summer`转换成了字符串 `picklestring`（也就是文本流）。随后我们可以用普通文本的存储方法来将该字符串储存在文件（文本文件的输入输出）。
-当然，我们也可以使用pickle.dump()的方法，将上面两部合二为一:
+当然，我们也可以使用`pickle.dump()`的方法，将上面两部合二为一：
```python
import pickle
@@ -46,17 +39,14 @@ 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
-
+对象`summer`存储在文件`a.pkl`。
2) 重建对象
-首先，我们要从文本中读出文本，存储到字符串 (文本文件的输入输出)。然后使用pickle.loads(str)的方法，将字符串转换成为对象。要记得，此时我们的程序中必须已经有了该对象的类定义。
-
-
+首先，我们要从文本中读出文本，存储到字符串（文本文件的输入输出）。然后使用`pickle.loads(str)`的方法，将字符串转换成为对象（反序列化）。要记得，此时我们的程序中必须已经有了该对象的类定义。
-此外，我们也可以使用pickle.load()的方法，将上面步骤合并:
+此外，我们也可以使用`pickle.load()`的方法，将上面步骤合并：
```python
import pickle
@@ -66,25 +56,23 @@ class Bird(object):
have_feather = True
way_of_reproduction = 'egg'
-fn = 'a.pkl'
+fn = 'a.pkl'
with open(fn, 'r') as f:
summer = pickle.load(f) # read file and build object
```
-
-
-
##cPickle包
-cPickle包的功能和用法与pickle包几乎完全相同 (其存在差别的地方实际上很少用到)，不同在于cPickle是基于c语言编写的，速度是pickle包的1000倍。对于上面的例子，如果想使用cPickle包，我们都可以将import语句改为:
+`cPickle`包的功能和用法与`pickle`包几乎完全相同（其存在差别的地方实际上很少用到），不同在于`cPickle`是基于c语言编写的，速度是`pickle`包的1000倍。对于上面的例子，如果想使用`cPickle`包，我们都可以将import语句改为：
+```python
import cPickle as pickle
-就不需要再做任何改动了。
+```
-
+就不需要再做任何改动了。
##总结
对象 -> 文本 -> 文件
-pickle.dump(), pickle.load(), cPickle
+`pickle.dump()`、`pickle.load()`、`cPickle`
\ No newline at end of file
diff --git a/content/STL06.md b/content/STL06.md
index fea726f..79f6ad8 100644
--- a/content/STL06.md
+++ b/content/STL06.md
@@ -1,163 +1,138 @@
-#Python标准库06 子进程 (subprocess包)
+#Python标准库06 子进程（subprocess包）
-
-
-
-这里的内容以Linux进程基础和Linux文本流为基础。subprocess包主要功能是执行外部的命令和程序。比如说，我需要使用wget下载文件。我在Python中调用wget程序。从这个意义上来说，subprocess的功能与shell类似。
-
-
+这里的内容以Linux进程基础和Linux文本流为基础。`subprocess`包主要功能是执行外部的命令和程序。比如说，我需要使用`wget`下载文件。我在Python中调用`wget`程序。从这个意义上来说，`subprocess`的功能与shell类似。
##subprocess以及常用的封装函数
-当我们运行python的时候，我们都是在创建并运行一个进程。正如我们在Linux进程基础中介绍的那样，一个进程可以fork一个子进程，并让这个子进程exec另外一个程序。在Python中，我们通过标准库中的subprocess包来fork一个子进程，并运行一个外部的程序(fork，exec见Linux进程基础)。
-
-
+当我们运行python的时候，我们都是在创建并运行一个进程。正如我们在Linux进程基础中介绍的那样，一个进程可以`fork`一个子进程，并让这个子进程`exec`另外一个程序。在Python中，我们通过标准库中的`subprocess`包来`fork`一个子进程，并运行一个外部的程序（`fork`，`exec`见Linux进程基础）。
-subprocess包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所以我们可以根据需要来从中选取一个使用。另外subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。
+`subprocess`包中定义有数个创建子进程的函数，这些函数分别以不同的方式创建子进程，所以我们可以根据需要来从中选取一个使用。另外`subprocess`还提供了一些管理标准流（standard stream）和管道（pipe）的工具，从而在进程间使用文本通信。
-
-
-使用subprocess包中的函数创建子进程的时候，要注意:
+使用`subprocess`包中的函数创建子进程的时候，要注意：
1) 在创建子进程之后，父进程是否暂停，并等待子进程运行。
-2) 函数返回什么
-
-3) 当returncode不为0时，父进程如何处理。
+2) 函数返回什么？
-
+3) 当`returncode`不为`0`时，父进程如何处理。
+```python
subprocess.call()
-父进程等待子进程完成
-返回退出信息(returncode，相当于exit code，见Linux进程基础)
+```
-
+父进程等待子进程完成。返回退出信息（`returncode`，相当于exit code，见Linux进程基础）。
+```python
subprocess.check_call()
+```
-父进程等待子进程完成
-
-返回0
-
-检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性，可用try...except...来检查(见Python错误处理)。
+父进程等待子进程完成。返回`0`。
-
+检查退出信息，如果`returncode`不为`0`，则举出错误`subprocess.CalledProcessError`，该对象包含有`returncode`属性，可用`try...except...`来检查（见Python错误处理）。
+```python
subprocess.check_output()
+```
-父进程等待子进程完成
-
-返回子进程向标准输出的输出结果
+父进程等待子进程完成。返回子进程向标准输出的输出结果。
-检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性和output属性，output属性为标准输出的输出结果，可用try...except...来检查。
+检查退出信息，如果`returncode`不为`0`，则举出错误`subprocess.CalledProcessError`，该对象包含有`returncode`属性和`output`属性，`output`属性为标准输出的输出结果，可用`try...except...`来检查。
-
+这三个函数的使用方法相类似，我们以`subprocess.call()`来说明：
-这三个函数的使用方法相类似，我们以subprocess.call()来说明:
```python
import subprocess
-rc = subprocess.call(["ls","-l"])
+rc = subprocess.call(["ls", "-l"])
```
-我们将程序名(ls)和所带的参数(-l)一起放在一个表中传递给subprocess.call()
-
+我们将程序名（`ls`）和所带的参数（`-l`）一起放在一个表中传递给`subprocess.call()`
+
+可以通过一个shell来解释一整个字符串：
-可以通过一个shell来解释一整个字符串:
```python
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允许我们运行这样一些命令。
+我们使用了`shell=True`这个参数。这个时候，我们使用一整个字符串，而不是一个表来运行子进程。Python将先运行一个shell，再用这个shell来解释这整个字符串。
-
+shell命令中有一些是shell的内建命令，这些命令必须通过shell运行，`$cd`。`shell=True`允许我们运行这样一些命令。
##Popen()
-实际上，我们上面的三个函数都是基于Popen()的封装(wrapper)。这些封装的目的在于让我们容易使用子进程。当我们想要更个性化我们的需求的时候，就要转向Popen类，该类生成的对象用来代表子进程。
+实际上，我们上面的三个函数都是基于`Popen()`的封装（wrapper）。这些封装的目的在于让我们容易使用子进程。当我们想要更个性化我们的需求的时候，就要转向`Popen`类，该类生成的对象用来代表子进程。
-
+与上面的封装不同，`Popen`对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的`wait()`方法，父进程才会等待（也就是阻塞block）：
-与上面的封装不同，Popen对象创建后，主程序不会自动等待子进程完成。我们必须调用对象的wait()方法，父进程才会等待 (也就是阻塞block)：
```python
import subprocess
-child = subprocess.Popen(["ping","-c","5","www.google.com"])
+child = subprocess.Popen(["ping", "-c", "5", "www.google.com"])
print("parent process")
```
-从运行结果中看到，父进程在开启子进程之后并没有等待child的完成，而是直接运行print。
-
+从运行结果中看到，父进程在开启子进程之后并没有等待`child`的完成，而是直接运行`print`。
+
+对比等待的情况：
-对比等待的情况:
```python
import subprocess
-child = subprocess.Popen(["ping","-c","5","www.google.com"])
+child = subprocess.Popen(["ping", "-c", "5", "www.google.com"])
child.wait()
print("parent process")
```
-此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的child对象:
+此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的`child`对象：
+```python
child.poll() # 检查子进程状态
-
child.kill() # 终止子进程
-
child.send_signal() # 向子进程发送信号
-
child.terminate() # 终止子进程
+```
-
-
-子进程的PID存储在child.pid
-
-
+子进程的PID存储在`child.pid`。
##子进程的文本流控制
-(沿用child子进程) 子进程的标准输入，标准输出和标准错误也可以通过如下属性表示:
+（沿用`child`子进程）子进程的标准输入，标准输出和标准错误也可以通过如下属性表示：
-child.stdin
+`child.stdin`
-child.stdout
+`child.stdout`
-child.stderr
+`child.stderr`
-
+我们可以在`Popen()`建立子进程的时候改变标准输入、标准输出和标准错误，并可以利用`subprocess.PIPE`将多个子进程的输入和输出连接在一起，构成管道（pipe）：
-我们可以在Popen()建立子进程的时候改变标准输入、标准输出和标准错误，并可以利用subprocess.PIPE将多个子进程的输入和输出连接在一起，构成管道(pipe):
```python
import subprocess
-child1 = subprocess.Popen(["ls","-l"], stdout=subprocess.PIPE)
-child2 = subprocess.Popen(["wc"], stdin=child1.stdout,stdout=subprocess.PIPE)
+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中的文本。
-要注意的是，communicate()是Popen对象的一个方法，该方法会阻塞父进程，直到子进程完成。
+`subprocess.PIPE`实际上为文本流提供一个缓存区。`child1`的`stdout`将文本输出到缓存区，随后`child2`的`stdin`从该`PIPE`中将文本读取走。`child2`的输出文本也被存放在`PIPE`中，直到`communicate()`方法从`PIPE`中读取出`PIPE`中的文本。
+
+要注意的是，`communicate()`是`Popen`对象的一个方法，该方法会阻塞父进程，直到子进程完成。
-
+我们还可以利用`communicate()`方法来使用`PIPE`给子进程输入：
-我们还可以利用communicate()方法来使用PIPE给子进程输入:
```python
import subprocess
child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)
child.communicate("vamei")
```
-我们启动子进程之后，cat会等待输入，直到我们用communicate()输入"vamei"。
-
-
-通过使用subprocess包，我们可以运行外部程序。这极大的拓展了Python的功能。如果你已经了解了操作系统的某些应用，你可以从Python中直接调用该应用(而不是完全依赖Python)，并将应用的结果输出给Python，并让Python继续处理。shell的功能(比如利用文本流连接各个应用)，就可以在Python中实现。
+我们启动子进程之后，`cat`会等待输入，直到我们用`communicate()`输入`"vamei"`。
-
+通过使用`subprocess`包，我们可以运行外部程序。这极大的拓展了Python的功能。如果你已经了解了操作系统的某些应用，你可以从Python中直接调用该应用（而不是完全依赖Python），并将应用的结果输出给Python，并让Python继续处理。shell的功能（比如利用文本流连接各个应用），就可以在Python中实现。
##总结
-subprocess.call, subprocess.check_call(), subprocess.check_output()
+`subprocess.call`、`subprocess.check_call()`、`subprocess.check_output()`
-subprocess.Popen(), subprocess.PIPE
+`subprocess.Popen()`、`subprocess.PIPE`
-Popen.wait(), Popen.communicate()
+`Popen.wait()`、`Popen.communicate()`
\ No newline at end of file
diff --git a/content/STL07.md b/content/STL07.md
index 0890694..07ebeb1 100644
--- a/content/STL07.md
+++ b/content/STL07.md
@@ -1,34 +1,34 @@
-#Python标准库07 信号 (signal包，部分os包)
+#Python标准库07 信号（signal包、部分os包）
-
-
-在了解了Linux的信号基础之后，Python标准库中的signal包就很容易学习和理解。signal包负责在Python程序内部处理信号，典型的操作包括预设信号处理函数，暂停并等待信号，以及定时发出SIGALRM等。要注意，signal包主要是针对UNIX平台(比如Linux, MAC OS)，而Windows内核中由于对信号机制的支持不充分，所以在Windows上的Python不能发挥信号系统的功能。
-
-
+在了解了Linux的信号基础之后，Python标准库中的`signal`包就很容易学习和理解。`signal`包负责在Python程序内部处理信号，典型的操作包括预设信号处理函数，暂停并等待信号，以及定时发出`SIGALRM`等。要注意，`signal`包主要是针对UNIX平台（比如Linux、OS X），而Windows内核中由于对信号机制的支持不充分，所以在Windows上的Python不能发挥信号系统的功能。
##定义信号名
-signal包定义了各个信号名及其对应的整数，比如
+`signal`包定义了各个信号名及其对应的整数，比如：
+
```python
import signal
print signal.SIGALRM
print signal.SIGCONT
```
+
Python所用的信号名和Linux一致。你可以通过
+
```bash
$man 7 signal
```
-查询
-
+来查询。
##预设信号处理函数
-signal包的核心是使用signal.signal()函数来预设(register)信号处理函数，如下所示：
+`signal`包的核心是使用`signal.signal()`函数来预设（register）信号处理函数，如下所示：
+```python
singnal.signal(signalnum, handler)
+```
-signalnum为某个信号，handler为该信号的处理函数。我们在信号基础里提到，进程可以无视信号，可以采取默认操作，还可以自定义操作。当handler为signal.SIG_IGN时，信号被无视(ignore)。当handler为singal.SIG_DFL，进程采取默认操作(default)。当handler为一个函数名时，进程采取函数中定义的操作。
+`signalnum`为某个信号，`handler`为该信号的处理函数。我们在信号基础里提到，进程可以无视信号，可以采取默认操作，还可以自定义操作。当`handler`为`signal.SIG_IGN`时，信号被无视（ignore）。当`handler`为`singal.SIG_DFL`，进程采取默认操作（default）。当`handler`为一个函数名时，进程采取函数中定义的操作。
```python
import signal
@@ -41,27 +41,24 @@ 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()函数来传递的。
+在主程序中，我们首先使用`signal.signal()`函数来预设信号处理函数。然后我们执行`signal.pause()`来让该进程暂停以等待信号，以等待信号。当信号`SIGUSR1`被传递给该进程时，进程从暂停中恢复，并根据预设，执行`SIGTSTP`的信号处理函数`myHandler()`。`myHandler`的两个参数一个用来识别信号（`signum`），另一个用来获得信号发生时，进程栈的状况（stack frame）。这两个参数都是由`signal.singnal()`函数来传递的。
-上面的程序可以保存在一个文件中(比如test.py)。我们使用如下方法运行:
+上面的程序可以保存在一个文件中（比如test.py）。我们使用如下方法运行：
+```bash
$python test.py
+```
-以便让进程运行。当程序运行到signal.pause()的时候，进程暂停并等待信号。此时，通过按下CTRL+Z向该进程发送SIGTSTP信号。我们可以看到，进程执行了myHandle()函数, 随后返回主程序，继续执行。(当然，也可以用$ps查询process ID, 再使用$kill来发出信号。)
-
-(进程并不一定要使用signal.pause()暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的signal.pause()改为一个需要长时间工作的循环。)
-
-
+以便让进程运行。当程序运行到`signal.pause()`的时候，进程暂停并等待信号。此时，通过按下`CTRL+Z`向该进程发送`SIGTSTP`信号。我们可以看到，进程执行了`myHandle()`函数，随后返回主程序，继续执行。（当然，也可以用`$ps`查询process ID，再使用`$kill`来发出信号。）
-我们可以根据自己的需要更改myHandler()中的操作，以针对不同的信号实现个性化的处理。
+（进程并不一定要使用`signal.pause()`暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的`signal.pause()`改为一个需要长时间工作的循环。）
-
+我们可以根据自己的需要更改`myHandler()`中的操作，以针对不同的信号实现个性化的处理。
##定时发出SIGALRM信号
-一个有用的函数是signal.alarm()，它被用于在一定时间之后，向进程自身发送SIGALRM信号:
+一个有用的函数是`signal.alarm()`，它被用于在一定时间之后，向进程自身发送`SIGALRM`信号：
```python
import signal
@@ -76,32 +73,28 @@ signal.alarm(5)
while True:
print('not yet')
```
-我们这里用了一个无限循环以便让进程持续运行。在signal.alarm()执行5秒之后，进程将向自己发出SIGALRM信号，随后，信号处理函数myHandler开始执行。
-
+我们这里用了一个无限循环以便让进程持续运行。在`signal.alarm()`执行`5`秒之后，进程将向自己发出`SIGALRM`信号，随后，信号处理函数`myHandler`开始执行。
##发送信号
-signal包的核心是设置信号处理函数。除了signal.alarm()向自身发送信号之外，并没有其他发送信号的功能。但在os包中，有类似于linux的kill命令的函数，分别为
+`signal`包的核心是设置信号处理函数。除了`signal.alarm()`向自身发送信号之外，并没有其他发送信号的功能。但在`os`包中，有类似于linux的`kill`命令的函数，分别为：
+```python
os.kill(pid, sid)
-
os.killpg(pgid, sid)
+```
-分别向进程和进程组(见Linux进程关系)发送信号。sid为信号所对应的整数或者singal.SIG*。
-
-
-
-实际上signal, pause，kill和alarm都是Linux应用编程中常见的C库函数，在这里，我们只不过是用Python语言来实现了一下。实际上，Python 的解释器是使用C语言来编写的，所以有此相似性也并不意外。此外，在Python 3.4中，signal包被增强，信号阻塞等功能被加入到该包中。我们暂时不深入到该包中。
+分别向进程和进程组（见Linux进程关系）发送信号。`sid`为信号所对应的整数或者`singal.SIG*`。
-
+实际上`signal`、`pause、`kill`和`alarm`都是Linux应用编程中常见的C库函数，在这里，我们只不过是用Python语言来实现了一下。实际上，Python 的解释器是使用C语言来编写的，所以有此相似性也并不意外。此外，在Python 3.4中，`signal`包被增强，信号阻塞等功能被加入到该包中。我们暂时不深入到该包中。
##总结
-signal.SIG*
+`signal.SIG*`
-signal.signal()
+`signal.signal()`
-signal.pause()
+`signal.pause()`
-signal.alarm()
+`signal.alarm()`
\ No newline at end of file
diff --git a/content/STL08.md b/content/STL08.md
index 7b185da..fffb0ea 100644
--- a/content/STL08.md
+++ b/content/STL08.md
@@ -1,17 +1,12 @@
-##Python标准库08 多线程与同步 (threading包)
+#Python标准库08 多线程与同步（threading包）
+Python主要通过标准库中的`threading`包来实现多线程。在当今网络时代，每个服务器都会接收到大量的请求。服务器可以利用多线程的方式来处理这些请求，以提高对网络端口的读写效率。Python是一种网络服务器的后台工作语言（比如豆瓣网），所以多线程也就很自然被Python语言支持。
-
-
-Python主要通过标准库中的threading包来实现多线程。在当今网络时代，每个服务器都会接收到大量的请求。服务器可以利用多线程的方式来处理这些请求，以提高对网络端口的读写效率。Python是一种网络服务器的后台工作语言 (比如豆瓣网)，所以多线程也就很自然被Python语言支持。
-
-(关于多线程的原理和C实现方法，请参考我之前写的Linux多线程与同步，要了解race condition, mutex和condition variable的概念)
-
-
+（关于多线程的原理和C实现方法，请参考我之前写的Linux多线程与同步，要了解race condition、mutex和condition variable的概念）
##多线程售票以及同步
-我们使用Python来实现Linux多线程与同步文中的售票程序。我们使用mutex (也就是Python中的Lock类对象) 来实现线程的同步:
+我们使用Python来实现Linux多线程与同步文中的售票程序。我们使用`mutex`（也就是Python中的`Lock`类对象）来实现线程的同步：
```python
# A program to simulate selling tickets in multi-thread way
@@ -30,38 +25,38 @@ def booth(tid):
global i
global lock
while True:
- lock.acquire() # Lock; or wait if other thread is holding the lock
+ 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
+ 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
+ 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)
+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 = 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)。
+我们使用了两个全局变量，一个是`i`，用以储存剩余票数；一个是`lock`对象，用于同步线程对`i`的修改。此外，在最后的`for`循环中，我们总共设置了`10`个线程。每个线程都执行`booth()`函数。线程在调用`start()`方法的时候正式启动（实际上，计算机中最多会有11个线程，因为主程序本身也会占用一个线程）。Python使用`threading.Thread`对象来代表线程，用`threading.Lock`对象来代表一个互斥锁（mutex）。
-有两点需要注意:
+有两点需要注意：
-我们在函数中使用global来声明变量为全局变量，从而让多线程共享i和lock (在C语言中，我们通过将变量放在所有函数外面来让它成为全局变量)。如果不这么声明，由于i和lock是不可变数据对象，它们将被当作一个局部变量(参看Python动态类型)。如果是可变数据对象的话，则不需要global声明。我们甚至可以将可变数据对象作为参数来传递给线程函数。这些线程将共享这些可变数据对象。
-我们在booth中使用了两个doChore()函数。可以在未来改进程序，以便让线程除了进行i=i-1之外，做更多的操作，比如打印剩余票数，找钱，或者喝口水之类的。第一个doChore()依然在Lock内部，所以可以安全地使用共享资源 (critical operations, 比如打印剩余票数)。第二个doChore()时，Lock已经被释放，所以不能再去使用共享资源。这时候可以做一些不使用共享资源的操作 (non-critical operation, 比如找钱、喝水)。我故意让doChore()等待了0.5秒，以代表这些额外的操作可能花费的时间。你可以定义的函数来代替doChore()。
-
+我们在函数中使用`global`来声明变量为全局变量，从而让多线程共享`i`和`lock`（在C语言中，我们通过将变量放在所有函数外面来让它成为全局变量）。如果不这么声明，由于`i`和`lock`是不可变数据对象，它们将被当作一个局部变量（参看Python动态类型）。如果是可变数据对象的话，则不需要`global`声明。我们甚至可以将可变数据对象作为参数来传递给线程函数。这些线程将共享这些可变数据对象。
+
+我们在`booth`中使用了两个`doChore()`函数。可以在未来改进程序，以便让线程除了进行`i = i - 1`之外，做更多的操作，比如打印剩余票数，找钱，或者喝口水之类的。第一个`doChore()`依然在`Lock`内部，所以可以安全地使用共享资源（critical operations，比如打印剩余票数）。第二个`doChore()`时，`Lock`已经被释放，所以不能再去使用共享资源。这时候可以做一些不使用共享资源的操作 （non-critical operation，比如找钱、喝水）。我故意让`doChore()`等待了`0.5`秒，以代表这些额外的操作可能花费的时间。你可以定义的函数来代替`doChore()`。
##OOP创建线程
-上面的Python程序非常类似于一个面向过程的C程序。我们下面介绍如何通过面向对象 (OOP， object-oriented programming，参看Python面向对象的基本概念和Python面向对象的进一步拓展) 的方法实现多线程，其核心是继承threading.Thread类。我们上面的for循环中已经利用了threading.Thread()的方法来创建一个Thread对象，并将函数booth()以及其参数传递给改对象，并调用start()方法来运行线程。OOP的话，通过修改Thread类的run()方法来定义线程所要执行的命令。
+上面的Python程序非常类似于一个面向过程的C程序。我们下面介绍如何通过面向对象（OOP， object-oriented programming，参看Python面向对象的基本概念和Python面向对象的进一步拓展）的方法实现多线程，其核心是继承`threading.Thread`类。我们上面的`for`循环中已经利用了`threading.Thread()`的方法来创建一个`Thread`对象，并将函数`booth()`以及其参数传递给改对象，并调用`start()`方法来运行线程。OOP的话，通过修改`Thread`类的`run()`方法来定义线程所要执行的命令。
```python
# A program to simulate selling tickets in multi-thread way
@@ -83,16 +78,16 @@ class BoothThread(threading.Thread):
threading.Thread.__init__(self)
def run(self):
while True:
- monitor['lock'].acquire() # Lock; or wait if other thread is holding the lock
+ 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
+ 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
+ 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()}
@@ -102,42 +97,39 @@ for k in range(10):
new_thread = BoothThread(k, monitor)
new_thread.start()
```
-我们自己定义了一个类BoothThread, 这个类继承自thread.Threading类。然后我们把上面的booth()所进行的操作统统放入到BoothThread类的run()方法中。注意，我们没有使用全局变量声明global，而是使用了一个词典monitor存放全局变量，然后把词典作为参数传递给线程函数。由于词典是可变数据对象，所以当它被传递给函数的时候，函数所使用的依然是同一个对象，相当于被多个线程所共享。这也是多线程乃至于多进程编程的一个技巧 (应尽量避免上面的global声明的用法，因为它并不适用于windows平台)。
-上面OOP编程方法与面向过程的编程方法相比，并没有带来太大实质性的差别。
+我们自己定义了一个类`BoothThread`，这个类继承自`thread.Threading`类。然后我们把上面的`booth()`所进行的操作统统放入到`BoothThread`类的`run()`方法中。注意，我们没有使用全局变量声明`global`，而是使用了一个词典`monitor`存放全局变量，然后把词典作为参数传递给线程函数。由于词典是可变数据对象，所以当它被传递给函数的时候，函数所使用的依然是同一个对象，相当于被多个线程所共享。这也是多线程乃至于多进程编程的一个技巧（应尽量避免上面的`global`声明的用法，因为它并不适用于windows平台）。
-
+上面OOP编程方法与面向过程的编程方法相比，并没有带来太大实质性的差别。
##其他
-threading.Thread对象： 我们已经介绍了该对象的start()和run(), 此外：
-
-join()方法，调用该方法的线程将等待直到改Thread对象完成，再恢复运行。这与进程间调用wait()函数相类似。
-
+`threading.Thread`对象： 我们已经介绍了该对象的`start()`和`run()`，此外，`join()`方法，调用该方法的线程将等待直到该`Thread`对象完成，再恢复运行。这与进程间调用`wait()`函数相类似。
下面的对象用于处理多线程同步。对象一旦被建立，可以被多个线程共享，并根据情况阻塞某些进程。请与Linux多线程与同步中的同步工具参照阅读。
-threading.Lock对象: mutex, 有acquire()和release()方法。
+`threading.Lock`对象: mutex，有`acquire()`和`release()`方法。
-threading.Condition对象: condition variable，建立该对象时，会包含一个Lock对象 (因为condition variable总是和mutex一起使用)。可以对Condition对象调用acquire()和release()方法，以控制潜在的Lock对象。此外:
+`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传统意义上是一种进程间同步工具，见Linux进程间通信)。创建对象的时候，可以传递一个整数作为计数上限 (sema = threading.Semaphore(5))。它与Lock类似，也有Lock的两个方法。
-threading.Event对象: 与threading.Condition相类似，相当于没有潜在的Lock保护的condition variable。对象有True和False两个状态。可以多个线程使用wait()等待，直到某个线程调用该对象的set()方法，将对象设置为True。线程可以调用对象的clear()方法来重置对象为False状态。
-
+`wait()`方法，相当于`cond_wait()`
+
+`notify_all()`，相当与`cond_broadcast()`
+
+`nofify()`，与`notify_all()`功能类似，但只唤醒一个等待的线程，而不是全部。
+
+`threading.Semaphore`对象: semaphore，也就是计数锁（也称信号量。semaphore传统意义上是一种进程间同步工具，见Linux进程间通信）。创建对象的时候，可以传递一个整数作为计数上限 (`sema = threading.Semaphore(5)`)。它与`Lock`类似，也有`Lock`的两个方法。
+
+`threading.Event`对象: 与`threading.Condition`相类似，相当于没有潜在的`Lock`保护的condition variable。对象有`True`和`False`两个状态。可以多个线程使用`wait()`等待，直到某个线程调用该对象的`set()`方法，将对象设置为`True`。线程可以调用对象的`clear()`方法来重置对象为`False`状态。
-练习
+##练习
+
参照Linux多线程与同步中的condition variable的例子，使用Python实现。同时考虑使用面向过程和面向对象的编程方法。
-更多的threading的内容请参考:
-http://docs.python.org/library/threading.html
+更多的threading的内容请参考:http://docs.python.org/library/threading.html
-
##总结
-threading.Thread
-
-Lock, Condition, Semaphore, Event
+`threading.Thread`
+`Lock`、`Condition`、`Semaphore`、`Event`
\ No newline at end of file
diff --git a/content/STL09.md b/content/STL09.md
index d213a3b..618fd88 100644
--- a/content/STL09.md
+++ b/content/STL09.md
@@ -1,106 +1,98 @@
+#Python标准库09 当前进程信息（部分os包）
-##Python标准库09 当前进程信息 (部分os包)
-
-
-
-
-我们在Linux的概念与体系，多次提及进程的重要性。Python的os包中有查询和修改进程信息的函数。学习Python的这些工具也有助于理解Linux体系。
-
-
+我们在Linux的概念与体系，多次提及进程的重要性。Python的`os`包中有查询和修改进程信息的函数。学习Python的这些工具也有助于理解Linux体系。
##进程信息
-os包中相关函数如下：
-
-uname() 返回操作系统相关信息。类似于Linux上的uname命令。
+`os`包中相关函数如下：
-umask() 设置该进程创建文件时的权限mask。类似于Linux上的umask命令，见Linux文件管理背景知识
+`uname()` 返回操作系统相关信息。类似于Linux上的`uname`命令。
-
+`umask()` 设置该进程创建文件时的权限mask。类似于Linux上的umask命令，见Linux文件管理背景知识。
-get*() 查询 (*由以下代替)
+`get*()` 查询（*由以下代替）
- uid, euid, resuid, gid, egid, resgid ：权限相关，其中resuid主要用来返回saved UID。相关介绍见Linux用户与“最小权限”原则
+ `uid`、`euid`、`resuid`、`gid`、`egid`、`resgid` ：权限相关，其中`resuid`主要用来返回saved UID。相关介绍见Linux用户与“最小权限”原则。
- pid, pgid, ppid, sid ：进程相关。相关介绍见Linux进程关系
+ `pid`、`pgid`、`ppid`、`sid` ：进程相关。相关介绍见Linux进程关系。
-
+`put*()` 设置（*由以下代替）
-put*() 设置 (*由以下代替)
+ `euid`、`egid`： 用于更改euid，egid。
- euid, egid： 用于更改euid，egid。
+ `uid`、 `gid` ： 改变进程的uid、gid。只有super user才有权改变进程uid和gid（意味着要以`$sudo python`的方式运行Python）。
- uid, gid ： 改变进程的uid, gid。只有super user才有权改变进程uid和gid (意味着要以$sudo python的方式运行Python)。
+ `pgid`、`sid` ： 改变进程所在的进程组（process group）和会话（session）。
- pgid, sid ： 改变进程所在的进程组(process group)和会话(session)。
+`getenviron()`：获得进程的环境变量。
-
-
-getenviron()：获得进程的环境变量
-
-setenviron()：更改进程的环境变量
-
-
+`setenviron()`：更改进程的环境变量。
例1，进程的real UID和real GID
+
```python
import os
print(os.getuid())
print(os.getgid())
```
-将上面的程序保存为py_id.py文件，分别用$python py_id.py和$sudo python py_id.py看一下运行结果
-
+将上面的程序保存为`py_id.py`文件，分别用`$python py_id.py`和`$sudo python py_id.py`看一下运行结果。
##saved UID和saved GID
我们希望saved UID和saved GID如我们在Linux用户与“最小权限”原则中描述的那样工作，但这很难。原因在于，当我们写一个Python脚本后，我们实际运行的是python这个解释器，而不是Python脚本文件。对比C，C语言直接运行由C语言编译成的执行文件。我们必须更改python解释器本身的权限来运用saved UID机制，然而这么做又是异常危险的。
-比如说，我们的python执行文件为/usr/bin/python (你可以通过$which python获知)
+比如说，我们的python执行文件为`/usr/bin/python`。（你可以通过`$which python`获知）
我们先看一下
+```bash
$ls -l /usr/bin/python
+```
-的结果:
+的结果：
+```quote
-rwxr-xr-x root root
+```quote
-
-
-我们修改权限以设置set UID和set GID位 (参考Linux用户与“最小权限”原则)
+我们修改权限以设置set UID和set GID位（参考Linux用户与“最小权限”原则）
+```bash
$sudo chmod 6755 /usr/bin/python
+```
-/usr/bin/python的权限成为:
+/usr/bin/python的权限成为：
+```quote
-rwsr-sr-x root root
+```
-
+随后，我们运行文件下面`test.py`文件，这个文件可以是由普通用户`vamei`所有：
-随后，我们运行文件下面test.py文件，这个文件可以是由普通用户vamei所有:
```python
import os
print(os.getresuid())
```
-我们得到结果:
+我们得到结果：
+
+```quote
(1000, 0, 0)
+```
-上面分别是UID，EUID，saved UID。我们只用执行一个由普通用户拥有的python脚本，就可以得到super user的权限！所以，这样做是极度危险的，我们相当于交出了系统的保护系统。想像一下Python强大的功能，别人现在可以用这些强大的功能作为攻击你的武器了！使用下面命令来恢复到从前:
+上面分别是UID，EUID，saved UID。我们只用执行一个由普通用户拥有的python脚本，就可以得到super user的权限！所以，这样做是极度危险的，我们相当于交出了系统的保护系统。想像一下Python强大的功能，别人现在可以用这些强大的功能作为攻击你的武器了！使用下面命令来恢复到从前：
+```bash
$sudo chmod 0755 /usr/bin/python
-
-
+```
关于脚本文件的saved UID/GID，更加详细的讨论见
http://www.faqs.org/faqs/unix-faq/faq/part4/section-7.html
-
-
##总结
-get*, set*
+`get*`、`set*`
-umask(), uname()
+`umask()`、`uname()`
\ No newline at end of file
diff --git a/content/STL10.md b/content/STL10.md
index 0586d1a..fc3a873 100644
--- a/content/STL10.md
+++ b/content/STL10.md
@@ -1,29 +1,32 @@
-##Python标准库10 多进程初步 (multiprocessing包)
+#Python标准库10 多进程初步（multiprocessing包）
+我们已经见过了使用`subprocess`包来创建子进程，但这个包有两个很大的局限性：
+1) 我们总是让subprocess运行外部的程序，而不是运行一个Python脚本内部编写的函数。
-
+2) 进程间只通过管道进行文本交流。以上限制了我们将`subprocess`包应用到更广泛的多进程任务。
-我们已经见过了使用subprocess包来创建子进程，但这个包有两个很大的局限性：1) 我们总是让subprocess运行外部的程序，而不是运行一个Python脚本内部编写的函数。2) 进程间只通过管道进行文本交流。以上限制了我们将subprocess包应用到更广泛的多进程任务。(这样的比较实际是不公平的，因为subprocessing本身就是设计成为一个shell，而不是一个多进程管理包)
-
-
+（这样的比较实际是不公平的，因为`subprocessing`本身就是设计成为一个shell，而不是一个多进程管理包）
##threading和multiprocessing
-(请尽量先阅读Python多线程与同步)
+（请尽量先阅读Python多线程与同步）
+
+`multiprocessing`包是Python中的多进程管理包。与`threading.Thread`类似，它可以利用`multiprocessing.Process`对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该`Process`对象与Thread对象的用法相同，也有`start()`、`run()`、`join()`的方法。
+
+此外`multiprocessing`包中也有`Lock`/`Event`/`Semaphore`/`Condition`类（这些对象可以像多线程那样，通过参数传递给各个进程），用以同步进程，其用法与`threading`包中的同名类一致。所以，`multiprocessing`的很大一部份与`threading`使用同一套API，只不过换到了多进程的情境。
-multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。
+但在使用这些共享API的时候，我们要注意以下几点：
-但在使用这些共享API的时候，我们要注意以下几点:
+在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用`wait`，否则进程成为僵尸进程（Zombie）。所以，有必要对每个`Process`对象调用`join()`方法（实际上等同于`wait`）。对于多线程来说，由于只有一个进程，所以不存在此必要性。
-在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性。
-multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。
-多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。
-Process.PID中保存有PID，如果进程还没有start()，则PID为None。
+`multiprocessing`提供了`threading`包中没有的IPC（比如Pipe和Queue），效率上更高。应优先考虑Pipe和Queue，避免使用`Lock`/`Event`/`Semaphore`/`Condition`等同步方式（因为它们占据的不是用户进程的资源）。
-
+多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和`Manager`的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。
-我们可以从下面的程序中看到Thread对象和Process对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出(stdout)输出。这样输出的字符会混合在一起，无法阅读。使用Lock同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。
+`Process.PID`中保存有PID，如果进程还没有`start()`，则PID为`None`。
+
+我们可以从下面的程序中看到`Thread`对象和`Process`对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出（stdout）输出。这样输出的字符会混合在一起，无法阅读。使用`Lock`同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。
```python
# Similarity and difference of multi thread vs. multi process
@@ -40,13 +43,13 @@ def worker(sign, lock):
lock.release()
# Main
-print('Main:',os.getpid())
+print('Main:', os.getpid())
# Multi-thread
record = []
lock = threading.Lock()
for i in range(5):
- thread = threading.Thread(target=worker,args=('thread',lock))
+ thread = threading.Thread(target=worker, args=('thread', lock))
thread.start()
record.append(thread)
@@ -57,30 +60,25 @@ for thread in record:
record = []
lock = multiprocessing.Lock()
for i in range(5):
- process = multiprocessing.Process(target=worker,args=('process',lock))
+ process = multiprocessing.Process(target=worker, args=('process', lock))
process.start()
record.append(process)
for process in record:
process.join()
```
-所有Thread的PID都与主程序相同，而每个Process都有一个不同的PID。
-(练习: 使用mutiprocessing包将Python多线程与同步中的多线程程序更改为多进程程序)
+所有`Thread`的PID都与主程序相同，而每个`Process`都有一个不同的PID。
-
+（练习：使用`mutiprocessing`包将Python多线程与同步中的多线程程序更改为多进程程序）
##Pipe和Queue
-正如我们在Linux多线程中介绍的管道PIPE和消息队列message queue，multiprocessing包中有Pipe类和Queue类来分别支持这两种IPC机制。Pipe和Queue可以用来传送常见的对象。
-
-
-
-1) Pipe可以是单向(half-duplex)，也可以是双向(duplex)。我们通过mutiprocessing.Pipe(duplex=False)创建单向管道 (默认为双向)。一个进程从PIPE一端输入对象，然后被PIPE另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。
+正如我们在Linux多线程中介绍的管道PIPE和消息队列message queue，`multiprocessing`包中有`Pipe`类和`Queue`类来分别支持这两种IPC机制。`Pipe`和`Queue`可以用来传送常见的对象。
-下面的程序展示了Pipe的使用:
+1) `Pipe`可以是单向（half-duplex），也可以是双向（duplex）。我们通过`mutiprocessing.Pipe(duplex=False)`创建单向管道（默认为双向）。一个进程从`Pipe`一端输入对象，然后被`Pipe`另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。
-
+下面的程序展示了`Pipe`的使用：
```python
# Multiprocessing with Pipe
@@ -90,10 +88,10 @@ import multiprocessing as mul
def proc1(pipe):
pipe.send('hello')
- print('proc1 rec:',pipe.recv())
+ print('proc1 rec:', pipe.recv())
def proc2(pipe):
- print('proc2 rec:',pipe.recv())
+ print('proc2 rec:', pipe.recv())
pipe.send('hello, too')
# Build a pipe
@@ -108,14 +106,13 @@ p2.start()
p1.join()
p2.join()
```
-这里的Pipe是双向的。
-Pipe对象建立的时候，返回一个含有两个元素的表，每个元素代表Pipe的一端(Connection对象)。我们对Pipe的某一端调用send()方法来传送对象，在另一端使用recv()来接收。
+这里的`Pipe`是双向的。
-
+`Pipe`对象建立的时候，返回一个含有两个元素的表，每个元素代表`Pipe`的一端（`Connection`对象）。我们对`Pipe`的某一端调用`send()`方法来传送对象，在另一端使用`recv()`来接收。
-2) Queue与Pipe相类似，都是先进先出的结构。但Queue允许多个进程放入，多个进程从队列取出对象。Queue使用mutiprocessing.Queue(maxsize)创建，maxsize表示队列中可以存放对象的最大数量。
-下面的程序展示了Queue的使用:
+2) `Queue`与`Pipe`相类似，都是先进先出的结构。但`Queue`允许多个进程放入，多个进程从队列取出对象。`Queue`使用`mutiprocessing.Queue(maxsize)`创建，`maxsize`表示队列中可以存放对象的最大数量。
+下面的程序展示了`Queue`的使用：
```python
# Written by Vamei
@@ -129,7 +126,7 @@ def inputQ(queue):
queue.put(info)
# output worker
-def outputQ(queue,lock):
+def outputQ(queue, lock):
info = queue.get()
lock.acquire()
print (str(os.getpid()) + '(get):' + info)
@@ -143,13 +140,13 @@ queue = multiprocessing.Queue(3)
# input processes
for i in range(10):
- process = multiprocessing.Process(target=inputQ,args=(queue,))
+ 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 = multiprocessing.Process(target=outputQ, args=(queue, lock))
process.start()
record2.append(process)
@@ -161,12 +158,11 @@ queue.close() # No more object will come, close the queue
for p in record2:
p.join()
```
- 一些进程使用put()在Queue中放入字符串，这个字符串中包含PID和时间。另一些进程从Queue中取出，并打印自己的PID以及get()的字符串。
-
+一些进程使用`put()`在`Queue`中放入字符串，这个字符串中包含PID和时间。另一些进程从`Queue`中取出，并打印自己的PID以及`get()`的字符串。
##总结
-Process, Lock, Event, Semaphore, Condition
+`Process`、`Lock`、`Event`、`Semaphore`、`Condition`
-Pipe, Queue
+`Pipe`、`Queue`
\ No newline at end of file
diff --git a/content/STL11.md b/content/STL11.md
index 14faf70..c31ef17 100644
--- a/content/STL11.md
+++ b/content/STL11.md
@@ -1,28 +1,14 @@
+#Python标准库11 多进程探索（multiprocessing包）
-##Python标准库11 多进程探索 (multiprocessing包)
-
-
-
-
-在初步了解Python多进程之后，我们可以继续探索multiprocessing包中更加高级的工具。这些工具可以让我们更加便利地实现多进程。
-
-
+在初步了解Python多进程之后，我们可以继续探索`multiprocessing`包中更加高级的工具。这些工具可以让我们更加便利地实现多进程。
##进程池
-进程池 (Process Pool)可以创建多个进程。这些进程就像是随时待命的士兵，准备执行任务(程序)。一个进程池中可以容纳多个待命的士兵。
-
-
-
-
+进程池（Process Pool）可以创建多个进程。这些进程就像是随时待命的士兵，准备执行任务（程序）。一个进程池中可以容纳多个待命的士兵。
“三个进程的进程池”
-
-
-
-
-比如下面的程序:
+比如下面的程序：
```python
import multiprocessing as mul
@@ -31,46 +17,40 @@ def f(x):
return x**2
pool = mul.Pool(5)
-rel = pool.map(f,[1,2,3,4,5,6,7,8,9,10])
+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()方法以获得结果。
+我们创建了一个容许5个进程的进程池（Process Pool）。`Pool`运行的每个进程都执行`f()`函数。我们利用`map()`方法，将`f()`函数作用到表的每个元素上。这与built-in的`map()`函数类似，只是这里用5个进程并行处理。如果进程运行结束后，还有需要处理的元素，那么的进程会被用于重新运行`f()`函数。除了`map()`方法外，`Pool`还有下面的常用方法。
-close() 进程池不再创建新的进程
+`apply_async(func, args)`：从进程池中取出一个进程执行`func`，`args`为`func`的参数。它将返回一个`AsyncResult`的对象，你可以对该对象调用`get()`方法以获得结果。
-join() wait进程池中的全部进程。必须对Pool先调用close()方法才能join。
+`close()`：进程池不再创建新的进程。
-
+`join()`：`wait`进程池中的全部进程。必须对`Pool`先调用`close()`方法才能`join`。
##练习
有下面一个文件download.txt。
-www.sina.com.cn
-www.163.com
-www.iciba.com
-www.cnblogs.com
-www.qq.com
-www.douban.com
-使用包含3个进程的进程池下载文件中网站的首页。(你可以使用subprocess调用wget或者curl等下载工具执行具体的下载任务)
+- www.sina.com.cn
+- www.163.com
+- www.iciba.com
+- www.cnblogs.com
+- www.qq.com
+- www.douban.com
-
+使用包含3个进程的进程池下载文件中网站的首页。（你可以使用`subprocess`调用`wget`或者`curl`等下载工具执行具体的下载任务）。
##共享资源
-我们在Python多进程初步已经提到，我们应该尽量避免多进程共享资源。多进程共享资源必然会带来进程间相互竞争。而这种竞争又会造成race condition，我们的结果有可能被竞争的不确定性所影响。但如果需要，我们依然可以通过共享内存和Manager对象这么做。
-
-
-
-
+我们在Python多进程初步已经提到，我们应该尽量避免多进程共享资源。多进程共享资源必然会带来进程间相互竞争。而这种竞争又会造成race condition，我们的结果有可能被竞争的不确定性所影响。但如果需要，我们依然可以通过共享内存和`Manager`对象这么做。
共享“资源”
共享内存
-在Linux进程间通信中，我们已经讲述了共享内存(shared memory)的原理，这里给出用Python实现的例子:
+在Linux进程间通信中，我们已经讲述了共享内存（shared memory）的原理，这里给出用Python实现的例子：
```python
# modified from official documentation
@@ -90,13 +70,12 @@ p.join()
print num.value
print arr[:]
```
-这里我们实际上只有主进程和Process对象代表的进程。我们在主进程的内存空间中创建共享的内存，也就是Value和Array两个对象。对象Value被设置成为双精度数(d), 并初始化为0.0。而Array则类似于C中的数组，有固定的类型(i, 也就是整数)。在Process进程中，我们修改了Value和Array对象。回到主程序，打印出结果，主程序也看到了两个对象的改变，说明资源确实在两个进程之间共享。
-
+这里我们实际上只有主进程和`Process`对象代表的进程。我们在主进程的内存空间中创建共享的内存，也就是`Value`和`Array`两个对象。对象`Value`被设置成为双精度数（`'d'`），并初始化为`0.0`。而`Array`则类似于C中的数组，有固定的类型（`'i'`，也就是整数）。在`Process`进程中，我们修改了`Value`和`Array`对象。回到主程序，打印出结果，主程序也看到了两个对象的改变，说明资源确实在两个进程之间共享。
Manager
-Manager对象类似于服务器与客户之间的通信 (server-client)，与我们在Internet上的活动很类似。我们用一个进程作为服务器，建立Manager来真正存放资源。其它的进程可以通过参数传递或者根据地址来访问Manager，建立连接后，操作服务器上的资源。在防火墙允许的情况下，我们完全可以将Manager运用于多计算机，从而模仿了一个真实的网络情境。下面的例子中，我们对Manager的使用类似于shared memory，但可以共享更丰富的对象类型。
+`Manager`对象类似于服务器与客户之间的通信（server-client），与我们在Internet上的活动很类似。我们用一个进程作为服务器，建立`Manager`来真正存放资源。其它的进程可以通过参数传递或者根据地址来访问`Manager`，建立连接后，操作服务器上的资源。在防火墙允许的情况下，我们完全可以将`Manager`运用于多计算机，从而模仿了一个真实的网络情境。下面的例子中，我们对`Manager`的使用类似于shared memory，但可以共享更丰富的对象类型。
```python
import multiprocessing
@@ -119,17 +98,13 @@ print(x.value)
print(arr)
print(l)
```
-Manager利用list()方法提供了表的共享方式。实际上你可以利用dict()来共享词典，Lock()来共享threading.Lock(注意，我们共享的是threading.Lock，而不是进程的mutiprocessing.Lock。后者本身已经实现了进程共享)等。 这样Manager就允许我们共享更多样的对象。
-
-
-我们在这里不深入讲解Manager在远程情况下的应用。有机会的话，会在网络应用中进一步探索。
+Manager利用`list()`方法提供了表的共享方式。实际上你可以利用`dict()`来共享词典，`Lock()`来共享`threading.Lock`（注意，我们共享的是`threading.Lock`，而不是进程的`mutiprocessing.Lock`。后者本身已经实现了进程共享）。 这样`Manager`就允许我们共享更多样的对象。
-
+我们在这里不深入讲解`Manager`在远程情况下的应用。有机会的话，会在网络应用中进一步探索。
##总结
-Pool
-
-Shared memory, Manager
+`Pool`
+Shared memory、`Manager`
\ No newline at end of file
diff --git a/content/STL12.md b/content/STL12.md
index 92ed492..fa149bf 100644
--- a/content/STL12.md
+++ b/content/STL12.md
@@ -1,119 +1,95 @@
-##Python标准库12 数学与随机数 (math包，random包)
+#Python标准库12 数学与随机数（math包、random包）
+我们已经在Python运算中看到Python最基本的数学运算功能。此外，`math`包补充了更多的函数。当然，如果想要更加高级的数学功能，可以考虑选择标准库之外的`numpy`和`scipy`项目，它们不但支持数组和矩阵运算，还有丰富的数学和物理方程可供使用。
-
-
-我们已经在Python运算中看到Python最基本的数学运算功能。此外，math包补充了更多的函数。当然，如果想要更加高级的数学功能，可以考虑选择标准库之外的numpy和scipy项目，它们不但支持数组和矩阵运算，还有丰富的数学和物理方程可供使用。
-
-此外，random包可以用来生成随机数。随机数不仅可以用于数学用途，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
-
-
+此外，`random`包可以用来生成随机数。随机数不仅可以用于数学用途，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
##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`包主要处理数学相关的运算。`math`包定义了两个常数：
-
+```python
+math.e # 自然常数e。
+math.pi # 圆周率pi。
+```
-三角函数: math.sin(x), math.cos(x), math.tan(x), math.asin(x), math.acos(x), math.atan(x)
+此外，`math`包还有各种运算函数（下面函数的功能可以参考数学手册）：
-这些函数都接收一个弧度(radian)为单位的x作为参数。
+```python
+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)`
-角度和弧度互换: math.degrees(x), math.radians(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.sinh(x)`、`math.cosh(x)`、`math.tanh(x)`、`math.asinh(x)`、`math.acosh(x)`、`math.atanh(x)`
-
-
-特殊函数： math.erf(x), math.gamma(x)
-
-
+特殊函数：`math.erf(x)`、`math.gamma(x)`
##random包
-如果你已经了解伪随机数(psudo-random number)的原理，那么你可以使用如下:
+如果你已经了解伪随机数（psudo-random number）的原理，那么你可以使用如下：
+```python
random.seed(x)
+```
-来改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
-
-
+来改变随机数生成器的种子`seed`。如果你不了解其原理，你不必特别去设定`seed`，Python会帮你选择`seed`。
1) 随机挑选和排序
-random.choice(seq) # 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
-
-random.sample(seq,k) # 从序列中随机挑选k个元素
-
-random.shuffle(seq) # 将序列的所有元素随机排序
-
-
+```python
+random.choice(seq) # 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
+random.sample(seq, k) # 从序列中随机挑选k个元素。
+random.shuffle(seq) # 将序列的所有元素随机排序。
+```
2）随机生成实数
-下面生成的实数符合均匀分布(uniform distribution)，意味着某个范围内的每个数字出现的概率相等:
+下面生成的实数符合均匀分布（uniform distribution），意味着某个范围内的每个数字出现的概率相等：
-random.random() # 随机生成下一个实数，它在[0,1)范围内。
+```python
+random.random() # 随机生成下一个实数，它在[0, 1)范围内。
+random.uniform(a, b) # 随机生成下一个实数，它在[a, b]范围内。
+```
-random.uniform(a,b) # 随机生成下一个实数，它在[a,b]范围内。
+下面生成的实数符合其它的分布（你可以参考一些统计方面的书籍来了解这些分布）：
-
+```python
+random.gauss(mu, sigma) # 随机生成符合高斯分布的随机数，mu、sigma为高斯分布的两个参数。
+random.expovariate(lambd) # 随机生成符合指数分布的随机数，lambd为指数分布的参数。
+```
-下面生成的实数符合其它的分布 (你可以参考一些统计方面的书籍来了解这些分布):
-
-random.gauss(mu,sigma) # 随机生成符合高斯分布的随机数，mu,sigma为高斯分布的两个参数。
-
-random.expovariate(lambd) # 随机生成符合指数分布的随机数，lambd为指数分布的参数。
-
-此外还有对数分布，正态分布，Pareto分布，Weibull分布，可参考下面链接:
+此外还有对数分布，正态分布，Pareto分布，Weibull分布，可参考下面链接：
http://docs.python.org/library/random.html
-
-
-假设我们有一群人参加舞蹈比赛，为了公平起见，我们要随机排列他们的出场顺序。我们下面利用random包实现：
+假设我们有一群人参加舞蹈比赛，为了公平起见，我们要随机排列他们的出场顺序。我们下面利用`random`包实现：
+```python
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)
-
+for i, name in enumerate(all_people):
+ print(i, ':' + name)
+```
##练习
-设计下面两种彩票号码生成器:
-
-1. 从1到22中随机抽取5个整数 （这5个数字不重复）
+设计下面两种彩票号码生成器：
+1. 从1到22中随机抽取5个整数（这5个数字不重复）。
2. 随机产生一个8位数字，每位数字都可以是1到6中的任意一个整数。
-
-
##总结
-math.floor(), math.sqrt(), math.sin(), math.degrees()
+`math.floor()`、`math.sqrt()`、`math.sin()`、`math.degrees()`
-random.random(), random.choice(), random.shuffle()
+`random.random()`、`random.choice()`、`random.shuffle()`
\ No newline at end of file
diff --git "a/content/STL13 \345\276\252\347\216\257\345\231\250 (itertools).md" "b/content/STL13 \345\276\252\347\216\257\345\231\250 (itertools).md"
index 2d32946..56b92e6 100644
--- "a/content/STL13 \345\276\252\347\216\257\345\231\250 (itertools).md"
+++ "b/content/STL13 \345\276\252\347\216\257\345\231\250 (itertools).md"
@@ -1,49 +1,43 @@
-Python标准库13 循环器 (itertools)
+#Python标准库13 循环器（itertools）
+在循环对象和函数对象中，我们了解了循环器（iterator）的功能。循环器是对象的容器，包含有多个对象。通过调用循环器的`next()`方法（`__next__()`方法，在Python 3.x中），循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出`StopIteration`错误。
-
+在`for i in iterator`结构中，循环器每次返回的对象将赋予给`i`，直到循环结束。使用`iter()`内置函数，我们可以将诸如表、字典等容器变为循环器。比如：
-在循环对象和函数对象中，我们了解了循环器(iterator)的功能。循环器是对象的容器，包含有多个对象。通过调用循环器的next()方法 (__next__()方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。
-
-
-
-在for i in iterator结构中，循环器每次返回的对象将赋予给i，直到循环结束。使用iter()内置函数，我们可以将诸如表、字典等容器变为循环器。比如
```python
for i in iter([2, 4, 5, 6]):
print(i)
```
-标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。
+标准库中的`itertools`包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。
+```python
# import the tools
from itertools import *
-
+```
##无穷循环器
-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也可以有一个次数限制:
+```python
+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(10, 5) #重复10，共重复5次
+repeat也可以有一个次数限制：
-
+```python
+repeat(10, 5) #重复10，共重复5次。
+```
##函数式工具
-函数式编程是将函数本身作为处理对象的编程范式。在Python中，函数也是对象，因此可以轻松的进行一些函数式的处理，比如map(), filter(), reduce()函数。
+函数式编程是将函数本身作为处理对象的编程范式。在Python中，函数也是对象，因此可以轻松的进行一些函数式的处理，比如`map()`、`filter()`、`reduce()`函数。
-itertools包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。
+`itertools`包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。
-
+比如：
-比如
```python
from itertools import *
@@ -52,79 +46,83 @@ 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()依次作用于后面两个列表的每个元素，并收集函数结果，组成返回的循环器。
-此外，还可以用下面的函数:
+上面显示了`imap`函数。该函数与`map()`函数功能相似，只不过返回的不是序列，而是一个循环器。包含元素`1`、`4`、`27`，即`1**1`、`2**2`、`3**3`的结果。函数`pow`（内置的乘方函数）作为第一个参数。`pow()`依次作用于后面两个列表的每个元素，并收集函数结果，组成返回的循环器。
+此外，还可以用下面的函数：
+
+```python
starmap(pow, [(1, 1), (2, 2), (3, 3)])
+```
-pow将依次作用于表的每个tuple。
+`pow`将依次作用于表的每个`tuple`。
-
+`ifilter`函数与`filter()`函数类似，只是返回的是一个循环器。
-ifilter函数与filter()函数类似，只是返回的是一个循环器。
```python
ifilter(lambda x: x > 5, [2, 3, 5, 6, 7]
```
-将lambda函数依次作用于每个元素，如果函数返回True，则收集原来的元素。6, 7
-此外，
+将`lambda`函数依次作用于每个元素，如果函数返回`True`，则收集原来的元素。返回`6`、`7`。
-ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7])
+此外：
-与上面类似，但收集返回False的元素。2, 3, 5
+```python
+ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7])
+```
-
+与上面类似，但收集返回`False`的元素。`2`、`3`、`5`。
+```python
takewhile(lambda x: x < 5, [1, 3, 6, 7, 1])
+```
-当函数返回True时，收集元素到循环器。一旦函数返回False，则停止。1, 3
-
-
+当函数返回`True`时，收集元素到循环器。一旦函数返回`False`，则停止。返回`1`、`3`。
+```python
dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])
+```
-当函数返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器。6, 7, 1
-
-
+当函数返回`False`时，跳过元素。一旦函数返回`True`，则开始收集剩下的所有元素到循环器。返回`6`、`7`、`1`。
##组合工具
我们可以通过组合原有循环器，来获得新的循环器。
-chain([1, 2, 3], [4, 5, 7]) # 连接两个循环器成为一个。1, 2, 3, 4, 5, 7
-
-
+```python
+chain([1, 2, 3], [4, 5, 7]) # 连接两个循环器成为一个。1, 2, 3, 4, 5, 7。
+```
-product('abc', [1, 2]) # 多个循环器集合的笛卡尔积。相当于嵌套循环
+```python
+product('abc', [1, 2]) # 多个循环器集合的笛卡尔积。相当于嵌套循环。
+```
+```python
for m, n in product('abc', [1, 2]):
print m, n
-
-
-
+```
+```python
permutations('abc', 2) # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。
+```
-注意，上面的组合分顺序，即ab, ba都返回。
-
-
+注意，上面的组合分顺序，即`'ab'`、`'ba'`都返回。
+```python
combinations('abc', 2) # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。
+```
-注意，上面的组合不分顺序，即ab, ba的话，只返回一个ab。
-
-
-
-combinations_with_replacement('abc', 2) # 与上面类似，但允许两次选出的元素重复。即多了aa, bb, cc
+注意，上面的组合不分顺序，即`'ab'`、`'ba'`的话，只返回一个`'ab'`。
-
+```python
+combinations_with_replacement('abc', 2) # 与上面类似，但允许两次选出的元素重复。即多了'aa', 'bb', 'cc'
+```
##groupby()
-将key函数作用于原循环器的各个元素。根据key函数结果，将拥有相同函数结果的元素分到一个新的循环器。每个新的循环器以函数返回结果为标签。
+将`key`函数作用于原循环器的各个元素。根据`key`函数结果，将拥有相同函数结果的元素分到一个新的循环器。每个新的循环器以函数返回结果为标签。
-这就好像一群人的身高作为循环器。我们可以使用这样一个key函数: 如果身高大于180，返回"tall"；如果身高底于160，返回"short";中间的返回"middle"。最终，所有身高将分为三个循环器，即"tall", "short", "middle"。
+这就好像一群人的身高作为循环器。我们可以使用这样一个`key`函数：如果身高大于`180`，返回`"tall"`；如果身高底于`160`，返回`"short"`;中间的返回`"middle"`。最终，所有身高将分为三个循环器，即`"tall"`、`"short"`、`"middle"`。
```python
def height_class(h):
@@ -142,20 +140,17 @@ for m, n in groupby(friends, key = height_class):
print(m)
print(list(n))
```
-注意，groupby的功能类似于UNIX中的uniq命令。分组之前需要使用sorted()对原循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。
-
+注意，groupby的功能类似于UNIX中的`uniq`命令。分组之前需要使用`sorted()`对原循环器的元素，根据`key`函数进行排序，让同组元素先在位置上靠拢。
##其它工具
-compress('ABCD', [1, 1, 1, 0]) # 根据[1, 1, 1, 0]的真假值情况，选择第一个参数'ABCD'中的元素。A, B, C
-
-islice() # 类似于slice()函数，只是返回的是一个循环器
-
+```python
+compress('ABCD', [1, 1, 1, 0]) # 根据[1, 1, 1, 0]的真假值情况，选择第一个参数'ABCD'中的元素。A, B, C。
+islice() # 类似于slice()函数，只是返回的是一个循环器。
izip() # 类似于zip()函数，只是返回的是一个循环器。
-
-
+```
##总结
-itertools的工具都可以自行实现。itertools只是提供了更加成形的解决方案。
+`itertools`的工具都可以自行实现。`itertools`只是提供了更加成形的解决方案。
\ No newline at end of file
diff --git a/content/intermediate01.md b/content/intermediate01.md
index 01ab3f8..05371bc 100644
--- a/content/intermediate01.md
+++ b/content/intermediate01.md
@@ -4,123 +4,116 @@
进阶教程对基础教程的进一步拓展，说明Python的细节。希望在进阶教程之后，你对Python有一个更全面的认识。
-
-
-之前我们说了，列表是Python里的一个类。一个特定的表，比如说nl = [1,3,8]，就是这个类的一个对象。我们可以调用这个对象的一些方法，比如 nl.append(15)。
-我们要介绍一个新的类，词典 (dictionary)。与列表相似，词典也可以储存多个元素。这种储存多个元素的对象称为容器(container)。
-
-
+之前我们说了，列表是Python里的一个类。一个特定的表，比如说`nl = [1, 3, 8]`，就是这个类的一个对象。我们可以调用这个对象的一些方法，比如 `nl.append(15)`。
+我们要介绍一个新的类，词典（dictionary）。与列表相似，词典也可以储存多个元素。这种储存多个元素的对象称为容器（container）。
##基本概念
-常见的创建词典的方法:
-```python
->>>dic = {'tom':11, 'sam':57,'lily':100}
+常见的创建词典的方法：
->>>print type(dic)
+```python
+dic = {'tom':11, 'sam':57, 'lily':100}
+print type(dic)
```
-词典和表类似的地方，是包含有多个元素，每个元素以逗号分隔。但词典的元素包含有两部分，键和值，常见的是以字符串来表示键，也可以使用数字或者真值来表示键（不可变的对象可以作为键）。值可以是任意对象。键和值两者一一对应。
-
-
-比如上面的例子中，'tom'对应11，'sam'对应57，'lily'对应100
+词典和表类似的地方，是包含有多个元素，每个元素以逗号分隔。但词典的元素包含有两部分，键和值，常见的是以字符串来表示键，也可以使用数字或者真值来表示键（不可变的对象可以作为键）。值可以是任意对象。键和值两者一一对应。
-
+比如上面的例子中，`tom`对应`11`，`sam`对应`57`，`lily`对应`100`。
与表不同的是，词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用。
-```python
->>>print dic['tom']
-
->>>dic['tom'] = 30
->>>print dic
+```python
+print dic['tom']
+dic['tom'] = 30
+print dic
```
-
构建一个新的空的词典：
-```python
->>>dic = {}
->>>print dic
+```python
+dic = {}
+print dic
```
-
在词典中增添一个新元素的方法：
-```python
->>>dic['lilei'] = 99
->>>print dic
+```python
+dic['lilei'] = 99
+print dic
```
-这里，我们引用一个新的键，并赋予它对应的值。
-
+这里，我们引用一个新的键，并赋予它对应的值。
##词典元素的循环调用
+
```python
-dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}
+dic = {'lilei':90, 'lily':100, 'sam':57, 'tom':90}
for key in dic:
print dic[key]
```
-在循环中，dict的每个键，被提取出来，赋予给key变量。
-
-通过print的结果，我们可以再次确认，dic中的元素是没有顺序的。
+在循环中，`dic`的每个键，被提取出来，赋予给`key`变量。
+通过`print`的结果，我们可以再次确认，`dic`中的元素是没有顺序的。
词典的遍历也可以同时取出键和值：
+
```python
for key,value in dict_od.items():
print key , value , '\n'
```
##词典的常用方法
-```python
->>>print dic.keys() # 返回dic所有的键
-
->>>print dic.values() # 返回dic所有的值
->>>print dic.items() # 返回dic所有的元素（键值对）
-
->>>dic.clear() # 清空dic，dict变为{}
+```python
+print dic.keys() # 返回dic所有的键
+print dic.values() # 返回dic所有的值
+print dic.items() # 返回dic所有的元素（键值对）
+dic.clear() # 清空dic，dict变为{}
```
-
另外有一个很常用的用法：
+
```python
->>>del dic['tom'] # 删除 dic 的‘tom’元素
+del dic['tom'] # 删除 dic 的‘tom’元素
```
-del是Python中保留的关键字，用于删除对象。
-
+`del`是Python中保留的关键字，用于删除对象。
+
+与表类似，你可以用`len()`查询词典中的元素总数。
-与表类似，你可以用len()查询词典中的元素总数。
```python
->>>print(len(dic))
+print(len(dic))
```
## 词典排序
+
前面我们已经谈到，词典是无序的，那么，如果需要词典内容有序，就需要使用排序方法：
-词典按key排序，排序后的结果存放到列表中:（这里用到了列表推导式)
+词典按`key`排序，排序后的结果存放到列表中：（这里用到了列表推导式)
```python
listRes = sorted([(k, v) for k, v in dict_rate.items()], reverse=True)
```
-词典按value排序，排序后的结果存放到列表中：
+词典按`value`排序，排序后的结果存放到列表中：
+
```python
-listRes = sorted([(v, k) for k, v in dict_rate.items()], reverse=True
+listRes = sorted([(v, k) for k, v in dict_rate.items()], reverse=True)
```
##总结
词典的每个元素是键值对。元素没有顺序。
+
```python
dic = {'tom':11, 'sam':57,'lily':100}
-
dic['tom'] = 99
+```python
for key in dic: ...
+```
+```python
del, len()
-```
+```
\ No newline at end of file
diff --git a/content/intermediate02.md b/content/intermediate02.md
index a300b79..0b43812 100644
--- a/content/intermediate02.md
+++ b/content/intermediate02.md
@@ -1,77 +1,67 @@
#Python进阶02 文本文件的输入输出
-
-
-
-
Python具有基本的文本文件读写功能。Python的标准库提供有更丰富的读写功能。
-文本文件的读写主要通过open()所构建的文件对象来实现。
-
-
+文本文件的读写主要通过`open()`所构建的文件对象来实现。
##创建文件对象
我们打开一个文件，并使用一个对象来表示该文件：
+
```python
f = open(文件名，模式)
```
-
最常用的模式有：
-```python
-"r" # 只读
+```quote
+"r" # 只读
"w" # 写入
-
"a" # 追加
```
-
+比如：
-比如
```python
->>>f = open("test.txt","r")
+f = open("test.txt", "r")
```
-
##文件对象的方法
读取：
+
```python
content = f.read(N) # 读取N bytes的数据
-
content = f.readline() # 读取一行
-
content = f.readlines() # 读取所有行，储存在列表中，每个元素是一行。
```
Pythonic:
读取文件更简洁的写法：
+
```python
-datafile = open('datafile',"r")
+datafile = open('datafile', "r")
for line in datafile:
do_something(line)
```
写入：
+
```python
f.write('I like apple') # 将'I like apple'写入文件
```
-
关闭文件：
+
```python
f.close()
```
##总结
-```python
-f = open(name, "r")
+```python
+f = open(name, "r")
line = f.readline()
-
f.write('abc')
-
f.close()
-```
+```
\ No newline at end of file
diff --git a/content/intermediate03.md b/content/intermediate03.md
index 553cef8..9956da9 100644
--- a/content/intermediate03.md
+++ b/content/intermediate03.md
@@ -1,80 +1,73 @@
#Python进阶03 模块
-
-
-
-
我们之前看到了函数和对象。从本质上来说，它们都是为了更好的组织已经有的程序，以方便重复利用。
-模块(module)也是为了同样的目的。在Python中，一个.py文件就构成一个模块。通过模块，你可以调用其它文件中的程序。
-
-
+模块（module）也是为了同样的目的。在Python中，一个`.py`文件就构成一个模块。通过模块，你可以调用其它文件中的程序。
##引入模块
-我们先写一个first.py文件，内容如下：
+我们先写一个`first.py`文件，内容如下：
+
```python
def laugh():
print 'HaHaHaHa'
```
-再写一个second.py，并引入first中的程序：
+再写一个`second.py`，并引入`first`中的程序：
+
```python
import first
for i in range(10):
first.laugh()
```
-在second.py中，我们使用了first.py中定义的laugh()函数。
-
+在`second.py`中，我们使用了`first.py`中定义的`laugh()`函数。
-引入模块后，可以通过模块.对象的方式来调用引入模块中的某个对象。上面例子中，first为引入的模块，laugh()是我们所引入的对象。
+引入模块后，可以通过`模块.对象`的方式来调用引入模块中的某个对象。上面例子中，`first`为引入的模块，`laugh()`是我们所引入的对象。
+
+Python中还有其它的引入方式：
-Python中还有其它的引入方式,
```python
import a as b # 引入模块a，并将模块a重命名为b
-
-from a import function1 # 从模块a中引入function1对象。调用a中对象时，我们不用再说明模块，即直接使用function1，而不是a.function1。
-
+from a import myFunc # 从模块a中引入myFunc对象。调用a中对象时，我们不用再说明模块，即直接使用myFunc，而不是a.myFunc。
from a import * # 从模块a中引入所有对象。调用a中对象时，我们不用再说明模块，即直接使用对象，而不是a.对象。
```
-这些引用方式，可以方便后面的程序书写。
-
+这些引用方式，可以方便后面的程序书写。
##搜索路径
Python会在以下路径中搜索它想要寻找的模块：
-程序所在的文件夹
-标准库的安装路径
-操作系统环境变量PYTHONPATH所包含的路径
-
+- 程序所在的文件夹
-如果你有自定义的模块，或者下载的模块，可以根据情况放在相应的路径，以便Python可以找到。
+- 标准库的安装路径
+
+- 操作系统环境变量`PYTHONPATH`所包含的路径
-
+如果你有自定义的模块，或者下载的模块，可以根据情况放在相应的路径，以便Python可以找到。
模块包
-可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。通过
+可以将功能相似的模块放在同一个文件夹（比如说`this_dir`）中，构成一个模块包。通过：
+
```python
import this_dir.module
```
-引入this_dir文件夹中的module模块。
-
-
-该文件夹中必须包含一个__init__.py的文件，提醒Python，该文件夹为一个模块包。__init__.py可以是一个空文件。
+引入`this_dir`文件夹中的`module`模块。
-
+该文件夹中必须包含一个`__init__.py`的文件，提醒Python，该文件夹为一个模块包。`__init__.py`可以是一个空文件。
##总结
+
```
import module
+```
+```
module.object
-
-__init__.py
```
+
+__init__.py
\ No newline at end of file
diff --git a/content/intermediate04.md b/content/intermediate04.md
index bd625f0..97ce1cd 100644
--- a/content/intermediate04.md
+++ b/content/intermediate04.md
@@ -1,123 +1,115 @@
#Python进阶04 函数的参数对应
-
-
-我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置，传递对应的参数。我们将接触更多的参数传递方式。
-
-
+我们已经接触过函数（function）的参数（arguments）传递。当时我们根据位置，传递对应的参数。我们将接触更多的参数传递方式。
回忆一下位置传递：
+
```python
-def f(a,b,c):
- return a+b+c
+def f(a, b, c):
+ return a + b + c
-print(f(1,2,3))
+print(f(1, 2, 3))
```
-在调用f时，1，2，3根据位置分别传递给了a,b,c。
-
+在调用`f`时，`1`、`2`、`3`根据位置分别传递给了`a`、`b`、`c`。
##关键字传递
-有些情况下，用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面f的定义，更改调用方式：
+有些情况下，用位置传递会感觉比较死板。关键字（keyword）传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面`f`的定义，更改调用方式：
+
```python
-print(f(c=3,b=2,a=1))
+print(f(c=3, b=2, a=1))
```
关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前：
+
```python
print(f(1,c=3,b=2))
```
##参数默认值
-在定义函数的时候，使用形如a=19的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。
+在定义函数的时候，使用形如`a=19`的方式，可以给参数赋予默认值（default）。如果该参数最终没有被传递值，将使用该默认值。
+
```python
-def f(a,b,c=10):
- return a+b+c
+def f(a, b, c=10):
+ return a + b + c
-print(f(3,2))
-print(f(3,2,1))
+print(f(3, 2))
+print(f(3, 2, 1))
```
-在第一次调用函数f时， 我们并没有足够的值，c没有被赋值，c将使用默认值10.
-第二次调用函数的时候，c被赋值为1，不再使用默认值。
+在第一次调用函数f时，我们并没有足够的值，`c`没有被赋值，`c`将使用默认值`10`。
-
+第二次调用函数的时候，`c`被赋值为`1`，不再使用默认值。
##包裹传递
-在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。
-
-
+在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。
下面是包裹位置传递的例子：
+
```python
def func(*name):
print type(name)
print name
-func(1,4,6)
-func(5,6,7,1,2,3)
+func(1, 4, 6)
+func(5, 6, 7, 1, 2, 3)
```
-两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。
-为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。
+两次调用，尽管参数个数不同，都基于同一个`func`定义。在`func`的参数表中，所有的参数被`name`收集，根据位置合并成一个元组（tuple），这就是包裹位置传递。
-
+为了提醒Python参数，`name`是包裹位置传递所用的元组名，在定义`func`时，在`name`前加`*`号。
下面是包裹关键字传递的例子：
-``python
+
+```python
def func(**dict):
print type(dict)
print dict
-func(a=1,b=9)
-func(m=2,n=1,c=11)
+func(a=1, b=9)
+func(m=2, n=1, c=11)
```
-与上面一个例子类似，dict是一个字典，收集所有的关键字，传递给函数func。为了提醒Python，参数dict是包裹关键字传递所用的字典，在dict前加**。
-包裹传递的关键在于定义函数时，在相应元组或字典前加*或**。
+与上面一个例子类似，`dict`是一个字典，收集所有的关键字，传递给函数`func`。为了提醒Python，参数`dict`是包裹关键字传递所用的字典，在`dict`前加`**`。
-
+包裹传递的关键在于定义函数时，在相应元组或字典前加`*`或`**`。
##解包裹
-*和**，也可以在调用的时候使用，即解包裹(unpacking), 下面为例：
+`*`和`**`，也可以在调用的时候使用，即解包裹（unpacking），下面为例：
+
```python
-def func(a,b,c):
- print a,b,c
+def func(a, b, c):
+ print a, b, c
-args = (1,3,4)
+args = (1, 3, 4)
func(*args)
```
-在这个例子中，所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数。在调用func时使用*，是为了提醒Python：我想要把args拆成分散的三个元素，分别传递给a,b,c。（设想一下在调用func时，args前面没有*会是什么后果？）
-
+在这个例子中，所谓的解包裹，就是在传递`tuple`时，让`tuple`的每一个元素对应一个位置参数。在调用`func`时使用`*`，是为了提醒Python：我想要把`args`拆成分散的三个元素，分别传递给`a`、`b`、`c`。（设想一下在调用`func`时，`args`前面没有`*`会是什么后果？）
+
+相应的，也存在对词典的解包裹，使用相同的`func`定义，然后：
-相应的，也存在对词典的解包裹，使用相同的func定义，然后：
```python
-dict = {'a':1,'b':2,'c':3}
+dict = {'a':1, 'b':2, 'c':3}
func(**dict)
```
-在传递词典dict时，让词典的每个键值对作为一个关键字传递给func。
-
+在传递词典`dict`时，让词典的每个键值对作为一个关键字传递给`func`。
##混合
在定义或者调用参数时，参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是，先位置，再关键字，再包裹位置，再包裹关键字，并且根据上面所说的原理细细分辨。
-
-
注意：请注意定义时和调用时的区分。包裹和解包裹并不是相反操作，是两个相对独立的过程。
-
-
##总结
-关键字，默认值，
+关键字，默认值。
-包裹位置，包裹关键字
+包裹位置，包裹关键字。
-解包裹
+解包裹。
\ No newline at end of file
diff --git a/content/intermediate05.md b/content/intermediate05.md
index d7d1dbe..5f8817d 100644
--- a/content/intermediate05.md
+++ b/content/intermediate05.md
@@ -1,68 +1,65 @@
#Python进阶05 循环设计
-
-
-
在“循环”一节，我们已经讨论了Python基本的循环语法。这一节，我们将接触更加灵活的循环方式。
-
-
##range()
-在Python中，for循环后的in跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。
+在Python中，`for`循环后的`in`跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。
+
+之前我们已经使用过`range()`来控制`for`循环。现在，我们继续开发`range`的功能，以实现下标对循环的控制：
-之前我们已经使用过range()来控制for循环。现在，我们继续开发range的功能，以实现下标对循环的控制：
```python
S = 'abcdefghijk'
-for i in range(0,len(S),2):
+for i in range(0, len(S), 2):
print S[i]
```
-在该例子中，我们利用len()函数和range()函数，用i作为S序列的下标来控制循环。在range函数中，分别定义上限，下限和每次循环的步长。这就和C语言中的for循环相类似了。
-
+在该例子中，我们利用`len()`函数和`range()`函数，用i作为S序列的下标来控制循环。在`range`函数中，分别定义上限，下限和每次循环的步长。这就和C语言中的for循环相类似了。
##enumerate()
-利用enumerate()函数，可以在每次循环中同时得到下标和元素：
+利用`enumerate()`函数，可以在每次循环中同时得到下标和元素：
+
```python
S = 'abcdefghijk'
-for (index,char) in enumerate(S):
+for (index, char) in enumerate(S):
print index
print char
```
-实际上，enumerate()在每次循环中，返回的是一个包含两个元素的定值表(tuple)，两个元素分别赋予index和char
-增加下标的访问设计
-在python 3.2中，支持enumerate带第二个参数，用来指定循环的开始位置，比如，从第一个下标位置开始循环：
+实际上，`enumerate()`在每次循环中，返回的是一个包含两个元素的定值表(`tuple`)，两个元素分别赋予`index`和`char`，增加下标的访问设计。
+
+在python 3.2中，支持`enumerate`带第二个参数，用来指定循环的开始位置，比如，从第一个下标位置开始循环：
+
```python
array = [1, 2, 3, 4, 5]
-for i, e in enumerate(array,1):
+for i, e in enumerate(array, 1):
print i, e
```
-
##zip()
-如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：
+如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用`zip()`方便地实现：
+
```python
-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)
+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()函数起到了聚合列表的功能。
+每次循环时，从各个序列分别从左到右取出一个元素，合并成一个`tuple`，然后`tuple`的元素赋予给`a`、`b`、`c`。
-
+`zip()`函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的（来自不同列表的）元素合成一个元组，合并成的元组放入`zip()`返回的列表中。`zip()`函数起到了聚合列表的功能。
我们可以分解聚合后的列表，如下:
+
```python
-ta = [1,2,3]
-tb = [9,8,7]
+ta = [1, 2, 3]
+tb = [9, 8, 7]
# cluster
zipped = zip(ta,tb)
@@ -73,11 +70,10 @@ na, nb = zip(*zipped)
print(na, nb)
```
-
##总结
-range()
+`range()`
-enumerate()
+`enumerate()`
-zip()
+`zip()`
diff --git a/content/intermediate06.md b/content/intermediate06.md
index 09a0de1..7b382ac 100644
--- a/content/intermediate06.md
+++ b/content/intermediate06.md
@@ -1,123 +1,119 @@
#Python进阶06 循环对象
-
-
-
-
这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。
循环对象的并不是随着Python的诞生就存在的，但它的发展迅速，特别是Python 3x的时代，循环对象正在成为循环的标准形式。
-
-
##什么是循环对象
-循环对象是这样一个对象，它包含有一个next()方法(__next__()方法，在python 3x中)， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration错误。
+循环对象是这样一个对象，它包含有一个`next()`方法(`__next__()`方法，在python 3x中)， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出`StopIteration`错误。
-当一个循环结构（比如for）调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()。
+当一个循环结构（比如`for`）调用循环对象时，它就会每次循环的时候调用`next()`方法，直到`StopIteration`出现，`for`循环接收到，就知道循环已经结束，停止调用`next()`。
+
+假设我们有一个`test.txt`的文件：
-假设我们有一个test.txt的文件:
```bash
1234
abcd
efg
```
-我们运行一下python命令行：
-```python
->>>f = open('test.txt')
-
->>>f.next()
->>>f.next()
+我们运行一下python命令行：
+```python
+f = open('test.txt')
+f.next()
+f.next()
...
```
-不断输入f.next()，直到最后出现StopIteration
+不断输入`f.next()`，直到最后出现`StopIteration`。
-open()返回的实际上是一个循环对象，包含有next()方法。而该next()方法每次返回的就是新的一行的内容，到达文件结尾时举出StopIteration。这样，我们相当于手工进行了循环。
+`open()`返回的实际上是一个循环对象，包含有`next()`方法。而该`next()`方法每次返回的就是新的一行的内容，到达文件结尾时举出`StopIteration`。这样，我们相当于手工进行了循环。
自动进行的话，就是：
+
```python
for line in open('test.txt'):
print line
```
-在这里，for结构自动调用next()方法，将该方法的返回值赋予给line。循环知道出现StopIteration的时候结束。
-
+在这里，`for`结构自动调用`next()`方法，将该方法的返回值赋予给`line`。循环知道出现`StopIteration`的时候结束。
相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。
-
-
##迭代器
-从技术上来说，循环对象和for循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。
-
-
+从技术上来说，循环对象和`for`循环调用之间还有一个中间层，就是要将循环对象转换成迭代器（iterator）。这一转换是通过使用`iter()`函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。
##生成器
-生成器(generator)的主要目的是构成一个用户自定义的循环对象。
+生成器（generator）的主要目的是构成一个用户自定义的循环对象。
-生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。
+生成器的编写方法和函数定义类似，只是在`return`的地方改为`yield`。生成器中可以有多个`yield`。当生成器遇到一个`yield`时，会暂停运行生成器，返回`yield`后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个`yield`。生成器自身又构成一个循环器，每次循环使用一个`yield`返回的值。
-
+下面是一个生成器：
-下面是一个生成器:
```python
def gen():
a = 100
yield a
- a = a*8
+ a = a * 8
yield a
yield 1000
```
-该生成器共有三个yield， 如果用作循环器时，会进行三次循环。
+
+该生成器共有三个`yield`， 如果用作循环器时，会进行三次循环。
+
```python
for i in gen():
print i
```
-再考虑如下一个生成器:
+再考虑如下一个生成器：
+```python
def gen():
for i in range(4):
yield i
-它又可以写成生成器表达式(Generator Expression):
+```
+它又可以写成生成器表达式（Generator Expression）：
+
+```python
G = (x for x in range(4))
-生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。
+```
-
+生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。
##表推导
-表推导(list comprehension)是快速生成表的方法。它的语法简单，很有实用价值。
-
-
+表推导（list comprehension）是快速生成表的方法。它的语法简单，很有实用价值。
假设我们生成表L：
+
```python
L = []
for x in range(10):
- L.append(x**2)
+ L.append(x ** 2)
```
-以上产生了表L，但实际上有快捷的写法，也就是表推导的方式:
+
+以上产生了表`L`，但实际上有快捷的写法，也就是表推导的方式：
+
```python
-L = [x**2 for x in range(10)]
+L = [x ** 2 for x in range(10)]
```
+
这与生成器表达式类似，只不过用的是中括号。
（表推导的机制实际上是利用循环对象，有兴趣可以查阅。）
-
-
练习 下面的表推导会生成什么？
+
```python
-xl = [1,3,5]
-yl = [9,12,13]
-L = [ x**2 for (x,y) in zip(xl,yl) if y > 10]
+xl = [1, 3, 5]
+yl = [9, 12, 13]
+L = [x ** 2 for (x, y) in zip(xl, yl) if y > 10]
```
##总结
@@ -126,6 +122,4 @@ L = [ x**2 for (x,y) in zip(xl,yl) if y > 10]
生成器
-表推导
-
-
+表推导
\ No newline at end of file
diff --git a/content/intermediate07.md b/content/intermediate07.md
index 43c5f49..05aa59b 100644
--- a/content/intermediate07.md
+++ b/content/intermediate07.md
@@ -1,25 +1,20 @@
#Python进阶07 函数对象
-
-
-
-
-秉承着一切皆对象的理念，我们再次回头来看函数(function)。函数也是一个对象，具有属性（可以使用dir()查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
-
-
+秉承着一切皆对象的理念，我们再次回头来看函数（function）。函数也是一个对象，具有属性（可以使用`dir()`查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
##lambda函数
-在展开之前，我们先提一下lambda函数。可以利用lambda函数的语法，定义函数。lambda例子如下：
+在展开之前，我们先提一下`lambda`函数。可以利用`lambda`函数的语法，定义函数。`lambda`例子如下：
+
```python
-func = lambda x,y: x + y
-print func(3,4)
+func = lambda x, y: x + y
+print func(3, 4)
```
-lambda生成一个函数对象。该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。
-
+`lambda`生成一个函数对象。该函数参数为`x`、`y`，返回值为`x + y`。函数对象赋给`func`。`func`的调用与正常函数无异。
以上定义可以写成以下形式：
+
```python
def func(x, y):
return x + y
@@ -27,7 +22,8 @@ def func(x, y):
##函数作为参数传递
-函数可以作为一个对象，进行参数传递。函数名(比如func)即该对象。比如说:
+函数可以作为一个对象，进行参数传递。函数名（比如`func`），即该对象。比如说：
+
```python
def test(f, a, b):
print 'test'
@@ -35,42 +31,40 @@ def test(f, a, b):
test(func, 3, 5)
```
-test函数的第一个参数f就是一个函数对象。将func传递给f，test中的f()就拥有了func()的功能。
-
+`test`函数的第一个参数`f`就是一个函数对象。将`func`传递给`f`，`test`中的`f()`就拥有了`func()`的功能。
+
+我们因此可以提高程序的灵活性。可以使用上面的`test`函数，带入不同的函数参数。比如：
-我们因此可以提高程序的灵活性。可以使用上面的test函数，带入不同的函数参数。比如:
```python
-test((lambda x,y: x**2 + y), 6, 9)
+test((lambda x, y: x ** 2 + y), 6, 9)
```
##map()函数
-map()是Python的内置函数。它的第一个参数是一个函数对象。
+`map()`是Python的内置函数。它的第一个参数是一个函数对象。
+
```python
-re = map((lambda x: x+3),[1,3,5,6])
+re = map((lambda x: x + 3), [1, 3, 5, 6])
```
-这里，map()有两个参数，一个是lambda所定义的函数对象，一个是包含有多个元素的表。map()的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表re中。map通过读入的函数(这里是lambda函数)来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加3）。
-在Python 3.X中，map()的返回值是一个循环对象。可以利用list()函数，将该循环对象转换成表。
+这里，`map()`有两个参数，一个是`lambda`所定义的函数对象，一个是包含有多个元素的表。`map()`的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表`re`中。`map()`通过读入的函数（这里是`lambda`函数）来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加`3`）。
+
+在Python 3.X中，`map()`的返回值是一个循环对象。可以利用`list()`函数，将该循环对象转换成表。
-
+如果作为参数的函数对象有多个参数，可使用下面的方式，向`map()`传递函数参数的多个参数：
-如果作为参数的函数对象有多个参数，可使用下面的方式，向map()传递函数参数的多个参数：
```python
-re = map((lambda x,y: x+y),[1,2,3],[6,7,9])
+re = map((lambda x, y: x + y),[1, 2, 3], [6, 7, 9])
```
-map()将每次从两个表中分别取出一个元素，带入lambda所定义的函数。
-
+`map()`将每次从两个表中分别取出一个元素，带入`lambda`所定义的函数。
##filter()函数
-filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True，则该次的元素被储存于返回的表中。filter通过读入的函数来筛选数据。同样，在Python 3.X中，filter返回的不是表，而是循环对象。
+`filter`函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是`True`，则该次的元素被储存于返回的表中。`filter`通过读入的函数来筛选数据。同样，在Python 3.X中，`filter`返回的不是表，而是循环对象。
-
-
-filter函数的使用如下例:
+`filter`函数的使用如下例：
```python
def func(a):
@@ -79,36 +73,33 @@ def func(a):
else:
return False
-print filter(func,[10,56,101,500])
+print filter(func,[10, 56, 101, 500])
```
-
##reduce()函数
-reduce函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。如下例：
+`reduce`函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。`reduce`可以累进地将函数作用于各个参数。如下例：
+
```python
-print reduce((lambda x,y: x+y),[1,2,5,7,9])
+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`的第一个参数是`lambda`函数，它接收两个参数`x`、`y`，返回`x + y`。
-
+`reduce`将表中的前两个元素(`1`和`2`)传递给`lambda`函数，得到`3`。该返回值(`3`)将作为`lambda`函数的第一个参数，而表中的下一个元素(`5`)作为`lambda`函数的第二个参数，进行下一次的对`lambda`函数的调用，得到`8`。依次调用`lambda`函数，每次`lambda`函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。
-根据mmufhy的提醒： reduce()函数在3.0里面不能直接用的，它被定义在了functools包里面，需要引入包，见评论区。
+上面例子，相当于`(((1 + 2) + 5) + 7) + 9`
-
+根据mmufhy的提醒： `reduce()`函数在3.0里面不能直接用的，它被定义在了`functools`包里面，需要引入包，见评论区。
##总结
函数是一个对象
-用lambda定义函数
+用`lambda`定义函数
-map()
+`map()`
-filter()
+`filter()`
-reduce()
+`reduce()`
\ No newline at end of file
diff --git a/content/intermediate08.md b/content/intermediate08.md
index 8c449de..c9f8bb2 100644
--- a/content/intermediate08.md
+++ b/content/intermediate08.md
@@ -1,17 +1,15 @@
#Python进阶08 异常处理
-
-
-
##异常处理
在项目开发中，异常处理是不可或缺的。异常处理帮助人们debug，通过更加丰富的信息，让人们更容易找到bug的所在。异常处理还可以提高程序的容错性。
-我们之前在讲循环对象的时候，曾提到一个StopIteration的异常，该异常是在循环对象穷尽所有元素时的报错。
+我们之前在讲循环对象的时候，曾提到一个`StopIteration`的异常，该异常是在循环对象穷尽所有元素时的报错。
我们以它为例，来说明基本的异常处理。
-一个包含异常的程序:
+一个包含异常的程序：
+
```python
re = iter(range(5))
@@ -20,13 +18,13 @@ for i in range(100):
print 'HaHaHaHa'
```
-首先，我们定义了一个循环对象re，该循环对象将进行5次循环，每次使用序列的一个元素。
-在随后的for循环中，我们手工调用next()函数。当循环进行到第6次的时候，re.next()不会再返回元素，而是抛出(raise)StopIteration的异常。整个程序将会中断。
+首先，我们定义了一个循环对象`re`，该循环对象将进行`5`次循环，每次使用序列的一个元素。
-
+在随后的`for`循环中，我们手工调用`next()`函数。当循环进行到第`6`次的时候，`re.next()`不会再返回元素，而是抛出(`raise`)`StopIteration`的异常。整个程序将会中断。
我们可以修改以上异常程序，直到完美的没有bug。但另一方面，如果我们在写程序的时候，知道这里可能犯错以及可能的犯错类型，我们可以针对该异常类型定义好”应急预案“。
+
```python
re = iter(range(5))
@@ -34,15 +32,14 @@ try:
for i in range(100):
print re.next()
except StopIteration:
- print 'here is end ',i
+ print 'here is end ', i
print 'HaHaHaHa'
```
-在try程序段中，我们放入容易犯错的部分。我们可以跟上except，来说明如果在try部分的语句发生StopIteration时，程序该做的事情。如果没有发生异常，则except部分被跳过。
-随后，程序将继续运行，而不是彻底中断。
+在`try`程序段中，我们放入容易犯错的部分。我们可以跟上`except`，来说明如果在`try`部分的语句发生`StopIteration`时，程序该做的事情。如果没有发生异常，则`except`部分被跳过。
-
+随后，程序将继续运行，而不是彻底中断。
完整的语法结构如下：
@@ -60,27 +57,26 @@ else:
finally:
...
```
-
-如果try中有异常发生时，将执行异常的归属，执行except。异常层层比较，看是否是exception1, exception2...，直到找到其归属，执行相应的except中的语句。如果except后面没有任何参数，那么表示所有的exception都交给这段程序处理。比如:
+如果`try`中有异常发生时，将执行异常的归属，执行`except`。异常层层比较，看是否是`exception1`、`exception2`...，直到找到其归属，执行相应的`except`中的语句。如果`except`后面没有任何参数，那么表示所有的`exception`都交给这段程序处理。比如：
+
```python
try:
- print(a*2)
+ print(a * 2)
except TypeError:
print("TypeError")
except:
print("Not Type Error & Error noted")
```
-由于a没有定义，所以是NameError。异常最终被except:部分的程序捕捉。
-
+由于`a`没有定义，所以是`NameError`。异常最终被`except:`部分的程序捕捉。
如果无法将异常交给合适的对象，异常将继续向上层抛出，直到被捕捉或者造成主程序报错。比如下面的程序
```python
def test_func():
try:
- m = 1/0
+ m = 1 / 0
except NameError:
print("Catch NameError in the sub-function")
@@ -89,33 +85,33 @@ try:
except ZeroDivisionError:
print("Catch error in the main program")
```
-子程序的try...except...结构无法处理相应的除以0的错误，所以错误被抛给上层的主程序。
-
+子程序的`try...except...`结构无法处理相应的除以`0`的错误，所以错误被抛给上层的主程序。
-如果try中没有异常，那么except部分将跳过，执行else中的语句。
+如果`try`中没有异常，那么`except`部分将跳过，执行`else`中的语句。
-finally是无论是否有异常，最后都要做的一些事情。
+`finally`是无论是否有异常，最后都要做的一些事情。
流程如下，
-try->异常->except->finally
-
-try->无异常->else->finally
+`try`->异常->`except`->`finally`
-
+`try`->无异常->`else`->`finally`
##抛出异常
-我们也可以自己写一个抛出异常的例子:
+我们也可以自己写一个抛出异常的例子：
+
```python
print 'Lalala'
raise StopIteration
print 'Hahaha'
```
-这个例子不具备任何实际意义。只是为了说明raise语句的作用。
-StopIteration是一个类。抛出异常时，会自动有一个中间环节，就是生成StopIteration的一个对象。Python实际上抛出的，是这个对象。当然，也可以自行声场对象:
+这个例子不具备任何实际意义。只是为了说明`raise`语句的作用。
+
+`StopIteration`是一个类。抛出异常时，会自动有一个中间环节，就是生成`StopIteration`的一个对象。Python实际上抛出的，是这个对象。当然，也可以自行生成对象：
+
```python
raise StopIteration()
```
@@ -124,4 +120,4 @@ raise StopIteration()
```python
try: ... except exception: ... else: ... finally: ...
raise exception
-```
+```
\ No newline at end of file
diff --git a/content/intermediate09.md b/content/intermediate09.md
index 32c0fa3..90e3d62 100644
--- a/content/intermediate09.md
+++ b/content/intermediate09.md
@@ -1,70 +1,62 @@
#Python进阶09 动态类型
-
-
-
-动态类型(dynamic typing)是Python另一个重要的核心概念。我们之前说过，Python的变量(variable)不需要声明，而在赋值时，变量可以重新赋值为任意值。这些都与动态类型的概念相关。
-
-
+动态类型（dynamic typing）是Python另一个重要的核心概念。我们之前说过，Python的变量（variable）不需要声明，而在赋值时，变量可以重新赋值为任意值。这些都与动态类型的概念相关。
##动态类型
-在我们接触的对象中，有一类特殊的对象，是用于存储数据的。常见的该类对象包括各种数字，字符串，表，词典。在C语言中，我们称这样一些数据结构为变量。而在Python中，这些是对象。
-
-对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名，只是指向这一对象的引用(reference)。
+在我们接触的对象中，有一类特殊的对象，是用于存储数据的。常见的该类对象包括各种数字，字符串、表、词典。在C语言中，我们称这样一些数据结构为变量。而在Python中，这些是对象。
-
+对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名，只是指向这一对象的引用（reference）。
引用和对象分离，是动态类型的核心。引用可以随时指向一个新的对象：
+
```python
a = 3
a = 'at'
```
-第一个语句中，3是储存在内存中的一个整数对象。通过赋值，引用a指向对象3。
-第二个语句中，内存中建立对象‘at’，是一个字符串(string)。引用a指向了'at'。此时，对象3不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct)，释放相应内存。
+第一个语句中，3是储存在内存中的一个整数对象。通过赋值，引用`a`指向对象`3`。
+
+第二个语句中，内存中建立对象`'at'`，是一个字符串（string）。引用`a`指向了`'at'`。此时，对象`3`不再有引用指向它。Python会自动将没有引用指向的对象销毁（destruct），释放相应内存。
-(对于小的整数和短字符串，Python会缓存这些对象，而不是频繁的建立和销毁。)
+（对于小的整数和短字符串，Python会缓存这些对象，而不是频繁的建立和销毁。）
-
```python
a = 5
b = a
a = a + 2
```
-再看这个例子。通过前两个句子，我们让a,b指向同一个整数对象5(b = a的含义是让引用b指向引用a所指的那一个对象)。但第三个句子实际上对引用a重新赋值，让a指向一个新的对象7。此时a,b分别指向不同的对象。我们看到，即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。
-
+再看这个例子。通过前两个句子，我们让`a`、`b`指向同一个整数对象`5`（`b = a`的含义是让引用b指向引用`a`所指的那一个对象）。但第三个句子实际上对引用`a`重新赋值，让`a`指向一个新的对象`7`。此时`a`、`b`分别指向不同的对象。我们看到，即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。
+
+其它数据对象也是如此：
-其它数据对象也是如此:
```python
-L1 = [1,2,3]
+L1 = [1, 2, 3]
L2 = L1
L1 = 1
```
但注意以下情况
+
```python
-L1 = [1,2,3]
+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], 也就是表对象的一部份(一个元素)，进行操作，所以所有指向该对象的引用都受到影响。
-（与之形成对比的是，我们之前的赋值操作都没有对对象自身发生作用，只是改变引用指向。）
+在该情况下，我们不再对`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)。
+列表可以通过引用其元素，改变对象自身（in-place change）。这种对象类型，称为可变数据对象（mutable object），词典也是这样的数据类型。
-我们之前学的元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object.
+而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象（immutable object）。
-
+我们之前学的元组（tuple），尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object。
##从动态类型看函数的参数传递
@@ -80,31 +72,26 @@ f(a)
print a
```
-参数x是一个新的引用，指向a所指的对象。如果参数是不可变(immutable)的对象，a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。
-
-
+参数x是一个新的引用，指向a所指的对象。如果参数是不可变（immutable）的对象，`a`和`x`引用之间相互独立。对参数`x`的操作不会影响引用`a`。这样的传递类似于C语言中的值传递。
-如果传递的是可变(mutable)的对象，那么改变函数参数，有可能改变原对象。所有指向原对象的引用都会受影响，编程的时候要对此问题留心。比如说：
+如果传递的是可变（mutable）的对象，那么改变函数参数，有可能改变原对象。所有指向原对象的引用都会受影响，编程的时候要对此问题留心。比如说：
```python
def f(x):
x[0] = 100
print x
-a = [1,2,3]
+a = [1, 2, 3]
f(a)
print a
```
-
动态类型是Python的核心机制之一。可以在应用中慢慢熟悉。
-
-
##总结
引用和对象的分离，对象是内存中储存数据的实体，引用指向对象。
-可变对象，不可变对象
+可变对象，不可变对象。
-函数值传递
+函数值传递。
\ No newline at end of file
diff --git "a/content/\346\267\261\345\205\24501 \347\211\271\346\256\212\346\226\271\346\263\225\344\270\216\345\244\232\350\214\203\345\274\217.md" "b/content/\346\267\261\345\205\24501 \347\211\271\346\256\212\346\226\271\346\263\225\344\270\216\345\244\232\350\214\203\345\274\217.md"
index d86b15b..bd04eae 100644
--- "a/content/\346\267\261\345\205\24501 \347\211\271\346\256\212\346\226\271\346\263\225\344\270\216\345\244\232\350\214\203\345\274\217.md"
+++ "b/content/\346\267\261\345\205\24501 \347\211\271\346\256\212\346\226\271\346\263\225\344\270\216\345\244\232\350\214\203\345\274\217.md"
@@ -1,80 +1,89 @@
##Python深入01 特殊方法与多范式
+Python一切皆对象，但同时，Python还是一个多范式语言（multi-paradigm），你不仅可以使用面向对象的方式来编写程序，还可以用面向过程的方式来编写相同功能的程序（还有函数式、声明式等，我们暂不深入）。Python的多范式依赖于Python对象中的特殊方法（special method）。
-
+特殊方法名的前后各有两个下划线。特殊方法又被成为魔法方法（magic method），定义了许多Python语法和表达方式，正如我们在下面的例子中将要看到的。当对象中定义了特殊方法的时候，Python也会对它们有“特殊优待”。比如定义了`__init__()`方法的类，会在创建对象的时候自动执行`__init__()`方法中的操作。
-Python一切皆对象，但同时，Python还是一个多范式语言(multi-paradigm),你不仅可以使用面向对象的方式来编写程序，还可以用面向过程的方式来编写相同功能的程序(还有函数式、声明式等，我们暂不深入)。Python的多范式依赖于Python对象中的特殊方法(special method)。
-
-特殊方法名的前后各有两个下划线。特殊方法又被成为魔法方法(magic method)，定义了许多Python语法和表达方式，正如我们在下面的例子中将要看到的。当对象中定义了特殊方法的时候，Python也会对它们有“特殊优待”。比如定义了__init__()方法的类，会在创建对象的时候自动执行__init__()方法中的操作。
-
-(可以通过dir()来查看对象所拥有的特殊方法，比如dir(1))
-
-
+（可以通过`dir()`来查看对象所拥有的特殊方法，比如`dir(1)`。）
##运算符
Python的运算符是通过调用对象的特殊方法实现的。比如：
+
```python
-'abc' + 'xyz' # 连接字符串
+'abc' + 'xyz' # 连接字符串
```
+
实际执行了如下操作：
+
```python
'abc'.__add__('xyz')
```
-所以，在Python中，两个对象是否能进行加法运算，首先就要看相应的对象是否有__add__()方法。一旦相应的对象有__add__()方法，即使这个对象从数学上不可加，我们都可以用加法的形式，来表达obj.__add__()所定义的操作。在Python中，运算符起到简化书写的功能，但它依靠特殊方法实现。
-Python不强制用户使用面向对象的编程方法。用户可以选择自己喜欢的使用方式(比如选择使用+符号，还是使用更加面向对象的__add__()方法)。特殊方法写起来总是要更费事一点。
+所以，在Python中，两个对象是否能进行加法运算，首先就要看相应的对象是否有`__add__()`方法。
-尝试下面的操作，看看效果，再想想它的对应运算符
+一旦相应的对象有`__add__()`方法，即使这个对象从数学上不可加，我们都可以用加法的形式，来表达`obj.__add__()`所定义的操作。
-(1.8).__mul__(2.0)
+在Python中，运算符起到简化书写的功能，但它依靠特殊方法实现。
-True.__or__(False)
+Python不强制用户使用面向对象的编程方法。用户可以选择自己喜欢的使用方式（比如选择使用`+`符号，还是使用更加面向对象的`__add__()`方法）。特殊方法写起来总是要更费事一点。
-
+尝试下面的操作，看看效果，再想想它的对应运算符：
+
+```pytho
+(1.8).__mul__(2.0)
+True.__or__(False)
+```
##内置函数
-与运算符类似，许多内置函数也都是调用对象的特殊方法。比如
+与运算符类似，许多内置函数也都是调用对象的特殊方法。比如：
+
```python
-len([1,2,3]) # 返回表中元素的总数
+len([1, 2, 3]) # 返回表中元素的总数
```
-实际上做的是
+
+实际上做的是：
+
```python
-[1,2,3].__len__()
+[1, 2, 3].__len__()
```
-相对与__len__()，内置函数len()也起到了简化书写的作用。
-尝试下面的操作，想一下它的对应内置函数
+相对与`__len__()`，内置函数`len()`也起到了简化书写的作用。
-(-1).__abs__()
+尝试下面的操作，想一下它的对应内置函数：
+```python
+(-1).__abs__()
(2.3).__int__()
+```
-
+##表（list）元素引用
-##表(list)元素引用
+下面是我们常见的表元素引用方式：
-下面是我们常见的表元素引用方式
```python
li = [1, 2, 3, 4, 5, 6]
print(li[3])
```
-上面的程序运行到li[3]的时候，Python发现并理解[]符号，然后调用__getitem__()方法。
+
+上面的程序运行到`li[3]`的时候，Python发现并理解`[]`符号，然后调用`__getitem__()`方法。
+
```python
li = [1, 2, 3, 4, 5, 6]
print(li.__getitem__(3))
```
-尝试看下面的操作，想想它的对应
-li.__setitem__(3, 0)
+尝试看下面的操作，想想它的对应：
+```python
+li.__setitem__(3, 0)
{'a':1, 'b':2}.__delitem__('a')
-
+```
##函数
-我们已经说过，在Python中，函数也是一种对象。实际上，任何一个有__call__()特殊方法的对象都被当作是函数。比如下面的例子:
+我们已经说过，在Python中，函数也是一种对象。实际上，任何一个有`__call__()`特殊方法的对象都被当作是函数。比如下面的例子：
```python
class SampleMore(object):
@@ -86,20 +95,14 @@ print(add(2)) # Call function
map(add, [2, 4, 5]) # Pass around function object
```
-add为SampleMore类的一个对象，当被调用时，add执行加5的操作。add还可以作为函数对象，被传递给map()函数。
+`add`为`SampleMore`类的一个对象，当被调用时，`add`执行加`5`的操作。`add`还可以作为函数对象，被传递给`map()`函数。
当然，我们还可以使用更“优美”的方式，想想是什么。
-
-
##总结
-对于内置的对象来说(比如整数、表、字符串等)，它们所需要的特殊方法都已经在Python中准备好了。而用户自己定义的对象也可以通过增加特殊方法，来实现自定义的语法。特殊方法比较靠近Python的底层，许多Python功能的实现都要依赖于特殊方法。我们将在以后看到更多的例子。
-
-
-
-
+对于内置的对象来说（比如整数、表、字符串等），它们所需要的特殊方法都已经在Python中准备好了。而用户自己定义的对象也可以通过增加特殊方法，来实现自定义的语法。特殊方法比较靠近Python的底层，许多Python功能的实现都要依赖于特殊方法。我们将在以后看到更多的例子。
-大黄蜂，还是Camaro跑车
+###大黄蜂，还是Camaro跑车
-Python的许多语法都是基于其面向对象模型的封装。对象模型是Python的骨架，是功能完备、火力强大的大黄蜂。但是Python也提供更加简洁的语法，让你使用不同的编程形态，从而在必要时隐藏一些面向对象的接口。正如我们看到的Camaro跑车，将自己威风的火药库收起来，提供方便人类使用的车门和座椅。
+Python的许多语法都是基于其面向对象模型的封装。对象模型是Python的骨架，是功能完备、火力强大的大黄蜂。但是Python也提供更加简洁的语法，让你使用不同的编程形态，从而在必要时隐藏一些面向对象的接口。正如我们看到的Camaro跑车，将自己威风的火药库收起来，提供方便人类使用的车门和座椅。
\ No newline at end of file
diff --git "a/content/\346\267\261\345\205\24502 \344\270\212\344\270\213\346\226\207\347\256\241\347\220\206\345\231\250.md" "b/content/\346\267\261\345\205\24502 \344\270\212\344\270\213\346\226\207\347\256\241\347\220\206\345\231\250.md"
index e731e2c..262f765 100644
--- "a/content/\346\267\261\345\205\24502 \344\270\212\344\270\213\346\226\207\347\256\241\347\220\206\345\231\250.md"
+++ "b/content/\346\267\261\345\205\24502 \344\270\212\344\270\213\346\226\207\347\256\241\347\220\206\345\231\250.md"
@@ -1,15 +1,13 @@
#Python深入02 上下文管理器
-
-
-上下文管理器(context manager)是Python2.5开始支持的一种语法，用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是with...as...
-
+上下文管理器（context manager）是Python2.5开始支持的一种语法，用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用（比如为对象分配或者释放内存）。它的语法形式是`with...as...`。
##关闭文件
我们会进行这样的操作：打开文件，读写，关闭文件。程序员经常会忘记关闭文件。上下文管理器可以在不需要文件的时候，自动关闭文件。
下面我们看一下两段程序：
+
```python
# without context manager
f = open("new.txt", "w")
@@ -18,7 +16,9 @@ f.write("Hello World!")
f.close()
print(f.closed)
```
+
以及：
+
```python
# with context manager
with open("new.txt", "w") as f:
@@ -26,58 +26,56 @@ with open("new.txt", "w") as f:
f.write("Hello World!")
print(f.closed)
```
-两段程序实际上执行的是相同的操作。我们的第二段程序就使用了上下文管理器 (with...as...)。上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候(也就是不再缩进)，上下文管理器自动关闭了文件 (我们通过f.closed来查询文件是否关闭)。我们相当于使用缩进规定了文件对象f的使用范围。
-
+两段程序实际上执行的是相同的操作。我们的第二段程序就使用了上下文管理器（`with...as...`）。
-上面的上下文管理器基于f对象的__exit__()特殊方法(还记得我们如何利用特殊方法来实现各种语法？参看特殊方法与多范式)。当我们使用上下文管理器的语法时，我们实际上要求Python在进入程序块之前调用对象的__enter__()方法，在结束程序块的时候调用__exit__()方法。对于文件对象f来说，它定义了__enter__()和__exit__()方法(可以通过dir(f)看到)。在f的__exit__()方法中，有self.close()语句。所以在使用上下文管理器时，我们就不用明文关闭f文件了。
+上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候（也就是不再缩进），上下文管理器自动关闭了文件（我们通过`f.closed`来查询文件是否关闭）。我们相当于使用缩进规定了文件对象`f`的使用范围。
-
+上面的上下文管理器基于`f`对象的`__exit__()`特殊方法（还记得我们如何利用特殊方法来实现各种语法？参看特殊方法与多范式）。
-##自定义
+当我们使用上下文管理器的语法时，我们实际上要求Python在进入程序块之前调用对象的`__enter__()`方法，在结束程序块的时候调用`__exit__()`方法。
+
+对于文件对象f来说，它定义了`__enter__()`和`__exit__()`方法（可以通过`dir(f)`看到）。在`f`的`__exit__()`方法中，有`self.close()`语句。所以在使用上下文管理器时，我们就不用明文关闭`f`文件了。
-任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器。文件对象f是内置对象，所以f自动带有这两个特殊方法，不需要自定义。
+##自定义
-下面，我们自定义用于上下文管理器的对象，就是下面的myvow：
+任何定义了`__enter__()`和`__exit__()`方法的对象都可以用于上下文管理器。文件对象`f`是内置对象，所以`f`自动带有这两个特殊方法，不需要自定义。
-
+下面，我们自定义用于上下文管理器的对象，就是下面的`myvow`：
```python
# 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):
+ 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)
```
-
-我们的运行结果如下:
+我们的运行结果如下：
+```quote
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增加了后缀("!")。
+我们可以看到，在进入上下文和离开上下文时，对象的text属性发生了改变（最初的`text`属性是`"I'm fine"`）。
-注意: __exit__()中有四个参数。当程序块中出现异常(exception)，__exit__()的参数中exc_type, exc_value, traceback用于描述异常。我们可以根据这三个参数进行相应的处理。如果正常运行结束，这三个参数都是None。在我们的程序中，我们并没有用到这一特性。
+`__enter__()`返回一个对象。上下文管理器会使用这一对象作为`as`所指的变量，也就是`myvow`。在`__enter__()`中，我们为`myvow.text`增加了前缀（`"I say: "`）。在`__exit__()`中，我们为`myvow.text`增加了后缀（`"!"`）。
-
+注意：`__exit__()`中有四个参数。当程序块中出现异常（`exception`），`__exit__()`的参数中`exc_type`、`exc_value`、`traceback`用于描述异常。我们可以根据这三个参数进行相应的处理。如果正常运行结束，这三个参数都是`None`。在我们的程序中，我们并没有用到这一特性。
##总结：
-通过上下文管理器，我们控制对象在程序不同区间的特性。上下文管理器(with EXPR as VAR)大致相当于如下流程:
+通过上下文管理器，我们控制对象在程序不同区间的特性。上下文管理器（`with EXPR as VAR`）大致相当于如下流程：
```python
# with EXPR as VAR:
@@ -89,4 +87,5 @@ try:
finally:
VAR.__exit__()
```
-由于上下文管理器带来的便利，它是一个值得使用的工具。
+
+由于上下文管理器带来的便利，它是一个值得使用的工具。
\ No newline at end of file
diff --git "a/content/\346\267\261\345\205\24504 \351\227\255\345\214\205.md" "b/content/\346\267\261\345\205\24504 \351\227\255\345\214\205.md"
index a8c867c..d653eb8 100644
--- "a/content/\346\267\261\345\205\24504 \351\227\255\345\214\205.md"
+++ "b/content/\346\267\261\345\205\24504 \351\227\255\345\214\205.md"
@@ -1,39 +1,32 @@
#Python深入04 闭包
+闭包（closure）是函数式编程的重要的语法结构。函数式编程是一种编程范式（而面向过程编程和面向对象编程也都是编程范式）。在面向过程编程中，我们见到过函数（function）；在面向对象编程中，我们见过对象（object）。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性（reusability）。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。
-
-
-闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。在面向过程编程中，我们见到过函数(function)；在面向对象编程中，我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。
-
-不同的语言实现闭包的方式不同。Python以函数对象为基础，为闭包这一语法结构提供支持的 (我们在特殊方法与多范式中，已经多次看到Python使用对象来实现一些特殊的语法)。Python一切皆对象，函数这一语法结构也是一个对象。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。
-
-
+不同的语言实现闭包的方式不同。Python以函数对象为基础，为闭包这一语法结构提供支持的（我们在特殊方法与多范式中，已经多次看到Python使用对象来实现一些特殊的语法）。Python一切皆对象，函数这一语法结构也是一个对象。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。
##函数对象的作用域
-和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用def语句定义的，函数对象的作用域与def所在的层级相同。比如下面代码，我们在line_conf函数的隶属范围内定义的函数line，就只能在line_conf的隶属范围内调用。
+和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用`def`语句定义的，函数对象的作用域与`def`所在的层级相同。比如下面代码，我们在`line_conf`函数的隶属范围内定义的函数`line`，就只能在`line_conf`的隶属范围内调用。
```python
def line_conf():
def line(x):
- return 2*x+1
+ 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将会有下面的错误：
+`line`函数定义了一条直线（`y = 2 * x + 1`）。可以看到，在`line_conf()`中可以调用`line`函数，而在作用域之外调用`line`将会有下面的错误：
+
+```quote
NameError: name 'line' is not defined
+```
说明这时已经在作用域之外。
-
-
-同样，如果使用lambda定义函数，那么函数对象的作用域与lambda所在的层级相同。
-
-
+同样，如果使用`lambda`定义函数，那么函数对象的作用域与`lambda`所在的层级相同。
##闭包
@@ -48,36 +41,34 @@ def line_conf():
my_line = line_conf()
print(my_line(5))
```
-上面的代码可以成功运行。line_conf的返回结果被赋给line对象。上面的代码将打印11。
-
+上面的代码可以成功运行。`line_conf`的返回结果被赋给`line`对象。上面的代码将打印`11`。
-如果line()的定义中引用了外部的变量，会发生什么呢？
+如果`line()`的定义中引用了外部的变量，会发生什么呢？
```python
def line_conf():
b = 15
def line(x):
- return 2*x+b
+ 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值。
+我们可以看到，`line`定义的隶属程序块中引用了高层级的变量`b`，但`b`信息存在于`line`的定义之外（`b`的定义并不在`line`的隶属程序块中）。我们称`b`为`line`的环境变量。事实上，`line`作为`line_conf`的返回值时，`line`中已经包括`b`的取值（尽管`b`并不隶属于`line`）。
-
+上面的代码将打印`25`，也就是说，`line`所参照的`b`值是函数对象定义时可供参考的`b`值，而不是使用时的`b`值。
-一个函数和它的环境变量合在一起，就构成了一个闭包(closure)。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的__closure__属性中。比如下面的代码：
+一个函数和它的环境变量合在一起，就构成了一个闭包（closure）。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的`__closure__`属性中。比如下面的代码：
```python
def line_conf():
b = 15
def line(x):
- return 2*x+b
+ return 2 * x + b
return line # return a function object
b = 5
@@ -85,30 +76,28 @@ my_line = line_conf()
print(my_line.__closure__)
print(my_line.__closure__[0].cell_contents)
```
-__closure__里包含了一个元组(tuple)。这个元组中的每个元素是cell类型的对象。我们看到第一个cell包含的就是整数15，也就是我们创建闭包时的环境变量b的取值。
-
+`__closure__`里包含了一个元组（`tuple`）。这个元组中的每个元素是`cell`类型的对象。我们看到第一个`cell`包含的就是整数`15`，也就是我们创建闭包时的环境变量`b`的取值。
下面看一个闭包的实际例子：
```python
def line_conf(a, b):
def line(x):
- return ax + b
+ 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传递来的参数，通过闭包的形式，将最终函数确定下来。
+这个例子中，函数`line`与环境变量`a`、`b`构成闭包。在创建闭包的时候，我们通过`line_conf`的参数`a`、`b`说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式（`y = 1 * x + 1`和`y = 4 * x + 5`）。我们只需要变换参数`a`、`b`，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。
-
+如果没有闭包，我们需要每次创建直线函数的时候同时说明`a`、`b`、`x`。这样，我们就需要更多的参数传递，也减少了代码的可移植性。利用闭包，我们实际上创建了泛函。`line`函数定义一种广泛意义的函数。这个函数的一些方面已经确定（必须是直线），但另一些方面（比如`a`和`b`参数待定）。随后，我们根据`line_conf`传递来的参数，通过闭包的形式，将最终函数确定下来。
##闭包与并行运算
闭包有效的减少了函数所需定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下，我们可以让每台电脑负责一个函数，然后将一台电脑的输出和下一台电脑的输入串联起来。最终，我们像流水线一样工作，从串联的电脑集群一端输入数据，从另一端输出数据。这样的情境最适合只有一个参数输入的函数。闭包就可以实现这一目的。
-并行运算正称为一个热点。这也是函数式编程又热起来的一个重要原因。函数式编程早在1950年代就已经存在，但应用并不广泛。然而，我们上面描述的流水线式的工作并行集群过程，正适合函数式编程。由于函数式编程这一天然优势，越来越多的语言也开始加入对函数式编程范式的支持。
+并行运算正称为一个热点。这也是函数式编程又热起来的一个重要原因。函数式编程早在1950年代就已经存在，但应用并不广泛。然而，我们上面描述的流水线式的工作并行集群过程，正适合函数式编程。由于函数式编程这一天然优势，越来越多的语言也开始加入对函数式编程范式的支持。
\ No newline at end of file
diff --git "a/content/\346\267\261\345\205\24505 \350\243\205\351\245\260\345\231\250.md" "b/content/\346\267\261\345\205\24505 \350\243\205\351\245\260\345\231\250.md"
index 23b957b..8c40c4f 100644
--- "a/content/\346\267\261\345\205\24505 \350\243\205\351\245\260\345\231\250.md"
+++ "b/content/\346\267\261\345\205\24505 \350\243\205\351\245\260\345\231\250.md"
@@ -1,13 +1,8 @@
#Python深入05 装饰器
+装饰器（decorator）是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数和类进行加工，比如在Python闭包中，我们见到函数对象作为某一个函数的返回结果。相对于其它方式，装饰器语法简单，代码可读性高。因此，装饰器在Python项目中有广泛的应用。
-
-
-装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数和类进行加工，比如在Python闭包中，我们见到函数对象作为某一个函数的返回结果。相对于其它方式，装饰器语法简单，代码可读性高。因此，装饰器在Python项目中有广泛的应用。
-
-装饰器最早在Python 2.5中出现，它最初被用于加工函数和方法这样的可调用对象(callable object，这样的对象定义有__call__方法)。在Python 2.6以及之后的Python版本中，装饰器被进一步用于加工类。
-
-
+装饰器最早在Python 2.5中出现，它最初被用于加工函数和方法这样的可调用对象（callable object，这样的对象定义有`__call__()`方法）。在Python 2.6以及之后的Python版本中，装饰器被进一步用于加工类。
##装饰函数和方法
@@ -16,15 +11,16 @@
```python
# get square sum
def square_sum(a, b):
- return a**2 + b**2
+ return a ** 2 + b ** 2
# get square diff
def square_diff(a, b):
- return a**2 - b**2
+ return a ** 2 - b ** 2
print(square_sum(3, 4))
print(square_diff(3, 4))
```
+
在拥有了基本的数学功能之后，我们可能想为函数增加其它的功能，比如打印输入。我们可以改写函数来实现这一点：
```python
@@ -33,19 +29,18 @@ print(square_diff(3, 4))
# get square sum
def square_sum(a, b):
print("intput:", a, b)
- return a**2 + b**2
+ return a ** 2 + b ** 2
# get square diff
def square_diff(a, b):
print("input", a, b)
- return a**2 - b**2
+ return a ** 2 - b ** 2
print(square_sum(3, 4))
print(square_diff(3, 4))
```
-我们修改了函数的定义，为函数增加了功能。
-
+我们修改了函数的定义，为函数增加了功能。
现在，我们使用装饰器来实现上述修改：
@@ -59,36 +54,39 @@ def decorator(F):
# get square sum
@decorator
def square_sum(a, b):
- return a**2 + b**2
+ return a ** 2 + b ** 2
# get square diff
@decorator
def square_diff(a, b):
- return a**2 - b**2
+ return a ** 2 - b ** 2
print(square_sum(3, 4))
print(square_diff(3, 4))
```
-装饰器可以用def的形式定义，如上面代码中的decorator。装饰器接收一个可调用对象作为输入参数，并返回一个新的可调用对象。装饰器新建了一个可调用对象，也就是上面的new_F。new_F中，我们增加了打印的功能，并通过调用F(a, b)来实现原有函数的功能。
-定义好装饰器后，我们就可以通过@语法使用了。在函数square_sum和square_diff定义之前调用@decorator，我们实际上将square_sum或square_diff传递给decorator，并将decorator返回的新的可调用对象赋给原来的函数名(square_sum或square_diff)。 所以，当我们调用square_sum(3, 4)的时候，就相当于：
+装饰器可以用`def`的形式定义，如上面代码中的`decorator`。装饰器接收一个可调用对象作为输入参数，并返回一个新的可调用对象。
+
+装饰器新建了一个可调用对象，也就是上面的`new_F`。`new_F`中，我们增加了打印的功能，并通过调用`F(a, b)`来实现原有函数的功能。
+
+定义好装饰器后，我们就可以通过`@`语法使用了。
+
+在函数`square_sum`和`square_diff`定义之前调用`@decorator`，我们实际上将`square_sum`或`square_diff`传递给`decorator`，并将`decorator`返回的新的可调用对象赋给原来的函数名（`square_sum`或`square_diff`）。 所以，当我们调用`square_sum(3, 4)`的时候，就相当于：
+
```python
square_sum = decorator(square_sum)
square_sum(3, 4)
```
-我们知道，Python中的变量名和对象是分离的。变量名可以指向任意一个对象。从本质上，装饰器起到的就是这样一个重新指向变量名的作用(name binding)，让同一个变量名指向一个新返回的可调用对象，从而达到修改可调用对象的目的。
-
-与加工函数类似，我们可以使用装饰器加工类的方法。
-
+我们知道，Python中的变量名和对象是分离的。变量名可以指向任意一个对象。从本质上，装饰器起到的就是这样一个重新指向变量名的作用（name binding），让同一个变量名指向一个新返回的可调用对象，从而达到修改可调用对象的目的。
-如果我们有其他的类似函数，我们可以继续调用decorator来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
+与加工函数类似，我们可以使用装饰器加工类的方法。
-
+如果我们有其他的类似函数，我们可以继续调用`decorator`来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
##含参的装饰器
-在上面的装饰器调用中，比如@decorator，该装饰器默认它后面的函数是唯一的参数。装饰器的语法允许我们调用decorator时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
+在上面的装饰器调用中，比如`@decorator`，该装饰器默认它后面的函数是唯一的参数。装饰器的语法允许我们调用`decorator`时，提供其它参数，比如`@decorator(a)`。这样，就为装饰器的编写和使用提供了更大的灵活性。
```python
# a new wrapper layer
@@ -104,20 +102,22 @@ def pre_str(pre=''):
# get square sum
@pre_str('^_^')
def square_sum(a, b):
- return a**2 + b**2
+ return a ** 2 + b ** 2
# get square diff
@pre_str('T_T')
def square_diff(a, b):
- return a**2 - b**2
+ return a ** 2 - b ** 2
print(square_sum(3, 4))
print(square_diff(3, 4))
```
-上面的pre_str是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用@pre_str('^_^')调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。该调用相当于:
+上面的`pre_str`是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用`@pre_str('^_^')`调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。该调用相当于：
+
+```python
square_sum = pre_str('^_^') (square_sum)
-
+```
##装饰类
@@ -146,14 +146,11 @@ eagleLord = Bird(5)
for i in range(3):
eagleLord.display()
```
-在decorator中，我们返回了一个新类newClass。在新类中，我们记录了原来类生成的对象（self.wrapped），并附加了新的属性total_display，用于记录调用display的次数。我们也同时更改了display方法。
-通过修改，我们的Bird类可以显示调用display的次数了。
+在`decorator`中，我们返回了一个新类`newClass`。在新类中，我们记录了原来类生成的对象（`self.wrapped`），并附加了新的属性`total_display`，用于记录调用`display()`的次数。我们也同时更改了`display()`方法。
-
+通过修改，我们的`Bird`类可以显示调用`display()`的次数了。
##总结
-装饰器的核心作用是name binding。这种语法是Python多编程范式的又一个体现。大部分Python用户都不怎么需要定义装饰器，但有可能会使用装饰器。鉴于装饰器在Python项目中的广泛使用，了解这一语法是非常有益的。
-
-
+装饰器的核心作用是name binding。这种语法是Python多编程范式的又一个体现。大部分Python用户都不怎么需要定义装饰器，但有可能会使用装饰器。鉴于装饰器在Python项目中的广泛使用，了解这一语法是非常有益的。
\ No newline at end of file
diff --git "a/content/\346\267\261\345\205\24506 Python\347\232\204\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/content/\346\267\261\345\205\24506 Python\347\232\204\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 17ee9f6..8d1bdad 100644
--- "a/content/\346\267\261\345\205\24506 Python\347\232\204\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/content/\346\267\261\345\205\24506 Python\347\232\204\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -1,38 +1,37 @@
#Python深入06 Python的内存管理
-
-
-
语言的内存管理是语言设计的一个重要方面。它是决定语言性能的重要因素。无论是C语言的手工管理，还是Java的垃圾回收，都成为语言最重要的特征。这里以Python语言为例子，说明一门动态类型的、面向对象的语言的内存管理方式。
-
-
##对象的内存使用
赋值语句是语言最常见的功能了。但即使是最简单的赋值语句，也可以很有内涵。Python的赋值语句就很值得研究。
+```python
a = 1
-整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。Python是动态类型的语言(参考动态类型)，对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。
+```
+整数`1`为一个对象。而`a`是一个引用。利用赋值语句，引用`a`指向对象`1`。Python是动态类型的语言（参考动态类型），对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。
+为了探索对象在内存的存储，我们可以求助于Python的内置函数`id()`。它用于返回对象的身份（identity）。其实，这里所谓的身份，就是该对象的内存地址。
-为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。
```pyhton
a = 1
print(id(a))
print(hex(id(a)))
```
-在我的计算机上，它们返回的是:
+在我的计算机上，它们返回的是：
+
+```quote
11246696
'0xab9c68'
+```
分别为内存地址的十进制和十六进制表示。
-
+在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于`1`的引用时，实际上是让所有这些引用指向同一个对象。
-在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。
```pyhton
a = 1
b = 1
@@ -40,17 +39,17 @@ b = 1
print(id(a))
print(id(b))
```
-上面程序返回
-11246696
+上面程序返回：
+```quote
11246696
+11246696
+```
-可见a和b实际上是指向同一个对象的两个引用。
-
-
+可见`a`和`b`实际上是指向同一个对象的两个引用。
-为了检验两个引用指向同一个对象，我们可以用is关键字。is用于判断两个引用所指的对象是否相同。
+为了检验两个引用指向同一个对象，我们可以用`is`关键字。`is`用于判断两个引用所指的对象是否相同。
```pyhton
# True
@@ -73,13 +72,13 @@ a = []
b = []
print(a is b)
```
-上面的注释为相应的运行结果。可以看到，由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。
-
+上面的注释为相应的运行结果。可以看到，由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数`1`的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。
+
+在Python中，每个对象都有存有指向该对象的引用总数，即引用计数（reference count）。
-在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。
+我们可以使用`sys`包中的`getrefcount()`，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给`getrefcount()`时，参数实际上创建了一个临时的引用。因此，`getrefcount()`所得到的结果，会比期望的多`1`。
-我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。
```pyhton
from sys import getrefcount
@@ -89,33 +88,29 @@ print(getrefcount(a))
b = a
print(getrefcount(b))
```
-由于上述原因，两个getrefcount将返回2和3，而不是期望的1和2。
-
+由于上述原因，两个`getrefcount()`将返回`2`和`3`，而不是期望的`1`和`2`。
##对象引用对象
-Python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。
+Python的一个容器对象（container），比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。
-我们也可以自定义一个对象，并引用其它对象:
+我们也可以自定义一个对象，并引用其它对象：
```pyhton
class from_obj(object):
def __init__(self, to_obj):
self.to_obj = to_obj
-b = [1,2,3]
+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`。
-
+对象引用对象，是Python最基本的构成方式。即使是`a = 1`这一赋值方式，实际上是让词典的一个键值`"a"`的元素引用整数对象`1`。该词典对象用于记录所有的全局引用。该词典引用了整数对象`1`。我们可以通过内置函数`globals()`来查看该词典。
当一个对象A被另一个对象B引用时，A的引用计数将增加1。
@@ -128,11 +123,11 @@ print(getrefcount(a))
b = [a, a]
print(getrefcount(a))
```
-由于对象b引用了两次a，a的引用计数增加了2。
-
+由于对象`b`引用了两次`a`、`a`的引用计数增加了2。
+
+容器对象的引用可能构成很复杂的拓扑结构。我们可以用`objgraph`包来绘制其引用关系，比如：
-容器对象的引用可能构成很复杂的拓扑结构。我们可以用objgraph包来绘制其引用关系，比如
```pyhton
x = [1, 2, 3]
y = [x, dict(key1=x)]
@@ -142,37 +137,35 @@ import objgraph
objgraph.show_refs([z], filename='ref_topo.png')
```
-
-
-
+`objgraph`是Python的一个第三方包。安装之前需要安装`xdot`：
-objgraph是Python的一个第三方包。安装之前需要安装xdot。
-```pyhton
+```bash
sudo apt-get install xdot
sudo pip install objgraph
-objgraph官网
```
-
+objgraph官网
+
+两个对象可能相互引用，从而构成所谓的引用环（reference cycle）。
-两个对象可能相互引用，从而构成所谓的引用环(reference cycle)。
```pyhton
a = []
b = [a]
a.append(b)
```
+
即使是一个对象，只需要自己引用自己，也能构成引用环。
+
```pyhton
a = []
a.append(a)
print(getrefcount(a))
```
-引用环会给垃圾回收机制带来很大的麻烦，我将在后面详细叙述这一点。
-
+引用环会给垃圾回收机制带来很大的麻烦，我将在后面详细叙述这一点。
##引用减少
-某个对象的引用计数可能减少。比如，可以使用del关键字删除某个引用:
+某个对象的引用计数可能减少。比如，可以使用`del`关键字删除某个引用：
```pyhton
from sys import getrefcount
@@ -184,18 +177,16 @@ print(getrefcount(b))
del a
print(getrefcount(b))
```
-
-del也可以用于删除容器元素中的元素，比如:
+`del`也可以用于删除容器元素中的元素，比如：
+
```pyhton
-a = [1,2,3]
+a = [1, 2, 3]
del a[0]
print(a)
```
-
-
-如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少:
+如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少：
```pyhton
from sys import getrefcount
@@ -207,68 +198,58 @@ print(getrefcount(b))
a = 1
print(getrefcount(b))
```
-
-
-
##垃圾回收
-吃太多，总会变胖，Python也是这样。当Python中的对象越来越多，它们将占据越来越大的内存。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥”，启动垃圾回收(garbage collection)，将没用的对象清除。在许多语言中都有垃圾回收机制，比如Java和Ruby。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收
+吃太多，总会变胖，Python也是这样。当Python中的对象越来越多，它们将占据越来越大的内存。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥”，启动垃圾回收（garbage collection），将没用的对象清除。
-)。
+在许多语言中都有垃圾回收机制，比如Java和Ruby。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 （这一点可以对比本文和Java内存管理与垃圾回收）。
-
+从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表：
-
-
-从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表:
```pyhton
a = [1, 2, 3]
del a
```
-del a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
-
+`del a`后，已经没有任何引用指向之前建立的`[1, 2, 3]`这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
+
+然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。
-然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
+当Python运行时，会记录其中分配对象（object allocation）和取消分配对象（object deallocation）的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
-我们可以通过gc模块的get_threshold()方法，查看该阈值:
+我们可以通过`gc`模块的`get_threshold()`方法，查看该阈值：
+```python
import gc
print(gc.get_threshold())
-返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。
-
-
+```
-我们也可以手动启动垃圾回收，即使用gc.collect()。
+返回`(700, 10, 10)`，后面的两个`10`是与分代回收相关的阈值，后面可以看到。`700`即是垃圾回收启动的阈值。可以通过`gc`中的`set_threshold()`方法重新设置。
-
+我们也可以手动启动垃圾回收，即使用`gc.collect()`。
##分代回收
-Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。
-
-
-
-
+Python同时采用了分代（generation）回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。
小家伙要多检查
-
+Python将所有的对象分为0、1、2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0、1、2，即对所有对象进行扫描。
-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代垃圾回收。
-这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。
-
-同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。
+同样可以用`set_threshold()`来调整，比如对2代对象进行更频繁的扫描。
+```python
import gc
gc.set_threshold(700, 10, 5)
-
+```
##孤立的引用环
引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用，但引用计数不为0的一些对象。
+
```pyhton
a = []
b = [a]
@@ -277,32 +258,19 @@ a.append(b)
del a
del b
```
-上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。
-
+上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了`a`、`b`引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。
孤立的引用环
-
-
-为了回收这样的引用环，Python复制每个对象的引用计数，可以记为gc_ref。假设，每个对象i，该计数为gc_ref_i。Python会遍历所有的对象i。对于每个对象i引用的对象j，将相应的gc_ref_j减1。
-
-
-
-
+为了回收这样的引用环，Python复制每个对象的引用计数，可以记为`gc_ref`。假设，每个对象`i`，该计数为`gc_ref_i`。Python会遍历所有的对象`i`。对于每个对象`i`引用的对象`j`，将相应的`gc_ref_j`减1。
遍历后的结果
-
-
-在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。
-
-
+在结束遍历后，`gc_ref`不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。
##总结
Python作为一种动态类型的语言，其对象和引用分离。这与曾经的面向过程语言有很大的区别。为了有效的释放内存，Python内置了垃圾回收的支持。Python采取了一种相对简单的垃圾回收机制，即引用计数，并因此需要解决孤立引用环的问题。Python与其它语言既有共通性，又有特别的地方。对该内存管理机制的理解，是提高Python性能的重要一步。
-
-
-欢迎继续阅读“Python快速教程”
+欢迎继续阅读“Python快速教程”
\ No newline at end of file
diff --git "a/content/\347\275\221\347\273\23401 \345\216\237\345\247\213Python\346\234\215\345\212\241\345\231\250.md" "b/content/\347\275\221\347\273\23401 \345\216\237\345\247\213Python\346\234\215\345\212\241\345\231\250.md"
index 57c488f..d1601cd 100644
--- "a/content/\347\275\221\347\273\23401 \345\216\237\345\247\213Python\346\234\215\345\212\241\345\231\250.md"
+++ "b/content/\347\275\221\347\273\23401 \345\216\237\345\247\213Python\346\234\215\345\212\241\345\231\250.md"
@@ -1,47 +1,28 @@
#Python网络01 原始Python服务器
+之前我的Python教程中有人留言，表示只学Python没有用，必须学会一个框架（比如`Django`和`web.py`）才能找到工作。而我的想法是，掌握一个类似于框架的高级工具是有用的，但是基础的东西可以让你永远不被淘汰。不要被工具限制了自己的发展。今天，我在这里想要展示的，就是不使用框架，甚至不使用Python标准库中的高级包，只使用标准库中的socket接口（我不是很明白套接字这个翻译，所以使用socket的英文名字），写一个Python服务器。
-
+在当今Python服务器框架（framework，比如`Django`、`Twisted`、`web.py`等等）横行的时代，从底层的socket开始写服务器似乎是一个出力不讨好的笨方法。框架的意义在于掩盖底层的细节，提供一套对于开发人员更加友好的API，并处理诸如MVC的布局问题。框架允许我们快速的构建一个成型而且成熟的Python服务器。然而，框架本身也是依赖于底层（比如socket）。对于底层socket的了解，不仅可以帮助我们更好的使用框架，更可以让我们明白框架是如何设计的。更进一步，如果拥有良好的底层socket编程知识和其他系统编程知识，你完全可以设计并开发一款自己的框架。如果你可以从底层socket开始，实现一个完整的Python服务器，支持用户层的协议，并处理好诸如MVC（Model-View-Control）、多线程（threading）等问题，并整理出一套清晰的函数或者类，作为接口（API）呈现给用户，你就相当于设计了一个框架。
-之前我的Python教程中有人留言，表示只学Python没有用，必须学会一个框架(比如Django和web.py)才能找到工作。而我的想法是，掌握一个类似于框架的高级工具是有用的，但是基础的东西可以让你永远不被淘汰。不要被工具限制了自己的发展。今天，我在这里想要展示的，就是不使用框架，甚至不使用Python标准库中的高级包，只使用标准库中的socket接口(我不是很明白套接字这个翻译，所以使用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这样一些效率比较高的语言，从而让服务器能更有效率的面对每天亿万次的请求。在这样一些时间，底层的重要性，就远远超过了框架。
-
-
+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/
-
-
##TCP/IP和socket
-我们需要对网络传输，特别是TCP/IP协议和socket有一定的了解。socket是进程间通信的一种方法 (参考Linux进程间通信)，它是基于网络传输协议的上层接口。socket有许多种类型，比如基于TCP协议或者UDP协议(两种网络传输协议)。其中又以TCP socket最为常用。TCP socket与双向管道(duplex PIPE)有些类似，一个进程向socket的一端写入或读取文本流，而另一个进程可以从socket的另一端读取或写入，比较特别是，这两个建立socket通信的进程可以分别属于两台不同的计算机。所谓的TCP协议，就是规定了一些通信的守则，以便在网络环境下能够有效实现上述进程间通信过程。双向管道(duplex PIPE)存活于同一台电脑中，所以不必区分两个进程的所在计算机的地址，而socket必须包含有地址信息，以便实现网络通信。一个socket包含四个地址信息: 两台计算机的IP地址和两个进程所使用的端口(port)。IP地址用于定位计算机，而port用于定位进程 (一台计算机上可以有多个进程分别使用不同的端口)。
-
-
-
-
+我们需要对网络传输，特别是TCP/IP协议和socket有一定的了解。socket是进程间通信的一种方法（参考Linux进程间通信），它是基于网络传输协议的上层接口。socket有许多种类型，比如基于TCP协议或者UDP协议（两种网络传输协议）。其中又以TCP socket最为常用。TCP socket与双向管道（duplex PIPE）有些类似，一个进程向socket的一端写入或读取文本流，而另一个进程可以从socket的另一端读取或写入，比较特别是，这两个建立socket通信的进程可以分别属于两台不同的计算机。所谓的TCP协议，就是规定了一些通信的守则，以便在网络环境下能够有效实现上述进程间通信过程。双向管道（duplex PIPE）存活于同一台电脑中，所以不必区分两个进程的所在计算机的地址，而socket必须包含有地址信息，以便实现网络通信。一个socket包含四个地址信息： 两台计算机的IP地址和两个进程所使用的端口（port）。IP地址用于定位计算机，而port用于定位进程（一台计算机上可以有多个进程分别使用不同的端口）。
一个TCP socket连接的网络
-
-
##TCP socket
在互联网上，我们可以让某台计算机作为服务器。服务器开放自己的端口，被动等待其他计算机连接。当其他计算机作为客户，主动使用socket连接到服务器的时候，服务器就开始为客户提供服务。
-
-
-在Python中，我们使用标准库中的socket包来进行底层的socket编程。
+在Python中，我们使用标准库中的`socket`包来进行底层的socket编程。
-首先是服务器端，我们使用bind()方法来赋予socket以固定的地址和端口，并使用listen()方法来被动的监听该端口。当有客户尝试用connect()方法连接的时候，服务器使用accept()接受连接，从而建立一个连接的socket：
+首先是服务器端，我们使用`bind()`方法来赋予socket以固定的地址和端口，并使用`listen()`方法来被动的监听该端口。当有客户尝试用`connect()`方法连接的时候，服务器使用`accept()`接受连接，从而建立一个连接的`socket`：
```python
# Written by Vamei
@@ -65,18 +46,17 @@ conn, addr = s.accept()
# receive message
request = conn.recv(1024)
-print 'request is: ',request
+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)。
-
+`socket.socket()`创建一个`socket`对象，并说明`socket`使用的是IPv4(`AF_INET`，IP version 4)和TCP协议(`SOCK_STREAM`)。
-然后用另一台电脑作为客户，我们主动使用connect()方法来搜索服务器端的IP地址(在Linux中，你可以用$ifconfig来查询自己的IP地址)和端口，以便客户可以找到服务器，并建立连接:
+然后用另一台电脑作为客户，我们主动使用`connect()`方法来搜索服务器端的IP地址(在Linux中，你可以用`$ifconfig`来查询自己的IP地址)和端口，以便客户可以找到服务器，并建立连接：
```python
# Written by Vamei
@@ -97,35 +77,25 @@ s.connect((HOST, PORT))
s.sendall(request)
# receive message
reply = s.recv(1024)
-print 'reply is: ',reply
+print 'reply is: ', reply
# close connection
s.close()
```
-在上面的例子中，我们对socket的两端都可以调用recv()方法来接收信息，调用sendall()方法来发送信息。这样，我们就可以在分处于两台计算机的两个进程间进行通信了。当通信结束的时候，我们使用close()方法来关闭socket连接。
-(如果没有两台计算机做实验，也可以将客户端IP想要connect的IP改为"127.0.0.1"，这是个特殊的IP地址，用来连接当地主机。)
+在上面的例子中，我们对socket的两端都可以调用`recv()`方法来接收信息，调用`sendall()`方法来发送信息。这样，我们就可以在分处于两台计算机的两个进程间进行通信了。当通信结束的时候，我们使用`close()`方法来关闭socket连接。
-
+（如果没有两台计算机做实验，也可以将客户端IP想要connect的IP改为"`127.0.0.1`"，这是个特殊的IP地址，用来连接当地主机。）
##基于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协议对这两个文本都有一定的格式要求。
+上面的例子中，我们已经可以使用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服务器端：
+
```python
# Written by Vamei
@@ -149,7 +119,7 @@ Content-Type: text/html
'''
# Read picture, put into HTTP format
-f = open('test.jpg','rb')
+f = open('test.jpg', 'rb')
pic_content = '''HTTP/1.x 200 OK
Content-Type: image/jpg
@@ -167,8 +137,8 @@ while True:
s.listen(3)
conn, addr = s.accept()
request = conn.recv(1024)
- method = request.split(' ')[0]
- src = request.split(' ')[1]
+ method = request.split(' ')[0]
+ src = request.split(' ')[1]
# deal with GET method
if method == 'GET':
@@ -186,58 +156,46 @@ while True:
##深入HTTP服务器程序
-如我们上面所看到的，服务器会根据request向客户传输的两条信息text_content和pic_content中的一条，作为response文本。整个response分为起始行(start line), 头信息(head)和主体(body)三部分。起始行就是第一行:
+如我们上面所看到的，服务器会根据`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)。
+它实际上又由空格分为三个片段，`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系统下，则不需要区分文本文件和二进制文件。)
-
-
+（注意，对于jpg文件，我们使用`'rb'`模式打开，是为了与windows兼容。因为在windows下，jpg被认为是二进制（binary）文件，在UNIX系统下，则不需要区分文本文件和二进制文件。）
我们并没有写客户端程序，后面我们会用浏览器作为客户端。request由客户端程序发给服务器。尽管request也可以像response那样分为三部分，request的格式与response的格式并不相同。request由客户发送给服务器，比如下面是一个request：
+```quote
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被发送回给客户端。
+起始行可以分为三部分，第一部分为请求方法（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`被发送回给客户端。
##使用浏览器实验
-为了配合上面的服务器程序，我已经在放置Python程序的文件夹里，保存了一个test.jpg图片文件。我们在终端运行上面的Python程序，作为服务器端，再打开一个浏览器作为客户端。(如果有时间，你也完全可以用Python写一个客户端。原理与上面的TCP socket的客户端程序相类似。)
+为了配合上面的服务器程序，我已经在放置Python程序的文件夹里，保存了一个`test.jpg`图片文件。我们在终端运行上面的Python程序，作为服务器端，再打开一个浏览器作为客户端。（如果有时间，你也完全可以用Python写一个客户端。原理与上面的TCP socket的客户端程序相类似。）
-在浏览器的地址栏输入:
+在浏览器的地址栏输入：
+```quote
127.0.0.1:8000
-
-
-(当然，你也可以用令一台电脑，并输入服务器的IP地址。) 我得到下面的结果:
-
-
-
+```
+（当然，你也可以用令一台电脑，并输入服务器的IP地址。）我得到下面的结果：
OK，我已经有了一个用Python实现的，并从socket写起的服务器了。
-从终端，我们可以看到，浏览器实际上发出了两个请求。第一个请求为 (关键信息在起始行，这一个请求的主体为空):
+从终端，我们可以看到，浏览器实际上发出了两个请求。第一个请求为（关键信息在起始行，这一个请求的主体为空）：
-```bash
+```quote
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
@@ -247,13 +205,11 @@ Accept-Encoding: gzip, deflate
Connection: keep-alive
```
-我们的Python程序根据这个请求，发送给服务器text_content的内容。
+我们的Python程序根据这个请求，发送给服务器`text_content`的内容。
-
+浏览器接收到`text_content`之后，发现正文的html文本中有`
`，知道需要获得`text.jpg`文件来补充为图片，立即发出了第二个请求：
-浏览器接收到text_content之后，发现正文的html文本中有，知道需要获得text.jpg文件来补充为图片，立即发出了第二个请求:
-
-```bash
+```quote
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
@@ -264,31 +220,26 @@ 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)
+我们的Python程序分析过起始行之后，发现`/test.jpg`符合`if`条件，所以将`pic_content`发送给客户。
-
+最后，浏览器根据html语言的语法，将html文本和图画以适当的方式显示出来。（html可参考http://www.w3schools.com/html/default.asp）
##探索的方向
-1) 在我们上面的服务器程序中，我们用while循环来让服务器一直工作下去。实际上，我们还可以根据我之前介绍的多线程的知识，将while循环中的内容改为多进程或者多线程工作。(参考Python多线程与同步，Python多进程初步，Python多进程探索)
+1) 在我们上面的服务器程序中，我们用`while`循环来让服务器一直工作下去。实际上，我们还可以根据我之前介绍的多线程的知识，将`while`循环中的内容改为多进程或者多线程工作。（参考Python多线程与同步，Python多进程初步，Python多进程探索）
2) 我们的服务器程序还不完善，我们还可以让我们的Python程序调用Python的其他功能，以实现更复杂的功能。比如说制作一个时间服务器，让服务器向客户返回日期和时间。你还可以使用Python自带的数据库，来实现一个完整的LAMP服务器。
-3) socket包是比较底层的包。Python标准库中还有高层的包，比如SocketServer，SimpleHTTPServer，CGIHTTPServer，cgi。这些都包都是在帮助我们更容易的使用socket。如果你已经了解了socket，那么这些包就很容易明白了。利用这些高层的包，你可以写一个相当成熟的服务器。
+3) `socket`包是比较底层的包。Python标准库中还有高层的包，比如`SocketServer`，`SimpleHTTPServer`，`CGIHTTPServer`，`cgi`。这些都包都是在帮助我们更容易的使用socket。如果你已经了解了socket，那么这些包就很容易明白了。利用这些高层的包，你可以写一个相当成熟的服务器。
4) 在经历了所有的辛苦和麻烦之后，你可能发现，框架是那么的方便，所以决定去使用框架。或者，你已经有了参与到框架开发的热情。
-
-
更多内容
-TCP/IP和port参考: TCP/IP illustrated http://book.douban.com/subject/1741925/
+TCP/IP和port参考：TCP/IP illustrated http://book.douban.com/subject/1741925/
-socket参考: UNIX Network Programming http://book.douban.com/subject/1756533/
+socket参考：UNIX Network Programming http://book.douban.com/subject/1756533/
Python socket 官方文档 http://docs.python.org/2/library/socket.html
-HTTP参考: HTTP, the definitive guide http://book.douban.com/subject/1440226/
-
+HTTP参考：HTTP, the definitive guide http://book.douban.com/subject/1440226/
\ No newline at end of file
diff --git "a/content/\347\275\221\347\273\23402 Python\346\234\215\345\212\241\345\231\250\350\277\233\345\214\226.md" "b/content/\347\275\221\347\273\23402 Python\346\234\215\345\212\241\345\231\250\350\277\233\345\214\226.md"
index 500afb1..db34668 100644
--- "a/content/\347\275\221\347\273\23402 Python\346\234\215\345\212\241\345\231\250\350\277\233\345\214\226.md"
+++ "b/content/\347\275\221\347\273\23402 Python\346\234\215\345\212\241\345\231\250\350\277\233\345\214\226.md"
@@ -1,17 +1,14 @@
#Python网络02 Python服务器进化
+**注意，在Python 3.x中，`BaseHTTPServer`、`SimpleHTTPServer`、`CGIHTTPServer`整合到`http.server`包，`SocketServer`改名为`socketserver`，请注意查阅官方文档。
-**注意，在Python 3.x中，BaseHTTPServer, SimpleHTTPServer, CGIHTTPServer整合到http.server包，SocketServer改名为socketserver，请注意查阅官方文档。
-
-在上一篇文章中(用socket写一个Python服务器)，我使用socket接口，制作了一个处理HTTP请求的Python服务器。任何一台装有操作系统和Python解释器的计算机，都可以作为HTTP服务器使用。我将在这里不断改写上一篇文章中的程序，引入更高级的Python包，以写出更成熟的Python服务器。
-
-
+在上一篇文章中（用`socket`写一个Python服务器），我使用`socket`接口，制作了一个处理HTTP请求的Python服务器。任何一台装有操作系统和Python解释器的计算机，都可以作为HTTP服务器使用。我将在这里不断改写上一篇文章中的程序，引入更高级的Python包，以写出更成熟的Python服务器。
##支持POST
-我首先增加该服务器的功能。这里增添了表格，以及处理表格提交数据的"POST"方法。如果你已经读过用socket写一个Python服务器，会发现这里只是增加很少的一点内容。
+我首先增加该服务器的功能。这里增添了表格，以及处理表格提交数据的`"POST"`方法。如果你已经读过用`socket`写一个Python服务器，会发现这里只是增加很少的一点内容。
-原始程序:
+原始程序：
```python
# Written by Vamei
@@ -27,15 +24,15 @@ text_content = '''HTTP/1.x 200 OK
Content-Type: text/html
-WOW
+ WOW
-Wow, Python Server
-
-
+ Wow, Python Server
+
+
'''
@@ -44,6 +41,7 @@ pic_content = '''HTTP/1.x 200 OK
Content-Type: image/jpg
'''
+
pic_content = pic_content + f.read()
# Configure socket
@@ -84,31 +82,20 @@ while True:
# close connection
conn.close()
```
+
服务器进行的操作很简单，即从POST请求中提取数据，再显示在屏幕上。
运行上面Python服务器，像上一篇文章那样，使用一个浏览器打开。
-
-
-
-
-
-
-页面新增了表格和提交(submit)按钮。在表格中输入aa并提交，页面显示出aa。
-
-
+页面新增了表格和提交（submit）按钮。在表格中输入`aa`并提交，页面显示出`aa`。
我下一步要用一些高级包，来简化之前的代码。
-
-
-
-
##使用SocketServer
-首先使用SocketServer包来方便的架设服务器。在上面使用socket的过程中，我们先设置了socket的类型，然后依次调用bind(),listen(),accept()，最后使用while循环来让服务器不断的接受请求。上面的这些步骤可以通过SocketServer包来简化。
+首先使用`SocketServer`包来方便的架设服务器。在上面使用`socket`的过程中，我们先设置了`socket`的类型，然后依次调用`bind()`、`listen()`、`accept()`，最后使用`while`循环来让服务器不断的接受请求。上面的这些步骤可以通过`SocketServer`包来简化。
-SocketServer:
+SocketServer：
```python
# Written by Vamei
@@ -123,15 +110,15 @@ text_content = '''HTTP/1.x 200 OK
Content-Type: text/html
-WOW
+ WOW
-Wow, Python Server
-
-
+ Wow, Python Server
+
+
'''
@@ -140,6 +127,7 @@ pic_content = '''HTTP/1.x 200 OK
Content-Type: image/jpg
'''
+
pic_content = pic_content + f.read()
# This class defines response to each request
@@ -172,74 +160,57 @@ class MyTCPHandler(SocketServer.BaseRequestHandler):
# ...
######
-
# 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的客户端地址。
+我建立了一个`TCPServer`对象，即一个使用TCP socket的服务器。在建立`TCPServe`的同时，设置该服务器的IP地址和端口。使用`server_forever()`方法来让服务器不断工作（就像原始程序中的`while`循环一样）。
-
+我们传递给`TCPServer`一个`MyTCPHandler`类。这个类定义了如何操作`socket`。`MyTCPHandler`继承自`BaseRequestHandler`。改写`handler()`方法，来具体规定不同情况下服务器的操作。
-经过SocketServer的改造之后，代码还是不够简单。 我们上面的通信基于TCP协议，而不是HTTP协议。因此，我们必须手动的解析HTTP协议。我们将建立基于HTTP协议的服务器。
+在`handler()`中，通过`self.request`来查询通过`socket`进入服务器的请求（正如我们在`handler()`中对`socket`进行`recv()`和`sendall()`操作），还使用`self.address`来引用`socket`的客户端地址。
-
+经过`SocketServer`的改造之后，代码还是不够简单。 我们上面的通信基于TCP协议，而不是HTTP协议。因此，我们必须手动的解析HTTP协议。我们将建立基于HTTP协议的服务器。
-##SimpleHTTPServer: 使用静态文件来回应请求
+##SimpleHTTPServer：使用静态文件来回应请求
HTTP协议基于TCP协议，但增加了更多的规范。这些规范，虽然限制了TCP协议的功能，但大大提高了信息封装和提取的方便程度。
-对于一个HTTP请求(request)来说，它包含有两个重要信息：请求方法和URL。
+对于一个HTTP请求（request）来说，它包含有两个重要信息：请求方法和URL。
-请求方法(request method) 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协议将文件发送给客户。
-
-
-
+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`文件。
-我们将text_content放置在index.html中，并单独存储text.jpg文件。如果URL指向index_html的母文件夹时，SimpleHTTPServer会读取该文件夹下的index.html文件。
+我在当前目录下生成`index.html`文件：
-
-
-我在当前目录下生成index.html文件:
-
-```python
+```html
-WOW
+ WOW
-Wow, Python Server
-
-
+ Wow, Python Server
+
+
```
-
-改写Python服务器程序。使用SimpleHTTPServer包中唯一的类SimpleHTTPRequestHandler:
+改写Python服务器程序。使用`SimpleHTTPServer`包中唯一的类`SimpleHTTPRequestHandler`：
```python
# Written by Vamei
@@ -256,35 +227,26 @@ server = SocketServer.TCPServer((HOST, PORT), SimpleHTTPServer.SimpleHTTPRequest
# Start the server
server.serve_forever()
```
-
这里的程序不能处理POST请求。我会在后面使用CGI来弥补这个缺陷。值得注意的是，Python服务器程序变得非常简单。将内容存放于静态文件，并根据URL为客户端提供内容，这让内容和服务器逻辑分离。每次更新内容时，我可以只修改静态文件，而不用停止整个Python服务器。
-这些改进也付出代价。在原始程序中，request中的URL只具有指导意义，我可以规定任意的操作。在SimpleHTTPServer中，操作与URL的指向密切相关。我用自由度，换来了更加简洁的程序。
-
-
+这些改进也付出代价。在原始程序中，`request`中的URL只具有指导意义，我可以规定任意的操作。在`SimpleHTTPServer`中，操作与URL的指向密切相关。我用自由度，换来了更加简洁的程序。
##CGIHTTPServer：使用静态文件或者CGI来回应请求
-CGIHTTPServer包中的CGIHTTPRequestHandler类继承自SimpleHTTPRequestHandler类，所以可以用来代替上面的例子，来提供静态文件的服务。此外，CGIHTTPRequestHandler类还可以用来运行CGI脚本。
-
-
+`CGIHTTPServer`包中的`CGIHTTPRequestHandler`类继承自`SimpleHTTPRequestHandler`类，所以可以用来代替上面的例子，来提供静态文件的服务。此外，`CGIHTTPRequestHandler`类还可以用来运行CGI脚本。
CGIHTTPServer
-
+先看看什么是CGI（Common Gateway Interface）。CGI是服务器和应用脚本之间的一套接口标准。它的功能是让服务器程序运行脚本程序，将程序的输出作为`response`发送给客户。总体的效果，是允许服务器动态的生成回复内容，而不必局限于静态文件。
-先看看什么是CGI (Common Gateway Interface)。CGI是服务器和应用脚本之间的一套接口标准。它的功能是让服务器程序运行脚本程序，将程序的输出作为response发送给客户。总体的效果，是允许服务器动态的生成回复内容，而不必局限于静态文件。
-
-支持CGI的服务器程接收到客户的请求，根据请求中的URL，运行对应的脚本文件。服务器会将HTTP请求的信息和socket信息传递给脚本文件，并等待脚本的输出。脚本的输出封装成合法的HTTP回复，发送给客户。CGI可以充分发挥服务器的可编程性，让服务器变得“更聪明”。
+支持CGI的服务器程接收到客户的请求，根据请求中的URL，运行对应的脚本文件。服务器会将HTTP请求的信息和`socket`信息传递给脚本文件，并等待脚本的输出。脚本的输出封装成合法的HTTP回复，发送给客户。CGI可以充分发挥服务器的可编程性，让服务器变得“更聪明”。
服务器和CGI脚本之间的通信要符合CGI标准。CGI的实现方式有很多，比如说使用Apache服务器与Perl写的CGI脚本，或者Python服务器与shell写的CGI脚本。
-
-
-为了使用CGI，我们需要使用BaseHTTPServer包中的HTTPServer类来构建服务器。Python服务器的改动很简单。
+为了使用CGI，我们需要使用`BaseHTTPServer`包中的`HTTPServer`类来构建服务器。Python服务器的改动很简单。
-CGIHTTPServer:
+CGIHTTPServer：
```python
# Written by Vamei
@@ -301,26 +263,24 @@ server = BaseHTTPServer.HTTPServer((HOST, PORT), CGIHTTPServer.CGIHTTPRequestHan
# Start the server
server.serve_forever()
```
-
-CGIHTTPRequestHandler默认当前目录下的cgi-bin和ht-bin文件夹中的文件为CGI脚本，而存放于其他地方的文件被认为是静态文件。因此，我们需要修改一下index.html，将其中form元素指向的action改为cgi-bin/post.py。
+`CGIHTTPRequestHandler`默认当前目录下的`cgi-bin和`ht-bin`文件夹中的文件为CGI脚本，而存放于其他地方的文件被认为是静态文件。因此，我们需要修改一下`index.html`，将其中`form`元素指向的`action`改为`cgi-bin/post.py`。
-```python
+```html
-WOW
+ WOW
-Wow, Python Server
-
-
+ Wow, Python Server
+
+
```
-
-我创建一个cgi-bin的文件夹，并在cgi-bin中放入如下post.py文件，也就是我们的CGI脚本：
+我创建一个`cgi-bin`的文件夹，并在`cgi-bin`中放入如下`post.py`文件，也就是我们的CGI脚本：
```python
#!/usr/bin/env python
@@ -334,18 +294,17 @@ print # blank line, end of headers
print "Hello world!
" # Start of content
print "" + repr(form['firstname']) + "
"
```
-(post.py需要有执行权限，见评论区)
-第一行说明了脚本所使用的语言，即Python。 cgi包用于提取请求中包含的表格信息。脚本只负责将所有的结果输出到标准输出(使用print)。CGIHTTPRequestHandler会收集这些输出，封装成HTTP回复，传送给客户端。
+（post.py需要有执行权限，见评论区）
-对于POST方法的请求，它的URL需要指向一个CGI脚本(也就是在cgi-bin或者ht-bin中的文件)。CGIHTTPRequestHandler继承自SimpleHTTPRequestHandler，所以也可以处理GET方法和HEAD方法的请求。此时，如果URL指向CGI脚本时，服务器将脚本的运行结果传送到客户端；当此时URL指向静态文件时，服务器将文件的内容传送到客户端。
+第一行说明了脚本所使用的语言，即Python。 `cgi`包用于提取请求中包含的表格信息。脚本只负责将所有的结果输出到标准输出（使用`print`）。`CGIHTTPRequestHandler`会收集这些输出，封装成HTTP回复，传送给客户端。
-更进一步，我可以让CGI脚本执行数据库操作，比如将接收到的数据放入到数据库中，以及更丰富的程序操作。相关内容从略。
+对于POST方法的请求，它的URL需要指向一个CGI脚本（也就是在`cgi-bin`或者`ht-bin`中的文件）。`CGIHTTPRequestHandler`继承自`SimpleHTTPRequestHandler`，所以也可以处理GET方法和HEAD方法的请求。此时，如果URL指向CGI脚本时，服务器将脚本的运行结果传送到客户端；当此时URL指向静态文件时，服务器将文件的内容传送到客户端。
-
+更进一步，我可以让CGI脚本执行数据库操作，比如将接收到的数据放入到数据库中，以及更丰富的程序操作。相关内容从略。
##总结
我使用了Python标准库中的一些高级包简化了Python服务器。最终的效果分离静态内容、CGI应用和服务器，降低三者之间的耦合，让代码变得简单而容易维护。
-希望你享受在自己的电脑上架设服务器的过程。
+希望你享受在自己的电脑上架设服务器的过程。
\ No newline at end of file
diff --git "a/content/\350\241\245\345\205\20502 Python\345\260\217\346\212\200\345\267\247.md" "b/content/\350\241\245\345\205\20502 Python\345\260\217\346\212\200\345\267\247.md"
index 326e158..f0dd026 100644
--- "a/content/\350\241\245\345\205\20502 Python\345\260\217\346\212\200\345\267\247.md"
+++ "b/content/\350\241\245\345\205\20502 Python\345\260\217\346\212\200\345\267\247.md"
@@ -1,21 +1,16 @@
##Python补充02 Python小技巧
-
-
-
在这里列举一些我使用Python时积累的小技巧。这些技巧是我在使用Python过程中经常使用的。之前很零碎的记在笔记本中，现在整理出来，和大家分享，也作为Python快速教程的一个补充。
-
-
##import模块
-在Python经常使用import声明，以使用其他模块(也就是其它.py文件)中定义的对象。
+在Python经常使用`import`声明，以使用其他模块（也就是其它.py文件）中定义的对象。
-1) 使用__name__
+1) 使用`__name__`
-当我们编写Python库模块的时候，我们往往运行一些测试语句。当这个程序作为库被import的时候，我们并不需要运行这些测试语句。一种解决方法是在import之前，将模块中的测试语句注释掉。Python有一种更优美的解决方法，就是使用__name__。
+当我们编写Python库模块的时候，我们往往运行一些测试语句。当这个程序作为库被`import`的时候，我们并不需要运行这些测试语句。一种解决方法是在`import`之前，将模块中的测试语句注释掉。Python有一种更优美的解决方法，就是使用`__name__`。
-下面是一个简单的库程序TestLib.py。当直接运行TestLib.py时，__name__为"__main__"。如果被import的话，__name__为"TestLib"。
+下面是一个简单的库程序`TestLib.py`。当直接运行`TestLib.py`时，`__name__`为`"__main__"`。如果被`import`的话，`__name__`为`"TestLib"`。
```python
def lib_func(a):
@@ -28,35 +23,42 @@ if __name__ == '__main__':
test = 101
print(lib_func(test))
```
- 我们在user.py中import上面的TestLib。
+
+我们在user.py中import上面的TestLib。
```python
import TestLib
print(TestLib.lib_func(120))
```
- 你可以尝试不在TestLib.py中使用if __name__=='__main__'， 并对比运行结果。
-
+你可以尝试不在`TestLib.py`中使用`if __name__ ==' __main__'`， 并对比运行结果。
-2) 更多import使用方式
+2) 更多`import`使用方式
-import TestLib as test # 引用TestLib模块，并将它改名为t
+```python
+import TestLib as test # 引用TestLib模块，并将它改名为t。
+```
+
+比如：
-比如:
```pyhton
import TestLib as t
print(t.lib_func(120))
-from TestLib import lib_func # 只引用TestLib中的lib_func对象，并跳过TestLib引用字段
+from TestLib import lib_func # 只引用TestLib中的lib_func对象，并跳过TestLib引用字段。
```
+
这样的好处是减小所引用模块的内存占用。
比如：
-```ython
+
+```python
from TestLib import lib_func
print(lib_func(120))
-from TestLib import * # 引用所有TestLib中的对象，并跳过TestLib引用字段
+from TestLib import * # 引用所有TestLib中的对象，并跳过TestLib引用字段。
```
-比如:
+
+比如：
+
```python
from TestLib import *
print(lib_func(120))
@@ -67,6 +69,7 @@ print(lib_func(120))
1) 查询函数的参数
当我们想要知道某个函数会接收哪些参数的时候，可以使用下面方法查询。
+
```python
import inspect
print(inspect.getargspec(func))
@@ -74,14 +77,17 @@ print(inspect.getargspec(func))
2) 查询对象的属性
-除了使用dir()来查询对象的属性之外，我们可以使用下面内置(built-in)函数来确认一个对象是否具有某个属性：
+除了使用`dir()`来查询对象的属性之外，我们可以使用下面内置（built-in）函数来确认一个对象是否具有某个属性：
-hasattr(obj, attr_name) # attr_name是一个字符串
+```python
+hasattr(obj, attr_name) # attr_name是一个字符串。
+```
例如：
+
```python
-a = [1,2,3]
-print(hasattr(a,'append'))
+a = [1, 2, 3]
+print(hasattr(a, 'append'))
```
2) 查询对象所属的类和类名称
@@ -93,23 +99,25 @@ print a.__class__.__name__
3) 查询父类
-我们可以用__base__属性来查询某个类的父类：
-
-cls.__base__
+我们可以用`__base__`属性来查询某个类的父类：`cls.__base__`。
例如：
+
```python
print(list.__base__)
```
-##使用中文(以及其它非ASCII编码)
+##使用中文（以及其它非ASCII编码）
+
+在Python程序的第一行加入`#coding=utf8`，例如：
-在Python程序的第一行加入#coding=utf8，例如:
```python
#coding=utf8
print("你好吗？")
```
+
也能用以下方式：
+
```python
#-*- coding: UTF-8 -*-
print("你好吗？")
@@ -117,13 +125,16 @@ print("你好吗？")
##表示2进制，8进制和16进制数字
-在2.6以上版本，以如下方式表示
+在2.6以上版本，以如下方式表示：
+
```python
print(0b1110) # 二进制，以0b开头
print(0o10) # 八进制，以0o开头
print(0x2A) # 十六进制，以0x开头
```
+
如果是更早版本，可以用如下方式：
+
```python
print(int("1110", 2))
print(int("10", 8))
@@ -132,9 +143,9 @@ print(int("2A", 16))
##注释
-一行内的注释可以以#开始
+一行内的注释可以以`#`开始。
-多行的注释可以以'''开始，以'''结束，比如
+多行的注释可以以`'''`开始，以`'''`结束，比如：
```python
'''
@@ -148,59 +159,62 @@ def func():
# main
func()
```
-注释应该和所在的程序块对齐。
-
+注释应该和所在的程序块对齐。
##搜索路径
-当我们import的时候，Python会在搜索路径中查找模块(module)。比如上面import TestLib，就要求TestLib.py在搜索路径中。
+当我们`import`的时候，Python会在搜索路径中查找模块（module）。比如上面`import TestLib`，就要求`TestLib.py`在搜索路径中。
我们可以通过下面方法来查看搜索路径：
+
```python
import sys
print(sys.path)
```
-我们可以在Python运行的时候增加或者删除sys.path中的元素。另一方面，我们可以通过在shell中增加PYTHONPATH环境变量，来为Python增加搜索路径。
-下面我们增加/home/vamei/mylib到搜索路径中：
+我们可以在Python运行的时候增加或者删除`sys.path`中的元素。另一方面，我们可以通过在Shell中增加`PYTHONPATH`环境变量，来为Python增加搜索路径。
-$export PYTHONPATH=$PYTHONPATH:/home/vamei/mylib
+下面我们增加`/home/vamei/mylib`到搜索路径中：
-你可以将正面的这行命令加入到～/.bashrc中。这样，我们就长期的改变了搜索路径。
+```bash
+$export PYTHONPATH=$PYTHONPATH:/home/vamei/mylib
+```
-
+你可以将正面的这行命令加入到`~/.bashrc`（不同系统下，此文件可能为`~/.bash_profile`、`~/.profile`等）中。这样，我们就长期的改变了搜索路径。
##脚本与命令行结合
可以使用下面方法运行一个Python脚本，在脚本运行结束后，直接进入Python命令行。这样做的好处是脚本的对象不会被清空，可以通过命令行直接调用。
+
```python
$python -i script.py
```
-
##安装非标准包
Python的标准库随着Python一起安装。当我们需要非标准包时，就要先安装。
-1) 使用Linux repository (Linux环境)
-
-这是安装Python附加包的一个好的起点。你可以在Linux repository中查找可能存在的Python包 (比如在Ubuntu Software Center中搜索matplot)。
-
-2) 使用pip。pip是Python自带的包管理程序，它连接Python repository，并查找其中可能存在的包。
+1) 使用Linux repository（Linux环境）
-比如使用如下方法来安装、卸载或者升级web.py：
+这是安装Python附加包的一个好的起点。你可以在Linux repository中查找可能存在的Python包（比如在Ubuntu Software Center中搜索“matplot”）。
-$pip install web.py
+2) 使用`pip`。`pip`是Python自带的包管理程序，它连接Python repository，并查找其中可能存在的包。
-$pip uninstall web.py
+比如使用如下方法来安装、卸载或者升级`web.py`：
-$pip install --upgrade web.py
+```bash
+$pip install web.py # 安装
+$pip uninstall web.py # 卸载
+$pip install --upgrade web.py # 升级
+```
-如果你的Python安装在一个非标准的路径(使用$which python来确认python可执行文件的路径)中，比如/home/vamei/util/python/bin中，你可以使用下面方法设置pip的安装包的路径:
+如果你的Python安装在一个非标准的路径（使用`$which python`来确认python可执行文件的路径）中，比如`/home/vamei/util/python/bin`中，你可以使用下面方法设置`pip`的安装包的路径：
+```bash
$pip install --install-option="--prefix=/home/vamei/util/" web.py
+```
3) 从源码编译
-如果上面方法都没法找到你想要的库，你可能需要从源码开始编译。Google往往是最好的起点。
+如果上面方法都没法找到你想要的库，你可能需要从源码开始编译。Google往往是最好的起点。
\ No newline at end of file
diff --git "a/content/\350\241\245\345\205\20503 Python\345\206\205\347\275\256\345\207\275\346\225\260\346\270\205\345\215\225.md" "b/content/\350\241\245\345\205\20503 Python\345\206\205\347\275\256\345\207\275\346\225\260\346\270\205\345\215\225.md"
index 8e62ab5..c14d789 100644
--- "a/content/\350\241\245\345\205\20503 Python\345\206\205\347\275\256\345\207\275\346\225\260\346\270\205\345\215\225.md"
+++ "b/content/\350\241\245\345\205\20503 Python\345\206\205\347\275\256\345\207\275\346\225\260\346\270\205\345\215\225.md"
@@ -1,114 +1,76 @@
-
##Python补充03 Python内置函数清单
+Python内置（built-in）函数随着python解释器的运行而创建。在Python的程序中，你可以随时调用这些函数，不需要定义。最常见的内置函数是：
-
-
-Python内置(built-in)函数随着python解释器的运行而创建。在Python的程序中，你可以随时调用这些函数，不需要定义。最常见的内置函数是:
-
+```python
print("Hello World!")
+```
-在Python教程中，我们已经提到下面一些内置函数:
-
-基本数据类型 type()
+在Python教程中，我们已经提到下面一些内置函数：
-反过头来看看 dir() help() len()
+基本数据类型：`type()`。
-词典 len()
+反过头来看看：`dir()`、`help()`、`len()`。
-文本文件的输入输出 open()
+词典：`len()`。
-循环设计 range() enumerate() zip()
+文本文件的输入输出：`open()`。
-循环对象 iter()
+循环设计：`range()`、`enumerate()`、`zip()`。
-函数对象 map() filter() reduce()
+循环对象：`iter()`。
-
+函数对象：`map()`、`filter()`、`reduce()`。
下面我采取的都是实际的参数，你可以直接在命令行尝试效果。
##数学运算
-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]) # 求和
-
-
+```python
+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]) # 求和。
+```
##类型转换
-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
+```python
+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。
+```
-dict(a=1,b="hello",c=[1,2,3]) # 构建词典 dictionary
+在Python中，下列对象都相当于`False`：`[]`、`()`、`{}`、`0`、`None`、`0.0`、`''`（空字符串）。
-
+```python
+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。
+```
##序列操作
-all([True, 1, "hello!"]) # 是否所有的元素都相当于True值
-
-any(["", 0, False, [], None]) # 是否有任意一个元素相当于True值
-
-
-
-
-
-sorted([1,5,3]) # 返回正序的序列，也就是[1,3,5]
-
-reversed([1,5,3]) # 返回反序的序列，也就是[3,5,1]
-
-
+```python
+all([True, 1, "hello!"]) # 是否所有的元素都相当于True值。
+any(["", 0, False, [], None]) # 是否有任意一个元素相当于True值。
+sorted([1, 5, 3]) # 返回正序的序列，也就是[1, 3, 5]。
+reversed([1, 5, 3]) # 返回反序的序列，也就是[3, 5, 1]。
+```
##类，对象，属性
@@ -122,43 +84,28 @@ 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类的子类
-
-
+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类的子类。
+```
##编译，执行
-repr(me) # 返回对象的字符串表达
-
-compile("print('Hello')",'test.py','exec') # 编译字符串成为code对象
-
-eval("1 + 1") # 解释字符串表达式。参数也可以是compile()返回的code对象
-
-exec("print('Hello')") # 解释并执行字符串，print('Hello')。参数也可以是compile()返回的code对象
-
-
-
-##s其他
-
-input("Please input:") # 等待输入
-
-
-
-globals() # 返回全局命名空间，比如全局变量名，全局函数名
-
-locals() # 返回局部命名空间
-
-
+```python
+repr(me) # 返回对象的字符串表达。
+compile("print('Hello')",'test.py','exec') # 编译字符串成为code对象。
+eval("1 + 1") # 解释字符串表达式。参数也可以是compile()返回的code对象。
+exec("print('Hello')") # 解释并执行字符串，print('Hello')。参数也可以是compile()返回的code对象。
+```
+##其他
+```python
+input("Please input:") # 等待输入。
+globals() # 返回全局命名空间，比如全局变量名，全局函数名。
+locals() # 返回局部命名空间。
+```
\ No newline at end of file
diff --git "a/content/\350\241\245\345\205\20505 \345\255\227\347\254\246\344\270\262\346\240\274\345\274\217\345\214\226 (%\346\223\215\344\275\234\347\254\246).md" "b/content/\350\241\245\345\205\20505 \345\255\227\347\254\246\344\270\262\346\240\274\345\274\217\345\214\226 (%\346\223\215\344\275\234\347\254\246).md"
index d560425..88250bb 100644
--- "a/content/\350\241\245\345\205\20505 \345\255\227\347\254\246\344\270\262\346\240\274\345\274\217\345\214\226 (%\346\223\215\344\275\234\347\254\246).md"
+++ "b/content/\350\241\245\345\205\20505 \345\255\227\347\254\246\344\270\262\346\240\274\345\274\217\345\214\226 (%\346\223\215\344\275\234\347\254\246).md"
@@ -1,106 +1,100 @@
#Python补充05 字符串格式化 (%操作符)
-
-
-
-在许多编程语言中都包含有格式化字符串的功能，比如C和Fortran语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作%。
-
-
+在许多编程语言中都包含有格式化字符串的功能，比如C和Fortran语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作`%`。
##模板
-格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个tuple将多个值传递给模板，每个值对应一个格式符。
+格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个`tuple`将多个值传递给模板，每个值对应一个格式符。
比如下面的例子：
+
```python
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"`为我们的模板。`%s`为第一个格式符，表示一个字符串。`%d`为第二个格式符，表示一个整数。`('Vamei', 99)`的两个元素`'Vamei'`和`99`为替换`%s`和`%d`的真实值。
+
+在模板和`tuple`之间，有一个`%`号分隔，它代表了格式化操作。
+
+整个`"I'm %s. I'm %d year old" % ('Vamei', 99)`实际上构成一个字符串表达式。我们可以像一个正常的字符串那样，将它赋值给某个变量。比如：
-整个"I'm %s. I'm %d year old" % ('Vamei', 99) 实际上构成一个字符串表达式。我们可以像一个正常的字符串那样，将它赋值给某个变量。比如:
```python
a = "I'm %s. I'm %d year old" % ('Vamei', 99)
print(a)
```
我们还可以用词典来传递真实值。如下：
+
```python
print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99}
```
-可以看到，我们对两个格式符进行了命名。命名使用()括起来。每个命名对应词典的一个key。
-
+可以看到，我们对两个格式符进行了命名。命名使用`()`括起来。每个命名对应词典的一个`key`。
格式符
-格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:
-
-%s 字符串 (采用str()的显示)
-
-%r 字符串 (采用repr()的显示)
+格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下：
-%c 单个字符
+`%s` 字符串（采用`str()`的显示）
-%b 二进制整数
+`%r` 字符串（采用`repr()`的显示）
-%d 十进制整数
+`%c` 单个字符
-%i 十进制整数
+`%b` 二进制整数
-%o 八进制整数
+`%d` 十进制整数
-%x 十六进制整数
+`%i` 十进制整数
-%e 指数 (基底写为e)
+`%o` 八进制整数
-%E 指数 (基底写为E)
+`%x` 十六进制整数
-%f 浮点数
+`%e` 指数（基底写为e）
-%F 浮点数，与上相同
+`%E` 指数（基底写为E）
-%g 指数(e)或浮点数 (根据显示长度)
+`%f` 浮点数
-%G 指数(E)或浮点数 (根据显示长度)
+`%F` 浮点数，与上相同
-
+`%g` 指数（e）或浮点数（根据显示长度）
-%% 字符"%"
+`%G` 指数（E）或浮点数（根据显示长度）
-
+`%%` 字符"%"
可以用如下的方式，对格式进行进一步的控制：
-%[(name)][flags][width].[precision]typecode
+`%[(name)][flags][width].[precision]typecode`
-(name)为命名
+`(name)`为命名。
-flags可以有+,-,' '或0。+表示右对齐。-表示左对齐。' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。
+`flags`可以有`+`、`-`、`一个空格`或`0`。`+`表示右对齐。`-`表示左对齐。`一个空格`表示在正数的左侧填充一个空格，从而与负数对齐。`0`表示使用0填充。
-width表示显示宽度
+`width`表示显示宽度。
-precision表示小数点后精度
-
-
+`precision`表示小数点后精度。
比如：
+
```python
print("%+10x" % 10)
print("%04d" % 5)
print("%6.3f" % 2.3)
```
-上面的width, precision为两个整数。我们可以利用*，来动态代入这两个量。比如：
+上面的`width`、 `precision`为两个整数。我们可以利用`*`，来动态代入这两个量。比如：
+
```python
print("%.*f" % (4, 1.2))
```
-Python实际上用4来替换*。所以实际的模板为"%.4f"。
-
+Python实际上用`4`来替换`*`。所以实际的模板为`"%.4f"`。
##总结
-Python中内置的%操作符可用于格式化字符串操作，控制字符串的呈现格式。Python中还有其他的格式化字符串的方式，但%操作符的使用是最方便的。
+Python中内置的%操作符可用于格式化字符串操作，控制字符串的呈现格式。Python中还有其他的格式化字符串的方式，但`%`操作符的使用是最方便的。
\ No newline at end of file
diff --git "a/content/\350\241\245\345\205\20506 Python\344\271\213\351\201\223.md" "b/content/\350\241\245\345\205\20506 Python\344\271\213\351\201\223.md"
index a62ca31..0575261 100644
--- "a/content/\350\241\245\345\205\20506 Python\344\271\213\351\201\223.md"
+++ "b/content/\350\241\245\345\205\20506 Python\344\271\213\351\201\223.md"
@@ -1,17 +1,14 @@
#Python补充06 Python之道
-
-
-
Python有一个彩蛋，用下面语句调出：
+
```python
import this
```
-该彩蛋的文档记录于PEP 20。
-语句执行之后，终端将显示一首"The Zen of Python"的诗，即“Python之道”。这首诗总结了Python的风格，可以指导Python程序员的编程。Python程序员会自豪宣称自己"Pythonic"。Pythonic的一个基本标准，是写出合乎“Python之道”的代码。
+该彩蛋的文档记录于PEP 20。
-
+语句执行之后，终端将显示一首“The Zen of Python”的诗，即“Python之道”。这首诗总结了Python的风格，可以指导Python程序员的编程。Python程序员会自豪宣称自己“Pythonic”。“Pythonic”的一个基本标准，是写出合乎“Python之道”的代码。
下面是“Python之道”的全文，以及我附加的翻译。
@@ -19,113 +16,88 @@ The Zen of Python, by Tim Peters
Python之道
-
Beautiful is better than ugly.
美观胜于丑陋。
-
Explicit is better than implicit.
显示胜于隐式。
-
Simple is better than complex.
简单胜于复杂。
-
Complex is better than complicated.
复杂胜于过度复杂。
-
Flat is better than nested.
平面胜于嵌套。
-
Sparse is better than dense.
稀少胜于稠密。
-
Readability counts.
可读性需要考虑。
-
Special cases aren't special enough to break the rules.
即使情况特殊，也不应打破原则，
-
Although practicality beats purity.
尽管实用胜于纯净。
-
Errors should never pass silently.
错误不应悄无声息的通过，
-
Unless explicitly silenced.
除非特意这么做。
-
In the face of ambiguity, refuse the temptation to guess.
当有混淆时，拒绝猜测（深入的搞明白问题）。
-
There should be one-- and preferably only one --obvious way to do it.
总有一个，且（理想情况下）只有一个，明显的方法来处理问题。
-
Although that way may not be obvious at first unless you're Dutch.
-尽管那个方法可能并不明显，除非你是荷兰人。(Python的作者Guido是荷兰人，这是在致敬)
-
+尽管那个方法可能并不明显，除非你是荷兰人。（Python的作者Guido是荷兰人，这是在致敬。）
Now is better than never.
现在开始胜过永远不开始，
-
Although never is often better than *right* now.
尽管永远不开始经常比仓促立即开始好。
-
If the implementation is hard to explain, it's a bad idea.
如果程序实现很难解释，那么它是个坏主意。
-
If the implementation is easy to explain, it may be a good idea.
如果程序实现很容易解释，那么它可能是个好主意。
-
Namespaces are one honking great idea -- let's do more of those!
命名空间是个绝好的主意，让我们多利用它。
-
-
"Python之道"强调美观、简单、可读和实用，拒绝复杂或模糊。
-
-
##历史
-Tim Peters于June 4, 1999的Python邮件列表，以"The Python Way"为标题，发表了“Python之道”，得到许多Python程序员的认同。另一方面，2001年的International Python Conference #10 (IPC10, IPC是PyCon的前身)会议，主办方希望在文化衫上印标语，而这一标语要能代表Python文化。到会的Python程序员们创作了500多条。组织者选了"import this"。后来，Python的作者Guido增加了this.py模块，让这个语句可以在解释器中执行，打印“Python之道”。
+Tim Peters于June 4, 1999的Python邮件列表，以“The Python Way”为标题，发表了“Python之道”，得到许多Python程序员的认同。另一方面，2001年的“International Python Conference #10”（IPC10, IPC是PyCon的前身）会议，主办方希望在文化衫上印标语，而这一标语要能代表Python文化。到会的Python程序员们创作了500多条。组织者选了"import this"。后来，Python的作者Guido增加了this.py模块，让这个语句可以在解释器中执行，打印“Python之道”。
Python社区很幽默。
-
-
-此外，PyCon是Python爱好者的集会，可以去给别人展示自己的Python项目，或者听讲座。2012年的PyCon是在北京和上海同时举行。
+此外，PyCon是Python爱好者的集会，可以去给别人展示自己的Python项目，或者听讲座。2012年的PyCon是在北京和上海同时举行。
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21001 \345\210\235\350\257\225\345\244\251\346\266\257.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21001 \345\210\235\350\257\225\345\244\251\346\266\257.md"
index 77a9262..db78bb3 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21001 \345\210\235\350\257\225\345\244\251\346\266\257.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21001 \345\210\235\350\257\225\345\244\251\346\266\257.md"
@@ -1,57 +1,51 @@
#被解放的姜戈01 初试天涯
-
-
-
-Django是Python下的一款网络服务器框架。Python下有许多款不同的框架。Django是重量级选手中最有代表性的一位。许多成功的网站和APP都基于Django。虽然Django之于Python，达不到Rail之于Ruby的一统江湖的地位，但Django无疑也是Python在网络应用方面的一位主将。
-
-
+Django是Python下的一款网络服务器框架。
+Python下有许多款不同的框架。Django是重量级选手中最有代表性的一位。许多成功的网站和APP都基于Django。
+虽然Django之于Python，达不到Rail之于Ruby的一统江湖的地位，但Django无疑也是Python在网络应用方面的一位主将。
向昆汀的致敬，“被解放的姜戈”
-
-
Django意外的和昆汀的电影重名。这大大提高了Django的知名度。另外利用电影，宣传了这个奇怪的词的发音。
-
-
下面是姜戈的初体验。
-
-
##安装Django
启动计算机中的Python，尝试载入Django模块。如果可以成功载入，那么说明Django已经安装好：
+
```python
import django
print(django.VERSION)
```
-如果Django还没有安装，可以在命令行，尝试使用pip安装:
+如果Django还没有安装，可以在命令行，尝试使用`pip`安装：
+
```python
sudo pip install django
```
-或者使用easy_install:
+
+或者使用`easy_install`：
+
```python
sudo easy_install django
```
黑夜中，姜戈和镣铐说再见。
-
-
##启动
使用下面的命令创建项目：
+
```python
django-admin.py startproject mysite
```
-在当前目录下，将生成mysite文件夹。其文件树结构如下:
+在当前目录下，将生成`mysite`文件夹。其文件树结构如下：
-```python
+```quote
mysite
├── manage.py
└── mysite
@@ -59,41 +53,32 @@ mysite
├── settings.py
├── urls.py
└── wsgi.py
-
1 directory, 5 files
```
-
-进入mysite，启动服务器：
+进入`mysite`，启动服务器：
+
```python
python manage.py runserver 8000
```
-上面的8000为端口号。如果不说明，那么端口号默认为8000。
-
-
-
-打开浏览器，访问http://127.0.0.1:8000，可以看到服务器已经在运行：
+上面的`8000`为端口号。如果不说明，那么端口号默认为`8000`。
+打开浏览器，访问`http://127.0.0.1:8000`，可以看到服务器已经在运行：
虽然有一个能跑的服务器，但什么内容都没有。
-
-
“赏金？猎人？” 姜戈满脸困惑。
-
-
##第一个网页
-在http协议中可以看到，网络服务器是“请求-回应”的工作模式。客户向URL发送请求，服务器根据请求，开动后厨，并最终为客人上菜。Django采用的MVC结构，即点单、厨房、储藏室分离。
+在http协议中可以看到，网络服务器是“请求-回应”的工作模式。客户向URL发送请求，服务器根据请求，开动后厨，并最终为客人上菜。
-
+Django采用的MVC结构，即点单、厨房、储藏室分离。
-我们需要一个指挥员，将URL对应分配给某个对象处理，这需要在mysite/mysite下的urls.py设定。Python会根据该程序，将URL请求分给某个厨师。
+我们需要一个指挥员，将URL对应分配给某个对象处理，这需要在`mysite/mysite`下的`urls.py`设定。Python会根据该程序，将URL请求分给某个厨师。
-复制代码
-```python
+```quote
├── manage.py
└── mysite
├── __init__.py
@@ -103,9 +88,8 @@ python manage.py runserver 8000
1 directory, 5 files
```
-
-将urls.py修改为:
+将urls.py修改为：
```python
from django.conf.urls import patterns, include, url
@@ -122,9 +106,11 @@ urlpatterns = patterns('',
url(r'^$', 'mysite.views.first_page'),
)
```
-我们添加了最后一行。它将根目录的URL分配给一个对象进行处理，这个对象是mysite.views.first_page。
-用以处理HTTP请求的这一对象还不存在，我们在mysite/mysite下创建views.py，并在其中定义first_page函数:
+我们添加了最后一行。它将根目录的URL分配给一个对象进行处理，这个对象是`mysite.views.first_page`。
+
+用以处理HTTP请求的这一对象还不存在，我们在`mysite/mysite`下创建`views.py`，并在其中定义`first_page`函数：
+
```python
# -*- coding: utf-8 -*-
@@ -133,27 +119,28 @@ from django.http import HttpResponse
def first_page(request):
return HttpResponse("世界好
")
```
-第一行说明字符编码为utf-8，为下面使用中文做准备。first_page函数的功能，是返回http回复，即这里的世界好
。first_page有一个参数request，该参数包含有请求的具体信息，比如请求的类型等，这里并没有用到。
-
+第一行说明字符编码为`utf-8`，为下面使用中文做准备。
+`first_page`函数的功能，是返回http回复，即这里的`世界好
`。`first_page`有一个参数`request`，该参数包含有请求的具体信息，比如请求的类型等，这里并没有用到。
姜戈接过枪，一枪射出去。“天哪！” 德国人惊呆了。
-
-
##增加app
-一个网站可能有多个功能。我们可以在Django下，以app为单位，模块化的管理，而不是将所有的东西都丢到一个文件夹中。在mysite下，运行manange.py，创建新的app：
+一个网站可能有多个功能。我们可以在Django下，以app为单位，模块化的管理，而不是将所有的东西都丢到一个文件夹中。
+在`mysite`下，运行`manange.py`，创建新的app：
+
+```bash
$python manage.py startapp west
-这个新的app叫做west，用来处理西餐。
+```
-
+这个新的app叫做`west`，用来处理西餐。
-我们的根目录下，出现了一个新的叫做west的文件夹。
+我们的根目录下，出现了一个新的叫做`west`的文件夹。
-```python
+```quote
mysite/
├── manage.py
├── mysite
@@ -172,7 +159,7 @@ mysite/
└── views.py
```
-我们还需要修改项目设置，说明我们要使用west。在mysite/setting.py中，在INSTALLED_APPS中，增加"west"：
+我们还需要修改项目设置，说明我们要使用`west`。在`mysite/setting.py`中，在`INSTALLED_APPS`中，增加`west`：
```python
INSTALLED_APPS = (
@@ -185,23 +172,18 @@ INSTALLED_APPS = (
'west',
)
```
-可以看到，除了新增加的west，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。
-
+可以看到，除了新增加的`west`，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。
姜戈看到曾经的工头们，眼中充满怒火。
-
-
##增加APP页面
-我们下面为APP增加首页。我们之前是在mysite/urls.py中设置的URL访问对象。依然采用类似的方式设置。
+我们下面为APP增加首页。我们之前是在`mysite/urls.py`中设置的URL访问对象。依然采用类似的方式设置。
-另一方面，为了去耦合，实现模块化，我们应该在west/urls.py中设置URL访问对象。具体如下：
+另一方面，为了去耦合，实现模块化，我们应该在`west/urls.py`中设置URL访问对象。具体如下：
-
-
-首先，修改mysite/urls.py：
+首先，修改`mysite/urls.py`：
```python
from django.conf.urls import patterns, include, url
@@ -219,11 +201,11 @@ urlpatterns = patterns('',
url(r'^west/', include('west.urls')),
)
```
-注意新增加的最后一行。这里，我们提醒指挥员，对于west/的访问，要参考west/urls.py。
-
+注意新增加的最后一行。这里，我们提醒指挥员，对于`west/`的访问，要参考`west/urls.py`。
+
+随后，我们创建`west/urls.py`，添加内容：
-随后，我们创建west/urls.py，添加内容：
```python
from django.conf.urls import patterns, include, url
@@ -231,11 +213,11 @@ urlpatterns = patterns('',
url(r'^$', 'west.views.first_page'),
)
```
-将URL对应west下，views.py中的first_page函数。
-
+将URL对应`west`下，`views.py`中的`first_page`函数。
+
+最后，在`west`下，修改`views.py`为：
-最后，在west下，修改views.py为:
```python
# -*- coding: utf-8 -*-
@@ -244,18 +226,13 @@ from django.http import HttpResponse
def first_page(request):
return HttpResponse("西餐
")
```
-访问http://127.0.0.1:8000/west，查看效果。
-
+访问`http://127.0.0.1:8000/west`，查看效果。
“你们这些混蛋，我一个都不会放过！” 姜戈大吼。
-
-
##总结
可以看到，Django的创建过程非常简单。但这只是初次尝试Django。为了创建一个完整功能的网站，还需要调用Django许多其它的功能。
-
-
-姜戈的解放，才刚刚开始。
+姜戈的解放，才刚刚开始。
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21002 \345\272\204\345\233\255\347\226\221\344\272\221.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21002 \345\272\204\345\233\255\347\226\221\344\272\221.md"
index 4f7174f..017481d 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21002 \345\272\204\345\233\255\347\226\221\344\272\221.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21002 \345\272\204\345\233\255\347\226\221\344\272\221.md"
@@ -1,46 +1,38 @@
#被解放的姜戈02 庄园疑云
-
-
-
上一回说到，姜戈的江湖初体验：如何架设服务器，如何回复http请求，如何创建App。这一回，我们要走入糖果庄园。
-
-
数据库是一所大庄园，藏着各种宝贝。一个没有数据库的网站，所能提供的功能会非常有限。
-
-
-
-
为了找到心爱的人，姜戈决定一探这神秘的糖果庄园。
-
-
##连接数据库
-Django为多种数据库后台提供了统一的调用API。根据需求不同，Django可以选择不同的数据库后台。MySQL算是最常用的数据库。我们这里将Django和MySQL连接。
+Django为多种数据库后台提供了统一的调用API。根据需求不同，Django可以选择不同的数据库后台。
-
+MySQL算是最常用的数据库。我们这里将Django和MySQL连接。
-在Linux终端下启动mysql:
+在Linux终端下启动mysql：
+```bash
$mysql -u root -p
-
+```
在MySQL中创立Django项目的数据库：
+```bash
mysql> CREATE DATABASE villa DEFAULT CHARSET=utf8;
-这里使用utf8作为默认字符集，以便支持中文。
+```
-
+这里使用`utf8`作为默认字符集，以便支持中文。
-在MySQL中为Django项目创立用户，并授予相关权限:
+在MySQL中为Django项目创立用户，并授予相关权限：
+```bash
mysql> GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, CREATE TEMPORARY TABLES, LOCK TABLES ON villa.* TO 'vamei'@'localhost' IDENTIFIED BY 'vameiisgood';
-
+```
-在settings.py中，将DATABASES对象更改为:
+在`settings.py`中，将`DATABASES`对象更改为：
```python
DATABASES = {
@@ -54,44 +46,42 @@ DATABASES = {
}
}
```
-后台类型为mysql。上面包含数据库名称和用户的信息，它们与MySQL中对应数据库和用户的设置相同。Django根据这一设置，与MySQL中相应的数据库和用户连接起来。此后，Django就可以在数据库中读写了。
-
+后台类型为`mysql`。上面包含数据库名称和用户的信息，它们与MySQL中对应数据库和用户的设置相同。
-姜戈略一迟疑，旋即走入了庄园的大门。
+Django根据这一设置，与MySQL中相应的数据库和用户连接起来。此后，Django就可以在数据库中读写了。
-
+姜戈略一迟疑，旋即走入了庄园的大门。
##创立模型
-MySQL是关系型数据库。但在Django的帮助下，我们不用直接编写SQL语句。Django将关系型的表(table)转换成为一个类(class)。而每个记录(record)是该类下的一个对象(object)。我们可以使用基于对象的方法，来操纵关系型的MySQL数据库。
+MySQL是关系型数据库。但在Django的帮助下，我们不用直接编写SQL语句。Django将关系型的表（table）转换成为一个类（class）。而每个记录（record）是该类下的一个对象（object）。我们可以使用基于对象的方法，来操纵关系型的MySQL数据库。
-
+在传统的MySQL中，数据模型是表。在Django下，一个表为一个类。表的每一列是该类的一个属性。在`models.py`中，我们创建一个只有一列的表，即只有一个属性的类：
-在传统的MySQL中，数据模型是表。在Django下，一个表为一个类。表的每一列是该类的一个属性。在models.py中，我们创建一个只有一列的表，即只有一个属性的类：
```python
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__()方法，实现相同的功能。
+类`Character`定义了数据模型，它需要继承自`models.Model`。在MySQL中，这个类实际上是一个表。表只有一列，为`name`。可以看到，`name`属性是字符类型，最大长度为`200`。
-
+类`Character`有一个`__unicode__()`方法，用来说明对象的字符表达方式。如果是Python 3，定义`__str__()`方法，实现相同的功能。
-命令Django同步数据库。Django根据models.py中描述的数据模型，在MySQL中真正的创建各个关系表：
-```python
+命令Django同步数据库。Django根据`models.py`中描述的数据模型，在MySQL中真正的创建各个关系表：
+
+```bash
$python manage.py syncdb
```
-同步数据库后，Django将建立相关的MySQL表格，并要求你创建一个超级用户:
-
-
+同步数据库后，Django将建立相关的MySQL表格，并要求你创建一个超级用户：
+```quote
Creating tables ...
Creating table django_admin_log
Creating table auth_permission
@@ -104,8 +94,6 @@ 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'): vamei
@@ -116,22 +104,25 @@ Superuser created successfully.
Installing custom SQL ...
Installing indexes ...
Installed 0 object(s) from 0 fixture(s)
+```
-
+数据模型建立了。打开MySQL命令行：
- 数据模型建立了。打开MySQL命令行：
-```python
+```bash
$mysql -u vamei -p
```
查看数据模型：
-```python
+
+```bash
USE villa;
SHOW TABLES;
SHOW COLUMNS FROM west_character;
```
-最后一个命令返回Character类的对应表格:
+最后一个命令返回`Character`类的对应表格：
+
+```quote
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
@@ -139,31 +130,33 @@ SHOW COLUMNS FROM west_character;
| name | varchar(200) | NO | | NULL | |
+-------+--------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)
+```
- 可以看到，Django还自动增加了一个id列，作为记录的主键(Primary Key)。
-
-
+可以看到，Django还自动增加了一个id列，作为记录的主键（Primary Key）。
这富丽堂皇的别墅中，姜戈隐隐闻到凶险的味道。
-
-
##显示数据
-数据模型虽然建立了，但还没有数据输入。为了简便，我们手动添加记录。打开MySQL命令行,并切换到相应数据库。添加记录：
+数据模型虽然建立了，但还没有数据输入。为了简便，我们手动添加记录。打开MySQL命令行，并切换到相应数据库。添加记录：
+```bash
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;
+```bash
+SELECT * FROM west_character;
+```
可以看到，三个名字已经录入数据库。
-
+下面我们从数据库中取出数据，并返回给http请求。
-下面我们从数据库中取出数据，并返回给http请求。在west/views.py中，添加视图。对于对应的请求，我们将从数据库中读取所有的记录，然后返回给客户端：
+在`west/views.py`中，添加视图。对于对应的请求，我们将从数据库中读取所有的记录，然后返回给客户端：
```python
# -*- coding: utf-8 -*-
@@ -177,11 +170,11 @@ def staff(request):
staff_str = map(str, staff_list)
return HttpResponse("" + ' '.join(staff_str) + "
")
```
-可以看到，我们从west.models中引入了Character类。通过操作该类，我们可以读取表格中的记录
-
+可以看到，我们从`west.models`中引入了`Character`类。通过操作该类，我们可以读取表格中的记录。
+
+为了让http请求能找到上面的程序，在`west/urls.py`增加url导航：
-为了让http请求能找到上面的程序，在west/urls.py增加url导航：
```python
from django.conf.urls import patterns, include, url
@@ -192,32 +185,22 @@ urlpatterns = patterns('',
运行服务器。在浏览器中输入URL：
+```quote
127.0.0.1:8000/west/staff
+```
查看效果：
-
-
-
-
从数据库读出数据，显示在页面
-
-
“我心爱的人，原来你在这里。” 姜戈强自镇定，嘴角忍不住颤动。
-
-
##总结
Django使用类和对象接口，来操纵底层的数据库。
有了数据库，就有了站点内容的大本营。
-
-
姜戈，风雨欲来。
-
-
-欢迎阅读“被解放的姜戈”系列文章。
+欢迎阅读“被解放的姜戈”系列文章。
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21003 \346\211\200\350\260\223\344\274\212\344\272\272.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21003 \346\211\200\350\260\223\344\274\212\344\272\272.md"
index 5c01f9b..4528591 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21003 \346\211\200\350\260\223\344\274\212\344\272\272.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21003 \346\211\200\350\260\223\344\274\212\344\272\272.md"
@@ -1,50 +1,45 @@
#被解放的姜戈03 所谓伊人
-
-
-
-在之前的程序中，我们直接生成一个字符串，作为http回复，返回给客户端。这一过程中使用了django.http.HttpResponse()。
+在之前的程序中，我们直接生成一个字符串，作为http回复，返回给客户端。这一过程中使用了`django.http.HttpResponse()`。
在这样的一种回复生成过程中，我们实际上将数据和视图的格式混合了到上面的字符串中。看似方便，却为我们的管理带来困难。想像一个成熟的网站，其显示格式会有许多重复的地方。如果可以把数据和视图格式分离，就可以重复使用同一视图格式了。
Django中自带的模板系统，可以将视图格式分离出来，作为模板使用。这样，不但视图可以容易修改，程序也会显得美观大方。
-
-
“她是我心中最美的人”，姜戈对德国人说。
-
-
##模板初体验
-我们拿一个独立的templay.html文件作为模板。它放在templates/west/文件夹下。文件系统的结构现在是:
+我们拿一个独立的`templay.html`文件作为模板。它放在`templates/west/`文件夹下。文件系统的结构现在是：
+```quote
mysite/
├── mysite
├── templates
│ └── west
└── west
-
+```
-templay.html文件的内容是：
+`templay.html`文件的内容是：
+```html
{{ label }}
-可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即标签，则已经标明在该模板文件中。
+```
-
+可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即``标签，则已经标明在该模板文件中。
-我们需要向Django说明模板文件的搜索路径，修改mysite/settings.py，添加:
+我们需要向Django说明模板文件的搜索路径，修改`mysite/settings.py`，添加：
+```python
# Template dir
TEMPLATE_DIRS = (
os.path.join(BASE_DIR, 'templates/west/'),
)
+```
如果还有其它的路径用于存放模板，可以增加该元组中的元素，以便Django可以找到需要的模板。
-
-
-我们现在修改west/views.py，增加一个新的对象，用于向模板提交数据：
+我们现在修改`west/views.py`，增加一个新的对象，用于向模板提交数据：
```python
# -*- coding: utf-8 -*-
@@ -57,33 +52,25 @@ def templay(request):
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对象。
+可以看到，我们这里使用`render`来替代之前使用的`HttpResponse`。`render`还使用了一个词典`context`作为参数。这就是我们的数据。
-
+`context`中元素的键值为`'label'`，正对应刚才的“陌生人”的名字。这样，该`context`中的`'label'`元素值，就会填上模板里的坑，构成一个完整的http回复。
-访问http://127.0.0.1:8000/west/templay，可以看到页面：
+作为上节内容的一个小练习，自行修改`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回复。
-
+再来回顾一下整个流程。`west/views.py`中的`templay()`在返回时，将环境数据`context`传递给模板`templay.html`。Django根据`context`元素中的键值，将相应数据放入到模板中的对应位置，生成最终的http回复。
+这一模板系统可以与Django的其它功能相互合作。上一回，我们从数据库中提取出了数据。如果将数据库中的数据放入到`context`中，那么就可以将数据库中的数据传送到模板。
-这一模板系统可以与Django的其它功能相互合作。上一回，我们从数据库中提取出了数据。如果将数据库中的数据放入到context中，那么就可以将数据库中的数据传送到模板。
+修改上次的`west/views.py`中的`staff`：
-修改上次的west/views.py中的staff:
```python
def staff(request):
staff_list = Character.objects.all()
@@ -91,113 +78,102 @@ def staff(request):
context = {'label': ' '.join(staff_str)}
return render(request, 'templay.html', context)
```
-练习: 显示上面的staff页面。
-
+练习：显示上面的`staff`页面。
“勇士翻过高山，并非因为他不害怕。”
-
-
##循环与选择
Django实际上提供了丰富的模板语言，可以在模板内部有限度的编程，从而更方便的编写视图和传送数据。
我们下面体验一下最常见的循环与选择。
-
+上面的`staff`中的数据实际上是一个数据容器，有三个元素。刚才我们将三个元素连接成一个字符串传送。
-上面的staff中的数据实际上是一个数据容器，有三个元素。刚才我们将三个元素连接成一个字符串传送。
+实际上，利用模板语言，我们可以直接传送数据容器本身，再循环显示。修改`staff()`为：
-实际上，利用模板语言，我们可以直接传送数据容器本身，再循环显示。修改staff()为:
```python
def staff(request):
staff_list = Character.objects.all()
return render(request, 'templay.html', {'staffs': staff_list})
```
-从数据库中查询到的三个对象都在staff_list中。我们直接将staff_list传送给模板。
-将模板templay.html修改为：
+从数据库中查询到的三个对象都在`staff_list`中。我们直接将`staff_list`传送给模板。
+将模板`templay.html`修改为：
+
+```html
{% for item in staffs %}
-
{{ item.id }}, {{item}}
+ {{ item.id }}, {{item}}
{% endfor %}
-我们以类似于Python中for循环的方式来定义模板中的for，以显示staffs中的每个元素。
+```
-还可以看到，对象.属性名的引用方式可以直接用于模板中。
+我们以类似于Python中`for`循环的方式来定义模板中的`for`，以显示`staffs`中的每个元素。
-
+还可以看到，对象.属性名的引用方式可以直接用于模板中。
-选择结构也与Python类似。根据传送来的数据是否为True，Django选择是否显示。使用方式如下：
+选择结构也与Python类似。根据传送来的数据是否为`True`，Django选择是否显示。使用方式如下：
```python
{% if condition1 %}
- ... display 1
+ ... display 1
{% elif condiiton2 %}
- ... display 2
+ ... display 2
{% else %}
- ... display 3
+ ... display 3
{% endif %}
```
-其中的elif和else和Python中一样，是可以省略的。
-
+其中的`elif`和`else`和Python中一样，是可以省略的。
“勇士屠杀恶龙，并非因为他不恐惧。”
-
-
-模板继承
+##模板继承
-模板可以用继承的方式来实现复用。我们下面用templay.html来继承base.html。这样，我们可以使用base.html的主体，只替换掉特定的部分。
+模板可以用继承的方式来实现复用。我们下面用`templay.html`来继承`base.html`。这样，我们可以使用`base.html`的主体，只替换掉特定的部分。
-新建templates/west/base.html:
+新建`templates/west/base.html`：
-```python
+```html
-
- templay
-
-
-
- come from base.html
- {% block mainbody %}
- original
- {% endblock %}
-
+
+ templay
+
+
+
+ come from base.html
+ {% block mainbody %}
+ original
+ {% endblock %}
+
```
-该页面中，名为mainbody的block标签是可以被继承者们替换掉的部分。
-
+该页面中，名为`mainbody`的`block`标签是可以被继承者们替换掉的部分。
-我们在下面的templay.html中继承base.html，并替换特定block：
+我们在下面的`templay.html`中继承`base.html`，并替换特定`block`：
-```python
+```html
{% extends "base.html" %}
{% block mainbody %}
{% for item in staffs %}
-{{ item.id }},{{ item.name }}
+ {{ item.id }},{{ item.name }}
{% endfor %}
{% endblock %}
```
-第一句说明templay.html继承自base.html。可以看到，这里相同名字的block标签用以替换base.html的相应block。
-
+第一句说明`templay.html`继承自`base.html`。可以看到，这里相同名字的`block`标签用以替换`base.html`的相应`block`。
“勇士穿过地狱火焰，因为，她值得。”
-
-
##总结
使用模板实现视图分离。
数据传递，模板变量，模板循环与选择，模板继承。
-
-
-姜戈静静的说，“我懂得他的感受。”
+姜戈静静的说，“我懂得他的感受。”
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21004 \345\220\204\345\217\226\346\211\200\351\234\200.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21004 \345\220\204\345\217\226\346\211\200\351\234\200.md"
index 3d3ab99..3c994b8 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21004 \345\220\204\345\217\226\346\211\200\351\234\200.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21004 \345\220\204\345\217\226\346\211\200\351\234\200.md"
@@ -1,105 +1,88 @@
#被解放的姜戈04 各取所需
-作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！
-
-
+作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！
我们在庄园疑云中讲到了服务器上的数据。当时我们是用手动的方式，直接在数据库插入数据。我们将允许客户向服务器传递数据。
表格是客户向服务器传数据的经典方式。我们先会看到传统的表格提交，然后了解Django的表格对象。
-
-
“我可不做赔本的买卖”，庄主对姜戈说。
-
-
##html表格
-HTTP协议以“请求－回复”的方式工作。客户发送请求时，可以在请求中附加数据。服务器通过解析请求，就可以获得客户传来的数据，并根据URL来提供特定的服务。
+HTTP协议以“请求－回复”的方式工作。客户发送请求时，可以在请求中附加数据。服务器通过解析请求，就可以获得客户传来的数据，并根据URL来提供特定的服务。
（http协议的运作方式，详见http协议）
-
-
HTML文件中可以包含表格标签。HTML表格的目的是帮助用户构成HTTP请求，把数据用GET或者POST的方法，传递给某一URL地址。下面是一个表格的例子：
-```python
+
+```html
```
-这里的form标签有两个属性。action用于说明URL地址，method说明请求的方法。
-表格中还包含有两个input标签，即两个输入栏目。根据type的不同，第一个为一个文本框，第二个为一个提交按钮。name为输入栏的名字。服务器在解析数据时，将以name为索引。
+这里的`form`标签有两个属性。`action`用于说明URL地址，`method`说明请求的方法。
+
+表格中还包含有两个`input`标签，即两个输入栏目。根据`type`的不同，第一个为一个文本框，第二个为一个提交按钮。`name`为输入栏的名字。服务器在解析数据时，将以`name`为索引。
-
+我们可以将上面的表格直接存入模板`form.html`，并在`[site]/west/views.py`中定义一个视图`form()`来显示表格：
-我们可以将上面的表格直接存入模板form.html，并在west/views.py中定义一个视图form()来显示表格:
```python
from django.shortcuts import render
def form(request):
return render(request, 'form.html')
```
-设置urls.py，让对[site]/west/form/的访问，指向该视图。
-
+设置`urls.py`，让对`/west/form/`的访问，指向该视图。
+
+最后，我们在`west/views.py`中定义`investigate()`来处理该表格提交的数据：
-最后，我们在west/views.py中定义investigate()来处理该表格提交的数据:
```python
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时，将显示:
+```
+可以看到，HTTP请求的相关信息，包括请求的方法，提交的数据，都包含在`request`参数中。
+表格是通过`GET`方法提交的。我们可以通过`request.GET['staff']`，来获得`name`为`staff`的输入栏的数据。该数据是一个字符串。`investigate()`将直接显示该字符串。
+设置`urls.py`，让该处理函数对应`action`的URL（`[site]/west/investigate/`）。
-提交表格后，页面将转到[site]/west/investigate。investigate()读取字符串后，在页面上显示出来。
+当我们访问`http://127.0.0.1:8000/west/form`时，将显示：
-
+提交表格后，页面将转到`[site]/west/investigate`。`investigate()`读取字符串后，在页面上显示出来。
姜戈舔舔嘴唇，“这就是你最好的决斗士？我觉得它们不值。”
-
-
##POST方法
-上面我们使用了GET方法。视图显示和请求处理分成两个函数处理。
-
-提交数据时更常用POST方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
+上面我们使用了`GET`方法。视图显示和请求处理分成两个函数处理。
-
+提交数据时更常用`POST`方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
-先创建模板investigate.html
+先创建模板`investigate.html`
-```python
+```html
{{ rlt }}
```
-我们修改提交表格的方法为post。在模板的末尾，我们增加一个rlt记号，为表格处理结果预留位置。
-表格后面还有一个{% csrf_token %}的标签。csrf全称是Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。POST方法提交的表格，必须有此标签。
+我们修改提交表格的方法为`post`。在模板的末尾，我们增加一个`rlt`记号，为表格处理结果预留位置。
-
+表格后面还有一个`{% csrf_token %}`的标签。`csrf`全称是Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。`POST`方法提交的表格，必须有此标签。
-在west/views.py中，用investigate()来处理表格：
+在`west/views.py`中，用`investigate()`来处理表格：
```python
from django.shortcuts import render
@@ -112,27 +95,20 @@ def investigate(request):
ctx['rlt'] = request.POST['staff']
return render(request, "investigate.html", ctx)
```
-这里的csrf()是和上面的{% csrf_token %}对应。我们在这里不深究。
-看程序的其它部分。对于该URL，可能有GET或者POST方法。if的语句有POST方法时，额外的处理，即提取表格中的数据到环境变量。
+这里的`csrf()`是和上面的`{% csrf_token %}`对应。我们在这里不深究。
-
+看程序的其它部分。对于该URL，可能有`GET`或者`POST`方法。`if`的语句有`POST`方法时，额外的处理，即提取表格中的数据到环境变量。
最终效果如下：
-
-
“哦，是吗，我可是有更好的货色”，庄主似乎胸有成竹。
-
-
##存储数据
-我们还可以让客户提交的数据存入数据库。使用庄园疑云中创建的模型。我们将客户提交的字符串存入模型Character。
-
-
+我们还可以让客户提交的数据存入数据库。使用庄园疑云中创建的模型。我们将客户提交的字符串存入模型`Character`。
-修改west/views.py的investigate():
+修改`west/views.py`的`investigate()`：
```python
from django.shortcuts import render
@@ -151,46 +127,38 @@ def investigate(request):
ctx['staff'] = all_records
return render(request, "investigate.html", ctx)
```
-在POST的处理部分，我们调用Character类创建新的对象，并让该对象的属性name等于用户提交的字符串。通过save()方法，我们让该记录入库。
-随后，我们从数据库中读出所有的对象，并传递给模板。
+在`POST`的处理部分，我们调用`Character`类创建新的对象，并让该对象的属性`name`等于用户提交的字符串。通过`save()`方法，我们让该记录入库。
-
+随后，我们从数据库中读出所有的对象，并传递给模板。
-我们还需要修改模板investigate.html，以更好的显示：
+我们还需要修改模板`investigate.html`，以更好的显示：
-```python
+```html
{% for person in staff %}
-{{ person }}
+ {{ person }}
{% endfor %}
```
-我们使用模板语言的for，来显示所有的记录。
-
-
-
-效果如下:
+我们使用模板语言的`for`，来显示所有的记录。
+效果如下：
“他只是勉强够看罢了”，姜戈摇摇头，德国人也赶快跟着摇摇头。
-
-
##表格对象
客户提交数据后，服务器往往需要对数据做一些处理。比如检验数据，看是否符合预期的长度和数据类型。在必要的时候，还需要对数据进行转换，比如从字符串转换成整数。这些过程通常都相当的繁琐。
Django提供的数据对象可以大大简化这一过程。该对象用于说明表格所预期的数据类型和其它的一些要求。这样Django在获得数据后，可以自动根据该表格对象的要求，对数据进行处理。
-
-
-修改west/views.py：
+修改`west/views.py`：
```python
from django.shortcuts import render
@@ -219,51 +187,41 @@ def investigate(request):
ctx['form'] = form
return render(request, "investigate.html", ctx)
```
-上面定义了CharacterForm类，并通过属性name，说明了输入栏name的类型为字符串，最大长度为200。
-在investigate()函数中，我们根据POST，直接创立form对象。该对象可以直接判断输入是否有效，并对输入进行预处理。空白输入被视为无效。
+上面定义了`CharacterForm`类，并通过属性`name`，说明了输入栏`name`的类型为字符串，最大长度为`200`。
-后面，我们再次创建一个空的form对象，并将它交给模板显示。
+在`investigate()`函数中，我们根据`POST`，直接创立`form`对象。该对象可以直接判断输入是否有效，并对输入进行预处理。空白输入被视为无效。
-
+后面，我们再次创建一个空的`form`对象，并将它交给模板显示。
-在模板investigate.html中，我们可以直接显示form对象：
+在模板`investigate.html`中，我们可以直接显示`form`对象：
-```python
+```html
{% for person in staff %}
-{{ person }}
+ {{ person }}
{% endfor %}
```
-如果有多个输入栏，我们可以用相同的方式直接显示整个form，而不是加入许多个标签。
-
+如果有多个输入栏，我们可以用相同的方式直接显示整个`form`，而不是加入许多个``标签。
效果如下：
-
-
-
-
庄主看看德国人，再看看女仆，脸上露出狡猾的笑容。
-
-
##总结
-GET和POST
-
-表格提交
+`GET`和`POST`。
-数据库入库
+表格提交。
-表格对象
+数据库入库。
-
+表格对象。
-“哈，那个德国人似乎看上了这个黑女仆呢”，庄主心里打着算盘。
+“哈，那个德国人似乎看上了这个黑女仆呢”，庄主心里打着算盘。
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21005 \351\273\221\351\235\242\347\256\241\345\256\266.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21005 \351\273\221\351\235\242\347\256\241\345\256\266.md"
index a907295..65ccc9f 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21005 \351\273\221\351\235\242\347\256\241\345\256\266.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21005 \351\273\221\351\235\242\347\256\241\345\256\266.md"
@@ -1,25 +1,17 @@
#被解放的姜戈05 黑面管家
+Django提供一个管理数据库的app，即`django.contrib.admin`。这是Django最方便的功能之一。通过该app，我们可以直接经由web页面，来管理我们的数据库。这一工具，主要是为网站管理人员使用。
-
-
-Django提供一个管理数据库的app，即django.contrib.admin。这是Django最方便的功能之一。通过该app，我们可以直接经由web页面，来管理我们的数据库。这一工具，主要是为网站管理人员使用。
-
-这个app通常已经预装好，你可以在mysite/settings.py中的INSTALLED_APPS看到它。
-
-
+这个app通常已经预装好，你可以在`mysite/settings.py`中的`INSTALLED_APPS`看到它。
“这庄园里的事情，都逃不过我的眼睛”，管家放下账本，洋洋得意。
-
-
##默认界面
-admin界面位于[site]/admin这个URL。这通常在mysite/urls.py中已经设置好。比如，下面是我的urls.py:
+`admin`界面位于`[site]/admin`这个URL。这通常在`mysite/urls.py`中已经设置好。比如，下面是我的`urls.py`：
```python
from django.conf.urls import patterns, include, url
-
from django.contrib import admin
admin.autodiscover() # admin
@@ -29,36 +21,28 @@ urlpatterns = patterns('',
url(r'^west/', include('west.urls')),
)
```
-
-为了让admin界面管理某个数据模型，我们需要先注册该数据模型到admin。比如，我们之前在west中创建的模型Character。修改west/admin.py:
+为了让`admin`界面管理某个数据模型，我们需要先注册该数据模型到`admin`。比如，我们之前在`west`中创建的模型`Character`。修改`west/admin.py`：
+```python
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模块。我们将在以后处理用户管理的问题。
+访问`http://127.0.0.1:8000/admin`，登录后，可以看到管理界面：
-
+这个页面除了`west.characters`外，还有用户和组信息。它们来自Django预装的`Auth`模块。我们将在以后处理用户管理的问题。
“我已经管理这个庄园几十年了。”
-
-
##复杂模型
管理页面的功能强大，完全有能力处理更加复杂的数据模型。
-
-
-先在west/models.py中增加一个更复杂的数据模型：
+先在`west/models.py`中增加一个更复杂的数据模型：
```python
from django.db import models
@@ -68,50 +52,49 @@ 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用于存储整数。
+这里有两个表。`Tag`以`Contact`为外部键。一个`Contact`可以对应多个`Tag`。
-
+我们还可以看到许多在之前没有见过的属性类型，比如`IntegerField`用于存储整数。
-同步数据库:
+同步数据库：
+```bash
$python manage.py syncdb
-
+```
+
+在`west/admin.py`注册多个模型并显示：
-在west/admin.py注册多个模型并显示：
```python
from django.contrib import admin
-from west.models import Character,Contact,Tag
+from west.models import Character, Contact, Tag
# Register your models here.
admin.site.register([Character, Contact, Tag])
```
-模型将在管理页面显示。比如Contact的添加条目的页面如下：
-
-
+模型将在管理页面显示。比如`Contact`的添加条目的页面如下：
“这些黑鬼在想什么，我一清二楚。”
-
-
##自定义页面
-我们可以自定义管理页面，来取代默认的页面。比如上面的"add"页面。我们想只显示name和email部分。修改west/admin.py:
+我们可以自定义管理页面，来取代默认的页面。比如上面的“add”页面。我们想只显示`name`和`email`部分。修改`west/admin.py`：
```python
from django.contrib import admin
-from west.models import Character,Contact,Tag
+from west.models import Character, Contact, Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
@@ -120,21 +103,14 @@ class ContactAdmin(admin.ModelAdmin):
admin.site.register(Contact, ContactAdmin)
admin.site.register([Character, Tag])
```
-
-
-上面定义了一个ContactAdmin类，用以说明管理页面的显示格式。里面的fields属性，用以说明要显示的输入栏。我们没有让"age"显示。由于该类对应的是Contact数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：
-
-
-
+上面定义了一个`ContactAdmin`类，用以说明管理页面的显示格式。里面的`fields`属性，用以说明要显示的输入栏。我们没有让“age”显示。由于该类对应的是`Contact`数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：
-
-
-我们还可以将输入栏分块，给每一块输入栏以自己的显示格式。修改west/admin.py为：
+我们还可以将输入栏分块，给每一块输入栏以自己的显示格式。修改`west/admin.py`为：
```python
from django.contrib import admin
-from west.models import Character,Contact,Tag
+from west.models import Character, Contact, Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
@@ -151,31 +127,22 @@ class ContactAdmin(admin.ModelAdmin):
admin.site.register(Contact, ContactAdmin)
admin.site.register([Character, Tag])
```
-
-
-上面的栏目分为了Main和Advance两部分。classes说明它所在的部分的CSS格式。这里让Advance部分收敛起来：
-
+上面的栏目分为了`Main`和`Advance`两部分。`classes`说明它所在的部分的CSS格式。这里让`Advance`部分收敛起来：
-Advance部分旁边有一个Show按钮，用于展开。
-
-
+`Advance`部分旁边有一个“Show”按钮，用于展开。
“这两个客人，似乎没有那么简单。”
-
-
##Inline显示
-上面的Contact是Tag的外部键，所以有外部参考的关系。而在默认的页面显示中，将两者分离开来，无法体现出两者的从属关系。我们可以使用Inline显示，让Tag附加在Contact的编辑页面上显示。
-
-
+上面的`Contact`是`Tag`的外部键，所以有外部参考的关系。而在默认的页面显示中，将两者分离开来，无法体现出两者的从属关系。我们可以使用`Inline`显示，让`Tag`附加在`Contact`的编辑页面上显示。
-修改west/admin.py：
+修改`west/admin.py`：
```python
from django.contrib import admin
-from west.models import Character,Contact,Tag
+from west.models import Character, Contact, Tag
# Register your models here.
class TagInline(admin.TabularInline):
@@ -185,7 +152,7 @@ class ContactAdmin(admin.ModelAdmin):
inlines = [TagInline] # Inline
fieldsets = (
['Main',{
- 'fields':('name','email'),
+ 'fields':('name', 'email'),
}],
['Advance',{
'classes': ('collapse',),
@@ -197,75 +164,52 @@ class ContactAdmin(admin.ModelAdmin):
admin.site.register(Contact, ContactAdmin)
admin.site.register([Character])
```
-
效果如下：
-
-
-
-
“但我也不是好惹的。”
-
-
##列表页的显示
-在Contact输入数条记录后，Contact的列表页看起来如下:
+在`Contact`输入数条记录后，`Contact`的列表页看起来如下：
-
-
-
-
-我们也可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在ContactAdmin中增加list_display属性:
+我们也可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在`ContactAdmin`中增加`list_display`属性：
```python
from django.contrib import admin
-from west.models import Character,Contact,Tag
+from west.models import Character, Contact, Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
- list_display = ('name','age', 'email') # list
+ list_display = ('name', 'age', 'email') # list
admin.site.register(Contact, ContactAdmin)
admin.site.register([Character, Tag])
```
-
列表页新的显示效果如下：
-
-
-
-
-我们还可以为该列表页增加搜索栏。搜索功能在管理大量记录时非常有用。使用search_fields说明要搜索的属性：
+我们还可以为该列表页增加搜索栏。搜索功能在管理大量记录时非常有用。使用`search_fields`说明要搜索的属性：
```python
from django.contrib import admin
-from west.models import Character,Contact,Tag
+from west.models import Character, Contact, Tag
# Register your models here.
class ContactAdmin(admin.ModelAdmin):
- list_display = ('name','age', 'email')
+ list_display = ('name', 'age', 'email')
search_fields = ('name',)
admin.site.register(Contact, ContactAdmin)
admin.site.register([Character])
```
-
效果如下：
-
-
“我要替小主人留心了。”
-
-
##总结
Django的管理页面有很丰富的数据库管理功能，并可以自定义显示方式，是非常值得使用的工具。
-
-
-“谁，也逃不出我的眼睛！”
+“谁，也逃不出我的眼睛！”
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21006 \345\201\207\344\275\234\347\234\237\346\227\266.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21006 \345\201\207\344\275\234\347\234\237\346\227\266.md"
index 42d2799..0bc66bd 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21006 \345\201\207\344\275\234\347\234\237\346\227\266.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21006 \345\201\207\344\275\234\347\234\237\346\227\266.md"
@@ -1,59 +1,48 @@
#被解放的姜戈06 假作真时
-
-
-
之前了解了：
-创建Django项目
-数据库
-模板
-表格提交
-admin管理页面
-上面的功能模块允许我们做出一个具有互动性的站点，但无法验证用户的身份。我们这次了解用户验证部分。通过用户验证，我们可以根据用户的身份，提供不同的服务。
+1.创建Django项目
+2.数据库
+3.模板
+4.表格提交
+5.admin管理页面
-
+上面的功能模块允许我们做出一个具有互动性的站点，但无法验证用户的身份。我们这次了解用户验证部分。通过用户验证，我们可以根据用户的身份，提供不同的服务。
一个Web应用的用户验证是它的基本组成部分。我们在使用一个应用时，总是从“登录”开始，到“登出”结束。另一方面，用户验证又和网站安全、数据库安全息息相关。HTTP协议是无状态的，但我们可以利用储存在客户端的cookie或者储存在服务器的session来记录用户的访问。
-Django有管理用户的模块，即django.contrib.auth。你可以在mysite/settings.py里看到，这个功能模块已经注册在INSTALLED_APPS中。利用该模块，你可以直接在逻辑层面管理用户，不需要为用户建立模型，也不需要手工去实现会话。
+Django有管理用户的模块，即`django.contrib.auth`。你可以在`mysite/settings.py`里看到，这个功能模块已经注册在`INSTALLED_APPS中`。利用该模块，你可以直接在逻辑层面管理用户，不需要为用户建立模型，也不需要手工去实现会话。
“为了救你的爱人出来，我们要演一场戏。”
-
-
##创建用户
-你可以在admin页面直接看到用户管理的对话框，即Users。从这里，你可以在这里创建、删除和修改用户。点击Add增加用户daddy，密码为daddyiscool。
-
-在admin页面下，我们还可以控制不同用户组对数据库的访问权限。我们可以在Groups中增加用户组，设置用户组对数据库的访问权限，并将用户加入到某个用户组中。
+你可以在`admin`页面直接看到用户管理的对话框，即`Users`。从这里，你可以在这里创建、删除和修改用户。点击“Add”增加用户`daddy`，密码为`daddyiscool`。
-在这一章节中，我们创立一个新的app，即users。下文的模板和views.py，都针对该app。
+在`admin`页面下，我们还可以控制不同用户组对数据库的访问权限。我们可以在`Groups`中增加用户组，设置用户组对数据库的访问权限，并将用户加入到某个用户组中。
-
+在这一章节中，我们创立一个新的app，即`users`。下文的模板和`views.py`，都针对该app。
"你这套新衣服，还真像那么回事"，德国人说。
-
-
用户登录
我们建立一个简单的表格。用户通过该表格来提交登陆信息，并在Django服务器上验证。如果用户名和密码正确，那么登入用户。
我们首先增加一个登录表格：
-```python
+```html
+
+
+
+
+
+
```
-
-我们在views.py中，定义处理函数user_login()，来登入用户：
+我们在`views.py`中，定义处理函数`user_login()`，来登入用户：
```python
# -*- coding: utf-8 -*-
@@ -70,30 +59,27 @@ def user_login(request):
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('/')
+ login(request, user)
+ return redirect('/')
+
ctx = {}
ctx.update(csrf(request))
- return render(request, 'login.html',ctx)
+ return render(request, 'login.html', ctx)
```
-上面的authenticate()函数，可以根据用户名和密码，验证用户信息。而login()函数则将用户登入。它们来自于django.contrib.auth。
-
+上面的`authenticate()`函数，可以根据用户名和密码，验证用户信息。而`login()`函数则将用户登入。它们来自于`django.contrib.auth`。
-作为替换，我们可以使用特别的form对象，而不自行定义表格。这将让代码更简单，而且提供一定的完整性检验。
+作为替换，我们可以使用特别的`form`对象，而不自行定义表格。这将让代码更简单，而且提供一定的完整性检验。
-练习. 使用contrib.auth.forms.AuthenticationForm。来简化上面的模板和处理函数。
-
-
+练习. 使用`contrib.auth.forms.AuthenticationForm`。来简化上面的模板和处理函数。
德国人还是不忘一再叮嘱，"记住，我们可不是什么赏金猎人。"
-
-
##登出
-有时用户希望能销毁会话。我们可以提供一个登出的URL，即/users/logout。登入用户访问该URL，即可登出。在views.py中，增加该URL的处理函数：
+有时用户希望能销毁会话。我们可以提供一个登出的URL，即`/users/logout`。登入用户访问该URL，即可登出。在`views.py`中，增加该URL的处理函数：
```python
# -*- coding: utf-8 -*-
@@ -104,24 +90,22 @@ def user_logout(request):
logout
URL: /users/logout
'''
+
logout(request)
return redirect('/')
```
-我们修改urls.py，让url对应user_logout()。访问http://127.0.0.1/users/logout，就可以登出用户。
-
+我们修改`urls.py`，让url对应`user_logout()`。访问`http://127.0.0.1/users/logout`，就可以登出用户。
德国人压低声音，“哦，我是来救你的，我们要演一出戏。”
-
-
##views.py中的用户
上面说明了如何登入和登出用户，但还没有真正开始享受用户验证带来的好处。用户登陆的最终目的，就是为了让服务器可以区别对待不同的用户。比如说，有些内容只能让登陆用户看到，有些内容则只能让特定登陆用户看到。我们下面将探索如何实现这些效果。
-
+在Django中，对用户身份的检验，主要是在`views.py`中进行。`views.py`是连接模型和视图的中间层。HTTP请求会转给`views.py`中的对应处理函数处理，并发回回复。
-在Django中，对用户身份的检验，主要是在views.py中进行。views.py是连接模型和视图的中间层。HTTP请求会转给views.py中的对应处理函数处理，并发回回复。在views.py的某个处理函数准备HTTP回复的过程中，我们可以检验用户是否登陆。根据用户是否登陆，我们可以给出不同的回复。最原始的方式，是使用if式的选择结构：
+在`views.py`的某个处理函数准备HTTP回复的过程中，我们可以检验用户是否登陆。根据用户是否登陆，我们可以给出不同的回复。最原始的方式，是使用`if`式的选择结构：
```python
# -*- coding: utf-8 -*-
@@ -132,35 +116,35 @@ def diff_response(request):
content = "my dear user
"
else:
content = "you wired stranger
"
+
return HttpResponse(content)
```
-
-可以看到，用户的登录信息包含在request.user中，is_authenticated()方法用于判断用户是否登录，如果用户没有登录，那么该方法将返回false。该user对象属于contrib.auth.user类型，还有其它属性可供使用，比如
+可以看到，用户的登录信息包含在`request.user`中，`is_authenticated()`方法用于判断用户是否登录，如果用户没有登录，那么该方法将返回`False`。该`user`对象属于`contrib.auth.user`类型，还有其它属性可供使用，比如：
-属性 功能
-get_username() 返回用户名
-set_password() 设置密码
-get_fullname() 返回姓名
-last_login 上次登录时间
-date_joined 账户创建时间
-练习. 实验上面的处理函数的效果。
+属性 功能
+`get_username()` 返回用户名
+`set_password()` 设置密码
+`get_fullname()` 返回姓名
+`last_login` 上次登录时间
+`date_joined` 账户创建时间
-
+练习. 实验上面的处理函数的效果。
-在Django中，我们还可以利用装饰器，根据用户的登录状况，来决定views.py中处理函数的显示效果。相对于上面的if结构，装饰器使用起来更加方便。下面的user_only()是views.py中的一个处理函数。
+在Django中，我们还可以利用装饰器，根据用户的登录状况，来决定`views.py`中处理函数的显示效果。相对于上面的if结构，装饰器使用起来更加方便。下面的`user_only()`是`views.py`中的一个处理函数。
+```python
from django.contrib.auth.decorators import login_required
from django.http import HttpResponse
@login_required
def user_only(request):
return HttpResponse("This message is for logged in user only.
")
-注意上面的装饰器login_required，它是Django预设的装饰器。user_only()的回复结果只能被登录用户看到，而未登录用户将被引导到其他页面。
+```
-
+注意上面的装饰器`login_required`，它是Django预设的装饰器。`user_only()`的回复结果只能被登录用户看到，而未登录用户将被引导到其他页面。
-Django中还有其它的装饰器，用于修饰处理函数。相应的http回复，只能被特殊的用户看到。比如user_passes_test，允许的用户必须满足特定标准，而这一标准是可以用户自定义的。比如下面，在views.py中增添：
+Django中还有其它的装饰器，用于修饰处理函数。相应的http回复，只能被特殊的用户看到。比如`user_passes_test`，允许的用户必须满足特定标准，而这一标准是可以用户自定义的。比如下面，在`views.py`中增添：
```python
from django.contrib.auth.decorators import user_passes_test
@@ -172,44 +156,36 @@ def name_check(user):
def specific_user(request):
return HttpResponse("for Vamei only
")
```
-
-
-装饰器带有一个参数，该参数是一个函数对象name_check。当name_check返回真值，即用户名为vamei时，specific_user的结果才能被用户看到。
-
+装饰器带有一个参数，该参数是一个函数对象`name_check`。当`name_check`返回真值，即用户名为`vamei`时，`specific_user`的结果才能被用户看到。
德国人羞涩的笑笑，“我确实对她有那么点好感。”
-
-
##模板中的用户
进一步，用户是否登陆这一信息，也可以直接用于模板。比较原始的方式是把用户信息直接作为环境数据，提交给模板。然而，这并不是必须的。事实上，Django为此提供了捷径：我们可以直接在模板中调用用户信息。比如下面的模板：
+```html
{% if user.is_authenticated %}
- Welcome, my genuine user, my true love.
+ Welcome, my genuine user, my true love.
{% else %}
- Sorry, not login, you are not yet my sweetheart.
+ Sorry, not login, you are not yet my sweetheart.
{% endif %}
-不需要环境变量中定义，我们就可以直接在模板中引用user。这里，模板中调用了user的一个方法，is_authenticated，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。
+```
-
+不需要环境变量中定义，我们就可以直接在模板中引用`user`。这里，模板中调用了`user`的一个方法，`is_authenticated`，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。
练习. 增加处理函数，显示该模板，然后查看不同登录情况下的显示结果。
-
-
管家冷不丁的说，“你认识他们？！”
-
-
##用户注册
-我们上面利用了admin管理页面来增加和删除用户。这是一种简便的方法，但并不能用于一般的用户注册的情境。我们需要提供让用户自主注册的功能。这可以让站外用户提交自己的信息，生成自己的账户，并开始作为登陆用户使用网站。
+我们上面利用了`admin`管理页面来增加和删除用户。这是一种简便的方法，但并不能用于一般的用户注册的情境。我们需要提供让用户自主注册的功能。这可以让站外用户提交自己的信息，生成自己的账户，并开始作为登陆用户使用网站。
-用户注册的基本原理非常简单，即建立一个提交用户信息的表格。表格中至少包括用户名和密码。相应的处理函数提取到这些信息后，建立User对象，并存入到数据库中。
+用户注册的基本原理非常简单，即建立一个提交用户信息的表格。表格中至少包括用户名和密码。相应的处理函数提取到这些信息后，建立`User`对象，并存入到数据库中。
-我们可以利用Django中的UserCreationForm，比较简洁的生成表格，并在views.py中处理表格：
+我们可以利用Django中的`UserCreationForm`，比较简洁的生成表格，并在`views.py`中处理表格：
```python
from django.contrib.auth.forms import UserCreationForm
@@ -228,27 +204,23 @@ def register(request):
ctx.update(csrf(request))
return render(request, "register.html", ctx)
```
-
-相应的模板register.html如下：
+相应的模板`register.html`如下：
+```html
-
+```
“骗子，你们这些骗子”，庄园主怒吼着。
-
-
##总结
正如我们上面提到的，用户登陆系统的最大功能是区分登入和未登入用户，向他们提供不同的内容和服务。
-我们看到了用户验证的基本流程，也看到了如何在views.py和模板中区分用户。
-
-
+我们看到了用户验证的基本流程，也看到了如何在`views.py`和模板中区分用户。
-两杆枪，一支指着德国人，一支指着姜戈。
+两杆枪，一支指着德国人，一支指着姜戈。
\ No newline at end of file
diff --git "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21007 \351\251\254\344\270\215\345\201\234\350\271\204.md" "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21007 \351\251\254\344\270\215\345\201\234\350\271\204.md"
index be29374..b1253c2 100644
--- "a/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21007 \351\251\254\344\270\215\345\201\234\350\271\204.md"
+++ "b/content/\350\242\253\350\247\243\346\224\276\347\232\204\345\247\234\346\210\21007 \351\251\254\344\270\215\345\201\234\350\271\204.md"
@@ -1,35 +1,33 @@
#被解放的姜戈07 马不停蹄
+前面的文章研究了Django最主要的几个方面：数据库、模板、动态生成页面等。但都是使用`python manage.py runserver`来运行服务器。这是一个实验性的web服务器，不适用于正常的站点运行。
-
+我们需要一个可以稳定而持续的服务器。这个服务器负责监听http端口，将收到的请求交给Django处理，将Django的回复发还给客户端。
-前面的文章研究了Django最主要的几个方面：数据库，模板，动态生成页面等。但都是使用python manage.py runserver来运行服务器。这是一个实验性的web服务器，不适用于正常的站点运行。我们需要一个可以稳定而持续的服务器。这个服务器负责监听http端口，将收到的请求交给Django处理，将Django的回复发还给客户端。
+这样的持续性服务器可以有很多选择，比如apache、Nginx、lighttpd等。这里将使用最常见的apache服务器。
-这样的持续性服务器可以有很多选择，比如apache, Nginx, lighttpd等。这里将使用最常见的apache服务器。服务器和Django之间通过Python的web服务接口WSGI连接，因此我们同样需要apache下的mod_wsgi模块。
+服务器和Django之间通过Python的web服务接口WSGI连接，因此我们同样需要apache下的`mod_wsgi`模块。
下面的配置和说明，是在Ubuntu 13.10下进行的。在其它系统下将有所差别。
-
-
-
-
姜戈大喝一声，掉转马头狂奔。
-
-
##安装
-首先需要安装apache2和mod_wsgi。在ubuntu下，我们可以使用apt-get安装：
+首先需要安装apache2和`mod_wsgi`。在ubuntu下，我们可以使用`apt-get`安装：
+
+（RedHat系的Linux发行版，使用`yum`来安装。）
+```bash
sudo apt-get install apache2
sudo apt-get install libapache2-mod-wsgi
- mod_wsgi也可以在google code下载，自行编译安装。
+```
-
+`mod_wsgi`也可以在google code下载，自行编译安装。
-在apache的配置文件/etc/apache2/apache2.conf中增加下面的配置：
+在apache的配置文件`/etc/apache2/apache2.conf`中增加下面的配置：
-```python
+```quote
# Django
WSGIScriptAlias / /home/vamei/mysite/mysite/wsgi.py
WSGIPythonPath /home/vamei/mysite
@@ -41,36 +39,28 @@ WSGIPythonPath /home/vamei/mysite
```
-上面的配置中/home/ubuntu/mysite是Django项目所在的位置。而/home/ubuntu/mysite/mysite/wsgi.py是Django项目中z自动创建的文件。
-可以看到，利用WSGIScriptAlias，我们实际上将URL /对应了wsgi接口程序。这样，当我们访问根URL时，访问请求会经由WSGI接口，传递给Django项目mysite。
+上面的配置中`/home/ubuntu/mysite`是Django项目所在的位置。而`/home/ubuntu/mysite/mysite/wsgi.py`是Django项目中自动创建的文件。
-
+可以看到，利用`WSGIScriptAlias`，我们实际上将URL /对应了`wsgi`接口程序。这样，当我们访问根URL时，访问请求会经由WSGI接口，传递给Django项目`mysite`。
配置好后，重启apache2
+```bash
sudo /etc/init.d/apache2 restart
-
+```
使用浏览器，可以检查效果：
-
-
-
-
想起逝去的德国人，姜戈心中一痛。
-
-
##静态文件
-Django的主要功能是动态的生成HTTP回复。很多媒体文件是静态存储的，如.js文件，.css文件和图片文件。这些文件变动的频率较小。我们希望静态的提供这些文件，而不是动态的生成。这样既可以减小服务器的负担，也便于在浏览器缓存，提高用户体验。
-
-
+Django的主要功能是动态的生成HTTP回复。很多媒体文件是静态存储的，如`.js`文件、`.css`文件和图片文件。这些文件变动的频率较小。我们希望静态的提供这些文件，而不是动态的生成。这样既可以减小服务器的负担，也便于在浏览器缓存，提高用户体验。
-我们可以在apache2.conf中添加如下配置：
+我们可以在`apache2.conf`中添加如下配置：
-```python
+```quote
Alias /media/ /home/vamei/media/
Alias /static/ /home/vamei/static/
@@ -95,38 +85,25 @@ WSGIPythonPath /home/vamei/mysite
```
-这样，/static/和/media/这两个URL的访问将引导向存有静态文件的/home/vamei/static/和/home/vamei/media/，apache将直接向客户提供这两个文件夹中的静态文件。而剩下的URL访问，将导向WSGI接口，由Django动态处理。
-
-
-
-在/home/vamei/static/中放入文件revenge.jpg，访问http://localhost/static/revenge：
-
+这样，`/static/`和`/media/`这两个URL的访问将引导向存有静态文件的`/home/vamei/static/和/home/vamei/media/`，apache将直接向客户提供这两个文件夹中的静态文件。而剩下的URL访问，将导向WSGI接口，由Django动态处理。
-
+在`/home/vamei/static/`中放入文件`revenge.jpg`，访问`http://localhost/static/revenge`：
姜戈想到爱人身陷囹圄，忧伤顿时化为愤怒。
-
-
##其它
云平台或者服务器的部署是一个大的课题，这里无法深入到所有的细节。幸运的是，在网上有丰富的资料。你可以根据自己的平台和问题，搜索相应的资料。
-在Django的debug模式下，我们可以在app文件夹中建立static目录，放入静态文件。Django将自动搜索到其中的静态文件。但这一方法有很大的安全隐患，只适用于开发。
-
-
+在Django的debug模式下，我们可以在`app`文件夹中建立`static`目录，放入静态文件。Django将自动搜索到其中的静态文件。但这一方法有很大的安全隐患，只适用于开发。
马蹄声疾，电光火石之间，姜戈已经把护园家丁撂倒在地。
-
-
##总结
-apache + mod_wsgi
-
-静态文件
+`apache` + `mod_wsgi`。
-
+静态文件。
-“你在外面等我，我要跟他们算总帐”，姜戈对爱人说。
+“你在外面等我，我要跟他们算总帐”，姜戈对爱人说。
\ No newline at end of file