python基础--14大内置模块(下)

(9）正则表达式和re模块(重点模块)

在我们学习这个模块之前，我们先明确一个关系。模块和实际工作的关系。

1)模块和实际工作时间的关系

1.time模块和时间是什么关系？time模块和时间本身是没有关系的，但是在实际的开发的过程中，我们使用time模块可以使我们更加的方便的操作时间，获取到时间的值。
2.re模块和正则表达式之间的关系
有了re模块就可以在python语言中操作正则表达式了。
就算没有了re模块，我们的正则表达式依然是存在的，只是我们re模块使得我们更好的更加方便的去操作正则表达式。
所有的语言（java c++ js等等）都是有正则的表达式，大部分正则表达式的语法都是相同的。
re模块可以使得我们去更好的操作正则表达式。
先学正则表达式，然后再学在python中怎么去使用和操作正则表达式的。
所以正则表达式是重点。re模块是重点。（这里必须重点掌握，这个阶段一定要挑战，冲刺正则表达式和re模块等等）

2)正则表达式

re模块--regex的缩写 正则表达式
正则表达式（重要性体现在以下几个方面）：
自动化运维 --- 实际上也是和开发有关系，开发相应的自动化运维的软件
爬虫 ---- python学习的热门方向

正则表达式在线测试工具：http://tool.chinaz.com/regex

字符组 ： [字符组]
在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
字符分为很多类，比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。

正则	待匹配字符	匹配结果	说明
[0123456789]	8	True	在一个字符组里枚举合法的所有字符，字符组里的任意一个字符和"待匹配字符"相同都视为可以匹配
[0123456789]	a	False	由于字符组中没有"a"字符，所以不能匹配
[0-9]	7	True	也可以用-表示范围,[0-9]就和[0123456789]是一个意思
[a-z]	s	True	同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示
[A-Z]	B	True	[A-Z]就表示所有的大写字母
[0-9a-fA-F]	e	True	可以匹配数字，大小写形式的a～f，用来验证十六进制字符

1.元字符：

元字符	匹配内容
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线
\s	匹配任意的空白符(\n \t 空格)
\d	匹配数字(0-9)
\n	匹配一个换行符
\t	匹配一个制表符
\b	匹配一个单词的结尾
^	匹配字符串的开始
$	匹配字符串的结尾
\W	匹配非字母或数字或下划线
\D	匹配非数字
\S	匹配非空白符
a|b	匹配字符a或字符b
()	匹配括号内的表达式，也表示一个组，表示一个分组
[...]	匹配字符组中的字符
[^...]	匹配除了字符组中字符的所有字符

2. 量词：

量词	用法说明
*	重复零次或一次或更多次
+	重复一次或更多次
?	重复零次或一次
	重复n次
	重复n次或更多次
	重复n到m次

3. . ^ $

正则	待匹配字符	匹配 结果	说明
海.	海燕海娇海东	海燕海娇海东	匹配所有"海."的字符
^海.	海燕海娇海东	海燕	只从开头匹配"海."
海.$ | 海燕海娇海东 | 海东 | 只匹配结尾的"海.$"

4.* + ?

正则	待匹配字符	匹配 结果	说明
李.?	李杰和李莲英和李二棍子	李杰 李莲 李二	?表示重复零次或一次，即只匹配"李"后面一个任意字符
李.*	李杰和李莲英和李二棍子	李杰和李莲英和李二棍子	*表示重复零次或多次，即匹配"李"后面0或多个任意字符
李.+	李杰和李莲英和李二棍子	李杰和李莲英和李二棍子	+表示重复一次或多次，即只匹配"李"后面1个或多个任意字符
李.	李杰和李莲英和李二棍子	李杰和 李莲英 李二棍	{1,2}匹配1到2次任意字符

注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

正则	待匹配字符	匹配 结果	说明
李.*?	李杰和李莲英和李二棍子	李 李 李	惰性匹配

5.字符集［］［^］

正则	待匹配字符	匹配 结果	说明
李[杰莲英二棍子]*	李杰和李莲英和李二棍子	李杰 李莲英 李二棍子	表示匹配"李"字后面[杰莲英二棍子]的字符任意次
李[^和]*	李杰和李莲英和李二棍子	李杰 李莲英 李二棍子	表示匹配一个不是"和"的字符任意次
[\d]	456bdha3	4 5 6 3	表示匹配任意一个数字，匹配到4个结果
[\d]+	456bdha3	456 3	表示匹配任意个数字，匹配到2个结果

