Skip to content

P
Python

OpenDocCN / Python

通知 5
Star 0
Fork 0
P
Python

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 2add141c 编写于 作者: T TwoWater
浏览文件
操作

修改目录结构

上级 319ad74f
隐藏空白更改
内联 并排
Showing with 432 addition and 507 deletion
Article/Linux/Linux命令-文件管理模块.md 0 → 100644
浏览文件 @ 2add141c
## 文件管理
#### 1.查看文件信息：`ls`
**简介：**
`ls` 是英文单词 list 的简写，其功能为列出目录的内容，是用户最常用的命令之一。
Linux 文件或者目录名称最长可以有 265 个字符，“.” 代表当前目录，“..” 代表上一级目录，以 “.” 开头的文件为隐藏文件，需要用 -a 参数才能显示。
**ls常用参数：**
| 参数 | 含义 |
| --- | --- |
| -a | 显示指定目录下所有子目录与文件，包括隐藏文件 |
| -l | 以列表方式显示文件的详细信息 |
| -h | 配合 -l 以人性化的方式显示文件大小 |
**ls 匹配通配符：**
与 DOS 下的文件操作类似，在 Unix/Linux 系统中，也同样允许使用特殊字符来同时引用多个文件名，这些特殊字符被称为通配符。
| 通配符 | 含义 |
| ------- | ----- |
| * | 文件代表文件名中所有字符 |
| ls te* | 查找以 `te` 开头的文件 |
| ls *html | 查找结尾为 `html` 的文件 |
| ？ | 代表文件名中任意一个字符 |
| ls ?.c | 只找第一个字符任意，后缀为 `.c` 的文件 |
| ls a.? | 只找只有 3 个字符，前 2 字符为 `a.` ，最后一个字符任意的文件 |
| [] | `"[”` 和 `“]”` 将字符组括起来，表示可以匹配字符组中的任意一个。`“-”` 用于表示字符范围。 |
| [abc] | 匹配 a、b、c 中的任意一个 |
| [a-f] | 匹配从 a 到 f 范围内的的任意一个字符 |
| ls [a-f]* | 找到从 a 到 f 范围内的的任意一个字符开头的文件 |
| ls a-f | 查找文件名为 a-f 的文件,当 `“-”` 处于方括号之外失去通配符的作用 |
| \ | 如果要使通配符作为普通字符使用，可以在其前面加上转义字符。`“?”` 和 `“*”` 处于方括号内时不用使用转义字符就失去通配符的作用。 |
| ls \*a | 查找文件名为 `*a` 的文件 |
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/ls.jpeg)
#### 2. 输出重定向命令：`>`
**简介：**
Linux 允许将命令执行结果重定向到一个文件，本应显示在终端上的内容保存到指定文件中。
如：ls > test.txt ( test.txt 如果不存在，则创建，存在则覆盖其内容 )
注意： `> 输出重定向会覆盖原来的内容， >> 输出重定向则会追加到文件的尾部。`
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/%E9%87%8D%E5%AE%9A%E5%90%91.jpeg)
#### 3. 分屏显示：`more`
**简介：**
查看内容时，在信息过长无法在一屏上显示时，会出现快速滚屏，使得用户无法看清文件的内容，此时可以使用 `more` 命令，每次只显示一页，按下空格键可以显示下一页，按下 `q` 键退出显示，按下 `h` 键可以获取帮助。
#### 4. 管道：`|`
**简介：**
管道：一个命令的输出可以通过管道做为另一个命令的输入。
管道我们可以理解现实生活中的管子，管子的一头塞东西进去，另一头取出来，这里 `|` 的左右分为两端，左端塞东西(写)，右端取东西(读)。
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/%E7%AE%A1%E9%81%93.png)
#### 5. 清屏：`clear`
`clear` 作用为清除终端上的显示(类似于 DOS 的 cls 清屏功能)，也可使用快捷键：Ctrl + l ( “l” 为字母 “L” 的小写 )。
#### 6. 切换工作目录：`cd`
**简介：**
在使用 Unix/Linux 的时候，经常需要更换工作目录。`cd` 命令可以帮助用户切换工作目录。`Linux 所有的目录和文件名大小写敏感`
`cd` 后面可跟绝对路径，也可以跟相对路径。如果省略目录，则默认切换到当前用户的主目录。
**cd 常用命令：**
| 命令 | 含义 |
| --- | --- |
| `cd` | 切换到当前用户的主目录(/home/用户目录)，用户登陆的时候，默认的目录就是用户的主目录。 |
| `cd ~` | 切换到当前用户的主目录(/home/用户目录) |
| `cd .` | 切换到当前目录 |
| `cd ..` | 切换到上级目录 |
| `cd -` | 可进入上次所在的目录 |
注意：
* 如果路径是从根路径开始的，则路径的前面需要加上 “ / ”，如 “ /mnt ”，通常进入某个目录里的文件夹，前面不用加 “ / ”。
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/cd.png)
#### 7. 显示当前路径：`pwd`
**简介：**
使用 `pwd` 命令可以显示当前的工作目录，该命令很简单，直接输入 `pwd` 即可，后面不带参数。
#### 8. 创建目录：`mkdir`
**简介：**
通过 `mkdir` 命令可以创建一个新的目录。参数 -p 可递归创建目录。
需要注意的是新建目录的名称不能与当前目录中已有的目录或文件同名，并且目录创建者必须对当前目录具有写权限。
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/mkdir.png)
#### 9. 删除目录：`rmdir`
**简介：**
可使用 `rmdir` 命令删除一个目录。必须离开目录，并且目录必须为空目录，不然提示删除失败。
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/rmdir.png)
#### 10. 删除文件：`rm`
**简介：**
可通过 `rm` 删除文件或目录。使用 `rm` 命令要小心，因为文件删除后不能恢复。为了防止文件误删，可以在 `rm` 后使用 `-i` 参数以逐个确认要删除的文件。
**`rm` 常用参数：**
| 参数 | 含义 |
| --- | --- |
| -i | 以进行交互式方式执行 |
| -f | 强制删除，忽略不存在的文件，无需提示 |
| -r | 递归地删除目录下的内容，删除文件夹时必须加此参数 |
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/rm.png)
#### 11. 建立链接文件：`ln`
**简介：**
Linux 链接文件类似于 Windows 下的快捷方式。
链接文件分为软链接和硬链接。
软链接：软链接不占用磁盘空间，源文件删除则软链接失效。
硬链接：硬链接只能链接普通文件，不能链接目录。
使用格式：
```
ln 源文件 链接文件
ln -s 源文件 链接文件
```
如果`没有-s`选项代表建立一个硬链接文件，两个文件占用相同大小的硬盘空间，即使删除了源文件，链接文件还是存在，所以-s选项是更常见的形式。
注意：如果软链接文件和源文件不在同一个目录，源文件要使用绝对路径，不能使用相对路径。
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/ln.png)
#### 12. 查看或者合并文件内容：`cat`
**简介：**
查看文件内容
#### 13. 文本搜索：`grep`
**简介：**
Linux 系统中 grep 命令是一种强大的文本搜索工具，grep 允许对文本文件进行模式查找。如果找到匹配模式， grep 打印包含模式的所有行。
grep一般格式为：
```
grep [-选项] ‘搜索内容串’文件名
```
在 grep 命令中输入字符串参数时，最好引号或双引号括起来。例如：grep‘a ’1.txt。
**`grep` 常用参数：**
| 选项 | 含义 |
| --- | --- |
| -v | 显示不包含匹配文本的所有行（相当于求反） |
| -n | 显示匹配行及行号 |
| -i | 忽略大小写 |
grep 搜索内容串可以是正则表达式。
**grep 常用正则表达式：**
| 参数 | 含义 |
| --- | --- |
| ^a | 行首,搜寻以 m 开头的行；grep -n '^a' 1.txt |
| ke$ | 行尾,搜寻以 ke 结束的行；grep -n 'ke$' 1.txt |
| [Ss]igna[Ll] | 匹配 [] 里中一系列字符中的一个；搜寻匹配单词signal、signaL、Signal、SignaL的行；grep -n '[Ss]igna[Ll]' 1.txt |
| . | (点)匹配一个非换行符的字符；匹配 e 和 e 之间有任意一个字符，可以匹配 eee，eae，eve，但是不匹配 ee，eaae；grep -n 'e.e' 1.txt |
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/grep.png)
#### 14. 查找文件：`find`
**简介：**
find 命令功能非常强大，通常用来在特定的目录下搜索符合条件的文件，也可以用来搜索特定用户属主的文件。
**常用用法：**
| 命令 | 含义 |
| --- | --- |
| find ./ -name test.sh | 查找当前目录下所有名为test.sh的文件 |
| find ./ -name '*.sh' | 查找当前目录下所有后缀为.sh的文件 |
| find ./ -name "[A-Z]*" | 查找当前目录下所有以大写字母开头的文件 |
| find /tmp -size 2M | 查找在/tmp 目录下等于2M的文件 |
| find /tmp -size +2M | 查找在/tmp 目录下大于2M的文件 |
| find /tmp -size -2M | 查找在/tmp 目录下小于2M的文件 |
| find ./ -size +4k -size -5M | 查找当前目录下大于4k，小于5M的文件 |
| find ./ -perm 0777 | 查找当前目录下权限为 777 的文件或目录 |
#### 1.15 拷贝文件：`cp`
**简介：**
`cp` 命令的功能是将给出的文件或目录复制到另一个文件或目录中，相当于 DOS 下的 copy 命令。
**常用参数说明：**
| 选项 | 含义 |
| --- | --- |
| -a | 该选项通常在复制目录时使用，它保留链接、文件属性，并递归地复制目录，简单而言，保持文件原有属性。 |
| -f | 已经存在的目标文件而不提示 |
| -i | 交互式复制，在覆盖目标文件之前将给出提示要求用户确认 |
| -r | 若给出的源文件是目录文件，则cp将递归复制该目录下的所有子目录和文件，目标文件必须为一个目录名。 |
| -v | 显示拷贝进度 |
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/find.png)
#### 16. 移动文件：`mv`
**简介：**
用户可以使用 `mv` 命令来移动文件或目录，也可以给文件或目录重命名。
**常用参数说明：**
| 选项 | 含义 |
| --- | --- |
| -f | 禁止交互式操作，如有覆盖也不会给出提示 |
| -i | 确认交互方式操作，如果mv操作将导致对已存在的目标文件的覆盖，系统会询问是否重写，要求用户回答以避免误覆盖文件 |
| -v | 显示移动进度 |
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/mv.png)
#### 17. 归档管理：`tar`
**简介：**
计算机中的数据经常需要备份，tar 是 Unix/Linux 中最常用的备份工具，此命令可以把一系列文件归档到一个大文件中，也可以把档案文件解开以恢复数据。其实说白了，就是打包。
**`tar` 使用格式：**
```
tar [参数] 打包文件名 文件
```
**`tar` 常用参数：**
tar 命令很特殊，其参数前面可以使用“-”，也可以不使用。
| 参数 | 含义 |
| --- | --- |
| -c | 生成档案文件，创建打包文件 |
| -v | 列出归档解档的详细过程，显示进度 |
| -f | 指定档案文件名称，f后面一定是.tar文件，所以必须放选项最后 |
| -t | 列出档案中包含的文件 |
| -x | 解开档案文件 |
注意：除了f需要放在参数的最后，其它参数的顺序任意。
#### 18. 文件压缩解压：`gzip`
**简介：**
tar 与 gzip 命令结合使用实现文件打包、压缩。 tar 只负责打包文件，但不压缩，用 gzip 压缩 tar 打包后的文件，其扩展名一般用xxxx.tar.gz。
**`gzip` 使用格式如下：**
```
gzip [选项] 被压缩文件
```
**常用选项：**
| 选项 | 含义 |
| --- | --- |
| -d | 解压 |
| -r | 压缩所有子目录 |
tar这个命令并没有压缩的功能，它只是一个打包的命令，但是在tar命令中增加一个选项(-z)可以调用gzip实现了一个压缩的功能，实行一个先打包后压缩的过程。
压缩用法：tar cvzf 压缩包包名 文件1 文件2 ...
```-z ：指定压缩包的格式为：file.tar.gz```
解压用法： tar zxvf 压缩包包名
```-z:指定压缩包的格式为：file.tar.gz```
解压到指定目录：-C （大写字母“C”）
#### 19. 文件压缩解压：`bzip2`
**简介：**
tar与bzip2命令结合使用实现文件打包、压缩(用法和gzip一样)。
tar只负责打包文件，但不压缩，用bzip2压缩tar打包后的文件，其扩展名一般用xxxx.tar.gz2。
在tar命令中增加一个选项(-j)可以调用bzip2实现了一个压缩的功能，实行一个先打包后压缩的过程。
压缩用法：tar -jcvf 压缩包包名 文件...(tar jcvf bk.tar.bz2 *.c)
解压用法：tar -jxvf 压缩包包名 (tar jxvf bk.tar.bz2)
#### 20. 文件压缩解压：`zip` 、`unzip`
通过zip压缩文件的目标文件不需要指定扩展名，默认扩展名为zip。
压缩文件：zip [-r] 目标文件(没有扩展名) 源文件
解压文件：unzip -d 解压后目录文件 压缩文件
#### 21. 查看命令位置：`which`
**简介：**
查看命令的路径
![](http://p1ceh5usj.bkt.clouddn.com/linux/%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86%E6%A8%A1%E5%9D%97/which.png)
Article/python14/Preface.md
浏览文件 @ 2add141c
# 目录 #
![草根学Python（十四） 一步一步了解正则表达式](https://raw.githubusercontent.com/TwoWater/Python/master/python14/%E8%8D%89%E6%A0%B9%E5%AD%A6Python%EF%BC%88%E5%8D%81%E5%9B%9B%EF%BC%89%20%E4%B8%80%E6%AD%A5%E4%B8%80%E6%AD%A5%E4%BA%86%E8%A7%A3%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F.png)
![草根学Python（十四） 一步一步了解正则表达式](https://raw.githubusercontent.com/TwoWater/Python/master/Article/python14/%E8%8D%89%E6%A0%B9%E5%AD%A6Python%EF%BC%88%E5%8D%81%E5%9B%9B%EF%BC%89%20%E4%B8%80%E6%AD%A5%E4%B8%80%E6%AD%A5%E4%BA%86%E8%A7%A3%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F.png)
python14/1.md 已删除 100644 → 0
浏览文件 @ 319ad74f
# 初识 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 已删除 100644 → 0
浏览文件 @ 319ad74f
# 字符集
好了，通过上面的几个实例我们初步认识了 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 已删除 100644 → 0
浏览文件 @ 319ad74f
# 数量词
来，继续加深对正则表达式的理解，这部分理解一下数量词，为什么要用数量词，想想都知道，如果你要匹配几十上百的字符时，难道你要一个一个的写，所以就出现了数量词。
数量词的词法是：{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 已删除 100644 → 0
浏览文件 @ 319ad74f
# 边界匹配符和组
将上面几个点，就用了很大的篇幅了，现在介绍一些边界匹配符和组的概念。
一般的边界匹配符有以下几个：
| 语法 | 描述 |
| ---- | ------------------------------------------------ |
| ^ | 匹配字符串开头（在有多行的情况中匹配每行的开头） |
| $ | 匹配字符串的末尾(在有多行的情况中匹配每行的末尾) |
| \A | 仅匹配字符串开头 |
| \Z | 仅匹配字符串末尾 |
| \b | 匹配 \w 和 \W 之间 |
| \B | [^\b] |
分组，被括号括起来的表达式就是分组。分组表达式 `(...)` 其实就是把这部分字符作为一个整体，当然，可以有多分组的情况，每遇到一个分组，编号就会加 1 ，而且分组后面也是可以加数量词的。
此处本应有例子，考虑到篇幅问题，就不贴了
python14/5.md 已删除 100644 → 0
浏览文件 @ 319ad74f
# 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
```
python14/6.md 已删除 100644 → 0
浏览文件 @ 319ad74f
# 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 = '<img src="https://s-media-cache-ak0.pinimg.com/originals/a8/c4/9e/a8c49ef606e0e1f3ee39a7b219b5c05e.jpg">'
# 使用 re.search
search = re.search('<img src="(.*)">', a)
# group(0) 是一个完整的分组
print(search.group(0))
print(search.group(1))
# 使用 re.findall
findall = re.findall('<img src="(.*)">', 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
<img src="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
['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 系列博客的库。也可以关注我的微信公众号：
![http://twowater.com.cn/images/20171204192251900.gif](http://twowater.com.cn/images/20171204192251900.gif)
python14/Preface.md 已删除 100644 → 0
浏览文件 @ 319ad74f
# 目录 #
![草根学Python（十四） 一步一步了解正则表达式](https://raw.githubusercontent.com/TwoWater/Python/master/python14/%E8%8D%89%E6%A0%B9%E5%AD%A6Python%EF%BC%88%E5%8D%81%E5%9B%9B%EF%BC%89%20%E4%B8%80%E6%AD%A5%E4%B8%80%E6%AD%A5%E4%BA%86%E8%A7%A3%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F.png)
python14/常用的正则表达式.md 已删除 100644 → 0
浏览文件 @ 319ad74f
#
# 常用的正则表达式
## 校验数字的表达式
```
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*?)[^>]*>.*?</\1>|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
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\&%_\./-~-]*)?
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或