2019-12-04 22:57:28

docs/37.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonbasics.org/class/](https://pythonbasics.org/class/)
 
-Python 类是 _“面向对象编程”_ 的概念。 Python 是一种面向对象的编程语言（oop）。 OOP 是一种构建软件的方法。
+Python 类是“面向对象编程”的概念。 Python 是一种面向对象的编程语言（OOP）。 OOP 是一种构建软件的方法。
 
 使用 OOP，您可以使程序更有条理，可伸缩性，可重用性和可扩展性。 OOP 概念可能有点奇怪。 掌握起来可能很困难，但这是一个非常强大的概念。
 
@@ -29,8 +29,7 @@ obj1.age = 5
 
 ```
 
-如果对象存在方法，则可以调用它们。 对象的唯一变量可以在这些方法中使用。
-这些方法可以多次使用：
+如果对象存在方法，则可以调用它们。 对象的唯一变量可以在这些方法中使用。这些方法可以多次使用：
 
 ```py
 obj1.bark()
@@ -54,10 +53,9 @@ obj4 = bird()
 
 对象总是从类创建的。 一个类定义对象中存在的每个方法和变量。 您可以将类视为对象的蓝图。
 
-还记得前面的示例中的 dog 类型的对象吗？
+还记得前面的示例中的`dog`类型的对象吗？
 
-该对象具有**变量**（年龄，名称）和**方法**（树皮）。 它们在狗类中定义。
-这是该类的定义方式：
+该对象具有**变量**（`name`，`age`）和**方法**（`bark`）。 它们在狗类中定义。这是该类的定义方式：
 
 ```py
 class dog:
@@ -69,7 +67,7 @@ class dog:
 
 ```
 
-首先，我们定义类本身：类狗。 然后定义变量（名称，狗）。 最后，我们定义方法。 如果仔细观察，就会发现该方法中包含**自我**一词。 **自我**一词指的是对象（您可以从一个类中创建多个对象。）
+首先，我们定义类本身：`class dog`。 然后定义变量（`name`，`age`）。 最后，我们定义方法。 如果仔细观察，就会发现该方法中包含`self`一词。`self`一词指的是对象（您可以从一个类中创建多个对象。）
 
 ![classes](img/19c8b8b00bad93b9152130737a32fd14.jpg)
 
@@ -77,8 +75,7 @@ class dog:
 
 类不仅用于有趣的示例（狗，鸟）。 它们已在所有计算机软件中使用。
 
-如果您承担制作网络浏览器的任务，则需要在某个时候显示一个网站。
-可以说程序将是面向对象的。 然后可以用这种方式定义一个类：
+如果您承担制作网络浏览器的任务，则需要在某个时候显示一个网站。可以说程序将是面向对象的。 然后可以用这种方式定义一个类：
 
 ```py
 #!/usr/bin/python
@@ -91,9 +88,9 @@ class Website:
 
 ```
 
-等等..什么是 init？
+等等..什么是`__init__`？
 
-如果创建了对象，则调用方法 **init** 。 这始终是创建新对象时调用的第一个方法。 该方法称为**构造函数**。
+如果创建了对象，则调用方法`__init__`。 这始终是创建新对象时调用的第一个方法。 该方法称为**构造函数**。
 
 然后，您可以创建 Web 浏览器对象。
 
@@ -111,7 +108,7 @@ obj.showTitle()
 
 ```
 
-在本示例中，我们有一个从类 Website 创建的对象（obj）。 该类有两种方法： **init** （）和 showTitle（）。
+在本示例中，我们有一个从类`Website`创建的对象（`obj`）。 该类有两种方法：`__init__`和`showTitle()`。
 
 ## 练习
 
@@ -121,7 +118,7 @@ obj.showTitle()
 2.  可以从同一个类中创建多个对象吗？
 3.  对象可以创建类吗？
 4.  使用上面的代码，创建另一个对象
-5.  在类中添加一个方法：location（）
+5.  在类中添加一个方法：`location()`
 
 完成这些步骤后，继续下一个练习。
 

docs/38.md

@@ -14,11 +14,11 @@
 
 每次创建对象时，都会调用一个方法。 该方法称为**构造函数**。
 
-构造函数是使用函数 **init** 创建的。 作为参数，我们编写了 self 关键字，它引用了自身（对象）。 从视觉上看，该过程是：
+构造函数是使用函数`__init__`创建的。 作为参数，我们编写了`self`关键字，它引用了自身（对象）。 从视觉上看，该过程是：
 
 ![constructor](img/8633b18ca0aedbc0c2aa0841fa26afdf.jpg)
 
-在构造函数内部，我们初始化两个变量：腿和手臂。 有时，在面向对象编程的上下文中，变量被称为属性。 我们创建一个对象（bob），仅通过创建它，即可初始化其变量。
+在构造函数内部，我们初始化两个变量：腿和手臂。 有时，在面向对象编程的上下文中，变量被称为属性。 我们创建一个对象（`bob`），仅通过创建它，即可初始化其变量。
 
 ```py
 class Human:
@@ -35,11 +35,11 @@ print(bob.legs)
 
 ### python `__init__`
 
-函数 **init** （自身）将构建您的对象。 它不仅是您可以在此处设置的变量，还可以调用类方法。 初始化对象所需的一切。
+函数`__init__(self)`将构建您的对象。 它不仅是您可以在此处设置的变量，还可以调用类方法。 初始化对象所需的一切。
 
-假设您有一个“飞机”课，该飞机一经创建便应开始飞行。 起飞涉及许多步骤：加速，更换襟翼，关闭车轮等。
+假设您有一个“飞机”类，该飞机一经创建便应开始飞行。 起飞涉及许多步骤：加速，更换襟翼，关闭车轮等。
 
-_ 可以在方法中定义默认操作。 这些方法可以在构造函数 _ 中调用。
+可以在方法中定义默认操作。 这些方法可以在构造函数中调用。
 
 ```py
 class Plane:
@@ -72,7 +72,7 @@ ba = Plane()
 
 可以在构造函数中设置新创建对象的默认值。
 
-belwo 示例显示了两个带有构造函数的类。 然后创建两个对象，但调用不同的构造函数。
+下面的示例显示了两个带有构造函数的类。 然后创建两个对象，但调用不同的构造函数。
 
 ```py
 class Bug:

docs/39.md

@@ -22,7 +22,7 @@ Bob = Friend()
 
 ```
 
-这些对象没有设置属性（作业）。 要进行设置，我们可以直接进行设置，但这是一个不好的做法。 相反，我们创建两个方法：getJob（）和 setJob（）。
+这些对象没有设置属性（作业）。 要进行设置，我们可以直接进行设置，但这是一个不好的做法。 相反，我们创建两个方法：`getJob()`和`setJob()`。
 
 ```py
 class Friend:
@@ -47,14 +47,15 @@ print(Alice.job)
 ```
 
 创建了两个对象，这两个对象对于属性作业均具有唯一的值：
+
 ![getter setter](img/73f6512e1f8ebce243695f723c837fe4.jpg)
 
 ## 练习
 
 试试下面的练习
 
-1.  添加可变年龄并创建吸气剂和吸气剂
-2.  为什么要使用 getter 和 setter 方法？
+1.  添加变量年龄并创建获取器和设置器
+2.  为什么要使用获取器和设置器方法？
 
 完成这些步骤后，继续下一个练习。
 

docs/40.md

@@ -18,9 +18,9 @@
 
 ### 导入模块
 
-您可以使用 **import** 关键字加载模块。
+您可以使用`import`关键字加载模块。
 
-在下面的示例中，我们加载 _os 模块 _。 这是操作系统的缩写，因此您可以执行系统任务。
+在下面的示例中，我们加载`os`模块。 这是操作系统的缩写，因此您可以执行系统任务。
 
 ```py
 import os
@@ -30,7 +30,7 @@ os.system("dir")
 
 使用该模块，我们调用其名为系统的函数之一（运行命令）。
 
-在这种情况下，它将仅列出目录中的文件（dir 命令）。
+在这种情况下，它将仅列出目录中的文件（`dir`命令）。
 
 Python 有许多可用的模块。
 
@@ -43,7 +43,7 @@ from module import function
 
 ```
 
-有一个名为 _time_ 的模块，该模块具有各种时间函数：获取日期，小时，分钟，秒等。 有很多函数。
+有一个名为`time`的模块，该模块具有各种时间函数：获取日期，小时，分钟，秒等。 有很多函数。
 
 假设您希望程序等待 2 秒。 如果需要，可以导入特定函数而不是整个模块。
 
@@ -56,8 +56,7 @@ sleep(2)
 
 ### 从模块导入所有函数
 
-您可以从模块导入所有函数，但是不建议这样做。
-下面的示例导入整个时间模块（所有函数），然后可以使用。
+您可以从模块导入所有函数，但是不建议这样做。下面的示例导入整个时间模块（所有函数），然后可以使用。
 
 ```py
 #!/usr/bin/python
@@ -83,8 +82,7 @@ dir(os)
 
 ### 制作模块
 
-要制作模块，请创建一个 Python 文件。 然后像导入其他模块一样将其导入。
-创建您的模块（fruit.py）
+要制作模块，请创建一个 Python 文件。 然后像导入其他模块一样将其导入。创建您的模块（`fruit.py`）
 
 ```py
 def lemon():
@@ -92,7 +90,7 @@ def lemon():
 
 ```
 
-然后创建您的程序（example.py）并调用该函数：
+然后创建您的程序（`example.py`）并调用该函数：
 
 ```py
 import fruit
@@ -103,8 +101,7 @@ fruit.lemon()
 
 ### 找不到 python 模块
 
-如果收到错误“ ImportError：没有名为<name>的模块”，则表示未安装该模块。
-您可以使用 pip 软件包管理器安装模块。 为此，最好也设置一个 virtualenv。</name>
+如果收到错误“`ImportError`：没有名为`<name>`的模块”，则表示未安装该模块。您可以使用`pip`软件包管理器安装模块。 为此，最好也设置一个`virtualenv`。
 
 ```py
 virtualenv projectname
@@ -118,7 +115,7 @@ pip install module
 
 试试下面的练习
 
-1.  导入数学模块并调用 sin 函数
-2.  使用函数 snake（）创建自己的模块
+1.  导入数学模块并调用`sin`函数
+2.  使用函数`snake()`创建自己的模块
 
 [下载示例](https://gum.co/HhgpI)
\ No newline at end of file

docs/41.md

@@ -4,7 +4,7 @@
 
 继承：一个类可以获取另一个类的属性和变量。 该类称为超类或父类。
 
-继承使您不必重复自己 _（在编码中：不要重复自己 _），您可以定义一次方法并将其用于一个或多个子类中。
+继承使您不必重复自己（在编码中：不要重复自己），您可以定义一次方法并将其用于一个或多个子类中。
 
 
 
@@ -12,8 +12,7 @@
 
 ### 简介
 
-您至少需要两个类才能使继承起作用。 就像现实生活一样，一个人会继承另一个。
-从超类继承的类将获得所有内容。 什么事
+您至少需要两个类才能使继承起作用。 就像现实生活一样，一个人会继承另一个。从超类继承的类将获得所有内容。
 
 对于面向对象的编程，这意味着它将从超类获取方法和变量。
 
@@ -23,9 +22,9 @@
 
 ### 工作原理
 
-定义两个类，一个超类（App）和一个子类（Android）。 子类（Android）继承自 App 类。
+定义两个类，一个超类（`App`）和一个子类（`Android`）。 子类（`Android`）继承自`App`类。
 
-首先，我们定义超类。 超级类的编写方式与普通类一样，没有什么特别之处，只不过其他人可以继承。 您可以根据需要提供方法和变量。
+首先，我们定义超类。 超类的编写方式与普通类一样，没有什么特别之处，只不过其他人可以继承。 您可以根据需要提供方法和变量。
 
 ```py
 class App:
@@ -34,9 +33,9 @@ class App:
 
 ```
 
-我们在超类（App）中定义了方法和变量，一旦继承，我们就可以在子类中使用它们。 让我们创建一个继承自超类的类（Android）。
+我们在超类（`App`）中定义了方法和变量，一旦继承，我们就可以在子类中使用它们。 让我们创建一个继承自超类的类（`Android`）。
 
-在超类中，我们创建方法 start（）。 这只是出于演示目的，该方法在使用 Android 类创建对象时将可用。
+在超类中，我们创建方法`start()`。 这只是出于演示目的，该方法在使用`Android`类创建对象时将可用。
 
 Python 如何知道类要继承？ 类名后的花括号。
 
@@ -74,7 +73,7 @@ app.getVersion()
 
 请尝试以下练习：
 
-1.  创建一个继承自 App 类的新类
+1.  创建一个继承自`App`类的新类
 2.  尝试创建一个从两个超类继承的类（多重继承）
 
 [下载示例](https://gum.co/HhgpI)
\ No newline at end of file

docs/42.md

@@ -14,7 +14,7 @@
 
 通常，您可能想进行函数调用，或者创建一个对象来调用其方法。 但是，您可以执行其他操作：在类中调用方法而不创建对象。
 
-下面演示静态方法。 用方法定义一个类。 在其上方添加关键字@staticmethod 以使其变为静态。
+下面演示静态方法。 用方法定义一个类。 在其上方添加关键字`@staticmethod`以使其变为静态。
 
 ```py
 class Music:

docs/43.md

@@ -2,10 +2,9 @@
 
 > 原文： [https://pythonbasics.org/iterable/](https://pythonbasics.org/iterable/)
 
-可迭代对象是可以用作序列的 Python 对象。 您可以使用 next（）方法转到序列的下一项。
+可迭代对象是可以用作序列的 Python 对象。 您可以使用`next()`方法转到序列的下一项。
 
-您可以遍历可迭代对象，但不能直接访问单个元素。
-这是一个容器对象：当时只能返回其元素之一。
+您可以遍历可迭代对象，但不能直接访问单个元素。这是一个容器对象：当时只能返回其元素之一。
 
 
 
@@ -47,8 +46,7 @@ print( next(iterator) )
 
 ### 可迭代类型
 
-您不能使用索引访问元素，这将引发异常。
-可迭代对象类型包括列表，字符串，字典和集合。
+您不能使用索引访问元素，这将引发异常。可迭代对象类型包括列表，字符串，字典和集合。
 
 下面的演示将迭代器应用于列表：
 

docs/44.md

@@ -12,7 +12,7 @@
 
 ### 类方法示例
 
-要将方法转换为类方法，请在方法定义之前添加 **@classmethod** 。 该方法始终将类作为参数。
+要将方法转换为类方法，请在方法定义之前添加`@classmethod`。 该方法始终将类作为参数。
 
 下面的示例定义了一个类方法。 然后，类本身可以使用该类方法。 在此示例中，类方法使用类属性名称。
 
@@ -78,9 +78,9 @@ Fruit.printAge()
 
 类方法与静态方法的不同之处在于，静态方法不了解类本身。 在类方法中，参数始终是类本身。
 
-_ 静态方法 _ 对类或实例一无所知。 您也可以使用函数调用。
+静态方法对类或实例一无所知。 您也可以使用函数调用。
 
-_ 类方法 _ 在调用该方法时获取该类。 它了解类的属性和方法。
+类方法在调用该方法时获取该类。 它了解类的属性和方法。
 
 ### 练习
 

docs/45.md

@@ -12,12 +12,11 @@
 
 ### 简介
 
-一个类可以从 Python _ 中的多个类继承（其他编程语言并非总是如此）_。
-如果创建一个类，则可以让它从父类（有时称为超类）继承。
+一个类可以从 Python 中的多个类继承（其他编程语言并非总是如此）。如果创建一个类，则可以让它从父类（有时称为超类）继承。
 
 该类本身可以命名为子类，因为它有多个父类。
 
-如果一个类继承自超类，它将获得其所有属性和方法。 如果您有 4 个超级类，它将仅继承所有它们。
+如果一个类继承自超类，它将获得其所有属性和方法。 如果您有 4 个超类，它将仅继承所有它们。
 
 通用格式为：
 
@@ -32,7 +31,7 @@ class Subclass(SuperClass1, SuperClass2, SuperClass3, ..):
 
 ### 多重继承
 
-在下面的程序中，定义了两个超级类：Human 和 Coder。 通过使用以下代码行，Pythonista 类从这两个类继承：
+在下面的程序中，定义了两个超类：`Human`和`Coder`。 通过使用以下代码行，`Pythonista`类从这两个类继承：
 
 ```py
 class Pythonista(Human, Coder):

docs/47.md

@@ -2,35 +2,33 @@
 
 > 原文： [https://pythonbasics.org/virtualenv/](https://pythonbasics.org/virtualenv/)
 
-virtualenv 可以创建 _ 隔离的 Python 环境 _。
+`virtualenv`可以创建隔离的 Python 环境。
 
 Python 默认情况下在系统范围内安装模块。 如果程序需要同一模块的不同版本，则可能会成为问题。
 
-这与其他未在系统范围内安装模块的编程语言不同。
-想象两个 Python 应用程序，其中一个需要 libBar 1.0，另一个需要 libBar 2.0。
+这与其他未在系统范围内安装模块的编程语言不同。想象两个 Python 应用程序，其中一个需要 libBar 1.0，另一个需要 libBar 2.0。
 
-virtualenv 通过创建隔离的环境巧妙地解决了这个问题。 模块将仅安装在虚拟环境中。 在您的环境内部，您可以安装任何模块而不会影响系统范围的配置。
+`virtualenv`通过创建隔离的环境巧妙地解决了这个问题。 模块将仅安装在虚拟环境中。 在您的环境内部，您可以安装任何模块而不会影响系统范围的配置。
 
 
 
 ## 设置
 
-程序 virtualenv 可以解决。 它使您可以创建虚拟环境。
-要创建虚拟环境，请使用以下命令：
+程序`virtualenv`可以解决。 它使您可以创建虚拟环境。要创建虚拟环境，请使用以下命令：
 
 ```py
 virtualenv -p python3 envname
 
 ```
 
-其中 envname 是您的项目名称。 如果将项目命名为“ testproject”，则会得到以下一行：
+其中`envname`是您的项目名称。 如果将项目命名为`testproject`，则会得到以下一行：
 
 ```py
 virtualenv -p python3 testproject
 
 ```
 
-这将使用以下子目录创建文件夹 virtualenv：bin，include，lib 和 share。
+这将使用以下子目录创建文件夹`virtualenv`：`bin`，`include`，`lib`和`share`。
 
 加载虚拟环境类型
 
@@ -40,8 +38,7 @@ bin/activate
 
 ```
 
-现在，您的虚拟环境已激活。
-Shell 将显示当前已加载的虚拟环境。
+现在，您的虚拟环境已激活。Shell 将显示当前已加载的虚拟环境。
 
 ![virtualenv python](img/7398f5673c673324cae1e8cc3386c337.jpg)
 
@@ -52,7 +49,7 @@ deactivate
 
 ```
 
-您可以根据需要创建任意数量的虚拟环境。 每个项目都应该有自己的 virtualenv，因为它需要不需要在系统范围内安装的特定模块。
+您可以根据需要创建任意数量的虚拟环境。 每个项目都应该有自己的`virtualenv`，因为它需要不需要在系统范围内安装的特定模块。
 
 ![virtualenv showing modules ](img/340d45a74478864f1574d91d2c2895c2.jpg)
 
@@ -60,6 +57,6 @@ deactivate
 
 请尝试以下练习：
 
-1.  为项目设置一个新的虚拟环境并激活它。 使用 pip 安装模块。
+1.  为项目设置一个新的虚拟环境并激活它。 使用`pip`安装模块。
 
 [下载示例](https://gum.co/HhgpI)
\ No newline at end of file

docs/48.md

@@ -4,13 +4,11 @@
 
 枚举是一个内置函数，它返回一个枚举对象。
 
-调用是枚举（顺序，开始= 0）
+调用是`enumerate(sequence, start=0)`
 
-输出对象包括一个计数器，如下所示：（0，thing [0]），（1，thing [1]），（2，thing [2]），
+输出对象包括一个计数器，如下所示：`(0, thing [0]), (1, thing [1]), (2, thing [2])`，依此类推。
 
-，依此类推。
-
-作为输入，它需要一个类似于列表，元组或迭代器的序列。 start 参数是可选的。
+作为输入，它需要一个类似于列表，元组或迭代器的序列。`start`参数是可选的。
 如果起始参数设置为 1，则计数将从 1 开始而不是从 0 开始
 
 
@@ -52,6 +50,6 @@ print(x)
 
 试试下面的练习
 
-1.  将 for 循环与可枚举相结合。
+1.  将`for`循环与`enumerate`相结合。
 
 [下载示例](https://gum.co/HhgpI)
\ No newline at end of file

docs/49.md

@@ -12,8 +12,7 @@ Pickle 可用于序列化和反序列化对象。 可以将已序列化的对象
 
 ## 序列化对象
 
-要使用 Pickle，请导入 Pickle 模块。
-创建一个对象并将其序列化。 然后使用文件对象将其写入文件。
+要使用 Pickle，请导入`pickle`模块。创建一个对象并将其序列化。 然后使用文件对象将其写入文件。
 
 ```py
 import pickle
@@ -30,7 +29,7 @@ fileObj.close()
 
 现在，该对象已保存到文件中，您可以加载它（解开它）。 在下面的示例中，我们从文件中加载对象。
 
-加载 pickle 模块，打开然后读取文件，然后使用 pickle.load（）加载数据。 您可以将其加载到所需的任何变量中，但是为了方便起见，我使用了相同的名称（exampleObj）。
+加载`pickle`模块，打开然后读取文件，然后使用`pickle.load()`加载数据。 您可以将其加载到所需的任何变量中，但是为了方便起见，我使用了相同的名称（`exampleObj`）。
 
 ```py
 import pickle   

docs/50.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://pythonbasics.org/regular-expressions/](https://pythonbasics.org/regular-expressions/)
 
-re 模块处理 Python 中的正则表达式
+`re`模块处理 Python 中的正则表达式
 
 正则表达式可用于查找字符串中的所有匹配项，或仅测试匹配项是否存在。
 
@@ -12,9 +12,9 @@ re 模块处理 Python 中的正则表达式
 
 ## 示例
 
-创建一个字符串以运行正则表达式。 作为示例短语，我们将使用美国著名的绕口令“ wouldchuck”。
+创建一个字符串以运行正则表达式。 作为示例短语，我们将使用美国著名的绕口令`"wouldchuck"`。
 
-使用正则表达式查找字符串的所有匹配项。 使用正则表达式和搜索空间作为参数调用方法 findall（）。
+使用正则表达式查找字符串的所有匹配项。 使用正则表达式和搜索空间作为参数调用方法`findall()`。
 
 请尝试以下程序：
 
@@ -28,12 +28,11 @@ print(matches)
 
 ```
 
-它返回正则表达式的匹配项。
-我们定义起始字母“ woo”，后跟匹配零次或多次*的单词字符\ w。
+它返回正则表达式的匹配项。我们定义起始字母`"woo"`，后跟匹配零次或多次（`*`）的单词字符`\w`。
 
 ![regular expression](img/063d4109d021245e06c9a9d6e68c98d1.jpg)
 
-要测试数据是否匹配正则表达式，请使用搜索方法。 返回 true 或 false，可以与 if 语句匹配：
+要测试数据是否匹配正则表达式，请使用搜索方法。 返回`true`或`false`，可以与`if`语句匹配：
 
 ```py
 if re.search(r'woo\w*', string):
@@ -43,7 +42,7 @@ else:
 
 ```
 
-如果要编写自己的正则表达式，请签出此[备忘单](https://i.pinimg.com/originals/07/62/db/0762dbbeef53ee102ee9ca2e4df6bda0.jpg)。
+如果要编写自己的正则表达式，请检查此[备忘单](https://i.pinimg.com/originals/07/62/db/0762dbbeef53ee102ee9ca2e4df6bda0.jpg)。
 
 ## 练习