修复了文档中的缺陷

第004课：Python语言元素之运算符.md

@@ -61,9 +61,9 @@ print(a)      # 算一下这里会输出什么
 
 ###比较运算符和逻辑运算符
 
-比较运算符有的地方也称为关系运算符，包括`==`、`!=`、`<`、`>`、`<=`、`>=`，我相信没有什么好解释的，大家一看就能懂，唯一需要提醒的是比较相等用的是`==`，请注意这个地方是两个等号，因为`=`是赋值运算符，我们在上面刚刚讲到过，`==`才是比较相等的比较运算符。比较运算符会产生布尔值，要么是`True`要么是`False`。
+比较运算符有的地方也称为关系运算符，包括`==`、`!=`、`<`、`>`、`<=`、`>=`，我相信没有什么好解释的，大家一看就能懂，需要提醒的是比较相等用的是`==`，请注意这里是两个等号，因为`=`是赋值运算符，我们在上面刚刚讲到过，`==`才是比较相等的运算符；比较不相等用的是`!=`，这不同于数学上的不等号，Python 2中曾经使用过`<>`来表示不等关系，大家知道就可以了。比较运算符会产生布尔值，要么是`True`要么是`False`。
 
-逻辑运算符有三个，分别是`and`、`or`和`not`。`and`字面意思是“而且”，所以`and`运算符会连接两个布尔值，如果两个布尔值都是`True`，那么运算的结果就是`True`；左右两边的布尔值有一个是`False`，最终的运算结果就是`False`。相信大家已经想到了，如果`and`左边的布尔值是`False`，不管右边的布尔值是什么，最终的结果都是`False`，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在`and`运算符左边为`False`的情况下，右边的表达式根本不会执行。`or`字面意思是“或者”，所以`or`运算符也会连接两个布尔值，如果两个布尔值有任意一个是`True`，那么最终的结果就是`True`。当然，`or`运算符也是有短路功能的，在它左边的布尔值为`True`的情况下，右边的表达式根本不会执行。`not`运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，后面的布尔值如果是`True`运算结果就是`False`，而后面的布尔值如果是`False`则运算结果就是`True`。
+逻辑运算符有三个，分别是`and`、`or`和`not`。`and`字面意思是“而且”，所以`and`运算符会连接两个布尔值，如果两个布尔值都是`True`，那么运算的结果就是`True`；左右两边的布尔值有一个是`False`，最终的运算结果就是`False`。相信大家已经想到了，如果`and`左边的布尔值是`False`，不管右边的布尔值是什么，最终的结果都是`False`，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在`and`运算符左边为`False`的情况下，右边的表达式根本不会执行。`or`字面意思是“或者”，所以`or`运算符也会连接两个布尔值，如果两个布尔值有任意一个是`True`，那么最终的结果就是`True`。当然，`or`运算符也是有短路功能的，在它左边的布尔值为`True`的情况下，右边的表达式根本不会执行。`not`运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，`not`后面的布尔值如果是`True`，运算结果就是`False`；而`not`后面的布尔值如果是`False`，运算结果就是`True`。
 
 ```Python
 """

第008课：函数和模块.md

@@ -120,8 +120,8 @@ print(add(1))        # 1
 print(add(1, 2))     # 3
 # 调用add函数，传入三个参数，分别赋值给a、b、c三个变量
 print(add(1, 2, 3))  # 6
-# 传递参数时可以不按照设定的顺序进行传递
-print(add(c=50, a=100, b=200))
+# 传递参数时可以不按照设定的顺序进行传递，但是要用“参数名=参数值”的形式
+print(add(c=50, a=100, b=200))    # 350
 ```
 
 #### 可变参数

第009课：常用数据结构之字符串.md

@@ -79,6 +79,36 @@ print(s1)    # hello world!!!hello world!!!
 
 用`*`实现字符串的重复是非常有意思的一个运算符，在很多编程语言中，要表示一个有10个`a`的字符串，你只能写成`"aaaaaaaaaa"`，但是在Python中，你可以写成`'a' * 10`。你可能觉得`"aaaaaaaaaa"`这种写法也没有什么不方便的，那么想一想，如果字符`a`要重复100次或者1000次又会如何呢？
 
