diff --git a/docs/10.md b/docs/10.md
index 0bbb52838c9c2cca78d5d3f510a71188e1a32155..782f0d9e4d438dad3c50acf679589737a173e64c 100644
--- a/docs/10.md
+++ b/docs/10.md
@@ -2,8 +2,7 @@
 
 > 原文： [https://pythonspot.com/global-local-variables/](https://pythonspot.com/global-local-variables/)
 
-变量有两种类型：**全局变量**和**局部变量**。
-全局变量可以在代码中的任何位置访问，局部变量只能在[作用域](https://pythonspot.com/scope/)中访问。
+变量有两种类型：**全局变量**和**局部变量**。全局变量可以在代码中的任何位置访问，局部变量只能在[作用域](https://pythonspot.com/scope/)中访问。
 
 ![global-local-variable](img/b096b6df86baa4af3f1d9b86a8b57af2.jpg)
 
@@ -23,8 +22,7 @@ print(sum(8,6))
 
 ```
 
-变量 x 和 y 只能在函数 sum 之内使用，而在函数外部则不存在。
-局部变量不能在其作用域之外使用，此行将不起作用：
+变量`x`和`y`只能在函数`sum`之内使用，而在函数外部则不存在。局部变量不能在其作用域之外使用，此行将不起作用：
 
 ```py
 
@@ -34,8 +32,7 @@ print(x)
 
 ## 全局变量
 
-全局变量可以在代码中的任何位置使用。
-在下面的示例中，我们定义了全局变量z
+全局变量可以在代码中的任何位置使用。在下面的示例中，我们定义了全局变量`z`
 
 ```py
 
@@ -65,7 +62,7 @@ print(z)
 
 ```
 
-调用 afunction（）之后，将更改整个程序的全局变量。
+调用`afunction()`之后，将更改整个程序的全局变量。
 
 ## 练习
 
diff --git a/docs/11.md b/docs/11.md
index d1146e13dd0ee8dd5c1b50ff97b79c85f170b3b8..8645fd5445da03d51eb9928a8af3ebb6e600a0ae 100644
--- a/docs/11.md
+++ b/docs/11.md
@@ -4,13 +4,13 @@
 
 ## 作用域
 
-变量只能到达定义它们的区域，这称为 _ 作用域 _。 将其视为可以使用变量的代码区域。 Python 支持全局变量（可在整个程序中使用）和局部变量。
+变量只能到达定义它们的区域，这称为作用域。 将其视为可以使用变量的代码区域。 Python 支持全局变量（可在整个程序中使用）和局部变量。
 
-默认情况下，函数中声明的所有变量都是局部变量。 要访问函数内部的全局变量，必须明确定义“全局变量”。
+默认情况下，函数中声明的所有变量都是局部变量。要访问函数内部的全局变量，必须明确定义“全局变量”。
 
 ## 示例
 
-下面我们将研究用法 局部变量和作用域。 此 _**不起作用**_ ：
+下面我们将研究局部变量和作用域的用法。它**不起作用**：
 
 ```py
 #!/usr/bin/python
@@ -72,6 +72,6 @@ print(result)
 
 ```
 
-如果在代码中的任何位置都可以访问变量，则称为 _**全局变量。**_ 如果仅在作用域内部知道变量，则将其称为 _**局部变量。**_
+如果在代码中的任何位置都可以访问变量，则称为**全局变量**。如果仅在作用域内部知道变量，则将其称为**局部变量**。
 
 [下载 Python 练习](https://pythonspot.com/download-python-exercises/)
\ No newline at end of file
diff --git a/docs/12.md b/docs/12.md
index 50dcae8563ecf1e551c2bf813ebefc18455ae098..2ff2da02bc6f14d1d228564ed3a861592f8667d1 100644
--- a/docs/12.md
+++ b/docs/12.md
@@ -2,9 +2,9 @@
 
 > 原文： [https://pythonspot.com/loops/](https://pythonspot.com/loops/)
 
-可以使用循环来重复代码。 代码行可以重复 N 次，其中 N 是可以手动配置的。 实际上，这意味着将重复执行代码，直到满足条件为止。 此条件通常为（x > = N），但这不是唯一可能的条件。
+可以使用循环来重复代码。 代码行可以重复 N 次，其中 N 是可以手动配置的。 实际上，这意味着将重复执行代码，直到满足条件为止。 此条件通常为（`x <= N`），但这不是唯一可能的条件。
 
-Python 有 3 种循环类型：for 循环，while 循环和嵌套循环。
+Python 有 3 种循环类型：`for`循环，`while`循环和嵌套循环。
 
 ## `for`循环
 
@@ -20,11 +20,11 @@ for item in items:
 
 ```
 
-for 循环的可视化：
+`for`循环的可视化：
 
 ![for loop](img/82f73ddadae94db3c7fa209585564d41.jpg)
 
-for 循环也可以重复 N 次：
+`for`循环也可以重复 N 次：
 
 ```py
 #!/usr/bin/python
diff --git a/docs/13.md b/docs/13.md
index efb0bb00577e2f8ebef76170a08008f8a23ff340..1b8cffec422a8db596fa24ce601051b69ef2d307 100644
--- a/docs/13.md
+++ b/docs/13.md
@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonspot.com/python-range/](https://pythonspot.com/python-range/)
 
-**range（）**函数的 return 会生成一个数字序列，从下限到上限。
+`range()`函数会生成一个数字序列，从下限到上限。
 
 ```py
 
@@ -10,11 +10,11 @@ range(lower_bound, upper_bound, step_size)
 
 ```
 
-*   lower_bound：_ 列表的起始值。_
+*   `lower_bound`：列表的起始值。
 
-*   upper_bound：_ 列表的最大值，不包括此数字。_
+*   `upper_bound`：列表的最大值，不包括此数字。
 
-*   step_bound：_ 步长，列表中每个数字之间的差。_
+*   `step_bound`：步长，列表中每个数字之间的差。
 
 `lower_bound`和`step_size`参数是可选的。默认情况下，下限设置为零，增量步长设置为一。参数必须为整数类型，但可以为负。
 
@@ -24,11 +24,11 @@ range(lower_bound, upper_bound, step_size)
 
 ## 范围实现差异
 
-通常是一个问题。 在 Python 版本中，range（）的实现略有不同：
+通常是一个问题。 在 Python 版本中，`range()`的实现略有不同：
 
-*   Python 2.x： _range（）函数返回一个列表。_
+*   Python 2.x：`range()`函数返回一个列表。
 
-*   Python 3.x： _range（）函数生成一个序列。_
+*   Python 3.x：`range()`函数生成一个序列。
 
 ## python 2.7 中的范围
 
@@ -40,7 +40,7 @@ range(lower_bound, upper_bound, step_size)
 
 ```
 
-调用 range（1,10）返回：1,2,3,4,5,6,7,8,9
+调用`range(1, 10)`返回：`1,2,3,4,5,6,7,8,9`
 
 ```py
 
@@ -48,7 +48,7 @@ range(lower_bound, upper_bound, step_size)
 
 ```
 
-调用范围（0,10,2）返回：0,2,4,6,8
+调用`range(0, 10, 2)`返回：`0,2,4,6,8`
 
 ```py
 
@@ -56,8 +56,7 @@ range(lower_bound, upper_bound, step_size)
 
 ```
 
-python 3 中的**范围**
-要使用范围生成列表，请添加列表功能
+python 3 中的**范围**。要使用范围生成列表，请添加列表函数。
 
 ```py
 
@@ -76,8 +75,8 @@ python 3 中的**范围**
 
 ## python 2 实现
 
-此版本的 range（）分配计算机内存，并在后台填充计算机内存。 对于大范围，这不是很有效的实现。
+此版本的`range()`分配计算机内存，并在后台填充计算机内存。 对于大范围，这不是很有效的实现。
 
-通常，range2 的 Python2 实现不会有任何问题，但如果使用大量（数百万个项目），则可能会遇到问题。
+通常，`range`的 Python2 实现不会有任何问题，但如果使用大量（数百万个项目），则可能会遇到问题。
 
 [下载 Python 练习](https://pythonspot.com/download-python-exercises/)
\ No newline at end of file
diff --git a/docs/14.md b/docs/14.md
index c1d1a56da6b67d02a9227e6a53661e58a66d4055..f61a1ab70f81688c0ce901380be91a236ef46f84 100644
--- a/docs/14.md
+++ b/docs/14.md
@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonspot.com/python-tuples/](https://pythonspot.com/python-tuples/)
 
-元组 _ 数据结构 _ 用于存储一组数据。 该组中的元素用逗号分隔。 创建后，元组的值将无法更改。
+元组数据结构用于存储一组数据。 该组中的元素用逗号分隔。 创建后，元组的值将无法更改。
 
 ## Python 元组
 
diff --git a/docs/15.md b/docs/15.md
index 81095d55bdfe38059ad35fb11be53be29a67c3eb..21869d021d1627b1b55411694af02a2af942e393 100644
--- a/docs/15.md
+++ b/docs/15.md
@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonspot.com/python-dictionaries/](https://pythonspot.com/python-dictionaries/)
 
-字典可以看作是 _ 键的无序集合：值 _ 对。
+字典可以看作是键值对的无序集合。
 
 一对大括号创建一个空字典： `{}` 。 每个元素都可以映射到某个值。 整数或字符串可用于索引。 字典没有命令。
 
@@ -33,7 +33,7 @@ Non
 
 ```
 
-我们绝不限于价值部分中的单个单词定义。 演示：
+我们绝不限于值部分中的单个单词定义。 演示：
 
 ```py
 #!/usr/bin/python
diff --git a/docs/16.md b/docs/16.md
index 77cbb5052346fe6346d303658a61a41f969eccba..c4f8d7dd3b234144bd33095960a3f2a0d5a53e8b 100644
--- a/docs/16.md
+++ b/docs/16.md
@@ -11,9 +11,9 @@ y = "text"
 
 ```
 
-它发现 _x 是整数 _ 类型， _y 是字符串 _ 类型。
+它发现`x`是整数类型，`y`是字符串类型。
 
-函数接受某种数据类型。 例如，print 仅接受字符串数据类型。
+函数接受某种数据类型。 例如，`print`仅接受字符串数据类型。
 
 ## 数据类型转换
 
@@ -31,9 +31,9 @@ print("y = " + str(y))
 
 ```
 
-我们使用 str（）函数将变量 x（整数）和变量 y（浮点数）转换为字符串。
+我们使用`str()`函数将变量`x`（整数）和变量`y`（浮点数）转换为字符串。
 
-如果我们有要存储为数字的文本怎么办？ 我们将不得不再次铸造。
+如果我们有要存储为数字的文本怎么办？ 我们将不得不再次转型。
 
 ```py
 a = "135.31421"
@@ -44,7 +44,7 @@ print(c)
 
 ```
 
-在上面的示例中，我们将两个具有数据类型字符串的变量强制转换为数据类型 float。
+在上面的示例中，我们将两个具有数据类型字符串的变量强制转换为数据类型`float`。
 
 ## 转换函数
 
diff --git a/docs/17.md b/docs/17.md
index ced306f17e0c46f7b70503cbd048b7de2448bf5c..8bfc5ce35418e49a5659a26227264a06c6af6019 100644
--- a/docs/17.md
+++ b/docs/17.md
@@ -2,11 +2,11 @@
 
 > 原文： [https://pythonspot.com/random-numbers/](https://pythonspot.com/random-numbers/)
 
-使用 _ 随机 _ 模块，我们可以生成伪随机数。 函数 random（）生成一个介于零和一之间的随机数[0，0.1 .. 1]。 用此模块生成的数字不是真正随机的，但对于大多数用途而言，它们是足够随机的。
+使用`random`模块，我们可以生成伪随机数。 函数`random()`生成一个介于零和一之间的随机数`[0, 0.1 .. 1]`。 用此模块生成的数字不是真正随机的，但对于大多数用途而言，它们是足够随机的。
 
 ## 介于 0 和 1 之间的随机数。
 
-我们 可以使用以下小代码生成（伪）随机浮点​​数：
+我们可以使用以下小代码生成（伪）随机浮点​​数：
 
 ```py
 from random import *
@@ -38,7 +38,7 @@ print(x)
 
 ## 1 到 10 之间的随机数
 
-要生成 1 到 10 之间的随机 _ 浮点数 _，您可以使用匀速（）函数
+要生成 1 到 10 之间的随机浮点数，您可以使用`uniform()`函数
 
 ```py
 from random import *
diff --git a/docs/19.md b/docs/19.md
index 97f87c5854a97d648b2dc8954f65ac07c7510367..a93cb4b4a20e3965fbaaf9e91613216b7dc067f9 100644
--- a/docs/19.md
+++ b/docs/19.md
@@ -31,7 +31,7 @@ for line in content:
 
 代码的第一部分将读取文件内容。 读取的所有行将存储在变量内容中。 第二部分将遍历变量内容中的每一行。
 
-如果您不想读取换行符“ \ n”，则可以将语句 f.readlines（）更改为此：
+如果您不想读取换行符`"\n"`，则可以将语句`f.readlines()`更改为此：
 
 ```py
 content = f.read().splitlines()
diff --git a/docs/20.md b/docs/20.md
index 6e6e01cf87ded9e9fe558cd55b27e58ea84ad4f6..09949d2a21ee12325c157b12aaba1635e7f4d31e 100644
--- a/docs/20.md
+++ b/docs/20.md
@@ -2,9 +2,9 @@
 
 > 原文： [https://pythonspot.com/write-file/](https://pythonspot.com/write-file/)
 
-Python 默认支持写文件，不需要特殊模块。 您可以使用.write（）方法以及包含文本数据的参数来写入文件。
+Python 默认支持写文件，不需要特殊模块。 您可以使用`.write()`方法以及包含文本数据的参数来写入文件。
 
-在将数据写入文件之前，请调用 open（filename，’w’）函数，其中 filename 包含文件名或文件名的路径。 最后，别忘了关闭文件。
+在将数据写入文件之前，请调用`open(filename, 'w')`函数，其中`filename`包含文件名或文件名的路径。 最后，别忘了关闭文件。
 
 ## 创建要写入的文件
 
@@ -27,7 +27,7 @@ myfile.close()
 
 ```
 
-“ w”标志可使 Python 截断该文件（如果已存在）。 也就是说，如果文件内容存在，它将被替换。
+`"w"`标志可使 Python 截断该文件（如果已存在）。 也就是说，如果文件内容存在，它将被替换。
 
 ## 附加到文件
 
diff --git a/docs/21.md b/docs/21.md
index b839f846f54fd1090f0efcb04fc7c30c3693ffe0..847f036e9749260e3bfd9d1b6423157dbcafaa3b 100644
--- a/docs/21.md
+++ b/docs/21.md
@@ -6,16 +6,13 @@
 
 技术总是在发展。什么是类，它们从何而来？
 
-**1.语句**：
-在计算的早期，程序员仅编写命令。
+**1\. 语句**：在计算的早期，程序员仅编写命令。
 
-**2.函数**：
-可重用的语句组，有助于结构化代码并提高了可读性。
+**2\. 函数**：可重用的语句组，有助于结构化代码并提高了可读性。
 
-**3.类**：
-这些类用于创建具有功能和变量的对象。 字符串是对象的示例：字符串书具有功能 book.replace（）和 book.lowercase（）。 这种样式通常称为面向对象编程。
+**3\. 类**：这些类用于创建具有功能和变量的对象。 字符串是对象的示例：字符串书具有功能`book.replace()`和`book.lowercase()`。这种样式通常称为面向对象编程。
 
-让我们一起潜水吧！
+让我们一起深入吧！
 
 ## Python 类
 
@@ -42,15 +39,15 @@ david.sayHello()
 
 ```
 
-运行该程序。 在此代码中，我们有 3 个虚拟对象：james，david 和 eric。 每个对象都是 User 类的实例。
+运行该程序。 在此代码中，我们有 3 个虚拟对象：`james`，`david`和`eric`。 每个对象都是`User`类的实例。
 
 ![python class: creation of objects](img/4915adfc6d1a53dddb74cfc74d45644b.jpg)
 
 Python 类：创建对象
 
-在此类中，我们定义了 sayHello（）方法，这就是为什么我们可以为每个对象调用它的原因。 **初始化**（）方法被称为**构造函数**，并且在创建对象时始终被调用。 该类拥有的变量在这种情况下为“名称”。 这些变量有时称为类属性。
+在此类中，我们定义了`sayHello()`方法，这就是为什么我们可以为每个对象调用它的原因。`__init__()`方法被称为**构造函数**，并且在创建对象时始终被调用。该类拥有的变量在这种情况下为`name`。这些变量有时称为类属性。
 
-我们可以在类中创建方法来更新对象的内部变量。 这听起来可能有些含糊，但我将举一个例子进行说明。
+我们可以在类中创建方法来更新对象的内部变量。这听起来可能有些含糊，但我将举一个例子进行说明。
 
 ## 类变量
 
@@ -103,7 +100,7 @@ pythonBean.printState()
 
 ```
 
-运行该程序。 代码的顶部定义了我们所描述的类。 下面的代码是我们创建虚拟对象的地方。 在此示例中，我们只有一个对象称为“ pythonBean”。 然后我们调用更改内部变量的方法，这是可能的，因为我们在类中定义了这些方法。 输出：
+运行该程序。 代码的顶部定义了我们所描述的类。 下面的代码是我们创建虚拟对象的地方。 在此示例中，我们只有一个对象称为`pythonBean`。 然后我们调用更改内部变量的方法，这是可能的，因为我们在类中定义了这些方法。 输出：
 
 ```py
 
diff --git a/docs/22.md b/docs/22.md
index fddc2568ee3486233995a724840d458c98ec4cb3..42e1f5d70688b1c615577eff65885f0dca2d27d7 100644
--- a/docs/22.md
+++ b/docs/22.md
@@ -22,7 +22,7 @@ duck.walk()
 
 ```
 
-我们在动物类中创建了一个名为“鸭子”的对象。 该类具有一个可以在每个对象上调用的方法（walk）。 我们还有一个称为 **init** （）的方法，该方法在创建新对象时总是被调用。 每种方法都必须使用 self 关键字。 我们使用类（self.name = ..）设置变量。
+我们在动物类中创建了一个名为`duck`的对象。 该类具有一个可以在每个对象上调用的方法（`walk`）。 我们还有一个称为`__init__()`的方法，该方法在创建新对象时总是被调用。 每种方法都必须使用`self`关键字。 我们使用类（`self.name = ..`）设置变量。
 
 ![python class](img/cb722e238db4c81d1854b65097d597a9.jpg)
 
diff --git a/docs/23.md b/docs/23.md
index 9d300d950a897f80d83b075254c5ac6f8b1ca5d4..e9c5f72bf958a143e4fe489899272671b6a7e184 100644
--- a/docs/23.md
+++ b/docs/23.md
@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonspot.com/encapsulation](https://pythonspot.com/encapsulation)
 
-在面向对象的 python 程序中，您可以 _ 限制对方法和变量的访问 _。 这可以防止意外修改数据，这就是 _ 封装 _。 让我们从一个例子开始。
+在面向对象的 python 程序中，您可以限制对方法和变量的访问。这可以防止意外修改数据，这就是封装。 让我们从一个例子开始。
 
 ## 私有方法
 
@@ -10,7 +10,7 @@
 
 封装。限制访问方法或变量
 
-我们创建了一个 Car 类，它具有两种方法：drive（）和 updateSoftware（）。 创建汽车对象时，它将调用私有方法 __updateSoftware（）。
+我们创建了一个`Car`类，它具有两种方法：`drive()`和`updateSoftware()`。创建汽车对象时，它将调用私有方法`__updateSoftware()`。
 
 仅在类内部不能直接在对象上调用此函数。
 
@@ -44,9 +44,9 @@ driving
 
 封装可以防止意外访问，但不是有意访问。
 
-私有属性和方法并未真正隐藏，而是在其名称的开头加上了 _Car”来重命名。
+私有属性和方法并未真正隐藏，而是在其名称的开头加上了`_Car`来重命名。
 
-实际上可以使用 redcar._Car__updateSoftware（）调用该方法。
+实际上可以使用`redcar._Car__updateSoftware()`调用该方法。
 
 ## 私有变量
 
diff --git a/docs/24.md b/docs/24.md
index 8ed069b1113aa84eeb224b1dd10b854377392205..96223ad60cc804c0c8fbd2b87d2986e26ca3c0f7 100644
--- a/docs/24.md
+++ b/docs/24.md
@@ -12,7 +12,7 @@
 
 根据函数定义，可以使用零个，一个，两个或多个参数来调用它。
 
-这称为 _ 方法重载。_ 并非所有的编程语言都支持方法重载，但是 Python 支持。
+这称为方法重载。并非所有的编程语言都支持方法重载，但是 Python 支持。
 
 ## 方法重载示例
 
@@ -51,7 +51,7 @@ Hello Guido
 
 ```
 
-为了澄清 _ 方法的重载 _，我们现在可以通过两种方式调用 sayHello（）方法：
+为了澄清方法的重载，我们现在可以通过两种方式调用`sayHello()`方法：
 
 ```py
 obj.sayHello()
diff --git a/docs/25.md b/docs/25.md
index 252878af51bd9686994d4a536d8f7cd24cfc13f0..0ab3b497a8492b517152aa2ec5f7b14cedc96919 100644
--- a/docs/25.md
+++ b/docs/25.md
@@ -38,11 +38,11 @@ class Programmer(User):
 
 ```
 
-除了参数中提供了 User 之外，这看起来非常像标准类。 这意味着可以在 Programmer 类中访问 User 类的所有功能。
+除了参数中提供了`User`之外，这看起来非常像标准类。 这意味着可以在`Programmer`类中访问`User`类的所有功能。
 
 ## 继承示例
 
-Full example of Python inheritance:
+Python 继承的完整示例：
 
 ```py
 class User:
@@ -79,6 +79,6 @@ Programming Python
 
 ```
 
-Brian 是 User 的实例，只能访问方法 printName。 Diana 是 Programmer 的一个实例，该类是继承自 User 的类，并且可以访问 Programmer 和 User 中的方法。
+`Brian`是`User`的实例，只能访问方法`printName`。`Diana`是`Programmer`的一个实例，该类是继承自`User`的类，并且可以访问`Programmer`和`User`中的方法。
 
 [下载练习](https://pythonspot.com/download-oop-exercises/)
\ No newline at end of file
diff --git a/docs/26.md b/docs/26.md
index dd9316984647eb5e34b75827175e5fc8eb2609da..c8797a6e3f2c4760b3b06e41aed70df9f73b86f6 100644
--- a/docs/26.md
+++ b/docs/26.md
@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonspot.com/polymorphism/](https://pythonspot.com/polymorphism/)
 
-有时，对象有多种类型或形式。 如果我们有一个按钮，则有许多不同的绘制输出（圆形按钮，复选按钮，方形按钮，带有图像的按钮），但它们确实共享相同的逻辑：onClick（）。 我们使用相同的方法访问它们。 这个想法称为 _ 多态 _。
+有时，对象有多种类型或形式。 如果我们有一个按钮，则有许多不同的绘制输出（圆形按钮，复选按钮，方形按钮，带有图像的按钮），但它们确实共享相同的逻辑：`onClick()`。 我们使用相同的方法访问它们。 这个想法称为多态。
 
 多态是基于希腊语 Poly（许多）和 morphism（形式）。 我们将创建一个可以采用或使用多种形式的对象的结构。
 
@@ -42,7 +42,7 @@ Woof woof!
 
 ![polymorphism example](img/2c012acbbf068f97276301d4bf125959.jpg)
 
-视觉多态。
+多态可视化。
 
 抽象结构在`Document`类中定义。
 
@@ -56,7 +56,7 @@ print document.name + ': ' + document.show()
 
 ```
 
-为此，我们创建了一个称为 document 的抽象类。 此类没有任何实现，但是定义了所有形式都必须具有的结构（以功能形式）。 如果我们定义函数 show（），则 PdfDocument 和 WordDocument 都必须具有 show（）函数。 完整代码：
+为此，我们创建了一个称为`document`的抽象类。 此类没有任何实现，但是定义了所有形式都必须具有的结构（以函数形式）。 如果我们定义函数`show()`，则`PdfDocument`和`WordDocument`都必须具有`show()`函数。完整代码：
 
 ```py
 class Document:
@@ -100,9 +100,9 @@ Document3: Show word contents!
 
 抽象类中的结构，其他类中的实现
 
-另一个例子是拥有一个抽象类 Car，其中包含了 drive（）和 stop（）结构。
+另一个例子是拥有一个抽象类`Car`，其中包含了`drive()`和`stop()`结构。
 
-我们定义了两个对象 Sportcar 和 Truck，它们都是 Car 的一种形式。 用伪代码我们将要做的是：
+我们定义了两个对象`Sportcar`和`Truck`，它们都是`Car`的一种形式。 用伪代码我们将要做的是：
 
 ```py
 class Car:
@@ -119,7 +119,7 @@ class Truck(Car):
 
 ```
 
-然后，我们可以访问任何类型的汽车并调用功能，而无需进一步考虑表格是 Sportscar 还是 Truck。 完整代码：
+然后，我们可以访问任何类型的汽车并调用函数，而无需进一步考虑表格是 Sportscar 还是 Truck。 完整代码：
 
 ```py
 class Car:
diff --git a/docs/27.md b/docs/27.md
index eb1298aed7d47daf7c9f53f1a88826b0291e92ad..c75c48ffa605fdab3f1faa8352633f50d742e6e5 100644
--- a/docs/27.md
+++ b/docs/27.md
@@ -36,7 +36,7 @@ talking...
 
 ```
 
-在上面的程序中，我们有内部类 Head（），它具有自己的方法。 内部类可以同时具有方法和变量。 在此示例中，类 Human（ **init** ）的构造函数创建了一个新的 head 对象。
+在上面的程序中，我们有内部类`Head()`，它具有自己的方法。内部类可以同时具有方法和变量。在此示例中，类`Human`的构造函数（`__init__`）创建了一个新的`head`对象。
 
 ## 多个内部类
 
diff --git a/docs/28.md b/docs/28.md
index 3428cccce6fa7bb4f9f2643ef34d5dc4fcb140b2..eb826fc8eafff29284b8e31b0091c0f58ed3d48b 100644
--- a/docs/28.md
+++ b/docs/28.md
@@ -3,7 +3,7 @@
 > 原文： [https://pythonspot.com/factory-method/](https://pythonspot.com/factory-method/)
 
 我们可能并不总是知道我们要预先创建什么样的对象。
-在用户请求执行后，只能在执行时创建 _ 的某些对象。_
+在用户请求执行后，只在执行时创建某些对象。
 
 可能使用**工厂方法**的示例：
 
@@ -23,7 +23,7 @@ obj.drive()
 
 ```
 
-**关键事实**：_ 工厂方法返回（新）对象。_
+**关键事实**：工厂方法返回（新）对象。
 
 对象的类型取决于您指定的输入字符串的类型。 这种技术还可以使您的程序更容易扩展。 新的程序员可以通过添加新的字符串和类来轻松添加功能，而无需阅读所有源代码。
 
diff --git a/docs/29.md b/docs/29.md
index 9b9a1cea8ee39a859642c0452f36016fb8a81cef..9fe824b0aa29f49293a7fb17d392d971248754ed 100644
--- a/docs/29.md
+++ b/docs/29.md
@@ -11,7 +11,7 @@
 
 您可能需要将一个复杂的问题分解为几个较小的问题。 您已经熟悉[循环或迭代](https://pythonspot.com/loops/)。 在某些情况下，递归可能是更好的解决方案。
 
-在 Python 中，**如果函数调用自身并且具有终止条件**，则该函数是递归的。 为什么要终止条件？ 阻止函数自称广告无穷大。
+在 Python 中，**如果函数调用自身并且具有终止条件**，则该函数是递归的。 为什么要终止条件？ 阻止函数无限自我调用。
 
 ## 递归示例
 
@@ -36,7 +36,7 @@ print(sum([5,7,3,8,10]))
 
 ```
 
-在我们简单地调用 sum 函数的地方，该函数将每个元素添加到变量 sum 并返回。 递归执行此操作：
+在我们简单地调用`sum`函数的地方，该函数将每个元素添加到变量`sum`并返回。 递归执行此操作：
 
 ```py
 #!/usr/bin/env python
@@ -51,11 +51,11 @@ print(sum([5,7,3,8,10]))
 
 ```
 
-如果列表的长度为 1，则返回列表（终止条件）。 否则，它返回元素，并调用函数 sum（）减去列表中的一个元素。 如果执行了所有调用，则返回达到终止条件并返回应答。
+如果列表的长度为 1，则返回列表（终止条件）。 否则，它返回元素，并调用函数`sum()`减去列表中的一个元素。 如果执行了所有调用，则返回达到终止条件并返回应答。
 
 ## 递归阶乘
 
-阶乘的数学定义是：n！ = n *（n-1）!,如果 n &gt; 1 并且 f（1）= 1.示例：3！ = 3 x 2 x 1 =6。我们可以使用递归函数在 Python 中实现：
+阶乘的数学定义是：`n! = n * (n-1)!`,如果`n > 1`并且`f(1) = 1`。示例：`3! = 3 x 2 x 1 = 6`。我们可以使用递归函数在 Python 中实现：
 
 ```py
 #!/usr/bin/env python
@@ -70,7 +70,7 @@ print(factorial(3))
 
 ```
 
-调用阶乘函数 n = 3 时。它将返回 n *阶乘（n-1）。 该过程将一直持续到 n =1。如果达到 n == 1，它将返回结果。
+调用阶乘函数`n = 3`时。它将返回`n * factorial(n-1)`。 该过程将一直持续到`n = 1`。如果达到`n == 1`，它将返回结果。
 
 ## 递归限制
 
diff --git a/docs/31.md b/docs/31.md
index 159ad0a1f4cbdcbf44aa0ac21f71944cd1561a16..c34b59e1385ac8d7f8b75bd85b663d8a5a993e2d 100644
--- a/docs/31.md
+++ b/docs/31.md
@@ -19,7 +19,7 @@ print stdout
 
 ```
 
-process.communicate（）调用从进程中读取输入和输出。 stdout 是进程输出。 仅当发生错误时，stderr 才会被写入。 如果要等待程序完成，可以调用 Popen.wait（）。
+`process.communicate()`调用从进程中读取输入和输出。`stdout`是进程输出。仅当发生错误时，`stderr`才会被写入。 如果要等待程序完成，可以调用`Popen.wait()`。
 
 ## `subprocess.call()`：
 
@@ -32,7 +32,7 @@ subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False)
 
 ```
 
-在下面的示例中，完整的命令将为“ ls -l”
+在下面的示例中，完整的命令将为`ls -l`
 
 ```py
 #!/usr/bin/env python
diff --git a/docs/32.md b/docs/32.md
index 3bb2d357f04b51622542606ff205020dedc379ab..5de42d0138e9e4c4d98292dabebcf68677cbced9 100644
--- a/docs/32.md
+++ b/docs/32.md
@@ -2,7 +2,8 @@
 
 > 原文： [https://pythonspot.com/threading](https://pythonspot.com/threading)
 
-在 Python 中，您可以使用 Python 2.x 中的`threading`模块或 Python 3 中的 _thread 模块创建线程。我们将使用`threading`模块与之交互。
+在 Python 中，您可以使用 Python 2.x 中的`threading`模块或 Python 3 中的`_thread`模块创建线程。我们将使用`threading`模块与之交互。
+
 线程是一种操作系统进程，具有与正常进程不同的功能：
 
 *   线程作为进程的子集存在
@@ -44,7 +45,7 @@ for x in xrange(10):
 
 ```
 
-如果运行一次，线程不必停止。 线程可以是定时的，每 x 秒重复执行一次线程功能。
+如果运行一次，线程不必停止。 线程可以是定时的，每`x`秒重复执行一次线程功能。
 
 ## 定时线程
 
diff --git a/docs/33.md b/docs/33.md
index 886caecad01c62297ccca430bfa1dcfaa67d7743..84fa54b809f4e8c037e7798987cae9cfd7f84d21 100644
--- a/docs/33.md
+++ b/docs/33.md
@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonspot.com/python-lambda/](https://pythonspot.com/python-lambda/)
 
-我们可以创建匿名函数，称为 lambda 函数。 Lambda 函数与常规 Python 函数不同，它们源自 Lambda 微积分。 它允许您编写非常简短的函数。
+我们可以创建匿名函数，称为 lambda 函数。 Lambda 函数与常规 Python 函数不同，它们源自 Lambda 演算。 它允许您编写非常简短的函数。
 
 ## Lambda 函数示例
 
@@ -16,8 +16,7 @@ print f(3)
 
 ```
 
-Lambda 函数从不使用 return 语句，它总是返回
-。 Lambda 函数可能包含 if 语句：
+Lambda 函数从不使用`return`语句，它总是返回。 Lambda 函数可能包含`if`语句：
 
 ```py
 #!/usr/bin/env python
@@ -56,7 +55,7 @@ print(newList)
 
 ```
 
-返回列表只包含 lambda 表达式“ lamba x：x％2 == 0”为真的元素。
+返回列表只包含 lambda 表达式`lamba x: x % 2 == 0`为真的元素。
 
 ## `reduce`函数
 
diff --git a/docs/34.md b/docs/34.md
index a9bd41a55eaa09ab3bd90557e9ffa740a55b7bdf..5ca44228423f1ccd48b5d6e9196eda0572b49bcc 100644
--- a/docs/34.md
+++ b/docs/34.md
@@ -8,7 +8,7 @@ Python 中的集合是对象的集合。 集合在 Python 2.4 和更高版本中
 
 ## 集合示例
 
-要创建一个集合，我们使用 set（）函数。
+要创建一个集合，我们使用`set()`函数。
 
 ```py
 #!/usr/bin/env python
@@ -18,7 +18,7 @@ print(x)
 
 ```
 
-如果我们多次添加相同的 item 元素，则会将其删除。 一个集合不能多次包含相同的元素。
+如果我们多次添加相同的`item`元素，则会将其删除。 一个集合不能多次包含相同的元素。
 
 ```py
 #!/usr/bin/env python
diff --git a/docs/35.md b/docs/35.md
index a40fcbf6f1fdea6a3345602ec7590331c774d5b4..56af98fa9fdb391001cefe60d0bbe4cf07b68c57 100644
--- a/docs/35.md
+++ b/docs/35.md
@@ -38,7 +38,7 @@ print(dir(sys))
 
 可以按照以下步骤创建自己的模块：
 
-创建一个名为 test.py 的文件（您的模块）
+创建一个名为`test.py`的文件（您的模块）
 
 ```py
 #!/usr/bin/env python
@@ -48,7 +48,7 @@ def add(a,b):
 
 ```
 
-然后创建一个名为 app.py 的文件：
+然后创建一个名为`app.py`的文件：
 
 ```py
 from test import *
diff --git a/docs/36.md b/docs/36.md
index 4098efbbc873b7e375671d983f971b492f40c7d1..cf2d19f400ce97513a6730a9d349d7b8075b47ca 100644
--- a/docs/36.md
+++ b/docs/36.md
@@ -14,7 +14,7 @@ Python 没有图数据类型。 要使用图，我们可以使用模块，也可
 
 *   自己实现图
 
-*   networkx 模块
+*   `networkx`模块
 
 ## Python 中的图
 
@@ -32,9 +32,9 @@ print(graph)
 
 ```
 
-## 使用 networkx 的图
+## 使用`networkx`的图
 
-networkx 软件模块支持创建，处理图。
+`networkx`软件模块支持创建，处理图。
 
 ```py
 #!/usr/bin/env python
diff --git a/docs/39.md b/docs/39.md
index 4e5abf68ea1cda85621b00c14ab1047fa73e4b03..37eebbd9bcc9960ecfc0c92c808a744054b24359 100644
--- a/docs/39.md
+++ b/docs/39.md
@@ -4,7 +4,7 @@
 
 ![binary numbers ](img/74c0efc42f7bf310489f953f2b5cbd0e.jpg)
 
-我们之前已经看过简单的数字和运算。 在本文中，您将学习数字在计算机内部的工作方式以及与此相关的一些魔术：-)
+我们之前已经看过简单的数字和运算。 在本文中，您将学习数字在计算机内部的工作方式以及与此相关的一些魔术 :-)
 
 更详细：虽然这在 Web 应用程序或大多数桌面应用程序中没有直接用处，但了解它非常有用。
 
@@ -16,7 +16,7 @@
 
 这些微小的信息，是您可以在计算机中存储的最小信息，称为位。我们将位表示为低（0）或高（1）。
 
-为了表示大于1的数字，使用一系列位的主意诞生了。 一个八位的序列可以存储更大的数字，这称为字节。 由一和零组成的序列称为二进制。我们传统的十位数计数系统称为十进制。
+为了表示大于 1 的数字，使用一系列位的主意诞生了。 一个八位的序列可以存储更大的数字，这称为字节。 由一和零组成的序列称为二进制。我们传统的十位数计数系统称为十进制。
 
 ![binary](img/74c0efc42f7bf310489f953f2b5cbd0e.jpg)
 
@@ -62,7 +62,7 @@ _ 二进制左移和二进制右移 _
 | 0 | 1 个 | 0 | 1 个 |
 | 1 个 | 0 | 1 个 | 0 |
 
-在移位（0,1,0,1）之前，我们有数字 5。 移位（1,0,1,0）后，我们得到数字 10。在 python 中，您可以使用按位向左运算符（&lt; &lt;）向左移动，按位向右运算符（&gt; &gt;） 向右移动。
+在移位（`0,1,0,1`）之前，我们有数字 5。 移位（`1,0,1,0`）后，我们得到数字 10。在 python 中，您可以使用按位向左运算符（`<<`）向左移动，按位向右运算符（`>>`） 向右移动。
 
 ```py
 inputA = int('0101',2)
@@ -90,7 +90,7 @@ After shifting in decimal: 10
 
 按位 AND
 
-在代码中，这就像使用&符号一样简单，该符号代表逻辑 AND 运算符。
+在代码中，这就像使用`&`符号一样简单，该符号代表逻辑 AND 运算符。
 
 ```py
 # This code will execute a bitwise logical AND. Both inputA and inputB are bits.
@@ -165,7 +165,7 @@ print bin(inputA | inputB)   # Execute bitwise logical OR and print result in bi
 
 按位 XOR
 
-为了执行它，我们使用^运算符。 可以像这样简单地执行一系列位：
+为了执行它，我们使用`^`运算符。 可以像这样简单地执行一系列位：
 
 ```py
 inputA = int('00100011',2)  # define binary number
diff --git a/docs/4.md b/docs/4.md
index 543171bc86ee5c7ee6bf08b893e38ab6e91212ba..18a9fca27a4e17cc3de53d53b6ebf8e961ad7ea7 100644
--- a/docs/4.md
+++ b/docs/4.md
@@ -39,7 +39,10 @@ print(name)
 ```
 
 要测试您的版本，请执行以下操作：
-_python –version_
+
+```
+python –version
+```
 
 ## 字符串比较
 
@@ -56,7 +59,7 @@ if q == sentence:
 
 ```
 
-要测试两个字符串是否相等，请使用 inequality 运算符（！=）
+要测试两个字符串是否相等，请使用不等运算符（`!=`）
 
 ```py
 #!/usr/bin/python
diff --git a/docs/40.md b/docs/40.md
index 4fb5489a9631e4463d5e0587271512117a0adaa7..70083400e1cbad7310334ab7d689eccd2946d90f 100644
--- a/docs/40.md
+++ b/docs/40.md
@@ -4,7 +4,7 @@
 
 我们可以使用调试工具来最小化和发现错误。 在本文中，您将学习最佳的 Python 调试技巧。
 
-## PuDB-基于控制台的 Python 调试器
+## PuDB - 基于控制台的 Python 调试器
 
 ![python-debugging-pudb](img/be30d3c5aa2158a9864d173116eb6291.jpg)
 
@@ -42,19 +42,19 @@ $ pudb3 program.py
 
 （或 sudo（如果您没有正确的权限））
 
-您可以逐步完成该程序。 使用 **n** 键逐步执行该程序。 当前变量内容显示在右上方。
+您可以逐步完成该程序。 使用`n`键逐步执行该程序。 当前变量内容显示在右上方。
 
 ![pudb-debug](img/224bd2a6a881437fdda6c2509430673e.jpg)
 
 python 调试
 
-您可以使用 **b** 键设置断点。 要继续执行直到下一个断点，请按 **c** 键。
+您可以使用`b`键设置断点。 要继续执行直到下一个断点，请按`c`键。
 
 ![python-breakpoint](img/b4dc9a1dbd2f3dbfa9b8223a63b62c12.jpg)
 
 Python 程序中的断点
 
-## PDB-Python 调试器
+## PDB - Python 调试器
 
 `pdb`模块支持设置断点。 断点是程序的有意暂停。 您可以在其中获取有关程序状态的更多信息。
 
@@ -83,7 +83,7 @@ pdb.set_trace()
 
 ```
 
-我们在该程序中插入了一些断点。 程序将在每个断点处暂停（ **pdb.set_trace（）**）。 要查看变量内容，只需键入变量名称：
+我们在该程序中插入了一些断点。 程序将在每个断点处暂停（`pdb.set_trace()`）。 要查看变量内容，只需键入变量名称：
 
 ```py
 
@@ -98,7 +98,7 @@ $ python3 program.py
 
 ```
 
-按 **c** 或**继续**继续执行程序，直到下一个断点
+按`c`或**继续**继续执行程序，直到下一个断点
 
 ```py
 
diff --git a/docs/43.md b/docs/43.md
index 8c7c42d1ee482685daa6e4a1aed51bfd6aac89db..c0c11cf2f2d04c9919ba55267d38180fe86df8c0 100644
--- a/docs/43.md
+++ b/docs/43.md
@@ -21,7 +21,7 @@ with open('persons.csv', 'wb') as csvfile:
 
 ```
 
-运行此代码将为我们提供以下内容的 filpeople.csv：
+运行此代码将为我们提供以下内容的`filpeople.csv`：
 
 ```py
 Name,Profession
@@ -31,11 +31,11 @@ Paul,Manager
 
 ```
 
-您可以在您喜欢的 Office 程序中导入 person.csv 文件。
+您可以在您喜欢的 Office 程序中导入`person.csv`文件。
 
 ![python csv](img/f177725bc03d4c71b4a00e1334990e57.jpg)
 
-Spreadsheet file created in Python
+用 Python 创建的电子表格文件
 
 ## 读取电子表格文件（csv）
 
@@ -64,7 +64,7 @@ with open('persons.csv', 'rb') as f:
 
 ```
 
-也许您想将其存储到 Python 列表中。 我们从 csv 文件中获取数据，然后将其存储到 Python 列表中。 我们使用 if 语句跳过标题，因为它不属于列表。 完整代码：
+也许您想将其存储到 Python 列表中。 我们从 csv 文件中获取数据，然后将其存储到 Python 列表中。 我们使用`if`语句跳过标题，因为它不属于列表。 完整代码：
 
 ```py
 import csv
@@ -102,5 +102,5 @@ print jobs
 
 ```
 
-大多数电子表格或 Office 程序都可以导出 csv 文件，因此我们建议您创建任何类型的 csv 文件并进行处理:-)
+大多数电子表格或 Office 程序都可以导出 csv 文件，因此我们建议您创建任何类型的 csv 文件并进行处理 :-)
 
diff --git a/docs/5.md b/docs/5.md
index 6641066e3a379c7edb3062fe53879bf0c44b82b4..0ea1945fb93ea0c207e4258e23e5209177cee659 100644
--- a/docs/5.md
+++ b/docs/5.md
@@ -10,7 +10,7 @@
 
 Python 为字符串的字符建立索引，每个索引都与一个唯一字符相关联。 例如，字符串`"python"`中的字符具有索引：
 
-![String](img/9faa714fe3700fc2441dae01484b73c3.jpg) &lt;/picture&gt;](/wp-content/uploads/2016/03/python-string.png) 
+![String](img/9faa714fe3700fc2441dae01484b73c3.jpg) 
 
 字符串编号
 
@@ -37,7 +37,7 @@ s[ startIndex : pastIndex ]
 
 ```
 
-startIndex 是字符串的起始索引。 pastIndex 是切片末尾的 1。
+`startIndex`是字符串的起始索引。`pastIndex`是切片末尾加 1。
 
 如果省略第一个索引，则切片将从头开始。 如果省略最后一个索引，则切片将转到字符串的末尾。 例如：
 
diff --git a/docs/6.md b/docs/6.md
index d7b2c45b28cd06ff693879e05bd1dcd2d90ece49..f23cfe2e488cf9ee894329badc9860d5c8992960 100644
--- a/docs/6.md
+++ b/docs/6.md
@@ -10,11 +10,11 @@ Python 中的变量（`x`，`y`，`z`）。它们可以稍后在程序中使用
 
 数字可以是以下数据类型之一：
 
-*   整数 _（1,2,3,4）_
+*   整数（`1,2,3,4`）
 
-*   浮点 _（点后面的数字）_
+*   浮点（点后面的数字）
 
-*   布尔值 _（对或错）_
+*   布尔值（真或假）
 
 ## 数值变量示例
 
@@ -27,7 +27,7 @@ z = True
 
 ```
 
-您可以使用 print（）函数将它们输出到屏幕上。
+您可以使用`print()`函数将它们输出到屏幕上。
 
 ```py
 x = 1
@@ -40,7 +40,7 @@ print(z)
 
 ```
 
-Python 支持算术运算，例如加法（+），乘法（*），除法（/）和减法（-）。
+Python 支持算术运算，例如加法（`+`），乘法（`*`），除法（`/`）和减法（`-`）。
 
 ```py
 #!/usr/bin/env python
@@ -73,8 +73,9 @@ print(sum)
 
 ```
 
-**Python 2** （旧版本）
-您也可以使用 _raw_input_ 函数要求用户输入：
+## Python 2 （旧版本）
+
+您也可以使用`raw_input`函数要求用户输入：
 
 ```py
 #!/usr/bin/env python
diff --git a/docs/7.md b/docs/7.md
index 5ed5e4eb5e8c5a4ec64e961cfa5aa8f94f07a5ed..78f251f85dfe8e2d0adfdf472bfb0448cf3dfbb4 100644
--- a/docs/7.md
+++ b/docs/7.md
@@ -52,7 +52,7 @@ print(l)     # prints all elements
 
 ```
 
-如果要按降序排列列表，只需使用 reverse（）函数。
+如果要按降序排列列表，只需使用`reverse()`函数。
 
 ```py
 #!/usr/bin/python
diff --git a/docs/8.md b/docs/8.md
index 56be126b83eb742a54e6e90e0761b84a2536cef7..565cfecc5ea34ffc5c14c23e6ad035d8247eaf7f 100644
--- a/docs/8.md
+++ b/docs/8.md
@@ -2,8 +2,7 @@
 
 > 原文： [https://pythonspot.com/if-statements/](https://pythonspot.com/if-statements/)
 
-在 Python 中，您可以定义条件语句，称为 if 语句。
-如果满足某些条件，则将执行代码块。
+在 Python 中，您可以定义条件语句，称为`if`语句。如果满足某些条件，则将执行代码块。
 
 ## `if`语句
 
@@ -21,7 +20,7 @@ else:
 
 ```
 
-如果将 x 设置为大于 10，它将执行第二个代码块。 我们使用缩进（4 个空格）定义块。
+如果将`x`设置为大于 10，它将执行第二个代码块。 我们使用缩进（4 个空格）定义块。
 
 ## 一个小游戏：
 
@@ -66,7 +65,7 @@ if a > 10:
 
 ```
 
-考虑结合 4 或 6 个条件，这可能很快变得难以阅读。 幸运的是，Python 有一个解决方案，我们可以使用 _ 和 _ 关键字组合条件。
+考虑结合 4 或 6 个条件，这可能很快变得难以阅读。 幸运的是，Python 有一个解决方案，我们可以使用`and`关键字组合条件。
 
 ```py
 guess = 24
@@ -77,6 +76,6 @@ else:
 
 ```
 
-有时您可能想使用 _ 或 _ 运算符。
+有时您可能想使用`or`运算符。
 
 [下载 Python 练习](https://pythonspot.com/download-python-exercises/)
\ No newline at end of file
diff --git a/docs/9.md b/docs/9.md
index c946b9f85a2b439a3d313d6d74207559f402996b..701a02e44f3667c74d2b57297596f545590e7642 100644
--- a/docs/9.md
+++ b/docs/9.md
@@ -17,7 +17,7 @@ def function(parameters):
 
 ```
 
-**def 关键字**告诉 Python 我们有一段可重用的代码（一个函数）。 一个程序可以具有许多函数。
+**`def`关键字**告诉 Python 我们有一段可重用的代码（一个函数）。 一个程序可以具有许多函数。
 
 ## 实际例子
 
@@ -40,7 +40,7 @@ print(f(3))
 
 ```
 
-该函数具有一个参数 x。 返回值是函数返回的值。 并非所有函数都必须返回某些内容。
+该函数具有一个参数`x`。 返回值是函数返回的值。 并非所有函数都必须返回某些内容。
 
 ## 参数