6.分组 ()与 或 ｜［^］

身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部🈶️数字组成，首位不能为0；如果是18位，则前17位全部是数字，末位可能是数字或x，下面我们尝试用正则来表示：

正则	待匹配字符	匹配 结果	说明
`[1]\d{13,16}[0-9x]	正则	待匹配字符	匹配 结果
----------------------------------	------------------	------------------	------------------------------------------------------------

         | 110101198001017032 | 110101198001017032 | 表示可以匹配一个正确的身份证号                               |

| ^[1-9]\d{13,16}[0-9x]| 正则 | 待匹配字符 | 匹配 结果 | 说明 | | ---------------------------------- | ------------------ | ------------------ | ------------------------------------------------------------ | | 1101011980010170 | 1101011980010170 | 表示也可以匹配这串数字，但这并不是一个正确的身份证号码，它是一个16位的数字| |^[2]\d{14}(\d{2}[0-9x])?| 正则 | 待匹配字符 | 匹配 结果 | 说明 |
| ---------------------------------- | ------------------ | ------------------ | ------------------------------------------------------------ |
| 1101011980010170 | False | `现在不会匹配错误的身份证号了()表示分组，将\d{2}[0-9x]分成一组，就可以整体约束他们出现的次数为0-1次` |
| `^([1-9]\d{16}[0-9x]|[1-9]\d{14})| 正则 | 待匹配字符 | 匹配 结果 | 说明 |
| ---------------------------------- | ------------------ | ------------------ | ------------------------------------------------------------ |
| 110105199812067023 | 110105199812067023 | `表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14}` |

7.转义符 \

在正则表达式中，有很多有特殊意义的是元字符，比如\n和\s等，如果要在正则中匹配正常的"\n"而不是"换行符"就需要对""进行转义，变成'\'。

在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\n",字符串中要写成'\n'，那么正则里就要写成"\\n",这样就太麻烦了。这个时候我们就用到了r'\n'这个概念，此时的正则是r'\n'就可以了。

正则	待匹配字符	匹配 结果	说明
\n	\n	False	因为在正则表达式中\是有特殊意义的字符，所以要匹配\n本身，用表达式\n无法匹配
\n	\n	True	转义\之后变成\\，即可匹配
"\\n"	'\n'	True	如果在python中，字符串中的'\'也需要转义，所以每一个字符串'\'又需要转义一次
r'\n'	r'\n'	True	在字符串之前加r，让整个字符串不转义

8.贪婪匹配

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

正则	待匹配字符	匹配 结果	说明
<.*>	<script>...<script>	<script>...<script>	默认为贪婪匹配模式，会匹配尽量长的字符串
<.*?>	r'\d'	<script> <script>	加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串

几个常用的非贪婪匹配Pattern
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
.*?的用法

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x
就是取前面任意长度的字符，直到一个x出现

# 正则表达式在线测试工具：http://tool.chinaz.com/regex
# 什么是正则表达式
    #正则表达式是一套规划---匹配字符串的
# 正则表达式能做什么？
    # 1.检测一个输入的字符串是否合法，例如：---web开发项目 表单验证
        # 用户输入一个内容的时候，我们要提前做检测
        # 能够提高程序的效率并且减轻服务器的压力。
    # 2.从一个大文件中找到所有符合规则的内容---日志分析、爬虫
        # 能够高效的从一大段文字中快速找到符合规则的内容。

