From d787a0d9faaac878f71ba99910690fb6f20409d7 Mon Sep 17 00:00:00 2001
From: "347073565@qq.com" <347073565@qq.com>
Date: Thu, 22 Feb 2018 16:22:33 +0800
Subject: [PATCH] =?UTF-8?q?=E4=B8=A4=E7=82=B9=E6=B0=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
README.md | 2 +-
SUMMARY.md | 2 +-
python14/1.md | 91 +++++++++++++++++
python14/2.md | 81 +++++++++++++++
python14/3.md | 76 ++++++++++++++
python14/4.md | 18 ++++
python14/5.md | 56 +++++++++++
python14/6.md | 95 ++++++++++++++++++
python14/Preface.md | 3 +
python14/常用的正则表达式.md | 86 ++++++++++++++++
python14/正则表达式.png | Bin 0 -> 189841 bytes
...学Python（十四） 一步一步了解正则表达式.png | Bin 0 -> 20029 bytes
12 files changed, 508 insertions(+), 2 deletions(-)
create mode 100644 python14/1.md
create mode 100644 python14/2.md
create mode 100644 python14/3.md
create mode 100644 python14/4.md
create mode 100644 python14/5.md
create mode 100644 python14/6.md
create mode 100644 python14/Preface.md
create mode 100644 python14/常用的正则表达式.md
create mode 100644 python14/正则表达式.png
create mode 100644 python14/草根学Python（十四） 一步一步了解正则表达式.png
diff --git a/README.md b/README.md
index 082c98e..80c32d3 100644
--- a/README.md
+++ b/README.md
@@ -111,7 +111,7 @@ IT 行业相对于一般传统行业，发展更新速度更快，一旦停止
# 知识点补漏
-* [Python 关键字 yield](/Article\supplement\Python关键字yield.md)
+* [Python 关键字 yield](/Article/supplement/Python关键字yield.md)
# Python 进阶
diff --git a/SUMMARY.md b/SUMMARY.md
index a9246d3..8444ed2 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -82,4 +82,4 @@
* [闭包](/Article/python15/1.md)
* [装饰器](/Article/python16/1.md)
* [知识点补漏](README.md)
- - [Python 关键字 yield](/Article\supplement\Python关键字yield.md)
+ - [Python 关键字 yield](/Article/supplement/Python关键字yield.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 @@
+# 目录 #
+
+
diff --git a/python14/常用的正则表达式.md b/python14/常用的正则表达式.md
new file mode 100644
index 0000000..5ffe751
--- /dev/null
+++ b/python14/常用的正则表达式.md
@@ -0,0 +1,86 @@
+
+#
+
+# 常用的正则表达式
+
+## 校验数字的表达式
+
+```
+1、 数字：^[0-9]*$
+2、 n位的数字：^\d{n}$
+3、 至少n位的数字：^\d{n,}$
+4、 m-n位的数字：^\d{m,n}$
+5、 零和非零开头的数字：^(0|[1-9][0-9]*)$
+6、 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$
+7、 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$
+8、 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
+9、 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
+10、 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
+11、 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
+12、 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
+13、 非负整数：^\d+$ 或 ^[1-9]\d*|0$
+14、 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
+15、 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
+16、 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
+17、 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
+18、 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
+19、 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
+```
+
+
+## 校验字符的表达式
+
+```
+1、 汉字：^[\u4e00-\u9fa5]{0,}$
+2、 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
+3、 长度为3-20的所有字符：^.{3,20}$
+4、 由26个英文字母组成的字符串：^[A-Za-z]+$
+5、 由26个大写英文字母组成的字符串：^[A-Z]+$
+6、 由26个小写英文字母组成的字符串：^[a-z]+$
+7、 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
+8、 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
+9、 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
+10、 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
+11、 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+
+12、 禁止输入含有~的字符：[^~\x22]+
+```
+
+## 特殊需求表达式
+
+```
+1、 Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
+2、 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
+3、 InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
+4、 手机号码：^(13[0-9]|14[0-9]|15[0-9]|166|17[0-9]|18[0-9]|19[8|9])\d{8}$
+5、 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
+6、 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
+7、 18位身份证号码(数字、字母x结尾)：^((\d{18})|([0-9x]{18})|([0-9X]{18}))$
+8、 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
+9、 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
+10、 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
+11、 日期格式：^\d{4}-\d{1,2}-\d{1,2}
+12、 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
+13、 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$
+14、 钱的输入格式：
+ a.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$
+ b.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$
+ c.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$
+ d.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$
+ e.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$
+ f.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$
+ g.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
+ h.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
+15、 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
+16、 中文字符的正则表达式：[\u4e00-\u9fa5]
+17、 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
+18、 空白行的正则表达式：\n\s*\r (可以用来删除空白行)
+19、 HTML标记的正则表达式：<(\S*?)[^>]*>.*?|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
+20、 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
+21、 腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)
+22、 中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
+23、 IP地址：\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)
+24、 IP地址：((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
+25、PV6 地址： (([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))
+26、URL 链接： ((http|ftp|https)://)(([a-zA-Z0-9\._-]+\.[a-zA-Z]{2,6})|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,4})*(/[a-zA-Z0-9\&%_\./-~-]*)?
+
+```
diff --git a/python14/正则表达式.png b/python14/正则表达式.png
new file mode 100644
index 0000000000000000000000000000000000000000..e11ec998653f664e406d52ba3cc846e1873af91e
GIT binary patch
literal 189841
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