两点水

Author: walter201230

README.md

@@ -3,21 +3,83 @@
 草根开发者学习Python（基于Python3.6）
 
 
-**通过本草根的博客整理而成，相应的博客地址**
+**通过本草根的博客整理而成，相应的博客地址,主要内容目录如下：**
 
-|博客文章|平台|
-|:----- |:------|
-|Python 代码规范 | [掘金](https://juejin.im/post/593ebd7eac502e006b520a8f)，[简书](http://www.jianshu.com/p/8b6c425b65a6)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73153945)，[个人博客](http://twowater.com.cn/2017/06/13/Python%E4%BB%A3%E7%A0%81%E8%A7%84%E8%8C%83/)|
-|草根学Python（一）第一个Python程序|[掘金](https://juejin.im/post/594633e5ac502e006b9e1331)，[简书](http://www.jianshu.com/p/0d757860c8cf)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73433637)，[个人博客](http://twowater.com.cn/2017/06/18/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%B8%80-%E7%AC%AC%E4%B8%80%E4%B8%AAPython%E7%A8%8B%E5%BA%8F/)|
-|草根学 Python（二）基本数据类型和变量|[掘金](https://juejin.im/post/5946b7f25c497d006bef5704)，[简书](http://www.jianshu.com/p/b5388a6c2e72)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73478060)，[个人博客](http://twowater.com.cn/2017/06/19/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%BA%8C-%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%8F%98%E9%87%8F/)|
-|草根学 Python（三）List 和 Tuple|[掘金](https://juejin.im/post/593fdb87128fe1006a02ce92)，[简书](http://www.jianshu.com/p/97c97d5a5a7c)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73524367)，[个人博客](http://twowater.com.cn/2017/06/21/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%B8%89-List-%E5%92%8C-Tuple/)|
-|草根学Python（四） Dict 和 Set|[掘金](https://juejin.im/post/5947bf84ac502e5490e4a6a1)，[简书](http://www.jianshu.com/p/90f5b897ce77)，[CSDN](http://blog.csdn.net/two_water/article/details/73719026)，[个人博客](http://twowater.com.cn/2017/06/25/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%9B%9B-Dict-%E5%92%8C-Set/)|
-|草根学Python（五） 条件语句和循环语句|[掘金](https://juejin.im/post/594c6c52f265da6c1f75f164)，[简书](http://www.jianshu.com/p/2b80009b1e8c)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73762517)，[个人博客](http://twowater.com.cn/2017/06/27/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%BA%94-%E6%9D%A1%E4%BB%B6%E8%AF%AD%E5%8F%A5%E5%92%8C%E5%BE%AA%E7%8E%AF%E8%AF%AD%E5%8F%A5/)|
-|草根学Python（六） 函数|[掘金](https://juejin.im/post/5946784461ff4b006cf1d8ec)，[简书](http://www.jianshu.com/p/d8f2a55edc75)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73865622)，[个人博客](http://twowater.com.cn/2017/06/29/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%85%AD-%E5%87%BD%E6%95%B0/)|
-|草根学Python（七） 迭代器和生成器|[掘金](https://juejin.im/post/59589fedf265da6c386ce4ac)，[简书](http://www.jianshu.com/p/74c0c1db1490)，[CSDN](http://blog.csdn.net/Two_Water/article/details/74164652)，[个人博客](http://twowater.com.cn/2017/07/02/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%B8%83-%E8%BF%AD%E4%BB%A3%E5%99%A8%E5%92%8C%E7%94%9F%E6%88%90%E5%99%A8/)|
-|草根学Python（八） 模块与包|[掘金](https://juejin.im/post/5962ddf95188252ec34009da)，[简书](http://www.jianshu.com/p/7f05f915d2ac)，[CSDN](http://blog.csdn.net/Two_Water/article/details/75042211)，[个人博客](http://twowater.com.cn/2017/07/12/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%85%AB-%E6%A8%A1%E5%9D%97%E4%B8%8E%E5%8C%85/)|
-|草根学Python（九） 面向对象|[掘金](https://juejin.im/post/596ca6656fb9a06b9b73c8b0)，[简书](http://www.jianshu.com/p/6ecaa414c702)，[CSDN](http://blog.csdn.net/two_water/article/details/76408890)，[个人博客](http://twowater.com.cn/2017/07/31/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%B9%9D-%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/)|
-|草根学Python（十）Python 的 Magic Method|[掘金](https://juejin.im/post/59828c2f6fb9a03c56319baa)，[简书](http://www.jianshu.com/p/345a80a02546)，[CSDN](http://blog.csdn.net/two_water/article/details/77351516)，[个人博客](http://twowater.com.cn/2017/08/18/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%8D%81-Python-%E7%9A%84-Magic-Method/)|
-|草根学Python（十一）枚举类|[掘金](https://juejin.im/post/599906a2f265da24722faec3)，[简书](http://www.jianshu.com/p/c4d2629e5015)，[CSDN](http://blog.csdn.net/Two_Water/article/details/77626179)，[个人博客](http://twowater.com.cn/2017/08/28/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%8D%81%E4%B8%80-%E6%9E%9A%E4%B8%BE%E7%B1%BB/)|
-|草根学Python（十二）元类|[掘金](https://juejin.im/post/59aff224f265da2476426796)，[简书](http://www.jianshu.com/p/9b10fcee7cda)，[CSDN](http://blog.csdn.net/two_water/article/details/77877621)，[个人博客](http://twowater.com.cn/2017/09/07/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%8D%81%E4%BA%8C-%E5%85%83%E7%B1%BB/)|
-|草根学Python（十三）线程和进程|[掘金](https://juejin.im/post/59cdbabb5188257a134abb6e)，[简书](http://www.jianshu.com/p/9106092d554f)，[CSDN](http://blog.csdn.net/Two_Water/article/details/78221478)，[个人博客](http://twowater.com.cn/2017/10/13/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%8D%81%E4%B8%89-%E7%BA%BF%E7%A8%8B%E5%92%8C%E8%BF%9B%E7%A8%8B/)| 
+* [Python代码规范](/codeSpecification/codeSpecification_Preface.md)
+  - [简明概述](/codeSpecification/codeSpecification_first.md)
+  - [注释](/codeSpecification/codeSpecification_second.md)
+  - [命名规范](/codeSpecification/codeSpecification_third.md)
+* [第一个Python程序](/python1/Preface.md)
+  - [Python 简介](/python1/Introduction.md)
+  - [Python 的安装](/python1/Installation.md)
+  - [第一个 Python 程序](/python1/The_first_procedure.md)
+  - [集成开发环境（IDE）: PyCharm](/python1/IDE.md)
+* [基本数据类型和变量](/python2/Preface.md)
+  - [Python 语法的简要说明](/python2/Grammar.md)
+  - [Python 的基本数据类型](/python2/Type_of_data.md)
+  - [基本数据类型转换](/python2/Type_conversion.md)
+  - [Python 中的变量](/python2/Variable.md)
+* [List 和 Tuple](/python3/Preface.md)
+  - [List（列表）](/python3/List.md)
+  - [tuple（元组）](/python3/tuple.md)
+* [ Dict 和 Set](/python4/Preface.md)
+  - [字典(Dictionary)](/python4/Dict.md)
+  - [set](/python4/Set.md)
+* [条件语句和循环语句](/python5/Preface.md)
+  - [条件语句](/python5/If.md)
+  - [循环语句](/python5/Cycle.md)
+  - [条件语句和循环语句综合实例](/python5/Example.md)
+* [函数](/python6/Preface.md)
+  - [Python 自定义函数的基本步骤](/python6/1.md)
+  - [函数传值问题](/python6/2.md)
+  - [函数返回值](/python6/3.md)
+  - [函数的参数](/python6/4.md)
+  - [匿名函数](/python6/5.md)
+* [迭代器和生成器](/python7/Preface.md)
+  - [迭代](/python7/1.md)
+  - [Python 迭代器](/python7/2.md)
+  - [lsit 生成式（列表生成式）](/python7/3.md)
+  - [生成器](/python7/4.md)
+  - [迭代器和生成器综合例子](/python7/5.md)
+* [模块与包](/python8/Preface.md)
+  - [Python 模块简介](/python8/1.md)
+  - [模块的使用](/python8/2.md)
+  - [主模块和非主模块](/python8/3.md)
+  - [包](/python8/4.md)
+  - [作用域](/python8/5.md)
+* [面向对象](/python9/Preface.md)
+  - [面向对象的概念](/python9/1.md)
+  - [类](/python9/2.md)
+  - [类的属性](/python9/3.md)
+  - [类的方法](/python9/4.md)
+  - [类的继承](/python9/5.md)
+  - [类的多态](/python9/6.md)
+* [Python 的 Magic Method](/python10/Preface.md)
+  - [Python 的 Magic Method](/python10/1.md)
+  - [构造(`__new__`)和初始化(`__init__`)](/python10/2.md)
+  - [属性的访问控制](/python10/3.md)
+  - [对象的描述器](/python10/4.md)
+  - [自定义容器（Container）](/python10/5.md)
+  - [运算符相关的魔术方法](/python10/6.md)
+* [枚举类](/python11/Preface.md)
+  - [枚举类的使用](/python11/1.md)
+  - [Enum 的源码](/python11/2.md)
+  - [自定义类型的枚举](/python11/3.md)
+  - [枚举的比较](/python11/4.md)
+* [元类](/python12/Preface.md)
+  - [Python 中类也是对象](/python12/1.md)
+  - [使用 `type()` 动态创建类](/python12/2.md)
+  - [什么是元类](/python12/3.md)
+  - [自定义元类](/python12/4.md)
+  - [使用元类](/python12/5.md)
+* [线程与进程](/python13/Preface.md)
+  - [线程与进程](/python13/1.md)
+  - [多线程编程](/python13/2.md)
+  - [进程](/python13/3.md)
+* [一步一步了解正则表达式](/python14/Preface.md)
+    - [初识 Python 正则表达式](/python14/1.md)
+    - [字符集](/python14/2.md)
+    - [数量词](/python14/3.md)
+    - [边界匹配符和组](/python14/4.md)
+    - [re.sub](/python14/5.md)
+    - [re.match 和 re.search](/python14/6.md)

SUMMARY.md

@@ -72,3 +72,10 @@
   - [线程与进程](/python13/1.md)
   - [多线程编程](/python13/2.md)
   - [进程](/python13/3.md)
+* [一步一步了解正则表达式](/python14/Preface.md)
+    - [初识 Python 正则表达式](/python14/1.md)
+    - [字符集](/python14/2.md)
+    - [数量词](/python14/3.md)
+    - [边界匹配符和组](/python14/4.md)
+    - [re.sub](/python14/5.md)
+    - [re.match 和 re.search](/python14/6.md)

python14/1.md

@@ -0,0 +1,91 @@
+# 初识 Python 正则表达式
+
+正则表达式是一个特殊的字符序列，用于判断一个字符串是否与我们所设定的字符序列是否匹配，也就是说检查一个字符串是否与某种模式匹配。
+
+Python 自 1.5 版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。
+
+下面通过实例，一步一步来初步认识正则表达式。
+
+比如在一段字符串中寻找是否含有某个字符或某些字符，通常我们使用内置函数来实现，如下：
+
+```python
+# 设定一个常量
+a = '两点水|twowater|liangdianshui|草根程序员|ReadingWithU'
+
+# 判断是否有 “两点水” 这个字符串，使用 PY 自带函数
+
+print('是否含有“两点水”这个字符串：{0}'.format(a.index('两点水') > -1))
+print('是否含有“两点水”这个字符串：{0}'.format('两点水' in a))
+```
+
+输出的结果如下：
+
+```txt
+是否含有“两点水”这个字符串：True
+是否含有“两点水”这个字符串：True
+```
+
+那么，如果使用正则表达式呢？
+
+刚刚提到过，Python 给我们提供了 re 模块来实现正则表达式的所有功能，那么我们先使用其中的一个函数：
+
+```python
+re.findall(pattern, string[, flags])
+```
+
+该函数实现了在字符串中找到正则表达式所匹配的所有子串，并组成一个列表返回,具体操作如下：
+
+```python
+
+import re
+
+# 设定一个常量
+a = '两点水|twowater|liangdianshui|草根程序员|ReadingWithU'
+
+# 正则表达式
+
+findall = re.findall('两点水', a)
+print(findall)
+
+if len(findall) > 0:
+    print('a 含有“两点水”这个字符串')
+else:
+    print('a 不含有“两点水”这个字符串')
+
+```
+
+输出的结果：
+
+```txt
+['两点水']
+a 含有“两点水”这个字符串
+```
+
+从输出结果可以看到，可以实现和内置函数一样的功能，可是在这里也要强调一点，上面这个例子只是方便我们理解正则表达式，这个正则表达式的写法是毫无意义的。为什么这样说呢？
+
+因为用 Python 自带函数就能解决的问题，我们就没必要使用正则表达式了，这样做多此一举。而且上面例子中的正则表达式设置成为了一个常量，并不是一个正则表达式的规则，正则表达式的灵魂在于规则，所以这样做意义不大。
+
+那么正则表达式的规则怎么写呢？先不急，我们一步一步来，先来一个简单的，找出字符串中的所有小写字母。首先我们在 `findall` 函数中第一个参数写正则表达式的规则，其中	`[a-z]` 就是匹配任何小写字母，第二个参数只要填写要匹配的字符串就行了。具体如下：
+
+```python
+
+import re
+
+# 设定一个常量
+a = '两点水|twowater|liangdianshui|草根程序员|ReadingWithU'
+
+# 选择 a 里面的所有小写英文字母
+
+re_findall = re.findall('[a-z]', a)
+
+print(re_findall)
+
+```
+
+输出的结果：
+
+```txt
+['t', 'w', 'o', 'w', 'a', 't', 'e', 'r', 'l', 'i', 'a', 'n', 'g', 'd', 'i', 'a', 'n', 's', 'h', 'u', 'i', 'e', 'a', 'd', 'i', 'n', 'g', 'i', 't', 'h']
+```
+
+这样我们就拿到了字符串中的所有小写字母了。

python14/2.md

@@ -0,0 +1,81 @@
+# 字符集
+
+
+好了，通过上面的几个实例我们初步认识了 Python 的正则表达式，可能你就会问，正则表达式还有什么规则，什么字母代表什么意思呢？
+
+其实，这些都不急，在本章后面会给出对应的正则表达式规则列表，而且这些东西在网上随便都能 Google 到。所以现在，我们还是进一步加深对正则表达式的理解，讲一下正则表达式的字符集。
+
+字符集是由一对方括号 “[]” 括起来的字符集合。使用字符集，可以匹配多个字符中的一个。
+
+举个例子，比如你使用 `C[ET]O` 匹配到的是 CEO 或 CTO ，也就是说 `[ET]` 代表的是一个 E 或者一个 T 。像上面提到的 `[a-z]` ,就是所有小写字母中的其中一个，这里使用了连字符 “-” 定义一个连续字符的字符范围。当然，像这种写法，里面可以包含多个字符范围的，比如：`[0-9a-fA-F]` ,匹配单个的十六进制数字，且不分大小写。注意了，字符和范围定义的先后顺序对匹配的结果是没有任何影响的。
+
+其实说了那么多，只是想证明，字符集一对方括号 “[]” 里面的字符关系是或关系，下面看一个例子：
+
+```Python
+
+import re
+a = 'uav,ubv,ucv,uwv,uzv,ucv,uov'
+
+# 字符集
+
+# 取 u 和 v 中间是 a 或 b 或 c 的字符
+findall = re.findall('u[abc]v', a)
+print(findall)
+# 如果是连续的字母，数字可以使用 - 来代替
+l = re.findall('u[a-c]v', a)
+print(l)
+
+# 取 u 和 v 中间不是 a 或 b 或 c 的字符
+re_findall = re.findall('u[^abc]v', a)
+print(re_findall)
+
+```
+
+输出的结果：
+
+```txt
+['uav', 'ubv', 'ucv', 'ucv']
+['uav', 'ubv', 'ucv', 'ucv']
+['uwv', 'uzv', 'uov']
+```
+
+在例子中，使用了取反字符集，也就是在左方括号 “[” 后面紧跟一个尖括号 “^”，就会对字符集取反。需要记住的一点是，取反字符集必须要匹配一个字符。比如：`q[^u]` 并不意味着：匹配一个 q，后面没有 u 跟着。它意味着：匹配一个 q，后面跟着一个不是 u 的字符。具体可以对比上面例子中输出的结果来理解。
+
+我们都知道，正则表达式本身就定义了一些规则，比如 `\d`,匹配所有数字字符,其实它是等价于 [0-9]，下面也写了个例子，通过字符集的形式解释了这些特殊字符。
+
+```Python
+import re
+
+a = 'uav_ubv_ucv_uwv_uzv_ucv_uov&123-456-789'
+
+# 概括字符集
+
+# \d 相当于 [0-9] ,匹配所有数字字符
+# \D 相当于 [^0-9] ， 匹配所有非数字字符
+findall1 = re.findall('\d', a)
+findall2 = re.findall('[0-9]', a)
+findall3 = re.findall('\D', a)
+findall4 = re.findall('[^0-9]', a)
+print(findall1)
+print(findall2)
+print(findall3)
+print(findall4)
+
+# \w 匹配包括下划线的任何单词字符，等价于 [A-Za-z0-9_]
+findall5 = re.findall('\w', a)
+findall6 = re.findall('[A-Za-z0-9_]', a)
+print(findall5)
+print(findall6)
+
+```
+
+输出结果：
+
+```txt
+['1', '2', '3', '4', '5', '6', '7', '8', '9']
+['1', '2', '3', '4', '5', '6', '7', '8', '9']
+['u', 'a', 'v', '_', 'u', 'b', 'v', '_', 'u', 'c', 'v', '_', 'u', 'w', 'v', '_', 'u', 'z', 'v', '_', 'u', 'c', 'v', '_', 'u', 'o', 'v', '&', '-', '-']
+['u', 'a', 'v', '_', 'u', 'b', 'v', '_', 'u', 'c', 'v', '_', 'u', 'w', 'v', '_', 'u', 'z', 'v', '_', 'u', 'c', 'v', '_', 'u', 'o', 'v', '&', '-', '-']
+['u', 'a', 'v', '_', 'u', 'b', 'v', '_', 'u', 'c', 'v', '_', 'u', 'w', 'v', '_', 'u', 'z', 'v', '_', 'u', 'c', 'v', '_', 'u', 'o', 'v', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+['u', 'a', 'v', '_', 'u', 'b', 'v', '_', 'u', 'c', 'v', '_', 'u', 'w', 'v', '_', 'u', 'z', 'v', '_', 'u', 'c', 'v', '_', 'u', 'o', 'v', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+```

python14/3.md

@@ -0,0 +1,76 @@
+# 数量词
+
+来，继续加深对正则表达式的理解，这部分理解一下数量词，为什么要用数量词，想想都知道，如果你要匹配几十上百的字符时，难道你要一个一个的写，所以就出现了数量词。
+
+数量词的词法是：{min,max} 。min 和 max 都是非负整数。如果逗号有而 max 被忽略了，则 max 没有限制。如果逗号和 max 都被忽略了，则重复 min 次。比如，`\b[1-9][0-9]{3}\b`,匹配的是 1000 ~ 9999 之间的数字( “\b” 表示单词边界），而 `\b[1-9][0-9]{2,4}\b`，匹配的是一个在 100 ~ 99999 之间的数字。
+
+下面看一个实例，匹配出字符串中 4 到 7 个字母的英文
+
+```Python
+import re
+
+a = 'java*&39android##@@python'
+
+# 数量词
+
+findall = re.findall('[a-z]{4,7}', a)
+print(findall)
+```
+
+输出结果：
+
+```txt
+['java', 'android', 'python']
+```
+
+注意，这里有贪婪和非贪婪之分。那么我们先看下相关的概念：
+
+
+贪婪模式：它的特性是一次性地读入整个字符串，如果不匹配就吐掉最右边的一个字符再匹配，直到找到匹配的字符串或字符串的长度为 0 为止。它的宗旨是读尽可能多的字符，所以当读到第一个匹配时就立刻返回。
+
+懒惰模式：它的特性是从字符串的左边开始，试图不读入字符串中的字符进行匹配，失败，则多读一个字符，再匹配，如此循环，当找到一个匹配时会返回该匹配的字符串，然后再次进行匹配直到字符串结束。
+
+上面例子中的就是贪婪的，如果要使用非贪婪，也就是懒惰模式，怎么呢？
+
+如果要使用非贪婪，则加一个 `?` ，上面的例子修改如下：
+
+```Python
+import re
+
+a = 'java*&39android##@@python'
+
+# 贪婪与非贪婪
+
+re_findall = re.findall('[a-z]{4,7}?', a)
+print(re_findall)
+
+```
+
+输出结果如下：
+
+```txt
+['java', 'andr', 'pyth']
+```
+
+从输出的结果可以看出，android 只打印除了 andr ，Python  只打印除了 pyth ，因为这里使用的是懒惰模式。
+
+当然，还有一些特殊字符也是可以表示数量的，比如：
+
+
+> `?`：告诉引擎匹配前导字符 0 次或 1 次
+>
+> `+`：告诉引擎匹配前导字符 1 次或多次
+>
+> `*`：告诉引擎匹配前导字符 0 次或多次
+
+
+把这部分的知识点总结一下,就是下面这个表了:
+
+| 贪   婪 | 惰   性 | 描   述                       |
+| ------- | ------- | ----------------------------- |
+| ？      | ？？    | 零次或一次出现，等价于{0,1}   |
+| +       | +？     | 一次或多次出现 ，等价于{1,}   |
+| *       | *？     | 零次或多次出现   ，等价于{0,} |
+| {n}     | {n}？   | 恰好 n 次出现                 |
+| {n,m}   | {n,m}？ | 至少 n 次枝多 m 次出现        |
+| {n,}    | {n,}？  | 至少 n 次出现                 |

python14/4.md

@@ -0,0 +1,18 @@
+# 边界匹配符和组
+
+将上面几个点，就用了很大的篇幅了，现在介绍一些边界匹配符和组的概念。
+
+一般的边界匹配符有以下几个：
+
+| 语法 | 描述                                             |
+| ---- | ------------------------------------------------ |
+| ^    | 匹配字符串开头（在有多行的情况中匹配每行的开头） |
+| $    | 匹配字符串的末尾(在有多行的情况中匹配每行的末尾) |
+| \A   | 仅匹配字符串开头                                 |
+| \Z   | 仅匹配字符串末尾                                 |
+| \b   | 匹配 \w 和 \W 之间                               |
+| \B   | [^\b]                                            |
+
+分组，被括号括起来的表达式就是分组。分组表达式 `(...)` 其实就是把这部分字符作为一个整体，当然，可以有多分组的情况，每遇到一个分组，编号就会加 1 ，而且分组后面也是可以加数量词的。
+
+此处本应有例子，考虑到篇幅问题，就不贴了