diff --git a/README.md b/README.md
index cc188ee..ec90e9b 100644
--- a/README.md
+++ b/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/)|
\ No newline at end of file
+* [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)
diff --git a/SUMMARY.md b/SUMMARY.md
index 301ddbb..be8bb9d 100644
--- a/SUMMARY.md
+++ b/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)
diff --git a/python14/1.md b/python14/1.md
new file mode 100644
index 0000000..32a0961
--- /dev/null
+++ b/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']
+```
+
+这样我们就拿到了字符串中的所有小写字母了。
diff --git a/python14/2.md b/python14/2.md
new file mode 100644
index 0000000..65c018a
--- /dev/null
+++ b/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']
+```
diff --git a/python14/3.md b/python14/3.md
new file mode 100644
index 0000000..130136d
--- /dev/null
+++ b/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 次出现 |
diff --git a/python14/4.md b/python14/4.md
new file mode 100644
index 0000000..1179069
--- /dev/null
+++ b/python14/4.md
@@ -0,0 +1,18 @@
+# 边界匹配符和组
+
+将上面几个点，就用了很大的篇幅了，现在介绍一些边界匹配符和组的概念。
+
+一般的边界匹配符有以下几个：
+
+| 语法 | 描述 |
+| ---- | ------------------------------------------------ |
+| ^ | 匹配字符串开头（在有多行的情况中匹配每行的开头） |
+| $ | 匹配字符串的末尾(在有多行的情况中匹配每行的末尾) |
+| \A | 仅匹配字符串开头 |
+| \Z | 仅匹配字符串末尾 |
+| \b | 匹配 \w 和 \W 之间 |
+| \B | [^\b] |
+
+分组，被括号括起来的表达式就是分组。分组表达式 `(...)` 其实就是把这部分字符作为一个整体，当然，可以有多分组的情况，每遇到一个分组，编号就会加 1 ，而且分组后面也是可以加数量词的。
+
+此处本应有例子，考虑到篇幅问题，就不贴了
diff --git a/python14/5.md b/python14/5.md
new file mode 100644
index 0000000..6c7138c
--- /dev/null
+++ b/python14/5.md
@@ -0,0 +1,56 @@
+# re.sub
+
+实战过程中，我们很多时候需要替换字符串中的字符，这时候就可以用到 `def sub(pattern, repl, string, count=0, flags=0) ` 函数了，re.sub 共有五个参数。其中三个必选参数：pattern, repl, string ; 两个可选参数：count, flags .
+
+具体参数意义如下：
+
+| 参数 | 描述 |
+| ------- | ------------------------------------------------------------- |
+| pattern | 表示正则中的模式字符串 |
+| repl | repl，就是replacement，被替换的字符串的意思 |
+| string | 即表示要被处理，要被替换的那个 string 字符串 |
+| count | 对于pattern中匹配到的结果，count可以控制对前几个group进行替换 |
+| flags | 正则表达式修饰符 |
+
+具体使用可以看下下面的这个实例，注释都写的很清楚的了，主要是注意一下，第二个参数是可以传递一个函数的，这也是这个方法的强大之处，例如例子里面的函数 `convert` ,对传递进来要替换的字符进行判断，替换成不同的字符。
+
+```python
+#!/usr/bin/env python3
+# -*- coding: UTF-8 -*-
+
+import re
+
+a = 'Python*Android*Java-888'
+
+# 把字符串中的 * 字符替换成 & 字符
+sub1 = re.sub('\*', '&', a)
+print(sub1)
+
+# 把字符串中的第一个 * 字符替换成 & 字符
+sub2 = re.sub('\*', '&', a, 1)
+print(sub2)
+
+
+# 把字符串中的 * 字符替换成 & 字符,把字符 - 换成 |
+
+# 1、先定义一个函数
+def convert(value):
+ group = value.group()
+ if (group == '*'):
+ return '&'
+ elif (group == '-'):
+ return '|'
+
+
+# 第二个参数，要替换的字符可以为一个函数
+sub3 = re.sub('[\*-]', convert, a)
+print(sub3)
+```
+
+输出的结果：
+
+```txt
+Python&Android&Java-888
+Python&Android*Java-888
+Python&Android&Java|888
+```
diff --git a/python14/6.md b/python14/6.md
new file mode 100644
index 0000000..8fd43bf
--- /dev/null
+++ b/python14/6.md
@@ -0,0 +1,95 @@
+# re.match 和 re.search
+
+**re.match 函数**
+
+语法：
+
+```python
+re.match(pattern, string, flags=0)
+```
+
+re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。
+
+
+**re.search 函数**
+
+语法：
+
+```Python
+re.search(pattern, string, flags=0)
+```
+
+re.search 扫描整个字符串并返回第一个成功的匹配。
+
+re.match 和 re.search 的参数，基本一致的，具体描述如下：
+
+| 参数 | 描述 |
+| ------- | -------------------------------------------------------- |
+| pattern | 匹配的正则表达式 |
+| string | 要匹配的字符串 |
+| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写 |
+
+那么它们之间有什么区别呢？
+
+re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None；而 re.search 匹配整个字符串，直到找到一个匹配。这就是它们之间的区别了。
+
+re.match 和 re.search 在网上有很多详细的介绍了，可是再个人的使用中，还是喜欢使用 re.findall
+
+看下下面的实例，可以对比下 re.search 和 re.findall 的区别，还有多分组的使用。具体看下注释，对比一下输出的结果：
+
+示例：
+
+```python
+
+#!/usr/bin/env python3
+# -*- coding: UTF-8 -*-
+
+# 提取图片的地址
+
+import re
+
+a = '
'
+
+# 使用 re.search
+search = re.search(')
', a)
+# group(0) 是一个完整的分组
+print(search.group(0))
+print(search.group(1))
+
+# 使用 re.findall
+findall = re.findall('', a)
+print(findall)
+
+# 多个分组的使用（比如我们需要提取 img 字段和图片地址字段）
+re_search = re.search('<(.*) src="(.*)">', a)
+# 打印 img
+print(re_search.group(1))
+# 打印图片地址
+print(re_search.group(2))
+# 打印 img 和图片地址，以元祖的形式
+print(re_search.group(1, 2))
+# 或者使用 groups
+print(re_search.groups())
+
+```
+
+输出的结果：
+
+```txt
+
+https://s-media-cache-ak0.pinimg.com/originals/a8/c4/9e/a8c49ef606e0e1f3ee39a7b219b5c05e.jpg
+['https://s-media-cache-ak0.pinimg.com/originals/a8/c4/9e/a8c49ef606e0e1f3ee39a7b219b5c05e.jpg']
+img
+https://s-media-cache-ak0.pinimg.com/originals/a8/c4/9e/a8c49ef606e0e1f3ee39a7b219b5c05e.jpg
+('img', 'https://s-media-cache-ak0.pinimg.com/originals/a8/c4/9e/a8c49ef606e0e1f3ee39a7b219b5c05e.jpg')
+('img', 'https://s-media-cache-ak0.pinimg.com/originals/a8/c4/9e/a8c49ef606e0e1f3ee39a7b219b5c05e.jpg')
+```
+
+
+最后，正则表达式是非常厉害的工具，通常可以用来解决字符串内置函数无法解决的问题，而且正则表达式大部分语言都是有的。python 的用途很多，但在爬虫和数据分析这连个模块中都是离不开正则表达式的。所以正则表达式对于学习 Python 来说，真的很重要。最后，附送一些常用的正则表达式和正则表达式和 Python 支持的正则表达式元字符和语法文档。
+
+github：https://github.com/TwoWater/Python/blob/master/python14/%E5%B8%B8%E7%94%A8%E7%9A%84%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F.md
+
+欢迎大家 start ，https://github.com/TwoWater/Python 一下，这是草根学 Python 系列博客的库。也可以关注我的微信公众号：
+
+
diff --git a/python14/Preface.md b/python14/Preface.md
new file mode 100644
index 0000000..f50b849
--- /dev/null
+++ b/python14/Preface.md
@@ -0,0 +1,3 @@
+# 目录 #
+
+