两点水

Author: walter201230

README.md

@@ -111,7 +111,7 @@ IT 行业相对于一般传统行业，发展更新速度更快，一旦停止
 
 
 # 知识点补漏
-* [Python 关键字 yield](/Article\supplement\Python关键字yield.md)
+* [Python 关键字 yield](/Article/supplement/Python关键字yield.md)
 
 
 # Python 进阶

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)

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 ，而且分组后面也是可以加数量词的。
+
+此处本应有例子，考虑到篇幅问题，就不贴了

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
+```