Merge pull request #1 from jackfrued/master

gengx

Day01-15/01.初识Python.md

@@ -1,4 +1,4 @@
-## Day01 - 初识Python
+## 初识Python
 
 ### Python简介
 
@@ -159,53 +159,51 @@ IDLE是安装Python环境时自带的集成开发工具，如下图所示。但
 IPython是一种基于Python的交互式解释器。相较于原生的Python Shell，IPython提供了更为强大的编辑和交互功能。可以通过Python的包管理工具pip安装IPython和Jupyter，具体的操作如下所示。
 
 ```Shell
-pip install ipython jupyter
+pip install ipython
 ```
 
 或者
 
 ```Shell
-python -m pip install ipython jupyter
+python -m pip install ipython
 ```
 
 安装成功后，可以通过下面的ipython命令启动IPython，如下图所示。
 
 ![](./res/python-ipython.png)
 
-当然我们也可以通过Jupyter运行名为notebook的项目在浏览器窗口中进行交互式操作。
+当然我们也可以通过安装Jupyter并运行名为notebook的程序在浏览器窗口中进行交互式代码编写操作。
 
 ```Shell
+pip install jupyter
 jupyter notebook
 ```
 
 ![](./res/python-jupyter-2.png)
 
-#### anaconda - 一站式的数据科学神器
-Anaconda指的是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。
-因为包含了大量的科学包，Anaconda 的下载文件比较大（约 531 MB），如果只需要某些包，或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）。
-对于学习数据科学的人来说，anaconda是绝对的神器，安装简便，而且anaconda支持安装相关软件【例如前文提到的ipython，jupyter notebook，甚至有R等其他数据科学软件 】
-[一个相当有价值的介绍](https://www.jianshu.com/p/169403f7e40c)
-现在唯一的问题在于清华镜像服务已经关闭，跨国下载会比较慢
-
 #### Sublime - 文本编辑神器
 
 ![](./res/python-sublime.png)
 
 - 首先可以通过[官方网站](https://www.sublimetext.com/)下载安装程序安装Sublime 3或Sublime 2。
 
-- 安装包管理工具。通过快捷键Ctrl+`或者在View菜单中选择Show Console打开控制台，输入下面的代码。
+- 安装包管理工具。
+  1. 通过快捷键Ctrl+`或者在View菜单中选择Show Console打开控制台，输入下面的代码。
 
   - Sublime 3
 
   ```Python
   import  urllib.request,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib.request.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read())
   ```
-
   - Sublime 2
 
   ```Python
   import  urllib2,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();os.makedirs(ipp)ifnotos.path.exists(ipp)elseNone;urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read());print('Please restart Sublime Text to finish installation')
   ```
+  2. 手动安装浏览器输入  https://sublime.wbond.net/Package%20Control.sublime-package 下载这个文件
+  下载好以后，打开sublime text，选择菜单Preferences->Browse Packages... 打开安装目录
+  此时会进入到一个叫做Packages的目录下，点击进入上一层目录Sublime Text3，在此目录下有一个文件夹叫做Installed Packages，把刚才下载的文件放到这里就可以了。然后重启sublime text3，观察Preferences菜单最下边是否有Package Settings 和Package Control两个选项，如果有，则代表安装成功了。
+
 
 - 安装插件。通过Preference菜单的Package Control或快捷键Ctrl+Shift+P打开命令面板，在面板中输入Install Package就可以找到安装插件的工具，然后再查找需要的插件。我们推荐大家安装以下几个插件：
 
@@ -217,7 +215,7 @@ Anaconda指的是一个开源的Python发行版本，其包含了conda、Python
 
 #### PyCharm - Python开发神器
 
-PyCharm的安装、配置和使用我们在后面会进行介绍。
+PyCharm的安装、配置和使用在[《玩转PyCharm》](../玩转PyCharm.md)进行了介绍，有兴趣的读者可以选择阅读。
 
 ![](./res/python-pycharm.png)
 

Day01-15/02.语言元素.md

@@ -1,4 +1,4 @@
-## Day02 - 语言元素
+## 语言元素
 
 #### 指令和程序
 
@@ -6,7 +6,7 @@
 
 ### 变量和类型
 
-在程序设计中，变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间，变量的值可以被读取和修改，这是所有计算和控制的基础。计算机能处理的数据有很多中类型，除了数值之外还可以处理文本、图形、音频、视频等各种各样的数据，那么不同的数据就需要定义不同的存储类型。Python中的数据类型很多，而且也允许我们自定义新的数据类型（这一点在后面会讲到），我们先介绍几种常用的数据类型。
+在程序设计中，变量是一种存储数据的载体。计算机中的变量是实际存在的数据或者说是存储器中存储数据的一块内存空间，变量的值可以被读取和修改，这是所有计算和控制的基础。计算机能处理的数据有很多种类型，除了数值之外还可以处理文本、图形、音频、视频等各种各样的数据，那么不同的数据就需要定义不同的存储类型。Python中的数据类型很多，而且也允许我们自定义新的数据类型（这一点在后面会讲到），我们先介绍几种常用的数据类型。
 
 - 整型：Python中可以处理任意大小的整数（Python 2.x中有int和long两种类型的整数，但这种区分对Python来说意义不大，因此在Python 3.x中整数只有int这一种了），而且支持二进制（如`0b100`，换算成十进制是4）、八进制（如`0o100`，换算成十进制是64）、十进制（`100`）和十六进制（`0x100`，换算成十进制是256）的表示法。
 - 浮点型：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如`123.456`）之外还支持科学计数法（如`1.23456e2`）。
@@ -99,11 +99,11 @@ print(type(e))
 
 在对变量类型进行转换时可以使用Python的内置函数（准确的说下面列出的并不是真正意义上的函数，而是后面我们要讲到的创建对象的构造方法）。
 
-- int()：将一个数值或字符串转换成整数，可以指定进制。
+- `int()`：将一个数值或字符串转换成整数，可以指定进制。
-- float()：将一个字符串转换成浮点数。
+- `float()`：将一个字符串转换成浮点数。
-- str()：将指定的对象转换成字符串形式，可以指定编码。
+- `str()`：将指定的对象转换成字符串形式，可以指定编码。
-- chr()：将整数转换成该编码对应的字符串（一个字符）。
+- `chr()`：将整数转换成该编码对应的字符串（一个字符）。
-- ord()：将字符串（一个字符）转换成对应的编码（整数）。
+- `ord()`：将字符串（一个字符）转换成对应的编码（整数）。
 
 ### 运算符
 
@@ -118,15 +118,15 @@ Python支持多种运算符，下表大致按照优先级从高到低的顺序
 | `+` `-`                                                      | 加，减                         |
 | `>>` `<<`                                                    | 右移，左移                     |
 | `&`                                                          | 按位与                         |
-| `^` `|`                                                      | 按位异或，按位或               |
+| `^` `\|`                                                      | 按位异或，按位或               |
 | `<=` `<` `>` `>=`                                            | 小于等于，小于，大于，大于等于 |
 | `==` `!=`                                                    | 等于，不等于                   |
 | `is`  `is not`                                               | 身份运算符                     |
 | `in` `not in`                                                | 成员运算符                     |
 | `not` `or` `and`                                             | 逻辑运算符                     |
-| `=` `+=` `-=` `*=` `/=` `%=` `//=` `**=` `&=` `|=` `^=` `>>=` `<<=` | （复合）赋值运算符             |
+| `=` `+=` `-=` `*=` `/=` `%=` `//=` `**=` `&=` `\|=` `^=` `>>=` `<<=` | （复合）赋值运算符             |
 
->**说明：**在实际开发中，如果搞不清楚优先级可以使用括号来确保运算的执行顺序。
+>**说明：** 在实际开发中，如果搞不清楚优先级可以使用括号来确保运算的执行顺序。
 
 下面的例子演示了运算符的使用。
 

Day01-15/03.分支结构.md

@@ -1,4 +1,4 @@
-## Day03 - 分支结构
+## 分支结构
 
 ### 分支结构的应用场景
 
@@ -31,7 +31,7 @@ else:
 
 当然如果要构造出更多的分支，可以使用`if…elif…else…`结构，例如下面的分段函数求值。
 
-$$f(x)=\begin{cases} 3x-5&\text{(x>1)}\\x+2&\text{(-1}\leq\text{x}\leq\text{1)}\\5x+3&\text {(x<-1)}\end{cases}$$
+![$$f(x)=\begin{cases} 3x-5&\text{(x>1)}\\x+2&\text{(-1}\leq\text{x}\leq\text{1)}\\5x+3&\text {(x<-1)}\end{cases}$$](./res/formula_1.png)
 
 ```Python
 """
@@ -79,7 +79,7 @@ else:
 print('f(%.2f) = %.2f' % (x, y))
 ```
 
-> **说明：**大家可以自己感受一下这两种写法到底是哪一种更好。在之前我们提到的Python之禅中有这么一句话“Flat is better than nested.”，之所以提出这个观点是因为嵌套结构的嵌套层次多了之后会严重的影响代码的可读性，如果可以使用扁平化的结构就不要去用嵌套，因此之前的写法是更好的做法。
+> **说明：** 大家可以自己感受一下这两种写法到底是哪一种更好。在之前我们提到的Python之禅中有这么一句话“Flat is better than nested.”，之所以提出这个观点是因为嵌套结构的嵌套层次多了之后会严重的影响代码的可读性，如果可以使用扁平化的结构就不要去用嵌套，因此之前的写法是更好的做法。
 
 ### 练习
 
@@ -130,7 +130,7 @@ else:
     result = '讲冷笑话'
 print(result)
 ```
-> **说明：**上面的代码中使用了random模块的randint函数生成指定范围的随机数来模拟掷骰子。
+> **说明：** 上面的代码中使用了random模块的randint函数生成指定范围的随机数来模拟掷骰子。
 
 #### 练习3：百分制成绩转等级制
 
@@ -184,7 +184,7 @@ if a + b > c and a + c > b and b + c > a:
 else:
     print('不能构成三角形')
 ```
-> **说明：**上面的代码中使用了`math`模块的`sqrt`函数来计算平方根。用边长计算三角形面积的公式叫做[海伦公式](https://zh.wikipedia.org/zh-hans/海伦公式)。
+> **说明：** 上面的代码中使用了`math`模块的`sqrt`函数来计算平方根。用边长计算三角形面积的公式叫做[海伦公式](https://zh.wikipedia.org/zh-hans/海伦公式)。
 
 #### 练习5：个人所得税计算器。
 
@@ -227,4 +227,4 @@ tax = abs(diff * rate - deduction)
 print('个人所得税: ￥%.2f元' % tax)
 print('实际到手收入: ￥%.2f元' % (diff + 3500 - tax))
 ```
->**说明：**上面的代码中使用了Python内置的`abs()`函数取绝对值来处理`-0`的问题。
+>**说明：** 上面的代码中使用了Python内置的`abs()`函数取绝对值来处理`-0`的问题。

Day01-15/04.循环结构.md

@@ -1,4 +1,4 @@
-## Day04 - 循环结构
+## 循环结构
 
 ### 循环结构的应用场景
 
@@ -6,7 +6,7 @@
 
 ### for-in循环
 
-如果明确的知道循环执行的次数或者是要对一个容器进行迭代（后面会讲到），那么我们推荐使用`for-in`循环，例如下面代码中计算$\sum_{n=1}^{100}n$。
+如果明确的知道循环执行的次数或者是要对一个容器进行迭代（后面会讲到），那么我们推荐使用`for-in`循环，例如下面代码中计算![$\sum_{n=1}^{100}n$](./res/formula_2.png)。
 
 ```Python
 """
@@ -94,7 +94,7 @@ if counter > 7:
     print('你的智商余额明显不足')
 ```
 
-> **说明：**上面的代码中使用了`break`关键字来提前终止循环，需要注意的是`break`只能终止它所在的那个循环，这一点在使用嵌套的循环结构（下面会讲到）需要引起注意。除了`break`之外，还有另一个关键字是`continue`，它可以用来放弃本次循环后续的代码直接让循环进入下一轮。
+> **说明：** 上面的代码中使用了`break`关键字来提前终止循环，需要注意的是`break`只能终止它所在的那个循环，这一点在使用嵌套的循环结构（下面会讲到）需要引起注意。除了`break`之外，还有另一个关键字是`continue`，它可以用来放弃本次循环后续的代码直接让循环进入下一轮。
 
 和分支结构一样，循环结构也是可以嵌套的，也就是说在循环中还可以构造循环结构。下面的例子演示了如何通过嵌套的循环来输出一个九九乘法表。
 

Day01-15/05.构造程序逻辑.md

@@ -1,4 +1,4 @@
-## 练习
+## 构造程序逻辑
 
 ### 练习清单
 

Day01-15/06.函数和模块的使用.md

@@ -2,11 +2,11 @@
 
 在讲解本章节的内容之前，我们先来研究一道数学题，请说出下面的方程有多少组正整数解。
 
-$$x_1 + x_2 + x_3 + x_4 = 8$$
+![$$x_1 + x_2 + x_3 + x_4 = 8$$](./res/formula_3.png)
 
 事实上，上面的问题等同于将8个苹果分成四组每组至少一个苹果有多少种方案。想到这一点问题的答案就呼之欲出了。
 
-$$C_M^N =\frac{M!}{N!(M-N)!}, \text{(M=7, N=3)} $$
+![$$C_M^N =\frac{M!}{N!(M-N)!}, \text{(M=7, N=3)} $$](./res/formula_4.png)
 
 可以用Python的程序来计算出这个值，代码如下所示。
 
@@ -59,7 +59,7 @@ n = int(input('n = '))
 print(factorial(m) // factorial(n) // factorial(m - n))
 ```
 
-> **说明：**Python的math模块中其实已经有一个factorial函数了，事实上要计算阶乘可以直接使用这个现成的函数而不用自己定义。下面例子中的某些函数其实Python中也是内置了，我们这里是为了讲解函数的定义和使用才把它们又实现了一遍，实际开发中不建议做这种低级的重复性的工作。
+> **说明：** Python的math模块中其实已经有一个factorial函数了，事实上要计算阶乘可以直接使用这个现成的函数而不用自己定义。下面例子中的某些函数其实Python中也是内置了，我们这里是为了讲解函数的定义和使用才把它们又实现了一遍，实际开发中不建议做这种低级的重复性的工作。
 
 
 ### 函数的参数
@@ -337,7 +337,7 @@ if __name__ == '__main__':
 
 在实际开发中，我们应该尽量减少对全局变量的使用，因为全局变量的作用域和影响过于广泛，可能会发生意料之外的修改和使用，除此之外全局变量比局部变量拥有更长的生命周期，可能导致对象占用的内存长时间无法被[垃圾回收](https://zh.wikipedia.org/wiki/%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6_(%E8%A8%88%E7%AE%97%E6%A9%9F%E7%A7%91%E5%AD%B8))。事实上，减少对全局变量的使用，也是降低代码之间耦合度的一个重要举措，同时也是对[迪米特法则](https://zh.wikipedia.org/zh-hans/%E5%BE%97%E5%A2%A8%E5%BF%92%E8%80%B3%E5%AE%9A%E5%BE%8B)的践行。减少全局变量的使用就意味着我们应该尽量让变量的作用域在函数的内部，但是如果我们希望将一个局部变量的生命周期延长，使其在函数调用结束后依然可以访问，这时候就需要使用[闭包](https://zh.wikipedia.org/wiki/%E9%97%AD%E5%8C%85_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6))，这个我们在后续的内容中进行讲解。
 
-> **说明**：很多人经常会将“闭包”一词和[“匿名函数”](https://zh.wikipedia.org/wiki/%E5%8C%BF%E5%90%8D%E5%87%BD%E6%95%B0)混为一谈，但实际上它们是不同的概念，如果想提前了解这个概念，推荐看看[维基百科](https://zh.wikipedia.org/wiki/)或者[知乎](https://www.zhihu.com/)上对这个概念的讨论。
+> **说明：** 很多人经常会将“闭包”一词和[“匿名函数”](https://zh.wikipedia.org/wiki/%E5%8C%BF%E5%90%8D%E5%87%BD%E6%95%B0)混为一谈，但实际上它们是不同的概念，如果想提前了解这个概念，推荐看看[维基百科](https://zh.wikipedia.org/wiki/)或者[知乎](https://www.zhihu.com/)上对这个概念的讨论。
 
 说了那么多，其实结论很简单，从现在开始我们可以将Python代码按照下面的格式进行书写，这一点点的改进其实就是在我们理解了函数和作用域的基础上跨出的巨大的一步。
 

Day01-15/07.字符串和常用数据结构.md

@@ -2,7 +2,7 @@
 
 ### 使用字符串
 
-第二次世界大战促使了现代电子计算机的诞生，当初的想法很简单，就是用计算机来计算导弹的弹道，因此在计算机刚刚诞生的那个年代，计算机处理的信息主要是数值，而世界上的第一台电子计算机ENIAC每秒钟能够完成约5000次浮点运算。随着时间的推移，虽然对数值运算仍然是计算机日常工作中最为重要的事情之一，但是今天的计算机处理得更多的数据都是以文本信息的方式存在的，而Python表示文本信息的方式我们在很早以前就说过了，那就是字符串类型。所谓**字符串**，就是由零个或多个字符组成的有限序列，一般记为[$${\displaystyle s=a_{1}a_{2}\dots a_{n}(0\leq n \leq \infty)}$$](https://wikimedia.org/api/rest_v1/media/math/render/svg/e29bf631b090323edd6889f810e6cff29538b161)。
+第二次世界大战促使了现代电子计算机的诞生，当初的想法很简单，就是用计算机来计算导弹的弹道，因此在计算机刚刚诞生的那个年代，计算机处理的信息主要是数值，而世界上的第一台电子计算机ENIAC每秒钟能够完成约5000次浮点运算。随着时间的推移，虽然对数值运算仍然是计算机日常工作中最为重要的事情之一，但是今天的计算机处理得更多的数据都是以文本信息的方式存在的，而Python表示文本信息的方式我们在很早以前就说过了，那就是字符串类型。所谓**字符串**，就是由零个或多个字符组成的有限序列，一般记为![$${\displaystyle s=a_{1}a_{2}\dots a_{n}(0\leq n \leq \infty)}$$](./res/formula_5.png)。
 
 我们可以通过下面的代码来了解字符串的使用。
 
@@ -183,11 +183,11 @@ if __name__ == '__main__':
 
 除了上面提到的生成器语法，Python中还有另外一种定义生成器的方式，就是通过`yield`关键字将一个普通函数改造成生成器函数。下面的代码演示了如何实现一个生成[斐波拉切数列](https://zh.wikipedia.org/wiki/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97)的生成器。所谓斐波拉切数列可以通过下面[递归](https://zh.wikipedia.org/wiki/%E9%80%92%E5%BD%92)的方法来进行定义：
 
-$${\displaystyle F_{0}=0}$$
+![$${\displaystyle F_{0}=0}$$](./res/formula_6.png)
 
-$${\displaystyle F_{1}=1}$$
+![$${\displaystyle F_{1}=1}$$](./res/formula_7.png)
 
-$${\displaystyle F_{n}=F_{n-1}+F_{n-2}}({n}\geq{2})$$
+![$${\displaystyle F_{n}=F_{n-1}+F_{n-2}}({n}\geq{2})$$](./res/formula_8.png)
 
 ![](./res/fibonacci-blocks.png)
 
@@ -307,7 +307,7 @@ if __name__ == '__main__':
     main()
 ```
 
-> **说明**：Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符（后面的章节中会讲到），上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如`&`运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。
+> **说明：** Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符（后面的章节中会讲到），上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如`&`运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。
 
 ### 使用字典
 
@@ -530,7 +530,7 @@ if __name__ == '__main__':
     main()
 ```
 
-> **说明**：上面使用random模块的sample函数来实现从列表中选择不重复的n个元素。
+> **说明：** 上面使用random模块的sample函数来实现从列表中选择不重复的n个元素。
 
 #### 综合案例2：[约瑟夫环问题](https://zh.wikipedia.org/wiki/%E7%BA%A6%E7%91%9F%E5%A4%AB%E6%96%AF%E9%97%AE%E9%A2%98)
 
@@ -609,4 +609,4 @@ if __name__ == '__main__':
     main()
 ```
 
->**说明**：最后这个案例来自[《Python编程快速上手:让繁琐工作自动化》](https://item.jd.com/11943853.html)一书（这本书对有编程基础想迅速使用Python将日常工作自动化的人来说还是不错的选择），对代码做了一点点的调整。
+>**说明：** 最后这个案例来自[《Python编程快速上手:让繁琐工作自动化》](https://item.jd.com/11943853.html)一书（这本书对有编程基础想迅速使用Python将日常工作自动化的人来说还是不错的选择），对代码做了一点点的调整。

Day01-15/08.面向对象编程基础.md

@@ -8,13 +8,13 @@
 
 ![](./res/oop-zhihu.png)
 
-> **说明**：以上的内容来自于网络，不代表作者本人的观点和看法，与作者本人立场无关，相关责任不由作者承担。
+> **说明：** 以上的内容来自于网络，不代表作者本人的观点和看法，与作者本人立场无关，相关责任不由作者承担。
 
 之前我们说过“程序是指令的集合”，我们在程序中书写的语句在执行时会变成一条或多条指令然后由CPU去执行。当然为了简化程序的设计，我们引入了函数的概念，把相对独立且经常重复使用的代码放置到函数中，在需要使用这些功能的时候只要调用函数即可；如果一个函数的功能过于复杂和臃肿，我们又可以进一步将函数继续切分为子函数来降低系统的复杂性。但是说了这么多，不知道大家是否发现，所谓编程就是程序员按照计算机的工作方式控制计算机完成各种任务。但是，计算机的工作方式与正常人类的思维模式是不同的，如果编程就必须得抛弃人类正常的思维方式去迎合计算机，编程的乐趣就少了很多，“每个人都应该学习编程”这样的豪言壮语就只能说说而已。当然，这些还不是最重要的，最重要的是当我们需要开发一个复杂的系统时，代码的复杂性会让开发和维护工作都变得举步维艰，所以在上世纪60年代末期，“[软件危机](https://zh.wikipedia.org/wiki/%E8%BD%AF%E4%BB%B6%E5%8D%B1%E6%9C%BA)”、“[软件工程](https://zh.wikipedia.org/wiki/%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B)”等一系列的概念开始在行业中出现。
 
 当然，程序员圈子内的人都知道，现实中并没有解决上面所说的这些问题的“[银弹](https://zh.wikipedia.org/wiki/%E6%B2%A1%E6%9C%89%E9%93%B6%E5%BC%B9)”，真正让软件开发者看到希望的是上世纪70年代诞生的[Smalltalk](https://zh.wikipedia.org/wiki/Smalltalk)编程语言中引入的面向对象的编程思想（面向对象编程的雏形可以追溯到更早期的[Simula](https://zh.wikipedia.org/wiki/Simula)语言）。按照这种编程理念，程序中的数据和操作数据的函数是一个逻辑上的整体，我们称之为“对象”，而我们解决问题的方式就是创建出需要的对象并向对象发出各种各样的消息，多个对象的协同工作最终可以让我们构造出复杂的系统来解决现实中的问题。
 
-> **说明**：当然面向对象也不是解决软件开发中所有问题的最后的“银弹”，所以今天的高级程序设计语言几乎都提供了对多种编程范式的支持，Python也不例外。
+> **说明：** 当然面向对象也不是解决软件开发中所有问题的最后的“银弹”，所以今天的高级程序设计语言几乎都提供了对多种编程范式的支持，Python也不例外。
 
 ### 类和对象
 
@@ -39,15 +39,15 @@ class Student(object):
         print('%s正在学习%s.' % (self.name, course_name))
 
     # PEP 8要求标识符的名字用全小写多个单词用下划线连接
-    # 但是很多程序员和公司更倾向于使用驼峰命名法(驼峰标识)
+    # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)
-    def watch_av(self):
+    def watch_movie(self):
         if self.age < 18:
             print('%s只能观看《熊出没》.' % self.name)
         else:
-            print('%s正在观看岛国爱情动作片.' % self.name
+            print('%s正在观看岛国爱情大电影.' % self.name)
 ```
 
-> **说明**：写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。
+> **说明：** 写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。
 
 ### 创建和使用对象
 
@@ -60,10 +60,10 @@ def main():
     # 给对象发study消息
     stu1.study('Python程序设计')
     # 给对象发watch_av消息
-    stu1.watch_av()
+    stu1.watch_movie()
     stu2 = Student('王大锤', 15)
     stu2.study('思想品德')
-    stu2.watch_av()
+    stu2.watch_movie()
 
 
 if __name__ == '__main__':
@@ -237,4 +237,4 @@ if __name__ == '__main__':
     main()
 ```
 
-> **说明**：本章中的插图来自于Grady Booch等著作的[《面向对象分析与设计》](https://item.jd.com/20476561918.html)一书，该书是讲解面向对象编程的经典著作，有兴趣的读者可以购买和阅读这本书来了解更多的面向对象的相关知识。
+> **说明：** 本章中的插图来自于Grady Booch等著作的[《面向对象分析与设计》](https://item.jd.com/20476561918.html)一书，该书是讲解面向对象编程的经典著作，有兴趣的读者可以购买和阅读这本书来了解更多的面向对象的相关知识。

Day01-15/09.面向对象进阶.md

@@ -636,7 +636,7 @@ if __name__ == '__main__':
     main()
 ```
 
->**说明**：大家可以自己尝试在上面代码的基础上写一个简单的扑克游戏，例如21点(Black Jack)，游戏的规则可以自己在网上找一找。
+>**说明：** 大家可以自己尝试在上面代码的基础上写一个简单的扑克游戏，例如21点(Black Jack)，游戏的规则可以自己在网上找一找。
 
 #### 案例3：工资结算系统
 

Day01-15/10.图形用户界面和游戏开发.md

@@ -128,7 +128,7 @@ if __name__ == '__main__':
     main()
 ```
 
-####加载图像
+#### 加载图像
 
 如果需要直接加载图像到窗口上，可以使用pygame中image模块的函数来加载图像，再通过之前获得的窗口对象的`blit`方法渲染图像，代码如下所示。
 
@@ -164,7 +164,7 @@ if __name__ == '__main__':
     main()
 ```
 
-####实现动画效果 
+#### 实现动画效果 
 
 说到[动画](https://zh.wikipedia.org/wiki/%E5%8A%A8%E7%94%BB)这个词大家都不会陌生，事实上要实现动画效果，本身的原理也非常简单，就是将不连续的图片连续的播放，只要每秒钟达到了一定的帧数，那么就可以做出比较流畅的动画效果。如果要让上面代码中的小球动起来，可以将小球的位置用变量来表示，并在循环中修改小球的位置再刷新整个窗口即可。
 

Day01-15/11.文件和异常.md

@@ -103,7 +103,7 @@ if __name__ == '__main__':
     main()
 ```
 
-要将文本信息写入文件文件也非常简单，在使用`open`函数时指定好文件名并将文件模式设置为`'w'`即可。注意如果需要对文件内容进行追加式写入，应该将模式设置为`'a'`。如果要写入的文件不存在会自动创建文件而不是引发异常。下面的例子演示了如何将1-9999直接的素数分别写入三个文件中（1-99之间的素数保存在a.txt中，100-999之间的素数保存在b.txt中，1000-9999之间的素数保存在c.txt中）。
+要将文本信息写入文件文件也非常简单，在使用`open`函数时指定好文件名并将文件模式设置为`'w'`即可。注意如果需要对文件内容进行追加式写入，应该将模式设置为`'a'`。如果要写入的文件不存在会自动创建文件而不是引发异常。下面的例子演示了如何将1-9999之间的素数分别写入三个文件中（1-99之间的素数保存在a.txt中，100-999之间的素数保存在b.txt中，1000-9999之间的素数保存在c.txt中）。
 
 ```Python
 from math import sqrt
@@ -174,14 +174,14 @@ if __name__ == '__main__':
 
 ```JSON
 {
-    'name': '骆昊',
+    "name": "骆昊",
-    'age': 38,
+    "age": 38,
-    'qq': 957658,
+    "qq": 957658,
-    'friends': ['王大锤', '白元芳'],
+    "friends": ["王大锤", "白元芳"],
-    'cars': [
+    "cars": [
-        {'brand': 'BYD', 'max_speed': 180},
+        {"brand": "BYD", "max_speed": 180},
-        {'brand': 'Audi', 'max_speed': 280},
+        {"brand": "Audi", "max_speed": 280},
-        {'brand': 'Benz', 'max_speed': 320}
+        {"brand": "Benz", "max_speed": 320}
     ]
 }
 ```

Day01-15/12.字符串和正则表达式.md

@@ -32,7 +32,7 @@
 | \|                 | 分支                                      | foo\|bar         | 可以匹配foo或者bar                                 |
 | (?#)               | 注释                                      |                  |                                                    |
 | (exp)              | 匹配exp并捕获到自动命名的组中             |                  |                                                    |
-| (?<name>exp) | 匹配exp并捕获到名为name的组中             |                  |                                                    |
+| (? <name>exp) | 匹配exp并捕获到名为name的组中             |                  |                                                    |
 | (?:exp)            | 匹配exp但是不捕获匹配的文本               |                  |                                                    |
 | (?=exp)            | 匹配exp前面的位置                         | \\b\\w+(?=ing)     | 可以匹配I'm dancing中的danc                        |
 | (?<=exp)           | 匹配exp后面的位置                         | (?<=\\bdanc)\\w+\\b | 可以匹配I love dancing and reading中的第一个ing    |
@@ -44,7 +44,7 @@
 | {M,N}?             | 重复M到N次，但尽可能少重复 |                  |                                                    |
 | {M,}?              | 重复M次以上，但尽可能少重复 |                  |                                                    |
 
-> **说明：**如果需要匹配的字符是正则表达式中的特殊字符，那么可以使用\\进行转义处理，例如想匹配小数点可以写成\\.就可以了，因为直接写.会匹配任意字符；同理，想匹配圆括号必须写成\\(和\\)，否则圆括号被视为正则表达式中的分组。
+> **说明：** 如果需要匹配的字符是正则表达式中的特殊字符，那么可以使用\\进行转义处理，例如想匹配小数点可以写成\\.就可以了，因为直接写.会匹配任意字符；同理，想匹配圆括号必须写成\\(和\\)，否则圆括号被视为正则表达式中的分组。
 
 ### Python对正则表达式的支持
 
@@ -64,7 +64,7 @@ Python提供了re模块来支持正则表达式相关操作，下面是re模块
 | re.I / re.IGNORECASE                         | 忽略大小写匹配标记                                           |
 | re.M / re.MULTILINE                          | 多行匹配标记                                                 |
 
-> **说明：**上面提到的re模块中的这些函数，实际开发中也可以用正则表达式对象的方法替代对这些函数的使用，如果一个正则表达式需要重复的使用，那么先通过compile函数编译正则表达式并创建出正则表达式对象无疑是更为明智的选择。
+> **说明：** 上面提到的re模块中的这些函数，实际开发中也可以用正则表达式对象的方法替代对这些函数的使用，如果一个正则表达式需要重复的使用，那么先通过compile函数编译正则表达式并创建出正则表达式对象无疑是更为明智的选择。
 
 下面我们通过一系列的例子来告诉大家在Python中如何使用正则表达式。
 
@@ -98,7 +98,7 @@ if __name__ == '__main__':
     main()
 ```
 
-> **提示**：上面在书写正则表达式时使用了“原始字符串”的写法（在字符串前面加上了r），所谓“原始字符串”就是字符串中的每个字符都是它原始的意义，说得更直接一点就是字符串中没有所谓的转义字符啦。因为正则表达式中有很多元字符和需要进行转义的地方，如果不使用原始字符串就需要将反斜杠写作\\\\，例如表示数字的\\d得书写成\\\\d，这样不仅写起来不方便，阅读的时候也会很吃力。
+> **提示：** 上面在书写正则表达式时使用了“原始字符串”的写法（在字符串前面加上了r），所谓“原始字符串”就是字符串中的每个字符都是它原始的意义，说得更直接一点就是字符串中没有所谓的转义字符啦。因为正则表达式中有很多元字符和需要进行转义的地方，如果不使用原始字符串就需要将反斜杠写作\\\\，例如表示数字的\\d得书写成\\\\d，这样不仅写起来不方便，阅读的时候也会很吃力。
 
 #### 例子2：从一段文字中提取出国内手机号码。
 
@@ -136,7 +136,7 @@ if __name__ == '__main__':
     main()
 ```
 
-> **说明**：上面匹配国内手机号的正则表达式并不够好，因为像14开头的号码只有145或147，而上面的正则表达式并没有考虑这种情况，要匹配国内手机号，更好的正则表达式的写法是：`(?<=\D)(1[38]\d{9}|14[57]\d{8}|15[0-35-9]\d{8}|17[678]\d{8})(?=\D)`，国内最近好像有19和16开头的手机号了，但是这个暂时不在我们考虑之列。
+> **说明：** 上面匹配国内手机号的正则表达式并不够好，因为像14开头的号码只有145或147，而上面的正则表达式并没有考虑这种情况，要匹配国内手机号，更好的正则表达式的写法是：`(?<=\D)(1[38]\d{9}|14[57]\d{8}|15[0-35-9]\d{8}|17[678]\d{8})(?=\D)`，国内最近好像有19和16开头的手机号了，但是这个暂时不在我们考虑之列。
 
 #### 例子3：替换字符串中的不良内容
 
@@ -155,7 +155,7 @@ if __name__ == '__main__':
     main()
 ```
 
-> **说明**：re模块的正则表达式相关函数中都有一个flags参数，它代表了正则表达式的匹配标记，可以通过该标记来指定匹配时是否忽略大小写、是否进行多行匹配、是否显示调试信息等。如果需要为flags参数指定多个值，可以使用[按位或运算符](http://www.runoob.com/python/python-operators.html#ysf5)进行叠加，如`flags=re.I | re.M`。
+> **说明：** re模块的正则表达式相关函数中都有一个flags参数，它代表了正则表达式的匹配标记，可以通过该标记来指定匹配时是否忽略大小写、是否进行多行匹配、是否显示调试信息等。如果需要为flags参数指定多个值，可以使用[按位或运算符](http://www.runoob.com/python/python-operators.html#ysf5)进行叠加，如`flags=re.I | re.M`。
 
 #### 例子4：拆分长字符串
 

Day01-15/13.进程和线程.md

@@ -320,7 +320,7 @@ if __name__ == '__main__':
 
 除了计算密集型任务，其他的涉及到网络、存储介质I/O的任务都可以视为I/O密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待I/O操作完成（因为I/O的速度远远低于CPU和内存的速度）。对于I/O密集型任务，如果启动多任务，就可以减少I/O等待时间从而让CPU高效率的运转。有一大类的任务都属于I/O密集型任务，这其中包括了我们很快会涉及到的网络应用和Web应用。
 
-> **说明：**上面的内容和例子来自于[廖雪峰官方网站的《Python教程》](https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000)，因为对作者文中的某些观点持有不同的看法，对原文的文字描述做了适当的调整。
+> **说明：** 上面的内容和例子来自于[廖雪峰官方网站的《Python教程》](https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000)，因为对作者文中的某些观点持有不同的看法，对原文的文字描述做了适当的调整。
 
 ### 单线程+异步I/O
 

Day01-15/14.网络编程入门和网络应用开发.md

@@ -70,9 +70,9 @@ JSON的例子：
 
 ```JSON
 {
-    'from': 'Alice',
+    "from": "Alice",
-    'to': 'Bob',
+    "to": "Bob",
-    'content': 'Will you marry me?'
+    "content": "Will you marry me?"
 }
 ```
 
@@ -291,9 +291,129 @@ if __name__ == '__main__':
 
 在这个案例中，我们使用了JSON作为数据传输的格式（通过JSON格式对传输的数据进行了序列化和反序列化的操作），但是JSON并不能携带二进制数据，因此对图片的二进制数据进行了Base64编码的处理。Base64是一种用64个字符表示所有二进制数据的编码方式，通过将二进制数据每6位一组的方式重新组织，刚好可以使用0~9的数字、大小写字母以及“+”和“/”总共64个字符表示从`000000`到`111111`的64种状态。[维基百科](https://zh.wikipedia.org/wiki/Base64)上有关于Base64编码的详细讲解，不熟悉Base64的读者可以自行阅读。
 
-> **说明**：上面的代码主要为了讲解网络编程的相关内容因此并没有对异常状况进行处理，请读者自行添加异常处理代码来增强程序的健壮性。
+> **说明：** 上面的代码主要为了讲解网络编程的相关内容因此并没有对异常状况进行处理，请读者自行添加异常处理代码来增强程序的健壮性。
 
 #### UDP套接字
 
 传输层除了有可靠的传输协议TCP之外，还有一种非常轻便的传输协议叫做用户数据报协议，简称UDP。TCP和UDP都是提供端到端传输服务的协议，二者的差别就如同打电话和发短信的区别，后者不对传输的可靠性和可达性做出任何承诺从而避免了TCP中握手和重传的开销，所以在强调性能和而不是数据完整性的场景中（例如传输网络音视频数据），UDP可能是更好的选择。可能大家会注意到一个现象，就是在观看网络视频时，有时会出现卡顿，有时会出现花屏，这无非就是部分数据传丢或传错造成的。在Python中也可以使用UDP套接字来创建网络应用，对此我们不进行赘述，有兴趣的读者可以自行研究。
 
+### 网络应用开发
+
+#### 发送电子邮件
+
+在即时通信软件如此发达的今天，电子邮件仍然是互联网上使用最为广泛的应用之一，公司向应聘者发出录用通知、网站向用户发送一个激活账号的链接、银行向客户推广它们的理财产品等几乎都是通过电子邮件来完成的，而这些任务应该都是由程序自动完成的。
+
+就像我们可以用HTTP（超文本传输协议）来访问一个网站一样，发送邮件要使用SMTP（简单邮件传输协议），SMTP也是一个建立在TCP（传输控制协议）提供的可靠数据传输服务的基础上的应用级协议，它规定了邮件的发送者如何跟发送邮件的服务器进行通信的细节，而Python中的smtplib模块将这些操作简化成了几个简单的函数。
+
+下面的代码演示了如何在Python发送邮件。
+
+```Python
+from smtplib import SMTP
+from email.header import Header
+from email.mime.text import MIMEText
+
+
+def main():
+    # 请自行修改下面的邮件发送者和接收者
+    sender = 'abcdefg@126.com'
+    receivers = ['uvwxyz@qq.com', 'uvwxyz@126.com']
+    message = MIMEText('用Python发送邮件的示例代码.', 'plain', 'utf-8')
+    message['From'] = Header('王大锤', 'utf-8')
+    message['To'] = Header('骆昊', 'utf-8')
+    message['Subject'] = Header('示例代码实验邮件', 'utf-8')
+    smtper = SMTP('smtp.126.com')
+    # 请自行修改下面的登录口令
+    smtper.login(sender, 'secretpass')
+    smtper.sendmail(sender, receivers, message.as_string())
+    print('邮件发送完成!')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+如果要发送带有附件的邮件，那么可以按照下面的方式进行操作。
+
+```Python
+from smtplib import SMTP
+from email.header import Header
+from email.mime.text import MIMEText
+from email.mime.image import MIMEImage
+from email.mime.multipart import MIMEMultipart
+
+import urllib
+
+
+def main():
+    # 创建一个带附件的邮件消息对象
+    message = MIMEMultipart()
+    
+    # 创建文本内容
+    text_content = MIMEText('附件中有本月数据请查收', 'plain', 'utf-8')
+    message['Subject'] = Header('本月数据', 'utf-8')
+    # 将文本内容添加到邮件消息对象中
+    message.attach(text_content)
+
+    # 读取文件并将文件作为附件添加到邮件消息对象中
+    with open('/Users/Hao/Desktop/hello.txt', 'rb') as f:
+        txt = MIMEText(f.read(), 'base64', 'utf-8')
+        txt['Content-Type'] = 'text/plain'
+        txt['Content-Disposition'] = 'attachment; filename=hello.txt'
+        message.attach(txt)
+    # 读取文件并将文件作为附件添加到邮件消息对象中
+    with open('/Users/Hao/Desktop/汇总数据.xlsx', 'rb') as f:
+        xls = MIMEText(f.read(), 'base64', 'utf-8')
+        xls['Content-Type'] = 'application/vnd.ms-excel'
+        xls['Content-Disposition'] = 'attachment; filename=month-data.xlsx'
+        message.attach(xls)
+    
+    # 创建SMTP对象
+    smtper = SMTP('smtp.126.com')
+    # 开启安全连接
+    # smtper.starttls()
+    sender = 'abcdefg@126.com'
+    receivers = ['uvwxyz@qq.com']
+    # 登录到SMTP服务器
+    # 请注意此处不是使用密码而是邮件客户端授权码进行登录
+    # 对此有疑问的读者可以联系自己使用的邮件服务器客服
+    smtper.login(sender, 'secretpass')
+    # 发送邮件
+    smtper.sendmail(sender, receivers, message.as_string())
+    # 与邮件服务器断开连接
+    smtper.quit()
+    print('发送完成!')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+#### 发送短信
+
+发送短信也是项目中常见的功能，网站的注册码、验证码、营销信息基本上都是通过短信来发送给用户的。在下面的代码中我们使用了[互亿无线](http://www.ihuyi.com/)短信平台（该平台为注册用户提供了50条免费短信以及常用开发语言发送短信的demo，可以登录该网站并在用户自服务页面中对短信进行配置）提供的API接口实现了发送短信的服务，当然国内的短信平台很多，读者可以根据自己的需要进行选择（通常会考虑费用预算、短信达到率、使用的难易程度等指标），如果需要在商业项目中使用短信服务建议购买短信平台提供的套餐服务。
+
+```Python
+import urllib.parse
+import http.client
+import json
+
+
+def main():
+    host  = "106.ihuyi.com"
+    sms_send_uri = "/webservice/sms.php?method=Submit"
+    # 下面的参数需要填入自己注册的账号和对应的密码
+    params = urllib.parse.urlencode({'account': '你自己的账号', 'password' : '你自己的密码', 'content': '您的验证码是：147258。请不要把验证码泄露给其他人。', 'mobile': '接收者的手机号', 'format':'json' })
+    print(params)
+    headers = {'Content-type': 'application/x-www-form-urlencoded', 'Accept': 'text/plain'}
+    conn = http.client.HTTPConnection(host, port=80, timeout=30)
+    conn.request('POST', sms_send_uri, params, headers)
+    response = conn.getresponse()
+    response_str = response.read()
+    jsonstr = response_str.decode('utf-8')
+    print(json.loads(jsonstr))
+    conn.close()
+
+
+if __name__ == '__main__':
+    main()
+```

Day01-15/15.图像和办公文档处理.md

@@ -76,7 +76,7 @@ Pillow中最为重要的是Image类，读取和处理图像都要通过这个类
 
    ```Python
    >>> image = Image.open('./res/guido.png')
-   >>> image.rotata(180).show()
+   >>> image.rotate(180).show()
    >>> image.transpose(Image.FLIP_LEFT_RIGHT).show()
    ```
 

Day01-15/Day14-B/网络应用开发.md

@@ -1,121 +0,0 @@
-## 网络应用开发
-
-### 发送电子邮件
-
-在即时通信软件如此发达的今天，电子邮件仍然是互联网上使用最为广泛的应用之一，公司向应聘者发出录用通知、网站向用户发送一个激活账号的链接、银行向客户推广它们的理财产品等几乎都是通过电子邮件来完成的，而这些任务应该都是由程序自动完成的。
-
-就像我们可以用HTTP（超文本传输协议）来访问一个网站一样，发送邮件要使用SMTP（简单邮件传输协议），SMTP也是一个建立在TCP（传输控制协议）提供的可靠数据传输服务的基础上的应用级协议，它规定了邮件的发送者如何跟发送邮件的服务器进行通信的细节，而Python中的smtplib模块将这些操作简化成了几个简单的函数。
-
-下面的代码演示了如何在Python发送邮件。
-
-```Python
-from smtplib import SMTP
-from email.header import Header
-from email.mime.text import MIMEText
-
-
-def main():
-    # 请自行修改下面的邮件发送者和接收者
-    sender = 'abcdefg@126.com'
-    receivers = ['uvwxyz@qq.com', 'uvwxyz@126.com']
-    message = MIMEText('用Python发送邮件的示例代码.', 'plain', 'utf-8')
-    message['From'] = Header('王大锤', 'utf-8')
-    message['To'] = Header('骆昊', 'utf-8')
-    message['Subject'] = Header('示例代码实验邮件', 'utf-8')
-    smtper = SMTP('smtp.126.com')
-    # 请自行修改下面的登录口令
-    smtper.login(sender, 'secretpass')
-    smtper.sendmail(sender, receivers, message.as_string())
-    print('邮件发送完成!')
-
-
-if __name__ == '__main__':
-    main()
-```
-
-如果要发送带有附件的邮件，那么可以按照下面的方式进行操作。
-
-```Python
-from smtplib import SMTP
-from email.header import Header
-from email.mime.text import MIMEText
-from email.mime.image import MIMEImage
-from email.mime.multipart import MIMEMultipart
-
-import urllib
-
-
-def main():
-    # 创建一个带附件的邮件消息对象
-    message = MIMEMultipart()
-    
-    # 创建文本内容
-    text_content = MIMEText('附件中有本月数据请查收', 'plain', 'utf-8')
-    message['Subject'] = Header('本月数据', 'utf-8')
-    # 将文本内容添加到邮件消息对象中
-    message.attach(text_content)
-
-    # 读取文件并将文件作为附件添加到邮件消息对象中
-    with open('/Users/Hao/Desktop/hello.txt', 'rb') as f:
-        txt = MIMEText(f.read(), 'base64', 'utf-8')
-        txt['Content-Type'] = 'text/plain'
-        txt['Content-Disposition'] = 'attachment; filename=hello.txt'
-        message.attach(txt)
-    # 读取文件并将文件作为附件添加到邮件消息对象中
-    with open('/Users/Hao/Desktop/汇总数据.xlsx', 'rb') as f:
-        xls = MIMEText(f.read(), 'base64', 'utf-8')
-        xls['Content-Type'] = 'application/vnd.ms-excel'
-        xls['Content-Disposition'] = 'attachment; filename=month-data.xlsx'
-        message.attach(xls)
-    
-    # 创建SMTP对象
-    smtper = SMTP('smtp.126.com')
-    # 开启安全连接
-    # smtper.starttls()
-    sender = 'abcdefg@126.com'
-    receivers = ['uvwxyz@qq.com']
-    # 登录到SMTP服务器
-    # 请注意此处不是使用密码而是邮件客户端授权码进行登录
-    # 对此有疑问的读者可以联系自己使用的邮件服务器客服
-    smtper.login(sender, 'secretpass')
-    # 发送邮件
-    smtper.sendmail(sender, receivers, message.as_string())
-    # 与邮件服务器断开连接
-    smtper.quit()
-    print('发送完成!')
-
-
-if __name__ == '__main__':
-    main()
-```
-
-### 发送短信
-
-发送短信也是项目中常见的功能，网站的注册码、验证码、营销信息基本上都是通过短信来发送给用户的。在下面的代码中我们使用了[互亿无线](http://www.ihuyi.com/)短信平台（该平台为注册用户提供了50条免费短信以及常用开发语言发送短信的demo，可以登录该网站并在用户自服务页面中对短信进行配置）提供的API接口实现了发送短信的服务，当然国内的短信平台很多，读者可以根据自己的需要进行选择（通常会考虑费用预算、短信达到率、使用的难易程度等指标），如果需要在商业项目中使用短信服务建议购买短信平台提供的套餐服务。
-
-```Python
-import urllib.parse
-import http.client
-import json
-
-
-def main():
-    host  = "106.ihuyi.com"
-    sms_send_uri = "/webservice/sms.php?method=Submit"
-    # 下面的参数需要填入自己注册的账号和对应的密码
-    params = urllib.parse.urlencode({'account': '你自己的账号', 'password' : '你自己的密码', 'content': '您的验证码是：147258。请不要把验证码泄露给其他人。', 'mobile': '接收者的手机号', 'format':'json' })
-    print(params)
-    headers = {'Content-type': 'application/x-www-form-urlencoded', 'Accept': 'text/plain'}
-    conn = http.client.HTTPConnection(host, port=80, timeout=30)
-    conn.request('POST', sms_send_uri, params, headers)
-    response = conn.getresponse()
-    response_str = response.read()
-    jsonstr = response_str.decode('utf-8')
-    print(json.loads(jsonstr))
-    conn.close()
-
-
-if __name__ == '__main__':
-    main()
-```
-

Day01-15/code/Day04/for1.py

@@ -8,6 +8,5 @@ Date: 2018-03-01
 
 sum = 0
 for x in range(1, 101):
-    if x % 2 == 0:
+    sum += x
-        sum += x
 print(sum)

Day01-15/code/Day10/renju.py

@@ -1,78 +1,78 @@
-import pygame
+import pygame
-
+
-EMPTY = 0
+EMPTY = 0
-BLACK = 1
+BLACK = 1
-WHITE = 2
+WHITE = 2
-
+
-black_color = [0, 0, 0]
+black_color = [0, 0, 0]
-white_color = [255, 255, 255]
+white_color = [255, 255, 255]
-
+
-
+
-class RenjuBoard(object):
+class RenjuBoard(object):
-
+
-    def __init__(self):
+    def __init__(self):
-        self._board = [[]] * 15
+        self._board = [[]] * 15
-        self.reset()
+        self.reset()
-
+
-    def reset(self):
+    def reset(self):
-        for row in range(len(self._board)):
+        for row in range(len(self._board)):
-            self._board[row] = [EMPTY] * 15
+            self._board[row] = [EMPTY] * 15
-
+
-    def move(self, row, col, is_black):
+    def move(self, row, col, is_black):
-        if self._board[row][col] == EMPTY:
+        if self._board[row][col] == EMPTY:
-            self._board[row][col] = BLACK if is_black else WHITE
+            self._board[row][col] = BLACK if is_black else WHITE
-            return True
+            return True
-        return False
+        return False
-
+
-    def draw(self, screen):
+    def draw(self, screen):
-        for index in range(1, 16):
+        for index in range(1, 16):
-            pygame.draw.line(screen, black_color,
+            pygame.draw.line(screen, black_color,
-                             [40, 40 * index], [600, 40 * index], 1)
+                             [40, 40 * index], [600, 40 * index], 1)
-            pygame.draw.line(screen, black_color,
+            pygame.draw.line(screen, black_color,
-                             [40 * index, 40], [40 * index, 600], 1)
+                             [40 * index, 40], [40 * index, 600], 1)
-        pygame.draw.rect(screen, black_color, [36, 36, 568, 568], 4)
+        pygame.draw.rect(screen, black_color, [36, 36, 568, 568], 4)
-        pygame.draw.circle(screen, black_color, [320, 320], 5, 0)
+        pygame.draw.circle(screen, black_color, [320, 320], 5, 0)
-        pygame.draw.circle(screen, black_color, [160, 160], 5, 0)
+        pygame.draw.circle(screen, black_color, [160, 160], 5, 0)
-        pygame.draw.circle(screen, black_color, [480, 480], 5, 0)
+        pygame.draw.circle(screen, black_color, [480, 480], 5, 0)
-        pygame.draw.circle(screen, black_color, [480, 160], 5, 0)
+        pygame.draw.circle(screen, black_color, [480, 160], 5, 0)
-        pygame.draw.circle(screen, black_color, [160, 480], 5, 0)
+        pygame.draw.circle(screen, black_color, [160, 480], 5, 0)
-        for row in range(len(self._board)):
+        for row in range(len(self._board)):
-            for col in range(len(self._board[row])):
+            for col in range(len(self._board[row])):
-                if self._board[row][col] != EMPTY:
+                if self._board[row][col] != EMPTY:
-                    ccolor = black_color \
+                    ccolor = black_color \
-                        if self._board[row][col] == BLACK else white_color
+                        if self._board[row][col] == BLACK else white_color
-                    pos = [40 * (col + 1), 40 * (row + 1)]
+                    pos = [40 * (col + 1), 40 * (row + 1)]
-                    pygame.draw.circle(screen, ccolor, pos, 20, 0)
+                    pygame.draw.circle(screen, ccolor, pos, 20, 0)
-
+
-
+
-def main():
+def main():
-    board = RenjuBoard()
+    board = RenjuBoard()
-    is_black = True
+    is_black = True
-    pygame.init()
+    pygame.init()
-    pygame.display.set_caption('五子棋')
+    pygame.display.set_caption('五子棋')
-    screen = pygame.display.set_mode([640, 640])
+    screen = pygame.display.set_mode([640, 640])
-    screen.fill([255, 255, 0])
+    screen.fill([255, 255, 0])
-    board.draw(screen)
+    board.draw(screen)
-    pygame.display.flip()
+    pygame.display.flip()
-    running = True
+    running = True
-    while running:
+    while running:
-        for event in pygame.event.get():
+        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
+            if event.type == pygame.QUIT:
-                running = False
+                running = False
-            elif event.type == pygame.KEYUP:
+            elif event.type == pygame.KEYUP:
-                pass
+                pass
-            elif event.type == pygame.MOUSEBUTTONDOWN\
+            elif event.type == pygame.MOUSEBUTTONDOWN\
-                    and event.button == 1:
+                    and event.button == 1:
-                x, y = event.pos
+                x, y = event.pos
-                row = round((y - 40) / 40)
+                row = round((y - 40) / 40)
-                col = round((x - 40) / 40)
+                col = round((x - 40) / 40)
-                if board.move(row, col, is_black):
+                if board.move(row, col, is_black):
-                    is_black = not is_black
+                    is_black = not is_black
-                    screen.fill([255, 255, 0])
+                    screen.fill([255, 255, 0])
-                    board.draw(screen)
+                    board.draw(screen)
-                    pygame.display.flip()
+                    pygame.display.flip()
-    pygame.quit()
+    pygame.quit()
-
+
-
+
-if __name__ == '__main__':
+if __name__ == '__main__':
-    main()
+    main()

Day01-15/code/Day10/snake.py

@@ -1,334 +1,334 @@
-from abc import ABCMeta, abstractmethod
+from abc import ABCMeta, abstractmethod
-from enum import Enum, unique
+from enum import Enum, unique
-from random import randrange
+from random import randrange
-from threading import Thread
+from threading import Thread
-
+
-import pygame
+import pygame
-
+
-
+
-class Color(object):
+class Color(object):
-    """颜色"""
+    """颜色"""
-
+
-    GRAY = (242, 242, 242)
+    GRAY = (242, 242, 242)
-    BLACK = (0, 0, 0)
+    BLACK = (0, 0, 0)
-    GREEN = (0, 255, 0)
+    GREEN = (0, 255, 0)
-    PINK = (255, 20, 147)
+    PINK = (255, 20, 147)
-
+
-
+
-@unique
+@unique
-class Direction(Enum):
+class Direction(Enum):
-    """方向"""
+    """方向"""
-
+
-    UP = 0
+    UP = 0
-    RIGHT = 1
+    RIGHT = 1
-    DOWN = 2
+    DOWN = 2
-    LEFT = 3
+    LEFT = 3
-
+
-
+
-class GameObject(object, metaclass=ABCMeta):
+class GameObject(object, metaclass=ABCMeta):
-    """游戏中的对象"""
+    """游戏中的对象"""
-
+
-    def __init__(self, x=0, y=0, color=Color.BLACK):
+    def __init__(self, x=0, y=0, color=Color.BLACK):
-        """
+        """
-        初始化方法
+        初始化方法
-
+
-        :param x: 横坐标
+        :param x: 横坐标
-        :param y: 纵坐标
+        :param y: 纵坐标
-        :param color: 颜色
+        :param color: 颜色
-        """
+        """
-        self._x = x
+        self._x = x
-        self._y = y
+        self._y = y
-        self._color = color
+        self._color = color
-
+
-    @property
+    @property
-    def x(self):
+    def x(self):
-        return self._x
+        return self._x
-
+
-    @property
+    @property
-    def y(self):
+    def y(self):
-        return self._y
+        return self._y
-
+
-    @abstractmethod
+    @abstractmethod
-    def draw(self, screen):
+    def draw(self, screen):
-        """
+        """
-        绘制
+        绘制
-
+
-        :param screen: 屏幕
+        :param screen: 屏幕
-        """
+        """
-        pass
+        pass
-
+
-
+
-class Wall(GameObject):
+class Wall(GameObject):
-    """围墙"""
+    """围墙"""
-
+
-    def __init__(self, x, y, width, height, color=Color.BLACK):
+    def __init__(self, x, y, width, height, color=Color.BLACK):
-        """
+        """
-        初始化方法
+        初始化方法
-
+
-        :param x: 横坐标
+        :param x: 横坐标
-        :param y: 纵坐标
+        :param y: 纵坐标
-        :param width: 宽度
+        :param width: 宽度
-        :param height: 高度
+        :param height: 高度
-        :param color: 颜色
+        :param color: 颜色
-        """
+        """
-        super().__init__(x, y, color)
+        super().__init__(x, y, color)
-        self._width = width
+        self._width = width
-        self._height = height
+        self._height = height
-
+
-    @property
+    @property
-    def width(self):
+    def width(self):
-        return self._width
+        return self._width
-
+
-    @property
+    @property
-    def height(self):
+    def height(self):
-        return self._height
+        return self._height
-
+
-    def draw(self, screen):
+    def draw(self, screen):
-        pygame.draw.rect(screen, self._color,
+        pygame.draw.rect(screen, self._color,
-                         (self._x, self._y, self._width, self._height), 4)
+                         (self._x, self._y, self._width, self._height), 4)
-
+
-
+
-class Food(GameObject):
+class Food(GameObject):
-    """食物"""
+    """食物"""
-
+
-    def __init__(self, x, y, size, color=Color.PINK):
+    def __init__(self, x, y, size, color=Color.PINK):
-        """
+        """
-        初始化方法
+        初始化方法
-
+
-        :param x: 横坐标
+        :param x: 横坐标
-        :param y: 纵坐标
+        :param y: 纵坐标
-        :param size: 大小
+        :param size: 大小
-        :param color: 颜色
+        :param color: 颜色
-        """
+        """
-        super().__init__(x, y, color)
+        super().__init__(x, y, color)
-        self._size = size
+        self._size = size
-        self._hidden = False
+        self._hidden = False
-
+
-    def draw(self, screen):
+    def draw(self, screen):
-        if not self._hidden:
+        if not self._hidden:
-            pygame.draw.circle(screen, self._color,
+            pygame.draw.circle(screen, self._color,
-                               (self._x + self._size // 2, self._y + self._size // 2),
+                               (self._x + self._size // 2, self._y + self._size // 2),
-                               self._size // 2, 0)
+                               self._size // 2, 0)
-        self._hidden = not self._hidden
+        self._hidden = not self._hidden
-
+
-
+
-class SnakeNode(GameObject):
+class SnakeNode(GameObject):
-    """蛇身上的节点"""
+    """蛇身上的节点"""
-
+
-    def __init__(self, x, y, size, color=Color.GREEN):
+    def __init__(self, x, y, size, color=Color.GREEN):
-        """
+        """
-        初始化方法
+        初始化方法
-
+
-        :param x: 横坐标
+        :param x: 横坐标
-        :param y: 纵坐标
+        :param y: 纵坐标
-        :param size: 大小
+        :param size: 大小
-        :param color: 颜色
+        :param color: 颜色
-        """
+        """
-        super().__init__(x, y, color)
+        super().__init__(x, y, color)
-        self._size = size
+        self._size = size
-
+
-    @property
+    @property
-    def size(self):
+    def size(self):
-        return self._size
+        return self._size
-
+
-    def draw(self, screen):
+    def draw(self, screen):
-        pygame.draw.rect(screen, self._color,
+        pygame.draw.rect(screen, self._color,
-                         (self._x, self._y, self._size, self._size), 0)
+                         (self._x, self._y, self._size, self._size), 0)
-        pygame.draw.rect(screen, Color.BLACK,
+        pygame.draw.rect(screen, Color.BLACK,
-                         (self._x, self._y, self._size, self._size), 1)
+                         (self._x, self._y, self._size, self._size), 1)
-
+
-
+
-class Snake(GameObject):
+class Snake(GameObject):
-    """蛇"""
+    """蛇"""
-
+
-    def __init__(self, x, y, size=20, length=5):
+    def __init__(self, x, y, size=20, length=5):
-        """
+        """
-        初始化方法
+        初始化方法
-
+
-        :param x: 横坐标
+        :param x: 横坐标
-        :param y: 纵坐标
+        :param y: 纵坐标
-        :param size: 大小
+        :param size: 大小
-        :param length: 初始长度
+        :param length: 初始长度
-        """
+        """
-        super().__init__()
+        super().__init__()
-        self._dir = Direction.LEFT
+        self._dir = Direction.LEFT
-        self._nodes = []
+        self._nodes = []
-        self._alive = True
+        self._alive = True
-        self._new_dir = None
+        self._new_dir = None
-        for index in range(length):
+        for index in range(length):
-            node = SnakeNode(x + index * size, y, size)
+            node = SnakeNode(x + index * size, y, size)
-            self._nodes.append(node)
+            self._nodes.append(node)
-
+
-    @property
+    @property
-    def dir(self):
+    def dir(self):
-        return self._dir
+        return self._dir
-
+
-    @property
+    @property
-    def alive(self):
+    def alive(self):
-        return self._alive
+        return self._alive
-
+
-    @property
+    @property
-    def head(self):
+    def head(self):
-        return self._nodes[0]
+        return self._nodes[0]
-
+
-    def change_dir(self, new_dir):
+    def change_dir(self, new_dir):
-        """
+        """
-        改变方向
+        改变方向
-
+
-        :param new_dir: 新方向
+        :param new_dir: 新方向
-        """
+        """
-        if new_dir != self._dir and \
+        if new_dir != self._dir and \
-                (self._dir.value + new_dir.value) % 2 != 0:
+                (self._dir.value + new_dir.value) % 2 != 0:
-            self._new_dir = new_dir
+            self._new_dir = new_dir
-
+
-    def move(self):
+    def move(self):
-        """移动"""
+        """移动"""
-        if self._new_dir:
+        if self._new_dir:
-            self._dir, self._new_dir = self._new_dir, None
+            self._dir, self._new_dir = self._new_dir, None
-        snake_dir = self._dir
+        snake_dir = self._dir
-        x, y, size = self.head.x, self.head.y, self.head.size
+        x, y, size = self.head.x, self.head.y, self.head.size
-        if snake_dir == Direction.UP:
+        if snake_dir == Direction.UP:
-            y -= size
+            y -= size
-        elif snake_dir == Direction.RIGHT:
+        elif snake_dir == Direction.RIGHT:
-            x += size
+            x += size
-        elif snake_dir == Direction.DOWN:
+        elif snake_dir == Direction.DOWN:
-            y += size
+            y += size
-        else:
+        else:
-            x -= size
+            x -= size
-        new_head = SnakeNode(x, y, size)
+        new_head = SnakeNode(x, y, size)
-        self._nodes.insert(0, new_head)
+        self._nodes.insert(0, new_head)
-        self._nodes.pop()
+        self._nodes.pop()
-
+
-    def collide(self, wall):
+    def collide(self, wall):
-        """
+        """
-        撞墙
+        撞墙
-
+
-        :param wall: 围墙
+        :param wall: 围墙
-        """
+        """
-        head = self.head
+        head = self.head
-        if head.x < wall.x or head.x + head.size > wall.x + wall.width \
+        if head.x < wall.x or head.x + head.size > wall.x + wall.width \
-                or head.y < wall.y or head.y + head.size > wall.y + wall.height:
+                or head.y < wall.y or head.y + head.size > wall.y + wall.height:
-            self._alive = False
+            self._alive = False
-
+
-    def eat_food(self, food):
+    def eat_food(self, food):
-        """
+        """
-        吃食物
+        吃食物
-
+
-        :param food: 食物
+        :param food: 食物
-
+
-        :return: 吃到食物返回True否则返回False
+        :return: 吃到食物返回True否则返回False
-        """
+        """
-        if self.head.x == food.x and self.head.y == food.y:
+        if self.head.x == food.x and self.head.y == food.y:
-            tail = self._nodes[-1]
+            tail = self._nodes[-1]
-            self._nodes.append(tail)
+            self._nodes.append(tail)
-            return True
+            return True
-        return False
+        return False
-
+
-    def eat_self(self):
+    def eat_self(self):
-        """咬自己"""
+        """咬自己"""
-        for index in range(4, len(self._nodes)):
+        for index in range(4, len(self._nodes)):
-            node = self._nodes[index]
+            node = self._nodes[index]
-            if node.x == self.head.x and node.y == self.head.y:
+            if node.x == self.head.x and node.y == self.head.y:
-                self._alive = False
+                self._alive = False
-
+
-    def draw(self, screen):
+    def draw(self, screen):
-        for node in self._nodes:
+        for node in self._nodes:
-            node.draw(screen)
+            node.draw(screen)
-
+
-
+
-def main():
+def main():
-
+
-    def refresh():
+    def refresh():
-        """刷新游戏窗口"""
+        """刷新游戏窗口"""
-        screen.fill(Color.GRAY)
+        screen.fill(Color.GRAY)
-        wall.draw(screen)
+        wall.draw(screen)
-        food.draw(screen)
+        food.draw(screen)
-        snake.draw(screen)
+        snake.draw(screen)
-        pygame.display.flip()
+        pygame.display.flip()
-
+
-    def handle_key_event(key_event):
+    def handle_key_event(key_event):
-        """处理按键事件"""
+        """处理按键事件"""
-        key = key_event.key
+        key = key_event.key
-        if key == pygame.K_F2:
+        if key == pygame.K_F2:
-            reset_game()
+            reset_game()
-        elif key in (pygame.K_a, pygame.K_w, pygame.K_d, pygame.K_s):
+        elif key in (pygame.K_a, pygame.K_w, pygame.K_d, pygame.K_s):
-            if snake.alive:
+            if snake.alive:
-                if key == pygame.K_w:
+                if key == pygame.K_w:
-                    new_dir = Direction.UP
+                    new_dir = Direction.UP
-                elif key == pygame.K_d:
+                elif key == pygame.K_d:
-                    new_dir = Direction.RIGHT
+                    new_dir = Direction.RIGHT
-                elif key == pygame.K_s:
+                elif key == pygame.K_s:
-                    new_dir = Direction.DOWN
+                    new_dir = Direction.DOWN
-                else:
+                else:
-                    new_dir = Direction.LEFT
+                    new_dir = Direction.LEFT
-                snake.change_dir(new_dir)
+                snake.change_dir(new_dir)
-
+
-    def create_food():
+    def create_food():
-        """创建食物"""
+        """创建食物"""
-        unit_size = snake.head.size
+        unit_size = snake.head.size
-        max_row = wall.height // unit_size
+        max_row = wall.height // unit_size
-        max_col = wall.width // unit_size
+        max_col = wall.width // unit_size
-        row = randrange(0, max_row)
+        row = randrange(0, max_row)
-        col = randrange(0, max_col)
+        col = randrange(0, max_col)
-        return Food(wall.x + unit_size * col, wall.y + unit_size * row, unit_size)
+        return Food(wall.x + unit_size * col, wall.y + unit_size * row, unit_size)
-
+
-    def reset_game():
+    def reset_game():
-        """重置游戏"""
+        """重置游戏"""
-        nonlocal food, snake
+        nonlocal food, snake
-        food = create_food()
+        food = create_food()
-        snake = Snake(250, 290)
+        snake = Snake(250, 290)
-
+
-    def background_task():
+    def background_task():
-        nonlocal running, food
+        nonlocal running, food
-        while running:
+        while running:
-            if snake.alive:
+            if snake.alive:
-                refresh()
+                refresh()
-            clock.tick(10)
+            clock.tick(10)
-            if snake.alive:
+            if snake.alive:
-                snake.move()
+                snake.move()
-                snake.collide(wall)
+                snake.collide(wall)
-                if snake.eat_food(food):
+                if snake.eat_food(food):
-                    food = create_food()
+                    food = create_food()
-                snake.eat_self()
+                snake.eat_self()
-
+
-    """
+    """
-    class BackgroundTask(Thread):
+    class BackgroundTask(Thread):
-
+
-        def run(self):
+        def run(self):
-            nonlocal running, food
+            nonlocal running, food
-            while running:
+            while running:
-                if snake.alive:
+                if snake.alive:
-                    refresh()
+                    refresh()
-                clock.tick(10)
+                clock.tick(10)
-                if snake.alive:
+                if snake.alive:
-                    snake.move()
+                    snake.move()
-                    snake.collide(wall)
+                    snake.collide(wall)
-                    if snake.eat_food(food):
+                    if snake.eat_food(food):
-                        food = create_food()
+                        food = create_food()
-                    snake.eat_self()
+                    snake.eat_self()
-    """
+    """
-
+
-    wall = Wall(10, 10, 600, 600)
+    wall = Wall(10, 10, 600, 600)
-    snake = Snake(250, 290)
+    snake = Snake(250, 290)
-    food = create_food()
+    food = create_food()
-    pygame.init()
+    pygame.init()
-    screen = pygame.display.set_mode((620, 620))
+    screen = pygame.display.set_mode((620, 620))
-    pygame.display.set_caption('贪吃蛇')
+    pygame.display.set_caption('贪吃蛇')
-    # 创建控制游戏每秒帧数的时钟
+    # 创建控制游戏每秒帧数的时钟
-    clock = pygame.time.Clock()
+    clock = pygame.time.Clock()
-    running = True
+    running = True
-    # 启动后台线程负责刷新窗口和让蛇移动
+    # 启动后台线程负责刷新窗口和让蛇移动
-    # BackgroundTask().start()
+    # BackgroundTask().start()
-    Thread(target=background_task).start()
+    Thread(target=background_task).start()
-    # 处理事件的消息循环
+    # 处理事件的消息循环
-    while running:
+    while running:
-        for event in pygame.event.get():
+        for event in pygame.event.get():
-            if event.type == pygame.QUIT:
+            if event.type == pygame.QUIT:
-                running = False
+                running = False
-            elif event.type == pygame.KEYDOWN:
+            elif event.type == pygame.KEYDOWN:
-                handle_key_event(event)
+                handle_key_event(event)
-    pygame.quit()
+    pygame.quit()
-
+
-
+
-if __name__ == '__main__':
+if __name__ == '__main__':
-    main()
+    main()