# 正则规则
# 就是所有的规则中的字符就可以刚好匹配到字符串中的内容。
# bc
# abcdefabcdefabcdefabcdefabcdefabcdefabcdef

    # 元字符--可以匹配内容的规则。
    # 字符组[]  描述的是一个位置上能出现的所以可能性
    # 接受范围，可以描述多个范围，连着写就可以了。
    # []  一个中括号（字符组）只表示一个字符位置，例如：[abc] 匹配的是a或者b或者c
    # [0-9] 一个中括号（字符组）只表示一个字符位置，例如：[0-9]匹配的是0,1,2,3,4,5,6,7,8,9 根据ascill进行范围的对比
    # [a-z] [A-Z]   [A-z] 根据ascill进行范围的对比[a-zA-Z]
    # [0-9a-zA-Z]所有的数字和字母
    # [0-9][0-9]
    # [0-9]  === \d 表示匹配任何一位数字
    # \w表示匹配到任何一个‘数字字母下划线’
    # 匹配所有的空白符 空白符（空格\tab\enter）====( |\t|\n)
    # [ \t\n]===\s 表示匹配所有的空白符
    # 空格，tab和回车都可以用\s匹配

    # \W  非数字字母下划线
    # \D  非数字
    # \S  非空白符
    # [\d\D] 既可以匹配所有的数字，也可以匹配所有的非数字。
    # [\s\S]  [\w\W]  [\d\D]这三个都是表示的是匹配的是所有。
    # . 匹配除了换行符以来的所有字符。

    # [^]:表示非字符组
    # [^\d]  表示匹配所有的非数字
    # [^1]   表示匹配所有的非1数字（除了1之外，其余都可以被匹配到）
    # [^c]   表示匹配所有的非c字母（除了c之外，其余都可以被匹配到）
    # ^ 匹配一个字符串的开始 例如：^a.表示匹配一个以a为开头的字符串
    # $ 匹配一个字符串的结尾 例如：d$  f.$ 表示匹配一个以d或者f.(fd)为结尾的字符串
    # ^ 和 $之间的数据个数和字符串的数据个数是一样的，才有匹配正确的可能性。
    # 例如：^a.a.a.$  acadab匹配成功。
    # ^不能出现在正则表达式的其它位置，只可以出现在第一个位置。但是在[]中表示的是取反。
    # $不能出现在正则表达式的其它位置，只可以出现在最后一个位置上。
    # | 或  a[bc]  == a[b|c]  都可以匹配到ab和ac
    # [ab][cd] 表示可以匹配ac ad bc bd
    # ad|bc 表示可以匹配ad 或者 bc
    # ab|abc  对于字符串abc的匹配结果为ab，而不是abc，因为正则表达式是从左到右依次匹配的。
    # a表达式|b表达式 匹配a或者b表达式中的内容，如果匹配a成功了，那么就不会继续和b匹配。所以，如果两个规则有重叠部分，总是把长的放在左边（前面）。
    # () 分组，使得作用域在某一个范围内,约束作用范围。或者作用范围只在某一块。
    # 例如：www\.oldboy\.com|www\.baidu\.com|www\.jd\.com|www\.taobao\.com
    # www\.(oldboy|baidu|jd|taobao)\.com
    # 约束|描述的内容的范围问题
    # o\b  表示匹配的是第一个o  例如：hello world 只能匹配到第一个字母o
    # 匹配两位整数 [1-9]\d

    # 匹配十位数 [1-9]\d\d\d\d\d\d\d\d\d\d,但是我们这样写看起来很烦躁，例如我们匹配15或者18位，这样写法就比较的麻烦。
    # 那么，我们有什么好的方法呢，去避免这些重复性的操作。

    # 在这里我们引入了量词的概念来解决这个问题。

    # 量词
    # 用来表示数量，表示可以匹配多少次。
    # {n} 表示匹配n次  =n
    # {n,} 表示至少匹配n次  >=n
    # {n,m}  表示至少匹配n次，至多匹配m次  >=n  <=m
    # ? 表示匹配0次或者1次  {0,1}
    # + 表示匹配1次或者多次  {1,}
    # * 表示匹配0次、1次或者多次 {0,}

    # 匹配0次
    # 匹配整数 \d+
    # 小数  \d+\.\d+
    # 整数或者小数：\d+\.?\d*,但是这个匹配的整数或者小数是不完全正确的。
    # 因为会出现小数点存在，但是后面的小数不存在的结果，这样是不合理的。
    # 所以，我们使用分组的知识，来实现准确的匹配整数和小数。
    # 分组的作用:\d+(\.\d+)?

    # 1.匹配手机号码
    # 第一位：1  第二位：3-9  总共11位
    # 判读用户输入的内容是否合法，如果用户输入的对的就能查到结果，如果输入是不对的，那么久查找不到结果。
    # 我写的答案是这样的：^1[3-9][\d]{9}$  匹配的电话号码例如是：18870325354

    # 2.从一个大文件中找到所有符合规则的手机号码的内容。
    # 1[3-9][\d]{9}，那么就会匹配到所有的手机号码。

    # 贪婪匹配和惰性匹配

    # 贪婪匹配
    # 在量词范围允许的情况下，尽量多的匹配内容。就是我们说的贪婪匹配。
    # 贪心算法和回溯算法。\d{3,}6  187246693634973618728  匹配出来的结果为：1872466936349736，把所有的6都匹配到
    # .*x 表示匹配任意字符， 任意多次数，但是遇到最后一个x才停下来。

    # 惰性匹配（非贪婪匹配）(在量词后面加个问好，就有原来的贪婪匹配，变成了非贪婪匹配)
    # 在量词范围允许的情况下，尽量少的匹配内容。就是我们说的惰性匹配。
    # 元字符 量词 ??
    # \d{3,}?6  187246693634973618728  匹配出来的结果为：187246  匹配第一个6就停下来。
    # 1\d??8  这里面的前面一个问好是表示的是量词，后面一个问好表示的是惰性匹配。匹配的结果为18。如果没有后面的?，那么匹配到的结果为188。
    # .*?x  表示匹配任意字符， 任意多次数，但是一旦遇到x就停下来。
    # .+?x  匹配任意字符，内容至少1次，遇到x就停止。
    # 转义符
        # 原本有特殊意义的字符，到了表达它本身的意义的时候，需要转义\
        # 有一些有特殊意义的内容，放在字符组[]中，会取消它的特殊意义,这个是对于一部分字符是有效的。
            # [. ()] [* + ?] 所有的内容在字符组中会取消它的特殊的意义。
            # [a\-c] -在字符组中表示范围，如果不希望它表示范围，需要转义，放在字符组的最前面，或者字符组的最后面。
