From 6e81f33b958325359f19f8233cc91f122a2d810e Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Wed, 18 Jun 2014 21:07:57 +0800
Subject: [PATCH 01/13] =?UTF-8?q?=E4=B8=BA=E6=96=87=E4=B8=AD=E5=87=BA?=
 =?UTF-8?q?=E7=8E=B0=E7=9A=84=E4=BB=A3=E7=A0=81=E3=80=81=E5=8F=98=E9=87=8F?=
 =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81=EF=BC=88code=EF=BC=89?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E3=80=82=E5=A6=82=EF=BC=9A`print()`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/07.md             | 20 +++++++++---------
 content/08.md             | 30 +++++++++++++-------------
 content/09.md             | 28 ++++++++++++-------------
 content/10.md             | 34 +++++++++++++++---------------
 content/intermediate01.md | 16 +++++++-------
 content/intermediate02.md |  2 +-
 content/intermediate03.md | 14 ++++++-------
 content/intermediate04.md | 26 +++++++++++------------
 content/intermediate05.md | 24 ++++++++++-----------
 content/intermediate06.md | 18 ++++++++--------
 content/intermediate07.md | 44 +++++++++++++++++++--------------------
 content/intermediate08.md | 26 +++++++++++------------
 content/intermediate09.md | 12 +++++------
 13 files changed, 147 insertions(+), 147 deletions(-)

diff --git a/content/07.md b/content/07.md
index 0d42d2e..aaae497 100644
--- a/content/07.md
+++ b/content/07.md
@@ -14,9 +14,9 @@ def square_sum(a,b):
 ```
 这个函数的功能是求两个数的平方和。
 
-首先，def，这个关键字通知python：我在定义一个函数。square_sum是函数名。
+首先，`def`，这个关键字通知`python`：我在定义一个函数。`square_sum`是函数名。
 
-括号中的a, b是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。
+括号中的`a`, `b`是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。
 
 我们已经在循环和选择中见过冒号和缩进来表示的隶属关系。
 
@@ -24,13 +24,13 @@ c = a**2 + b**2        # 这一句是函数内部进行的运算
 
 return c               # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。
 
-return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。
+`return`可以返回多个值，以逗号分隔。相当于返回一个`tuple`(定值表)。
 
 return a,b,c          # 相当于 return (a,b,c)
 
  
 
-在Python中，当程序执行到return的时候，程序将停止执行函数内余下的语句。return并不是必须的，当没有return, 或者return后面没有返回值时，函数将自动返回None。None是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。None多用于关键字参数传递的默认值。
+在Python中，当程序执行到`return`的时候，程序将停止执行函数内余下的语句。`return`并不是必须的，当没有`return`, 或者`return`后面没有返回值时，函数将自动返回`None`。`None`是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。`None`多用于关键字参数传递的默认值。
 
  
 
@@ -40,11 +40,11 @@ return a,b,c          # 相当于 return (a,b,c)
 ```python
 print square_sum(3,4)
 ```
-Python通过位置，知道3对应的是函数定义中的第一个参数a， 4对应第二个参数b，然后把参数传递给函数square_sum。
+Python通过位置，知道3对应的是函数定义中的第一个参数`a`， `4`对应第二个参数`b`，然后把参数传递给函数`square_sum`。
 
 （Python有丰富的参数传递方式，还有关键字传递、表传递、字典传递等，基础教程将只涉及位置传递）
 
-函数经过运算，返回值25, 这个25被print打印出来。
+函数经过运算，返回值`25`, 这个`25`被`print`打印出来。
 
  
 
@@ -71,9 +71,9 @@ def change_list(b):
 print change_list(b)
 print b
 ```
-第一个例子，我们将一个整数变量传递给函数，函数对它进行操作，但原整数变量a不发生变化。
+第一个例子，我们将一个整数变量传递给函数，函数对它进行操作，但原整数变量`a`不发生变化。
 
-第二个例子，我们将一个表传递给函数，函数进行操作，原来的表b发生变化。
+第二个例子，我们将一个表传递给函数，函数进行操作，原来的表`b`发生变化。
 
 对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为值传递）
 
@@ -89,7 +89,7 @@ def function_name(a,b,c):
 ```    
 函数的目的： 提高程序的重复可用性。
 
-return     None
+`return`     `None`
 
 通过位置，传递参数。
 
@@ -101,4 +101,4 @@ return     None
 
 练习:
 
-写一个判断闰年的函数，参数为年、月、日。若是是闰年，返回True
+写一个判断闰年的函数，参数为年、月、日。若是是闰年，返回`True`
diff --git a/content/08.md b/content/08.md
index 1f69024..94fb6ad 100644
--- a/content/08.md
+++ b/content/08.md
@@ -18,16 +18,16 @@ class Bird(object):
     have_feather = True
     way_of_reproduction  = 'egg'
 ```
-我们定义了一个类别（class），就是鸟（Bird）。在隶属于这个类比的语句块中，我们定义了两个变量，一个是有羽毛（have_feather），一个是生殖方式（way_of_reproduction）,这两个变量对应我们刚才说的属性（attribute）。我们暂时先不说明括号以及其中的内容，记为问题1。
+我们定义了一个类别（class），就是鸟（`Bird`）。在隶属于这个类比的语句块中，我们定义了两个变量，一个是有羽毛（`have_feather`），一个是生殖方式（`way_of_reproduction`）,这两个变量对应我们刚才说的属性（attribute）。我们暂时先不说明括号以及其中的内容，记为问题1。
 
-假设我养了一只小鸡，叫summer。它是个对象，且属于鸟类。使用前面定义的类：
+假设我养了一只小鸡，叫`summer`。它是个对象，且属于鸟类。使用前面定义的类：
 ```python
 summer = Bird()
 print summer.way_of_reproduction
 ```
-通过第一句创建对象，并说明summer是类别鸟中的一个对象，summer就有了鸟的类属性，对属性的引用是通过 对象.属性（object.attribute） 的形式实现的。
+通过第一句创建对象，并说明`summer`是类别鸟中的一个对象，`summer`就有了鸟的类属性，对属性的引用是通过 对象.属性（`object.attribute`） 的形式实现的。
 
-可怜的summer，你就是个有毛产的蛋货，好不精致。
+可怜的`summer`，你就是个有毛产的蛋货，好不精致。
 
 ##动作
 
@@ -48,15 +48,15 @@ class Bird(object):
 summer = Bird()
 print 'after move:',summer.move(5,8)
 ```
-我们重新定义了鸟这个类别。鸟新增一个方法属性，就是表示移动的方法move。（我承认这个方法很傻，你可以在看过下一讲之后定义个有趣些的方法）
+我们重新定义了鸟这个类别。鸟新增一个方法属性，就是表示移动的方法`move`。（我承认这个方法很傻，你可以在看过下一讲之后定义个有趣些的方法）
 
-（它的参数中有一个self，它是为了方便我们引用对象自身。方法的第一个参数必须是self，无论是否用到。有关self的内容会在下一讲展开）
+（它的参数中有一个`self`，它是为了方便我们引用对象自身。方法的第一个参数必须是`self`，无论是否用到。有关`self`的内容会在下一讲展开）
 
-另外两个参数，dx, dy表示在x、y两个方向移动的距离。move方法会最终返回运算过的position。
+另外两个参数，`dx`, `dy`表示在`x`、`y`两个方向移动的距离。`move`方法会最终返回运算过的`position`。
 
-在最后调用move方法的时候，我们只传递了dx和dy两个参数，不需要传递self参数（因为self只是为了内部使用）。
+在最后调用`move`方法的时候，我们只传递了`dx`和`dy`两个参数，不需要传递`self`参数（因为`self`只是为了内部使用）。
 
-我的summer可以跑了。
+我的`summer`可以跑了。
 
 ##子类
 
@@ -79,19 +79,19 @@ summer = Chicken()
 print summer.have_feather
 print summer.move(5,8)
 ```
-新定义的鸡（Chicken）类的，增加了两个属性：移动方式（way_of_move），可能在KFC找到（possible_in_KFC）
+新定义的鸡（`Chicken`）类的，增加了两个属性：移动方式（`way_of_move`），可能在KFC找到（`possible_in_KFC`）
 
-在类定义时，括号里为了Bird。这说明，Chicken是属于鸟类（Bird）的一个子类，即Chicken继承自Bird。自然而然，Bird就是Chicken的父类。Chicken将享有Bird的所有属性。尽管我只声明了summer是鸡类，它通过继承享有了父类的属性（无论是变量属性have_feather还是方法属性move）
+在类定义时，括号里为了`Bird`。这说明，`Chicken`是属于鸟类（`Bird`）的一个子类，即`Chicken`继承自`Bird`。自然而然，`Bird`就是`Chicken`的父类。`Chicken`将享有`Bird`的所有属性。尽管我只声明了`summer`是鸡类，它通过继承享有了父类的属性（无论是变量属性`have_feather`还是方法属性`move`）
 
  
 
-新定义的黄鹂(Oriole)类，同样继承自鸟类。在创建一个黄鹂对象时，该对象自动拥有鸟类的属性。
+新定义的黄鹂(`Oriole`)类，同样继承自鸟类。在创建一个黄鹂对象时，该对象自动拥有鸟类的属性。
 
  
 
 通过继承制度，我们可以减少程序中的重复信息和重复语句。如果我们分别定义两个类，而不继承自鸟类，就必须把鸟类的属性分别输入到鸡类和黄鹂类的定义中。整个过程会变得繁琐，因此，面向对象提高了程序的可重复使用性。
 
-（回到问题1, 括号中的object，当括号中为object时，说明这个类没有父类（到头了））
+（回到问题1, 括号中的`object`，当括号中为`object`时，说明这个类没有父类（到头了））
 
  
 
@@ -107,8 +107,8 @@ print summer.move(5,8)
 
 用继承来说明父类-子类关系。子类自动具有父类的所有属性。
 
-self代表了根据类定义而创建的对象。
+`self`代表了根据类定义而创建的对象。
 
 建立对一个对象： 对象名 = 类名()
 
-引用对象的属性： object.attribute
+引用对象的属性： `object.attribute`
diff --git a/content/09.md b/content/09.md
index 1b36a88..90d1811 100644
--- a/content/09.md
+++ b/content/09.md
@@ -4,7 +4,7 @@
 
 ##调用类的其它信息
 
-上一讲中提到，在定义方法时，必须有self这一参数。这个参数表示某个对象。对象拥有类的所有性质，那么我们可以通过self，调用类属性。
+上一讲中提到，在定义方法时，必须有`self`这一参数。这个参数表示某个对象。对象拥有类的所有性质，那么我们可以通过`self`，调用类属性。
 
 ```python
 class Human(object):
@@ -18,17 +18,17 @@ class Human(object):
 li_lei = Human()          
 li_lei.laugh_100th()
 ```
-这里有一个类属性laugh。在方法show_laugh()中，通过self.laugh，调用了该属性的值。
+这里有一个类属性`laugh`。在方法`show_laugh()`中，通过`self.laugh`，调用了该属性的值。
 
-还可以用相同的方式调用其它方法。方法show_laugh()，在方法laugh_100th中()被调用。
+还可以用相同的方式调用其它方法。方法`show_laugh()`，在方法`laugh_100th()`中被调用。
 
 通过对象可以修改类属性值。但这是危险的。类属性被所有同一类及其子类的对象共享。类属性值的改变会影响所有的对象。
 
 ##__init__()方法
 
-__init__()是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。
+`__init__()`是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。
 
-如果你在类中定义了__init__()这个方法，创建对象时，Python会自动调用这个方法。这个过程也叫初始化。
+如果你在类中定义了`__init__()`这个方法，创建对象时，Python会自动调用这个方法。这个过程也叫初始化。
 ```python
 class happyBird(Bird):
     def __init__(self,more_words):
@@ -36,18 +36,18 @@ class happyBird(Bird):
 
 summer = happyBird('Happy,Happy!')
 ```
-这里继承了Bird类，它的定义见上一讲。
+这里继承了`Bird`类，它的定义见上一讲。
 
  
 
 屏幕上打印：
 > We are happy birds.Happy,Happy!
 
-我们看到，尽管我们只是创建了summer对象，但__init__()方法被自动调用了。最后一行的语句(summer = happyBird...)先创建了对象，然后执行：
+我们看到，尽管我们只是创建了`summer`对象，但`__init__()`方法被自动调用了。最后一行的语句(`summer = happyBird...`)先创建了对象，然后执行：
 ```python
 summer.__init__(more_words)
 ```
-'Happy,Happy!' 被传递给了__init__()的参数more_words
+`'Happy,Happy!'` 被传递给了`__init__()`的参数`more_words`
 
  
 
@@ -57,7 +57,7 @@ summer.__init__(more_words)
 
 在一些情况下，我们定义对象的性质，用于记录该对象的特别信息。比如说，人这个类。性别是某个人的一个性质，不是所有的人类都是男，或者都是女。这个性质的值随着对象的不同而不同。李雷是人类的一个对象，性别是男；韩美美也是人类的一个对象，性别是女。
 
-当定义类的方法时，必须要传递一个self的参数。这个参数指代的就是类的一个对象。我们可以通过操纵self，来修改某个对象的性质。比如用类来新建一个对象，即下面例子中的li_lei, 那么li_lei就被self表示。我们通过赋值给self.attribute，给li_lei这一对象增加一些性质，比如说性别的男女。self会传递给各个方法。在方法内部，可以通过引用self.attribute，查询或修改对象的性质。
+当定义类的方法时，必须要传递一个`self`的参数。这个参数指代的就是类的一个对象。我们可以通过操纵`self`，来修改某个对象的性质。比如用类来新建一个对象，即下面例子中的`li_lei`, 那么`li_lei`就被`self`表示。我们通过赋值给`self.attribute`，给`li_lei`这一对象增加一些性质，比如说性别的男女。`self`会传递给各个方法。在方法内部，可以通过引用`self.attribute`，查询或修改对象的性质。
 
 这样，在类属性的之外，又给每个对象增添了各自特色的性质，从而能描述多样的世界。
 
@@ -72,16 +72,16 @@ li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的
 print li_lei.gender
 li_lei.printGender()
 ```
-在初始化中，将参数input_gender，赋值给对象的性质，即self.gender。
+在初始化中，将参数`input_gender`，赋值给对象的性质，即`self.gender`。
 
-li_lei拥有了对象性质gender。gender不是一个类属性。Python在建立了li_lei这一对象之后，使用li_lei.gender这一对象性质，专门储存属于对象li_lei的特有信息。
+`li_lei`拥有了对象性质`gender`。`gender`不是一个类属性。Python在建立了`li_lei`这一对象之后，使用`li_lei.gender`这一对象性质，专门储存属于对象`li_lei`的特有信息。
 
-对象的性质也可以被其它方法调用，调用方法与类属性的调用相似，正如在printGender()方法中的调用。
+对象的性质也可以被其它方法调用，调用方法与类属性的调用相似，正如在`printGender()`方法中的调用。
 
 ##总结
 
-通过self调用类属性
+通过`self`调用类属性
 
-__init__(): 在建立对象时自动执行
+`__init__()`: 在建立对象时自动执行
 
 类属性和对象的性质的区别
diff --git a/content/10.md b/content/10.md
index 569daf1..9029974 100644
--- a/content/10.md
+++ b/content/10.md
@@ -6,21 +6,21 @@
 
  
 
-需要先要介绍两个内置函数，dir()和help()
+需要先要介绍两个内置函数，`dir()`和`help()`
 
-dir()用来查询一个类或者对象所有属性。你可以尝试一下
+`dir()`用来查询一个类或者对象所有属性。你可以尝试一下
 
 ```python
 >>>print dir(list)
 ```
 
-help()用来查询的说明文档。你可以尝试一下
+`help()`用来查询的说明文档。你可以尝试一下
 
 ```python
 >>>print help(list)
 ```
 
-(list是Python内置的一个类，对应于我们之前讲解过的列表)
+(`list`是Python内置的一个类，对应于我们之前讲解过的列表)
 
 
 ##list是一个类
@@ -31,9 +31,9 @@ help()用来查询的说明文档。你可以尝试一下
 >>>nl = [1,2,5,3,5]
 ```
 
-实际上，nl是类list的一个对象。
+实际上，`nl`是类`list`的一个对象。
 
-实验一些list的方法：
+实验一些`list`的方法：
 
 ```python
 >>>print nl.count(5)       # 计数，看总共有多少个5
@@ -44,24 +44,24 @@ help()用来查询的说明文档。你可以尝试一下
 >>>nl.remove(2)            # 从nl中去除第一个2
 >>>nl.insert(0,9)          # 在下标为0的位置插入9
 ```
-总之，list是一个类。每个列表都属于该类。
+总之，`list`是一个类。每个列表都属于该类。
 
-Python补充中有list常用方法的附录。
+Python补充中有`list`常用方法的附录。
 
  
 
 ##运算符是特殊方法
 
-使用dir(list)的时候，能看到一个属性，是__add__()。从形式上看是特殊方法（下划线，下划线）。它特殊在哪呢？
+使用`dir(list)`的时候，能看到一个属性，是`__add__()`。从形式上看是特殊方法（下划线，下划线）。它特殊在哪呢？
 
-这个方法定义了"+"运算符对于list对象的意义，两个list的对象相加时，会进行的操作。
+这个方法定义了`+`运算符对于`list`对象的意义，两个`list`的对象相加时，会进行的操作。
 
 ```python
 >>>print [1,2,3] + [5,6,9]
 ```
  
 
-运算符，比如+, -, >, <, 以及下标引用[start:end]等等，从根本上都是定义在类内部的方法。
+运算符，比如`+`, `-`, `>`, `<`, 以及下标引用`[start:end]`等等，从根本上都是定义在类内部的方法。
 
  
 
@@ -70,7 +70,7 @@ Python补充中有list常用方法的附录。
 >>>print [1,2,3] - [3,4]
 ```
 
-会有错误信息，说明该运算符“-”没有定义。现在我们继承list类，添加对"-"的定义
+会有错误信息，说明该运算符`-`没有定义。现在我们继承`list`类，添加对`-`的定义
 
 ```python
 class superList(list):
@@ -85,17 +85,17 @@ class superList(list):
 
 print superList([1,2,3]) - superList([3,4])
 ```
-内置函数len()用来返回list所包含的元素的总数。内置函数__sub__()定义了“-”的操作：从第一个表中去掉第二个表中出现的元素。如果__sub__()已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。
+内置函数`len()`用来返回`list`所包含的元素的总数。内置函数`__sub__()`定义了`-`的操作：从第一个表中去掉第二个表中出现的元素。如果`__sub__()`已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。
 
 （教程最后也会给出一个特殊方法的清单）
 
-定义运算符对于复杂的对象非常有用。举例来说，人类有多个属性，比如姓名，年龄和身高。我们可以把人类的比较（>, <, =）定义成只看年龄。这样就可以根据自己的目的，将原本不存在的运算增加在对象上了。
+定义运算符对于复杂的对象非常有用。举例来说，人类有多个属性，比如姓名，年龄和身高。我们可以把人类的比较（`>`, `<`, `=`）定义成只看年龄。这样就可以根据自己的目的，将原本不存在的运算增加在对象上了。
 
 ##下一步
 
 希望你已经对Python有了一个基本了解。你可能跃跃欲试，要写一些程序练习一下。这会对你很有好处。
 
-但是，Python的强大很大一部分原因在于，它提供有很多已经写好的，可以现成用的对象。我们已经看到了内置的比如说list，还有tuple等等。它们用起来很方便。在Python的标准库里，还有大量可以用于操作系统互动，Internet开发，多线程，文本处理的对象。而在所有的这些的这些的基础上，又有很多外部的库包，定义了更丰富的对象，比如numpy, tkinter, django等用于科学计算，GUI开发，web开发的库，定义了各种各样的对象。对于一般用户来说，使用这些库，要比自己去从头开始容易得多。我们要开始攀登巨人的肩膀了。
+但是，Python的强大很大一部分原因在于，它提供有很多已经写好的，可以现成用的对象。我们已经看到了内置的比如说`list`，还有`tuple`等等。它们用起来很方便。在Python的标准库里，还有大量可以用于操作系统互动，Internet开发，多线程，文本处理的对象。而在所有的这些的这些的基础上，又有很多外部的库包，定义了更丰富的对象，比如`numpy`, `tkinter`, `django`等用于科学计算，GUI开发，web开发的库，定义了各种各样的对象。对于一般用户来说，使用这些库，要比自己去从头开始容易得多。我们要开始攀登巨人的肩膀了。
 
 谢谢你的关注，
 
@@ -105,8 +105,8 @@ print superList([1,2,3]) - superList([3,4])
 
 ##总结
 
-len() dir() help()
+`len()` `dir()` `help()`
 
-数据结构list(列表)是一个类。
+数据结构`list`(列表)是一个类。
 
 运算符是方法
diff --git a/content/intermediate01.md b/content/intermediate01.md
index 01ab3f8..ea5b384 100644
--- a/content/intermediate01.md
+++ b/content/intermediate01.md
@@ -6,7 +6,7 @@
 
  
 
-之前我们说了，列表是Python里的一个类。一个特定的表，比如说nl = [1,3,8]，就是这个类的一个对象。我们可以调用这个对象的一些方法，比如 nl.append(15)。
+之前我们说了，列表是Python里的一个类。一个特定的表，比如说`nl = [1,3,8]`，就是这个类的一个对象。我们可以调用这个对象的一些方法，比如 `nl.append(15)`。
 我们要介绍一个新的类，词典 (dictionary)。与列表相似，词典也可以储存多个元素。这种储存多个元素的对象称为容器(container)。
 
  
@@ -23,7 +23,7 @@
 
  
 
-比如上面的例子中，'tom'对应11，'sam'对应57，'lily'对应100
+比如上面的例子中，`tom`对应`11`，`sam`对应`57`，`lily`对应`100`
 
  
 
@@ -62,9 +62,9 @@ for key in dic:
     print dic[key]
 ```
 
-在循环中，dict的每个键，被提取出来，赋予给key变量。
+在循环中，`dic`的每个键，被提取出来，赋予给`key`变量。
 
-通过print的结果，我们可以再次确认，dic中的元素是没有顺序的。
+通过`print`的结果，我们可以再次确认，`dic`中的元素是没有顺序的。
 
 
 词典的遍历也可以同时取出键和值：
@@ -89,11 +89,11 @@ for key,value in dict_od.items():
 ```python
 >>>del dic['tom']             # 删除 dic 的‘tom’元素
 ```
-del是Python中保留的关键字，用于删除对象。
+`del`是Python中保留的关键字，用于删除对象。
 
  
 
-与表类似，你可以用len()查询词典中的元素总数。
+与表类似，你可以用`len()`查询词典中的元素总数。
 ```python
 >>>print(len(dic))
 ```
@@ -101,13 +101,13 @@ del是Python中保留的关键字，用于删除对象。
 ## 词典排序
 前面我们已经谈到，词典是无序的，那么，如果需要词典内容有序，就需要使用排序方法：
 
-词典按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
 ```
diff --git a/content/intermediate02.md b/content/intermediate02.md
index a300b79..2717ddb 100644
--- a/content/intermediate02.md
+++ b/content/intermediate02.md
@@ -6,7 +6,7 @@
 
 Python具有基本的文本文件读写功能。Python的标准库提供有更丰富的读写功能。
 
-文本文件的读写主要通过open()所构建的文件对象来实现。
+文本文件的读写主要通过`open()`所构建的文件对象来实现。
 
  
 
diff --git a/content/intermediate03.md b/content/intermediate03.md
index 553cef8..4b81a59 100644
--- a/content/intermediate03.md
+++ b/content/intermediate03.md
@@ -18,24 +18,24 @@ 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
 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.对象。
 ```
@@ -49,7 +49,7 @@ Python会在以下路径中搜索它想要寻找的模块：
 
 程序所在的文件夹
 标准库的安装路径
-操作系统环境变量PYTHONPATH所包含的路径
+操作系统环境变量`PYTHONPATH`所包含的路径
  
 
 如果你有自定义的模块，或者下载的模块，可以根据情况放在相应的路径，以便Python可以找到。
@@ -58,11 +58,11 @@ Python会在以下路径中搜索它想要寻找的模块：
 
 模块包
 
-可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。通过
+可以将功能相似的模块放在同一个文件夹（比如说`this_dir`）中，构成一个模块包。通过
 ```python
 import this_dir.module
 ```
-引入this_dir文件夹中的module模块。
+引入`this_dir`文件夹中的`module`模块。
 
  
 
diff --git a/content/intermediate04.md b/content/intermediate04.md
index bd625f0..2fade5b 100644
--- a/content/intermediate04.md
+++ b/content/intermediate04.md
@@ -13,13 +13,13 @@ def f(a,b,c):
 
 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))
 ``` 
@@ -31,7 +31,7 @@ print(f(1,c=3,b=2))
 
 ##参数默认值
 
-在定义函数的时候，使用形如a=19的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。
+在定义函数的时候，使用形如`a=19`的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。
 ```python
 def f(a,b,c=10):
     return a+b+c
@@ -39,9 +39,9 @@ def f(a,b,c=10):
 print(f(3,2))
 print(f(3,2,1))
 ```
-在第一次调用函数f时， 我们并没有足够的值，c没有被赋值，c将使用默认值10.
+在第一次调用函数f时， 我们并没有足够的值，`c`没有被赋值，`c`将使用默认值`10`.
 
-第二次调用函数的时候，c被赋值为1，不再使用默认值。
+第二次调用函数的时候，`c`被赋值为`1`，不再使用默认值。
 
  
 
@@ -60,9 +60,9 @@ def func(*name):
 func(1,4,6)
 func(5,6,7,1,2,3)
 ```
-两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。
+两次调用，尽管参数个数不同，都基于同一个`func`定义。在`func`的参数表中，所有的参数被`name`收集，根据位置合并成一个元组(`tuple`)，这就是包裹位置传递。
 
-为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。
+为了提醒Python参数，`name`是包裹位置传递所用的元组名，在定义`func`时，在`name`前加`*`号。
 
  
 
@@ -75,15 +75,15 @@ def func(**dict):
 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
@@ -91,16 +91,16 @@ def func(a,b,c):
 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}
 func(**dict)
 ```
-在传递词典dict时，让词典的每个键值对作为一个关键字传递给func。
+在传递词典`dict`时，让词典的每个键值对作为一个关键字传递给`func`。
 
  
 
diff --git a/content/intermediate05.md b/content/intermediate05.md
index d7d1dbe..4bf4a2d 100644
--- a/content/intermediate05.md
+++ b/content/intermediate05.md
@@ -9,31 +9,31 @@
 
 ##range()
 
-在Python中，for循环后的in跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。
+在Python中，`for`循环后的`in`跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。
 
-之前我们已经使用过range()来控制for循环。现在，我们继续开发range的功能，以实现下标对循环的控制：
+之前我们已经使用过`range()`来控制`for`循环。现在，我们继续开发`range`的功能，以实现下标对循环的控制：
 ```python
 S = 'abcdefghijk'
 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):
     print index
     print char
 ```
-实际上，enumerate()在每次循环中，返回的是一个包含两个元素的定值表(tuple)，两个元素分别赋予index和char
+实际上，`enumerate()`在每次循环中，返回的是一个包含两个元素的定值表(`tuple`)，两个元素分别赋予`index`和`char`
 
 增加下标的访问设计
-在python 3.2中，支持enumerate带第二个参数，用来指定循环的开始位置，比如，从第一个下标位置开始循环：
+在python 3.2中，支持`enumerate`带第二个参数，用来指定循环的开始位置，比如，从第一个下标位置开始循环：
 ```python
 array = [1, 2, 3, 4, 5]
 
@@ -45,7 +45,7 @@ for i, e in enumerate(array,1):
 
 ##zip()
 
-如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：
+如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用`zip()`方便地实现：
 ```python
 ta = [1,2,3]
 tb = [9,8,7]
@@ -53,9 +53,9 @@ tc = ['a','b','c']
 for (a,b,c) in zip(ta,tb,tc):
     print(a,b,c)
 ```    
-每次循环时，从各个序列分别从左到右取出一个元素，合并成一个tuple，然后tuple的元素赋予给a,b,c
+每次循环时，从各个序列分别从左到右取出一个元素，合并成一个`tuple`，然后`tuple`的元素赋予给`a`,`b`,`c`
 
-zip()函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。
+`zip()`函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入`zip()`返回的列表中。`zip()`函数起到了聚合列表的功能。
 
  
 
@@ -76,8 +76,8 @@ print(na, nb)
 
 ##总结
 
-range()
+`range()`
 
-enumerate()
+`enumerate()`
 
-zip()
+`zip()`
diff --git a/content/intermediate06.md b/content/intermediate06.md
index 09a0de1..699c1d5 100644
--- a/content/intermediate06.md
+++ b/content/intermediate06.md
@@ -12,9 +12,9 @@
 
 ##什么是循环对象
 
-循环对象是这样一个对象，它包含有一个next()方法(__next__()方法，在python 3x中)， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration错误。
+循环对象是这样一个对象，它包含有一个`next()`方法(`__next__()`方法，在python 3x中)， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出`StopIteration`错误。
 
-当一个循环结构（比如for）调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()。
+当一个循环结构（比如`for`）调用循环对象时，它就会每次循环的时候调用`next()`方法，直到`StopIteration`出现，`for`循环接收到，就知道循环已经结束，停止调用`next()`。
 
 假设我们有一个test.txt的文件:
 ```bash
@@ -33,16 +33,16 @@ efg
 ...
 ```
 
-不断输入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`的时候结束。
 
  
 
@@ -52,7 +52,7 @@ for line in open('test.txt'):
 
 ##迭代器
 
-从技术上来说，循环对象和for循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。
+从技术上来说，循环对象和`for`循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用`iter()`函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。
 
  
 
@@ -60,7 +60,7 @@ for line in open('test.txt'):
 
 生成器(generator)的主要目的是构成一个用户自定义的循环对象。
 
-生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。
+生成器的编写方法和函数定义类似，只是在`return`的地方改为`yield`。生成器中可以有多个`yield`。当生成器遇到一个`yield`时，会暂停运行生成器，返回`yield`后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个`yield`。生成器自身又构成一个循环器，每次循环使用一个`yield`返回的值。
 
  
 
@@ -73,7 +73,7 @@ def gen():
     yield a
     yield 1000
 ```    
-该生成器共有三个yield， 如果用作循环器时，会进行三次循环。
+该生成器共有三个`yield`， 如果用作循环器时，会进行三次循环。
 ```python
 for i in gen():
     print i
@@ -103,7 +103,7 @@ L = []
 for x in range(10):
     L.append(x**2)
 ```    
-以上产生了表L，但实际上有快捷的写法，也就是表推导的方式:
+以上产生了表`L`，但实际上有快捷的写法，也就是表推导的方式:
 ```python
 L = [x**2 for x in range(10)]
 ```
diff --git a/content/intermediate07.md b/content/intermediate07.md
index 43c5f49..f15fc54 100644
--- a/content/intermediate07.md
+++ b/content/intermediate07.md
@@ -4,18 +4,18 @@
 
  
 
-秉承着一切皆对象的理念，我们再次回头来看函数(function)。函数也是一个对象，具有属性（可以使用dir()查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
+秉承着一切皆对象的理念，我们再次回头来看函数(function)。函数也是一个对象，具有属性（可以使用`dir()`查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
 
  
 
 ##lambda函数
 
-在展开之前，我们先提一下lambda函数。可以利用lambda函数的语法，定义函数。lambda例子如下：
+在展开之前，我们先提一下`lambda`函数。可以利用`lambda`函数的语法，定义函数。`lambda`例子如下：
 ```python
 func = lambda x,y: x + y
 print func(3,4)
 ```
-lambda生成一个函数对象。该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。
+`lambda`生成一个函数对象。该函数参数为`x`,`y`，返回值为`x + y`。函数对象赋给`func`。`func`的调用与正常函数无异。
 
  
 
@@ -27,7 +27,7 @@ def func(x, y):
 
 ##函数作为参数传递
 
-函数可以作为一个对象，进行参数传递。函数名(比如func)即该对象。比如说:
+函数可以作为一个对象，进行参数传递。函数名(比如`func`)即该对象。比如说:
 ```python
 def test(f, a, b):
     print 'test'
@@ -35,42 +35,42 @@ 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)
 ``` 
 
 ##map()函数
 
-map()是Python的内置函数。它的第一个参数是一个函数对象。
+`map()`是Python的内置函数。它的第一个参数是一个函数对象。
 ```python
 re = map((lambda x: x+3),[1,3,5,6])
 ```
-这里，map()有两个参数，一个是lambda所定义的函数对象，一个是包含有多个元素的表。map()的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表re中。map通过读入的函数(这里是lambda函数)来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加3）。
+这里，`map()`有两个参数，一个是`lambda`所定义的函数对象，一个是包含有多个元素的表。`map()`的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表`re`中。`map()`通过读入的函数(这里是`lambda`函数)来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加`3`）。
 
-在Python 3.X中，map()的返回值是一个循环对象。可以利用list()函数，将该循环对象转换成表。
+在Python 3.X中，`map()`的返回值是一个循环对象。可以利用`list()`函数，将该循环对象转换成表。
 
  
 
-如果作为参数的函数对象有多个参数，可使用下面的方式，向map()传递函数参数的多个参数：
+如果作为参数的函数对象有多个参数，可使用下面的方式，向`map()`传递函数参数的多个参数：
 ```python
 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):
@@ -85,19 +85,19 @@ 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])
 ```
-reduce的第一个参数是lambda函数，它接收两个参数x,y, 返回x+y。
+`reduce`的第一个参数是`lambda`函数，它接收两个参数`x`,`y`, 返回`x + y`。
 
-reduce将表中的前两个元素(1和2)传递给lambda函数，得到3。该返回值(3)将作为lambda函数的第一个参数，而表中的下一个元素(5)作为lambda函数的第二个参数，进行下一次的对lambda函数的调用，得到8。依次调用lambda函数，每次lambda函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。
+`reduce`将表中的前两个元素(`1`和`2`)传递给`lambda`函数，得到`3`。该返回值(`3`)将作为`lambda`函数的第一个参数，而表中的下一个元素(`5`)作为`lambda`函数的第二个参数，进行下一次的对`lambda`函数的调用，得到`8`。依次调用`lambda`函数，每次`lambda`函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。
 
-上面例子，相当于(((1+2)+5)+7)+9
+上面例子，相当于`(((1 + 2) + 5) + 7) + 9`
 
  
 
-根据mmufhy的提醒： reduce()函数在3.0里面不能直接用的，它被定义在了functools包里面，需要引入包，见评论区。
+根据mmufhy的提醒： `reduce()`函数在3.0里面不能直接用的，它被定义在了`functools`包里面，需要引入包，见评论区。
 
  
 
@@ -105,10 +105,10 @@ reduce将表中的前两个元素(1和2)传递给lambda函数，得到3。该返
 
 函数是一个对象
 
-用lambda定义函数
+用`lambda`定义函数
 
-map()
+`map()`
 
-filter()
+`filter()`
 
-reduce()
+`reduce()`
diff --git a/content/intermediate08.md b/content/intermediate08.md
index 8c449de..a1fecfc 100644
--- a/content/intermediate08.md
+++ b/content/intermediate08.md
@@ -7,7 +7,7 @@
 
 在项目开发中，异常处理是不可或缺的。异常处理帮助人们debug，通过更加丰富的信息，让人们更容易找到bug的所在。异常处理还可以提高程序的容错性。
 
-我们之前在讲循环对象的时候，曾提到一个StopIteration的异常，该异常是在循环对象穷尽所有元素时的报错。
+我们之前在讲循环对象的时候，曾提到一个`StopIteration`的异常，该异常是在循环对象穷尽所有元素时的报错。
 
 我们以它为例，来说明基本的异常处理。
 
@@ -20,9 +20,9 @@ for i in range(100):
 
 print 'HaHaHaHa'
 ```
-首先，我们定义了一个循环对象re，该循环对象将进行5次循环，每次使用序列的一个元素。
+首先，我们定义了一个循环对象`re`，该循环对象将进行`5`次循环，每次使用序列的一个元素。
 
-在随后的for循环中，我们手工调用next()函数。当循环进行到第6次的时候，re.next()不会再返回元素，而是抛出(raise)StopIteration的异常。整个程序将会中断。
+在随后的`for`循环中，我们手工调用`next()`函数。当循环进行到第`6`次的时候，`re.next()`不会再返回元素，而是抛出(`raise`)`StopIteration`的异常。整个程序将会中断。
 
  
 
@@ -38,7 +38,7 @@ except StopIteration:
 
 print 'HaHaHaHa'
 ```
-在try程序段中，我们放入容易犯错的部分。我们可以跟上except，来说明如果在try部分的语句发生StopIteration时，程序该做的事情。如果没有发生异常，则except部分被跳过。
+在`try`程序段中，我们放入容易犯错的部分。我们可以跟上`except`，来说明如果在`try`部分的语句发生`StopIteration`时，程序该做的事情。如果没有发生异常，则`except`部分被跳过。
 
 随后，程序将继续运行，而不是彻底中断。
 
@@ -62,7 +62,7 @@ finally:
 ```
  
 
-如果try中有异常发生时，将执行异常的归属，执行except。异常层层比较，看是否是exception1, exception2...，直到找到其归属，执行相应的except中的语句。如果except后面没有任何参数，那么表示所有的exception都交给这段程序处理。比如:
+如果`try`中有异常发生时，将执行异常的归属，执行`except`。异常层层比较，看是否是`exception1`, `exception2`...，直到找到其归属，执行相应的`except`中的语句。如果`except`后面没有任何参数，那么表示所有的`exception`都交给这段程序处理。比如:
 ```python
 try:
     print(a*2)
@@ -71,7 +71,7 @@ except TypeError:
 except:
     print("Not Type Error & Error noted")
 ```
-由于a没有定义，所以是NameError。异常最终被except:部分的程序捕捉。
+由于`a`没有定义，所以是`NameError`。异常最终被`except:`部分的程序捕捉。
 
  
 
@@ -89,19 +89,19 @@ 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`->异常->`except`->`finally`
 
-try->无异常->else->finally
+`try`->无异常->`else`->`finally`
 
  
 
@@ -113,9 +113,9 @@ print 'Lalala'
 raise StopIteration
 print 'Hahaha'
 ```
-这个例子不具备任何实际意义。只是为了说明raise语句的作用。
+这个例子不具备任何实际意义。只是为了说明`raise`语句的作用。
 
-StopIteration是一个类。抛出异常时，会自动有一个中间环节，就是生成StopIteration的一个对象。Python实际上抛出的，是这个对象。当然，也可以自行声场对象:
+`StopIteration`是一个类。抛出异常时，会自动有一个中间环节，就是生成`StopIteration`的一个对象。Python实际上抛出的，是这个对象。当然，也可以自行生成对象:
 ```python
 raise StopIteration()
 ``` 
diff --git a/content/intermediate09.md b/content/intermediate09.md
index 32c0fa3..ce4aa1d 100644
--- a/content/intermediate09.md
+++ b/content/intermediate09.md
@@ -22,7 +22,7 @@ a = 'at'
 ```
 第一个语句中，3是储存在内存中的一个整数对象。通过赋值，引用a指向对象3。
 
-第二个语句中，内存中建立对象‘at’，是一个字符串(string)。引用a指向了'at'。此时，对象3不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct)，释放相应内存。
+第二个语句中，内存中建立对象`'at'`，是一个字符串(string)。引用`a`指向了`'at'`。此时，对象`3`不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct)，释放相应内存。
 
 (对于小的整数和短字符串，Python会缓存这些对象，而不是频繁的建立和销毁。)
 
@@ -32,7 +32,7 @@ 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`分别指向不同的对象。我们看到，即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。
 
  
 
@@ -50,9 +50,9 @@ L2 = L1
 L1[0] = 10
 print L2
 ```
-在该情况下，我们不再对L1这一引用赋值，而是对L1所指向的表的元素赋值。结果是，L2也同时发生变化。
+在该情况下，我们不再对`L1`这一引用赋值，而是对`L1`所指向的表的元素赋值。结果是，`L2`也同时发生变化。
 
-原因何在呢？因为L1，L2的指向没有发生变化，依然指向那个表。表实际上是包含了多个引用的对象（每个引用是一个元素，比如L1[0]，L1[1]..., 每个引用指向一个对象，比如1,2,3), 。而L1[0] = 10这一赋值操作，并不是改变L1的指向，而是对L1[0], 也就是表对象的一部份(一个元素)，进行操作，所以所有指向该对象的引用都受到影响。
+原因何在呢？因为`L1`，`L2`的指向没有发生变化，依然指向那个表。表实际上是包含了多个引用的对象（每个引用是一个元素，比如`L1[0]`，`L1[1]`..., 每个引用指向一个对象，比如`1`,`2`,`3`), 。而`L1[0] = 10`这一赋值操作，并不是改变`L1`的指向，而是对`L1[0]`, 也就是表对象的一部份(一个元素)，进行操作，所以所有指向该对象的引用都受到影响。
 
 （与之形成对比的是，我们之前的赋值操作都没有对对象自身发生作用，只是改变引用指向。）
 
@@ -62,7 +62,7 @@ print L2
 
 而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。
 
-我们之前学的元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object.
+我们之前学的元组(`tuple`)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是immutable object.
 
  
 
@@ -80,7 +80,7 @@ f(a)
 print a
 ```
 
-参数x是一个新的引用，指向a所指的对象。如果参数是不可变(immutable)的对象，a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。
+参数x是一个新的引用，指向a所指的对象。如果参数是不可变(immutable)的对象，`a`和`x`引用之间相互独立。对参数`x`的操作不会影响引用`a`。这样的传递类似于C语言中的值传递。
 
  
 

From db41da5efd73fc2ac90ee4314888d45093e48829 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Wed, 18 Jun 2014 21:37:22 +0800
Subject: [PATCH 02/13] =?UTF-8?q?=E6=96=87=E7=AB=A0=E5=86=85=E5=AE=B9?=
 =?UTF-8?q?=E4=B8=BB=E8=A6=81=E4=B8=BA=E9=85=8D=E7=BD=AE=EF=BC=8C=E6=95=85?=
 =?UTF-8?q?=E4=B8=BB=E8=A6=81=E4=B8=BA=E5=87=BA=E7=8E=B0=E7=9A=84=E5=91=BD?=
 =?UTF-8?q?=E4=BB=A4=E3=80=81=E8=B7=AF=E5=BE=84=E3=80=81=E6=96=87=E4=BB=B6?=
 =?UTF-8?q?=E5=90=8D=E7=AD=89=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81=EF=BC=88?=
 =?UTF-8?q?code=EF=BC=89=E6=A0=BC=E5=BC=8F=E3=80=82=E5=A6=82=EF=BC=9A`apt-?=
 =?UTF-8?q?get`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...54\344\270\215\345\201\234\350\271\204.md" | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

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..68c2940 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"	
@@ -3,9 +3,9 @@
 
  
 
-前面的文章研究了Django最主要的几个方面：数据库，模板，动态生成页面等。但都是使用python manage.py runserver来运行服务器。这是一个实验性的web服务器，不适用于正常的站点运行。我们需要一个可以稳定而持续的服务器。这个服务器负责监听http端口，将收到的请求交给Django处理，将Django的回复发还给客户端。
+前面的文章研究了Django最主要的几个方面：数据库，模板，动态生成页面等。但都是使用`python manage.py runserver`来运行服务器。这是一个实验性的web服务器，不适用于正常的站点运行。我们需要一个可以稳定而持续的服务器。这个服务器负责监听http端口，将收到的请求交给Django处理，将Django的回复发还给客户端。
 
-这样的持续性服务器可以有很多选择，比如apache, Nginx, lighttpd等。这里将使用最常见的apache服务器。服务器和Django之间通过Python的web服务接口WSGI连接，因此我们同样需要apache下的mod_wsgi模块。
+这样的持续性服务器可以有很多选择，比如apache, Nginx, lighttpd等。这里将使用最常见的apache服务器。服务器和Django之间通过Python的web服务接口WSGI连接，因此我们同样需要apache下的`mod_wsgi`模块。
 
 下面的配置和说明，是在Ubuntu 13.10下进行的。在其它系统下将有所差别。
 
@@ -19,15 +19,15 @@
 
 ##安装
 
-首先需要安装apache2和mod_wsgi。在ubuntu下，我们可以使用apt-get安装：
+首先需要安装apache2和`mod_wsgi`。在ubuntu下，我们可以使用`apt-get`安装：
 
 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
 # Django
@@ -41,9 +41,9 @@ WSGIPythonPath /home/vamei/mysite
 </Files>
 </Directory>
 ```
-上面的配置中/home/ubuntu/mysite是Django项目所在的位置。而/home/ubuntu/mysite/mysite/wsgi.py是Django项目中z自动创建的文件。
+上面的配置中`/home/ubuntu/mysite`是Django项目所在的位置。而`/home/ubuntu/mysite/mysite/wsgi.py`是Django项目中自动创建的文件。
 
-可以看到，利用WSGIScriptAlias，我们实际上将URL /对应了wsgi接口程序。这样，当我们访问根URL时，访问请求会经由WSGI接口，传递给Django项目mysite。
+可以看到，利用`WSGIScriptAlias`，我们实际上将URL /对应了`wsgi`接口程序。这样，当我们访问根URL时，访问请求会经由WSGI接口，传递给Django项目`mysite`。
 
  
 
@@ -64,11 +64,11 @@ sudo /etc/init.d/apache2 restart
 
 ##静态文件
 
-Django的主要功能是动态的生成HTTP回复。很多媒体文件是静态存储的，如.js文件，.css文件和图片文件。这些文件变动的频率较小。我们希望静态的提供这些文件，而不是动态的生成。这样既可以减小服务器的负担，也便于在浏览器缓存，提高用户体验。
+Django的主要功能是动态的生成HTTP回复。很多媒体文件是静态存储的，如`.js`文件，`.css`文件和图片文件。这些文件变动的频率较小。我们希望静态的提供这些文件，而不是动态的生成。这样既可以减小服务器的负担，也便于在浏览器缓存，提高用户体验。
 
  
 
-我们可以在apache2.conf中添加如下配置：
+我们可以在`apache2.conf`中添加如下配置：
 
 ```python
 Alias /media/ /home/vamei/media/
@@ -95,11 +95,11 @@ WSGIPythonPath /home/vamei/mysite
 </Files>
 </Directory>
 ```
-这样，/static/和/media/这两个URL的访问将引导向存有静态文件的/home/vamei/static/和/home/vamei/media/，apache将直接向客户提供这两个文件夹中的静态文件。而剩下的URL访问，将导向WSGI接口，由Django动态处理。
+这样，`/static/`和`/media/`这两个URL的访问将引导向存有静态文件的`/home/vamei/static/和/home/vamei/media/`，apache将直接向客户提供这两个文件夹中的静态文件。而剩下的URL访问，将导向WSGI接口，由Django动态处理。
 
  
 
-在/home/vamei/static/中放入文件revenge.jpg，访问http://localhost/static/revenge：
+在`/home/vamei/static/`中放入文件`revenge.jpg`，访问`http://localhost/static/revenge`：
 
 
 
@@ -113,7 +113,7 @@ WSGIPythonPath /home/vamei/mysite
 
 云平台或者服务器的部署是一个大的课题，这里无法深入到所有的细节。幸运的是，在网上有丰富的资料。你可以根据自己的平台和问题，搜索相应的资料。
 
-在Django的debug模式下，我们可以在app文件夹中建立static目录，放入静态文件。Django将自动搜索到其中的静态文件。但这一方法有很大的安全隐患，只适用于开发。
+在Django的debug模式下，我们可以在`app`文件夹中建立`static`目录，放入静态文件。Django将自动搜索到其中的静态文件。但这一方法有很大的安全隐患，只适用于开发。
 
  
 
@@ -123,7 +123,7 @@ WSGIPythonPath /home/vamei/mysite
 
 ##总结
 
-apache + mod_wsgi
+`apache` + `mod_wsgi`
 
 静态文件
 

From fe5fe370308ad3d8fc9d150d76865415b57d0d91 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Wed, 18 Jun 2014 22:58:51 +0800
Subject: [PATCH 03/13] =?UTF-8?q?=E4=B8=BA=E6=96=87=E4=B8=AD=E5=87=BA?=
 =?UTF-8?q?=E7=8E=B0=E7=9A=84=E4=BB=A3=E7=A0=81=E3=80=81=E5=8F=98=E9=87=8F?=
 =?UTF-8?q?=E5=8F=8A=E8=B7=AF=E5=BE=84=E3=80=81=E6=96=87=E4=BB=B6=E5=90=8D?=
 =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81=EF=BC=88code=EF=BC=89?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E3=80=82=E5=A6=82=EF=BC=9A`print()`=20`http:?=
 =?UTF-8?q?//127.0.0.1`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...35\350\257\225\345\244\251\346\266\257.md" | 46 +++++++-------
 ...04\345\233\255\347\226\221\344\272\221.md" | 22 +++----
 ...00\350\260\223\344\274\212\344\272\272.md" | 52 ++++++++--------
 ...04\345\217\226\346\211\200\351\234\200.md" | 60 +++++++++----------
 ...21\351\235\242\347\256\241\345\256\266.md" | 42 ++++++-------
 ...07\344\275\234\347\234\237\346\227\266.md" | 54 ++++++++---------
 6 files changed, 138 insertions(+), 138 deletions(-)

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..06972d2 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"	
@@ -29,11 +29,11 @@ import django
 print(django.VERSION)
 ```
 
-如果Django还没有安装，可以在命令行，尝试使用pip安装:
+如果Django还没有安装，可以在命令行，尝试使用`pip`安装:
 ```python
 sudo pip install django
 ```
-或者使用easy_install:
+或者使用`easy_install`:
 ```python
 sudo easy_install django
 ``` 
@@ -49,7 +49,7 @@ sudo easy_install django
 django-admin.py startproject mysite
 ``` 
 
-在当前目录下，将生成mysite文件夹。其文件树结构如下:
+在当前目录下，将生成`mysite`文件夹。其文件树结构如下:
 
 ```python
 mysite
@@ -64,15 +64,15 @@ mysite
 ```
  
 
-进入mysite，启动服务器：
+进入`mysite`，启动服务器：
 ```python
 python manage.py runserver 8000
 ```
-上面的8000为端口号。如果不说明，那么端口号默认为8000。
+上面的`8000`为端口号。如果不说明，那么端口号默认为`8000`。
 
  
 
-打开浏览器，访问http://127.0.0.1:8000，可以看到服务器已经在运行：
+打开浏览器，访问`http://127.0.0.1:8000`，可以看到服务器已经在运行：
 
 
 
@@ -90,7 +90,7 @@ python manage.py runserver 8000
 
  
 
-我们需要一个指挥员，将URL对应分配给某个对象处理，这需要在mysite/mysite下的urls.py设定。Python会根据该程序，将URL请求分给某个厨师。
+我们需要一个指挥员，将URL对应分配给某个对象处理，这需要在`mysite/mysite`下的`urls.py`设定。Python会根据该程序，将URL请求分给某个厨师。
 
 复制代码
 ```python
@@ -122,9 +122,9 @@ urlpatterns = patterns('',
     url(r'^$', 'mysite.views.first_page'),
 )
 ```
-我们添加了最后一行。它将根目录的URL分配给一个对象进行处理，这个对象是mysite.views.first_page。
+我们添加了最后一行。它将根目录的URL分配给一个对象进行处理，这个对象是`mysite.views.first_page`。
 
-用以处理HTTP请求的这一对象还不存在，我们在mysite/mysite下创建views.py，并在其中定义first_page函数:
+用以处理HTTP请求的这一对象还不存在，我们在`mysite/mysite`下创建`views.py`，并在其中定义`first_page`函数:
 ```python
 # -*- coding: utf-8 -*-
 
@@ -133,7 +133,7 @@ from django.http import HttpResponse
 def first_page(request):
     return HttpResponse("<p>世界好</p>")
 ```    
-第一行说明字符编码为utf-8，为下面使用中文做准备。first_page函数的功能，是返回http回复，即这里的<p>世界好</p>。first_page有一个参数request，该参数包含有请求的具体信息，比如请求的类型等，这里并没有用到。
+第一行说明字符编码为`utf-8`，为下面使用中文做准备。`first_page`函数的功能，是返回http回复，即这里的`<p>世界好</p>`。`first_page`有一个参数`request`，该参数包含有请求的具体信息，比如请求的类型等，这里并没有用到。
 
  
 
@@ -144,14 +144,14 @@ def first_page(request):
 
 ##增加app
 
-一个网站可能有多个功能。我们可以在Django下，以app为单位，模块化的管理，而不是将所有的东西都丢到一个文件夹中。在mysite下，运行manange.py，创建新的app：
+一个网站可能有多个功能。我们可以在Django下，以app为单位，模块化的管理，而不是将所有的东西都丢到一个文件夹中。在`mysite`下，运行`manange.py`，创建新的app：
 
 $python manage.py startapp west
-这个新的app叫做west，用来处理西餐。
+这个新的app叫做`west`，用来处理西餐。
 
  
 
-我们的根目录下，出现了一个新的叫做west的文件夹。
+我们的根目录下，出现了一个新的叫做`west`的文件夹。
 
 ```python
 mysite/
@@ -172,7 +172,7 @@ mysite/
     └── views.py
 ``` 
 
-我们还需要修改项目设置，说明我们要使用west。在mysite/setting.py中，在INSTALLED_APPS中，增加"west"：
+我们还需要修改项目设置，说明我们要使用`west`。在`mysite/setting.py`中，在`INSTALLED_APPS`中，增加`west`：
 
 ```python
 INSTALLED_APPS = (
@@ -185,7 +185,7 @@ INSTALLED_APPS = (
     'west',
 )
 ```
-可以看到，除了新增加的west，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。
+可以看到，除了新增加的`west`，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。
 
  
 
@@ -195,13 +195,13 @@ INSTALLED_APPS = (
 
 ##增加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 +219,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 +231,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,7 +244,7 @@ from django.http import HttpResponse
 def first_page(request):
     return HttpResponse("<p>西餐</p>")
 ```
-访问http://127.0.0.1:8000/west，查看效果。
+访问`http://127.0.0.1:8000/west`，查看效果。
 
  
 
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..64b1ebb 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"	
@@ -31,7 +31,7 @@ $mysql -u root -p
 在MySQL中创立Django项目的数据库：
 
 mysql> CREATE DATABASE villa DEFAULT CHARSET=utf8;
-这里使用utf8作为默认字符集，以便支持中文。
+这里使用`utf8`作为默认字符集，以便支持中文。
 
  
 
@@ -40,7 +40,7 @@ mysql> CREATE DATABASE villa DEFAULT CHARSET=utf8;
 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,7 +54,7 @@ DATABASES = {
     }
 }
 ```
-后台类型为mysql。上面包含数据库名称和用户的信息，它们与MySQL中对应数据库和用户的设置相同。Django根据这一设置，与MySQL中相应的数据库和用户连接起来。此后，Django就可以在数据库中读写了。
+后台类型为`mysql`。上面包含数据库名称和用户的信息，它们与MySQL中对应数据库和用户的设置相同。Django根据这一设置，与MySQL中相应的数据库和用户连接起来。此后，Django就可以在数据库中读写了。
 
  
 
@@ -68,7 +68,7 @@ MySQL是关系型数据库。但在Django的帮助下，我们不用直接编写
 
  
 
-在传统的MySQL中，数据模型是表。在Django下，一个表为一个类。表的每一列是该类的一个属性。在models.py中，我们创建一个只有一列的表，即只有一个属性的类：
+在传统的MySQL中，数据模型是表。在Django下，一个表为一个类。表的每一列是该类的一个属性。在`models.py`中，我们创建一个只有一列的表，即只有一个属性的类：
 ```python
 from django.db import models
 
@@ -77,13 +77,13 @@ class Character(models.Model):
     def __unicode__(self):
         return self.name
 ```
-类Character定义了数据模型，它需要继承自models.Model。在MySQL中，这个类实际上是一个表。表只有一列，为name。可以看到，name属性是字符类型，最大长度为200。
+类`Character`定义了数据模型，它需要继承自`models.Model`。在MySQL中，这个类实际上是一个表。表只有一列，为`name`。可以看到，`name`属性是字符类型，最大长度为`200`。
 
-类Character有一个__unicode__()方法，用来说明对象的字符表达方式。如果是Python 3，定义__str__()方法，实现相同的功能。
+类`Character`有一个`__unicode__()`方法，用来说明对象的字符表达方式。如果是Python 3，定义`__str__()`方法，实现相同的功能。
 
  
 
-命令Django同步数据库。Django根据models.py中描述的数据模型，在MySQL中真正的创建各个关系表：
+命令Django同步数据库。Django根据`models.py`中描述的数据模型，在MySQL中真正的创建各个关系表：
 ```python
 $python manage.py syncdb
 ``` 
@@ -130,7 +130,7 @@ USE villa;
 SHOW TABLES;
 SHOW COLUMNS FROM west_character;
 ```
-最后一个命令返回Character类的对应表格:
+最后一个命令返回`Character`类的对应表格:
 
 +-------+--------------+------+-----+---------+----------------+
 | Field | Type         | Null | Key | Default | Extra          |
@@ -163,7 +163,7 @@ INSERT INTO west_character (name) Values ('John');
 
  
 
-下面我们从数据库中取出数据，并返回给http请求。在west/views.py中，添加视图。对于对应的请求，我们将从数据库中读取所有的记录，然后返回给客户端：
+下面我们从数据库中取出数据，并返回给http请求。在`west/views.py`中，添加视图。对于对应的请求，我们将从数据库中读取所有的记录，然后返回给客户端：
 
 ```python
 # -*- coding: utf-8 -*-
@@ -177,11 +177,11 @@ def staff(request):
     staff_str  = map(str, staff_list)
     return HttpResponse("<p>" + ' '.join(staff_str) + "</p>")
 ```
-可以看到，我们从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
 
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..a7f5ce9 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"	
@@ -3,7 +3,7 @@
 
  
 
-在之前的程序中，我们直接生成一个字符串，作为http回复，返回给客户端。这一过程中使用了django.http.HttpResponse()。
+在之前的程序中，我们直接生成一个字符串，作为http回复，返回给客户端。这一过程中使用了`django.http.HttpResponse()`。
 
 在这样的一种回复生成过程中，我们实际上将数据和视图的格式混合了到上面的字符串中。看似方便，却为我们的管理带来困难。想像一个成熟的网站，其显示格式会有许多重复的地方。如果可以把数据和视图格式分离，就可以重复使用同一视图格式了。
 
@@ -17,7 +17,7 @@ Django中自带的模板系统，可以将视图格式分离出来，作为模
 
 ##模板初体验
 
-我们拿一个独立的templay.html文件作为模板。它放在templates/west/文件夹下。文件系统的结构现在是:
+我们拿一个独立的`templay.html`文件作为模板。它放在`templates/west/`文件夹下。文件系统的结构现在是:
 
 mysite/
 ├── mysite
@@ -26,14 +26,14 @@ mysite/
 └── west
  
 
-templay.html文件的内容是：
+`templay.html`文件的内容是：
 
 <h1>{{ label }}</h1>
-可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即<h1>标签，则已经标明在该模板文件中。
+可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即`<h1>`标签，则已经标明在该模板文件中。
 
  
 
-我们需要向Django说明模板文件的搜索路径，修改mysite/settings.py，添加:
+我们需要向Django说明模板文件的搜索路径，修改`mysite/settings.py`，添加:
 
 # Template dir
 TEMPLATE_DIRS = (
@@ -44,7 +44,7 @@ TEMPLATE_DIRS = (
 
  
 
-我们现在修改west/views.py，增加一个新的对象，用于向模板提交数据：
+我们现在修改`west/views.py`，增加一个新的对象，用于向模板提交数据：
 
 ```python
 # -*- coding: utf-8 -*-
@@ -57,17 +57,17 @@ def templay(request):
     context['label'] = 'Hello World!'
     return render(request, 'templay.html', context)
 ```
-可以看到，我们这里使用render来替代之前使用的HttpResponse。render还使用了一个词典context作为参数。这就是我们的数据。
+可以看到，我们这里使用`render`来替代之前使用的`HttpResponse`。`render`还使用了一个词典`context`作为参数。这就是我们的数据。
 
-context中元素的键值为'label'，正对应刚才的“陌生人”的名字。这样，该context中的‘label’元素值，就会填上模板里的坑，构成一个完整的http回复。
+`context`中元素的键值为`'label'`，正对应刚才的“陌生人”的名字。这样，该`context`中的`'label'`元素值，就会填上模板里的坑，构成一个完整的http回复。
 
  
 
-作为上节内容的一个小练习，自行修改west/urls.py，让http://127.0.0.1:8000/west/templay的URL请求可以找到相应的view对象。
+作为上节内容的一个小练习，自行修改`west/urls.py`，让`http://127.0.0.1:8000/west/templay`的URL请求可以找到相应的view对象。
 
  
 
-访问http://127.0.0.1:8000/west/templay，可以看到页面：
+访问`http://127.0.0.1:8000/west/templay`，可以看到页面：
 
  
 
@@ -77,13 +77,13 @@ context中元素的键值为'label'，正对应刚才的“陌生人”的名字
 
 ##流程
 
-再来回顾一下整个流程。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,7 +91,7 @@ def staff(request):
     context   = {'label': ' '.join(staff_str)}
     return render(request, 'templay.html', context)
 ```
-练习: 显示上面的staff页面。
+练习: 显示上面的`staff`页面。
 
  
 
@@ -107,28 +107,28 @@ 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传送给模板。
+从数据库中查询到的三个对象都在`staff_list`中。我们直接将`staff_list`传送给模板。
 
-将模板templay.html修改为：
+将模板`templay.html`修改为：
 
 {% for item in staffs %}
 <p>{{ item.id }}, {{item}}</p>
 {% endfor %}
-我们以类似于Python中for循环的方式来定义模板中的for，以显示staffs中的每个元素。
+我们以类似于Python中`for`循环的方式来定义模板中的`for`，以显示`staffs`中的每个元素。
 
 还可以看到，对象.属性名的引用方式可以直接用于模板中。
 
  
 
-选择结构也与Python类似。根据传送来的数据是否为True，Django选择是否显示。使用方式如下：
+选择结构也与Python类似。根据传送来的数据是否为`True`，Django选择是否显示。使用方式如下：
 
 ```python
 {% if condition1 %}
@@ -139,7 +139,7 @@ def staff(request):
    ... display 3
 {% endif %}
 ```
-其中的elif和else和Python中一样，是可以省略的。
+其中的`elif`和`else`和Python中一样，是可以省略的。
 
  
 
@@ -149,9 +149,9 @@ def staff(request):
 
 模板继承
 
-模板可以用继承的方式来实现复用。我们下面用templay.html来继承base.html。这样，我们可以使用base.html的主体，只替换掉特定的部分。
+模板可以用继承的方式来实现复用。我们下面用`templay.html`来继承`base.html`。这样，我们可以使用`base.html`的主体，只替换掉特定的部分。
 
-新建templates/west/base.html:
+新建`templates/west/base.html`:
 
 ```python
 <html>
@@ -167,11 +167,11 @@ def staff(request):
   </body>
 </html>
 ```
-该页面中，名为mainbody的block标签是可以被继承者们替换掉的部分。
+该页面中，名为`mainbody`的`block`标签是可以被继承者们替换掉的部分。
 
  
 
-我们在下面的templay.html中继承base.html，并替换特定block：
+我们在下面的`templay.html`中继承`base.html`，并替换特定`block`：
 
 ```python
 {% extends "base.html" %}
@@ -184,7 +184,7 @@ def staff(request):
 
 {% endblock %}
 ```
-第一句说明templay.html继承自base.html。可以看到，这里相同名字的block标签用以替换base.html的相应block。
+第一句说明`templay.html`继承自`base.html`。可以看到，这里相同名字的`block`标签用以替换`base.html`的相应`block`。
 
  
 
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..9e2dcf5 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"	
@@ -29,24 +29,24 @@ HTML文件中可以包含表格标签。HTML表格的目的是帮助用户构成
   <input type="submit" value="Submit">
 </form>
 ```
-这里的form标签有两个属性。action用于说明URL地址，method说明请求的方法。
+这里的`form`标签有两个属性。`action`用于说明URL地址，`method`说明请求的方法。
 
-表格中还包含有两个input标签，即两个输入栏目。根据type的不同，第一个为一个文本框，第二个为一个提交按钮。name为输入栏的名字。服务器在解析数据时，将以name为索引。
+表格中还包含有两个`input`标签，即两个输入栏目。根据`type`的不同，第一个为一个文本框，第二个为一个提交按钮。`name`为输入栏的名字。服务器在解析数据时，将以`name`为索引。
 
  
 
-我们可以将上面的表格直接存入模板form.html，并在west/views.py中定义一个视图form()来显示表格:
+我们可以将上面的表格直接存入模板`form.html`，并在`[site]/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
 
@@ -54,19 +54,19 @@ def investigate(request):
     rlt = request.GET['staff']
     return HttpResponse(rlt)
 ```
-可以看到，HTTP请求的相关信息，包括请求的方法，提交的数据，都包含在request参数中。
+可以看到，HTTP请求的相关信息，包括请求的方法，提交的数据，都包含在`request`参数中。
 
-表格是通过GET方法提交的。我们可以通过request.GET['staff']，来获得name为staff的输入栏的数据。该数据是一个字符串。investigate()将直接显示该字符串。
+表格是通过`GET`方法提交的。我们可以通过`request.GET['staff']`，来获得`name`为`staff`的输入栏的数据。该数据是一个字符串。`investigate()`将直接显示该字符串。
 
-设置urls.py，让该处理函数对应action的URL([site]/west/investigate/)。
+设置`urls.py`，让该处理函数对应`action`的URL(`[site]/west/investigate/`)。
 
  
 
-当我们访问http://127.0.0.1:8000/west/form时，将显示:
+当我们访问`http://127.0.0.1:8000/west/form`时，将显示:
 
 
 
-提交表格后，页面将转到[site]/west/investigate。investigate()读取字符串后，在页面上显示出来。
+提交表格后，页面将转到`[site]/west/investigate`。`investigate()`读取字符串后，在页面上显示出来。
 
  
 
@@ -76,13 +76,13 @@ def investigate(request):
 
 ##POST方法
 
-上面我们使用了GET方法。视图显示和请求处理分成两个函数处理。
+上面我们使用了`GET`方法。视图显示和请求处理分成两个函数处理。
 
-提交数据时更常用POST方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
+提交数据时更常用`POST`方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
 
  
 
-先创建模板investigate.html
+先创建模板`investigate.html`
 
 ```python
 <form action="/west/investigate/" method="post">
@@ -93,13 +93,13 @@ def investigate(request):
 
 <p>{{ rlt }}</p>
 ```
-我们修改提交表格的方法为post。在模板的末尾，我们增加一个rlt记号，为表格处理结果预留位置。
+我们修改提交表格的方法为`post`。在模板的末尾，我们增加一个`rlt`记号，为表格处理结果预留位置。
 
-表格后面还有一个{% csrf_token %}的标签。csrf全称是Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。POST方法提交的表格，必须有此标签。
+表格后面还有一个`{% csrf_token %}`的标签。`csrf`全称是Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。`POST`方法提交的表格，必须有此标签。
 
  
 
-在west/views.py中，用investigate()来处理表格：
+在`west/views.py`中，用`investigate()`来处理表格：
 
 ```python
 from django.shortcuts import render
@@ -112,9 +112,9 @@ def investigate(request):
         ctx['rlt'] = request.POST['staff']
     return render(request, "investigate.html", ctx)
 ```
-这里的csrf()是和上面的{% csrf_token %}对应。我们在这里不深究。
+这里的`csrf()`是和上面的`{% csrf_token %}`对应。我们在这里不深究。
 
-看程序的其它部分。对于该URL，可能有GET或者POST方法。if的语句有POST方法时，额外的处理，即提取表格中的数据到环境变量。
+看程序的其它部分。对于该URL，可能有`GET`或者`POST`方法。`if`的语句有`POST`方法时，额外的处理，即提取表格中的数据到环境变量。
 
  
 
@@ -128,11 +128,11 @@ def investigate(request):
 
 ##存储数据
 
-我们还可以让客户提交的数据存入数据库。使用庄园疑云中创建的模型。我们将客户提交的字符串存入模型Character。
+我们还可以让客户提交的数据存入数据库。使用庄园疑云中创建的模型。我们将客户提交的字符串存入模型`Character`。
 
  
 
-修改west/views.py的investigate():
+修改`west/views.py`的`investigate()`:
 
 ```python
 from django.shortcuts import render
@@ -151,13 +151,13 @@ 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
 <form action="/west/investigate/" method="post">
@@ -170,7 +170,7 @@ def investigate(request):
 <p>{{ person }}</p>
 {% endfor %}
 ```
-我们使用模板语言的for，来显示所有的记录。
+我们使用模板语言的`for`，来显示所有的记录。
 
  
 
@@ -190,7 +190,7 @@ Django提供的数据对象可以大大简化这一过程。该对象用于说
 
  
 
-修改west/views.py：
+修改`west/views.py`：
 
 ```python
 from django.shortcuts import render
@@ -219,15 +219,15 @@ def investigate(request):
     ctx['form']  = form
     return render(request, "investigate.html", ctx)
 ```
-上面定义了CharacterForm类，并通过属性name，说明了输入栏name的类型为字符串，最大长度为200。
+上面定义了`CharacterForm`类，并通过属性`name`，说明了输入栏`name`的类型为字符串，最大长度为`200`。
 
-在investigate()函数中，我们根据POST，直接创立form对象。该对象可以直接判断输入是否有效，并对输入进行预处理。空白输入被视为无效。
+在`investigate()`函数中，我们根据`POST`，直接创立`form`对象。该对象可以直接判断输入是否有效，并对输入进行预处理。空白输入被视为无效。
 
-后面，我们再次创建一个空的form对象，并将它交给模板显示。
+后面，我们再次创建一个空的`form`对象，并将它交给模板显示。
 
  
 
-在模板investigate.html中，我们可以直接显示form对象：
+在模板`investigate.html`中，我们可以直接显示`form`对象：
 
 ```python
 <form action="/west/investigate/" method="post">
@@ -240,7 +240,7 @@ def investigate(request):
 <p>{{ person }}</p>
 {% endfor %}
 ```
-如果有多个输入栏，我们可以用相同的方式直接显示整个form，而不是加入许多个<input>标签。
+如果有多个输入栏，我们可以用相同的方式直接显示整个`form`，而不是加入许多个`<input>`标签。
 
  
 
@@ -256,7 +256,7 @@ def investigate(request):
 
 ##总结
 
-GET和POST
+`GET`和`POST`
 
 表格提交
 
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..9bd5ed0 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"	
@@ -3,9 +3,9 @@
 
  
 
-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`看到它。
 
 
 
@@ -15,7 +15,7 @@ Django提供一个管理数据库的app，即django.contrib.admin。这是Django
 
 ##默认界面
 
-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
@@ -31,7 +31,7 @@ urlpatterns = patterns('',
 ```
  
 
-为了让admin界面管理某个数据模型，我们需要先注册该数据模型到admin。比如，我们之前在west中创建的模型Character。修改west/admin.py:
+为了让`admin`界面管理某个数据模型，我们需要先注册该数据模型到`admin`。比如，我们之前在`west`中创建的模型`Character`。修改`west/admin.py`:
 
 from django.contrib import admin
 from west.models import Character
@@ -40,11 +40,11 @@ from west.models import Character
 admin.site.register(Character)
  
 
-访问http://127.0.0.1:8000/admin，登录后，可以看到管理界面：
+访问`http://127.0.0.1:8000/admin`，登录后，可以看到管理界面：
 
 
 
-这个页面除了west.characters外，还有用户和组信息。它们来自Django预装的Auth模块。我们将在以后处理用户管理的问题。
+这个页面除了`west.characters`外，还有用户和组信息。它们来自Django预装的`Auth`模块。我们将在以后处理用户管理的问题。
 
  
 
@@ -58,7 +58,7 @@ admin.site.register(Character)
 
  
 
-先在west/models.py中增加一个更复杂的数据模型：
+先在`west/models.py`中增加一个更复杂的数据模型：
 
 ```python
 from django.db import models
@@ -77,9 +77,9 @@ class Tag(models.Model):
     def __unicode__(self):
         return self.name
 ```
-这里有两个表。Tag以Contact为外部键。一个Contact可以对应多个Tag。
+这里有两个表。`Tag`以`Contact`为外部键。一个`Contact`可以对应多个`Tag`。
 
-我们还可以看到许多在之前没有见过的属性类型，比如IntegerField用于存储整数。
+我们还可以看到许多在之前没有见过的属性类型，比如`IntegerField`用于存储整数。
 
  
 
@@ -88,7 +88,7 @@ class Tag(models.Model):
 $python manage.py syncdb
  
 
-在west/admin.py注册多个模型并显示：
+在`west/admin.py`注册多个模型并显示：
 ```python
 from django.contrib import admin
 from west.models import Character,Contact,Tag
@@ -97,7 +97,7 @@ from west.models import Character,Contact,Tag
 admin.site.register([Character, Contact, Tag])
 ``` 
 
-模型将在管理页面显示。比如Contact的添加条目的页面如下：
+模型将在管理页面显示。比如`Contact`的添加条目的页面如下：
 
 
 
@@ -107,7 +107,7 @@ admin.site.register([Character, Contact, Tag])
 
 ##自定义页面
 
-我们可以自定义管理页面，来取代默认的页面。比如上面的"add"页面。我们想只显示name和email部分。修改west/admin.py:
+我们可以自定义管理页面，来取代默认的页面。比如上面的“add”页面。我们想只显示`name`和`email`部分。修改`west/admin.py`:
 
 ```python
 from django.contrib import admin
@@ -122,7 +122,7 @@ admin.site.register([Character, Tag])
 ```
  
 
-上面定义了一个ContactAdmin类，用以说明管理页面的显示格式。里面的fields属性，用以说明要显示的输入栏。我们没有让"age"显示。由于该类对应的是Contact数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：
+上面定义了一个`ContactAdmin`类，用以说明管理页面的显示格式。里面的`fields`属性，用以说明要显示的输入栏。我们没有让“age”显示。由于该类对应的是`Contact`数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：
 
 
 
@@ -130,7 +130,7 @@ admin.site.register([Character, Tag])
 
  
 
-我们还可以将输入栏分块，给每一块输入栏以自己的显示格式。修改west/admin.py为：
+我们还可以将输入栏分块，给每一块输入栏以自己的显示格式。修改`west/admin.py`为：
 
 ```python
 from django.contrib import admin
@@ -153,11 +153,11 @@ admin.site.register([Character, Tag])
 ```
  
 
-上面的栏目分为了Main和Advance两部分。classes说明它所在的部分的CSS格式。这里让Advance部分收敛起来：
+上面的栏目分为了`Main`和`Advance`两部分。`classes`说明它所在的部分的CSS格式。这里让`Advance`部分收敛起来：
 
 
 
-Advance部分旁边有一个Show按钮，用于展开。
+`Advance`部分旁边有一个“Show”按钮，用于展开。
 
  
 
@@ -167,11 +167,11 @@ 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
@@ -211,13 +211,13 @@ admin.site.register([Character])
 
 ##列表页的显示
 
-在Contact输入数条记录后，Contact的列表页看起来如下:
+在`Contact`输入数条记录后，`Contact`的列表页看起来如下:
 
 
 
  
 
-我们也可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在ContactAdmin中增加list_display属性:
+我们也可以自定义该页面的显示，比如在列表中显示更多的栏目，只需要在`ContactAdmin`中增加`list_display`属性:
 
 ```python
 from django.contrib import admin
@@ -238,7 +238,7 @@ admin.site.register([Character, Tag])
 
  
 
-我们还可以为该列表页增加搜索栏。搜索功能在管理大量记录时非常有用。使用search_fields说明要搜索的属性：
+我们还可以为该列表页增加搜索栏。搜索功能在管理大量记录时非常有用。使用`search_fields`说明要搜索的属性：
 
 ```python
 from django.contrib import admin
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..d256fbc 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"	
@@ -16,7 +16,7 @@ admin管理页面
 
 一个Web应用的用户验证是它的基本组成部分。我们在使用一个应用时，总是从“登录”开始，到“登出”结束。另一方面，用户验证又和网站安全、数据库安全息息相关。HTTP协议是无状态的，但我们可以利用储存在客户端的cookie或者储存在服务器的session来记录用户的访问。 
 
-Django有管理用户的模块，即django.contrib.auth。你可以在mysite/settings.py里看到，这个功能模块已经注册在INSTALLED_APPS中。利用该模块，你可以直接在逻辑层面管理用户，不需要为用户建立模型，也不需要手工去实现会话。
+Django有管理用户的模块，即`django.contrib.auth`。你可以在`mysite/settings.py`里看到，这个功能模块已经注册在`INSTALLED_APPS中`。利用该模块，你可以直接在逻辑层面管理用户，不需要为用户建立模型，也不需要手工去实现会话。
 
 “为了救你的爱人出来，我们要演一场戏。”
 
@@ -24,11 +24,11 @@ Django有管理用户的模块，即django.contrib.auth。你可以在mysite/set
 
 ##创建用户
 
-你可以在admin页面直接看到用户管理的对话框，即Users。从这里，你可以在这里创建、删除和修改用户。点击Add增加用户daddy，密码为daddyiscool。
+你可以在`admin`页面直接看到用户管理的对话框，即`Users`。从这里，你可以在这里创建、删除和修改用户。点击“Add”增加用户`daddy`，密码为`daddyiscool`。
 
-在admin页面下，我们还可以控制不同用户组对数据库的访问权限。我们可以在Groups中增加用户组，设置用户组对数据库的访问权限，并将用户加入到某个用户组中。
+在`admin`页面下，我们还可以控制不同用户组对数据库的访问权限。我们可以在`Groups`中增加用户组，设置用户组对数据库的访问权限，并将用户加入到某个用户组中。
 
-在这一章节中，我们创立一个新的app，即users。下文的模板和views.py，都针对该app。
+在这一章节中，我们创立一个新的app，即`users`。下文的模板和`views.py`，都针对该app。
 
  
 
@@ -53,7 +53,7 @@ Django有管理用户的模块，即django.contrib.auth。你可以在mysite/set
 ```
  
 
-我们在views.py中，定义处理函数user_login()，来登入用户：
+我们在`views.py`中，定义处理函数`user_login()`，来登入用户：
 
 ```python
 # -*- coding: utf-8 -*-
@@ -77,13 +77,13 @@ def user_login(request):
     ctx.update(csrf(request))
     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`。来简化上面的模板和处理函数。
 
  
 
@@ -93,7 +93,7 @@ def user_login(request):
 
 ##登出
 
-有时用户希望能销毁会话。我们可以提供一个登出的URL，即/users/logout。登入用户访问该URL，即可登出。在views.py中，增加该URL的处理函数：
+有时用户希望能销毁会话。我们可以提供一个登出的URL，即`/users/logout`。登入用户访问该URL，即可登出。在`views.py`中，增加该URL的处理函数：
 
 ```python
 # -*- coding: utf-8 -*-
@@ -107,7 +107,7 @@ def user_logout(request):
     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`，就可以登出用户。
 
  
 
@@ -121,7 +121,7 @@ def user_logout(request):
 
  
 
-在Django中，对用户身份的检验，主要是在views.py中进行。views.py是连接模型和视图的中间层。HTTP请求会转给views.py中的对应处理函数处理，并发回回复。在views.py的某个处理函数准备HTTP回复的过程中，我们可以检验用户是否登陆。根据用户是否登陆，我们可以给出不同的回复。最原始的方式，是使用if式的选择结构： 
+在Django中，对用户身份的检验，主要是在`views.py`中进行。`views.py`是连接模型和视图的中间层。HTTP请求会转给`views.py`中的对应处理函数处理，并发回回复。在`views.py`的某个处理函数准备HTTP回复的过程中，我们可以检验用户是否登陆。根据用户是否登陆，我们可以给出不同的回复。最原始的方式，是使用`if`式的选择结构： 
 
 ```python
 # -*- coding: utf-8 -*-
@@ -136,19 +136,19 @@ def diff_response(request):
 ```
  
 
-可以看到，用户的登录信息包含在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`中的一个处理函数。
 
 from django.contrib.auth.decorators import login_required
 from django.http import HttpResponse
@@ -156,11 +156,11 @@ from django.http import HttpResponse
 @login_required
 def user_only(request):
     return HttpResponse("<p>This message is for logged in user only.</p>")
-注意上面的装饰器login_required，它是Django预设的装饰器。user_only()的回复结果只能被登录用户看到，而未登录用户将被引导到其他页面。
+注意上面的装饰器`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
@@ -174,7 +174,7 @@ def specific_user(request):
 ```
  
 
-装饰器带有一个参数，该参数是一个函数对象name_check。当name_check返回真值，即用户名为vamei时，specific_user的结果才能被用户看到。
+装饰器带有一个参数，该参数是一个函数对象`name_check`。当`name_check`返回真值，即用户名为`vamei`时，`specific_user`的结果才能被用户看到。
 
  
 
@@ -191,7 +191,7 @@ def specific_user(request):
 {% else %}
   <p>Sorry, not login, you are not yet my sweetheart. </p>
 {% endif %}
-不需要环境变量中定义，我们就可以直接在模板中引用user。这里，模板中调用了user的一个方法，is_authenticated，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。
+不需要环境变量中定义，我们就可以直接在模板中引用`user`。这里，模板中调用了`user`的一个方法，`is_authenticated`，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。
 
  
 
@@ -205,11 +205,11 @@ def specific_user(request):
 
 ##用户注册
 
-我们上面利用了admin管理页面来增加和删除用户。这是一种简便的方法，但并不能用于一般的用户注册的情境。我们需要提供让用户自主注册的功能。这可以让站外用户提交自己的信息，生成自己的账户，并开始作为登陆用户使用网站。
+我们上面利用了`admin`管理页面来增加和删除用户。这是一种简便的方法，但并不能用于一般的用户注册的情境。我们需要提供让用户自主注册的功能。这可以让站外用户提交自己的信息，生成自己的账户，并开始作为登陆用户使用网站。
 
-用户注册的基本原理非常简单，即建立一个提交用户信息的表格。表格中至少包括用户名和密码。相应的处理函数提取到这些信息后，建立User对象，并存入到数据库中。
+用户注册的基本原理非常简单，即建立一个提交用户信息的表格。表格中至少包括用户名和密码。相应的处理函数提取到这些信息后，建立`User`对象，并存入到数据库中。
 
-我们可以利用Django中的UserCreationForm，比较简洁的生成表格，并在views.py中处理表格：
+我们可以利用Django中的`UserCreationForm`，比较简洁的生成表格，并在`views.py`中处理表格：
 
 ```python
 from django.contrib.auth.forms import UserCreationForm
@@ -230,7 +230,7 @@ def register(request):
 ```
  
 
-相应的模板register.html如下：
+相应的模板`register.html`如下：
 
 <form action="" method="post">
    {% csrf_token %}
@@ -247,7 +247,7 @@ def register(request):
 
 正如我们上面提到的，用户登陆系统的最大功能是区分登入和未登入用户，向他们提供不同的内容和服务。
 
-我们看到了用户验证的基本流程，也看到了如何在views.py和模板中区分用户。
+我们看到了用户验证的基本流程，也看到了如何在`views.py`和模板中区分用户。
 
  
 

From f2c041abf729e058683d89bc081e378d9c409fe7 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Wed, 18 Jun 2014 23:34:05 +0800
Subject: [PATCH 04/13] =?UTF-8?q?=E4=B8=BA=E6=96=87=E4=B8=AD=E5=87=BA?=
 =?UTF-8?q?=E7=8E=B0=E7=9A=84=E4=BB=A3=E7=A0=81=E3=80=81=E5=8F=98=E9=87=8F?=
 =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81=EF=BC=88code=EF=BC=89?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E3=80=82=E5=A6=82=EF=BC=9A`print()`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...on\345\260\217\346\212\200\345\267\247.md" | 38 ++++++------
 ...75\346\225\260\346\270\205\345\215\225.md" | 16 ++---
 ...%\346\223\215\344\275\234\347\254\246).md" | 58 +++++++++----------
 ...5\20506 Python\344\271\213\351\201\223.md" |  4 +-
 4 files changed, 57 insertions(+), 59 deletions(-)

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..bbd4593 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"	
@@ -9,13 +9,13 @@
 
 ##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):
@@ -34,11 +34,11 @@ if __name__ == '__main__':
 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
 
@@ -74,7 +74,7 @@ print(inspect.getargspec(func))
 
 2) 查询对象的属性
 
-除了使用dir()来查询对象的属性之外，我们可以使用下面内置(built-in)函数来确认一个对象是否具有某个属性：
+除了使用`dir()`来查询对象的属性之外，我们可以使用下面内置(built-in)函数来确认一个对象是否具有某个属性：
 
 hasattr(obj, attr_name)   # attr_name是一个字符串
 
@@ -93,9 +93,7 @@ print a.__class__.__name__
 
 3) 查询父类
 
-我们可以用__base__属性来查询某个类的父类：
-
-cls.__base__
+我们可以用`__base__`属性来查询某个类的父类：`cls.__base__`
 
 例如：
 ```python
@@ -104,7 +102,7 @@ print(list.__base__)
 
 ##使用中文(以及其它非ASCII编码)
 
-在Python程序的第一行加入#coding=utf8，例如:
+在Python程序的第一行加入`#coding=utf8`，例如:
 ```python
 #coding=utf8
 print("你好吗？")
@@ -132,9 +130,9 @@ print(int("2A", 16))
 
 ##注释
 
-一行内的注释可以以#开始
+一行内的注释可以以`#`开始
 
-多行的注释可以以'''开始，以'''结束，比如
+多行的注释可以以`'''`开始，以`'''`结束，比如
 
 ```python
 '''
@@ -154,20 +152,20 @@ 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增加搜索路径。
+我们可以在Python运行的时候增加或者删除`sys.path`中的元素。另一方面，我们可以通过在shell中增加`PYTHONPATH`环境变量，来为Python增加搜索路径。
 
-下面我们增加/home/vamei/mylib到搜索路径中：
+下面我们增加`/home/vamei/mylib`到搜索路径中：
 
 $export PYTHONPATH=$PYTHONPATH:/home/vamei/mylib
 
-你可以将正面的这行命令加入到～/.bashrc中。这样，我们就长期的改变了搜索路径。
+你可以将正面的这行命令加入到`~/.bashrc`（不同系统下，此文件可能为`~/.bash_profile`、`~/.profile`等）中。这样，我们就长期的改变了搜索路径。
 
  
 
@@ -187,9 +185,9 @@ Python的标准库随着Python一起安装。当我们需要非标准包时，
 
 这是安装Python附加包的一个好的起点。你可以在Linux repository中查找可能存在的Python包 (比如在Ubuntu Software Center中搜索matplot)。
 
-2) 使用pip。pip是Python自带的包管理程序，它连接Python repository，并查找其中可能存在的包。
+2) 使用`pip`。`pip`是Python自带的包管理程序，它连接Python repository，并查找其中可能存在的包。
 
-比如使用如下方法来安装、卸载或者升级web.py：
+比如使用如下方法来安装、卸载或者升级`web.py`：
 
 $pip install web.py
 
@@ -197,7 +195,7 @@ $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`的安装包的路径:
 
 $pip install --install-option="--prefix=/home/vamei/util/" web.py
 
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..36a2efc 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"	
@@ -10,19 +10,19 @@ print("Hello World!")
 
 在Python教程中，我们已经提到下面一些内置函数:
 
-基本数据类型 type()
+基本数据类型 `type()`
 
-反过头来看看 dir() help() len()
+反过头来看看 `dir()` `help()` `len()`
 
-词典 len()
+词典 `len()`
 
-文本文件的输入输出 open()
+文本文件的输入输出 `open()`
 
-循环设计 range() enumerate() zip()
+循环设计 `range()` `enumerate()` `zip()`
 
-循环对象 iter()
+循环对象 `iter()`
 
-函数对象 map() filter() reduce()
+函数对象 `map()` `filter()` `reduce()`
 
  
 
@@ -72,7 +72,7 @@ unichr(65)                       # 数值65对应的unicode字符
 
 bool(0)                          # 转换为相应的真假值，在Python中，0相当于False
 
-在Python中，下列对象都相当于False： [], (), {}, 0, None, 0.0, ''
+在Python中，下列对象都相当于`False`： `[]`, `()`, `{}`, `0`, `None`, `0.0`, `''`（空字符串）
 
  
 
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..80aec95 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"	
@@ -3,13 +3,13 @@
 
  
 
-在许多编程语言中都包含有格式化字符串的功能，比如C和Fortran语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作%。
+在许多编程语言中都包含有格式化字符串的功能，比如C和Fortran语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作`%`。
 
  
 
 ##模板
 
-格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个tuple将多个值传递给模板，每个值对应一个格式符。
+格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个`tuple`将多个值传递给模板，每个值对应一个格式符。
 
 比如下面的例子：
 ```python
@@ -17,10 +17,10 @@ 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)
@@ -30,7 +30,7 @@ print(a)
 ```python
 print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99}
 ```
-可以看到，我们对两个格式符进行了命名。命名使用()括起来。每个命名对应词典的一个key。
+可以看到，我们对两个格式符进行了命名。命名使用`()`括起来。每个命名对应词典的一个`key`。
 
  
 
@@ -38,51 +38,51 @@ print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99}
 
 格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:
 
-%s    字符串 (采用str()的显示)
+`%s`    字符串 (采用`str()`的显示)
 
-%r    字符串 (采用repr()的显示)
+`%r`    字符串 (采用`repr()`的显示)
 
-%c    单个字符
+`%c`    单个字符
 
-%b    二进制整数
+`%b`    二进制整数
 
-%d    十进制整数
+`%d`    十进制整数
 
-%i    十进制整数
+`%i`    十进制整数
 
-%o    八进制整数
+`%o`    八进制整数
 
-%x    十六进制整数
+`%x`    十六进制整数
 
-%e    指数 (基底写为e)
+`%e`    指数 (基底写为e)
 
-%E    指数 (基底写为E)
+`%E`    指数 (基底写为E)
 
-%f    浮点数
+`%f`    浮点数
 
-%F    浮点数，与上相同
+`%F`    浮点数，与上相同
 
-%g    指数(e)或浮点数 (根据显示长度)
+`%g`    指数(e)或浮点数 (根据显示长度)
 
-%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`表示小数点后精度
 
  
 
@@ -93,14 +93,14 @@ 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中还有其他的格式化字符串的方式，但`%`操作符的使用是最方便的。
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..6bdd106 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"	
@@ -9,7 +9,7 @@ import this
 ```
 该彩蛋的文档记录于PEP 20。
 
-语句执行之后，终端将显示一首"The Zen of Python"的诗，即“Python之道”。这首诗总结了Python的风格，可以指导Python程序员的编程。Python程序员会自豪宣称自己"Pythonic"。Pythonic的一个基本标准，是写出合乎“Python之道”的代码。
+语句执行之后，终端将显示一首“The Zen of Python”的诗，即“Python之道”。这首诗总结了Python的风格，可以指导Python程序员的编程。Python程序员会自豪宣称自己“Pythonic”。“Pythonic”的一个基本标准，是写出合乎“Python之道”的代码。
 
  
 
@@ -122,7 +122,7 @@ Namespaces are one honking great idea -- let's do more of those!
 
 ##历史
 
-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社区很幽默。
 

From 5eb0a3446393771a40464352135a385ff3e118dc Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Fri, 20 Jun 2014 00:07:42 +0800
Subject: [PATCH 05/13] =?UTF-8?q?=E6=B7=B1=E5=85=A5=E3=80=81=E7=BD=91?=
 =?UTF-8?q?=E7=BB=9C=EF=BC=9A=E4=B8=BA=E6=96=87=E4=B8=AD=E5=87=BA=E7=8E=B0?=
 =?UTF-8?q?=E7=9A=84=E4=BB=A3=E7=A0=81=E3=80=81=E5=8F=98=E9=87=8F=E6=B7=BB?=
 =?UTF-8?q?=E5=8A=A0=E4=BB=A3=E7=A0=81=EF=BC=88code=EF=BC=89=E6=A0=BC?=
 =?UTF-8?q?=E5=BC=8F=E3=80=82=E5=A6=82`print()`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...16\345\244\232\350\214\203\345\274\217.md" | 16 +++----
 ...07\347\256\241\347\220\206\345\231\250.md" | 18 +++----
 ...345\205\24504 \351\227\255\345\214\205.md" | 22 ++++-----
 ...5 \350\243\205\351\245\260\345\231\250.md" | 16 +++----
 ...05\345\255\230\347\256\241\347\220\206.md" | 48 +++++++++----------
 ...on\346\234\215\345\212\241\345\231\250.md" | 44 ++++++++---------
 ...41\345\231\250\350\277\233\345\214\226.md" | 44 ++++++++---------
 7 files changed, 103 insertions(+), 105 deletions(-)

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..339994d 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"	
@@ -5,9 +5,9 @@
 
 Python一切皆对象，但同时，Python还是一个多范式语言(multi-paradigm),你不仅可以使用面向对象的方式来编写程序，还可以用面向过程的方式来编写相同功能的程序(还有函数式、声明式等，我们暂不深入)。Python的多范式依赖于Python对象中的特殊方法(special method)。
 
-特殊方法名的前后各有两个下划线。特殊方法又被成为魔法方法(magic method)，定义了许多Python语法和表达方式，正如我们在下面的例子中将要看到的。当对象中定义了特殊方法的时候，Python也会对它们有“特殊优待”。比如定义了__init__()方法的类，会在创建对象的时候自动执行__init__()方法中的操作。
+特殊方法名的前后各有两个下划线。特殊方法又被成为魔法方法(magic method)，定义了许多Python语法和表达方式，正如我们在下面的例子中将要看到的。当对象中定义了特殊方法的时候，Python也会对它们有“特殊优待”。比如定义了`__init__()`方法的类，会在创建对象的时候自动执行`__init__()`方法中的操作。
 
-(可以通过dir()来查看对象所拥有的特殊方法，比如dir(1))
+(可以通过`dir()`来查看对象所拥有的特殊方法，比如`dir(1)`)
 
  
 
@@ -21,9 +21,9 @@ Python的运算符是通过调用对象的特殊方法实现的。比如：
 ```python
 'abc'.__add__('xyz')
 ```
-所以，在Python中，两个对象是否能进行加法运算，首先就要看相应的对象是否有__add__()方法。一旦相应的对象有__add__()方法，即使这个对象从数学上不可加，我们都可以用加法的形式，来表达obj.__add__()所定义的操作。在Python中，运算符起到简化书写的功能，但它依靠特殊方法实现。
+所以，在Python中，两个对象是否能进行加法运算，首先就要看相应的对象是否有`__add__()`方法。一旦相应的对象有`__add__()`方法，即使这个对象从数学上不可加，我们都可以用加法的形式，来表达`obj.__add__()`所定义的操作。在Python中，运算符起到简化书写的功能，但它依靠特殊方法实现。
 
-Python不强制用户使用面向对象的编程方法。用户可以选择自己喜欢的使用方式(比如选择使用+符号，还是使用更加面向对象的__add__()方法)。特殊方法写起来总是要更费事一点。
+Python不强制用户使用面向对象的编程方法。用户可以选择自己喜欢的使用方式(比如选择使用`+`符号，还是使用更加面向对象的`__add__()`方法)。特殊方法写起来总是要更费事一点。
 
 尝试下面的操作，看看效果，再想想它的对应运算符
 
@@ -43,7 +43,7 @@ len([1,2,3])      # 返回表中元素的总数
 ```python
 [1,2,3].__len__()
 ```
-相对与__len__()，内置函数len()也起到了简化书写的作用。
+相对与`__len__()`，内置函数`len()`也起到了简化书写的作用。
 
 尝试下面的操作，想一下它的对应内置函数
 
@@ -60,7 +60,7 @@ len([1,2,3])      # 返回表中元素的总数
 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))
@@ -74,7 +74,7 @@ li.__setitem__(3, 0)
 
 ##函数
 
-我们已经说过，在Python中，函数也是一种对象。实际上，任何一个有__call__()特殊方法的对象都被当作是函数。比如下面的例子:
+我们已经说过，在Python中，函数也是一种对象。实际上，任何一个有`__call__()`特殊方法的对象都被当作是函数。比如下面的例子:
 
 ```python
 class SampleMore(object):
@@ -86,7 +86,7 @@ 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()`函数。
 
 当然，我们还可以使用更“优美”的方式，想想是什么。
 
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..3fff9fe 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,7 +1,7 @@
 #Python深入02 上下文管理器
 	
  
-上下文管理器(context manager)是Python2.5开始支持的一种语法，用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是with...as...
+上下文管理器(context manager)是Python2.5开始支持的一种语法，用于规定某个对象的使用范围。一旦进入或者离开该使用范围，会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是`with...as...`
 
  
 
@@ -26,19 +26,19 @@ with open("new.txt", "w") as f:
     f.write("Hello World!")
 print(f.closed)
 ```
-两段程序实际上执行的是相同的操作。我们的第二段程序就使用了上下文管理器 (with...as...)。上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候(也就是不再缩进)，上下文管理器自动关闭了文件 (我们通过f.closed来查询文件是否关闭)。我们相当于使用缩进规定了文件对象f的使用范围。
+两段程序实际上执行的是相同的操作。我们的第二段程序就使用了上下文管理器 (`with...as...`)。上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候(也就是不再缩进)，上下文管理器自动关闭了文件 (我们通过`f.closed`来查询文件是否关闭)。我们相当于使用缩进规定了文件对象`f`的使用范围。
 
  
 
-上面的上下文管理器基于f对象的__exit__()特殊方法(还记得我们如何利用特殊方法来实现各种语法？参看特殊方法与多范式)。当我们使用上下文管理器的语法时，我们实际上要求Python在进入程序块之前调用对象的__enter__()方法，在结束程序块的时候调用__exit__()方法。对于文件对象f来说，它定义了__enter__()和__exit__()方法(可以通过dir(f)看到)。在f的__exit__()方法中，有self.close()语句。所以在使用上下文管理器时，我们就不用明文关闭f文件了。
+上面的上下文管理器基于`f`对象的`__exit__()`特殊方法(还记得我们如何利用特殊方法来实现各种语法？参看特殊方法与多范式)。当我们使用上下文管理器的语法时，我们实际上要求Python在进入程序块之前调用对象的`__enter__()`方法，在结束程序块的时候调用`__exit__()`方法。对于文件对象f来说，它定义了`__enter__()`和`__exit__()`方法(可以通过`dir(f)`看到)。在`f`的`__exit__()`方法中，有`self.close()`语句。所以在使用上下文管理器时，我们就不用明文关闭`f`文件了。
 
  
 
 ##自定义
 
-任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器。文件对象f是内置对象，所以f自动带有这两个特殊方法，不需要自定义。
+任何定义了`__enter__()`和`__exit__()`方法的对象都可以用于上下文管理器。文件对象`f`是内置对象，所以`f`自动带有这两个特殊方法，不需要自定义。
 
-下面，我们自定义用于上下文管理器的对象，就是下面的myvow：
+下面，我们自定义用于上下文管理器的对象，就是下面的`myvow`：
 
  
 
@@ -67,17 +67,17 @@ print(myvow.text)
 I say: I'm fine
 I say: I'm fine!
 
-我们可以看到，在进入上下文和离开上下文时，对象的text属性发生了改变(最初的text属性是"I'm fine")。
+我们可以看到，在进入上下文和离开上下文时，对象的text属性发生了改变(最初的`text`属性是`"I'm fine"`)。
 
-__enter__()返回一个对象。上下文管理器会使用这一对象作为as所指的变量，也就是myvow。在__enter__()中，我们为myvow.text增加了前缀 ("I say: ")。在__exit__()中，我们为myvow.text增加了后缀("!")。
+`__enter__()`返回一个对象。上下文管理器会使用这一对象作为`as`所指的变量，也就是`myvow`。在`__enter__()`中，我们为`myvow.text`增加了前缀 (`"I say: "`)。在`__exit__()`中，我们为`myvow.text`增加了后缀(`"!"`)。
 
-注意: __exit__()中有四个参数。当程序块中出现异常(exception)，__exit__()的参数中exc_type, exc_value, traceback用于描述异常。我们可以根据这三个参数进行相应的处理。如果正常运行结束，这三个参数都是None。在我们的程序中，我们并没有用到这一特性。
+注意: `__exit__()`中有四个参数。当程序块中出现异常(`exception`)，`__exit__()`的参数中`exc_type`, `exc_value`, `traceback`用于描述异常。我们可以根据这三个参数进行相应的处理。如果正常运行结束，这三个参数都是`None`。在我们的程序中，我们并没有用到这一特性。
 
  
 
 ##总结：
 
-通过上下文管理器，我们控制对象在程序不同区间的特性。上下文管理器(with EXPR as VAR)大致相当于如下流程:
+通过上下文管理器，我们控制对象在程序不同区间的特性。上下文管理器(`with EXPR as VAR`)大致相当于如下流程:
 
 ```python
 # with EXPR as VAR:
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..b3e4921 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"	
@@ -11,7 +11,7 @@
 
 ##函数对象的作用域
 
-和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用def语句定义的，函数对象的作用域与def所在的层级相同。比如下面代码，我们在line_conf函数的隶属范围内定义的函数line，就只能在line_conf的隶属范围内调用。
+和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用`def`语句定义的，函数对象的作用域与`def`所在的层级相同。比如下面代码，我们在`line_conf`函数的隶属范围内定义的函数`line`，就只能在`line_conf`的隶属范围内调用。
 
 ```python
 def line_conf():
@@ -23,7 +23,7 @@ def line_conf():
 line_conf()
 print(line(5))       # out of the scope
 ```
-line函数定义了一条直线(y = 2x + 1)。可以看到，在line_conf()中可以调用line函数，而在作用域之外调用line将会有下面的错误：
+`line`函数定义了一条直线(`y = 2x + 1`)。可以看到，在`line_conf()`中可以调用`line`函数，而在作用域之外调用`line`将会有下面的错误：
 
 NameError: name 'line' is not defined
 
@@ -31,7 +31,7 @@ NameError: name 'line' is not defined
 
  
 
-同样，如果使用lambda定义函数，那么函数对象的作用域与lambda所在的层级相同。
+同样，如果使用`lambda`定义函数，那么函数对象的作用域与`lambda`所在的层级相同。
 
  
 
@@ -48,11 +48,11 @@ 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():
@@ -65,13 +65,13 @@ 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)。
+我们可以看到，`line`定义的隶属程序块中引用了高层级的变量`b`，但`b`信息存在于`line`的定义之外 (`b`的定义并不在`line`的隶属程序块中)。我们称`b`为`line`的环境变量。事实上，`line`作为`line_conf`的返回值时，`line`中已经包括`b`的取值(尽管`b`并不隶属于`line`)。
 
-上面的代码将打印25，也就是说，line所参照的b值是函数对象定义时可供参考的b值，而不是使用时的b值。
+上面的代码将打印`25`，也就是说，`line`所参照的`b`值是函数对象定义时可供参考的`b`值，而不是使用时的`b`值。
 
  
 
-一个函数和它的环境变量合在一起，就构成了一个闭包(closure)。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的__closure__属性中。比如下面的代码：
+一个函数和它的环境变量合在一起，就构成了一个闭包(closure)。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的`__closure__`属性中。比如下面的代码：
 
 ```python
 def line_conf():
@@ -85,7 +85,7 @@ 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`的取值。
 
  
 
@@ -101,9 +101,9 @@ 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，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。
+这个例子中，函数`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传递来的参数，通过闭包的形式，将最终函数确定下来。
+如果没有闭包，我们需要每次创建直线函数的时候同时说明`a`,`b`,`x`。这样，我们就需要更多的参数传递，也减少了代码的可移植性。利用闭包，我们实际上创建了泛函。`line`函数定义一种广泛意义的函数。这个函数的一些方面已经确定(必须是直线)，但另一些方面(比如`a`和`b`参数待定)。随后，我们根据`line_conf`传递来的参数，通过闭包的形式，将最终函数确定下来。
 
  
 
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..b4b21bb 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"	
@@ -5,7 +5,7 @@
 
 装饰器(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版本中，装饰器被进一步用于加工类。
 
  
 
@@ -69,9 +69,9 @@ def square_diff(a, b):
 print(square_sum(3, 4))
 print(square_diff(3, 4))
 ```
-装饰器可以用def的形式定义，如上面代码中的decorator。装饰器接收一个可调用对象作为输入参数，并返回一个新的可调用对象。装饰器新建了一个可调用对象，也就是上面的new_F。new_F中，我们增加了打印的功能，并通过调用F(a, b)来实现原有函数的功能。
+装饰器可以用`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)的时候，就相当于：
+定义好装饰器后，我们就可以通过`@`语法使用了。在函数`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)
@@ -82,13 +82,13 @@ square_sum(3, 4)
 
  
 
-如果我们有其他的类似函数，我们可以继续调用decorator来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
+如果我们有其他的类似函数，我们可以继续调用`decorator`来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
 
  
 
 ##含参的装饰器
 
-在上面的装饰器调用中，比如@decorator，该装饰器默认它后面的函数是唯一的参数。装饰器的语法允许我们调用decorator时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
+在上面的装饰器调用中，比如`@decorator`，该装饰器默认它后面的函数是唯一的参数。装饰器的语法允许我们调用`decorator`时，提供其它参数，比如`@decorator(a)`。这样，就为装饰器的编写和使用提供了更大的灵活性。
 
 ```python
 # a new wrapper layer
@@ -114,7 +114,7 @@ def square_diff(a, b):
 print(square_sum(3, 4))
 print(square_diff(3, 4))
 ```
-上面的pre_str是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用@pre_str('^_^')调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。该调用相当于:
+上面的`pre_str`是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用`@pre_str('^_^')`调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。该调用相当于:
 
 square_sum = pre_str('^_^') (square_sum)
  
@@ -146,9 +146,9 @@ eagleLord = Bird(5)
 for i in range(3):
     eagleLord.display()
 ```
-在decorator中，我们返回了一个新类newClass。在新类中，我们记录了原来类生成的对象（self.wrapped），并附加了新的属性total_display，用于记录调用display的次数。我们也同时更改了display方法。
+在`decorator`中，我们返回了一个新类`newClass`。在新类中，我们记录了原来类生成的对象（`self.wrapped`），并附加了新的属性`total_display`，用于记录调用`display()`的次数。我们也同时更改了`display()`方法。
 
-通过修改，我们的Bird类可以显示调用display的次数了。
+通过修改，我们的`Bird`类可以显示调用`display()`的次数了。
 
  
 
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..03f0046 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"	
@@ -12,11 +12,11 @@
 赋值语句是语言最常见的功能了。但即使是最简单的赋值语句，也可以很有内涵。Python的赋值语句就很值得研究。
 
 a = 1
-整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。Python是动态类型的语言(参考动态类型)，对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。
+整数`1`为一个对象。而`a`是一个引用。利用赋值语句，引用`a`指向对象`1`。Python是动态类型的语言(参考动态类型)，对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。
 
 
 
-为了探索对象在内存的存储，我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。
+为了探索对象在内存的存储，我们可以求助于Python的内置函数`id()`。它用于返回对象的身份(identity)。其实，这里所谓的身份，就是该对象的内存地址。
 ```pyhton
 a = 1
 
@@ -32,7 +32,7 @@ print(hex(id(a)))
 
  
 
-在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。
+在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于`1`的引用时，实际上是让所有这些引用指向同一个对象。
 ```pyhton
 a = 1
 b = 1
@@ -46,11 +46,11 @@ print(id(b))
 
 11246696
 
-可见a和b实际上是指向同一个对象的两个引用。
+可见`a`和`b`实际上是指向同一个对象的两个引用。
 
  
 
-为了检验两个引用指向同一个对象，我们可以用is关键字。is用于判断两个引用所指的对象是否相同。
+为了检验两个引用指向同一个对象，我们可以用`is`关键字。`is`用于判断两个引用所指的对象是否相同。
 
 ```pyhton
 # True
@@ -73,13 +73,13 @@ a = []
 b = []
 print(a is b)
 ```
-上面的注释为相应的运行结果。可以看到，由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。
+上面的注释为相应的运行结果。可以看到，由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数`1`的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。
 
  
 
 在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。
 
-我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。
+我们可以使用`sys`包中的`getrefcount()`，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给`getrefcount()`时，参数实际上创建了一个临时的引用。因此，`getrefcount()`所得到的结果，会比期望的多`1`。
 ```pyhton
 from sys import getrefcount
 
@@ -89,7 +89,7 @@ print(getrefcount(a))
 b = a
 print(getrefcount(b))
 ```
-由于上述原因，两个getrefcount将返回2和3，而不是期望的1和2。
+由于上述原因，两个`getrefcount()`将返回`2`和`3`，而不是期望的`1`和`2`。
 
  
 
@@ -109,11 +109,11 @@ a = from_obj(b)
 print(id(a.to_obj))
 print(id(b))
 ```
-可以看到，a引用了对象b。
+可以看到，`a`引用了对象`b`。
 
  
 
-对象引用对象，是Python最基本的构成方式。即使是a = 1这一赋值方式，实际上是让词典的一个键值"a"的元素引用整数对象1。该词典对象用于记录所有的全局引用。该词典引用了整数对象1。我们可以通过内置函数globals()来查看该词典。
+对象引用对象，是Python最基本的构成方式。即使是`a = 1`这一赋值方式，实际上是让词典的一个键值`"a"`的元素引用整数对象`1`。该词典对象用于记录所有的全局引用。该词典引用了整数对象`1`。我们可以通过内置函数`globals()`来查看该词典。
 
  
 
@@ -128,11 +128,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)]
@@ -146,7 +146,7 @@ objgraph.show_refs([z], filename='ref_topo.png')
 
  
 
-objgraph是Python的一个第三方包。安装之前需要安装xdot。
+`objgraph`是Python的一个第三方包。安装之前需要安装`xdot`。
 ```pyhton
 sudo apt-get install xdot
 sudo pip install objgraph
@@ -172,7 +172,7 @@ print(getrefcount(a))
 
 ##引用减少
 
-某个对象的引用计数可能减少。比如，可以使用del关键字删除某个引用:
+某个对象的引用计数可能减少。比如，可以使用`del`关键字删除某个引用:
 
 ```pyhton
 from sys import getrefcount
@@ -186,7 +186,7 @@ print(getrefcount(b))
 ```
  
 
-del也可以用于删除容器元素中的元素，比如:
+`del`也可以用于删除容器元素中的元素，比如:
 ```pyhton
 a = [1,2,3]
 del a[0]
@@ -226,21 +226,21 @@ print(getrefcount(b))
 a = [1, 2, 3]
 del a
 ```
-del a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
+`del a`后，已经没有任何引用指向之前建立的`[1, 2, 3]`这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
 
  
 
 然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
 
-我们可以通过gc模块的get_threshold()方法，查看该阈值:
+我们可以通过`gc`模块的`get_threshold()`方法，查看该阈值:
 
 import gc
 print(gc.get_threshold())
-返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。
+返回`(700, 10, 10)`，后面的两个`10`是与分代回收相关的阈值，后面可以看到。`700`即是垃圾回收启动的阈值。可以通过`gc`中的`set_threshold()`方法重新设置。
 
  
 
-我们也可以手动启动垃圾回收，即使用gc.collect()。
+我们也可以手动启动垃圾回收，即使用`gc.collect()`。
 
  
 
@@ -258,9 +258,9 @@ Python同时采用了分代(generation)回收的策略。这一策略的基本
 
 Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。
 
-这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。
+这两个次数即上面`get_threshold()`返回的(700, 10, 10)返回的两个`10`。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。
 
-同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。
+同样可以用`set_threshold()`来调整，比如对2代对象进行更频繁的扫描。
 
 import gc
 gc.set_threshold(700, 10, 5)
@@ -277,7 +277,7 @@ a.append(b)
 del a
 del b
 ```
-上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。
+上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了`a`，`b`引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。
 
 
 
@@ -285,7 +285,7 @@ del b
 
  
 
-为了回收这样的引用环，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。
 
 
 
@@ -295,7 +295,7 @@ del b
 
  
 
-在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。
+在结束遍历后，`gc_ref`不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。
 
  
 
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..21afbd1 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"	
@@ -3,11 +3,11 @@
 
  
 
-之前我的Python教程中有人留言，表示只学Python没有用，必须学会一个框架(比如Django和web.py)才能找到工作。而我的想法是，掌握一个类似于框架的高级工具是有用的，但是基础的东西可以让你永远不被淘汰。不要被工具限制了自己的发展。今天，我在这里想要展示的，就是不使用框架，甚至不使用Python标准库中的高级包，只使用标准库中的socket接口(我不是很明白套接字这个翻译，所以使用socket的英文名字)，写一个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服务器框架 (framework, 比如`Django`, `Twisted`, `web.py`等等) 横行的时代，从底层的socket开始写服务器似乎是一个出力不讨好的笨方法。框架的意义在于掩盖底层的细节，提供一套对于开发人员更加友好的API，并处理诸如MVC的布局问题。框架允许我们快速的构建一个成型而且成熟的Python服务器。然而，框架本身也是依赖于底层(比如socket)。对于底层socket的了解，不仅可以帮助我们更好的使用框架，更可以让我们明白框架是如何设计的。更进一步，如果拥有良好的底层socket编程知识和其他系统编程知识，你完全可以设计并开发一款自己的框架。如果你可以从底层socket开始，实现一个完整的Python服务器，支持用户层的协议，并处理好诸如MVC(Model-View-Control)、多线程(threading)等问题，并整理出一套清晰的函数或者类，作为接口(API)呈现给用户，你就相当于设计了一个框架。
 
  
 
@@ -39,9 +39,9 @@ http://yakovfain.com/2012/10/11/the-degradation-of-java-developers/
 
  
 
-在Python中，我们使用标准库中的socket包来进行底层的socket编程。
+在Python中，我们使用标准库中的`socket`包来进行底层的socket编程。
 
-首先是服务器端，我们使用bind()方法来赋予socket以固定的地址和端口，并使用listen()方法来被动的监听该端口。当有客户尝试用connect()方法连接的时候，服务器使用accept()接受连接，从而建立一个连接的socket：
+首先是服务器端，我们使用`bind()`方法来赋予socket以固定的地址和端口，并使用`listen()`方法来被动的监听该端口。当有客户尝试用`connect()`方法连接的时候，服务器使用`accept()`接受连接，从而建立一个连接的`socket`：
 
 ```python
 # Written by Vamei
@@ -72,11 +72,11 @@ 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
@@ -101,9 +101,9 @@ print 'reply is: ',reply
 # close connection
 s.close()
 ```
-在上面的例子中，我们对socket的两端都可以调用recv()方法来接收信息，调用sendall()方法来发送信息。这样，我们就可以在分处于两台计算机的两个进程间进行通信了。当通信结束的时候，我们使用close()方法来关闭socket连接。
+在上面的例子中，我们对socket的两端都可以调用`recv()`方法来接收信息，调用`sendall()`方法来发送信息。这样，我们就可以在分处于两台计算机的两个进程间进行通信了。当通信结束的时候，我们使用`close()`方法来关闭socket连接。
 
-(如果没有两台计算机做实验，也可以将客户端IP想要connect的IP改为"127.0.0.1"，这是个特殊的IP地址，用来连接当地主机。)
+(如果没有两台计算机做实验，也可以将客户端IP想要connect的IP改为"`127.0.0.1`"，这是个特殊的IP地址，用来连接当地主机。)
 
  
 
@@ -186,23 +186,21 @@ 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。
+它实际上又由空格分为三个片段，`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)。
+头信息跟随起始行，它和主体之间有一个空行。这里的`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系统下，则不需要区分文本文件和二进制文件。)
 
  
 
@@ -212,15 +210,15 @@ 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。
+起始行可以分为三部分，第一部分为请求方法(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被发送回给客户端。
+按照HTTP协议的规定，服务器需要根据请求执行一定的操作。正如我们在服务器程序中看到的，我们的Python程序先检查了`request`的方法，随后根据URL的不同，来生成不同的response(`text_content`或者`pic_content`)。随后，这个`response`被发送回给客户端。
 
  
 
 ##使用浏览器实验
 
-为了配合上面的服务器程序，我已经在放置Python程序的文件夹里，保存了一个test.jpg图片文件。我们在终端运行上面的Python程序，作为服务器端，再打开一个浏览器作为客户端。(如果有时间，你也完全可以用Python写一个客户端。原理与上面的TCP socket的客户端程序相类似。)
+为了配合上面的服务器程序，我已经在放置Python程序的文件夹里，保存了一个`test.jpg`图片文件。我们在终端运行上面的Python程序，作为服务器端，再打开一个浏览器作为客户端。(如果有时间，你也完全可以用Python写一个客户端。原理与上面的TCP socket的客户端程序相类似。)
 
 在浏览器的地址栏输入:
 
@@ -247,11 +245,11 @@ Accept-Encoding: gzip, deflate
 Connection: keep-alive
 ```
 
-我们的Python程序根据这个请求，发送给服务器text_content的内容。
+我们的Python程序根据这个请求，发送给服务器`text_content`的内容。
 
  
 
-浏览器接收到text_content之后，发现正文的html文本中有<IMG src="text.jpg" />，知道需要获得text.jpg文件来补充为图片，立即发出了第二个请求:
+浏览器接收到`text_content`之后，发现正文的html文本中有`<IMG src="text.jpg" />`，知道需要获得`text.jpg`文件来补充为图片，立即发出了第二个请求:
 
 ```bash
 GET /test.jpg HTTP/1.1
@@ -264,7 +262,7 @@ Connection: keep-alive
 Referer: http://127.0.0.1:8000/
 ```
 
-我们的Python程序分析过起始行之后，发现/test.jpg符合if条件，所以将pic_content发送给客户。
+我们的Python程序分析过起始行之后，发现`/test.jpg`符合`if`条件，所以将`pic_content`发送给客户。
 
 最后，浏览器根据html语言的语法，将html文本和图画以适当的方式显示出来。(html可参考http://www.w3schools.com/html/default.asp)
 
@@ -272,11 +270,11 @@ Referer: http://127.0.0.1:8000/
 
 ##探索的方向
 
-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) 在经历了所有的辛苦和麻烦之后，你可能发现，框架是那么的方便，所以决定去使用框架。或者，你已经有了参与到框架开发的热情。
 
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..819f654 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,15 +1,15 @@
 #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服务器，会发现这里只是增加很少的一点内容。
 
 原始程序:
 
@@ -94,7 +94,7 @@ while True:
 
  
 
-页面新增了表格和提交(submit)按钮。在表格中输入aa并提交，页面显示出aa。
+页面新增了表格和提交(submit)按钮。在表格中输入`aa`并提交，页面显示出`aa`。
 
  
 
@@ -106,7 +106,7 @@ while True:
 
 ##使用SocketServer
 
-首先使用SocketServer包来方便的架设服务器。在上面使用socket的过程中，我们先设置了socket的类型，然后依次调用bind(),listen(),accept()，最后使用while循环来让服务器不断的接受请求。上面的这些步骤可以通过SocketServer包来简化。
+首先使用`SocketServer`包来方便的架设服务器。在上面使用`socket`的过程中，我们先设置了`socket`的类型，然后依次调用`bind()`,`listen()`,`accept()`，最后使用`while`循环来让服务器不断的接受请求。上面的这些步骤可以通过`SocketServer`包来简化。
 
 SocketServer:
 
@@ -180,15 +180,15 @@ server.serve_forever()
 ```
  
 
-我建立了一个TCPServer对象，即一个使用TCP socket的服务器。在建立TCPServe的同时，设置该服务器的IP地址和端口。使用server_forever()方法来让服务器不断工作(就像原始程序中的while循环一样)。
+我建立了一个`TCPServer`对象，即一个使用TCP socket的服务器。在建立`TCPServe`的同时，设置该服务器的IP地址和端口。使用`server_forever()`方法来让服务器不断工作(就像原始程序中的`while`循环一样)。
 
-我们传递给TCPServer一个MyTCPHandler类。这个类定义了如何操作socket。MyTCPHandler继承自BaseRequestHandler。改写handler()方法，来具体规定不同情况下服务器的操作。
+我们传递给`TCPServer`一个`MyTCPHandler`类。这个类定义了如何操作`socket`。`MyTCPHandler`继承自`BaseRequestHandler`。改写`handler()`方法，来具体规定不同情况下服务器的操作。
 
-在handler()中，通过self.request来查询通过socket进入服务器的请求 (正如我们在handler()中对socket进行recv()和sendall()操作)，还使用self.address来引用socket的客户端地址。
+在`handler()`中，通过`self.request`来查询通过`socket`进入服务器的请求 (正如我们在`handler()`中对`socket`进行`recv()`和`sendall()`操作)，还使用`self.address`来引用`socket`的客户端地址。
 
  
 
-经过SocketServer的改造之后，代码还是不够简单。 我们上面的通信基于TCP协议，而不是HTTP协议。因此，我们必须手动的解析HTTP协议。我们将建立基于HTTP协议的服务器。
+经过`SocketServer`的改造之后，代码还是不够简单。 我们上面的通信基于TCP协议，而不是HTTP协议。因此，我们必须手动的解析HTTP协议。我们将建立基于HTTP协议的服务器。
 
  
 
@@ -208,7 +208,7 @@ POST                          /                  分析request主体中包含的
 
  
 
-根据请求方法和URL的不同，一个大型的HTTP服务器可以应付成千上万种不同的请求。在Python中，我们可以使用SimpleHTTPServer包和CGIHTTPServer包来规定针对不同请求的操作。其中，SimpleHTTPServer可以用于处理GET方法和HEAD方法的请求。它读取request中的URL地址，找到对应的静态文件，分析文件类型，用HTTP协议将文件发送给客户。
+根据请求方法和URL的不同，一个大型的HTTP服务器可以应付成千上万种不同的请求。在Python中，我们可以使用`SimpleHTTPServer`包和`CGIHTTPServer`包来规定针对不同请求的操作。其中，`SimpleHTTPServer`可以用于处理GET方法和HEAD方法的请求。它读取`request`中的URL地址，找到对应的静态文件，分析文件类型，用HTTP协议将文件发送给客户。
 
  
 
@@ -218,11 +218,11 @@ 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
 <head>
@@ -239,7 +239,7 @@ First name:<input type="text" name="firstname"><br>
 ```
  
 
-改写Python服务器程序。使用SimpleHTTPServer包中唯一的类SimpleHTTPRequestHandler:
+改写Python服务器程序。使用`SimpleHTTPServer`包中唯一的类`SimpleHTTPRequestHandler`:
 
 ```python
 # Written by Vamei
@@ -260,13 +260,13 @@ 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脚本。
 
 
 
@@ -274,15 +274,15 @@ 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:
 
@@ -303,7 +303,7 @@ 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
 <head>
@@ -320,7 +320,7 @@ First name:<input type="text" name="firstname"><br>
 ```
  
 
-我创建一个cgi-bin的文件夹，并在cgi-bin中放入如下post.py文件，也就是我们的CGI脚本：
+我创建一个`cgi-bin`的文件夹，并在`cgi-bin`中放入如下`post.py`文件，也就是我们的CGI脚本：
 
 ```python
 #!/usr/bin/env python
@@ -336,9 +336,9 @@ print "<p>" +  repr(form['firstname']) + "</p>"
 ```
 (post.py需要有执行权限，见评论区)
 
-第一行说明了脚本所使用的语言，即Python。 cgi包用于提取请求中包含的表格信息。脚本只负责将所有的结果输出到标准输出(使用print)。CGIHTTPRequestHandler会收集这些输出，封装成HTTP回复，传送给客户端。
+第一行说明了脚本所使用的语言，即Python。 `cgi`包用于提取请求中包含的表格信息。脚本只负责将所有的结果输出到标准输出(使用`print`)。`CGIHTTPRequestHandler`会收集这些输出，封装成HTTP回复，传送给客户端。
 
-对于POST方法的请求，它的URL需要指向一个CGI脚本(也就是在cgi-bin或者ht-bin中的文件)。CGIHTTPRequestHandler继承自SimpleHTTPRequestHandler，所以也可以处理GET方法和HEAD方法的请求。此时，如果URL指向CGI脚本时，服务器将脚本的运行结果传送到客户端；当此时URL指向静态文件时，服务器将文件的内容传送到客户端。
+对于POST方法的请求，它的URL需要指向一个CGI脚本(也就是在`cgi-bin`或者`ht-bin`中的文件)。`CGIHTTPRequestHandler`继承自`SimpleHTTPRequestHandler`，所以也可以处理GET方法和HEAD方法的请求。此时，如果URL指向CGI脚本时，服务器将脚本的运行结果传送到客户端；当此时URL指向静态文件时，服务器将文件的内容传送到客户端。
 
 更进一步，我可以让CGI脚本执行数据库操作，比如将接收到的数据放入到数据库中，以及更丰富的程序操作。相关内容从略。
 

From 852a71d24cab2d986276505b49bc1c7c80e21966 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Sun, 22 Jun 2014 03:43:11 +0800
Subject: [PATCH 06/13] =?UTF-8?q?=E4=B8=BA=E6=96=87=E4=B8=AD=E5=87=BA?=
 =?UTF-8?q?=E7=8E=B0=E7=9A=84=E4=BB=A3=E7=A0=81=E3=80=81=E5=8F=98=E9=87=8F?=
 =?UTF-8?q?=E3=80=81shell=E5=91=BD=E4=BB=A4=E3=80=81Python=E5=8C=85?=
 =?UTF-8?q?=E5=90=8D=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81=EF=BC=88code?=
 =?UTF-8?q?=EF=BC=89=E6=A0=BC=E5=BC=8F=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...53\351\200\237\346\225\231\347\250\213.md" |  4 +--
 ...60\351\251\254\350\247\202\350\212\261.md" | 32 +++++++++----------
 ...46\344\271\240\345\207\206\345\244\207.md" |  2 +-
 "content/Python\347\256\200\345\217\262.md"   | 10 +++---
 4 files changed, 24 insertions(+), 24 deletions(-)

diff --git "a/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md" "b/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md"
index a2dfd36..693220a 100644
--- "a/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md"	
+++ "b/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md"	
@@ -31,7 +31,7 @@ Lucy, 11, 58
 
 Joseph, 19, 56
 ```
-第一栏为姓名(name)，第二栏为年纪(age)，第三栏为得分(score)
+第一栏为姓名(`name`)，第二栏为年纪(`age`)，第三栏为得分(`score`)
 
 现在，写一个Python程序，
 
@@ -41,7 +41,7 @@ Joseph, 19, 56
 
 得分低于60的人都有谁？
 
-谁的名字以L开头？
+谁的名字以“L”开头？
 
 所有人的总分是多少?
 
diff --git "a/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md" "b/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md"
index 3d548f4..69d461c 100644
--- "a/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md"
+++ "b/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md"
@@ -28,11 +28,11 @@ Python自身的已有的一些功能可以随着标准库的使用而得到增
 
 1) 文字处理
 
-Python的string类提供了对字符串进行处理的方法。但Python并不止步于此。通过标准库中的re包，Python实现了对正则表达式(regular expression)的支持。Python的正则表达式可以和Perl以及Linux bash的正则表达相媲美。
+Python的`string`类提供了对字符串进行处理的方法。但Python并不止步于此。通过标准库中的`re`包，Python实现了对正则表达式(regular expression)的支持。Python的正则表达式可以和Perl以及Linux bash的正则表达相媲美。
 
 （正则表达式通过自定义的模板在文本中搜索或替换符合该模板的字符串。比如你可以搜索一个文本中所有的数字。正则表达式的关键在于根据自己的需要构成模板。）
 
-此外，Python标准库还为字符串的输出提供更加丰富的格式， 比如： string包，textwrap包。
+此外，Python标准库还为字符串的输出提供更加丰富的格式， 比如： `string`包，`textwrap`包。
 
  
 
@@ -40,29 +40,29 @@ Python的string类提供了对字符串进行处理的方法。但Python并不
 
 我们之前的快速教程介绍了表(list), 字典(dictionary)等数据对象。它们各自有不同的特征，适用于不同场合的对数据的组织和管理。Python的标准库定义了更多的数据对象，比如说数组(array)，队列(Queue)。这些数据对象也分别有各自的特点和功能。一个熟悉数据结构(data structure)的Python用户可以在这些包中找到自己需要的数据结构。
 
-此外，我们也会经常使用copy包，以复制对象。
+此外，我们也会经常使用`copy`包，以复制对象。
 
  
 
 3) 日期和时间
 
-日期和时间的管理并不复杂，但容易犯错。Python的标准库中对日期和时间的管理颇为完善（利用time包管理时间，利用datetime包管理日期和时间），你不仅可以进行日期时间的查询和变换（比如：2012年7月18日对应的是星期几），还可以对日期时间进行运算(比如2000.1.1 13:00的378小时之后是什么日期，什么时间)。通过这些标准库，还可以根据需要控制日期时间输出的文本格式(比如：输出’2012-7-18‘还是'18 Jul 2012')
+日期和时间的管理并不复杂，但容易犯错。Python的标准库中对日期和时间的管理颇为完善（利用`time`包管理时间，利用`datetime`包管理日期和时间），你不仅可以进行日期时间的查询和变换（比如：2012年7月18日对应的是星期几），还可以对日期时间进行运算(比如2000.1.1 13:00的378小时之后是什么日期，什么时间)。通过这些标准库，还可以根据需要控制日期时间输出的文本格式(比如：输出`'2012-7-18'`还是`'18 Jul 2012'`)
 
  
 
 4) 数学运算
 
-标准库中，Python定义了一些新的数字类型(decimal包, fractions包), 以弥补之前的数字类型(integer, float)可能的不足。标准库还包含了random包，用于处理随机数相关的功能（产生随机数，随机取样等）。math包补充了一些重要的数学常数和数学函数，比如pi，三角函数等等。
+标准库中，Python定义了一些新的数字类型(`decimal`包, `fractions`包), 以弥补之前的数字类型(`integer`, `float`)可能的不足。标准库还包含了`random`包，用于处理随机数相关的功能（产生随机数，随机取样等）。`math`包补充了一些重要的数学常数和数学函数，比如pi，三角函数等等。
 
-(尽管numpy并不是标准库中的包，但它的数组运算的良好支持，让它在基于Python的科研和计算方面得到相当广泛的应用，可以适当关注。)
+(尽管`numpy`并不是标准库中的包，但它的数组运算的良好支持，让它在基于Python的科研和计算方面得到相当广泛的应用，可以适当关注。)
 
  
 
 5) 存储
 
-之前我们的快速教程中，只提及了文本的输入和输出。实际上，Python可以输入或输出任意的对象。这些对象可以通过标准库中的pickle包转换成为二进制格式(binary)，然后存储于文件之中，也可以反向从二进制文件中读取对象。
+之前我们的快速教程中，只提及了文本的输入和输出。实际上，Python可以输入或输出任意的对象。这些对象可以通过标准库中的`pickle`包转换成为二进制格式(binary)，然后存储于文件之中，也可以反向从二进制文件中读取对象。
 
-此外，标准库中还支持基本的数据库功能(sqlite3包)。XML和csv格式的文件也有相应的处理包。
+此外，标准库中还支持基本的数据库功能(`sqlite3`包)。XML和csv格式的文件也有相应的处理包。
 
 
 
@@ -74,7 +74,7 @@ Python的string类提供了对字符串进行处理的方法。但Python并不
 
 1) Python运行控制
 
-sys包被用于管理Python自身的运行环境。Python是一个解释器(interpreter), 也是一个运行在操作系统上的程序。我们可以用sys包来控制这一程序运行的许多参数，比如说Python运行所能占据的内存和CPU， Python所要扫描的路径等。另一个重要功能是和Python自己的命令行互动，从命令行读取命令和参数。
+sys包被用于管理Python自身的运行环境。Python是一个解释器(interpreter), 也是一个运行在操作系统上的程序。我们可以用`sys`包来控制这一程序运行的许多参数，比如说Python运行所能占据的内存和CPU， Python所要扫描的路径等。另一个重要功能是和Python自己的命令行互动，从命令行读取命令和参数。
 
  
 
@@ -82,17 +82,17 @@ sys包被用于管理Python自身的运行环境。Python是一个解释器(inte
 
 如果说Python构成了一个小的世界，那么操作系统就是包围这个小世界的大世界。Python与操作系统的互动可以让Python在自己的小世界里管理整个大世界。
 
-os包是Python与操作系统的接口。我们可以用os包来实现操作系统的许多功能，比如管理系统进程，改变当前路径(相当于’cd‘)，改变文件权限等，建立。但要注意，os包是建立在操作系统的平台上的，许多功能在Windows系统上是无法实现的。另外，在使用os包中，要注意其中的有些功能已经被其他的包取代。
+`os`包是Python与操作系统的接口。我们可以用`os`包来实现操作系统的许多功能，比如管理系统进程，改变当前路径(相当于`cd`)，改变文件权限等，建立。但要注意，os包是建立在操作系统的平台上的，许多功能在Windows系统上是无法实现的。另外，在使用`os`包中，要注意其中的有些功能已经被其他的包取代。
 
-我们通过文件系统来管理磁盘上储存的文件。查找、删除，复制文件，以及列出文件列表等都是常见的文件操作。这些功能经常可以在操作系统中看到（比如ls, mv, cp等Linux命令），但现在可以通过Python标准库中的glob包、shutil包、os.path包、以及os包的一些函数等，在Python内部实现。
+我们通过文件系统来管理磁盘上储存的文件。查找、删除，复制文件，以及列出文件列表等都是常见的文件操作。这些功能经常可以在操作系统中看到（比如`ls`, `mv`, `cp`等Linux命令），但现在可以通过Python标准库中的`glob`包、`shutil`包、`os.path`包、以及`os`包的一些函数等，在Python内部实现。
 
-subprocess包被用于执行外部命令，其功能相当于我们在操作系统的命令行中输入命令以执行，比如常见的系统命令'ls'或者'cd'，还可以是任意可以在命令行中执行的程序。
+`subprocess`包被用于执行外部命令，其功能相当于我们在操作系统的命令行中输入命令以执行，比如常见的系统命令`ls`或者`cd`，还可以是任意可以在命令行中执行的程序。
 
  
 
 4) 线程与进程
 
-Python支持多线程(threading包)运行和多进程(multiprocessing包)运行。通过多线程和多进程，可以提高系统资源的利用率，提高计算机的处理速度。Python在这些包中，附带有相关的通信和内存管理工具。此外，Python还支持类似于UNIX的signal系统，以实现进程之间的粗糙的信号通信。
+Python支持多线程(`threading`包)运行和多进程(`multiprocessing`包)运行。通过多线程和多进程，可以提高系统资源的利用率，提高计算机的处理速度。Python在这些包中，附带有相关的通信和内存管理工具。此外，Python还支持类似于UNIX的signal系统，以实现进程之间的粗糙的信号通信。
 
  
 
@@ -104,15 +104,15 @@ Python支持多线程(threading包)运行和多进程(multiprocessing包)运行
 
 1) 基于socket层的网络应用
 
-socket是网络可编程部分的底层。通过socket包，我们可以直接管理socket，比如说将socket赋予给某个端口(port)，连接远程端口，以及通过连接传输数据。我们也可以利用SocketServer包更方便地建立服务器。
+socket是网络可编程部分的底层。通过`socket`包，我们可以直接管理socket，比如说将socket赋予给某个端口(port)，连接远程端口，以及通过连接传输数据。我们也可以利用`SocketServer`包更方便地建立服务器。
 
-通过与多线程和多进程配合，建立多线程或者多进程的服务器，可以有效提高服务器的工作能力。此外，通过asyncore包实现异步处理，也是改善服务器性能的一个方案。
+通过与多线程和多进程配合，建立多线程或者多进程的服务器，可以有效提高服务器的工作能力。此外，通过`asyncore`包实现异步处理，也是改善服务器性能的一个方案。
 
  
 
 2) 互联网应用
 
-在实际应用中，网络的很多底层细节（比如socket）都是被高层的协议隐藏起来的。建立在socket之上的http协议实际上更容易也更经常被使用。http通过request/responce的模式建立连接并进行通信，其信息内容也更容易理解。Python标准库中有http的服务器端和客户端的应用支持(BaseHTTPServer包; urllib包, urllib2包), 并且可以通过urlparse包对URL（URL实际上说明了网络资源所在的位置）进行理解和操作。
+在实际应用中，网络的很多底层细节（比如socket）都是被高层的协议隐藏起来的。建立在socket之上的http协议实际上更容易也更经常被使用。http通过request/responce的模式建立连接并进行通信，其信息内容也更容易理解。Python标准库中有http的服务器端和客户端的应用支持(`BaseHTTPServer`包; `urllib`包, `urllib2`包), 并且可以通过`urlparse`包对URL（URL实际上说明了网络资源所在的位置）进行理解和操作。
 
  
 
diff --git "a/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md" "b/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md"
index be9d29c..9d2f41d 100644
--- "a/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md"
+++ "b/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md"
@@ -34,7 +34,7 @@ Python标准库的一部份是为了提高系统的性能(比如mmap)，所以
 
 6) 常用系统命令以及应用，比如ls, mv, rm, mkdir, chmod, zip, tar..., 
 
-学习文件相关的内容，，是为了学习os包, shutil包中文件管理相关的部分。学习文件接口对于文本输入输出的理解很重要，也会影响到对于socket包, select包概念的理解。此外，python中的归档(archive)和压缩(compress)功能也和操作系统中的类似。
+学习文件相关的内容，是为了学习`os`包, `shutil`包中文件管理相关的部分。学习文件接口对于文本输入输出的理解很重要，也会影响到对于`socket`包, `select`包概念的理解。此外，python中的归档(archive)和压缩(compress)功能也和操作系统中的类似。
 
 7) Linux shell，比如说file name matching，对于理解glob包等有帮助。如果你对Linux的正则表达(regular expression)有了解的话，python的正则表达的学习会变得比较容易。学习Linux命令行中的参数传递对于理解python标准库中解析命令行的包也是有用的。
 
diff --git "a/content/Python\347\256\200\345\217\262.md" "b/content/Python\347\256\200\345\217\262.md"
index 184b4f7..281b349 100644
--- "a/content/Python\347\256\200\345\217\262.md"
+++ "b/content/Python\347\256\200\345\217\262.md"
@@ -48,7 +48,7 @@ HOW TO RETURN words document:
             INSERT word IN collection
    RETURN collection
 ```
-HOW TO用于定义一个函数。一个Python程序员应该很容易理解这段程序。ABC语言使用冒号(:)和缩进来表示程序块(C语言使用{}来表示程序块)。行尾没有分号。for和if结构中也没有括号()。如果将HOW TO改为def，将PUT行改为collection = []，将INSERT行改为collection.append(word)，这就几乎是一个标准的Python函数。上面的函数读起来就像一段自然的文字。
+`HOW TO`用于定义一个函数。一个Python程序员应该很容易理解这段程序。ABC语言使用冒号(`:`)和缩进来表示程序块(C语言使用`{}`来表示程序块)。行尾没有分号。`for`和`if`结构中也没有括号`()`。如果将`HOW TO`改为`def`，将`PUT`行改为`collection = []`，将`INSERT`行改为`collection.append(word)`，这就几乎是一个标准的Python函数。上面的函数读起来就像一段自然的文字。
 
  
 
@@ -56,7 +56,7 @@ HOW TO用于定义一个函数。一个Python程序员应该很容易理解这
 
 可拓展性差。ABC语言不是模块化语言。如果想在ABC语言中增加功能，比如对图形化的支持，就必须改动很多地方。
 不能直接进行IO。ABC语言不能直接操作文件系统。尽管你可以通过诸如文本流的方式导入数据，但ABC无法直接读写文件。输入输出的困难对于计算机语言来说是致命的。你能想像一个打不开车门的跑车么？
-过度革新。ABC用自然语言的方式来表达程序的意义，比如上面程序中的HOW TO (如何)。然而对于程序员来说，他们更习惯用function或者define来定义一个函数。同样，程序员也习惯了用等号(=)来分配变量。这尽管让ABC语言显得特别，但实际上增加了程序员的学习难度 (程序员大都掌握不止一种语言)。
+过度革新。ABC用自然语言的方式来表达程序的意义，比如上面程序中的`HOW TO`(如何)。然而对于程序员来说，他们更习惯用`function`或者`define`来定义一个函数。同样，程序员也习惯了用等号(`=`)来分配变量。这尽管让ABC语言显得特别，但实际上增加了程序员的学习难度 (程序员大都掌握不止一种语言)。
 传播困难。ABC编译器很大，必须被保存在磁带(tape)上。当时Guido在访问的时候，就必须有一个大磁带来给别人安装ABC编译器。 这样，ABC语言就很难快速传播。
 IBM tape drive：读写磁带
 
@@ -74,7 +74,7 @@ IBM tape drive：读写磁带
 
 最初的Python logo: 由Guido的兄弟Just von Rossum设计
 
-Python语法很多来自C，但又受到ABC语言的强烈影响。来自ABC语言的一些规定直到今天还富有争议，比如强制缩进。但这些语法规定让Python容易读。另一方面，Python聪明的选择服从一些惯例(特别是C语言的惯例)。比如使用等号赋值，使用def来定义函数。Guido认为，如果“常识”上确立的东西，没有必要过度纠结。
+Python语法很多来自C，但又受到ABC语言的强烈影响。来自ABC语言的一些规定直到今天还富有争议，比如强制缩进。但这些语法规定让Python容易读。另一方面，Python聪明的选择服从一些惯例(特别是C语言的惯例)。比如使用等号赋值，使用`def`来定义函数。Guido认为，如果“常识”上确立的东西，没有必要过度纠结。
 
 Python从一开始就特别在意可拓展性(extensibility)。Python可以在多个层次上拓展。从高层上，你可以引入.py文件。在底层，你可以引用C语言的库。Python程序员可以快速的使用Python写.py文件作为拓展模块。但当性能是考虑的重要因素时，Python程序员可以深入底层，写C程序，编译为.so文件引入到Python中使用。Python就好像是使用钢构建房一样，先规定好大的框架。而程序员可以在此框架下相当自由的拓展或更改。
 
@@ -96,11 +96,11 @@ Windows 3.0
 
 (Guido不得不作出许多决定，这也是他被称为Benevolent Dictator For Life的原因)
 
-Python被称为“Battery Included”，是说它以及其标准库的功能强大。这些是整个社区的贡献。Python的开发者来自不同领域，他们将不同领域的优点带给Python。比如Python标准库中的正则表达(regular expression)是参考Perl，而lambda, map, filter, reduce函数参考Lisp。Python本身的一些功能以及大部分的标准库来自于社区。Python的社区不断扩大，进而拥有了自己的newsgroup，网站(python.org)，以及基金 (Python Software Foundation)。从Python 2.0开始，Python也从maillist的开发方式，转为完全开源的开发方式。社区气氛已经形成，工作被整个社区分担，Python也获得了更加高速的发展。
+Python被称为“Battery Included”，是说它以及其标准库的功能强大。这些是整个社区的贡献。Python的开发者来自不同领域，他们将不同领域的优点带给Python。比如Python标准库中的正则表达(regular expression)是参考Perl，而`lambda`, `map`, `filter`, `reduce`函数参考Lisp。Python本身的一些功能以及大部分的标准库来自于社区。Python的社区不断扩大，进而拥有了自己的newsgroup，网站(python.org)，以及基金 (Python Software Foundation)。从Python 2.0开始，Python也从maillist的开发方式，转为完全开源的开发方式。社区气氛已经形成，工作被整个社区分担，Python也获得了更加高速的发展。
 
 (由于Guido享有绝对的仲裁权，所以在Python早期maillist的开发时代，不少爱好者相当担心Guido的生命。他们甚至作出假设：如果Guido挂了的话，Python会怎样。见If Guido was hit by a bus)
 
-到今天，Python的框架已经确立。Python语言以对象为核心组织代码(Everything is object)，支持多种编程范式(multi-paradigm)，采用动态类型(dynamic typing)，自动进行内存回收(garbage collection)。Python支持解释运行(interpret)，并能调用C库进行拓展。Python有强大的标准库 (battery included)。由于标准库的体系已经稳定，所以Python的生态系统开始拓展到第三方包。这些包，如Django, web.py, wxpython, numpy, matplotlib,PIL，将Python升级成了物种丰富的热带雨林。
+到今天，Python的框架已经确立。Python语言以对象为核心组织代码(Everything is object)，支持多种编程范式(multi-paradigm)，采用动态类型(dynamic typing)，自动进行内存回收(garbage collection)。Python支持解释运行(interpret)，并能调用C库进行拓展。Python有强大的标准库 (battery included)。由于标准库的体系已经稳定，所以Python的生态系统开始拓展到第三方包。这些包，如`Django`, `web.py`, `wxpython`, `numpy`, `matplotlib`,`PIL`，将Python升级成了物种丰富的热带雨林。
 
  
 

From 65b3860d492374b414cd53ed09175413a010941e Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Mon, 23 Jun 2014 22:52:05 +0800
Subject: [PATCH 07/13] =?UTF-8?q?=E6=A0=87=E5=87=86=E5=BA=93=E9=83=A8?=
 =?UTF-8?q?=E5=88=86=EF=BC=9A=E4=B8=BA=E6=96=87=E4=B8=AD=E5=87=BA=E7=8E=B0?=
 =?UTF-8?q?=E7=9A=84=E4=BB=A3=E7=A0=81=E3=80=81=E5=8F=98=E9=87=8F=E3=80=81?=
 =?UTF-8?q?=E5=91=BD=E4=BB=A4=E7=AD=89=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81?=
 =?UTF-8?q?=EF=BC=88code=EF=BC=89=E6=A0=BC=E5=BC=8F=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/STL01.md                              | 80 +++++++++----------
 content/STL02.md                              | 37 ++++-----
 content/STL03.md                              | 16 ++--
 content/STL04.md                              | 60 +++++++-------
 content/STL05.md                              | 18 ++---
 content/STL06.md                              | 62 +++++++-------
 content/STL07.md                              | 34 ++++----
 content/STL08.md                              | 36 ++++-----
 content/STL09.md                              | 36 ++++-----
 content/STL10.md                              | 44 +++++-----
 content/STL11.md                              | 26 +++---
 content/STL12.md                              | 26 +++---
 ...52\347\216\257\345\231\250 (itertools).md" | 40 +++++-----
 13 files changed, 261 insertions(+), 254 deletions(-)

diff --git a/content/STL01.md b/content/STL01.md
index 1386cc3..ae4b3f5 100644
--- a/content/STL01.md
+++ b/content/STL01.md
@@ -16,15 +16,15 @@
 
 (官方documentation)
 
-在Python中使用正则表达式需要标准库中的一个包re。
+在Python中使用正则表达式需要标准库中的一个包`re`。
 ```python
 import re
 m = re.search('[0-9]','abcd4ef')
 print(m.group(0))
 ```
-re.search()接收两个参数，第一个'[0-9]'就是我们所说的正则表达式，它告诉Python的是，“听着，我从字符串想要找的是从0到9的一个数字字符”。
+`re.search()`接收两个参数，第一个`'[0-9]'`就是我们所说的正则表达式，它告诉Python的是，“听着，我从字符串想要找的是从`0`到`9`的一个数字字符”。
 
-re.search()如果从第二个参数找到符合要求的子字符串，就返回一个对象m，你可以通过m.group()的方法查看搜索到的结果。如果没有找到符合要求的字符，re.search()会返回None。
+`re.search()`如果从第二个参数找到符合要求的子字符串，就返回一个对象`m`，你可以通过`m.group()`的方法查看搜索到的结果。如果没有找到符合要求的字符，`re.search()`会返回`None`。
 
  
 
@@ -32,7 +32,7 @@ re.search()如果从第二个参数找到符合要求的子字符串，就返回
 ```bash
 $rm book[0-9][0-9].txt
 ```
-这就是要删除类似于book02.txt的文件。book[0-9][0-9].txt所包含的信息是，以book开头，后面跟两个数字字符，之后跟有".txt"的文件名。如果不符合条件的文件名，比如说:
+这就是要删除类似于`book02.txt`的文件。`book[0-9][0-9].txt`所包含的信息是，以`book`开头，后面跟两个数字字符，之后跟有`.txt`的文件名。如果不符合条件的文件名，比如说:
 
 bo12.txt
 
@@ -51,10 +51,10 @@ Perl中内建有正则表达式的功能，据说是所有正则表达式系统
 m = re.search(pattern, string)  # 搜索整个字符串，直到发现符合的子字符串。
 m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式。必须从字符串的第一个字符开始就相符。
 ```
-可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用re.match()的话，则会得到None，因为字符串的起始为‘a’， 不符合'[0-9]'的要求。
+可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用`re.match()`的话，则会得到`None`，因为字符串的起始为`'a'`， 不符合`'[0-9]'`的要求。
 
 
-对于返回的m, 我们使用m.group()来调用结果。（我们会在后面更详细解释m.group()）
+对于返回的`m`, 我们使用`m.group()`来调用结果。（我们会在后面更详细解释`m.group()`）
 
  
 
@@ -71,7 +71,7 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
  
 
-(在熟悉了上面的函数后，可以看一下re.compile()，以便于提高搜索效率。)
+(在熟悉了上面的函数后，可以看一下`re.compile()`，以便于提高搜索效率。)
 
  
 
@@ -81,29 +81,29 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 1）单个字符:
 
-.          任意的一个字符
+`.`          任意的一个字符
 
-a|b        字符a或字符b
+`a|b`        字符a或字符b
 
-[afg]      a或者f或者g的一个字符        
+`[afg]`      a或者f或者g的一个字符        
 
-[0-4]      0-4范围内的一个字符
+`[0-4]`      0-4范围内的一个字符
 
-[a-f]      a-f范围内的一个字符
+`[a-f]`      a-f范围内的一个字符
 
-[^m]       不是m的一个字符
+`[^m]`       不是m的一个字符
 
-\s         一个空格
+`\s`         一个空格
 
-\S         一个非空格
+`\S`         一个非空格
 
-\d         [0-9]
+`\d`         即`[0-9]`
 
-\D         [^0-9]
+`\D`         即`[^0-9]`
 
-\w         [0-9a-zA-Z]
+`\w`         即`[0-9a-zA-Z]`
 
-\W         [^0-9a-zA-Z]
+`\W`         即`[^0-9a-zA-Z]`
 
  
 
@@ -111,76 +111,76 @@ a|b        字符a或字符b
 
 紧跟在单个字符之后，表示多个这样类似的字符
 
-*         重复 >=0 次
+`*`         重复 >=0 次
 
-+         重复 >=1 次
+`+`         重复 >=1 次
 
-?         重复 0或者1 次
+`?`         重复 0或者1 次
 
-{m}       重复m次。比如说 a{4}相当于aaaa，再比如说[1-3]{2}相当于[1-3][1-3]
+`{m}`       重复m次。比如说 a{4}相当于aaaa，再比如说`[1-3]{2}`相当于`[1-3][1-3]`
 
-{m, n}    重复m到n次。比如说a{2, 5}表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。
+`{m, n}`    重复m到n次。比如说`a{2, 5}`表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。
 
  
 
 正则表达          相符的字符串举例
 
-[0-9]{3,5}       9678
+`[0-9]{3,5}`       9678
 
-a?b              b
+`a?b`              b
 
-a+b              aaaaab
+`a+b`              aaaaab
 
  
 
 3) 位置
 
-^         字符串的起始位置
+`^`         字符串的起始位置
 
-$         字符串的结尾位置
+`$`         字符串的结尾位置
 
  
 
 正则表达          相符的字符串举例        不相符字符串
 
-^ab.*c$          abeec               cabeec (如果用re.search(), 将无法找到。)
+`^ab.*c$`          abeec               cabeec (如果用`re.search()`, 将无法找到。)
 
 
 4）返回控制
 
 我们有可能对搜索的结果进行进一步精简信息。比如下面一个正则表达式：
 
-output_(\d{4})
+`output_(\d{4})`
 
-该正则表达式用括号()包围了一个小的正则表达式，\d{4}。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。
-我们可以m.group(number)的方法来查询群。group(0)是整个正则表达的搜索结果，group(1)是第一个群……
+该正则表达式用括号`()`包围了一个小的正则表达式，`\d{4}`。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。
+我们可以`m.group(number)`的方法来查询群。`group(0)`是整个正则表达的搜索结果，`group(1)`是第一个群……
 ```python
 import re
 m = re.search("output_(\d{4})", "output_1986.txt")
 print(m.group(1))
 ``` 
 
-我们还可以将群命名，以便更好地使用m.group查询:
+我们还可以将群命名，以便更好地使用`m.group`查询:
 ```python
 import re
 m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   #(?P<name>...) 为group命名
 print(m.group("year"))
 ``` 
 
-对比re.search和re.match
-本节开头我们用re.search实现数字子串的提取；
+对比`re.search`和`re.match`
+本节开头我们用`re.search`实现数字子串的提取；
 m = re.search('[0-9]','abcd4ef')
-使用re.match同样实现上述功能（提取数字子串)，我们需要用到小括号'()':
+使用`re.match`同样实现上述功能（提取数字子串)，我们需要用到小括号`'()'`:
 ```python
 m = re.match('.*([0-9]+).*','abcd4ef')
 # 注意,我们通过m.group(1)来获取数字字串，下标0处是匹配的整个字符串
 print m.group(0), m.group(1) 
 abcd4ef 4
 ```
-很明显，这里使用match方法要繁琐一些；体会两个方法的差异，搜索整个字符串中的子串使用re.search，而从头开始检查字符串是否符合正则表达式选用re.match;
+很明显，这里使用`match`方法要繁琐一些；体会两个方法的差异，搜索整个字符串中的子串使用`re.search`，而从头开始检查字符串是否符合正则表达式选用`re.match`;
 
 练习
-有一个文件，文件名为output_1981.10.21.txt 。下面使用Python： 读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为output_YYYY-MM-DD-W.txt (YYYY:四位的年，MM：两位的月份，DD：两位的日，W：一位的周几，并假设周一为一周第一天)
+有一个文件，文件名为`output_1981.10.21.txt`。下面使用Python： 读取文件名中的日期时间信息，并找出这一天是周几。将文件改名为`output_YYYY-MM-DD-W.txt`(`YYYY`:四位的年，`MM`：两位的月份，`DD`：两位的日，`W`：一位的周几，并假设周一为一周第一天)
 
  
 
@@ -188,6 +188,6 @@ abcd4ef 4
 
 ##总结
 
-re.search() re.match() re.sub() re.findall()
+`re.search()` `re.match()` `re.sub()` `re.findall()`
 
 正则表达式构成方法
diff --git a/content/STL02.md b/content/STL02.md
index fa9a7ee..4690574 100644
--- a/content/STL02.md
+++ b/content/STL02.md
@@ -8,14 +8,14 @@ Python具有良好的时间和日期管理功能。实际上，计算机只会
 
 ##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')
@@ -26,7 +26,7 @@ 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格式的当地时间, 当地时区根据系统环境决定。
@@ -38,9 +38,9 @@ s  = time.mktime(st)    # 将struct_time格式转换成wall clock time
 
 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
@@ -48,17 +48,17 @@ import datetime
 t = datetime.datetime(2012,9,3,21,30)
 print(t)
 ```
-所返回的t有如下属性:
+所返回的`t`有如下属性:
 
-hour, minute, second, microsecond
+`hour`, `minute`, `second`, `microsecond`
 
-year, month, day, weekday   # weekday表示周几
+`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
@@ -70,18 +70,18 @@ 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
@@ -89,18 +89,19 @@ 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
 ```
+`strptime`中的“p”代表解析（parsing）。
 
-我们通过format来告知Python我们的str字符串中包含的日期的格式。在format中，%Y表示年所出现的位置, %m表示月份所出现的位置……。
 
-反过来，我们也可以调用datetime对象的strftime()方法，来将datetime对象转换为特定格式的字符串。比如上面所定义的t_next,
+我们通过`format`来告知Python我们的str字符串中包含的日期的格式。在`format`中，`%Y`表示年所出现的位置, `%m`表示月份所出现的位置……。
+
+反过来，我们也可以调用`datetime`对象的`strftime()`方法，来将`datetime`对象转换为特定格式的字符串。比如上面所定义的`t_next`,
 ```python
 print(t_next.strftime(format))
 ```
-strftime, f = formatting
+`strftime`中的“f”代表格式化（formatting）。
 
-具体的格式写法可参阅官方文档。 如果是Linux系统，也可查阅date命令的手册($man date)，两者相通。
+具体的格式写法可参阅官方文档。 如果是Linux系统，也可查阅`date`命令的手册(`$man date`)，两者相通。
 
  
 
@@ -108,7 +109,7 @@ strftime, f = formatting
 
 时间，休眠
 
-datetime, timedelta
+`datetime`, `timedelta`
 
 格式化时间
 
diff --git a/content/STL03.md b/content/STL03.md
index 1cc81ef..2feeaab 100644
--- a/content/STL03.md
+++ b/content/STL03.md
@@ -10,7 +10,7 @@
 
 ##os.path包
 
-os.path包主要是处理路径字符串，比如说'/home/vamei/doc/file.txt'，提取出有用信息。
+`os.path`包主要是处理路径字符串，比如说`'/home/vamei/doc/file.txt'`，提取出有用信息。
 
 ```python
 import os.path
@@ -31,7 +31,7 @@ os.path.normpath(path)   # 去除路径path中的冗余。比如'/home/vamei/../
 
  
 
-os.path还可以查询文件的相关信息(metadata)。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息(比如文件类型，大小，修改时间)。
+`os.path`还可以查询文件的相关信息(metadata)。文件的相关信息不存储在文件内部，而是由操作系统维护的，关于文件的一些信息(比如文件类型，大小，修改时间)。
 
 ```python
 import os.path 
@@ -46,15 +46,15 @@ print(os.path.getmtime(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
 
@@ -70,7 +70,7 @@ Filename Pattern Expression      Python Regular Expression
 
  
 
-我们可以用该命令找出/home/vamei下的所有文件:
+我们可以用该命令找出`/home/vamei`下的所有文件:
 ```python
 import glob
 print(glob.glob('/home/vamei/*'))
@@ -80,6 +80,6 @@ print(glob.glob('/home/vamei/*'))
 
 文件系统
 
-os.path
+`os.path`
 
-glob.glob
+`glob.glob`
diff --git a/content/STL04.md b/content/STL04.md
index e05460e..7734d66 100644
--- a/content/STL04.md
+++ b/content/STL04.md
@@ -10,57 +10,57 @@
 
 ##os包 
 
-os包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。os包的一些命令就是用于文件管理。我们这里列出最常用的:
+`os`包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。`os`包的一些命令就是用于文件管理。我们这里列出最常用的:
 
-mkdir(path)
+`mkdir(path)`
 
-创建新目录，path为一个字符串，表示新目录的路径。相当于$mkdir命令
+创建新目录，`path`为一个字符串，表示新目录的路径。相当于`$mkdir`命令
 
-rmdir(path)
+`rmdir(path)`
 
-删除空的目录，path为一个字符串，表示想要删除的目录的路径。相当于$rmdir命令
+删除空的目录，`path`为一个字符串，表示想要删除的目录的路径。相当于`$rmdir`命令
 
-listdir(path)
+`listdir(path)`
 
-返回目录中所有文件。相当于$ls命令。
+返回目录中所有文件。相当于`$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()
+`getcwd()`
 
-查询当前工作路径 (cwd, current working directory)，相当于$pwd命令。
+查询当前工作路径 (cwd, current working directory)，相当于`$pwd`命令。
 
  
 
-比如说我们要新建目录new：
+比如说我们要新建目录`new`：
 ```python
 import os
 os.mkdir('/home/vamei/new')
@@ -68,23 +68,23 @@ 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打造成一个文件管理的利器了。
 
@@ -92,6 +92,6 @@ shutil.copy('a.txt', 'b.txt')
 
 ##总结
 
-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`
diff --git a/content/STL05.md b/content/STL05.md
index c19bf64..33a9f39 100644
--- a/content/STL05.md
+++ b/content/STL05.md
@@ -6,13 +6,13 @@
 
 在之前对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 +27,11 @@ 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 +46,17 @@ 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
@@ -76,7 +76,7 @@ with open(fn, 'r') as f:
 
 ##cPickle包
 
-cPickle包的功能和用法与pickle包几乎完全相同 (其存在差别的地方实际上很少用到)，不同在于cPickle是基于c语言编写的，速度是pickle包的1000倍。对于上面的例子，如果想使用cPickle包，我们都可以将import语句改为:
+`cPickle`包的功能和用法与`pickle`包几乎完全相同 (其存在差别的地方实际上很少用到)，不同在于`cPickle`是基于c语言编写的，速度是`pickle`包的1000倍。对于上面的例子，如果想使用`cPickle`包，我们都可以将import语句改为:
 
 import cPickle as pickle
 就不需要再做任何改动了。
@@ -87,4 +87,4 @@ import cPickle as pickle
 
 对象 -> 文本 -> 文件
 
-pickle.dump(), pickle.load(), cPickle
+`pickle.dump()`, `pickle.load()`, `cPickle`
diff --git a/content/STL06.md b/content/STL06.md
index fea726f..2c01b07 100644
--- a/content/STL06.md
+++ b/content/STL06.md
@@ -3,33 +3,33 @@
 
  
 
-这里的内容以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时，父进程如何处理。
+3) 当`returncode`不为`0`时，父进程如何处理。
 
  
 
 subprocess.call()
 父进程等待子进程完成
-返回退出信息(returncode，相当于exit code，见Linux进程基础)
+返回退出信息(`returncode`，相当于exit code，见Linux进程基础)
 
  
 
@@ -37,9 +37,9 @@ subprocess.check_call()
 
 父进程等待子进程完成
 
-返回0
+返回`0`
 
-检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性，可用try...except...来检查(见Python错误处理)。
+检查退出信息，如果`returncode`不为`0`，则举出错误`subprocess.CalledProcessError`，该对象包含有`returncode`属性，可用`try...except...`来检查(见Python错误处理)。
 
  
 
@@ -49,16 +49,16 @@ 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"])
 ```
-我们将程序名(ls)和所带的参数(-l)一起放在一个表中传递给subprocess.call()
+我们将程序名(`ls`)和所带的参数(`-l`)一起放在一个表中传递给`subprocess.call()`
 
  
 
@@ -68,25 +68,25 @@ import subprocess
 out = subprocess.call("ls -l", shell=True)
 out = subprocess.call("cd ..", shell=True)
 ```
-我们使用了shell=True这个参数。这个时候，我们使用一整个字符串，而不是一个表来运行子进程。Python将先运行一个shell，再用这个shell来解释这整个字符串。
+我们使用了`shell=True`这个参数。这个时候，我们使用一整个字符串，而不是一个表来运行子进程。Python将先运行一个shell，再用这个shell来解释这整个字符串。
 
-shell命令中有一些是shell的内建命令，这些命令必须通过shell运行，$cd。shell=True允许我们运行这样一些命令。
+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"])
 print("parent process")
 ```
-从运行结果中看到，父进程在开启子进程之后并没有等待child的完成，而是直接运行print。
+从运行结果中看到，父进程在开启子进程之后并没有等待`child`的完成，而是直接运行`print`。
 
  
 
@@ -98,7 +98,7 @@ child.wait()
 print("parent process")
 ``` 
 
-此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的child对象:
+此外，你还可以在父进程中对子进程进行其它操作，比如我们上面例子中的`child`对象:
 
 child.poll()           # 检查子进程状态
 
@@ -110,23 +110,23 @@ 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)
@@ -134,30 +134,30 @@ 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中的文本。
+`subprocess.PIPE`实际上为文本流提供一个缓存区。`child1`的`stdout`将文本输出到缓存区，随后`child2`的`stdin`从该`PIPE`中将文本读取走。`child2`的输出文本也被存放在`PIPE`中，直到`communicate()`方法从`PIPE`中读取出`PIPE`中的文本。
 
-要注意的是，communicate()是Popen对象的一个方法，该方法会阻塞父进程，直到子进程完成。
+要注意的是，`communicate()`是`Popen`对象的一个方法，该方法会阻塞父进程，直到子进程完成。
 
  
 
-我们还可以利用communicate()方法来使用PIPE给子进程输入:
+我们还可以利用`communicate()`方法来使用`PIPE`给子进程输入:
 ```python
 import subprocess
 child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)
 child.communicate("vamei")
 ```
-我们启动子进程之后，cat会等待输入，直到我们用communicate()输入"vamei"。
+我们启动子进程之后，`cat`会等待输入，直到我们用`communicate()`输入`"vamei"`。
 
  
 
-通过使用subprocess包，我们可以运行外部程序。这极大的拓展了Python的功能。如果你已经了解了操作系统的某些应用，你可以从Python中直接调用该应用(而不是完全依赖Python)，并将应用的结果输出给Python，并让Python继续处理。shell的功能(比如利用文本流连接各个应用)，就可以在Python中实现。
+通过使用`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()`
diff --git a/content/STL07.md b/content/STL07.md
index 0890694..30d444a 100644
--- a/content/STL07.md
+++ b/content/STL07.md
@@ -2,13 +2,13 @@
 
  
 
-在了解了Linux的信号基础之后，Python标准库中的signal包就很容易学习和理解。signal包负责在Python程序内部处理信号，典型的操作包括预设信号处理函数，暂停并等待信号，以及定时发出SIGALRM等。要注意，signal包主要是针对UNIX平台(比如Linux, MAC OS)，而Windows内核中由于对信号机制的支持不充分，所以在Windows上的Python不能发挥信号系统的功能。
+在了解了Linux的信号基础之后，Python标准库中的`signal`包就很容易学习和理解。`signal`包负责在Python程序内部处理信号，典型的操作包括预设信号处理函数，暂停并等待信号，以及定时发出`SIGALRM`等。要注意，`signal`包主要是针对UNIX平台(比如Linux, MAC OS)，而Windows内核中由于对信号机制的支持不充分，所以在Windows上的Python不能发挥信号系统的功能。
 
  
 
 ##定义信号名
 
-signal包定义了各个信号名及其对应的整数，比如
+`signal`包定义了各个信号名及其对应的整数，比如
 ```python
 import signal
 print signal.SIGALRM
@@ -24,11 +24,11 @@ $man 7 signal
 
 ##预设信号处理函数
 
-signal包的核心是使用signal.signal()函数来预设(register)信号处理函数，如下所示：
+`signal`包的核心是使用`signal.signal()`函数来预设(register)信号处理函数，如下所示：
 
 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
@@ -43,25 +43,25 @@ 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)。我们使用如下方法运行:
 
 $python test.py
 
-以便让进程运行。当程序运行到signal.pause()的时候，进程暂停并等待信号。此时，通过按下CTRL+Z向该进程发送SIGTSTP信号。我们可以看到，进程执行了myHandle()函数, 随后返回主程序，继续执行。(当然，也可以用$ps查询process ID, 再使用$kill来发出信号。)
+以便让进程运行。当程序运行到`signal.pause()`的时候，进程暂停并等待信号。此时，通过按下`CTRL+Z`向该进程发送`SIGTSTP`信号。我们可以看到，进程执行了`myHandle()`函数, 随后返回主程序，继续执行。(当然，也可以用`$ps`查询process ID, 再使用`$kill`来发出信号。)
 
-(进程并不一定要使用signal.pause()暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的signal.pause()改为一个需要长时间工作的循环。)
+(进程并不一定要使用`signal.pause()`暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的`signal.pause()`改为一个需要长时间工作的循环。)
 
  
 
-我们可以根据自己的需要更改myHandler()中的操作，以针对不同的信号实现个性化的处理。
+我们可以根据自己的需要更改`myHandler()`中的操作，以针对不同的信号实现个性化的处理。
 
  
 
 ##定时发出SIGALRM信号
 
-一个有用的函数是signal.alarm()，它被用于在一定时间之后，向进程自身发送SIGALRM信号:
+一个有用的函数是`signal.alarm()`，它被用于在一定时间之后，向进程自身发送`SIGALRM`信号:
 
 ```python
 import signal
@@ -76,32 +76,32 @@ 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`命令的函数，分别为
 
 os.kill(pid, sid)
 
 os.killpg(pgid, sid)
 
-分别向进程和进程组(见Linux进程关系)发送信号。sid为信号所对应的整数或者singal.SIG*。
+分别向进程和进程组(见Linux进程关系)发送信号。`sid`为信号所对应的整数或者`singal.SIG*`。
 
  
 
-实际上signal, pause，kill和alarm都是Linux应用编程中常见的C库函数，在这里，我们只不过是用Python语言来实现了一下。实际上，Python 的解释器是使用C语言来编写的，所以有此相似性也并不意外。此外，在Python 3.4中，signal包被增强，信号阻塞等功能被加入到该包中。我们暂时不深入到该包中。
+实际上`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()`
diff --git a/content/STL08.md b/content/STL08.md
index 7b185da..02bb977 100644
--- a/content/STL08.md
+++ b/content/STL08.md
@@ -3,7 +3,7 @@
 
  
 
-Python主要通过标准库中的threading包来实现多线程。在当今网络时代，每个服务器都会接收到大量的请求。服务器可以利用多线程的方式来处理这些请求，以提高对网络端口的读写效率。Python是一种网络服务器的后台工作语言 (比如豆瓣网)，所以多线程也就很自然被Python语言支持。
+Python主要通过标准库中的`threading`包来实现多线程。在当今网络时代，每个服务器都会接收到大量的请求。服务器可以利用多线程的方式来处理这些请求，以提高对网络端口的读写效率。Python是一种网络服务器的后台工作语言 (比如豆瓣网)，所以多线程也就很自然被Python语言支持。
 
 (关于多线程的原理和C实现方法，请参考我之前写的Linux多线程与同步，要了解race condition, mutex和condition variable的概念)
 
@@ -11,7 +11,7 @@ Python主要通过标准库中的threading包来实现多线程。在当今网
 
 ##多线程售票以及同步
 
-我们使用Python来实现Linux多线程与同步文中的售票程序。我们使用mutex (也就是Python中的Lock类对象) 来实现线程的同步:
+我们使用Python来实现Linux多线程与同步文中的售票程序。我们使用`mutex`(也就是Python中的`Lock`类对象) 来实现线程的同步:
 
 ```python
 # A program to simulate selling tickets in multi-thread way
@@ -51,17 +51,17 @@ for k in range(10):
     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
@@ -102,7 +102,7 @@ for k in range(10):
     new_thread = BoothThread(k, monitor)
     new_thread.start()
 ```
-我们自己定义了一个类BoothThread, 这个类继承自thread.Threading类。然后我们把上面的booth()所进行的操作统统放入到BoothThread类的run()方法中。注意，我们没有使用全局变量声明global，而是使用了一个词典monitor存放全局变量，然后把词典作为参数传递给线程函数。由于词典是可变数据对象，所以当它被传递给函数的时候，函数所使用的依然是同一个对象，相当于被多个线程所共享。这也是多线程乃至于多进程编程的一个技巧 (应尽量避免上面的global声明的用法，因为它并不适用于windows平台)。
+我们自己定义了一个类`BoothThread`, 这个类继承自`thread.Threading`类。然后我们把上面的`booth()`所进行的操作统统放入到`BoothThread`类的`run()`方法中。注意，我们没有使用全局变量声明`global`，而是使用了一个词典`monitor`存放全局变量，然后把词典作为参数传递给线程函数。由于词典是可变数据对象，所以当它被传递给函数的时候，函数所使用的依然是同一个对象，相当于被多个线程所共享。这也是多线程乃至于多进程编程的一个技巧 (应尽量避免上面的`global`声明的用法，因为它并不适用于windows平台)。
 
 上面OOP编程方法与面向过程的编程方法相比，并没有带来太大实质性的差别。
 
@@ -110,22 +110,22 @@ for k in range(10):
 
 ##其他
 
-threading.Thread对象： 我们已经介绍了该对象的start()和run(), 此外：
+`threading.Thread`对象： 我们已经介绍了该对象的`start()`和`run()`, 此外：
 
-join()方法，调用该方法的线程将等待直到改Thread对象完成，再恢复运行。这与进程间调用wait()函数相类似。
+`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`状态。
  
  
 练习
@@ -137,7 +137,7 @@ http://docs.python.org/library/threading.html
 
 ##总结
 
-threading.Thread
+`threading.Thread`
 
-Lock, Condition, Semaphore, Event
+`Lock`, `Condition`, `Semaphore`, `Event`
 
diff --git a/content/STL09.md b/content/STL09.md
index d213a3b..e8a3b6e 100644
--- a/content/STL09.md
+++ b/content/STL09.md
@@ -4,41 +4,41 @@
 
  
 
-我们在Linux的概念与体系，多次提及进程的重要性。Python的os包中有查询和修改进程信息的函数。学习Python的这些工具也有助于理解Linux体系。
+我们在Linux的概念与体系，多次提及进程的重要性。Python的`os`包中有查询和修改进程信息的函数。学习Python的这些工具也有助于理解Linux体系。
 
  
 
 ##进程信息
 
-os包中相关函数如下：
+`os`包中相关函数如下：
 
-uname() 返回操作系统相关信息。类似于Linux上的uname命令。
+`uname()` 返回操作系统相关信息。类似于Linux上的`uname`命令。
 
-umask() 设置该进程创建文件时的权限mask。类似于Linux上的umask命令，见Linux文件管理背景知识
+`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()`：更改进程的环境变量
 
  
 
@@ -48,7 +48,7 @@ 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`看一下运行结果
 
  
 
@@ -56,7 +56,7 @@ print(os.getgid())
 
 我们希望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`获知)
 
 我们先看一下
 
@@ -78,7 +78,7 @@ $sudo chmod 6755 /usr/bin/python
 
  
 
-随后，我们运行文件下面test.py文件，这个文件可以是由普通用户vamei所有:
+随后，我们运行文件下面`test.py`文件，这个文件可以是由普通用户`vamei`所有:
 ```python
 import os
 print(os.getresuid())
@@ -101,6 +101,6 @@ http://www.faqs.org/faqs/unix-faq/faq/part4/section-7.html
 
 ##总结
 
-get*, set*
+`get*`, `set*`
 
-umask(), uname()
+`umask()`, `uname()`
diff --git a/content/STL10.md b/content/STL10.md
index 0586d1a..b9e2ded 100644
--- a/content/STL10.md
+++ b/content/STL10.md
@@ -4,7 +4,13 @@
 
  
 
-我们已经见过了使用subprocess包来创建子进程，但这个包有两个很大的局限性：1) 我们总是让subprocess运行外部的程序，而不是运行一个Python脚本内部编写的函数。2) 进程间只通过管道进行文本交流。以上限制了我们将subprocess包应用到更广泛的多进程任务。(这样的比较实际是不公平的，因为subprocessing本身就是设计成为一个shell，而不是一个多进程管理包)
+我们已经见过了使用`subprocess`包来创建子进程，但这个包有两个很大的局限性：
+
+1) 我们总是让subprocess运行外部的程序，而不是运行一个Python脚本内部编写的函数。
+
+2) 进程间只通过管道进行文本交流。以上限制了我们将`subprocess`包应用到更广泛的多进程任务。
+
+(这样的比较实际是不公平的，因为`subprocessing`本身就是设计成为一个shell，而不是一个多进程管理包)
 
  
 
@@ -12,18 +18,18 @@
 
 (请尽量先阅读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的时候，我们要注意以下几点:
 
-在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性。
-multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。
-多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。
-Process.PID中保存有PID，如果进程还没有start()，则PID为None。
+在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用`wait`，否则进程成为僵尸进程(Zombie)。所以，有必要对每个`Process`对象调用`join()`方法 (实际上等同于`wait`)。对于多线程来说，由于只有一个进程，所以不存在此必要性。
+`multiprocessing`提供了`threading`包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用`Lock`/`Event`/`Semaphore`/`Condition`等同步方式 (因为它们占据的不是用户进程的资源)。
+多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和`Manager`的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。
+`Process.PID`中保存有PID，如果进程还没有`start()`，则PID为`None`。
 
  
 
-我们可以从下面的程序中看到Thread对象和Process对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出(stdout)输出。这样输出的字符会混合在一起，无法阅读。使用Lock同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。
+我们可以从下面的程序中看到`Thread`对象和`Process`对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出(stdout)输出。这样输出的字符会混合在一起，无法阅读。使用`Lock`同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。
 
 ```python
 # Similarity and difference of multi thread vs. multi process
@@ -64,21 +70,21 @@ for i in range(5):
 for process in record:
     process.join()
 ```
-所有Thread的PID都与主程序相同，而每个Process都有一个不同的PID。
+所有`Thread`的PID都与主程序相同，而每个`Process`都有一个不同的PID。
 
-(练习: 使用mutiprocessing包将Python多线程与同步中的多线程程序更改为多进程程序)
+(练习: 使用`mutiprocessing`包将Python多线程与同步中的多线程程序更改为多进程程序)
 
  
 
 ##Pipe和Queue
 
-正如我们在Linux多线程中介绍的管道PIPE和消息队列message queue，multiprocessing包中有Pipe类和Queue类来分别支持这两种IPC机制。Pipe和Queue可以用来传送常见的对象。
+正如我们在Linux多线程中介绍的管道PIPE和消息队列message queue，`multiprocessing`包中有`Pipe`类和`Queue`类来分别支持这两种IPC机制。`Pipe`和`Queue`可以用来传送常见的对象。
 
  
 
-1) Pipe可以是单向(half-duplex)，也可以是双向(duplex)。我们通过mutiprocessing.Pipe(duplex=False)创建单向管道 (默认为双向)。一个进程从PIPE一端输入对象，然后被PIPE另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。
+1) `Pipe`可以是单向(half-duplex)，也可以是双向(duplex)。我们通过`mutiprocessing.Pipe(duplex=False)`创建单向管道 (默认为双向)。一个进程从`Pipe`一端输入对象，然后被`Pipe`另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。
 
-下面的程序展示了Pipe的使用:
+下面的程序展示了`Pipe`的使用:
 
  
 
@@ -108,14 +114,14 @@ p2.start()
 p1.join()
 p2.join()
 ```
-这里的Pipe是双向的。
+这里的`Pipe`是双向的。
 
-Pipe对象建立的时候，返回一个含有两个元素的表，每个元素代表Pipe的一端(Connection对象)。我们对Pipe的某一端调用send()方法来传送对象，在另一端使用recv()来接收。
+`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
@@ -161,12 +167,12 @@ 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`
diff --git a/content/STL11.md b/content/STL11.md
index 14faf70..490d343 100644
--- a/content/STL11.md
+++ b/content/STL11.md
@@ -4,7 +4,7 @@
 
  
 
-在初步了解Python多进程之后，我们可以继续探索multiprocessing包中更加高级的工具。这些工具可以让我们更加便利地实现多进程。
+在初步了解Python多进程之后，我们可以继续探索`multiprocessing`包中更加高级的工具。这些工具可以让我们更加便利地实现多进程。
 
  
 
@@ -34,13 +34,13 @@ pool = mul.Pool(5)
 rel  = pool.map(f,[1,2,3,4,5,6,7,8,9,10])
 print(rel)
 ```
-我们创建了一个容许5个进程的进程池 (Process Pool) 。Pool运行的每个进程都执行f()函数。我们利用map()方法，将f()函数作用到表的每个元素上。这与built-in的map()函数类似，只是这里用5个进程并行处理。如果进程运行结束后，还有需要处理的元素，那么的进程会被用于重新运行f()函数。除了map()方法外，Pool还有下面的常用方法。
+我们创建了一个容许5个进程的进程池 (Process Pool) 。`Pool`运行的每个进程都执行`f()`函数。我们利用`map()`方法，将`f()`函数作用到表的每个元素上。这与built-in的`map()`函数类似，只是这里用5个进程并行处理。如果进程运行结束后，还有需要处理的元素，那么的进程会被用于重新运行`f()`函数。除了`map()`方法外，`Pool`还有下面的常用方法。
 
-apply_async(func,args)  从进程池中取出一个进程执行func，args为func的参数。它将返回一个AsyncResult的对象，你可以对该对象调用get()方法以获得结果。
+`apply_async(func,args)`：从进程池中取出一个进程执行`func`，`args`为`func`的参数。它将返回一个`AsyncResult`的对象，你可以对该对象调用`get()`方法以获得结果。
 
-close()  进程池不再创建新的进程
+`close()`：进程池不再创建新的进程。
 
-join()   wait进程池中的全部进程。必须对Pool先调用close()方法才能join。
+`join()`：`wait`进程池中的全部进程。必须对`Pool`先调用`close()`方法才能`join`。
 
  
 
@@ -54,13 +54,13 @@ www.iciba.com
 www.cnblogs.com
 www.qq.com
 www.douban.com
-使用包含3个进程的进程池下载文件中网站的首页。(你可以使用subprocess调用wget或者curl等下载工具执行具体的下载任务)
+使用包含3个进程的进程池下载文件中网站的首页。(你可以使用`subprocess`调用`wget`或者`curl`等下载工具执行具体的下载任务)
 
  
 
 ##共享资源
 
-我们在Python多进程初步已经提到，我们应该尽量避免多进程共享资源。多进程共享资源必然会带来进程间相互竞争。而这种竞争又会造成race condition，我们的结果有可能被竞争的不确定性所影响。但如果需要，我们依然可以通过共享内存和Manager对象这么做。
+我们在Python多进程初步已经提到，我们应该尽量避免多进程共享资源。多进程共享资源必然会带来进程间相互竞争。而这种竞争又会造成race condition，我们的结果有可能被竞争的不确定性所影响。但如果需要，我们依然可以通过共享内存和`Manager`对象这么做。
 
  
 
@@ -90,13 +90,13 @@ 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 +119,17 @@ print(x.value)
 print(arr)
 print(l)
 ```
-Manager利用list()方法提供了表的共享方式。实际上你可以利用dict()来共享词典，Lock()来共享threading.Lock(注意，我们共享的是threading.Lock，而不是进程的mutiprocessing.Lock。后者本身已经实现了进程共享)等。 这样Manager就允许我们共享更多样的对象。
+Manager利用`list()`方法提供了表的共享方式。实际上你可以利用`dict()`来共享词典，`Lock()`来共享`threading.Lock`(注意，我们共享的是`threading.Lock`，而不是进程的`mutiprocessing.Lock`。后者本身已经实现了进程共享)等。 这样`Manager`就允许我们共享更多样的对象。
 
  
 
-我们在这里不深入讲解Manager在远程情况下的应用。有机会的话，会在网络应用中进一步探索。
+我们在这里不深入讲解`Manager`在远程情况下的应用。有机会的话，会在网络应用中进一步探索。
 
  
 
 ##总结
 
-Pool
+`Pool`
 
-Shared memory, Manager
+Shared memory, `Manager`
 
diff --git a/content/STL12.md b/content/STL12.md
index 92ed492..ee24c44 100644
--- a/content/STL12.md
+++ b/content/STL12.md
@@ -3,15 +3,15 @@
 
  
 
-我们已经在Python运算中看到Python最基本的数学运算功能。此外，math包补充了更多的函数。当然，如果想要更加高级的数学功能，可以考虑选择标准库之外的numpy和scipy项目，它们不但支持数组和矩阵运算，还有丰富的数学和物理方程可供使用。
+我们已经在Python运算中看到Python最基本的数学运算功能。此外，`math`包补充了更多的函数。当然，如果想要更加高级的数学功能，可以考虑选择标准库之外的`numpy`和`scipy`项目，它们不但支持数组和矩阵运算，还有丰富的数学和物理方程可供使用。
 
-此外，random包可以用来生成随机数。随机数不仅可以用于数学用途，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
+此外，`random`包可以用来生成随机数。随机数不仅可以用于数学用途，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
 
  
 
 ##math包
 
-math包主要处理数学相关的运算。math包定义了两个常数:
+`math`包主要处理数学相关的运算。`math`包定义了两个常数:
 
 math.e   # 自然常数e
 
@@ -19,7 +19,7 @@ math.pi  # 圆周率pi
 
  
 
-此外，math包还有各种运算函数 (下面函数的功能可以参考数学手册)：
+此外，`math`包还有各种运算函数 (下面函数的功能可以参考数学手册)：
 
 math.ceil(x)       # 对x向上取整，比如x=1.2，返回2
 
@@ -33,21 +33,21 @@ math.sqrt(x)       # 平方根
 
  
 
-三角函数: math.sin(x), math.cos(x), math.tan(x), math.asin(x), math.acos(x), math.atan(x)
+三角函数: `math.sin(x)`, `math.cos(x)`, `math.tan(x)`, `math.asin(x)`, `math.acos(x)`, `math.atan(x)`
 
-这些函数都接收一个弧度(radian)为单位的x作为参数。
+这些函数都接收一个弧度(radian)为单位的`x`作为参数。
 
  
 
-角度和弧度互换: math.degrees(x), math.radians(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)`
 
  
 
@@ -57,7 +57,7 @@ math.sqrt(x)       # 平方根
 
 random.seed(x)
 
-来改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
+来改变随机数生成器的种子`seed`。如果你不了解其原理，你不必特别去设定`seed`，Python会帮你选择`seed`。
 
  
 
@@ -93,7 +93,7 @@ http://docs.python.org/library/random.html
 
  
 
-假设我们有一群人参加舞蹈比赛，为了公平起见，我们要随机排列他们的出场顺序。我们下面利用random包实现：
+假设我们有一群人参加舞蹈比赛，为了公平起见，我们要随机排列他们的出场顺序。我们下面利用`random`包实现：
 
 import random
 all_people = ['Tom', 'Vivian', 'Paul', 'Liya', 'Manu', 'Daniel', 'Shawn']
@@ -114,6 +114,6 @@ for i,name in enumerate(all_people):
 
 ##总结
 
-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()`
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..0b45412 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"	
@@ -3,17 +3,17 @@ Python标准库13 循环器 (itertools)
 
  
 
-在循环对象和函数对象中，我们了解了循环器(iterator)的功能。循环器是对象的容器，包含有多个对象。通过调用循环器的next()方法 (__next__()方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。
+在循环对象和函数对象中，我们了解了循环器(iterator)的功能。循环器是对象的容器，包含有多个对象。通过调用循环器的`next()`方法 (`__next__()`方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出`StopIteration`错误。
 
  
 
-在for i in iterator结构中，循环器每次返回的对象将赋予给i，直到循环结束。使用iter()内置函数，我们可以将诸如表、字典等容器变为循环器。比如
+在`for i in iterator`结构中，循环器每次返回的对象将赋予给`i`，直到循环结束。使用`iter()`内置函数，我们可以将诸如表、字典等容器变为循环器。比如
 ```python
 for i in iter([2, 4, 5, 6]):
     print(i)
 ```
 
-标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。
+标准库中的`itertools`包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。
 
 # import the tools
 from itertools import *
@@ -29,7 +29,7 @@ repeat(1.2)     #重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...
 
  
 
-repeat也可以有一个次数限制:
+#repeat也可以有一个次数限制:
 
 repeat(10, 5)   #重复10，共重复5次
 
@@ -37,9 +37,9 @@ repeat(10, 5)   #重复10，共重复5次
 
 ##函数式工具
 
-函数式编程是将函数本身作为处理对象的编程范式。在Python中，函数也是对象，因此可以轻松的进行一些函数式的处理，比如map(), filter(), reduce()函数。
+函数式编程是将函数本身作为处理对象的编程范式。在Python中，函数也是对象，因此可以轻松的进行一些函数式的处理，比如`map()`, `filter()`, `reduce()`函数。
 
-itertools包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。
+`itertools`包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。
 
  
 
@@ -52,39 +52,39 @@ 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()`依次作用于后面两个列表的每个元素，并收集函数结果，组成返回的循环器。
 
 此外，还可以用下面的函数:
 
 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
+与上面类似，但收集返回`False`的元素。`2`, `3`, `5`
 
  
 
 takewhile(lambda x: x < 5, [1, 3, 6, 7, 1])
 
-当函数返回True时，收集元素到循环器。一旦函数返回False，则停止。1, 3
+当函数返回`True`时，收集元素到循环器。一旦函数返回`False`，则停止。`1`, `3`
 
  
 
 dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])
 
-当函数返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器。6, 7, 1
+当函数返回`False`时，跳过元素。一旦函数返回`True`，则开始收集剩下的所有元素到循环器。`6`, `7`, `1`
 
  
 
@@ -106,25 +106,25 @@ for m, n in product('abc', [1, 2]):
 
 permutations('abc', 2)   # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。
 
-注意，上面的组合分顺序，即ab, ba都返回。
+注意，上面的组合分顺序，即`'ab'`, `'ba'`都返回。
 
  
 
 combinations('abc', 2)   # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。
 
-注意，上面的组合不分顺序，即ab, ba的话，只返回一个ab。
+注意，上面的组合不分顺序，即`'ab'`, `'ba'`的话，只返回一个`'ab'`。
 
  
 
-combinations_with_replacement('abc', 2) # 与上面类似，但允许两次选出的元素重复。即多了aa, bb, cc
+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,7 +142,7 @@ for m, n in groupby(friends, key = height_class):
     print(m)
     print(list(n))
 ```
-注意，groupby的功能类似于UNIX中的uniq命令。分组之前需要使用sorted()对原循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。
+注意，groupby的功能类似于UNIX中的`uniq`命令。分组之前需要使用`sorted()`对原循环器的元素，根据`key`函数进行排序，让同组元素先在位置上靠拢。
 
  
 
@@ -158,4 +158,4 @@ izip()                          # 类似于zip()函数，只是返回的是一
 
 ##总结
 
-itertools的工具都可以自行实现。itertools只是提供了更加成形的解决方案。
+`itertools`的工具都可以自行实现。`itertools`只是提供了更加成形的解决方案。

From 8a36ecd357fee84602f4eb49554329b3f8af7b38 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Tue, 24 Jun 2014 00:16:40 +0800
Subject: [PATCH 08/13] =?UTF-8?q?07.md~09.md=EF=BC=9A=E6=95=B4=E4=BD=93?=
 =?UTF-8?q?=E8=B0=83=E6=95=B4=E6=A0=BC=E5=BC=8F=EF=BC=8C=E5=A6=82=E5=88=A0?=
 =?UTF-8?q?=E9=99=A4=E5=A4=9A=E4=BD=99=E7=A9=BA=E8=A1=8C=E3=80=81=E6=95=B4?=
 =?UTF-8?q?=E7=90=86=E4=BB=A3=E7=A0=81=E5=9D=97=E3=80=81=E4=BF=AE=E6=AD=A3?=
 =?UTF-8?q?=E6=A0=87=E7=82=B9=E7=AC=A6=E5=8F=B7=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/07.md | 75 +++++++++++++++++++++++++++------------------------
 content/08.md | 58 ++++++++++++++++++++++-----------------
 content/09.md | 45 ++++++++++++++++++++-----------
 content/10.md | 73 ++++++++++++++++++++++++-------------------------
 4 files changed, 141 insertions(+), 110 deletions(-)

diff --git a/content/07.md b/content/07.md
index aaae497..6ed9976 100644
--- a/content/07.md
+++ b/content/07.md
@@ -6,53 +6,55 @@
 
 ##函数的定义
 
-首先，我们要定义一个函数, 以说明这个函数的功能。
+首先，我们要定义一个函数，以说明这个函数的功能。
+
 ```python
-def square_sum(a,b):
-    c = a**2 + b**2
+def square_sum(a, b):
+    c = a ** 2 + b ** 2
     return c
 ```
+
 这个函数的功能是求两个数的平方和。
 
-首先，`def`，这个关键字通知`python`：我在定义一个函数。`square_sum`是函数名。
+首先，`def`这个关键字通知`python`：我在定义一个函数。`square_sum`是函数名。
 
-括号中的`a`, `b`是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。
+括号中的`a`、`b`是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）。
 
 我们已经在循环和选择中见过冒号和缩进来表示的隶属关系。
 
-c = a**2 + b**2        # 这一句是函数内部进行的运算
-
+```python
+c = a ** 2 + b ** 2    # 这一句是函数内部进行的运算。
 return c               # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。
+```
 
-`return`可以返回多个值，以逗号分隔。相当于返回一个`tuple`(定值表)。
-
-return a,b,c          # 相当于 return (a,b,c)
+`return`可以返回多个值，以逗号分隔。相当于返回一个`tuple`（定值表）。
 
- 
+```python
+return a, b, c         # 相当于 return (a, b, c)
+```
 
-在Python中，当程序执行到`return`的时候，程序将停止执行函数内余下的语句。`return`并不是必须的，当没有`return`, 或者`return`后面没有返回值时，函数将自动返回`None`。`None`是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。`None`多用于关键字参数传递的默认值。
+在Python中，当程序执行到`return`的时候，程序将停止执行函数内余下的语句。`return`并不是必须的，当没有`return`，或者`return`后面没有返回值时，函数将自动返回`None`。
 
- 
+`None`是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。`None`多用于关键字参数传递的默认值。
 
 ##函数调用和参数传递
 
-定义过函数后，就可以在后面程序中使用这一函数
+定义过函数后，就可以在后面程序中使用这一函数：
+
 ```python
-print square_sum(3,4)
+print square_sum(3, 4)
 ```
-Python通过位置，知道3对应的是函数定义中的第一个参数`a`， `4`对应第二个参数`b`，然后把参数传递给函数`square_sum`。
 
-（Python有丰富的参数传递方式，还有关键字传递、表传递、字典传递等，基础教程将只涉及位置传递）
+Python通过位置，知道`3`对应的是函数定义中的第一个参数`a`，`4`对应第二个参数`b`，然后把参数传递给函数`square_sum`。
 
-函数经过运算，返回值`25`, 这个`25`被`print`打印出来。
+（Python有丰富的参数传递方式，还有关键字传递、表传递、字典传递等，基础教程将只涉及位置传递。）
 
- 
+函数经过运算，返回值`25`，这个`25`被`print`打印出来。
 
-我们再看下面两个例子
+我们再看下面两个例子：
 
 ```python
 a = 1
-
 def change_integer(a):
     a = a + 1
     return a
@@ -60,9 +62,9 @@ def change_integer(a):
 print change_integer(a)
 print a
 
-#===(Python中 "#" 后面跟的内容是注释，不执行 )
+# (Python中 "#" 后面跟的内容是注释，不执行。)
 
-b = [1,2,3]
+b = [1, 2, 3]
 
 def change_list(b):
     b[0] = b[0] + 1
@@ -71,34 +73,37 @@ def change_list(b):
 print change_list(b)
 print b
 ```
+
 第一个例子，我们将一个整数变量传递给函数，函数对它进行操作，但原整数变量`a`不发生变化。
 
 第二个例子，我们将一个表传递给函数，函数进行操作，原来的表`b`发生变化。
 
-对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为值传递）
+对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。
+
+（我们称此为值传递）
 
-但是对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。 （我们称此为指针传递）
+但是对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。 
 
- 
+（我们称此为指针传递）
 
 ##总结
+
 ```python
-def function_name(a,b,c):
+def function_name(a, b, c):
     statement
-    return something  # return不是必须的
-```    
+    return something  # return不是必须的。
+```
+
 函数的目的： 提高程序的重复可用性。
 
-`return`     `None`
+`return`、`None`
 
 通过位置，传递参数。
 
-基本数据类型的参数：值传递
-
-表作为参数：指针传递
+基本数据类型的参数：值传递。
 
- 
+表作为参数：指针传递。
 
 练习:
 
-写一个判断闰年的函数，参数为年、月、日。若是是闰年，返回`True`
+写一个判断闰年的函数，参数为年、月、日。若是是闰年，返回`True`。
diff --git a/content/08.md b/content/08.md
index 94fb6ad..7ab7471 100644
--- a/content/08.md
+++ b/content/08.md
@@ -1,6 +1,6 @@
 #Python基础08 面向对象的基本概念
 
-Python使用类(class)和对象(object)，进行面向对象（object-oriented programming，简称OOP）的编程。
+Python使用类（class）和对象（object），进行面向对象（object-oriented programming，简称OOP）的编程。
 
 面向对象的最主要目的是提高程序的重复使用性。我们这么早切入面向对象编程的原因是，Python的整个概念是基于对象的。了解OOP是进一步学习Python的关键。
 
@@ -12,26 +12,36 @@ Python使用类(class)和对象(object)，进行面向对象（object-oriented p
 
 面向对象就是模拟了以上人类认知过程。在Python语言，为了听起来酷，我们把上面说的“东西”称为对象（object）。
 
-先定义鸟类
+先定义鸟类：
+
 ```python
 class Bird(object):
     have_feather = True
     way_of_reproduction  = 'egg'
 ```
-我们定义了一个类别（class），就是鸟（`Bird`）。在隶属于这个类比的语句块中，我们定义了两个变量，一个是有羽毛（`have_feather`），一个是生殖方式（`way_of_reproduction`）,这两个变量对应我们刚才说的属性（attribute）。我们暂时先不说明括号以及其中的内容，记为问题1。
+
+我们定义了一个类别（class），就是鸟（`Bird`）。
+
+在隶属于这个类比的语句块中，我们定义了两个变量，一个是有羽毛（`have_feather`），一个是生殖方式（`way_of_reproduction`），这两个变量对应我们刚才说的属性（attribute）。
+
+我们暂时先不说明括号以及其中的内容，记为问题1。
 
 假设我养了一只小鸡，叫`summer`。它是个对象，且属于鸟类。使用前面定义的类：
+
 ```python
 summer = Bird()
 print summer.way_of_reproduction
 ```
+
 通过第一句创建对象，并说明`summer`是类别鸟中的一个对象，`summer`就有了鸟的类属性，对属性的引用是通过 对象.属性（`object.attribute`） 的形式实现的。
 
 可怜的`summer`，你就是个有毛产的蛋货，好不精致。
 
 ##动作
 
-日常认知中，我们在通过属性识别类别的时候，有时根据这个东西能做什么事情来区分类别。比如说，鸟会移动。这样，鸟就和房屋的类别区分开了。这些动作会带来一定的结果，比如移动导致位置的变化。
+日常认知中，我们在通过属性识别类别的时候，有时根据这个东西能做什么事情来区分类别。
+
+比如说，鸟会移动。这样，鸟就和房屋的类别区分开了。这些动作会带来一定的结果，比如移动导致位置的变化。
 
 这样的一些“行为”属性为方法（method）。Python中通过在类的内部定义函数，来说明方法。
 
@@ -40,19 +50,20 @@ class Bird(object):
     have_feather = True
     way_of_reproduction = 'egg'
     def move(self, dx, dy):
-        position = [0,0]
+        position = [0, 0]
         position[0] = position[0] + dx
         position[1] = position[1] + dy
         return position
 
 summer = Bird()
-print 'after move:',summer.move(5,8)
+print 'after move:', summer.move(5, 8)
 ```
-我们重新定义了鸟这个类别。鸟新增一个方法属性，就是表示移动的方法`move`。（我承认这个方法很傻，你可以在看过下一讲之后定义个有趣些的方法）
+
+我们重新定义了鸟这个类别。鸟新增一个方法属性，就是表示移动的方法`move`。（我承认这个方法很傻，你可以在看过下一讲之后定义个有趣些的方法。）
 
 （它的参数中有一个`self`，它是为了方便我们引用对象自身。方法的第一个参数必须是`self`，无论是否用到。有关`self`的内容会在下一讲展开）
 
-另外两个参数，`dx`, `dy`表示在`x`、`y`两个方向移动的距离。`move`方法会最终返回运算过的`position`。
+另外两个参数，`dx`、`dy`表示在`x`、`y`两个方向移动的距离。`move`方法会最终返回运算过的`position`。
 
 在最后调用`move`方法的时候，我们只传递了`dx`和`dy`两个参数，不需要传递`self`参数（因为`self`只是为了内部使用）。
 
@@ -64,7 +75,7 @@ print 'after move:',summer.move(5,8)
 
 比如说，鸟类可以进一步分成鸡，大雁，黄鹂。
 
-在OOP中，我们通过继承(inheritance)来表达上述概念。
+在OOP中，我们通过继承（inheritance）来表达上述概念。
 
 ```python
 class Chicken(Bird):
@@ -77,38 +88,37 @@ class Oriole(Bird):
 
 summer = Chicken()
 print summer.have_feather
-print summer.move(5,8)
+print summer.move(5, 8)
 ```
-新定义的鸡（`Chicken`）类的，增加了两个属性：移动方式（`way_of_move`），可能在KFC找到（`possible_in_KFC`）
 
-在类定义时，括号里为了`Bird`。这说明，`Chicken`是属于鸟类（`Bird`）的一个子类，即`Chicken`继承自`Bird`。自然而然，`Bird`就是`Chicken`的父类。`Chicken`将享有`Bird`的所有属性。尽管我只声明了`summer`是鸡类，它通过继承享有了父类的属性（无论是变量属性`have_feather`还是方法属性`move`）
+新定义的鸡（`Chicken`）类的，增加了两个属性：移动方式（`way_of_move`），可能在KFC找到（`possible_in_KFC`）。
 
- 
+在类定义时，括号里为了`Bird`。这说明，`Chicken`是属于鸟类（`Bird`）的一个子类，即`Chicken`继承自`Bird`。自然，`Bird`就是`Chicken`的父类。`Chicken`将享有`Bird`的所有属性。
 
-新定义的黄鹂(`Oriole`)类，同样继承自鸟类。在创建一个黄鹂对象时，该对象自动拥有鸟类的属性。
+尽管我只声明了`summer`是鸡类，它通过继承享有了父类的属性。（无论是变量属性`have_feather`还是方法属性`move`）
 
- 
+新定义的黄鹂（`Oriole`）类，同样继承自鸟类。在创建一个黄鹂对象时，该对象自动拥有鸟类的属性。 
 
-通过继承制度，我们可以减少程序中的重复信息和重复语句。如果我们分别定义两个类，而不继承自鸟类，就必须把鸟类的属性分别输入到鸡类和黄鹂类的定义中。整个过程会变得繁琐，因此，面向对象提高了程序的可重复使用性。
+通过继承制度，我们可以减少程序中的重复信息和重复语句。
 
-（回到问题1, 括号中的`object`，当括号中为`object`时，说明这个类没有父类（到头了））
+如果我们分别定义两个类，而不继承自鸟类，就必须把鸟类的属性分别输入到鸡类和黄鹂类的定义中。整个过程会变得繁琐，因此，面向对象提高了程序的可重复使用性。
 
- 
+（回到问题1：括号中的`object`，当括号中为`object`时，说明这个类没有父类（到头了））
 
-将各种各样的东西分类，从而了解世界，从人类祖先开始，我们就在练习了这个认知过程，面向对象是符合人类思维习惯的。所谓面向过程，也就是执行完一个语句再执行下一个，更多的是机器思维。通过面向对象的编程，我们可以更方便的表达思维中的复杂想法。
+将各种各样的东西分类，从而了解世界。从人类祖先开始，我们就在练习了这个认知过程，面向对象是符合人类思维习惯的。而所谓面向过程，也就是执行完一个语句再执行下一个，更多的是机器思维。
 
- 
+通过面向对象的编程，我们可以更方便的表达思维中的复杂想法。
 
 ##总结
 
-将东西根据属性归类 ( 将object归为class )
+将东西根据属性归类（将object归为class）
 
-方法是一种属性，表示动作
+方法是一种属性，表示动作。
 
 用继承来说明父类-子类关系。子类自动具有父类的所有属性。
 
 `self`代表了根据类定义而创建的对象。
 
-建立对一个对象： 对象名 = 类名()
+建立对一个对象：对象名 = 类名()
 
-引用对象的属性： `object.attribute`
+引用对象的属性：`object.attribute`
\ No newline at end of file
diff --git a/content/09.md b/content/09.md
index 90d1811..5d18d0d 100644
--- a/content/09.md
+++ b/content/09.md
@@ -9,8 +9,10 @@
 ```python
 class Human(object):
     laugh = 'hahahaha'
+
     def show_laugh(self):
         print self.laugh
+    
     def laugh_100th(self):
         for i in range(100):
             self.show_laugh()
@@ -18,6 +20,7 @@ class Human(object):
 li_lei = Human()          
 li_lei.laugh_100th()
 ```
+
 这里有一个类属性`laugh`。在方法`show_laugh()`中，通过`self.laugh`，调用了该属性的值。
 
 还可以用相同的方式调用其它方法。方法`show_laugh()`，在方法`laugh_100th()`中被调用。
@@ -26,38 +29,46 @@ li_lei.laugh_100th()
 
 ##__init__()方法
 
-`__init__()`是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。
+`__init__()`是一个特殊方法（special method）。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。
 
 如果你在类中定义了`__init__()`这个方法，创建对象时，Python会自动调用这个方法。这个过程也叫初始化。
+
 ```python
 class happyBird(Bird):
     def __init__(self,more_words):
-        print 'We are happy birds.',more_words
+        print 'We are happy birds.', more_words
 
 summer = happyBird('Happy,Happy!')
 ```
-这里继承了`Bird`类，它的定义见上一讲。
 
- 
+这里继承了`Bird`类，它的定义见上一讲。
 
 屏幕上打印：
-> We are happy birds.Happy,Happy!
 
-我们看到，尽管我们只是创建了`summer`对象，但`__init__()`方法被自动调用了。最后一行的语句(`summer = happyBird...`)先创建了对象，然后执行：
+```quote
+We are happy birds.Happy,Happy!
+```
+
+我们看到，尽管我们只是创建了`summer`对象，但`__init__()`方法被自动调用了。最后一行的语句（`summer = happyBird...`）先创建了对象，然后执行：
+
 ```python
 summer.__init__(more_words)
 ```
 `'Happy,Happy!'` 被传递给了`__init__()`的参数`more_words`
 
- 
-
 ##对象的性质
 
-我们讲到了许多属性，但这些属性是类的属性。所有属于该类的对象会共享这些属性。比如说，鸟都有羽毛，鸡都不会飞。
+我们讲到了许多属性，但这些属性是类的属性。所有属于该类的对象会共享这些属性。比如说：鸟都有羽毛，鸡都不会飞。
+
+在一些情况下，我们定义对象的性质，用于记录该对象的特别信息。比如说，人这个类。性别是某个人的一个性质，不是所有的人类都是男，或者都是女。这个性质的值随着对象的不同而不同。
+
+李雷是人类的一个对象，性别是男；韩美美也是人类的一个对象，性别是女。
 
-在一些情况下，我们定义对象的性质，用于记录该对象的特别信息。比如说，人这个类。性别是某个人的一个性质，不是所有的人类都是男，或者都是女。这个性质的值随着对象的不同而不同。李雷是人类的一个对象，性别是男；韩美美也是人类的一个对象，性别是女。
+当定义类的方法时，必须要传递一个`self`的参数。这个参数指代的就是类的一个对象。我们可以通过操纵`self`，来修改某个对象的性质。比如：用类来新建一个对象，即下面例子中的`li_lei`。那么`li_lei`就被`self`表示。
 
-当定义类的方法时，必须要传递一个`self`的参数。这个参数指代的就是类的一个对象。我们可以通过操纵`self`，来修改某个对象的性质。比如用类来新建一个对象，即下面例子中的`li_lei`, 那么`li_lei`就被`self`表示。我们通过赋值给`self.attribute`，给`li_lei`这一对象增加一些性质，比如说性别的男女。`self`会传递给各个方法。在方法内部，可以通过引用`self.attribute`，查询或修改对象的性质。
+我们通过赋值给`self.attribute`，给`li_lei`这一对象增加一些性质。比如说：性别的男女。
+
+`self`会传递给各个方法。在方法内部，可以通过引用`self.attribute`，查询或修改对象的性质。
 
 这样，在类属性的之外，又给每个对象增添了各自特色的性质，从而能描述多样的世界。
 
@@ -65,6 +76,7 @@ summer.__init__(more_words)
 class Human(object):
     def __init__(self, input_gender):
         self.gender = input_gender
+        
     def printGender(self):
         print self.gender
 
@@ -72,16 +84,19 @@ li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的
 print li_lei.gender
 li_lei.printGender()
 ```
+
 在初始化中，将参数`input_gender`，赋值给对象的性质，即`self.gender`。
 
-`li_lei`拥有了对象性质`gender`。`gender`不是一个类属性。Python在建立了`li_lei`这一对象之后，使用`li_lei.gender`这一对象性质，专门储存属于对象`li_lei`的特有信息。
+`li_lei`拥有了对象性质`gender`。
+
+`gender`不是一个类属性。Python在建立了`li_lei`这一对象之后，使用`li_lei.gender`这一对象性质，专门储存属于对象`li_lei`的特有信息。
 
 对象的性质也可以被其它方法调用，调用方法与类属性的调用相似，正如在`printGender()`方法中的调用。
 
 ##总结
 
-通过`self`调用类属性
+通过`self`调用类属性。
 
-`__init__()`: 在建立对象时自动执行
+`__init__()`：在建立对象时自动执行。
 
-类属性和对象的性质的区别
+类属性和对象的性质的区别。
diff --git a/content/10.md b/content/10.md
index 9029974..04c8159 100644
--- a/content/10.md
+++ b/content/10.md
@@ -4,52 +4,48 @@
 
 我们之前提到一句话，"Everything is Object". 那么我们就深入体验一下这句话。
 
- 
+需要先要介绍两个内置函数，`dir()`和`help()`。
 
-需要先要介绍两个内置函数，`dir()`和`help()`
-
-`dir()`用来查询一个类或者对象所有属性。你可以尝试一下
+`dir()`用来查询一个类或者对象所有属性：
 
 ```python
->>>print dir(list)
+print dir(list)
 ```
 
-`help()`用来查询的说明文档。你可以尝试一下
+`help()`用来查询的说明文档：
 
 ```python
->>>print help(list)
+print help(list)
 ```
 
-(`list`是Python内置的一个类，对应于我们之前讲解过的列表)
-
+(`list`是Python内置的一个类，对应于我们之前讲解过的列表。)
 
 ##list是一个类
 
 在上面以及看到，表是Python已经定义好的一个类。当我们新建一个表时，比如：
 
 ```python
->>>nl = [1,2,5,3,5]
+nl = [1, 2, 5, 3, 5]
 ```
 
 实际上，`nl`是类`list`的一个对象。
 
-实验一些`list`的方法：
+一些`list`的方法：
 
 ```python
->>>print nl.count(5)       # 计数，看总共有多少个5
->>>print nl.index(3)       # 查询 nl 的第一个3的下标
->>>nl.append(6)            # 在 nl 的最后增添一个新元素6
->>>nl.sort()               # 对nl的元素排序
->>>print nl.pop()          # 从nl中去除最后一个元素，并将该元素返回。
->>>nl.remove(2)            # 从nl中去除第一个2
->>>nl.insert(0,9)          # 在下标为0的位置插入9
+print nl.count(5)       # 计数，看总共有多少个5
+print nl.index(3)       # 查询 nl 的第一个3的下标
+nl.append(6)            # 在 nl 的最后增添一个新元素6
+nl.sort()               # 对nl的元素排序
+print nl.pop()          # 从nl中去除最后一个元素，并将该元素返回。
+nl.remove(2)            # 从nl中去除第一个2
+nl.insert(0, 9)         # 在下标为0的位置插入9
 ```
+
 总之，`list`是一个类。每个列表都属于该类。
 
 Python补充中有`list`常用方法的附录。
 
- 
-
 ##运算符是特殊方法
 
 使用`dir(list)`的时候，能看到一个属性，是`__add__()`。从形式上看是特殊方法（下划线，下划线）。它特殊在哪呢？
@@ -57,56 +53,61 @@ Python补充中有`list`常用方法的附录。
 这个方法定义了`+`运算符对于`list`对象的意义，两个`list`的对象相加时，会进行的操作。
 
 ```python
->>>print [1,2,3] + [5,6,9]
+print [1, 2, 3] + [5, 6, 9]
 ```
- 
 
 运算符，比如`+`, `-`, `>`, `<`, 以及下标引用`[start:end]`等等，从根本上都是定义在类内部的方法。
 
- 
+尝试：
 
-尝试一下
 ```python
->>>print [1,2,3] - [3,4]
+>>>print [1, 2, 3] - [3, 4]
 ```
 
-会有错误信息，说明该运算符`-`没有定义。现在我们继承`list`类，添加对`-`的定义
+会有错误信息，说明该运算符`-`没有定义。现在我们继承`list`类，添加对`-`的定义：
 
 ```python
 class superList(list):
     def __sub__(self, b):
         a = self[:]     # 这里，self是supeList的对象。由于superList继承于list，它可以利用和list[:]相同的引用方法来表示整个对象。
-        b = b[:]        
+        b = b[:]
+
         while len(b) > 0:
             element_b = b.pop()
             if element_b in a:
                 a.remove(element_b)
+
         return a
 
-print superList([1,2,3]) - superList([3,4])
+print superList([1, 2, 3]) - superList([3, 4])
 ```
-内置函数`len()`用来返回`list`所包含的元素的总数。内置函数`__sub__()`定义了`-`的操作：从第一个表中去掉第二个表中出现的元素。如果`__sub__()`已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。
+
+内置函数`len()`用来返回`list`所包含的元素的总数。内置函数`__sub__()`定义了`-`的操作：从第一个表中去掉第二个表中出现的元素。
+
+如果`__sub__()`已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。
 
 （教程最后也会给出一个特殊方法的清单）
 
-定义运算符对于复杂的对象非常有用。举例来说，人类有多个属性，比如姓名，年龄和身高。我们可以把人类的比较（`>`, `<`, `=`）定义成只看年龄。这样就可以根据自己的目的，将原本不存在的运算增加在对象上了。
+定义运算符对于复杂的对象非常有用。举例来说，人类有多个属性，如姓名、年龄和身高。
+
+我们可以把人类的比较（`>`, `<`, `=`）定义成只看年龄。这样就可以根据自己的目的，将原本不存在的运算增加在对象上了。
 
 ##下一步
 
-希望你已经对Python有了一个基本了解。你可能跃跃欲试，要写一些程序练习一下。这会对你很有好处。
+希望你已经对Python有了一个基本了解。你可能跃跃欲试，要写一些程序练习一下。这会对你很有好处。但是，Python的强大很大一部分原因在于，它提供有很多已经写好的，可以现成用的对象。我们已经看到了内置的比如说`list`，还有`tuple`等等。它们用起来很方便。
 
-但是，Python的强大很大一部分原因在于，它提供有很多已经写好的，可以现成用的对象。我们已经看到了内置的比如说`list`，还有`tuple`等等。它们用起来很方便。在Python的标准库里，还有大量可以用于操作系统互动，Internet开发，多线程，文本处理的对象。而在所有的这些的这些的基础上，又有很多外部的库包，定义了更丰富的对象，比如`numpy`, `tkinter`, `django`等用于科学计算，GUI开发，web开发的库，定义了各种各样的对象。对于一般用户来说，使用这些库，要比自己去从头开始容易得多。我们要开始攀登巨人的肩膀了。
+在Python的标准库里，还有大量可以用于操作系统互动，Internet开发，多线程，文本处理的对象。而在所有的这些的这些的基础上，又有很多外部的库包，定义了更丰富的对象，比如`numpy`, `tkinter`, `django`等用于科学计算；GUI开发，web开发的库，定义了各种各样的对象。
+
+对于一般用户来说，使用这些库，要比自己去从头开始容易得多。我们要开始攀登巨人的肩膀了。
 
 谢谢你的关注，
 
 欢迎来到Python的世界。
 
- 
-
 ##总结
 
-`len()` `dir()` `help()`
+`len()`、`dir()`、`help()`
 
 数据结构`list`(列表)是一个类。
 
-运算符是方法
+运算符是方法。
\ No newline at end of file

From 81f88080e88fb6dca40d064489df63422737a9c1 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Tue, 24 Jun 2014 23:42:27 +0800
Subject: [PATCH 09/13] =?UTF-8?q?=E8=A2=AB=E8=A7=A3=E6=94=BE=E7=9A=84?=
 =?UTF-8?q?=E5=A7=9C=E6=88=88*.md=EF=BC=9A=E6=95=B4=E4=BD=93=E8=B0=83?=
 =?UTF-8?q?=E6=95=B4=E6=A0=BC=E5=BC=8F=EF=BC=9A=E5=88=A0=E9=99=A4=E5=A4=9A?=
 =?UTF-8?q?=E4=BD=99=E7=A9=BA=E8=A1=8C=E3=80=81=E6=95=B4=E7=90=86=E4=BB=A3?=
 =?UTF-8?q?=E7=A0=81=E5=9D=97=E3=80=81=E4=BF=AE=E6=AD=A3=E6=A0=87=E7=82=B9?=
 =?UTF-8?q?=E7=AC=A6=E5=8F=B7=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...35\350\257\225\345\244\251\346\266\257.md" |  97 ++++++--------
 ...04\345\233\255\347\226\221\344\272\221.md" | 111 +++++++---------
 ...00\350\260\223\344\274\212\344\272\272.md" | 108 ++++++----------
 ...04\345\217\226\346\211\200\351\234\200.md" | 122 ++++++------------
 ...21\351\235\242\347\256\241\345\256\266.md" | 104 ++++-----------
 ...07\344\275\234\347\234\237\346\227\266.md" | 110 ++++++----------
 ...54\344\270\215\345\201\234\350\271\204.md" |  61 +++------
 7 files changed, 250 insertions(+), 463 deletions(-)

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 06972d2..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`，启动服务器：
+
 ```python
 python manage.py runserver 8000
 ```
-上面的`8000`为端口号。如果不说明，那么端口号默认为`8000`。
 
- 
+上面的`8000`为端口号。如果不说明，那么端口号默认为`8000`。
 
 打开浏览器，访问`http://127.0.0.1:8000`，可以看到服务器已经在运行：
 
-
-
 虽然有一个能跑的服务器，但什么内容都没有。
 
- 
-
 “赏金？猎人？” 姜戈满脸困惑。
 
- 
-
 ##第一个网页
 
-在http协议中可以看到，网络服务器是“请求-回应”的工作模式。客户向URL发送请求，服务器根据请求，开动后厨，并最终为客人上菜。Django采用的MVC结构，即点单、厨房、储藏室分离。
+在http协议中可以看到，网络服务器是“请求-回应”的工作模式。客户向URL发送请求，服务器根据请求，开动后厨，并最终为客人上菜。
 
- 
+Django采用的MVC结构，即点单、厨房、储藏室分离。
 
 我们需要一个指挥员，将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`函数:
+用以处理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("<p>世界好</p>")
 ```    
-第一行说明字符编码为`utf-8`，为下面使用中文做准备。`first_page`函数的功能，是返回http回复，即这里的`<p>世界好</p>`。`first_page`有一个参数`request`，该参数包含有请求的具体信息，比如请求的类型等，这里并没有用到。
 
- 
+第一行说明字符编码为`utf-8`，为下面使用中文做准备。
 
+`first_page`函数的功能，是返回http回复，即这里的`<p>世界好</p>`。`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`的文件夹。
 
-```python
+```quote
 mysite/
 ├── manage.py
 ├── mysite
@@ -185,22 +172,17 @@ INSTALLED_APPS = (
     'west',
 )
 ```
-可以看到，除了新增加的`west`，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。
 
- 
+可以看到，除了新增加的`west`，Django已经默认加载了一些功能性的app，比如用户验证、会话管理、显示静态文件等。我们将在以后讲解它们的用途。
 
 姜戈看到曾经的工头们，眼中充满怒火。
 
- 
-
 ##增加APP页面
 
 我们下面为APP增加首页。我们之前是在`mysite/urls.py`中设置的URL访问对象。依然采用类似的方式设置。
 
 另一方面，为了去耦合，实现模块化，我们应该在`west/urls.py`中设置URL访问对象。具体如下：
 
- 
-
 首先，修改`mysite/urls.py`：
 
 ```python
@@ -219,11 +201,11 @@ urlpatterns = patterns('',
     url(r'^west/', include('west.urls')),
 )
 ```
-注意新增加的最后一行。这里，我们提醒指挥员，对于`west/`的访问，要参考`west/urls.py`。
 
- 
+注意新增加的最后一行。这里，我们提醒指挥员，对于`west/`的访问，要参考`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`函数。
 
- 
+最后，在`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("<p>西餐</p>")
 ```
-访问`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 64b1ebb..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`中，我们创建一个只有一列的表，即只有一个属性的类：
+
 ```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__()`方法，实现相同的功能。
 
- 
-
 命令Django同步数据库。Django根据`models.py`中描述的数据模型，在MySQL中真正的创建各个关系表：
-```python
+
+```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("<p>" + ' '.join(staff_str) + "</p>")
 ```
-可以看到，我们从`west.models`中引入了`Character`类。通过操作该类，我们可以读取表格中的记录
 
- 
+可以看到，我们从`west.models`中引入了`Character`类。通过操作该类，我们可以读取表格中的记录。
 
 为了让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 a7f5ce9..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,49 +1,44 @@
 #被解放的姜戈03 所谓伊人
 
-
- 
-
 在之前的程序中，我们直接生成一个字符串，作为http回复，返回给客户端。这一过程中使用了`django.http.HttpResponse()`。
 
 在这样的一种回复生成过程中，我们实际上将数据和视图的格式混合了到上面的字符串中。看似方便，却为我们的管理带来困难。想像一个成熟的网站，其显示格式会有许多重复的地方。如果可以把数据和视图格式分离，就可以重复使用同一视图格式了。
 
 Django中自带的模板系统，可以将视图格式分离出来，作为模板使用。这样，不但视图可以容易修改，程序也会显得美观大方。
 
-
-
 “她是我心中最美的人”，姜戈对德国人说。
 
- 
-
 ##模板初体验
 
-我们拿一个独立的`templay.html`文件作为模板。它放在`templates/west/`文件夹下。文件系统的结构现在是:
+我们拿一个独立的`templay.html`文件作为模板。它放在`templates/west/`文件夹下。文件系统的结构现在是：
 
+```quote
 mysite/
 ├── mysite
 ├── templates
 │   └── west
 └── west
- 
+```
 
 `templay.html`文件的内容是：
 
+```html
 <h1>{{ label }}</h1>
-可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即`<h1>`标签，则已经标明在该模板文件中。
+```
 
- 
+可以看到，这个文件中，有一个奇怪的双括号包起来的陌生人。这就是我们未来数据要出现的地方。而相关的格式控制，即`<h1>`标签，则已经标明在该模板文件中。
 
-我们需要向Django说明模板文件的搜索路径，修改`mysite/settings.py`，添加:
+我们需要向Django说明模板文件的搜索路径，修改`mysite/settings.py`，添加：
 
+```python
 # Template dir
 TEMPLATE_DIRS = (
     os.path.join(BASE_DIR, 'templates/west/'),
 )
+```
 
 如果还有其它的路径用于存放模板，可以增加该元组中的元素，以便Django可以找到需要的模板。
 
- 
-
 我们现在修改`west/views.py`，增加一个新的对象，用于向模板提交数据：
 
 ```python
@@ -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对象。
 
- 
-
 访问`http://127.0.0.1:8000/west/templay`，可以看到页面：
 
- 
-
 “我给你讲个故事吧，勇士拯救公主的故事”，德国人说。 
 
- 
-
 ##流程
 
 再来回顾一下整个流程。`west/views.py`中的`templay()`在返回时，将环境数据`context`传递给模板`templay.html`。Django根据`context`元素中的键值，将相应数据放入到模板中的对应位置，生成最终的http回复。
 
-
-
 这一模板系统可以与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()`为：
+
 ```python
 def staff(request):
     staff_list = Character.objects.all()
     return render(request, 'templay.html', {'staffs': staff_list})
 ```
+
 从数据库中查询到的三个对象都在`staff_list`中。我们直接将`staff_list`传送给模板。
 
 将模板`templay.html`修改为：
 
+```html
 {% for item in staffs %}
-<p>{{ item.id }}, {{item}}</p>
+    <p>{{ item.id }}, {{item}}</p>
 {% endfor %}
+```
+
 我们以类似于Python中`for`循环的方式来定义模板中的`for`，以显示`staffs`中的每个元素。
 
 还可以看到，对象.属性名的引用方式可以直接用于模板中。
 
- 
-
 选择结构也与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`的主体，只替换掉特定的部分。
 
-新建`templates/west/base.html`:
+新建`templates/west/base.html`：
 
-```python
+```html
 <html>
-  <head>
-    <title>templay</title>
-  </head>
-
-  <body>
-    <h1>come from base.html</h1>
-    {% block mainbody %}
-       <p>original</p>
-    {% endblock %}
-  </body>
+    <head>
+        <title>templay</title>
+    </head>
+
+    <body>
+        <h1>come from base.html</h1>
+        {% block mainbody %}
+            <p>original</p>
+        {% endblock %}
+    </body>
 </html>
 ```
-该页面中，名为`mainbody`的`block`标签是可以被继承者们替换掉的部分。
 
- 
+该页面中，名为`mainbody`的`block`标签是可以被继承者们替换掉的部分。
 
 我们在下面的`templay.html`中继承`base.html`，并替换特定`block`：
 
-```python
+```html
 {% extends "base.html" %}
 
 {% block mainbody %}
 
 {% for item in staffs %}
-<p>{{ item.id }},{{ item.name }}</p>
+    <p>{{ item.id }},{{ item.name }}</p>
 {% 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 9e2dcf5..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,104 +1,87 @@
 #被解放的姜戈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="/west/investigate/" method="get">
-  <input type="text" name="staff">
-  <input type="submit" value="Submit">
+    <input type="text" name="staff">
+    <input type="submit" value="Submit">
 </form>
 ```
+
 这里的`form`标签有两个属性。`action`用于说明URL地址，`method`说明请求的方法。
 
 表格中还包含有两个`input`标签，即两个输入栏目。根据`type`的不同，第一个为一个文本框，第二个为一个提交按钮。`name`为输入栏的名字。服务器在解析数据时，将以`name`为索引。
 
- 
+我们可以将上面的表格直接存入模板`form.html`，并在`[site]/west/views.py`中定义一个视图`form()`来显示表格：
 
-我们可以将上面的表格直接存入模板`form.html`，并在`[site]/west/views.py`中定义一个视图`form()`来显示表格:
 ```python
 from django.shortcuts import render
 
 def form(request):
     return render(request, 'form.html')
 ```
+
 设置`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`时，将显示:
-
+设置`urls.py`，让该处理函数对应`action`的URL（`[site]/west/investigate/`）。
 
+当我们访问`http://127.0.0.1:8000/west/form`时，将显示：
 
 提交表格后，页面将转到`[site]/west/investigate`。`investigate()`读取字符串后，在页面上显示出来。
 
- 
-
 姜戈舔舔嘴唇，“这就是你最好的决斗士？我觉得它们不值。”
 
- 
-
 ##POST方法
 
 上面我们使用了`GET`方法。视图显示和请求处理分成两个函数处理。
 
 提交数据时更常用`POST`方法。我们下面使用该方法，并用一个URL和处理函数，同时显示视图和处理请求。
 
- 
-
 先创建模板`investigate.html`
 
-```python
+```html
 <form action="/west/investigate/" method="post">
-  {% csrf_token %}
-  <input type="text" name="staff">
-  <input type="submit" value="Submit">
+    {% csrf_token %}
+    <input type="text" name="staff">
+    <input type="submit" value="Submit">
 </form>
 
 <p>{{ rlt }}</p>
 ```
+
 我们修改提交表格的方法为`post`。在模板的末尾，我们增加一个`rlt`记号，为表格处理结果预留位置。
 
 表格后面还有一个`{% csrf_token %}`的标签。`csrf`全称是Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。`POST`方法提交的表格，必须有此标签。
 
- 
-
 在`west/views.py`中，用`investigate()`来处理表格：
 
 ```python
@@ -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`方法时，额外的处理，即提取表格中的数据到环境变量。
 
- 
-
 最终效果如下：
 
-
-
 “哦，是吗，我可是有更好的货色”，庄主似乎胸有成竹。 
 
- 
-
 ##存储数据
 
 我们还可以让客户提交的数据存入数据库。使用庄园疑云中创建的模型。我们将客户提交的字符串存入模型`Character`。
 
- 
-
-修改`west/views.py`的`investigate()`:
+修改`west/views.py`的`investigate()`：
 
 ```python
 from django.shortcuts import render
@@ -151,45 +127,37 @@ def investigate(request):
     ctx['staff'] = all_records
     return render(request, "investigate.html", ctx)
 ```
+
 在`POST`的处理部分，我们调用`Character`类创建新的对象，并让该对象的属性`name`等于用户提交的字符串。通过`save()`方法，我们让该记录入库。
 
 随后，我们从数据库中读出所有的对象，并传递给模板。
 
- 
-
 我们还需要修改模板`investigate.html`，以更好的显示：
 
-```python
+```html
 <form action="/west/investigate/" method="post">
-  {% csrf_token %}
-  <input type="text" name="staff">
-  <input type="submit" value="Submit">
+    {% csrf_token %}
+    <input type="text" name="staff">
+    <input type="submit" value="Submit">
 </form>
 
 {% for person in staff %}
-<p>{{ person }}</p>
+    <p>{{ person }}</p>
 {% endfor %}
 ```
-我们使用模板语言的`for`，来显示所有的记录。
-
- 
-
-效果如下:
 
+我们使用模板语言的`for`，来显示所有的记录。
 
+效果如下：
 
 “他只是勉强够看罢了”，姜戈摇摇头，德国人也赶快跟着摇摇头。 
 
- 
-
 ##表格对象
 
 客户提交数据后，服务器往往需要对数据做一些处理。比如检验数据，看是否符合预期的长度和数据类型。在必要的时候，还需要对数据进行转换，比如从字符串转换成整数。这些过程通常都相当的繁琐。
 
 Django提供的数据对象可以大大简化这一过程。该对象用于说明表格所预期的数据类型和其它的一些要求。这样Django在获得数据后，可以自动根据该表格对象的要求，对数据进行处理。
 
- 
-
 修改`west/views.py`：
 
 ```python
@@ -219,51 +187,41 @@ def investigate(request):
     ctx['form']  = form
     return render(request, "investigate.html", ctx)
 ```
+
 上面定义了`CharacterForm`类，并通过属性`name`，说明了输入栏`name`的类型为字符串，最大长度为`200`。
 
 在`investigate()`函数中，我们根据`POST`，直接创立`form`对象。该对象可以直接判断输入是否有效，并对输入进行预处理。空白输入被视为无效。
 
 后面，我们再次创建一个空的`form`对象，并将它交给模板显示。
 
- 
-
 在模板`investigate.html`中，我们可以直接显示`form`对象：
 
-```python
+```html
 <form action="/west/investigate/" method="post">
-  {% csrf_token %}
-  {{ form.as_p }}
-  <input type="submit" value="Submit">
+    {% csrf_token %}
+    {{ form.as_p }}
+    <input type="submit" value="Submit">
 </form>
 
 {% for person in staff %}
-<p>{{ person }}</p>
+    <p>{{ person }}</p>
 {% endfor %}
 ```
-如果有多个输入栏，我们可以用相同的方式直接显示整个`form`，而不是加入许多个`<input>`标签。
 
- 
+如果有多个输入栏，我们可以用相同的方式直接显示整个`form`，而不是加入许多个`<input>`标签。
 
 效果如下：
 
-
-
- 
-
 庄主看看德国人，再看看女仆，脸上露出狡猾的笑容。
 
- 
-
 ##总结
 
-`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 9bd5ed0..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页面，来管理我们的数据库。这一工具，主要是为网站管理人员使用。
 
 这个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,35 +21,27 @@ 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`模块。我们将在以后处理用户管理的问题。
 
- 
-
 “我已经管理这个庄园几十年了。”
 
- 
-
 ##复杂模型
 
 管理页面的功能强大，完全有能力处理更加复杂的数据模型。
 
- 
-
 先在`west/models.py`中增加一个更复杂的数据模型：
 
 ```python
@@ -68,30 +52,33 @@ 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`用于存储整数。
 
- 
-
-同步数据库:
+同步数据库：
 
+```bash
 $python manage.py syncdb
- 
+```
 
 在`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])
@@ -99,19 +86,15 @@ admin.site.register([Character, Contact, Tag])
 
 模型将在管理页面显示。比如`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`数据模型，我们在注册的时候，需要将它们一起注册。显示效果如下：
 
-
-
- 
-
- 
-
 我们还可以将输入栏分块，给每一块输入栏以自己的显示格式。修改`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`部分收敛起来：
 
-
-
 `Advance`部分旁边有一个“Show”按钮，用于展开。
 
- 
-
 “这两个客人，似乎没有那么简单。”
 
- 
-
 ##Inline显示
 
 上面的`Contact`是`Tag`的外部键，所以有外部参考的关系。而在默认的页面显示中，将两者分离开来，无法体现出两者的从属关系。我们可以使用`Inline`显示，让`Tag`附加在`Contact`的编辑页面上显示。
 
- 
-
 修改`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`说明要搜索的属性：
 
 ```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 d256fbc..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,18 +1,14 @@
 #被解放的姜戈06 假作真时
 
-
- 
-
 之前了解了：
 
-创建Django项目
-数据库
-模板
-表格提交
-admin管理页面
-上面的功能模块允许我们做出一个具有互动性的站点，但无法验证用户的身份。我们这次了解用户验证部分。通过用户验证，我们可以根据用户的身份，提供不同的服务。
+1.创建Django项目
+2.数据库
+3.模板
+4.表格提交
+5.admin管理页面
 
- 
+上面的功能模块允许我们做出一个具有互动性的站点，但无法验证用户的身份。我们这次了解用户验证部分。通过用户验证，我们可以根据用户的身份，提供不同的服务。
 
 一个Web应用的用户验证是它的基本组成部分。我们在使用一个应用时，总是从“登录”开始，到“登出”结束。另一方面，用户验证又和网站安全、数据库安全息息相关。HTTP协议是无状态的，但我们可以利用储存在客户端的cookie或者储存在服务器的session来记录用户的访问。 
 
@@ -20,8 +16,6 @@ Django有管理用户的模块，即`django.contrib.auth`。你可以在`mysite/
 
 “为了救你的爱人出来，我们要演一场戏。”
 
- 
-
 ##创建用户
 
 你可以在`admin`页面直接看到用户管理的对话框，即`Users`。从这里，你可以在这里创建、删除和修改用户。点击“Add”增加用户`daddy`，密码为`daddyiscool`。
@@ -30,28 +24,23 @@ Django有管理用户的模块，即`django.contrib.auth`。你可以在`mysite/
 
 在这一章节中，我们创立一个新的app，即`users`。下文的模板和`views.py`，都针对该app。
 
- 
-
 "你这套新衣服，还真像那么回事"，德国人说。
 
- 
-
 用户登录
 
 我们建立一个简单的表格。用户通过该表格来提交登陆信息，并在Django服务器上验证。如果用户名和密码正确，那么登入用户。
 
 我们首先增加一个登录表格：
 
-```python
+```html
 <form role="form" action="/login" method="post">
-      <label>Username</label>
-      <input type="text" name='username'>
-      <label>Password</label>
-      <input name="password" type="password">
-      <input type="submit" value="Submit">
- </form>
+	<label>Username</label>
+	<input type="text" name='username'>
+	<label>Password</label>
+	<input name="password" type="password">
+	<input type="submit" value="Submit">
+</form>
 ```
- 
 
 我们在`views.py`中，定义处理函数`user_login()`，来登入用户：
 
@@ -70,27 +59,24 @@ 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`对象，而不自行定义表格。这将让代码更简单，而且提供一定的完整性检验。
 
 练习. 使用`contrib.auth.forms.AuthenticationForm`。来简化上面的模板和处理函数。
 
- 
-
 德国人还是不忘一再叮嘱，"记住，我们可不是什么赏金猎人。" 
 
- 
-
 ##登出
 
 有时用户希望能销毁会话。我们可以提供一个登出的URL，即`/users/logout`。登入用户访问该URL，即可登出。在`views.py`中，增加该URL的处理函数：
@@ -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,33 +116,33 @@ def diff_response(request):
         content = "<p>my dear user</p>"
     else:
         content = "<p>you wired stranger</p>"
+
     return HttpResponse(content)
 ```
- 
 
-可以看到，用户的登录信息包含在`request.user`中，`is_authenticated()`方法用于判断用户是否登录，如果用户没有登录，那么该方法将返回`False`。该`user`对象属于`contrib.auth.user`类型，还有其它属性可供使用，比如
+可以看到，用户的登录信息包含在`request.user`中，`is_authenticated()`方法用于判断用户是否登录，如果用户没有登录，那么该方法将返回`False`。该`user`对象属于`contrib.auth.user`类型，还有其它属性可供使用，比如：
 
-属性  功能
+属性              功能
 `get_username()`  返回用户名
 `set_password()`  设置密码
 `get_fullname()`  返回姓名
 `last_login`      上次登录时间
 `date_joined`　　  账户创建时间
-练习. 实验上面的处理函数的效果。
 
- 
+练习. 实验上面的处理函数的效果。
 
 在Django中，我们还可以利用装饰器，根据用户的登录状况，来决定`views.py`中处理函数的显示效果。相对于上面的if结构，装饰器使用起来更加方便。下面的`user_only()`是`views.py`中的一个处理函数。
 
+```python
 from django.contrib.auth.decorators import login_required
 from django.http import HttpResponse
 
 @login_required
 def user_only(request):
     return HttpResponse("<p>This message is for logged in user only.</p>")
-注意上面的装饰器`login_required`，它是Django预设的装饰器。`user_only()`的回复结果只能被登录用户看到，而未登录用户将被引导到其他页面。
+```
 
- 
+注意上面的装饰器`login_required`，它是Django预设的装饰器。`user_only()`的回复结果只能被登录用户看到，而未登录用户将被引导到其他页面。
 
 Django中还有其它的装饰器，用于修饰处理函数。相应的http回复，只能被特殊的用户看到。比如`user_passes_test`，允许的用户必须满足特定标准，而这一标准是可以用户自定义的。比如下面，在`views.py`中增添： 
 
@@ -172,37 +156,29 @@ def name_check(user):
 def specific_user(request):
     return HttpResponse("<p>for Vamei only</p>")
 ```
- 
 
 装饰器带有一个参数，该参数是一个函数对象`name_check`。当`name_check`返回真值，即用户名为`vamei`时，`specific_user`的结果才能被用户看到。
 
- 
-
 德国人羞涩的笑笑，“我确实对她有那么点好感。” 
 
- 
-
 ##模板中的用户
 
 进一步，用户是否登陆这一信息，也可以直接用于模板。比较原始的方式是把用户信息直接作为环境数据，提交给模板。然而，这并不是必须的。事实上，Django为此提供了捷径：我们可以直接在模板中调用用户信息。比如下面的模板：
 
+```html
 {% if user.is_authenticated %}
-  <p>Welcome, my genuine user, my true love.</p>
+	<p>Welcome, my genuine user, my true love.</p>
 {% else %}
-  <p>Sorry, not login, you are not yet my sweetheart. </p>
+	<p>Sorry, not login, you are not yet my sweetheart. </p>
 {% endif %}
-不需要环境变量中定义，我们就可以直接在模板中引用`user`。这里，模板中调用了`user`的一个方法，`is_authenticated`，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。
+```
 
- 
+不需要环境变量中定义，我们就可以直接在模板中引用`user`。这里，模板中调用了`user`的一个方法，`is_authenticated`，将根据用户的登录情况，返回真假值。需要注意，和正常的Python程序不同，在Django模板中调用方法并不需要后面的括号。
 
 练习. 增加处理函数，显示该模板，然后查看不同登录情况下的显示结果。
 
- 
-
 管家冷不丁的说，“你认识他们？！” 
 
- 
-
 ##用户注册
 
 我们上面利用了`admin`管理页面来增加和删除用户。这是一种简便的方法，但并不能用于一般的用户注册的情境。我们需要提供让用户自主注册的功能。这可以让站外用户提交自己的信息，生成自己的账户，并开始作为登陆用户使用网站。
@@ -228,27 +204,23 @@ def register(request):
         ctx.update(csrf(request))       
         return render(request, "register.html", ctx)
 ```
- 
 
 相应的模板`register.html`如下：
 
+```html
 <form action="" method="post">
-   {% csrf_token %}
-   {{ form.as_p }}
-   <input type="submit" value="Register">
+	{% csrf_token %}
+	{{ form.as_p }}
+	<input type="submit" value="Register">
 </form>
- 
+```
 
 “骗子，你们这些骗子”，庄园主怒吼着。
 
- 
-
 ##总结
 
 正如我们上面提到的，用户登陆系统的最大功能是区分登入和未登入用户，向他们提供不同的内容和服务。
 
 我们看到了用户验证的基本流程，也看到了如何在`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 68c2940..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`安装：
 
+（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`中增加下面的配置： 
 
-```python
+```quote
 # Django
 WSGIScriptAlias / /home/vamei/mysite/mysite/wsgi.py
 WSGIPythonPath /home/vamei/mysite
@@ -41,36 +39,28 @@ WSGIPythonPath /home/vamei/mysite
 </Files>
 </Directory>
 ```
+
 上面的配置中`/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`中添加如下配置：
 
-```python
+```quote
 Alias /media/ /home/vamei/media/
 Alias /static/ /home/vamei/static/
 
@@ -95,38 +85,25 @@ WSGIPythonPath /home/vamei/mysite
 </Files>
 </Directory>
 ```
-这样，`/static/`和`/media/`这两个URL的访问将引导向存有静态文件的`/home/vamei/static/和/home/vamei/media/`，apache将直接向客户提供这两个文件夹中的静态文件。而剩下的URL访问，将导向WSGI接口，由Django动态处理。
 
- 
+这样，`/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将自动搜索到其中的静态文件。但这一方法有很大的安全隐患，只适用于开发。
 
- 
-
 马蹄声疾，电光火石之间，姜戈已经把护园家丁撂倒在地。
 
- 
-
 ##总结
 
-`apache` + `mod_wsgi`
-
-静态文件
+`apache` + `mod_wsgi`。
 
- 
+静态文件。
 
-“你在外面等我，我要跟他们算总帐”，姜戈对爱人说。
+“你在外面等我，我要跟他们算总帐”，姜戈对爱人说。
\ No newline at end of file

From 9998b51c05636a894a53598781eb3621dbf2eae1 Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Thu, 26 Jun 2014 23:49:19 +0800
Subject: [PATCH 10/13] =?UTF-8?q?=E8=A1=A5=E5=85=85*.md=E3=80=81=E6=B7=B1?=
 =?UTF-8?q?=E5=85=A5*.md=E3=80=81=E7=BD=91=E7=BB=9C*.md=EF=BC=9A=E6=95=B4?=
 =?UTF-8?q?=E4=BD=93=E8=B0=83=E6=95=B4=E6=A0=BC=E5=BC=8F=EF=BC=8C=E5=A6=82?=
 =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=A4=9A=E4=BD=99=E7=A9=BA=E8=A1=8C=E3=80=81?=
 =?UTF-8?q?=E6=95=B4=E7=90=86=E4=BB=A3=E7=A0=81=E5=9D=97=E3=80=81=E4=BF=AE?=
 =?UTF-8?q?=E6=AD=A3=E6=A0=87=E7=82=B9=E7=AC=A6=E5=8F=B7=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...16\345\244\232\350\214\203\345\274\217.md" |  77 ++++----
 ...07\347\256\241\347\220\206\345\231\250.md" |  43 ++--
 ...345\205\24504 \351\227\255\345\214\205.md" |  47 ++---
 ...5 \350\243\205\351\245\260\345\231\250.md" |  59 +++---
 ...05\345\255\230\347\256\241\347\220\206.md" | 140 +++++--------
 ...on\346\234\215\345\212\241\345\231\250.md" | 123 ++++--------
 ...41\345\231\250\350\277\233\345\214\226.md" | 149 +++++---------
 ...on\345\260\217\346\212\200\345\267\247.md" |  98 +++++----
 ...75\346\225\260\346\270\205\345\215\225.md" | 187 +++++++-----------
 ...%\346\223\215\344\275\234\347\254\246).md" |  52 +++--
 ...5\20506 Python\344\271\213\351\201\223.md" |  38 +---
 11 files changed, 405 insertions(+), 608 deletions(-)

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 339994d..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()`也起到了简化书写的作用。
 
-尝试下面的操作，想一下它的对应内置函数
+尝试下面的操作，想一下它的对应内置函数：
 
+```python
 (-1).__abs__()
-
 (2.3).__int__()
+```
 
- 
+##表（list）元素引用
 
-##表(list)元素引用
+下面是我们常见的表元素引用方式：
 
-下面是我们常见的表元素引用方式
 ```python
 li = [1, 2, 3, 4, 5, 6]
 print(li[3])
 ```
+
 上面的程序运行到`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):
@@ -90,16 +99,10 @@ map(add, [2, 4, 5])    # Pass around function object
 
 当然，我们还可以使用更“优美”的方式，想想是什么。
 
- 
-
 ##总结
 
-对于内置的对象来说(比如整数、表、字符串等)，它们所需要的特殊方法都已经在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 3fff9fe..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,13 +26,16 @@ 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`文件了。
 
 ##自定义
 
@@ -40,44 +43,39 @@ print(f.closed)
 
 下面，我们自定义用于上下文管理器的对象，就是下面的`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 b3e4921..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,13 +1,8 @@
 #Python深入04 闭包
 
+闭包（closure）是函数式编程的重要的语法结构。函数式编程是一种编程范式（而面向过程编程和面向对象编程也都是编程范式）。在面向过程编程中，我们见到过函数（function）；在面向对象编程中，我们见过对象（object）。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性（reusability）。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。
 
- 
-
-闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。在面向过程编程中，我们见到过函数(function)；在面向对象编程中，我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。
-
-不同的语言实现闭包的方式不同。Python以函数对象为基础，为闭包这一语法结构提供支持的 (我们在特殊方法与多范式中，已经多次看到Python使用对象来实现一些特殊的语法)。Python一切皆对象，函数这一语法结构也是一个对象。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。
-
- 
+不同的语言实现闭包的方式不同。Python以函数对象为基础，为闭包这一语法结构提供支持的（我们在特殊方法与多范式中，已经多次看到Python使用对象来实现一些特殊的语法）。Python一切皆对象，函数这一语法结构也是一个对象。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。
 
 ##函数对象的作用域
 
@@ -16,25 +11,23 @@
 ```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`所在的层级相同。
 
- 
-
 ##闭包
 
 函数是一个对象，所以可以作为某个函数的返回结果。
@@ -48,9 +41,8 @@ def line_conf():
 my_line = line_conf()
 print(my_line(5))       
 ```
-上面的代码可以成功运行。`line_conf`的返回结果被赋给`line`对象。上面的代码将打印`11`。
 
- 
+上面的代码可以成功运行。`line_conf`的返回结果被赋给`line`对象。上面的代码将打印`11`。
 
 如果`line()`的定义中引用了外部的变量，会发生什么呢？
 
@@ -58,26 +50,25 @@ print(my_line(5))
 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 = 1 * x + 1`和`y = 4 * x + 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 b4b21bb..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,33 +54,36 @@ 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(a)`。这样，就为装饰器的编写和使用提供了更大的灵活性。
@@ -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()`的次数了。
 
- 
-
 ##总结
 
-装饰器的核心作用是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 03f0046..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`的引用时，实际上是让所有这些引用指向同一个对象。
+
 ```pyhton
 a = 1
 b = 1
@@ -40,16 +39,16 @@ b = 1
 print(id(a))
 print(id(b))
 ```
-上面程序返回
 
-11246696
+上面程序返回：
 
+```quote
 11246696
+11246696
+```
 
 可见`a`和`b`实际上是指向同一个对象的两个引用。
 
- 
-
 为了检验两个引用指向同一个对象，我们可以用`is`关键字。`is`用于判断两个引用所指的对象是否相同。
 
 ```pyhton
@@ -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`。
+
 ```pyhton
 from sys import getrefcount
 
@@ -89,34 +88,30 @@ 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`。
 
- 
+可以看到，`a`引用了对象`b`。
 
 对象引用对象，是Python最基本的构成方式。即使是`a = 1`这一赋值方式，实际上是让词典的一个键值`"a"`的元素引用整数对象`1`。该词典对象用于记录所有的全局引用。该词典引用了整数对象`1`。我们可以通过内置函数`globals()`来查看该词典。
 
- 
-
 当一个对象A被另一个对象B引用时，A的引用计数将增加1。
 
 ```pyhton
@@ -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的对象，就将它所占据的内存清空。
 
- 
+然而，减肥是个昂贵而费力的事情。垃圾回收时，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()`方法重新设置。
+```
 
- 
+返回`(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代垃圾回收。
 
 同样可以用`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。
 
-
-
- 
-
 遍历后的结果
 
- 
-
 在结束遍历后，`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 21afbd1..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,44 +1,25 @@
 #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编程。
 
 首先是服务器端，我们使用`bind()`方法来赋予socket以固定的地址和端口，并使用`listen()`方法来被动的监听该端口。当有客户尝试用`connect()`方法连接的时候，服务器使用`accept()`接受连接，从而建立一个连接的`socket`：
@@ -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,56 +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。
-
- 
+它实际上又由空格分为三个片段，`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)。
-
- 
+而`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,11 +207,9 @@ Connection: keep-alive
 
 我们的Python程序根据这个请求，发送给服务器`text_content`的内容。
 
- 
+浏览器接收到`text_content`之后，发现正文的html文本中有`<IMG src="text.jpg" />`，知道需要获得`text.jpg`文件来补充为图片，立即发出了第二个请求：
 
-浏览器接收到`text_content`之后，发现正文的html文本中有`<IMG src="text.jpg" />`，知道需要获得`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,13 +222,11 @@ Referer: http://127.0.0.1:8000/
 
 我们的Python程序分析过起始行之后，发现`/test.jpg`符合`if`条件，所以将`pic_content`发送给客户。
 
-最后，浏览器根据html语言的语法，将html文本和图画以适当的方式显示出来。(html可参考http://www.w3schools.com/html/default.asp)
-
- 
+最后，浏览器根据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服务器。
 
@@ -278,15 +234,12 @@ Referer: http://127.0.0.1:8000/
 
 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 819f654..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服务器，会发现这里只是增加很少的一点内容。
 
-原始程序:
+原始程序：
 
 ```python
 # Written by Vamei
@@ -27,15 +24,15 @@ text_content = '''HTTP/1.x 200 OK
 Content-Type: text/html
 
 <head>
-<title>WOW</title>
+    <title>WOW</title>
 </head>
 <html>
-<p>Wow, Python Server</p>
-<IMG src="test.jpg"/>
-<form name="input" action="/" method="post">
-First name:<input type="text" name="firstname"><br>
-<input type="submit" value="Submit">
-</form> 
+    <p>Wow, Python Server</p>
+    <IMG src="test.jpg"/>
+    <form name="input" action="/" method="post">
+        First name:<input type="text" name="firstname"><br>
+        <input type="submit" value="Submit">
+    </form> 
 </html>
 '''
 
@@ -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
 
 <head>
-<title>WOW</title>
+    <title>WOW</title>
 </head>
 <html>
-<p>Wow, Python Server</p>
-<IMG src="test.jpg"/>
-<form name="input" action="/" method="post">
-First name:<input type="text" name="firstname"><br>
-<input type="submit" value="Submit">
-</form> 
+    <p>Wow, Python Server</p>
+    <IMG src="test.jpg"/>
+    <form name="input" action="/" method="post">
+        First name:<input type="text" name="firstname"><br>
+        <input type="submit" value="Submit">
+    </form> 
 </html>
 '''
 
@@ -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`对象，即一个使用TCP socket的服务器。在建立`TCPServe`的同时，设置该服务器的IP地址和端口。使用`server_forever()`方法来让服务器不断工作（就像原始程序中的`while`循环一样）。
 
 我们传递给`TCPServer`一个`MyTCPHandler`类。这个类定义了如何操作`socket`。`MyTCPHandler`继承自`BaseRequestHandler`。改写`handler()`方法，来具体规定不同情况下服务器的操作。
 
-在`handler()`中，通过`self.request`来查询通过`socket`进入服务器的请求 (正如我们在`handler()`中对`socket`进行`recv()`和`sendall()`操作)，还使用`self.address`来引用`socket`的客户端地址。
-
- 
+在`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
-
- 
+POST                          /                  分析request主体中包含的value（实际上是我们填入表格的内容）; 发送text_content和value
 
 根据请求方法和URL的不同，一个大型的HTTP服务器可以应付成千上万种不同的请求。在Python中，我们可以使用`SimpleHTTPServer`包和`CGIHTTPServer`包来规定针对不同请求的操作。其中，`SimpleHTTPServer`可以用于处理GET方法和HEAD方法的请求。它读取`request`中的URL地址，找到对应的静态文件，分析文件类型，用HTTP协议将文件发送给客户。
 
- 
-
-
-
 SimpleHTTPServer
 
- 
-
 我们将`text_content`放置在`index.html`中，并单独存储`text.jpg`文件。如果URL指向`index_html`的母文件夹时，`SimpleHTTPServer`会读取该文件夹下的`index.html`文件。
 
- 
-
-我在当前目录下生成`index.html`文件:
+我在当前目录下生成`index.html`文件：
 
-```python
+```html
 <head>
-<title>WOW</title>
+    <title>WOW</title>
 </head>
 <html>
-<p>Wow, Python Server</p>
-<IMG src="test.jpg"/>
-<form name="input" action="/" method="post">
-First name:<input type="text" name="firstname"><br>
-<input type="submit" value="Submit">
-</form>
+    <p>Wow, Python Server</p>
+    <IMG src="test.jpg"/>
+    <form name="input" action="/" method="post">
+        First name:<input type="text" name="firstname"><br>
+        <input type="submit" value="Submit">
+    </form>
 </html>
 ```
- 
 
-改写Python服务器程序。使用`SimpleHTTPServer`包中唯一的类`SimpleHTTPRequestHandler`:
+改写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的指向密切相关。我用自由度，换来了更加简洁的程序。
 
- 
-
 ##CGIHTTPServer：使用静态文件或者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脚本之间的通信要符合CGI标准。CGI的实现方式有很多，比如说使用Apache服务器与Perl写的CGI脚本，或者Python服务器与shell写的CGI脚本。
 
- 
-
 为了使用CGI，我们需要使用`BaseHTTPServer`包中的`HTTPServer`类来构建服务器。Python服务器的改动很简单。
 
-CGIHTTPServer:
+CGIHTTPServer：
 
 ```python
 # Written by Vamei
@@ -301,24 +263,22 @@ 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`。
 
-```python
+```html
 <head>
-<title>WOW</title>
+    <title>WOW</title>
 </head>
 <html>
-<p>Wow, Python Server</p>
-<IMG src="test.jpg"/>
-<form name="input" action="cgi-bin/post.py" method="post">
-First name:<input type="text" name="firstname"><br>
-<input type="submit" value="Submit">
-</form>
+    <p>Wow, Python Server</p>
+    <IMG src="test.jpg"/>
+    <form name="input" action="cgi-bin/post.py" method="post">
+        First name:<input type="text" name="firstname"><br>
+        <input type="submit" value="Submit">
+    </form>
 </html>
 ```
- 
 
 我创建一个`cgi-bin`的文件夹，并在`cgi-bin`中放入如下`post.py`文件，也就是我们的CGI脚本：
 
@@ -334,18 +294,17 @@ print                               # blank line, end of headers
 print "<p>Hello world!</p>"         # Start of content
 print "<p>" +  repr(form['firstname']) + "</p>"
 ```
-(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 bbd4593..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,15 +1,10 @@
 ##Python补充02 Python小技巧
 
-
- 
-
 在这里列举一些我使用Python时积累的小技巧。这些技巧是我在使用Python过程中经常使用的。之前很零碎的记在笔记本中，现在整理出来，和大家分享，也作为Python快速教程的一个补充。
 
- 
-
 ##import模块
 
-在Python经常使用`import`声明，以使用其他模块(也就是其它.py文件)中定义的对象。
+在Python经常使用`import`声明，以使用其他模块（也就是其它.py文件）中定义的对象。
 
 1) 使用`__name__`
 
@@ -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`使用方式
 
-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,21 +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("你好吗？")
@@ -115,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))
@@ -130,9 +143,9 @@ print(int("2A", 16))
 
 ##注释
 
-一行内的注释可以以`#`开始
+一行内的注释可以以`#`开始。
 
-多行的注释可以以`'''`开始，以`'''`结束，比如
+多行的注释可以以`'''`开始，以`'''`结束，比如：
 
 ```python
 '''
@@ -146,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增加搜索路径。
+
+我们可以在Python运行的时候增加或者删除`sys.path`中的元素。另一方面，我们可以通过在Shell中增加`PYTHONPATH`环境变量，来为Python增加搜索路径。
 
 下面我们增加`/home/vamei/mylib`到搜索路径中：
 
+```bash
 $export PYTHONPATH=$PYTHONPATH:/home/vamei/mylib
+```
 
 你可以将正面的这行命令加入到`~/.bashrc`（不同系统下，此文件可能为`~/.bash_profile`、`~/.profile`等）中。这样，我们就长期的改变了搜索路径。
 
- 
-
 ##脚本与命令行结合
 
 可以使用下面方法运行一个Python脚本，在脚本运行结束后，直接进入Python命令行。这样做的好处是脚本的对象不会被清空，可以通过命令行直接调用。
+
 ```python
 $python -i script.py
 ```
- 
 
 ##安装非标准包
 
 Python的标准库随着Python一起安装。当我们需要非标准包时，就要先安装。
 
-1) 使用Linux repository (Linux环境)
+1) 使用Linux repository（Linux环境）
 
-这是安装Python附加包的一个好的起点。你可以在Linux repository中查找可能存在的Python包 (比如在Ubuntu Software Center中搜索matplot)。
+这是安装Python附加包的一个好的起点。你可以在Linux repository中查找可能存在的Python包（比如在Ubuntu Software Center中搜索“matplot”）。
 
 2) 使用`pip`。`pip`是Python自带的包管理程序，它连接Python repository，并查找其中可能存在的包。
 
 比如使用如下方法来安装、卸载或者升级`web.py`：
 
-$pip install web.py
-
-$pip uninstall 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 36a2efc..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 80aec95..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,46 +1,45 @@
 #Python补充05 字符串格式化 (%操作符)
 
-
- 
-
 在许多编程语言中都包含有格式化字符串的功能，比如C和Fortran语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作`%`。
 
- 
-
 ##模板
 
 格式化字符串时，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" % ('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()`的显示)
+`%s`    字符串（采用`str()`的显示）
 
-`%r`    字符串 (采用`repr()`的显示)
+`%r`    字符串（采用`repr()`的显示）
 
 `%c`    单个字符
 
@@ -54,53 +53,48 @@ print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99}
 
 `%x`    十六进制整数
 
-`%e`    指数 (基底写为e)
+`%e`    指数（基底写为e）
 
-`%E`    指数 (基底写为E)
+`%E`    指数（基底写为E）
 
 `%f`    浮点数
 
 `%F`    浮点数，与上相同
 
-`%g`    指数(e)或浮点数 (根据显示长度)
-
-`%G`    指数(E)或浮点数 (根据显示长度)
+`%g`    指数（e）或浮点数（根据显示长度）
 
- 
+`%G`    指数（E）或浮点数（根据显示长度）
 
 `%%`    字符"%"
 
- 
-
 可以用如下的方式，对格式进行进一步的控制：
 
 `%[(name)][flags][width].[precision]typecode`
 
-`(name)`为命名
-
-`flags`可以有`+`,`-`,`一个空格`或`0`。`+`表示右对齐。`-`表示左对齐。`一个空格`表示在正数的左侧填充一个空格，从而与负数对齐。`0`表示使用0填充。
+`(name)`为命名。
 
-`width`表示显示宽度
+`flags`可以有`+`、`-`、`一个空格`或`0`。`+`表示右对齐。`-`表示左对齐。`一个空格`表示在正数的左侧填充一个空格，从而与负数对齐。`0`表示使用0填充。
 
-`precision`表示小数点后精度
+`width`表示显示宽度。
 
- 
+`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 6bdd106..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,131 +1,103 @@
 #Python补充06 Python之道
 
-
- 
-
 Python有一个彩蛋，用下面语句调出：
+
 ```python
 import this
 ```
+
 该彩蛋的文档记录于PEP 20。
 
 语句执行之后，终端将显示一首“The Zen of Python”的诗，即“Python之道”。这首诗总结了Python的风格，可以指导Python程序员的编程。Python程序员会自豪宣称自己“Pythonic”。“Pythonic”的一个基本标准，是写出合乎“Python之道”的代码。
 
- 
-
 下面是“Python之道”的全文，以及我附加的翻译。
 
 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

From 1059c0af8318b98fad160db0204522eeb7df510e Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Tue, 22 Jul 2014 01:33:02 +0800
Subject: [PATCH 11/13] =?UTF-8?q?intermediate*.md=EF=BC=9A=E6=95=B4?=
 =?UTF-8?q?=E4=BD=93=E8=B0=83=E6=95=B4=E6=A0=BC=E5=BC=8F=EF=BC=8C=E5=A6=82?=
 =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=A4=9A=E4=BD=99=E7=A9=BA=E8=A1=8C=E3=80=81?=
 =?UTF-8?q?=E6=95=B4=E7=90=86=E4=BB=A3=E7=A0=81=E5=9D=97=E3=80=81=E4=BF=AE?=
 =?UTF-8?q?=E6=AD=A3=E6=A0=87=E7=82=B9=E7=AC=A6=E5=8F=B7=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/intermediate01.md | 89 ++++++++++++++++++--------------------
 content/intermediate02.md | 36 ++++++----------
 content/intermediate03.md | 57 +++++++++++--------------
 content/intermediate04.md | 90 ++++++++++++++++++---------------------
 content/intermediate05.md | 44 +++++++++----------
 content/intermediate06.md | 80 ++++++++++++++++------------------
 content/intermediate07.md | 59 +++++++++++--------------
 content/intermediate08.md | 40 ++++++++---------
 content/intermediate09.md | 61 +++++++++++---------------
 9 files changed, 244 insertions(+), 312 deletions(-)

diff --git a/content/intermediate01.md b/content/intermediate01.md
index ea5b384..05371bc 100644
--- a/content/intermediate01.md
+++ b/content/intermediate01.md
@@ -4,60 +4,50 @@
 
 进阶教程对基础教程的进一步拓展，说明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]
 ```
@@ -66,61 +56,64 @@ for key in dic:
 
 通过`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()`查询词典中的元素总数。
+
 ```python
->>>print(len(dic))
+print(len(dic))
 ```
 
 ## 词典排序
+
 前面我们已经谈到，词典是无序的，那么，如果需要词典内容有序，就需要使用排序方法：
 
-词典按`key`排序，排序后的结果存放到列表中:（这里用到了列表推导式)
+词典按`key`排序，排序后的结果存放到列表中：（这里用到了列表推导式)
 
 ```python
 listRes = sorted([(k, v) for k, v in dict_rate.items()], reverse=True)
 ```
 
 词典按`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 2717ddb..0b43812 100644
--- a/content/intermediate02.md
+++ b/content/intermediate02.md
@@ -1,77 +1,67 @@
 #Python进阶02 文本文件的输入输出
 
-
-
- 
-
 Python具有基本的文本文件读写功能。Python的标准库提供有更丰富的读写功能。
 
 文本文件的读写主要通过`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 4b81a59..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 myFunc   # 从模块a中引入myFunc对象。调用a中对象时，我们不用再说明模块，即直接使用myFunc，而不是a.myFunc。
-
+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 2fade5b..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`前加`**`。
 
 包裹传递的关键在于定义函数时，在相应元组或字典前加`*`或`**`。
 
- 
-
 ##解包裹
 
-`*`和`**`，也可以在调用的时候使用，即解包裹(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`定义，然后：
+
 ```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 4bf4a2d..5f8817d 100644
--- a/content/intermediate05.md
+++ b/content/intermediate05.md
@@ -1,68 +1,65 @@
 #Python进阶05 循环设计
 
-
- 
-
 在“循环”一节，我们已经讨论了Python基本的循环语法。这一节，我们将接触更加灵活的循环方式。
 
- 
-
 ##range()
 
 在Python中，`for`循环后的`in`跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。
 
 之前我们已经使用过`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()`函数，可以在每次循环中同时得到下标和元素：
+
 ```python
 S = 'abcdefghijk'
-for (index,char) in enumerate(S):
+for (index, char) in enumerate(S):
     print index
     print char
 ```
-实际上，`enumerate()`在每次循环中，返回的是一个包含两个元素的定值表(`tuple`)，两个元素分别赋予`index`和`char`
 
-增加下标的访问设计
+实际上，`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()`方便地实现：
+
 ```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,7 +70,6 @@ na, nb = zip(*zipped)
 print(na, nb)
 ```
 
-
 ##总结
 
 `range()`
diff --git a/content/intermediate06.md b/content/intermediate06.md
index 699c1d5..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`错误。
 
 当一个循环结构（比如`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`。这样，我们相当于手工进行了循环。
 
 自动进行的话，就是：
+
 ```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`返回的值。
 
- 
+下面是一个生成器：
 
-下面是一个生成器:
 ```python
 def gen():
     a = 100
     yield a
-    a = a*8
+    a = a * 8
     yield a
     yield 1000
 ```    
+
 该生成器共有三个`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 f15fc54..05aa59b 100644
--- a/content/intermediate07.md
+++ b/content/intermediate07.md
@@ -1,25 +1,20 @@
 #Python进阶07 函数对象
 
-
-
- 
-
-秉承着一切皆对象的理念，我们再次回头来看函数(function)。函数也是一个对象，具有属性（可以使用`dir()`查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
-
- 
+秉承着一切皆对象的理念，我们再次回头来看函数（function）。函数也是一个对象，具有属性（可以使用`dir()`查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
 
 ##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`函数，带入不同的函数参数。比如：
 
-我们因此可以提高程序的灵活性。可以使用上面的`test`函数，带入不同的函数参数。比如:
 ```python
-test((lambda x,y: x**2 + y), 6, 9)
+test((lambda x, y: x ** 2 + y), 6, 9)
 ``` 
 
 ##map()函数
 
 `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()`传递函数参数的多个参数：
+
 ```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`函数的使用如下例:
+`filter`函数的使用如下例：
 
 ```python
 def func(a):
@@ -79,28 +73,25 @@ def func(a):
     else:
         return False
 
-print filter(func,[10,56,101,500])
+print filter(func,[10, 56, 101, 500])
 ```
- 
 
 ##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`的第一个参数是`lambda`函数，它接收两个参数`x`、`y`，返回`x + y`。
 
 `reduce`将表中的前两个元素(`1`和`2`)传递给`lambda`函数，得到`3`。该返回值(`3`)将作为`lambda`函数的第一个参数，而表中的下一个元素(`5`)作为`lambda`函数的第二个参数，进行下一次的对`lambda`函数的调用，得到`8`。依次调用`lambda`函数，每次`lambda`函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。
 
 上面例子，相当于`(((1 + 2) + 5) + 7) + 9`
 
- 
-
 根据mmufhy的提醒： `reduce()`函数在3.0里面不能直接用的，它被定义在了`functools`包里面，需要引入包，见评论区。
 
- 
-
 ##总结
 
 函数是一个对象
@@ -111,4 +102,4 @@ print reduce((lambda x,y: x+y),[1,2,5,7,9])
 
 `filter()`
 
-`reduce()`
+`reduce()`
\ No newline at end of file
diff --git a/content/intermediate08.md b/content/intermediate08.md
index a1fecfc..c9f8bb2 100644
--- a/content/intermediate08.md
+++ b/content/intermediate08.md
@@ -1,8 +1,5 @@
 #Python进阶08 异常处理
 
-
- 
-
 ##异常处理
 
 在项目开发中，异常处理是不可或缺的。异常处理帮助人们debug，通过更加丰富的信息，让人们更容易找到bug的所在。异常处理还可以提高程序的容错性。
@@ -11,7 +8,8 @@
 
 我们以它为例，来说明基本的异常处理。
 
-一个包含异常的程序:
+一个包含异常的程序：
+
 ```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`的异常。整个程序将会中断。
 
- 
-
 我们可以修改以上异常程序，直到完美的没有bug。但另一方面，如果我们在写程序的时候，知道这里可能犯错以及可能的犯错类型，我们可以针对该异常类型定义好”应急预案“。
+
 ```python
 re = iter(range(5))
 
@@ -34,16 +32,15 @@ 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`部分被跳过。
 
 随后，程序将继续运行，而不是彻底中断。
 
- 
-
 完整的语法结构如下：
 
 ```python
@@ -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,9 +85,8 @@ try:
 except ZeroDivisionError:
     print("Catch error in the main program")
 ```
-子程序的`try...except...`结构无法处理相应的除以`0`的错误，所以错误被抛给上层的主程序。
 
- 
+子程序的`try...except...`结构无法处理相应的除以`0`的错误，所以错误被抛给上层的主程序。
 
 如果`try`中没有异常，那么`except`部分将跳过，执行`else`中的语句。
 
@@ -103,19 +98,20 @@ except ZeroDivisionError:
 
 `try`->无异常->`else`->`finally`
 
- 
-
 ##抛出异常
 
-我们也可以自己写一个抛出异常的例子:
+我们也可以自己写一个抛出异常的例子：
+
 ```python
 print 'Lalala'
 raise StopIteration
 print 'Hahaha'
 ```
+
 这个例子不具备任何实际意义。只是为了说明`raise`语句的作用。
 
-`StopIteration`是一个类。抛出异常时，会自动有一个中间环节，就是生成`StopIteration`的一个对象。Python实际上抛出的，是这个对象。当然，也可以自行生成对象:
+`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 ce4aa1d..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`，`L2`的指向没有发生变化，依然指向那个表。表实际上是包含了多个引用的对象（每个引用是一个元素，比如`L1[0]`，`L1[1]`……每个引用指向一个对象，比如`1`、`2`、`3`) 。而`L1[0] = 10`这一赋值操作，并不是改变`L1`的指向，而是对`L1[0]`，也就是表对象的一部份（一个元素），进行操作，所以所有指向该对象的引用都受到影响。
 
 （与之形成对比的是，我们之前的赋值操作都没有对对象自身发生作用，只是改变引用指向。）
 
- 
-
-列表可以通过引用其元素，改变对象自身(in-place change)。这种对象类型，称为可变数据对象(mutable object)，词典也是这样的数据类型。
+列表可以通过引用其元素，改变对象自身（in-place change）。这种对象类型，称为可变数据对象（mutable object），词典也是这样的数据类型。
 
-而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。
+而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象（immutable object）。
 
-我们之前学的元组(`tuple`)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是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

From 033bda8ea7a18b773456bf74d98f2ce6baaca30a Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Wed, 23 Jul 2014 03:15:57 +0800
Subject: [PATCH 12/13] =?UTF-8?q?Python*.md=EF=BC=9A=E6=95=B4=E4=BD=93?=
 =?UTF-8?q?=E8=B0=83=E6=95=B4=E6=A0=BC=E5=BC=8F=EF=BC=8C=E5=A6=82=E5=88=A0?=
 =?UTF-8?q?=E9=99=A4=E5=A4=9A=E4=BD=99=E7=A9=BA=E8=A1=8C=E3=80=81=E6=95=B4?=
 =?UTF-8?q?=E7=90=86=E4=BB=A3=E7=A0=81=E5=9D=97=E3=80=81=E4=BF=AE=E6=AD=A3?=
 =?UTF-8?q?=E6=A0=87=E7=82=B9=E7=AC=A6=E5=8F=B7=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...53\351\200\237\346\225\231\347\250\213.md" |  23 +-
 ...1\347\250\213 \345\260\276\345\243\260.md" |  28 +--
 ...31\347\250\213\346\200\273\347\273\223.md" |  12 +-
 ...60\351\251\254\350\247\202\350\212\261.md" |  84 +++-----
 ...46\344\271\240\345\207\206\345\244\207.md" |  46 ++--
 "content/Python\347\256\200\345\217\262.md"   |  93 +++-----
 ...27\347\232\204\346\226\271\346\263\225.md" | 200 ++++++++----------
 7 files changed, 166 insertions(+), 320 deletions(-)

diff --git "a/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md" "b/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md"
index 693220a..53ed609 100644
--- "a/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md"	
+++ "b/content/Python\345\260\217\351\242\230\347\233\256 \351\222\210\345\257\271\345\277\253\351\200\237\346\225\231\347\250\213.md"	
@@ -1,37 +1,28 @@
 Python小题目 针对快速教程
 
-
- 
-
 作业的目的是帮助熟悉之前学习的内容：
 
- 
-
- 1.
+1.
 
 写一个程序，判断2008年是否是闰年。
 
-写一个程序，用于计算2008年10月1日是这一年的第几天？（2008年1月1日是这一年的第一天）
+写一个程序，用于计算2008年10月1日是这一年的第几天？（2008年1月1日是这一年的第一天）。
 
 这些小题目是为了方便大家加深对Python理解而设计的。
 
- 
-
 2.
 
-有一个record.txt的文档，内容如下:
+有一个record.txt的文档，内容如下：
+
 ```python
 # name, age, score
-
 tom, 12, 86
-
 Lee, 15, 99
-
 Lucy, 11, 58
-
 Joseph, 19, 56
 ```
-第一栏为姓名(`name`)，第二栏为年纪(`age`)，第三栏为得分(`score`)
+
+第一栏为姓名（`name`），第二栏为年纪（`age`），第三栏为得分（`score`）。
 
 现在，写一个Python程序，
 
@@ -45,4 +36,4 @@ Joseph, 19, 56
 
 所有人的总分是多少?
 
-3）姓名的首字母需要大写，该record.txt是否符合此要求？ 如何纠正错误的地方？
+3）姓名的首字母需要大写，该record.txt是否符合此要求？如何纠正错误的地方？
\ No newline at end of file
diff --git "a/content/Python\345\277\253\351\200\237\346\225\231\347\250\213 \345\260\276\345\243\260.md" "b/content/Python\345\277\253\351\200\237\346\225\231\347\250\213 \345\260\276\345\243\260.md"
index 150c8f1..09ee993 100644
--- "a/content/Python\345\277\253\351\200\237\346\225\231\347\250\213 \345\260\276\345\243\260.md"	
+++ "b/content/Python\345\277\253\351\200\237\346\225\231\347\250\213 \345\260\276\345\243\260.md"	
@@ -1,29 +1,16 @@
 #Python快速教程 尾声
 
-
- 
-
 写了将近两年的Python快速教程，终于大概成形。这一系列文章，包括Python基础、标准库、Django框架。前前后后的文章，包含了Python最重要的组成部分。这一内容的跨度远远超过我的预期，也超过了我看过的任何Python相关书籍。最初动笔的原因，除了要总结，还对很多Python书和教程觉得不满意，觉得太晦涩，又不够全面。现在，我比较确定，参考我在Linux、网络、算法方面的总结，读者可以在无基础的背景下，在短时间，有深度的学习Python了。
 
- 
-
 这一篇也是尾声。准备在一个长的时间内，停止更新Python快速教程，把精力集中在其它方面。毕竟一件事情做久了，会缺乏自我突破。编程是一个很有创新性，很需要突破自我的工作。在一个方面待久了，自己都会觉得发馊。而未知的计算机领域中，还有很多有趣的技术值得更深入的学习。另一方面，Python用舒服了，导致我一想到问题，基本都是Python的思路。这样，Python就成了我的舒服区域。我懒得去想，Java会如何解决，Scala会如何解决，C会如何解决。成长的空间被压缩得很小。为了自己能前进，要打破这个舒适区。
 
- 
-
 谢谢各位阅读这些的Python文章。你们的支持是我走到现在的最大动力。希望这些技术文章能点缀你的闲暇。如果再能有一些具体的帮助，那就最好不过了。
 
- 
-
- 
-
 下面是我在知乎回答的一个帖子“你是如何自学Python的”，略做修改，作为总结：
 
- 
-
 我是自学的Python。从对Python一无所知，到在博客上写Python相关的系列文章，期间有不少门槛，但也充满乐趣。乐趣是自学的最大动力。Python是一个容易编写，又功能强大的动态语言。使用Python，可以在短短几行内实现相当强大的功能。通过自己写一些小程序，迅速的看到效果，发现问题，这是学习Python最便利的地方。在《黑客与画家》中，Paul也说，动态语言可以给Hacker们更多涂涂画画的快感。这深得我心。
 
-在学习Python之前，可以了解一下Python的特点和设计理念(Python简史)。在设计之初，Python就试图在复杂、强大的C和方便、功能有限的bash之间，找到一个平衡点。Python的语法比较简单，用起来很方便，因此有些人把它当作脚本语言使用。但Python要比普通的脚本语言功能强大很多。通过良好的可拓展性，Python的功能相当全面，应用面很广：web服务器，网络爬虫，科学运算，机器学习，游戏开发…… 当然，天下没有免费的午餐，也没有完美的语言，Python为了达到上述两点，有意的牺牲了Python的运行速度。如果你是在编写高业务量、运算量的程序，可能Python并不是最好的选择。
+在学习Python之前，可以了解一下Python的特点和设计理念（Python简史）。在设计之初，Python就试图在复杂、强大的C和方便、功能有限的bash之间，找到一个平衡点。Python的语法比较简单，用起来很方便，因此有些人把它当作脚本语言使用。但Python要比普通的脚本语言功能强大很多。通过良好的可拓展性，Python的功能相当全面，应用面很广：web服务器，网络爬虫，科学运算，机器学习，游戏开发…… 当然，天下没有免费的午餐，也没有完美的语言，Python为了达到上述两点，有意的牺牲了Python的运行速度。如果你是在编写高业务量、运算量的程序，可能Python并不是最好的选择。
 
 -----
 
@@ -39,8 +26,9 @@ Python的主体内容大致可以分为以下几个部分：
 Python号称“Battery Included"，也就是说，功能都已经包含在了语言中。这一自信，主要来自Python功能全面的标准库。标准库提供了许多功能模块，每个模块是某一方面功能的接口，比如文件管理，操作系统互动，字符处理，网络接口，编码加密等等。
 
 The Python Standard Library中，你可以看到标准库模块的列表。这里也是标准库最好的学习资料。如果想找书，我只看到过两本关于标准库的：
-Python Essential Reference
-The Python Standard Library by Example
+
+- 《Python Essential Reference》
+- 《The Python Standard Library by Example》
 
 说实话，这两本都不算很好的标准库教材，而标准库的参考书也确实很难写。因为标准库只是调用功能的接口，最终实现的是Python和系统的互动。这需要很强的系统知识，比如文件系统知识，进程管理，http原理，socket编程，数据库原理…… 如果这些知识都已经准备充分，那么标准库学起来完全没有难度。然而，这些背景知识的学习曲线，要远远陡过Python本身。
 
@@ -51,10 +39,8 @@ The Python Standard Library by Example
 建设一个网站
 做一个网页爬虫
 系统管理
-Python功能全面，所以不要担心自己想的问题Python解决不了 (基本上Python解决不了的问题，别的语言也没戏)。比如我学习多线程的动力，就因为要并行的下载大量的文件。基本上一个项目下来，会用到Python好几块的内容，知识会特别巩固。
-
-最后，和其它任何知识的学习一样，笔记和总结很重要。在看参考书和看网页时，可以做一些笔记。等到学了一段时间后，可以把笔记整理成更有条理的参考卡片(reference card)，或者写博客。
+Python功能全面，所以不要担心自己想的问题Python解决不了（基本上Python解决不了的问题，别的语言也没戏）。比如我学习多线程的动力，就因为要并行的下载大量的文件。基本上一个项目下来，会用到Python好几块的内容，知识会特别巩固。
 
- 
+最后，和其它任何知识的学习一样，笔记和总结很重要。在看参考书和看网页时，可以做一些笔记。等到学了一段时间后，可以把笔记整理成更有条理的参考卡片）reference card），或者写博客。
 
-长路漫漫，与诸君共勉。
+*长路漫漫，与诸君共勉。*
\ No newline at end of file
diff --git "a/content/Python\345\277\253\351\200\237\346\225\231\347\250\213\346\200\273\347\273\223.md" "b/content/Python\345\277\253\351\200\237\346\225\231\347\250\213\346\200\273\347\273\223.md"
index 1ba7308..1299db2 100644
--- "a/content/Python\345\277\253\351\200\237\346\225\231\347\250\213\346\200\273\347\273\223.md"
+++ "b/content/Python\345\277\253\351\200\237\346\225\231\347\250\213\346\200\273\347\273\223.md"
@@ -1,21 +1,13 @@
-Python快速教程总结
-
-
-
- 
+#Python快速教程总结
 
 到现在为止，Python快速教程就到一段落。谢谢大家的鼓励和支持，特别是对其中错误的包容和指正。
 
- 
-
 在第一部分，基础部分中，除了一些基础知识，我们着力于建立对象的概念。在第二部分中，我们深入到许多实用并且常用的Python用法。如果只是想了解Python是什么，那么第一部分应该可以给出一个基本概念。加上第二部分的话，我们应该可以有足够的知识读懂Python程序，并编写一些应用。
 
 我会在以后写一些选读性的随笔，以便对教程更进一步补充。
 
- 
-
 我还在考虑下一步在博客中写什么。Python依然有一个庞大的标准库可以展开。但标准库的讲解离不开对计算机原理和互联网原理的了解，很难以一个快速教程的方式呈现出来。但离开标准库，Python也显得很单薄。一个可能是，先写一个总体纲要，描述一下标准库各个包所包含的内容，以及可能的用途，不知是否可行？
 
 另外，最近看了一些Google Engine和Django的内容，觉得也不错。只可惜自己在这方面经验太浅，不知从何说起。
 
-另一方面，我个人的Python经验也非常有限。希望能多参与到一些项目，以便能积累经验。
+另一方面，我个人的Python经验也非常有限。希望能多参与到一些项目，以便能积累经验。
\ No newline at end of file
diff --git "a/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md" "b/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md"
index 69d461c..5032949 100644
--- "a/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md"
+++ "b/content/Python\346\240\207\345\207\206\345\272\223\342\200\224\342\200\224\350\265\260\351\251\254\350\247\202\350\212\261.md"
@@ -1,26 +1,14 @@
 #Python标准库——走马观花
 
+Python的一大好处在于它有一套很有用的标准库（standard library）。标准库是随着Python一起安装在你的电脑中的，是Python的一部分（当然也有特殊情况。有些场合会因为系统安全性的要求，不使用全部的标准库，比如说Google App Engine）。
 
+利用已有的类（class）和函数（function）进行开发，可以省去你从头写所有程序的苦恼。这些标准库就是盖房子已经烧好的砖，要比你自己去烧砖来得便捷得多。
 
- 
+我将根据我个人的使用经验中，先挑选出标准库下面三个方面的包（package）介绍，以说明标准库的强大功能：
 
-Python的一大好处在于它有一套很有用的标准库(standard library)。标准库是随着Python一起安装在你的电脑中的，是Python的一部分 (当然也有特殊情况。有些场合会因为系统安全性的要求，不使用全部的标准库，比如说Google App Engine)。
-
- 
-
-利用已有的类(class)和函数(function)进行开发，可以省去你从头写所有程序的苦恼。这些标准库就是盖房子已经烧好的砖，要比你自己去烧砖来得便捷得多。
-
- 
-
-我将根据我个人的使用经验中，先挑选出标准库下面三个方面的包(package)介绍，以说明标准库的强大功能：
-
-Python增强
-
-系统互动
-
-网络
-
- 
+- Python增强
+- 系统互动
+- 网络
 
 ##第一类：Python增强
 
@@ -28,92 +16,68 @@ Python自身的已有的一些功能可以随着标准库的使用而得到增
 
 1) 文字处理
 
-Python的`string`类提供了对字符串进行处理的方法。但Python并不止步于此。通过标准库中的`re`包，Python实现了对正则表达式(regular expression)的支持。Python的正则表达式可以和Perl以及Linux bash的正则表达相媲美。
+Python的`string`类提供了对字符串进行处理的方法。但Python并不止步于此。通过标准库中的`re`包，Python实现了对正则表达式（regular expression）的支持。Python的正则表达式可以和Perl以及Linux bash的正则表达相媲美。
 
 （正则表达式通过自定义的模板在文本中搜索或替换符合该模板的字符串。比如你可以搜索一个文本中所有的数字。正则表达式的关键在于根据自己的需要构成模板。）
 
-此外，Python标准库还为字符串的输出提供更加丰富的格式， 比如： `string`包，`textwrap`包。
-
- 
+此外，Python标准库还为字符串的输出提供更加丰富的格式，比如：`string`包、`textwrap`包。
 
 2) 数据对象
 
-我们之前的快速教程介绍了表(list), 字典(dictionary)等数据对象。它们各自有不同的特征，适用于不同场合的对数据的组织和管理。Python的标准库定义了更多的数据对象，比如说数组(array)，队列(Queue)。这些数据对象也分别有各自的特点和功能。一个熟悉数据结构(data structure)的Python用户可以在这些包中找到自己需要的数据结构。
+我们之前的快速教程介绍了表（list）、字典（dictionary）等数据对象。它们各自有不同的特征，适用于不同场合的对数据的组织和管理。Python的标准库定义了更多的数据对象，比如说数组（array），队列（Queue）。这些数据对象也分别有各自的特点和功能。一个熟悉数据结构（data structure）的Python用户可以在这些包中找到自己需要的数据结构。
 
 此外，我们也会经常使用`copy`包，以复制对象。
 
- 
-
 3) 日期和时间
 
-日期和时间的管理并不复杂，但容易犯错。Python的标准库中对日期和时间的管理颇为完善（利用`time`包管理时间，利用`datetime`包管理日期和时间），你不仅可以进行日期时间的查询和变换（比如：2012年7月18日对应的是星期几），还可以对日期时间进行运算(比如2000.1.1 13:00的378小时之后是什么日期，什么时间)。通过这些标准库，还可以根据需要控制日期时间输出的文本格式(比如：输出`'2012-7-18'`还是`'18 Jul 2012'`)
-
- 
+日期和时间的管理并不复杂，但容易犯错。Python的标准库中对日期和时间的管理颇为完善（利用`time`包管理时间，利用`datetime`包管理日期和时间），你不仅可以进行日期时间的查询和变换（比如：2012年7月18日对应的是星期几），还可以对日期时间进行运算（比如2000.1.1 13:00的378小时之后是什么日期，什么时间)。通过这些标准库，还可以根据需要控制日期时间输出的文本格式（比如：输出`'2012-7-18'`还是`'18 Jul 2012'`）
 
 4) 数学运算
 
-标准库中，Python定义了一些新的数字类型(`decimal`包, `fractions`包), 以弥补之前的数字类型(`integer`, `float`)可能的不足。标准库还包含了`random`包，用于处理随机数相关的功能（产生随机数，随机取样等）。`math`包补充了一些重要的数学常数和数学函数，比如pi，三角函数等等。
+标准库中，Python定义了一些新的数字类型（`decimal`包、`fractions`包），以弥补之前的数字类型（`integer`、`float`）可能的不足。标准库还包含了`random`包，用于处理随机数相关的功能（产生随机数，随机取样等）。`math`包补充了一些重要的数学常数和数学函数，比如pi，三角函数等等。
 
-(尽管`numpy`并不是标准库中的包，但它的数组运算的良好支持，让它在基于Python的科研和计算方面得到相当广泛的应用，可以适当关注。)
-
- 
+（尽管`numpy`并不是标准库中的包，但它的数组运算的良好支持，让它在基于Python的科研和计算方面得到相当广泛的应用，可以适当关注。）
 
 5) 存储
 
-之前我们的快速教程中，只提及了文本的输入和输出。实际上，Python可以输入或输出任意的对象。这些对象可以通过标准库中的`pickle`包转换成为二进制格式(binary)，然后存储于文件之中，也可以反向从二进制文件中读取对象。
-
-此外，标准库中还支持基本的数据库功能(`sqlite3`包)。XML和csv格式的文件也有相应的处理包。
-
+之前我们的快速教程中，只提及了文本的输入和输出。实际上，Python可以输入或输出任意的对象。这些对象可以通过标准库中的`pickle`包转换成为二进制格式（binary），然后存储于文件之中，也可以反向从二进制文件中读取对象。
 
+此外，标准库中还支持基本的数据库功能（`sqlite3`包）。XML和csv格式的文件也有相应的处理包。
 
 ##第二类：系统互动
 
-系统互动，主要指Python和操作系统(operate system)、文件系统(file system)的互动。Python可以实现一个操作系统的许多功能。它能够像bash脚本那样管理操作系统，这也是Python有时被成为脚本语言的原因。
-
- 
+系统互动，主要指Python和操作系统（operate system）、文件系统（file system）的互动。Python可以实现一个操作系统的许多功能。它能够像bash脚本那样管理操作系统，这也是Python有时被成为脚本语言的原因。
 
 1) Python运行控制
 
-sys包被用于管理Python自身的运行环境。Python是一个解释器(interpreter), 也是一个运行在操作系统上的程序。我们可以用`sys`包来控制这一程序运行的许多参数，比如说Python运行所能占据的内存和CPU， Python所要扫描的路径等。另一个重要功能是和Python自己的命令行互动，从命令行读取命令和参数。
-
- 
+sys包被用于管理Python自身的运行环境。Python是一个解释器（interpreter），也是一个运行在操作系统上的程序。我们可以用`sys`包来控制这一程序运行的许多参数，比如说Python运行所能占据的内存和CPU， Python所要扫描的路径等。另一个重要功能是和Python自己的命令行互动，从命令行读取命令和参数。
 
 2) 操作系统
 
 如果说Python构成了一个小的世界，那么操作系统就是包围这个小世界的大世界。Python与操作系统的互动可以让Python在自己的小世界里管理整个大世界。
 
-`os`包是Python与操作系统的接口。我们可以用`os`包来实现操作系统的许多功能，比如管理系统进程，改变当前路径(相当于`cd`)，改变文件权限等，建立。但要注意，os包是建立在操作系统的平台上的，许多功能在Windows系统上是无法实现的。另外，在使用`os`包中，要注意其中的有些功能已经被其他的包取代。
+`os`包是Python与操作系统的接口。我们可以用`os`包来实现操作系统的许多功能，比如管理系统进程，改变当前路径（相当于`cd`），改变文件权限等，建立。但要注意，os包是建立在操作系统的平台上的，许多功能在Windows系统上是无法实现的。另外，在使用`os`包中，要注意其中的有些功能已经被其他的包取代。
 
-我们通过文件系统来管理磁盘上储存的文件。查找、删除，复制文件，以及列出文件列表等都是常见的文件操作。这些功能经常可以在操作系统中看到（比如`ls`, `mv`, `cp`等Linux命令），但现在可以通过Python标准库中的`glob`包、`shutil`包、`os.path`包、以及`os`包的一些函数等，在Python内部实现。
+我们通过文件系统来管理磁盘上储存的文件。查找、删除，复制文件，以及列出文件列表等都是常见的文件操作。这些功能经常可以在操作系统中看到（比如`ls`、`mv`、`cp`等Linux命令），但现在可以通过Python标准库中的`glob`包、`shutil`包、`os.path`包以及`os`包的一些函数等，在Python内部实现。
 
 `subprocess`包被用于执行外部命令，其功能相当于我们在操作系统的命令行中输入命令以执行，比如常见的系统命令`ls`或者`cd`，还可以是任意可以在命令行中执行的程序。
 
- 
+3) 线程与进程
 
-4) 线程与进程
-
-Python支持多线程(`threading`包)运行和多进程(`multiprocessing`包)运行。通过多线程和多进程，可以提高系统资源的利用率，提高计算机的处理速度。Python在这些包中，附带有相关的通信和内存管理工具。此外，Python还支持类似于UNIX的signal系统，以实现进程之间的粗糙的信号通信。
-
- 
+Python支持多线程（`threading`包）运行和多进程（`multiprocessing`包）运行。通过多线程和多进程，可以提高系统资源的利用率，提高计算机的处理速度。Python在这些包中，附带有相关的通信和内存管理工具。此外，Python还支持类似于UNIX的signal系统，以实现进程之间的粗糙的信号通信。
 
 ##第三类：网络
 
-现在，网络功能的强弱很大程度上决定了一个语言的成功与否。从Ruby, JavaScript, php身上都可以感受到这一点。Python的标准库对互联网开发的支持并不充分，这也是Django等基于Python的项目的出发点: 增强Python在网络方面的应用功能。这些项目取得了很大的成功，也是许多人愿意来学习Python的一大原因。但应注意到，这些基于Python的项目也是建立在Python标准库的基础上的。
-
- 
+现在，网络功能的强弱很大程度上决定了一个语言的成功与否。从Ruby、JavaScript、php身上都可以感受到这一点。Python的标准库对互联网开发的支持并不充分，这也是Django等基于Python的项目的出发点：增强Python在网络方面的应用功能。这些项目取得了很大的成功，也是许多人愿意来学习Python的一大原因。但应注意到，这些基于Python的项目也是建立在Python标准库的基础上的。
 
 1) 基于socket层的网络应用
 
-socket是网络可编程部分的底层。通过`socket`包，我们可以直接管理socket，比如说将socket赋予给某个端口(port)，连接远程端口，以及通过连接传输数据。我们也可以利用`SocketServer`包更方便地建立服务器。
+socket是网络可编程部分的底层。通过`socket`包，我们可以直接管理socket，比如说将socket赋予给某个端口（port），连接远程端口，以及通过连接传输数据。我们也可以利用`SocketServer`包更方便地建立服务器。
 
 通过与多线程和多进程配合，建立多线程或者多进程的服务器，可以有效提高服务器的工作能力。此外，通过`asyncore`包实现异步处理，也是改善服务器性能的一个方案。
 
- 
-
 2) 互联网应用
 
-在实际应用中，网络的很多底层细节（比如socket）都是被高层的协议隐藏起来的。建立在socket之上的http协议实际上更容易也更经常被使用。http通过request/responce的模式建立连接并进行通信，其信息内容也更容易理解。Python标准库中有http的服务器端和客户端的应用支持(`BaseHTTPServer`包; `urllib`包, `urllib2`包), 并且可以通过`urlparse`包对URL（URL实际上说明了网络资源所在的位置）进行理解和操作。
-
- 
+在实际应用中，网络的很多底层细节（比如socket）都是被高层的协议隐藏起来的。建立在socket之上的http协议实际上更容易也更经常被使用。http通过request/responce的模式建立连接并进行通信，其信息内容也更容易理解。Python标准库中有http的服务器端和客户端的应用支持（`BaseHTTPServer`包、`urllib`包、`urllib2`包），并且可以通过`urlparse`包对URL（URL实际上说明了网络资源所在的位置）进行理解和操作。
 
-以上的介绍比较粗糙，只希望能为大家提供一个了解标准库的入口。欢迎大家一起分享标准库的使用经验。
+以上的介绍比较粗糙，只希望能为大家提供一个了解标准库的入口。欢迎大家一起分享标准库的使用经验。
\ No newline at end of file
diff --git "a/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md" "b/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md"
index 9d2f41d..f76d9c5 100644
--- "a/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md"
+++ "b/content/Python\346\240\207\345\207\206\345\272\223\347\232\204\345\255\246\344\271\240\345\207\206\345\244\207.md"
@@ -1,44 +1,34 @@
 #Python标准库的学习准备
 
-
-
- 
-
 Python标准库是Python强大的动力所在，我们已经在前文中有所介绍。由于标准库所涉及的应用很广，所以需要学习一定的背景知识。
 
- 
-
 ##硬件原理
 
 这一部份需要了解内存，CPU，磁盘存储以及IO的功能和性能，了解计算机工作的流程，了解指令的概念。这些内容基础而重要。
 
-Python标准库的一部份是为了提高系统的性能(比如mmap)，所以有必要了解基本的计算机各个组成部分的性能。
-
- 
+Python标准库的一部份是为了提高系统的性能（比如mmap），所以有必要了解基本的计算机各个组成部分的性能。
 
 ##操作系统
 
 在了解操作系统时，下面是重点：
 
-1) 操作系统的进程管理，比如什么是UID, PID, daemon
+1) 操作系统的进程管理，比如什么是UID、PID、daemon。
 
-2) 进程之间的信号通信，比如使用kill传递信号的方式
+2) 进程之间的信号通信，比如使用kill传递信号的方式。
 
-学习进程相关的内容，是为了方便于学习os包，thread包，multiprocessing包，signal包
+学习进程相关的内容，是为了方便于学习os包、thread包、multiprocessing包、signal包。
 
 3) 文件管理，文件的几种类型。
 
-4) 文件读写(IO)接口
+4) 文件读写（IO）接口。
 
-5) 文件的权限以及其它的文件信息(meta data)
+5) 文件的权限以及其它的文件信息（meta data）。
 
-6) 常用系统命令以及应用，比如ls, mv, rm, mkdir, chmod, zip, tar..., 
+6) 常用系统命令以及应用，比如`ls`、`mv`、`rm`、`mkdir`、`chmod`、`zip`、`tar`...。
 
-学习文件相关的内容，是为了学习`os`包, `shutil`包中文件管理相关的部分。学习文件接口对于文本输入输出的理解很重要，也会影响到对于`socket`包, `select`包概念的理解。此外，python中的归档(archive)和压缩(compress)功能也和操作系统中的类似。
+学习文件相关的内容，是为了学习`os`包、`shutil`包中文件管理相关的部分。学习文件接口对于文本输入输出的理解很重要，也会影响到对于`socket`包、`select`包概念的理解。此外，python中的归档（archive）和压缩（compress）功能也和操作系统中的类似。
 
-7) Linux shell，比如说file name matching，对于理解glob包等有帮助。如果你对Linux的正则表达(regular expression)有了解的话，python的正则表达的学习会变得比较容易。学习Linux命令行中的参数传递对于理解python标准库中解析命令行的包也是有用的。
-
- 
+7) Linux shell，比如说file name matching，对于理解glob包等有帮助。如果你对Linux的正则表达（regular expression）有了解的话，python的正则表达的学习会变得比较容易。学习Linux命令行中的参数传递对于理解python标准库中解析命令行的包也是有用的。
 
 ##网络
 
@@ -46,29 +36,23 @@ Python的一大应用是在网络方面。但Python和标准库只是提供了
 
 1) TCP/IP的基础的分层架构。这方面的内容太广博了，所以可以有选择地了解骨干知识。
 
-2) 常用的应用层协议，比如http, 以及邮件相关的协议，特别是它们的工作过程。
+2) 常用的应用层协议，比如http以及邮件相关的协议，特别是它们的工作过程。
 
 3) 根据需要，了解html/css/javascript/jQuery/frame等
 
 如果想利用python建服务器，比如在google app engine上，这些知识是需要的。
 
- 
-
 ##算法与数据结构
 
-标准库中定义有一些数据对象的封装。因此，你并不需要重头编写它们。相关数据结构的应用需要一些数据结构的知识，比如队列，树等。
+标准库中定义有一些数据对象的封装。因此，你并不需要重头编写它们。相关数据结构的应用需要一些数据结构的知识，比如队列、树等。
 
 标准库中已经实现了许多算法，比如排序等，可以方便的调用。算法的基础知识可以帮助你做决定。
 
- 
-
 ##数据库
 
 Python中内置了sqlite3。如果你只需要一个简单的数据库，可以直接从标准库中调用sqlite3。
 
-当使用Python中数据库相关的包时(比如sqlite3)，需要对数据库，特别是关系型数据库，有一个基本了解。
-
- 
+当使用Python中数据库相关的包时（比如sqlite3），需要对数据库，特别是关系型数据库，有一个基本了解。
 
 ##加密和文本编码
 
@@ -76,9 +60,7 @@ Python的加密算法同样基于一些经典加密算法，比如MD5，RSA算
 
 使用非ASCII编码，比如中文时，文本编码的知识很重要。
 
- 
-
-总结 
+##总结 
 
 Python基本的对象概念和动态类型概念。可以参照快速教程，并尝试阅读更多的资料和源码，来加深对概念的理解。Python标准库学习
-的难度在于背景知识。一个了解相关背景知识(或者其它语言的库)的程序员，可以在很短的时间内掌握Python基础库。
+的难度在于背景知识。一个了解相关背景知识（或者其它语言的库）的程序员，可以在很短的时间内掌握Python基础库。
\ No newline at end of file
diff --git "a/content/Python\347\256\200\345\217\262.md" "b/content/Python\347\256\200\345\217\262.md"
index 281b349..c29cf68 100644
--- "a/content/Python\347\256\200\345\217\262.md"
+++ "b/content/Python\347\256\200\345\217\262.md"
@@ -1,45 +1,32 @@
 #Python简史
 
-
- 
-
 Python是我喜欢的语言，简洁，优美，容易使用。前两天，我很激昂的向朋友宣传Python的好处。
 
 听过之后，朋友问我：好吧，我承认Python不错，但它为什么叫Python呢？
 
 我不是很确定：呃，似乎是一个电视剧的名字。
 
-朋友又问：那你说的Guido是美国人么？ (Guido von Rossum，Python的作者)
-
-我再次不是很确定：他从google换到Dropbox工作，但他的名字像是荷兰人的 (有一个von在中间)。
+朋友又问：那你说的Guido是美国人么？（Guido von Rossum，Python的作者）
 
- 
+我再次不是很确定：他从google换到Dropbox工作，但他的名字像是荷兰人的（有一个von在中间）。
 
-所以，后面我花了些时间调查Python的历史。这是很好的学习。我看到了Python中许多功能的来源和Python的设计理念，比如哪些功能是历史遗留，哪些功能是重复，如何增加功能…… 而且，Python也是开源(open source)运动的一个成功案例。从Python的历史中，我们可以一窥开源开发的理念和成就。
+所以，后面我花了些时间调查Python的历史。这是很好的学习。我看到了Python中许多功能的来源和Python的设计理念，比如哪些功能是历史遗留，哪些功能是重复，如何增加功能…… 而且，Python也是开源（open source）运动的一个成功案例。从Python的历史中，我们可以一窥开源开发的理念和成就。
 
 这也可以作为我写的Python快速教程的序篇。
 
- 
-
 ##Python的起源
 
-Python的作者，Guido von Rossum，确实是荷兰人。1982年，Guido从阿姆斯特丹大学(University of Amsterdam)获得了数学和计算机硕士学位。然而，尽管他算得上是一位数学家，但他更加享受计算机带来的乐趣。用他的话说，尽管拥有数学和计算机双料资质，他总趋向于做计算机相关的工作，并热衷于做任何和编程相关的活儿。
-
-
+Python的作者，Guido von Rossum，确实是荷兰人。1982年，Guido从阿姆斯特丹大学（University of Amsterdam）获得了数学和计算机硕士学位。然而，尽管他算得上是一位数学家，但他更加享受计算机带来的乐趣。用他的话说，尽管拥有数学和计算机双料资质，他总趋向于做计算机相关的工作，并热衷于做任何和编程相关的活儿。
 
-在那个时候，他接触并使用过诸如Pascal、C、 Fortran等语言。这些语言的基本设计原则是让机器能更快运行。在80年代，虽然IBM和苹果已经掀起了个人电脑浪潮，但这些个人电脑的配置很低 (在今天看来)。比如早期的Macintosh，只有8MHz的CPU主频和128KB的RAM，一个大的数组就能占满内存。所有的编译器的核心是做优化，以便让程序能够运行。为了增进效率，语言也迫使程序员像计算机一样思考，以便能写出更符合机器口味的程序。在那个时代，程序员恨不得用手榨取计算机每一寸的能力。有人甚至认为C语言的指针是在浪费内存。至于动态类型，内存自动管理，面向对象…… 别想了，那会让你的电脑陷入瘫痪。
+在那个时候，他接触并使用过诸如Pascal、C、 Fortran等语言。这些语言的基本设计原则是让机器能更快运行。在80年代，虽然IBM和苹果已经掀起了个人电脑浪潮，但这些个人电脑的配置很低（在今天看来）。比如早期的Macintosh，只有8MHz的CPU主频和128KB的RAM，一个大的数组就能占满内存。所有的编译器的核心是做优化，以便让程序能够运行。为了增进效率，语言也迫使程序员像计算机一样思考，以便能写出更符合机器口味的程序。在那个时代，程序员恨不得用手榨取计算机每一寸的能力。有人甚至认为C语言的指针是在浪费内存。至于动态类型，内存自动管理，面向对象…… 别想了，那会让你的电脑陷入瘫痪。
 
- 
+然而，这种思考方式让Guido感到苦恼。Guido知道如何用C语言写出一个功能，但整个编写过程需要耗费大量的时间（即使他已经准确的知道了如何实现）。他的另一个选择是shell。Bourne Shell作为UNIX系统的解释器（interpreter）已经长期存在。UNIX的管理员们常常用shell去写一些简单的脚本，以进行一些系统维护的工作，比如定期备份、文件系统管理等等。shell可以像胶水一样，将UNIX下的许多功能连接在一起。许多C语言下上百行的程序，在shell下只用几行就可以完成。然而，shell的本质是调用命令。它并不是一个真正的语言。比如说，shell没有数值型的数据类型，加法运算都很复杂。总之，shell不能全面的调动计算机的功能。
 
-然而，这种思考方式让Guido感到苦恼。Guido知道如何用C语言写出一个功能，但整个编写过程需要耗费大量的时间 (即使他已经准确的知道了如何实现)。他的另一个选择是shell。Bourne Shell作为UNIX系统的解释器(interpreter)已经长期存在。UNIX的管理员们常常用shell去写一些简单的脚本，以进行一些系统维护的工作，比如定期备份、文件系统管理等等。shell可以像胶水一样，将UNIX下的许多功能连接在一起。许多C语言下上百行的程序，在shell下只用几行就可以完成。然而，shell的本质是调用命令。它并不是一个真正的语言。比如说，shell没有数值型的数据类型，加法运算都很复杂。总之，shell不能全面的调动计算机的功能。
+（关于shell，你可以参考Linux架构和Linux命令行与命令）
 
-(关于shell，你可以参考Linux架构和Linux命令行与命令)
+Guido希望有一种语言，这种语言能够像C语言那样，能够全面调用计算机的功能接口，又可以像shell那样，可以轻松的编程。ABC语言让Guido看到希望。ABC是由荷兰的CWI（Centrum Wiskunde & Informatica，数学和计算机研究所）开发的。Guido在CWI工作，并参与到ABC语言的开发。ABC语言以教学为目的。与当时的大部分语言不同，ABC语言的目标是“让用户感觉更好”。ABC语言希望让语言变得容易阅读，容易使用，容易记忆，容易学习，并以此来激发人们学习编程的兴趣。比如下面是一段来自Wikipedia的ABC程序，这个程序用于统计文本中出现的词（word）的总数：
 
- 
-
-Guido希望有一种语言，这种语言能够像C语言那样，能够全面调用计算机的功能接口，又可以像shell那样，可以轻松的编程。ABC语言让Guido看到希望。ABC是由荷兰的CWI (Centrum Wiskunde & Informatica, 数学和计算机研究所)开发的。Guido在CWI工作，并参与到ABC语言的开发。ABC语言以教学为目的。与当时的大部分语言不同，ABC语言的目标是“让用户感觉更好”。ABC语言希望让语言变得容易阅读，容易使用，容易记忆，容易学习，并以此来激发人们学习编程的兴趣。比如下面是一段来自Wikipedia的ABC程序，这个程序用于统计文本中出现的词(word)的总数：
-
-```python
+```ABC
 HOW TO RETURN words document:
    PUT {} IN collection
    FOR line IN document:
@@ -48,69 +35,55 @@ HOW TO RETURN words document:
             INSERT word IN collection
    RETURN collection
 ```
-`HOW TO`用于定义一个函数。一个Python程序员应该很容易理解这段程序。ABC语言使用冒号(`:`)和缩进来表示程序块(C语言使用`{}`来表示程序块)。行尾没有分号。`for`和`if`结构中也没有括号`()`。如果将`HOW TO`改为`def`，将`PUT`行改为`collection = []`，将`INSERT`行改为`collection.append(word)`，这就几乎是一个标准的Python函数。上面的函数读起来就像一段自然的文字。
 
- 
+`HOW TO`用于定义一个函数。一个Python程序员应该很容易理解这段程序。ABC语言使用冒号`:`和缩进来表示程序块（C语言使用`{}`来表示程序块）。行尾没有分号。`for`和`if`结构中也没有括号`()`。如果将`HOW TO`改为`def`，将`PUT`行改为`collection = []`，将`INSERT`行改为`collection.append(word)`，这就几乎是一个标准的Python函数。上面的函数读起来就像一段自然的文字。
 
 尽管已经具备了良好的可读性和易用性，ABC语言最终没有流行起来。在当时，ABC语言编译器需要比较高配置的电脑才能运行。而这些电脑的使用者通常精通计算机，他们更多考虑程序的效率，而非它的学习难度。除了硬件上的困难外，ABC语言的设计也存在一些致命的问题：
 
 可拓展性差。ABC语言不是模块化语言。如果想在ABC语言中增加功能，比如对图形化的支持，就必须改动很多地方。
 不能直接进行IO。ABC语言不能直接操作文件系统。尽管你可以通过诸如文本流的方式导入数据，但ABC无法直接读写文件。输入输出的困难对于计算机语言来说是致命的。你能想像一个打不开车门的跑车么？
-过度革新。ABC用自然语言的方式来表达程序的意义，比如上面程序中的`HOW TO`(如何)。然而对于程序员来说，他们更习惯用`function`或者`define`来定义一个函数。同样，程序员也习惯了用等号(`=`)来分配变量。这尽管让ABC语言显得特别，但实际上增加了程序员的学习难度 (程序员大都掌握不止一种语言)。
-传播困难。ABC编译器很大，必须被保存在磁带(tape)上。当时Guido在访问的时候，就必须有一个大磁带来给别人安装ABC编译器。 这样，ABC语言就很难快速传播。
-IBM tape drive：读写磁带
+过度革新。ABC用自然语言的方式来表达程序的意义，比如上面程序中的`HOW TO`（如何）。然而对于程序员来说，他们更习惯用`function`或者`define`来定义一个函数。同样，程序员也习惯了用等号`=`来分配变量。这尽管让ABC语言显得特别，但实际上增加了程序员的学习难度（程序员大都掌握不止一种语言）。
+传播困难。ABC编译器很大，必须被保存在磁带（tape）上。当时Guido在访问的时候，就必须有一个大磁带来给别人安装ABC编译器。 这样，ABC语言就很难快速传播。
 
- 
-
-1989年，为了打发圣诞节假期，Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧Monty Python's Flying Circus (BBC1960-1970年代播放的室内情景幽默剧，以当时的英国生活为素材)。他希望这个新的叫做Python的语言，能实现他的理念(一种C和shell之间，功能全面，易学易用，可拓展的语言)。Guido作为一个语言设计爱好者，已经有过设计语言的(不很成功)的尝试。这一次，也不过是一次纯粹的hacking行为。
+IBM tape drive：读写磁带
 
- 
+1989年，为了打发圣诞节假期，Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧Monty Python's Flying Circus（BBC1960-1970年代播放的室内情景幽默剧，以当时的英国生活为素材）。他希望这个新的叫做Python的语言，能实现他的理念（一种C和shell之间，功能全面，易学易用，可拓展的语言）。Guido作为一个语言设计爱好者，已经有过设计语言的（不很成功）的尝试。这一次，也不过是一次纯粹的hacking行为。
 
 ##Python的诞生
 
-1991年，第一个Python编译器(同时也是解释器)诞生。它是用C语言实现的，并能够调用C库(.so文件)。从一出生，Python已经具有了：类(class)，函数(function)，异常处理(exception)，包括表(list)和词典(dictionary)在内的核心数据类型，以及模块(module)为基础的拓展系统。
+1991年，第一个Python编译器（同时也是解释器）诞生。它是用C语言实现的，并能够调用C库（.so文件）。从一出生，Python已经具有了：类（class），函数（function），异常处理（exception），包括表（list）和词典（dictionary）在内的核心数据类型，以及模块（module）为基础的拓展系统。
 
+最初的Python logo：由Guido的兄弟Just von Rossum设计
 
+Python语法很多来自C，但又受到ABC语言的强烈影响。来自ABC语言的一些规定直到今天还富有争议，比如强制缩进。但这些语法规定让Python容易读。另一方面，Python聪明的选择服从一些惯例（特别是C语言的惯例）。比如使用等号赋值，使用`def`来定义函数。Guido认为，如果“常识”上确立的东西，没有必要过度纠结。
 
-最初的Python logo: 由Guido的兄弟Just von Rossum设计
+Python从一开始就特别在意可拓展性（extensibility）。Python可以在多个层次上拓展。从高层上，你可以引入.py文件。在底层，你可以引用C语言的库。Python程序员可以快速的使用Python写.py文件作为拓展模块。但当性能是考虑的重要因素时，Python程序员可以深入底层，写C程序，编译为.so文件引入到Python中使用。Python就好像是使用钢构建房一样，先规定好大的框架。而程序员可以在此框架下相当自由的拓展或更改。
 
-Python语法很多来自C，但又受到ABC语言的强烈影响。来自ABC语言的一些规定直到今天还富有争议，比如强制缩进。但这些语法规定让Python容易读。另一方面，Python聪明的选择服从一些惯例(特别是C语言的惯例)。比如使用等号赋值，使用`def`来定义函数。Guido认为，如果“常识”上确立的东西，没有必要过度纠结。
+最初的Python完全由Guido本人开发。Python得到Guido同事的欢迎。他们迅速的反馈使用意见，并参与到Python的改进。Guido和一些同事构成Python的核心团队。他们将自己大部分的业余时间用于hack Python（也包括工作时间，因为他们将Python用于工作）。随后，Python拓展到CWI之外。Python将许多机器层面上的细节隐藏，交给编译器处理，并凸显出逻辑层面的编程思考。Python程序员可以花更多的时间用于思考程序的逻辑，而不是具体的实现细节（Guido有一件T恤，写着：人生苦短，我用Python）。这一特征吸引了广大的程序员。Python开始流行。
 
-Python从一开始就特别在意可拓展性(extensibility)。Python可以在多个层次上拓展。从高层上，你可以引入.py文件。在底层，你可以引用C语言的库。Python程序员可以快速的使用Python写.py文件作为拓展模块。但当性能是考虑的重要因素时，Python程序员可以深入底层，写C程序，编译为.so文件引入到Python中使用。Python就好像是使用钢构建房一样，先规定好大的框架。而程序员可以在此框架下相当自由的拓展或更改。
-
-最初的Python完全由Guido本人开发。Python得到Guido同事的欢迎。他们迅速的反馈使用意见，并参与到Python的改进。Guido和一些同事构成Python的核心团队。他们将自己大部分的业余时间用于hack Python (也包括工作时间，因为他们将Python用于工作)。随后，Python拓展到CWI之外。Python将许多机器层面上的细节隐藏，交给编译器处理，并凸显出逻辑层面的编程思考。Python程序员可以花更多的时间用于思考程序的逻辑，而不是具体的实现细节 (Guido有一件T恤，写着：人生苦短，我用Python)。这一特征吸引了广大的程序员。Python开始流行。
-
- 
-
-我们不得不暂停我们的Python时间，转而看一看这时的计算机概况。1990年代初，个人计算机开始进入普通家庭。Intel发布了486处理器，windows发布window 3.0开始的一系列视窗系统。计算机的性能大大提高。程序员开始关注计算机的易用性  (比如图形化界面)。 
+我们不得不暂停我们的Python时间，转而看一看这时的计算机概况。1990年代初，个人计算机开始进入普通家庭。Intel发布了486处理器，windows发布window 3.0开始的一系列视窗系统。计算机的性能大大提高。程序员开始关注计算机的易用性（比如图形化界面）。
 
 Windows 3.0
 
 由于计算机性能的提高，软件的世界也开始随之改变。硬件足以满足许多个人电脑的需要。硬件厂商甚至渴望高需求软件的出现，以带动硬件的更新换代。C++和Java相继流行。C++和Java提供了面向对象的编程范式，以及丰富的对象库。在牺牲了一定的性能的代价下，C++和Java大大提高了程序的产量。语言的易用性被提到一个新的高度。我们还记得，ABC失败的一个重要原因是硬件的性能限制。从这方面说，Python要比ABC幸运许多。
 
-另一个悄然发生的改变是Internet。1990年代还是个人电脑的时代，windows和Intel挟PC以令天下，盛极一时。尽管Internet为主体的信息革命尚未到来，但许多程序员以及资深计算机用户已经在频繁使用Internet进行交流 (包括email和newsgroup)。Internet让信息交流成本大大下降。一种新的软件开发模式开始流行：开源 (open source)。程序员利用业余时间进行软件开发，并开放源代码。1991年，Linus在comp.os.minix新闻组上发布了Linux内核源代码，吸引大批hacker的加入。Linux和GNU相互合作，最终构成了一个充满活力的开源平台。
-
- 
+另一个悄然发生的改变是Internet。1990年代还是个人电脑的时代，windows和Intel挟PC以令天下，盛极一时。尽管Internet为主体的信息革命尚未到来，但许多程序员以及资深计算机用户已经在频繁使用Internet进行交流（包括email和newsgroup）。Internet让信息交流成本大大下降。一种新的软件开发模式开始流行：开源（open source）。程序员利用业余时间进行软件开发，并开放源代码。1991年，Linus在comp.os.minix新闻组上发布了Linux内核源代码，吸引大批hacker的加入。Linux和GNU相互合作，最终构成了一个充满活力的开源平台。
 
 硬件性能不是瓶颈，Python又容易使用，所以许多人开始转向Python。Guido维护了一个maillist，Python用户就通过邮件进行交流。Python用户来自许多领域，有不同的背景，对Python也有不同的需求。Python相当的开放，又容易拓展，所以当用户不满足于现有功能，很容易对Python进行拓展或改造。随后，这些用户将改动发给Guido，并由Guido决定是否将新的特征加入到Python或者标准库中。如果代码能被纳入Python自身或者标准库，这将极大的荣誉。Python自身也因此变得更好。
 
-(Guido不得不作出许多决定，这也是他被称为Benevolent Dictator For Life的原因)
-
-Python被称为“Battery Included”，是说它以及其标准库的功能强大。这些是整个社区的贡献。Python的开发者来自不同领域，他们将不同领域的优点带给Python。比如Python标准库中的正则表达(regular expression)是参考Perl，而`lambda`, `map`, `filter`, `reduce`函数参考Lisp。Python本身的一些功能以及大部分的标准库来自于社区。Python的社区不断扩大，进而拥有了自己的newsgroup，网站(python.org)，以及基金 (Python Software Foundation)。从Python 2.0开始，Python也从maillist的开发方式，转为完全开源的开发方式。社区气氛已经形成，工作被整个社区分担，Python也获得了更加高速的发展。
-
-(由于Guido享有绝对的仲裁权，所以在Python早期maillist的开发时代，不少爱好者相当担心Guido的生命。他们甚至作出假设：如果Guido挂了的话，Python会怎样。见If Guido was hit by a bus)
+（Guido不得不作出许多决定，这也是他被称为Benevolent Dictator For Life的原因）
 
-到今天，Python的框架已经确立。Python语言以对象为核心组织代码(Everything is object)，支持多种编程范式(multi-paradigm)，采用动态类型(dynamic typing)，自动进行内存回收(garbage collection)。Python支持解释运行(interpret)，并能调用C库进行拓展。Python有强大的标准库 (battery included)。由于标准库的体系已经稳定，所以Python的生态系统开始拓展到第三方包。这些包，如`Django`, `web.py`, `wxpython`, `numpy`, `matplotlib`,`PIL`，将Python升级成了物种丰富的热带雨林。
+Python被称为“Battery Included”，是说它以及其标准库的功能强大。这些是整个社区的贡献。Python的开发者来自不同领域，他们将不同领域的优点带给Python。比如Python标准库中的正则表达（regular expression）是参考Perl，而`lambda`、`map`、`filter`、`reduce`函数参考Lisp。Python本身的一些功能以及大部分的标准库来自于社区。Python的社区不断扩大，进而拥有了自己的newsgroup，网站（python.org），以及基金（Python Software Foundation）。从Python 2.0开始，Python也从maillist的开发方式，转为完全开源的开发方式。社区气氛已经形成，工作被整个社区分担，Python也获得了更加高速的发展。
 
- 
+（由于Guido享有绝对的仲裁权，所以在Python早期maillist的开发时代，不少爱好者相当担心Guido的生命。他们甚至作出假设：如果Guido挂了的话，Python会怎样。见If Guido was hit by a bus）
 
-今天Python已经进入到3.0的时代。由于Python 3.0向后不兼容，所以从2.0到3.0的过渡并不容易。另一方面，Python的性能依然值得改进，Python的运算性能低于C++和Java(见Google的讨论)。Python依然是一个在发展中的语言。我期待看到Python的未来。
+到今天，Python的框架已经确立。Python语言以对象为核心组织代码（Everything is object），支持多种编程范式（multi-paradigm），采用动态类型（dynamic typing），自动进行内存回收（garbage collection）。Python支持解释运行（interpret），并能调用C库进行拓展。Python有强大的标准库（battery included）。由于标准库的体系已经稳定，所以Python的生态系统开始拓展到第三方包。这些包，如`Django`、`web.py`、`wxpython`、`numpy`、`matplotlib`、`PIL`，将Python升级成了物种丰富的热带雨林。
 
- 
+今天Python已经进入到3.0的时代。由于Python 3.0向后不兼容，所以从2.0到3.0的过渡并不容易。另一方面，Python的性能依然值得改进，Python的运算性能低于C++和Java（见Google的讨论）。Python依然是一个在发展中的语言。我期待看到Python的未来。
 
 ##Python启示录
 
-Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言 (TIOBE语言排行第八，Google的第三大开发语言，Dropbox的基础语言，豆瓣的服务器语言)。这个世界并不缺乏优秀的语言，但Python的发展史作为一个代表，带给我许多启示。
+Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言（TIOBE语言排行第八，Google的第三大开发语言，Dropbox的基础语言，豆瓣的服务器语言）。这个世界并不缺乏优秀的语言，但Python的发展史作为一个代表，带给我许多启示。
 
 在Python的开发过程中，社区起到了重要的作用。Guido自认为自己不是全能型的程序员，所以他只负责制订框架。如果问题太复杂，他会选择绕过去，也就是cut the corner。这些问题最终由社区中的其他人解决。社区中的人才是异常丰富的，就连创建网站，筹集基金这样与开发稍远的事情，也有人乐意于处理。如今的项目开发越来越复杂，越来越庞大，合作以及开放的心态成为项目最终成功的关键。
 
@@ -118,20 +91,12 @@ Python从其他语言中学到了很多，无论是已经进入历史的ABC，
 
 无论Python未来的命运如何，Python的历史已经是本很有趣的小说。
 
- 
-
 如果你因为本文对Python产生了兴趣，欢迎阅读我的Python快速教程。
 
- 
-
 本文主要参考：
 
-Guido在Dropbox所做演讲
-
-
-
-http://v.youku.com/v_show/id_XNTExOTc1NTU2.html
+[Guido在Dropbox所做演讲](http://v.youku.com/v_show/id_XNTExOTc1NTU2.html)
 
 python.org的文档
 
-Wikipedia
+Wikipedia
\ No newline at end of file
diff --git "a/content/Python\350\241\245\345\205\20501 \345\272\217\345\210\227\347\232\204\346\226\271\346\263\225.md" "b/content/Python\350\241\245\345\205\20501 \345\272\217\345\210\227\347\232\204\346\226\271\346\263\225.md"
index d4df176..63e9391 100644
--- "a/content/Python\350\241\245\345\205\20501 \345\272\217\345\210\227\347\232\204\346\226\271\346\263\225.md"	
+++ "b/content/Python\350\241\245\345\205\20501 \345\272\217\345\210\227\347\232\204\346\226\271\346\263\225.md"	
@@ -1,123 +1,89 @@
 #Python补充01 序列的方法
 
+在快速教程中，我们了解了最基本的序列（sequence）。回忆一下，序列包含有定值表（tuple）和表（list）。此外，字符串（string）是一种特殊的定值表。表的元素可以更改，定值表一旦建立，其元素不可更改。
 
+任何的序列都可以引用其中的元素（item）。
 
-在快速教程中，我们了解了最基本的序列(sequence)。回忆一下，序列包含有定值表(tuple)和表(list)。此外，字符串(string)是一种特殊的定值表。表的元素可以更改，定值表一旦建立，其元素不可更改。
-
- 
-
-任何的序列都可以引用其中的元素(item)。
-
- 
-
-下面的内建函数(built-in function)可用于序列(表，定值表，字符串):
+下面的内建函数（built-in function）可用于序列（表、定值表、字符串）：
 
+```python
 # s为一个序列
-
-len(s)         返回： 序列中包含元素的个数
-
-min(s)         返回： 序列中最小的元素
-
-max(s)         返回： 序列中最大的元素
-
-all(s)         返回： True, 如果所有元素都为True的话
-
-any(s)         返回： True, 如果任一元素为True的话
-
- 
-
-下面的方法主要起查询功能，不改变序列本身, 可用于表和定值表:
-
-sum(s)         返回：序列中所有元素的和
-
-# x为元素值，i为下标(元素在序列中的位置)
-
-s.count(x)     返回： x在s中出现的次数
-
-s.index(x)     返回： x在s中第一次出现的下标
-
- 
-
-由于定值表的元素不可变更，下面方法只适用于表:
-
-# l为一个表, l2为另一个表
-
-l.extend(l2)        在表l的末尾添加表l2的所有元素
-
-l.append(x)         在l的末尾附加x元素
-
-l.sort()            对l中的元素排序
-
-l.reverse()         将l中的元素逆序
-
-l.pop()             返回：表l的最后一个元素，并在表l中删除该元素
-
-del l[i]            删除该元素
-
-(以上这些方法都是在原来的表的上进行操作，会对原来的表产生影响，而不是返回一个新表。)
-
- 
-
-下面是一些用于字符串的方法。尽管字符串是定值表的特殊的一种，但字符串(string)类有一些方法是改变字符串的。这些方法的本质不是对原有字符串进行操作，而是删除原有字符串，再建立一个新的字符串，所以并不与定值表的特点相矛盾。
-
-#str为一个字符串，sub为str的一个子字符串。s为一个序列，它的元素都是字符串。width为一个整数，用于说明新生成字符串的宽度。
-
-str.count(sub)       返回：sub在str中出现的次数
-
-str.find(sub)        返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1
-
-str.index(sub)       返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误
-
-str.rfind(sub)       返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1
-
-str.rindex(sub)      返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误
-
- 
-
-str.isalnum()        返回：True， 如果所有的字符都是字母或数字
-
-str.isalpha()        返回：True，如果所有的字符都是字母
-
-str.isdigit()        返回：True，如果所有的字符都是数字
-
-str.istitle()        返回：True，如果所有的词的首字母都是大写
-
-str.isspace()        返回：True，如果所有的字符都是空格
-
-str.islower()        返回：True，如果所有的字符都是小写字母
-
-str.isupper()        返回：True，如果所有的字符都是大写字母
-
- 
-
-str.split([sep, [max]])    返回：从左开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。可以str.split(',')的方式使用逗号或者其它分割符
-
-str.rsplit([sep, [max]])   返回：从右开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。可以str.rsplit(',')的方式使用逗号或者其它分割符
-
- 
-
-str.join(s)                返回：将s中的元素，以str为分割符，合并成为一个字符串。
-
-str.strip([sub])           返回：去掉字符串开头和结尾的空格。也可以提供参数sub，去掉位于字符串开头和结尾的sub  
-
-str.replace(sub, new_sub)  返回：用一个新的字符串new_sub替换str中的sub
-
-         
-
-str.capitalize()           返回：将str第一个字母大写
-
-str.lower()                返回：将str全部字母改为小写
-
-str.upper()                返回：将str全部字母改为大写
-
-str.swapcase()             返回：将str大写字母改为小写，小写改为大写
-
-str.title()                返回：将str的每个词(以空格分隔)的首字母大写
-
- 
-
-str.center(width)          返回：长度为width的字符串，将原字符串放入该字符串中心，其它空余位置为空格。
-
-str.ljust(width)           返回：长度为width的字符串，将原字符串左对齐放入该字符串，其它空余位置为空格。
-
-str.rjust(width)           返回：长度为width的字符串，将原字符串右对齐放入该字符串，其它空余位置为空格。
+len(s)        # 返回： 序列中包含元素的个数
+min(s)        # 返回： 序列中最小的元素
+max(s)        # 返回： 序列中最大的元素
+all(s)        # 返回： True，如果所有元素都为True的话
+any(s)        # 返回： True，如果任一元素为True的话
+```
+
+下面的方法主要起查询功能，不改变序列本身，可用于表和定值表：
+
+```python
+sum(s)        # 返回：序列中所有元素的和
+
+# x为元素值，i为下标（元素在序列中的位置）
+
+s.count(x)    # 返回： x在s中出现的次数
+s.index(x)    # 返回： x在s中第一次出现的下标
+```
+
+由于定值表的元素不可变更，下面方法只适用于表：
+
+```python
+# l为一个表，l2为另一个表
+
+l.extend(l2)       # 在表l的末尾添加表l2的所有元素
+l.append(x)        # 在l的末尾附加x元素
+l.sort()           # 对l中的元素排序
+l.reverse()        # 将l中的元素逆序
+l.pop()            # 返回：表l的最后一个元素，并在表l中删除该元素
+del l[i]           # 删除该元素
+```
+
+（以上这些方法都是在原来的表的上进行操作，会对原来的表产生影响，而不是返回一个新表。）
+
+下面是一些用于字符串的方法。尽管字符串是定值表的特殊的一种，但字符串（string）类有一些方法是改变字符串的。这些方法的本质不是对原有字符串进行操作，而是删除原有字符串，再建立一个新的字符串，所以并不与定值表的特点相矛盾。
+
+```python
+#str为一个字符串，sub为str的一个子字符串。
+#s为一个序列，它的元素都是字符串。
+#width为一个整数，用于说明新生成字符串的宽度。
+
+str.count(sub)      # 返回：sub在str中出现的次数
+str.find(sub)       # 返回：从左开始，查找sub在str中第一次出现的位置。
+                    #      如果str中不包含sub，返回 -1
+str.index(sub)      # 返回：从左开始，查找sub在str中第一次出现的位置。
+                    #      如果str中不包含sub，举出错误
+str.rfind(sub)      # 返回：从右开始，查找sub在str中第一次出现的位置。
+                    #      如果str中不包含sub，返回 -1
+str.rindex(sub)     # 返回：从右开始，查找sub在str中第一次出现的位置。
+                    # 如果str中不包含sub，举出错误
+
+str.isalnum()       # 返回：True，如果所有的字符都是字母或数字
+str.isalpha()       # 返回：True，如果所有的字符都是字母
+str.isdigit()       # 返回：True，如果所有的字符都是数字
+str.istitle()       # 返回：True，如果所有的词的首字母都是大写
+str.isspace()       # 返回：True，如果所有的字符都是空格
+str.islower()       # 返回：True，如果所有的字符都是小写字母
+str.isupper()       # 返回：True，如果所有的字符都是大写字母
+
+str.split([sep, [max]])   # 返回：从左开始，以空格为分割符（separator），将str分割为多个子字符串。
+                          #      总共分割max次。将所得的子字符串放在一个表中返回。
+                          #      可以str.split(',')的方式使用逗号或者其它分割符
+str.rsplit([sep, [max]])  # 返回：从右开始，以空格为分割符（separator），将str分割为多个子字符串。
+                          #      总共分割max次。将所得的子字符串放在一个表中返回。
+                          #      可以str.rsplit(',')的方式使用逗号或者其它分割符
+str.join(s)               # 返回：将s中的元素，以str为分割符，合并成为一个字符串。
+str.strip([sub])          # 返回：去掉字符串开头和结尾的空格。
+                          #      也可以提供参数sub，去掉位于字符串开头和结尾的sub  
+str.replace(sub, new_sub) # 返回：用一个新的字符串new_sub替换str中的sub
+
+str.capitalize()          # 返回：将str第一个字母大写
+str.lower()               # 返回：将str全部字母改为小写
+str.upper()               # 返回：将str全部字母改为大写
+str.swapcase()            # 返回：将str大写字母改为小写，小写改为大写
+str.title()               # 返回：将str的每个词（以空格分隔）的首字母大写
+
+str.center(width)         # 返回：长度为width的字符串，将原字符串放入该字符串中心，其它空余位置为空格。
+str.ljust(width)          # 返回：长度为width的字符串，将原字符串左对齐放入该字符串，其它空余位置为空格。
+str.rjust(width)          # 返回：长度为width的字符串，将原字符串右对齐放入该字符串，其它空余位置为空格。
+```
\ No newline at end of file

From 52148742c3ebdc19fe8b1b2105f7735109447b5a Mon Sep 17 00:00:00 2001
From: pastgift <pastgift@gmail.com>
Date: Wed, 30 Jul 2014 02:02:13 +0800
Subject: [PATCH 13/13] =?UTF-8?q?STL*.md=EF=BC=9A=E6=95=B4=E4=BD=93?=
 =?UTF-8?q?=E8=B0=83=E6=95=B4=E6=A0=BC=E5=BC=8F=EF=BC=8C=E5=A6=82=E5=88=A0?=
 =?UTF-8?q?=E9=99=A4=E5=A4=9A=E4=BD=99=E7=A9=BA=E8=A1=8C=E3=80=81=E6=95=B4?=
 =?UTF-8?q?=E7=90=86=E4=BB=A3=E7=A0=81=E5=9D=97=E3=80=81=E4=BF=AE=E6=AD=A3?=
 =?UTF-8?q?=E6=A0=87=E7=82=B9=E7=AC=A6=E5=8F=B7=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/STL01.md                              | 144 ++++++++++--------
 content/STL02.md                              |  66 ++++----
 content/STL03.md                              |  82 +++++-----
 content/STL04.md                              |  32 ++--
 content/STL05.md                              |  40 ++---
 content/STL06.md                              | 109 +++++--------
 content/STL07.md                              |  57 +++----
 content/STL08.md                              |  96 ++++++------
 content/STL09.md                              |  78 +++++-----
 content/STL10.md                              |  72 ++++-----
 content/STL11.md                              |  63 +++-----
 content/STL12.md                              | 114 ++++++--------
 ...52\347\216\257\345\231\250 (itertools).md" | 119 +++++++--------
 13 files changed, 478 insertions(+), 594 deletions(-)

diff --git a/content/STL01.md b/content/STL01.md
index ae4b3f5..4907562 100644
--- a/content/STL01.md
+++ b/content/STL01.md
@@ -1,85 +1,77 @@
-#Python标准库01 正则表达式 (re包)
-
-
- 
+#Python标准库01 正则表达式（re包）
 
 我将从正则表达式开始讲Python的标准库。正则表达式是文字处理中常用的工具，而且不需要额外的系统知识或经验。我们会把系统相关的包放在后面讲解。
 
- 
-
-正则表达式(regular expression)主要功能是从字符串(string)中通过特定的模式(pattern)，搜索想要找到的内容。
-
+正则表达式（regular expression）主要功能是从字符串（string）中通过特定的模式（pattern），搜索想要找到的内容。
 
 ##语法
 
 之前，我们简介了字符串相关的处理函数。我们可以通过这些函数实现简单的搜索功能，比如说从字符串“I love you”中搜索是否有“you”这一子字符串。但有些时候，我们只是模糊地知道我们想要找什么，而不能具体说出我是在找“you”，比如说，我想找出字符串中包含的数字，这些数字可以是0到9中的任何一个。这些模糊的目标可以作为信息写入正则表达式，传递给Python，从而让Python知道我们想要找的是什么。
 
-(官方documentation)
+（官方documentation）
 
 在Python中使用正则表达式需要标准库中的一个包`re`。
+
 ```python
 import re
-m = re.search('[0-9]','abcd4ef')
+m = re.search('[0-9]', 'abcd4ef')
 print(m.group(0))
 ```
+
 `re.search()`接收两个参数，第一个`'[0-9]'`就是我们所说的正则表达式，它告诉Python的是，“听着，我从字符串想要找的是从`0`到`9`的一个数字字符”。
 
 `re.search()`如果从第二个参数找到符合要求的子字符串，就返回一个对象`m`，你可以通过`m.group()`的方法查看搜索到的结果。如果没有找到符合要求的字符，`re.search()`会返回`None`。
 
- 
+如果你熟悉Linux或者Perl，你应该已经熟悉正则表达式。当我们打开Linux shell的时候，可以用正则表达式去查找或着删除我们想要的文件，比如说：
 
-如果你熟悉Linux或者Perl, 你应该已经熟悉正则表达式。当我们打开Linux shell的时候，可以用正则表达式去查找或着删除我们想要的文件，比如说：
 ```bash
 $rm book[0-9][0-9].txt
 ```
-这就是要删除类似于`book02.txt`的文件。`book[0-9][0-9].txt`所包含的信息是，以`book`开头，后面跟两个数字字符，之后跟有`.txt`的文件名。如果不符合条件的文件名，比如说:
 
-bo12.txt
+这就是要删除类似于`book02.txt`的文件。`book[0-9][0-9].txt`所包含的信息是，以`book`开头，后面跟两个数字字符，之后跟有`.txt`的文件名。如果不符合条件的文件名，比如说：
 
+```quote
+bo12.txt
 book1.txt
-
 book99.text
+```
 
 都不会被选中。
 
 Perl中内建有正则表达式的功能，据说是所有正则表达式系统中最强的，这也是Perl成为系统管理员利器的一个原因。
 
- 
-
 ##正则表达式的函数
+
 ```python
 m = re.search(pattern, string)  # 搜索整个字符串，直到发现符合的子字符串。
 m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式。必须从字符串的第一个字符开始就相符。
 ```
-可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用`re.match()`的话，则会得到`None`，因为字符串的起始为`'a'`， 不符合`'[0-9]'`的要求。
 
+可以从这两个函数中选择一个进行搜索。上面的例子中，我们如果使用`re.match()`的话，则会得到`None`，因为字符串的起始为`'a'`， 不符合`'[0-9]'`的要求。
 
-对于返回的`m`, 我们使用`m.group()`来调用结果。（我们会在后面更详细解释`m.group()`）
-
- 
+对于返回的`m`，我们使用`m.group()`来调用结果。（我们会在后面更详细解释`m.group()`）
 
 我们还可以在搜索之后将搜索到的子字符串进行替换：
 
-str = re.sub(pattern, replacement, string)   # 在string中利用正则变换pattern进行搜索，对于搜索到的字符串，用另一字符串replacement替换。返回替换后的字符串。
- 
+```python
+str = re.sub(pattern, replacement, string)   # 在string中利用正则变换pattern进行搜索。
+                                             # 对于搜索到的字符串，用另一字符串replacement替换。返回替换后的字符串。
+```
 
 此外，常用的正则表达式函数还有
 
-re.split()    # 根据正则表达式分割字符串， 将分割后的所有子字符串放在一个表(list)中返回
-
-re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字符串放在一给表(list)中返回
-
- 
-
-(在熟悉了上面的函数后，可以看一下`re.compile()`，以便于提高搜索效率。)
+```python
+re.split()    # 根据正则表达式分割字符串， 将分割后的所有子字符串放在一个表（list）中返回。
+re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字符串放在一给表（list）中返回。
+```
 
- 
+（在熟悉了上面的函数后，可以看一下`re.compile()`，以便于提高搜索效率。）
 
 ##写一个正则表达式
 
 关键在于将信息写成一个正则表达式。我们先看正则表达式的常用语法：
 
-1）单个字符:
+1）单个字符：
 
 `.`          任意的一个字符
 
@@ -105,11 +97,9 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 `\W`         即`[^0-9a-zA-Z]`
 
- 
-
 2）重复
 
-紧跟在单个字符之后，表示多个这样类似的字符
+紧跟在单个字符之后，表示多个这样类似的字符：
 
 `*`         重复 >=0 次
 
@@ -117,21 +107,31 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 `?`         重复 0或者1 次
 
-`{m}`       重复m次。比如说 a{4}相当于aaaa，再比如说`[1-3]{2}`相当于`[1-3][1-3]`
+`{m}`       重复m次。比如说 a{4}相当于aaaa，再比如说`[1-3]{2}`相当于`[1-3][1-3]`。
 
 `{m, n}`    重复m到n次。比如说`a{2, 5}`表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。
 
- 
-
-正则表达          相符的字符串举例
+<table style="text-align:center">
+	<tr>
+		<td>正则表达</td>
+		<td>相符的字符串举例</td>
+	</tr>
 
-`[0-9]{3,5}`       9678
+	<tr>
+		<td>`[0-9]{3,5}`</td>
+		<td>9678</td>
+	</tr>
 
-`a?b`              b
+	<tr>
+		<td>`a?b`</td>
+		<td>b</td>
+	</tr>
 
-`a+b`              aaaaab
-
- 
+	<tr>
+		<td>`a+b`</td>
+		<td>aaaaab</td>
+	</tr>
+</table>
 
 3) 位置
 
@@ -139,12 +139,19 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 `$`         字符串的结尾位置
 
- 
-
-正则表达          相符的字符串举例        不相符字符串
-
-`^ab.*c$`          abeec               cabeec (如果用`re.search()`, 将无法找到。)
+<table>
+	<tr>
+		<td>正则表达</td>
+		<td>相符的字符串举例</td>
+		<td>不相符字符串</td>
+	</tr>
 
+	<tr>
+		<td>`^ab.*c$`</td>
+		<td>abeec</td>
+		<td>cabeec（如果用`re.search()`，将无法找到。）</td>
+	</tr>
+</table>
 
 4）返回控制
 
@@ -152,42 +159,51 @@ re.findall()  # 根据正则表达式搜索字符串，将所有符合的子字
 
 `output_(\d{4})`
 
-该正则表达式用括号`()`包围了一个小的正则表达式，`\d{4}`。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。
+该正则表达式用括号`()`包围了一个小的正则表达式，`\d{4}`。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群（group）。
 我们可以`m.group(number)`的方法来查询群。`group(0)`是整个正则表达的搜索结果，`group(1)`是第一个群……
+
 ```python
 import re
 m = re.search("output_(\d{4})", "output_1986.txt")
 print(m.group(1))
 ``` 
 
-我们还可以将群命名，以便更好地使用`m.group`查询:
+我们还可以将群命名，以便更好地使用`m.group`查询：
+
 ```python
 import re
-m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   #(?P<name>...) 为group命名
+m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   # (?P<name>...) 为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.match('.*([0-9]+).*','abcd4ef')
-# 注意,我们通过m.group(1)来获取数字字串，下标0处是匹配的整个字符串
+m = re.search('[0-9]', 'abcd4ef')
+```
+
+使用`re.match`同样实现上述功能（提取数字子串)，我们需要用到小括号`'()'`：
+
+```python
+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()`
 
-正则表达式构成方法
+正则表达式构成方法
\ No newline at end of file
diff --git a/content/STL02.md b/content/STL02.md
index 4690574..9da856b 100644
--- a/content/STL02.md
+++ b/content/STL02.md
@@ -1,14 +1,11 @@
-#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
@@ -16,22 +13,22 @@ print(time.clock())  # processor clock time, unit: second
 ``` 
 
 `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包
@@ -40,41 +37,41 @@ s  = time.mktime(st)    # 将struct_time格式转换成wall clock 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)
 ``` 
@@ -84,33 +81,32 @@ print(t > t_next)
 假如我们有一个的字符串，我们如何将它转换成为`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`表示月份所出现的位置……。
 
-我们通过`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 2feeaab..60ca880 100644
--- a/content/STL03.md
+++ b/content/STL03.md
@@ -1,12 +1,6 @@
-#Python标准库03 路径与文件 (os.path包, glob包)
+#Python标准库03 路径与文件（os.path包、glob包）
 
-
-
- 
-
-路径与文件的简介请参看Linux文件系统
-
- 
+路径与文件的简介请参看Linux文件系统。
 
 ##os.path包
 
@@ -16,61 +10,77 @@
 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
+<table style="text-align:center">
+    <tr>
+        <td>Filename Pattern Expression</td>
+        <td>Python Regular Expression</td>
+    </tr>
 
-*                                .*
+    <tr>
+        <td>*</td>
+        <td>.*</td>
+    </tr>
 
-?                                .
+    <tr>
+        <td>?</td>
+        <td>.</td>
+    </tr>
 
-[0-9]                            same
+    <tr>
+     <td colspan=2>[0-9]</td>
+    </tr>
 
-[a-e]                            same
+    <tr>
+        <td colspan=2>[a-z]</td>
+    </tr>
 
-[^mnp]                           same
+    <tr>
+        <td colspan=2>[^nmp]</td>
+    </tr>
+</table>
 
- 
+我们可以用该命令找出`/home/vamei`下的所有文件：
 
-我们可以用该命令找出`/home/vamei`下的所有文件:
 ```python
 import glob
 print(glob.glob('/home/vamei/*'))
@@ -82,4 +92,4 @@ print(glob.glob('/home/vamei/*'))
 
 `os.path`
 
-`glob.glob`
+`glob.glob`
\ No newline at end of file
diff --git a/content/STL04.md b/content/STL04.md
index 7734d66..32e00a8 100644
--- a/content/STL04.md
+++ b/content/STL04.md
@@ -1,31 +1,25 @@
-#Python标准库04 文件管理 (部分os包，shutil包)
-
- 
+#Python标准库04 文件管理（部分os、shutil包）
 
 在操作系统下，用户可以通过操作系统的命令来管理文件，参考linux文件管理相关命令。Python标准库则允许我们从Python内部管理文件。相同的目的，我们有了两条途径。尽管在Python调用标准库的方式不如操作系统命令直接，但有它自己的优势。你可以利用Python语言，并发挥其他Python工具，形成组合的文件管理功能。Python or Shell? 这是留给用户的选择。本文中会尽量将两者相似的功能相对应。
 
 本文基于linux文件管理背景知识
 
- 
-
 ##os包 
 
-`os`包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。`os`包的一些命令就是用于文件管理。我们这里列出最常用的:
+`os`包包括各种各样的函数，以实现操作系统的许多功能。这个包非常庞杂。`os`包的一些命令就是用于文件管理。我们这里列出最常用的：
 
 `mkdir(path)`
 
-创建新目录，`path`为一个字符串，表示新目录的路径。相当于`$mkdir`命令
+创建新目录，`path`为一个字符串，表示新目录的路径。相当于`$mkdir`命令。
 
 `rmdir(path)`
 
-删除空的目录，`path`为一个字符串，表示想要删除的目录的路径。相当于`$rmdir`命令
+删除空的目录，`path`为一个字符串，表示想要删除的目录的路径。相当于`$rmdir`命令。
 
 `listdir(path)`
 
 返回目录中所有文件。相当于`$ls`命令。
 
- 
-
 `remove(path)`
 
 删除`path`指向的文件。
@@ -34,8 +28,6 @@
 
 重命名文件，`src`和`dst`为两个路径，分别表示重命名之前和之后的路径。 
 
- 
-
 `chmod(path, mode)`
 
 改变`path`指向的文件的权限。相当于`$chmod`命令。
@@ -52,15 +44,12 @@
 
 为文件`dst`创建软链接，`src`为软链接文件的路径。相当于`$ln -s`命令。
 
- 
-
 `getcwd()`
 
-查询当前工作路径 (cwd, current working directory)，相当于`$pwd`命令。
-
- 
+查询当前工作路径（cwd, current working directory），相当于`$pwd`命令。
 
 比如说我们要新建目录`new`：
+
 ```python
 import os
 os.mkdir('/home/vamei/new')
@@ -76,9 +65,8 @@ os.mkdir('/home/vamei/new')
 
 移动文件，从`src`到`dst`。相当于`$mv`命令。
 
- 
+比如我们想复制文件`a.txt`：
 
-比如我们想复制文件`a.txt`:
 ```python
 import shutil
 shutil.copy('a.txt', 'b.txt')
@@ -88,10 +76,8 @@ shutil.copy('a.txt', 'b.txt')
 
 结合本章以及之前的内容，我们把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 33a9f39..837d137 100644
--- a/content/STL05.md
+++ b/content/STL05.md
@@ -1,14 +1,8 @@
-#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包
 
@@ -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 2c01b07..79f6ad8 100644
--- a/content/STL06.md
+++ b/content/STL06.md
@@ -1,122 +1,101 @@
-#Python标准库06 子进程 (subprocess包)
-
-
- 
+#Python标准库06 子进程（subprocess包）
 
 这里的内容以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) 函数返回什么
+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...`来检查。
 
- 
+这三个函数的使用方法相类似，我们以`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`允许我们运行这样一些命令。
 
- 
-
 ##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`。
 
- 
+对比等待的情况：
 
-对比等待的情况:
 ```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`
 
@@ -124,40 +103,36 @@ child.terminate()      # 终止子进程
 
 `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`对象的一个方法，该方法会阻塞父进程，直到子进程完成。
 
- 
+我们还可以利用`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 30d444a..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`来发出信号。）
 
- 
+（进程并不一定要使用`signal.pause()`暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的`signal.pause()`改为一个需要长时间工作的循环。）
 
 我们可以根据自己的需要更改`myHandler()`中的操作，以针对不同的信号实现个性化的处理。
 
- 
-
 ##定时发出SIGALRM信号
 
-一个有用的函数是`signal.alarm()`，它被用于在一定时间之后，向进程自身发送`SIGALRM`信号:
+一个有用的函数是`signal.alarm()`，它被用于在一定时间之后，向进程自身发送`SIGALRM`信号：
 
 ```python
 import signal
@@ -76,25 +73,21 @@ 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`包被增强，信号阻塞等功能被加入到该包中。我们暂时不深入到该包中。
 
 ##总结
 
@@ -104,4 +97,4 @@ os.killpg(pgid, sid)
 
 `signal.pause()`
 
-`signal.alarm()`
+`signal.alarm()`
\ No newline at end of file
diff --git a/content/STL08.md b/content/STL08.md
index 02bb977..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`的两个方法。
+
+`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`
-
+`Lock`、`Condition`、`Semaphore`、`Event`
\ No newline at end of file
diff --git a/content/STL09.md b/content/STL09.md
index e8a3b6e..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体系。
 
- 
-
 ##进程信息
 
 `os`包中相关函数如下：
 
 `uname()` 返回操作系统相关信息。类似于Linux上的`uname`命令。
 
-`umask()` 设置该进程创建文件时的权限mask。类似于Linux上的umask命令，见Linux文件管理背景知识
-
- 
+`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 b9e2ded..fc3a873 100644
--- a/content/STL10.md
+++ b/content/STL10.md
@@ -1,8 +1,4 @@
-##Python标准库10 多进程初步 (multiprocessing包)
-
-
-
- 
+#Python标准库10 多进程初步（multiprocessing包）
 
 我们已经见过了使用`subprocess`包来创建子进程，但这个包有两个很大的局限性：
 
@@ -10,26 +6,27 @@
 
 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()`的方法。
 
-但在使用这些共享API的时候，我们要注意以下几点:
+此外`multiprocessing`包中也有`Lock`/`Event`/`Semaphore`/`Condition`类（这些对象可以像多线程那样，通过参数传递给各个进程），用以同步进程，其用法与`threading`包中的同名类一致。所以，`multiprocessing`的很大一部份与`threading`使用同一套API，只不过换到了多进程的情境。
+
+但在使用这些共享API的时候，我们要注意以下几点：
+
+在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用`wait`，否则进程成为僵尸进程（Zombie）。所以，有必要对每个`Process`对象调用`join()`方法（实际上等同于`wait`）。对于多线程来说，由于只有一个进程，所以不存在此必要性。
+
+`multiprocessing`提供了`threading`包中没有的IPC（比如Pipe和Queue），效率上更高。应优先考虑Pipe和Queue，避免使用`Lock`/`Event`/`Semaphore`/`Condition`等同步方式（因为它们占据的不是用户进程的资源）。
 
-在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用`wait`，否则进程成为僵尸进程(Zombie)。所以，有必要对每个`Process`对象调用`join()`方法 (实际上等同于`wait`)。对于多线程来说，由于只有一个进程，所以不存在此必要性。
-`multiprocessing`提供了`threading`包中没有的IPC(比如Pipe和Queue)，效率上更高。应优先考虑Pipe和Queue，避免使用`Lock`/`Event`/`Semaphore`/`Condition`等同步方式 (因为它们占据的不是用户进程的资源)。
 多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和`Manager`的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。
-`Process.PID`中保存有PID，如果进程还没有`start()`，则PID为`None`。
 
- 
+`Process.PID`中保存有PID，如果进程还没有`start()`，则PID为`None`。
 
-我们可以从下面的程序中看到`Thread`对象和`Process`对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出(stdout)输出。这样输出的字符会混合在一起，无法阅读。使用`Lock`同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。
+我们可以从下面的程序中看到`Thread`对象和`Process`对象在使用上的相似性与结果上的不同。各个线程和进程都做一件事：打印PID。但问题是，所有的任务在打印的时候都会向同一个标准输出（stdout）输出。这样输出的字符会混合在一起，无法阅读。使用`Lock`同步，在一个任务输出完成之后，再允许另一个任务输出，可以避免多个任务同时向终端输出。
 
 ```python
 # Similarity and difference of multi thread vs. multi process
@@ -46,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)
 
@@ -63,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`另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。
+1) `Pipe`可以是单向（half-duplex），也可以是双向（duplex）。我们通过`mutiprocessing.Pipe(duplex=False)`创建单向管道（默认为双向）。一个进程从`Pipe`一端输入对象，然后被`Pipe`另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。
 
-下面的程序展示了`Pipe`的使用:
-
- 
+下面的程序展示了`Pipe`的使用：
 
 ```python
 # Multiprocessing with Pipe
@@ -96,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
@@ -114,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`的使用:
+下面的程序展示了`Queue`的使用：
 
 ```python
 # Written by Vamei
@@ -135,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)
@@ -149,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)
 
@@ -167,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 490d343..c31ef17 100644
--- a/content/STL11.md
+++ b/content/STL11.md
@@ -1,28 +1,14 @@
-
-##Python标准库11 多进程探索 (multiprocessing包)
-
-
- 
+#Python标准库11 多进程探索（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`还有下面的常用方法。
+
+`apply_async(func, args)`：从进程池中取出一个进程执行`func`，`args`为`func`的参数。它将返回一个`AsyncResult`的对象，你可以对该对象调用`get()`方法以获得结果。
 
 `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`对象这么做。
 
- 
-
-
-
 共享“资源”
 
 共享内存
 
-在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利用`list()`方法提供了表的共享方式。实际上你可以利用`dict()`来共享词典，`Lock()`来共享`threading.Lock`（注意，我们共享的是`threading.Lock`，而不是进程的`mutiprocessing.Lock`。后者本身已经实现了进程共享）。 这样`Manager`就允许我们共享更多样的对象。
 
 我们在这里不深入讲解`Manager`在远程情况下的应用。有机会的话，会在网络应用中进一步探索。
 
- 
-
 ##总结
 
 `Pool`
 
-Shared memory, `Manager`
-
+Shared memory、`Manager`
\ No newline at end of file
diff --git a/content/STL12.md b/content/STL12.md
index ee24c44..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`项目，它们不但支持数组和矩阵运算，还有丰富的数学和物理方程可供使用。
 
 此外，`random`包可以用来生成随机数。随机数不仅可以用于数学用途，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
 
- 
-
 ##math包
 
-`math`包主要处理数学相关的运算。`math`包定义了两个常数:
-
-math.e   # 自然常数e
-
-math.pi  # 圆周率pi
-
- 
+`math`包主要处理数学相关的运算。`math`包定义了两个常数：
 
-此外，`math`包还有各种运算函数 (下面函数的功能可以参考数学手册)：
+```python
+math.e   # 自然常数e。
+math.pi  # 圆周率pi。
+```
 
-math.ceil(x)       # 对x向上取整，比如x=1.2，返回2
+此外，`math`包还有各种运算函数（下面函数的功能可以参考数学手册）：
 
-math.floor(x)      # 对x向下取整，比如x=1.2，返回1
+```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.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.sin(x)`、`math.cos(x)`、`math.tan(x)`、`math.asin(x)`、`math.acos(x)`、`math.atan(x)`
 
 这些函数都接收一个弧度(radian)为单位的`x`作为参数。
 
- 
-
-角度和弧度互换: `math.degrees(x)`, `math.radians(x)`
-
- 
+角度和弧度互换：`math.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`。
 
- 
-
 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`包实现：
 
+```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 0b45412..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,13 +1,9 @@
-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)
@@ -15,35 +11,33 @@ for i in iter([2, 4, 5, 6]):
 
 标准库中的`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`包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。
 
- 
+比如：
 
-比如
 ```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`。
 
- 
-
 `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'`。
-
- 
+注意，上面的组合不分顺序，即`'ab'`、`'ba'`的话，只返回一个`'ab'`。
 
+```python
 combinations_with_replacement('abc', 2) # 与上面类似，但允许两次选出的元素重复。即多了'aa', 'bb', 'cc'
-
- 
+```
 
 ##groupby()
 
 将`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