+#### 比较运算
+
+对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。需要说明的是，因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的大小比较比的是每个字符对应的编码的大小。例如`A`的编码是`65`， 而`a`的编码是`97`，所以`'A' < 'a'`的结果相当于就是`65 < 97`的结果，很显然是`True`；而`'boy' < 'bad'`，因为第一个字符都是`'b'`比不出大小，所以实际比较的是第二个字符的大小，显然`'o' < 'a'`的结果是`False`，所以`'boy' < 'bad'`的结果也是`False`。如果不清楚两个字符对应的编码到底是多少，可以使用`ord`函数来获得，例如`ord('A')`的值是`65`，而`ord('昊')`的值是`26122`。下面的代码为大家展示了字符串的比较运算。
+
+```Python
+s1 = 'a whole new world'
+s2 = 'hello world'
+print(s1 == s2, s1 < s2)      # False True
+print(s2 == 'hello world')    # True
+print(s2 == 'Hello world')    # False
+print(s2 != 'Hello world')    # True
+s3 = '骆昊'
+print(ord('骆'), ord('昊'))               # 39558 26122
+s4 = '王大锤'
+print(ord('王'), ord('大'), ord('锤'))    # 29579 22823 38180
+print(s3 > s4, s3 <= s4)      # True False
+```
+
+需要强调一下的是，字符串的比较运算比较的是字符串的内容，Python中还有一个`is`运算符（身份运算符），如果用`is`来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址），简单的说就是两个变量是否对应内存中的同一个字符串。看看下面的代码就比较清楚`is`运算符的作用了。
+
+```Python
+s1 = 'hello world'
+s2 = 'hello world'
+s3 = s2
+# 比较字符串的内容
+print(s1 == s2, s2 == s3)    # True True
+# 比较字符串的内存地址
+print(s1 is s2, s2 is s3)    # False True
+```
+
 #### 成员运算
 
 Python中可以用`in`和`not in`判断一个字符串中是否存在另外一个字符或字符串，`in`和`not in`运算通常称为成员运算，会产生布尔值`True`或`False`，代码如下所示。

第011课：常用数据结构之列表.md

@@ -46,11 +46,20 @@ items1 = [35, 12, 99, 68, 55, 87]
 items2 = ['Python', 'Java', 'Go', 'Kotlin']
 ```
 
+除此以外，还可以通过Python内置的`list`函数将其他序列变成列表。准确的说，`list`并不是一个函数，而是创建列表对象的构造器（后面会讲到对象和构造器这两个概念）。
+
+```Python
+items1 = list(range(1, 10))
+print(items1)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]
+items2 = list('hello')
+print(items2)    # ['h', 'e', 'l', 'l', 'o']
+```
+
 需要说明的是，列表是一种可变数据类型，也就是说列表可以添加元素、删除元素、更新元素，这一点跟我们上一课讲到的字符串有着鲜明的差别。字符串是一种不可变数据类型，也就是说对字符串做拼接、重复、转换大小写、修剪空格等操作的时候会产生新的字符串，原来的字符串并没有发生任何改变。
 
 #### 列表的运算符
 
-和字符串类型一样，列表也支持拼接、重复、成员运算、索引和切片，对此我们不再进行赘述，请大家参考下面的代码。
+和字符串类型一样，列表也支持拼接、重复、成员运算、索引和切片以及比较运算，对此我们不再进行赘述，请大家参考下面的代码。
 
 ```Python
 items1 = [35, 12, 99, 68, 55, 87]
@@ -82,6 +91,15 @@ print(items3[:5])          # [35, 12, 99, 68, 55]
 print(items3[4:])          # [55, 87, 45, 8, 100]
 print(items3[-5:-7:-1])    # [55, 68]
 print(items3[::-2])        # [100, 45, 55, 99, 35]
