07.md~09.md：整体调整格式，如删除多余空行、整理代码块、修正标点符号。

Author: pastgift

content/07.md

@@ -6,63 +6,65 @@
 
 ##函数的定义
 
-首先，我们要定义一个函数, 以说明这个函数的功能。
+首先，我们要定义一个函数，以说明这个函数的功能。
+
 ```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
 
 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`。

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`

content/09.md

@@ -9,15 +9,18 @@
 ```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()
 
 li_lei = Human()          
 li_lei.laugh_100th()
 ```
+
 这里有一个类属性`laugh`。在方法`show_laugh()`中，通过`self.laugh`，调用了该属性的值。
 
 还可以用相同的方式调用其它方法。方法`show_laugh()`，在方法`laugh_100th()`中被调用。
@@ -26,62 +29,74 @@ 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`，查询或修改对象的性质。
 
 这样，在类属性的之外，又给每个对象增添了各自特色的性质，从而能描述多样的世界。
 
 ```python
 class Human(object):
     def __init__(self, input_gender):
         self.gender = input_gender
+        
     def printGender(self):
         print self.gender
 
 li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的input_gender变量。
 print li_lei.gender
 li_lei.printGender()
 ```
+
 在初始化中，将参数`input_gender`，赋值给对象的性质，即`self.gender`。
 
-`li_lei`拥有了对象性质`gender`。`gender`不是一个类属性。Python在建立了`li_lei`这一对象之后，使用`li_lei.gender`这一对象性质，专门储存属于对象`li_lei`的特有信息。
+`li_lei`拥有了对象性质`gender`。
+
+`gender`不是一个类属性。Python在建立了`li_lei`这一对象之后，使用`li_lei.gender`这一对象性质，专门储存属于对象`li_lei`的特有信息。
 
 对象的性质也可以被其它方法调用，调用方法与类属性的调用相似，正如在`printGender()`方法中的调用。
 
 ##总结
 
-通过`self`调用类属性
+通过`self`调用类属性。
 
-`__init__()`: 在建立对象时自动执行
+`__init__()`：在建立对象时自动执行。
 
-类属性和对象的性质的区别
+类属性和对象的性质的区别。