# 在正则表达式中能够帮助我们表示匹配的内容的符号都是正则表达式中的元字符


# 正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

# 18/15位的身份证号
# 15
    # 1-9  15
# 18
    # 1-9 16 0-9/X

# 要把元素多的放在前面，元素少的放在后面
# 我给出的答案是：([1-9][\d]{16}[0-9|x])|([1-9][\d]{14})  ([1-9][\d]{16}[\d|x])|([1-9][\d]{14})  [1-9][\d]{16}[\d|x]|[1-9][\d]{14}   ^([1-9][\d]{16}[\d|x]|[1-9][\d]{14})$
# ^[1-9][\d]{16}[\d|x]$|^[1-9][\d]{14}$

# 还有一种更加高级的做法，因为前面15位是重叠的。这里面用到了贪婪匹配的知识。
# ^([1-9][\d]{14})(\d{2}[\d|x])?$
# ^([1-9][\d]{14})([\d]{2}[\d|x])?$

# 匹配的字符串为：371392199954820141  37139219995482014x
# 匹配到的结果为：371392199954820141  37139219995482014x

3)re模块下的常用方法

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())  #结果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果

# findAll 和search和分组之间的关系。
# 关系的结果如下所示：
# findAll 还是按照完整的正则表达式进行匹配，显示所有匹配到的内容，但是只是总是只显示括号里匹配到的内容
# search 还是按照完整的正则表达式进行匹配，显示也显示匹配到的第一个内容，但是我们可以通过给group方法参数
# 来获取具体文组中的内容。

# 如下所示的代码：
import re

ret = re.findall('\d+','1970ash93010uru')
print(ret) # ['1970', '93010'],输出的结果为列表

ret = re.search('\d+','1970ash93010uru')
print(ret) # <re.Match object; span=(0, 4), match='1970'>
# ret是一个对象，数学类的对象。
if ret:
    print(ret.group()) # 1970 得到的是第一个匹配的值


# 预习一个现象并且找到答案 - 分组有关系()
# ret = re.findall('9(\d)\d','1970ash93010uru')
# print(ret) # ['7', '3']
#
# ret = re.findall('9(\d)(\d)','1970ash93010uru')
# print(ret) # [('7', '0'), ('3', '0')]
#
#
# ret = re.search('9(\d)(\d)','1970ash93010uru')
# print(ret) # <re.Match object; span=(1, 4), match='970'>
# if ret:
#     print(ret.group()) # 970 什么参数也没有写，这里的默认参数为0
#     print(ret.group(0)) # 970
#     print(ret.group(1)) # 7
#     print(ret.group(2))# 0


# findall
    # 取所有符合条件的，优先显示分组中的
# search
    # 只取第一个符合条件的，没有优先显示这件事儿
    # 得到的结果是一个变量
        # 变量.group()的结果 完全和 变量.group(0)的结果一致。
        # 变量.group(n)的形式来指定获取第n个分组中匹配到的内容。