+
+# 列表的比较运算
+items5 = [1, 2, 3, 4]
+items6 = list(range(1, 5))
+# 两个列表比较相等性比的是对应索引位置上的元素是否相等
+print(items5 == items6)    # True
+items7 = [3, 2, 1]
+# 两个列表比较大小比的是对应索引位置上的元素的大小
+print(items5 <= items7)    # True
 ```
 
 值得一提的是，由于列表是可变类型，所以通过索引操作既可以获取列表中的元素，也可以更新列表中的元素。对列表做索引操作一样要注意索引越界的问题，对于有`N`个元素的列表，正向索引的范围是`0`到`N-1`，负向索引的范围是`-1`到`-N`，如果超出这个范围，将引发`IndexError`异常，错误信息为：`list index out of range`。
@@ -154,6 +172,14 @@ print(items)    # []
 
 需要提醒大家，在使用`remove`方法删除元素时，如果要删除的元素并不在列表中，会引发`ValueError`异常，错误消息是：`list.remove(x): x not in list`。在使用`pop`方法删除元素时，如果索引的值超出了范围，会引发`IndexError`异常，错误消息是：`pop index out of range`。
 
+从列表中删除元素其实还有一种方式，就是使用Python中的`del`关键字后面跟要删除的元素，这种做法跟使用`pop`方法指定索引删除元素没有实质性的区别，但后者会返回删除的元素，前者在性能上略优（`del`对应字节码指令是`DELETE_SUBSCR`，而`pop`对应的字节码指令是`CALL_METHOD`和`POP_TOP`）。
+
+```Python
+items = ['Python', 'Java', 'Go', 'Kotlin']
+del items[1]
+print(items)    # ['Python', 'Go', 'Kotlin']
+```
+
 #### 元素位置和次数
 
 列表类型的`index`方法可以查找某个元素在列表中的索引位置；因为列表中允许有重复的元素，所以列表类型提供了`count`方法来统计一个元素在列表中出现的次数。请看下面的代码。
@@ -271,7 +297,7 @@ print(scores)    # [[95, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
 
 ### 简单的总结
 
-这节课我们先不做总结，等学完下节课的元组之后，我们对列表和元组的使用做一个简单的总结。
+Python中的列表底层是一个可以动态扩容的数组，列表元素在内存中也是连续存储的，所以可以实现随机访问（通过一个有效的索引获取到对应的元素且操作时间与列表元素个数无关）。我们暂时不去触碰这些底层存储细节以及列表每个方法的渐近时间复杂度（执行这个方法耗费的时间跟列表元素个数的关系），等需要的时候再告诉大家。现阶段，大家只需要知道**列表是容器**，可以**保存各种类型的数据**，**可以通过索引操作列表元素**就可以了。
 
 > **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**。
 

第012课：常用数据结构之元组.md

@@ -1,10 +1,10 @@
 ## 第012课：常用数据结构之元组
 
-上一节课为大家讲解了Python中的列表，它是一种容器型数据类型，我们可以通过定义列表类型的变量来保存和操作多个元素。当然，Python中容器型的数据类型肯定不止列表一种，接下来我们为大家讲解另一种非常重要的容器型数据类型，它的名字叫元组（tuple）。
+上一节课为大家讲解了Python中的列表，它是一种容器型数据类型，我们可以通过定义列表类型的变量来保存和操作多个元素。当然，Python中容器型的数据类型肯定不止列表一种，接下来我们为大家讲解另一种重要的容器型数据类型，它的名字叫元组（tuple）。
 
 ### 定义和使用元组
 
-在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组使用`()`字面量语法，元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。
+在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组通常使用`()`字面量语法，也建议大家使用这种方式来创建元组。元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。
 
 ```Python
 # 定义一个三元组
@@ -35,6 +35,11 @@ print(t3)           # (30, 10, 55, '骆昊', 40, True, '四川成都')
 
 # 切片
 print(t3[::3])      # (30, '骆昊', '四川成都')
+
+# 比较运算
+print(t1 == t3)    # False
+print(t1 >= t3)    # False
+print(t1 < (30, 11, 55))    # True
 ```
 
 一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，`()`表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则`()`就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以`('hello', )`和`(100, )`才是一元组，而`('hello')`和`(100)`只是字符串和整数。我们可以通过下面的代码来加以验证。
@@ -196,6 +201,6 @@ def find_max_and_min(items):
 
 ### 简单的总结
 
-**列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行**拼接**、**成员运算**、**索引和切片**这些操作，就如同之前讲到的字符串类型一样，因为字符串是字符按一定顺序构成的序列，在这一点上三者并没有本质区别。我们**推荐大家使用列表的生成式语法来创建列表**，它很好用，也是Python中非常有特色的语法。
+**列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行**拼接**、**成员运算**、**索引和切片**这些操作，就如同之前讲到的字符串类型一样，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。我们**推荐大家使用列表的生成式语法来创建列表**，它很好用，也是Python中非常有特色的语法。
 
 > **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**。