1 ```python
  2 知识脉络: 
  3 # 在python中使用正则表达式
  4     # 转义符 : 在正则中的转义符 \ 在python中的转义符
  5     # re模块
  6         # findall search match
  7         # sub subn split
  8         # compile finditer
  9     # python中的正则表达式
 10         # findall 会优先显示分组中的内容,要想取消分组优先,(?:正则表达式)
 11         # split 遇到分组 会保留分组内被切掉的内容
 12         # search 如果search中有分组的话,通过group(n)就能够拿到group中的匹配的内容
 13 # 正则表达式进阶
 14     # 分组命名
 15         # (?P<name>正则表达式) 表示给分组起名字
 16         # (?P=name)表示使用这个分组,这里匹配到的内容应该和分组中的内容完全相同
 17     # 通过索引使用分组
 18         # \1 表示使用第一组,匹配到的内容必须和第一个组中的内容完全相同
 19 ```
 20 
 21 
 22 
 23 2021/11/15学习内容
 24 
 25 1.学习大纲:        a. re模块  b. 常用的方法
 26 
 27 ​                            c. python中正则表达式的特点
 28 
 29 ​                            d. time模块
 30 
 31 ​                            e. random模块
 32 
 33 
 34 
 35 
 36 
 37 a. re 模块      (1)  匹配   findall search match
 38 
 39 ​                       (2)  替换   sub  subn
 40 
 41 ​                       (3)  切割   split
 42 
 43 ​                       (4)  进阶方法  compile  finditer
 44 
 45 ​                                                            (1)    匹配.  
 46 
 47 ```python
 48 import re
 49 # 匹配一 findall  (*****)
 50 re.findall('正则表达式', '字符串')    
 51 返回值类型:'列表' 返回值个数:1个 返回值内容:如果匹配上了就返回一个列表对象如果匹配不上返回空列表
 52 eg1:
 53     ret1 = re.findall('\d+', '451355saddf5562')  # 第一个是正则表达式,第二个参数是
 54     print(ret1)
 55 结果:  ['451355', '5562']   返回的是一个列表 
 56 ```
 57 
 58 ```python
 59 import re
 60 # 匹配二  search   (*****)
 61 re.search('正则表达式', '字符串')
 62 返回值类型: 正则表达式的结果对象 返回值个数: 1个  返回值内容: 如果匹配上了就返回对象 如果匹配不上就返回None
 63 eg2:
 64     ret2 = re.search('\d+', '45132132asdhask13212')
 65     print(ret2)
 66     print(ret2.group())
 67 结果: <re.Match object; span=(10, 11), match='d'>  返回的是一个(正则匹配结果的)对象
 68 结果: 45132132   # 只匹配一次结果,惰性机制
 69 eg3:  ret3 = re.search('\d+', 'sdferer')
 70       print(ret3)
 71       if ret3:print(ret3.group())
 72 结果: None  因为没有匹配到结果,所有返回None
 73 ```
 74 
 75 ```python
 76 import re
 77 # 匹配三 match    (**)
 78 re.match('正则表达式', '字符串')
 79 相当于 在search前面加^(只从开头位置匹配)  可以通过group()函数来查看返回的值 只匹配一次
 80 ```
 81 
 82 ​                                                                  (2)  替换
 83 
 84 ```python
 85 import re
 86 # 替换一. sub (***)  replace   'sads021'.replace('021', 'h')  将021替换成h
 87 re.sub('替换的方式:正则表达式', '替换的结果','要替换字符串','次数') 
 88          # 如果不指定次数 默认 全部替换
 89 re.subn('正则表达式', '要替换的内容','字符串') 返回一个元组 ('字符串', '替换的次数') 相当于返回符合的个数
 90 eg1:    
 91     ret = re.sub('\d+', 'h', 'sads021')   将021替换成h
 92     print(ret)
 93 结果:  sadsh       将字符串中的021替换成h  
 94 eg2:
 95     ret = re.sub('\d+', 'h', 'sads021sdaf021dsf021')   
 96     print(ret)
 97 结果:  sadshsdafhdsfh  将字符串中的021全部替换h
 98 eg3:
 99     ret = re.subn('\d+','h','sdf1313sfa564q6fads')
100     print(ret)
101 结果:  ('sdfhsfahqhfads', 3)  返回的是一个元组 ('新的字符串', '替换的次数')
102 ```
103 
104 ​                                                                  (3)  切割
105 
106 ```python
107 import re
108 # 切割  split(***)
109 返回的是一个列表
110 eg1:
111     ret = re.split('\d','alex83egon20taibai40')
112     print(ret)
113 结果: ['alex', '', 'egon', '', 'taibai', '', ''] 
114 eg2: 
115     print('yuxin/23/'.split('/'))
116 结果: ['yuxin', '23', '']
117 eg3: 
118     ret = re.split('\d+','alex83egon20taibai40')
119     print(ret)
120 结果:  ['alex', 'egon', 'taibai', ''] 
121 eg4:
122     ret = re.split('(\d+)','alex83egon20taibai40')
123     print(ret) 
124 结果: ['alex', '83', 'egon', '20', 'taibai', '40', '']
125     # 对比eg3和eg4 将正则表达式用分组阔起来 就可以显示切割的字符串
126 ```
127 
128 ​                                                                (4)  进阶方法
129 
130 ```python
131 # 进阶方法    - 爬虫\自动化开发
132 # compile ***** 时间效率
133 # re.findall('-0\.\d+|-[1-9]+(\.\d+)?','alex83egon20taibai40')  --> python解释器能理解的代码 --> 执行代码
134 # ret = re.compile('-0\.\d+|-[1-9]\d+(\.\d+)?')
135 # res = ret.search('alex83egon-20taibai-40')
136 # print(res.group())
137 # 节省时间 : 只有在多次使用某一个相同的正则表达式的时候,这个compile才会帮助我们提高程序的效率
138 ```
139 
140 ```python
141 # finditer ***** 空间效率
142 # print(re.findall('\d','sjkhkdy982ufejwsh02yu93jfpwcmc'))
143 # ret = re.finditer('\d','sjkhkdy982ufejwsh02yu93jfpwcmc')
144 # for r in ret:
145 #     print(r.group())
146 ```
147 
148 c. python中正则表达式的特点
149 
150 ```python
151 # 分组遇到findall
152 import re
153 eg1:
154     ret = re.findall('-0\.\d+|-[1-9]\d*(\.\d+)?','-1asdada-200')
155     print(ret)
156 结果:  ['', '']  当正则表达式中的分组遇到了findall会优先显示分组内匹配的内容 忽略其他分组外的匹配内容
157 eg2:
158     ret = re.findall('www.(baidu|oldboy).com','www.oldboy.com')
159     print(ret)
160 结果:    ['oldboy'] 只会优先显示分组内匹配的内容,忽略分组外匹配的内容
161 # 如果解决这个问题  要求eg2中返回 www.oldboy.com
162 eg3:
163     ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
164     print(ret)
165 结果: ['www.oldboy.com']  只需要在分组括号内前面加?: (?:....) 就可以取消分组优先显示
166 ```
167 
168 ```python
169 # 分组遇见search
170 # ret = re.search('\d+(.\d+)(.\d+)(.\d+)?','1.2.3.4-2*(60+(-40.35/5)-(-4*3))')
171 # print(ret.group())  # 没有参数默认返回 整个匹配值
172 # print(ret.group(1))
173 # print(ret.group(2))
174 # print(ret.group(3))
175 # group(参数) 参数对应的就是读取括号 一一对应
176 ```
177 
178 ​                                                                    分组练习
179 
180 ```python
181 import re
182 eg1:
183     ret = re.findall(r"\d+(?:\.\d+)?","1-2*(60+(-40.35/5)-(-4*3))")
184     print(ret)
185 结果: ['1', '2', '60', '40.35', '5', '4', '3']  但是我们需求是只要整数
186 eg2:
187     ret = re.find(r"\d+(?:\.\d+)?|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
188     print(ret)
189     ret.remove('')
190     print(ret)
191 结果:  ['1', '2', '60', '', '5', '4', '3']
192 结果:  ['1', '2', '60', '5', '4', '3']
193 eg3:
194     ret = re.findall('>(\w+)<',r'<a>wahaha<\a>')
195     print(ret)
196 结果:  ['wahaha']
197 eg4:
198     ret = re.search(r'<(\w+)>(\w+)</(\w+)>',r'<a>wahaha</b>')
199     print(ret.group())
200     print(ret.group(1))
201     print(ret.group(2))
202 结果 :  <a>wahaha</b>
203 结果 :  a
204 结果 :  wahaha  
205 ```
206 
207 ​                                                                         分组命名
208 
209 ```python
210 import re
211 eg1:
212     ret = re.search("<(?P<name>\w+)>\w+</(?P=name)>","<h1>hello</h1>")
213     print(ret.group('name'))
214 结果: h1    给分组命名了 保证了第一个分组和第三个分组内容一样   在分组前面 ?P 表示给分组命名
215 eg2:
216     ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
217     print(ret.group(1))
218 结果: h1             也可以使用\1  表示内容与第一个分组一致
219 eg3:
220     ret = re.search(r'<(?P<tag>\w+)>(?P<c>\w+)</(\w+)>',r'<a>wahaha</b>')
221     print(ret.group())
222     print(ret.group('tag'))
223     print(ret.group('c'))
224 结果:  <a>wahaha</b>
225 结果:   a
226 结果:   wahaha       也可以使用group('分组名字')来调用  
227     
228 ```
229 
230 ​                                 推荐书籍  <<正则指引>>