import re
# 为什么在search中不需要分组优先，而在findall中需要？
# findAll加上括号是为了对真正需要的内容进行提取筛选。
# ret = re.findall('<\w+>\w+</\w+>','<h1>adqdqhdnnsdjne123717kjsdkja</h1>')
# print(ret) # 输出的结果为：['<h1>adqdqhdnnsdjne123717kjsdkja</h1>']
# ret = re.findall('<\w+>(\w+)</\w+>','<h1>adqdqhdnnsdjne123717kjsdkja</h1>')
# print(ret) # 输出的结果为：['adqdqhdnnsdjne123717kjsdkja']
#
# # search
# ret = re.search('<\w+>(\w+)(</\w+>)','<h1>adqdqhdnnsdjne123717kjsdkja</h1>')
# print(ret.group())
# print(ret.group(1))
# # 输出的结果为：
# # <h1>adqdqhdnnsdjne123717kjsdkja</h1>
# # adqdqhdnnsdjne123717kjsdkja
# print(ret.group(2)) # </h1>

# 为什么要用分组，以及findall的分组优先到底有什么好处？
exp = '2-3*(5+6)'
# a+b 或者a-b 并且计算他们的结果
ret = re.search('(\d+)[+](\d+)',exp)
print(ret)
# print(ret.group(0))
# print(ret.group(1))
# print(ret.group(2))
#  ret.group()得到的是一个字符串
a = int(ret.group(1))
b = int(ret.group(2))
print(a+b) # 11

# 如果我们要查找的内容在一个复杂的环境中
# 我们要查的内容并没有一个突出的，与众不同的特点，甚至会和杂乱的数据混合在一起
# 这个时候我们就需要把所有的数据都统计出来，然后对这个数据进行筛选，把我们真正需要的数据对应的正则表达式用()圈起来
# 这样我们就可以筛选出真正需要的数据了。


# 什么是爬虫
    # 通过代码获取到一个网页的源码
    # 要的是源码中嵌着的网页上的内容  ---获取信息
    # import requests
    # requests.get()

# 分组和findall的现象
    # 为什么要用分组？
        # 把想要的内容放在分组里，这样就可以方便的取到自己想要的内容


# 如何取消分组优先
    # 如果在写正则的时候由于不得已的原因 导致不要的内容也得写在分组里
    # 在括号中加入？和：  (?:)取消这个分组的优先显示。


# \d\d\d\w+?  123abc45678  匹配的结果为：123a  4567
# \d\d\d\w+?\d  123abc45678  匹配的结果为：123abc4

注意：

1 findall的优先级查询：

import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']

2 split的优先级查询

ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。
# split
ret = re.split('\d+','alex222wusir')
print(ret) # ['alex', 'wusir']
# 根据正则表达式的规则将alex222wusir，切成了两半，一半是alex，一半是wusir
ret = re.split('(\d+)','alex222wusir')
print(ret) # ['alex', '222', 'wusir'] 加了分组，会把切的内容保存下来。
ret = re.split('\d(\d)\d','alex222wusir')
print(ret) # ['alex', '2', 'wusir']
# print('123'.split('2')) #['1', '3']

3 sub、subn、match、compile、finditer方法使用

# sub
ret = re.sub('\d+','H','alex123wusir456')
# 将所有的数字都有H来替代。将所有匹配到的数字用字母H来替代。
print(ret) # alexHwusirH
ret = re.sub('\d+','H','alex123wusir456',1)# 表示只是替换一次
print(ret) # alexHwusir456

# subn
ret = re.subn('\d+','H','alex123wusir456')
print(ret) # ('alexHwusirH', 2) 返回的是一个元组，并且会告知替换了两次，替换的次数

# match---有一个特点，相当于人为的在前面添加了一个^的符号。必须开头的匹配到才可以
# 除了这个特点之外，其余和search是一样的。
ret = re.match('\d+','eval123taibai456') # 等价于 ret = re.match('^\d+','eval123taibai456')
# ret = re.search('^\d+','eval123taibai456')相等价
print(ret) # None
ret = re.match('\d+','123evaltaibai456')
print(ret) # <re.Match object; span=(0, 3), match='123'>
print(ret.group()) # 123

# 考虑三件事
# 1.功能
# 2.性能
        # 时间
            # 你要完成一个代码所需要执行的代码行数
            # 你在执行代码的过程中，底层程序是如何工作的
        # 空间
            # 是占用了宝贵的内存条资源
            # 影响程序的执行效率
# 3.用户体验

# compile(重点)---节省代码时间的工具
    # re.findall('\d+','aigs19738sah')
    # 假如同一个正则表达式要被使用多次
    # 节省了多次解析同一个正则表达式的时间
ret = re.compile('\d+')
res1 = ret.search('alex37176')
res2 = ret.findall('alex37176')
print(res1)
print(res2)
'''
输出的结果为：
<re.Match object; span=(4, 9), match='37176'>
['37176']
'''

# finditer(重点)---节省空间
# ret = re.findall('^\d+','eval123taibai456')
# 用这个方法，可以转换为迭代器，那么这样就可以减少内存的负担，节省空间。
ret = re.finditer('\d+','agkslak018039')
print(ret) # <callable_iterator object at 0x000001F74D178B88>
for i in ret:
    print(i) # <re.Match object; span=(7, 13), match='018039'>
    print(i.group()) # 018039

ret = re.finditer('\d+','44988agkslak018039assda45646adad1343553355adsda')
print(ret) # <callable_iterator object at 0x000001F74D178B88>
for i in ret:
    print(i.group())
'''
<callable_iterator object at 0x000001D5D06487C8>
44988
018039
45646
1343553355
'''

# 即节省时间，有节省空间，先compile（如果没有重复使用同一个正则表达式，那么也不能节省时间），后finditer。
# 在结果集很多的时候，我们用finditer,这样可以节省空间
ret = re.compile('\d+')
res = ret.finditer('44988agkslak018039assda45646adad1343553355adsda')
for i in res:
    print(i.group())
'''
输出的结果如下：
44988
018039
45646
1343553355
这样做既可以节省时间，而且还可以节省空间。
'''

(10）shutil模块

import shutil

# 拷贝文件
# shutil.copy2('原文件', '现文件')
# shutil.copy2('file', 'temp')

# 拷贝目录
# shutil.copytree("原目录", "新目录", ignore=shutil.ignore_patterns("*.pyc"))
# shutil.copytree("/Users/jingliyang/PycharmProjects/面试题/常用模块/logging模块", "logging模块2", ignore=shutil.ignore_patterns("__init__.py"))

# 删除目录
# shutil.rmtree("temp", ignore_errors=True)
# shutil.rmtree("logging模块2", ignore_errors=True)

# 移动文件/目录
# shutil.move("logging模块", "logging2", copy_function=shutil.copy2)

# 获取磁盘使用空间
# total, used, free = shutil.disk_usage(".")
# print("当前磁盘共: %iGB, 已使用: %iGB, 剩余: %iGB"%(total / 1073741824, used / 1073741824, free / 1073741824))

# 压缩文件
# shutil.make_archive('压缩后文件夹的名字', 'zip','待压缩的文件夹路径')
# shutil.make_archive('logging2', 'zip','/Users/jingliyang/PycharmProjects/面试题/常用模块/随机数')

# 解压文件
# shutil.unpack_archive('zip文件的路径.zip'，'解压到目的文件夹路径')
# shutil.unpack_archive('/Users/jingliyang/PycharmProjects/面试题/常用模块/shutil模块/logging2.zip','/Users/jingliyang/PycharmProjects/面试题/常用模块/shutil模块/tmp')

(11）xml模块(了解)

xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，
大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。
现在这种格式的文件比较少了，但是还是存在的所以大家简单了解一下，以备不时之需。

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml数据

# 增删改查
# 在进行操作之前，都应该进行这两步：

# import xml.etree.ElementTree as ET
# tree = ET.parse('a.xml')  # 形成树形结构
# root = tree.getroot()  # 得到树的根系
# print(root)
# 循环打印：
# for i in root:
#     print(i)
# <Element 'country' at 0x00000196B51191D8>
# <Element 'country' at 0x00000196B5124B88>
# <Element 'country' at 0x00000196B5124D18>

# 所有的增删改查都是基于这个root根系去操作

# 查：
# 1,全文搜索 year 将所有的year标签全部找
# print(root.iter('year'))
# print([i for i in root.iter('year')])
# 2,只找第一个，找到就返回
# print(root.find('country'))
# 3,在root的子节点找，找所有的
# print(root.findall('country'))

# 练习
# 找到标签也可以找到标签相应的内容：tag,attrib,text

# 1,找所有的rank标签，以及 attrib 和 text (这里利用列表推导式比较方便)
# print([i for i in root.iter('rank')])
# [<Element 'rank' at 0x000001367D0D49F8>, <Element 'rank' at 0x000001367D0D4BD8>, <Element 'rank' at 0x000001367D0D4D68>]
# print([i.attrib for i in root.iter('rank')])
# [{'updated': 'yes'}, {'updated': 'yes'}, {'updated': 'yes'}]
# print([i.text for i in root.iter('rank')])  # ['2', '5', '69']

# 2,找到第二个country的 neighbor标签以及他的属性
# print([tag for tag in root.findall('country')][1].find('neighbor').attrib)
# {'direction': 'N', 'name': 'Malaysia'}


# 增 append
# import xml.etree.ElementTree as ET
# tree = ET.parse('a.xml')  # 形成树形结构
# root = tree.getroot()  # 得到树的根系

# 给 year 大于2010年的所有标签下面添加一个month标签，属性为name:month 内容为30days

# for country in root.findall('country'):
#     for year in country.findall('year'):
#         if int(year.text) > 2010:
#             month = ET.Element('month')
#             month.text = '30days'
#             month.attrib = {'name': 'month'}
#             country.append(month)
# tree.write('b.xml')

#改

# import xml.etree.ElementTree as ET
# tree = ET.parse('a.xml')  # 形成树形结构
# root = tree.getroot()  # 得到树的根系
# 对所有的year属性以及值进行修改
# for node in root.iter('year'):
#     new_year=int(node.text)+1
#     node.text=str(new_year)
#     node.set('updated','yes')
#     node.set('version','1.0')
# tree.write('test.xml')


# 删
# import xml.etree.ElementTree as ET
# tree = ET.parse('a.xml')  # 形成树形结构
# root = tree.getroot()  # 得到树的根系
#
# # 将 rank值大于50的country标签删除
# for country in root.findall('country'):
#    rank = int(country.find('rank').text)
#    if rank > 50:
#      root.remove(country)
#
# tree.write('output.xml')

import xml.etree.ElementTree as ET
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

(12）subprocess模块(了解)

 1 import  subprocess
 2 
 3 '''
 4 sh-3.2# ls /Users/egon/Desktop |grep txt$
 5 mysql.txt
 6 tt.txt
 7 事物.txt
 8 '''
 9 
10 res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
11 res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,
12                  stdout=subprocess.PIPE)
13 
14 print(res.stdout.read().decode('utf-8'))
15 
16 
17 #等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
18 res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)
19 print(res1.stdout.read().decode('utf-8'))
20 
21 
22 #windows下:
23 # dir | findstr 'test*'
24 # dir | findstr 'txt$'
25 import subprocess
26 res1=subprocess.Popen(r'dir C:\Users\Administrator\PycharmProjects\test\函数备课',shell=True,stdout=subprocess.PIPE)
27 res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
28                  stdout=subprocess.PIPE)
29 
30 print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码#举例说明：
import subprocess

obj = subprocess.Popen('dir',
                 shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                       
                )

print(obj.stdout.read().decode('gbk'))  # 正确命令
print(obj.stderr.read().decode('gbk'))  # 错误命令

# shell: 命令解释器，相当于调用cmd 执行指定的命令。
# stdout:正确结果丢到管道中。
# stderr:错了丢到另一个管道中。
# windows操作系统的默认编码是gbk编码。

(13）logging模块

1)为什么要写log？

1.log是为了排错

2.log用来做数据分析和操作审计

购物商城---数据库里

• 什么时间购买了什么商品
• 把哪些商品加入了购物车了

2)下面这些例子都是需要用到log，因为把任何东西都放进数据库是一个不明智的选择，会造成数据库存储的东西太多，同时也不方便管理，造成查询数据库变得复杂等等。

1.一个用户什么时间在什么地点登录了购物程序

2.搜索了哪些信息，多长时间被展示出来了。

3.什么时候关闭了软件

4.对哪些商品点进去看了

3)写日志有什么好处呢？

1.用来记录用户的行为---数据分析。做数据分析的内容，记录到log日志文件中。

2.用来记录用户的行为---操作审计。可以记录管理员的操作，清晰的知道管理员在后台做了什么操作。同时记录用户的操作行为，明确用户做了什么样的操作。

3.排查代码中的错误。做代码的排错，记录错误的结果出现的每一个环节，判断是哪个环节出现了问题，那么久可以找到出现错误的地方。（日志会记录输入的表达式是什么，返回的结果是什么）

import logging
import logging
# 输出内容是有等级的,默认处理warming级别以上的所有信息。
logging.debug('debug message')  # 调试
logging.info('info message')  # 信息	
logging.warning('warning message')  # 警告
logging.error('error message')  # 错误
logging.critical('critical message') # 批判性的
'''
输出的结果如下所示：
WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message
'''

1)函数式简单配置

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message') 

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

灵活配置日志级别，日志格式，输出位置:

# 输出到屏幕
import logging

file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s[line:%(lineno)d] -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
)
logging.warning('warning message test2')
logging.error('error message test2')
logging.critical('critical message test2')
logging.error('你好')

'''
输出日志的结果为：
2020-07-07 10:47:30 AM - root - WARNING[line:20] -04logging_demo:  warning message test2
2020-07-07 10:47:30 AM - root - ERROR[line:21] -04logging_demo:  error message test2
2020-07-07 10:47:30 AM - root - CRITICAL[line:22] -04logging_demo:  critical message test2
2020-07-07 10:47:30 AM - root - ERROR[line:23] -04logging_demo:  你好
'''

# 输出到文件
import logging

file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s[line:%(lineno)d] -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[file_handler,],
    level=logging.DEBUG # 设置一下级别
)
logging.warning('warning message test2')
logging.error('error message test2')
logging.critical('critical message test2')
logging.error('你好')
'''
文件中得到的输出的结果如下所示：
2020-07-07 10:52:25 AM - root - WARNING[line:20] -04logging_demo:  warning message test2
2020-07-07 10:52:25 AM - root - ERROR[line:21] -04logging_demo:  error message test2
2020-07-07 10:52:25 AM - root - CRITICAL[line:22] -04logging_demo:  critical message test2
2020-07-07 10:52:25 AM - root - ERROR[line:23] -04logging_demo:  你好
'''

# 同时向文件和屏幕上输出
import logging

file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',) # 加上这句话就可以输出到文件了
sh = logging.StreamHandler() # 加上这句话就可以在屏幕上输出了
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s[line:%(lineno)d] -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[file_handler,sh],
    level=logging.DEBUG
)
logging.warning('warning message test2')
logging.error('error message test2')
logging.critical('critical message test2')
logging.error('你好')

日志切割

import time
import logging
from logging import handlers

sh = logging.StreamHandler()

# 下面的两句，rh和fh是用来做日志的切割
rh = handlers.RotatingFileHandler('myapp.log', maxBytes=1024,backupCount=5) # 按照文件大小切割
fh = handlers.TimedRotatingFileHandler(filename='x2.log', when='s', interval=5, encoding='utf-8') # 按照时间大小切割

logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[fh,sh,rh],
    level=logging.ERROR
)

for i in range(1,100000):
    time.sleep(1)
    logging.error('KeyboardInterrupt error %s'%str(i))

配置参数：

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行，在哪一行打印日志。
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

2)logger对象配置

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8') 
# 再创建一个handler，用于输出到控制台 
ch = logging.StreamHandler() 
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter) 
ch.setFormatter(formatter) 
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 
logger.addHandler(ch) 

logger.debug('logger debug message') 
logger.info('logger info message') 
logger.warning('logger warning message') 
logger.error('logger error message') 
logger.critical('logger critical message')

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过fh.setLevel(logging.Debug)单对文件流设置某个级别。

(14）configparser模块(了解)

该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节（section），每个节可以有多个参数（键=值）。

1)创建文件

来看一个好多软件的常见文档格式如下：

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
  
[bitbucket.org]
User = hg
  
[topsecret.server.com]
Port = 50022
ForwardX11 = no

如果想用python生成一个这样的文档怎么做呢？

import configparser

config = configparser.ConfigParser()

config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}

config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}

with open('example.ini', 'w') as configfile:
   config.write(configfile)

2)查找文件

import configparser

config = configparser.ConfigParser()

#---------------------------查找文件内容,基于字典的形式

print(config.sections())        #  []

config.read('example.ini')

print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']

print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True

print(config['bitbucket.org']["user"])  # hg

print(config['DEFAULT']['Compression']) #yes

print(config['topsecret.server.com']['ForwardX11'])  #no


print(config['bitbucket.org'])          #<Section: bitbucket.org>

for key in config['bitbucket.org']:     # 注意,有default会默认default的键
    print(key)

print(config.options('bitbucket.org'))  # 同for循环,找到'bitbucket.org'下所有键

print(config.items('bitbucket.org'))    #找到'bitbucket.org'下所有键值对

print(config.get('bitbucket.org','compression')) # yes       get方法Section下的key对应的value

3)增删改操作

import configparser

config = configparser.ConfigParser()

config.read('example.ini')

config.add_section('yuan')

config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")

config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')

config.write(open('new2.ini', "w"))

---

1. 1-9 ↩︎

2. 1-9 ↩︎