我们连接 Linux 来实现正则表达式
一, Python3 正则表达式
正则表达式是一个特殊的字符序列, 它能帮助你方便的检查一个字符串是否与某种模式匹配.
Python 自 1.5 版本起增加了 re 模块, 它提供 Perl 风格的正则表达式模式.
re 模块使 Python 语言拥有全部的正则表达式功能.
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象. 该对象拥有一系列方法用于正则表达式匹配和替换.
re 模块也提供了与这些方法, 功能完全一致的函数, 这些函数使用一个模式字符串做为它们的第一个参数.
本章节主要介绍 Python 中常用的正则表达式处理函数, 如果你对正则表达式不了解, 可以查看我们的 正则表达式 - 教程.
1,re.split
split 方法按照能够匹配的子串将字符串分割后返回列表, 它的使用形式如下:
re.split(pattern, string[, maxsplit=0, flags=0])
参数:
参数 | 描述 |
---|---|
pattern | 匹配的正则表达式 |
string | 要匹配的字符串。 |
maxsplit | 分隔次数,maxsplit=1 分隔一次,默认为 0,不限制次数。 |
flags | 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。参见: 正则表达式修饰符 - 可选标志 |
例子
- import re
- # fLags=re.IGNORECASE: 忽略大小写
- data = 'Last login: Tue Mar 31 17:56:11 2020 from 192.168.1.80'
- new_data = re.split('[:.]\s*', data)
- print(new_data)
- print(data.split(':'))
以上实例输出结果如下:
- ['Last login', 'Tue Mar 31 17', '56', '11 2020 from 192', '168', '1', '80']
- ['Last login', 'Tue Mar 31 17:56:11 2020 from 192.168.1.80']
以下是正则表达式的基本语法:
模式 | 描述 |
---|---|
^ | 匹配字符串的开头 |
$ | 匹配字符串的末尾。 |
. | 匹配任意字符,除了换行符,当 re.DOTALL 标记被指定时,则可以匹配包括换行符的任意字符。 |
[...] | 用来表示一组字符, 单独列出:[amk] 匹配 ‘a‘,‘m‘或‘k‘ |
[^...] | 不在 [] 中的字符:[^abc] 匹配除了 a,b,c 之外的字符。 |
re* | 匹配 0 个或多个的表达式。 |
re+ | 匹配 1 个或多个的表达式。 |
re? | 匹配 0 个或 1 个由前面的正则表达式定义的片段,非贪婪方式 |
re{ n} | 匹配 n 个前面表达式。例如,"o{2}" 不能匹配 "Bob" 中的 "o",但是能匹配 "food" 中的两个 o。 |
re{ n,} | 精确匹配 n 个前面表达式。例如,"o{2,}" 不能匹配 "Bob" 中的 "o",但能匹配 "foooood" 中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。 |
re{ n, m} | 匹配 n 到 m 次由前面的正则表达式定义的片段,贪婪方式 |
2, 特殊字符类
实例 | 描述 |
---|---|
. | 匹配除 "\n" 之外的任何单个字符。要匹配包括 ‘\n‘ 在内的任何字符,请使用象 ‘[.\n]‘ 的模式。 |
\d | 匹配一个数字字符。等价于 [0-9]。 |
\D | 匹配一个非数字字符。等价于 [^0-9]。 |
\s | 匹配任何空白字符,包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 |
\S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
\w | 匹配包括下划线的任何单词字符。等价于‘[A-Za-z0-9_]‘。 |
\W | 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]‘。 |
- # ?[a-zA-Z]+
- # ? 用来匹配单词前后可能出现的空格,[a-zA-Z]代表一个或多个英文字母
- # 匹配一个 IP 地址 192.168.1.80
- # [0-9]{
- 1,3
- }\.[0-9]{
- 1,3
- }\.[0-9]{
- 1,3
- }\.[0-9]{
- 1,3
- }
3,findall 函数
在字符串中找到正则表达式所匹配的所有子串, 并返回一个列表, 如果没有找到匹配的, 则返回空列表.
注意: match 和 search 是匹配一次 findall 匹配所有.
语法格式为:
re.findall(string[, pos[, endpos]])
参数:
string 待匹配的字符串.
pos 可选参数, 指定字符串的起始位置, 默认为 0.
endpos 可选参数, 指定字符串的结束位置, 默认为字符串的长度.
查找字符串中的所有数字:
- import re
- pattern = re.compile(r'\d+') # 查找数字
- result1 = pattern.findall('runoob 123 google 456')
- result2 = pattern.findall('run88oob123google456', 0, 10)
- print(result1)
- print(result2)
以上实例输出结果如下:
- ['123', '456']
- ['88', '12']
4,compile 函数
compile 函数用于编译正则表达式, 生成一个正则表达式 ( Pattern ) 对象, 供 match() 和 search() 这两个函数使用.
语法格式为:
re.compile(pattern[, flags])
参数:
pattern : 一个字符串形式的正则表达式
flags 可选, 表示匹配模式, 比如忽略大小写, 多行模式等, 具体参数为:
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为'.'并且包括换行符在内的任意字符('.'不包括换行符)
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性, 忽略空格和'#'后面的注释
例子 1
- >>>import re
- >>> pattern = re.compile(r'\d+') # 用于匹配至少一个数字
- >>> m = pattern.match('one12twothree34four') # 查找头部, 没有匹配
- >>> print( m )
- None
- >>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配, 没有匹配
- >>> print( m )
- None
- >>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配, 正好匹配
- >>> print( m ) # 返回一个 Match 对象
- <_sre.SRE_Match object at 0x10a42aac0>
- >>> m.group(0) # 可省略 0
- '12'
- >>> m.start(0) # 可省略 0
- 3
- >>> m.end(0) # 可省略 0
- 5
- >>> m.span(0) # 可省略 0
- (3, 5)
在上面, 当匹配成功时返回一个 Match 对象, 其中:
group([group1, ...])
方法用于获得一个或多个分组匹配的字符串, 当要获得整个匹配的子串时, 可直接使用 group() 或 group(0);
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引), 参数默认值为 0;
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引 + 1), 参数默认值为 0;
span([group]) 方法返回
- (start(group), end(group))
- .
例子 2
- import re
- # flags=re. IGNORECASE: 忽略大小写
- data = 'Linux 系统内置 Python 2.7.5, 我们安装了 Python 3.8.1.'
- print(re.findall( 'python [0-9]\.[0-9]\.[0-9]', data, flags=re.IGNORECASE))
- #
- re_obj = re.compile('python [0-9]\.[0-9]\.[0-9]', flags=re.IGNORECASE)
- print(re_obj.findall(data))
以上实例输出结果如下:
- ['Python 2.7.5', 'Python 3.8.1']
- ['Python 2.7.5', 'Python 3.8.1']
5, 测试 findall 和 compile 的读取速度
(1)Linux 生成数字文件
[[email protected] ~]# seq 10000> data.txt
(2)pycharm 创建 findall 和 compile 的读取 data.txt 的文件
- findall
- import re
- def main():
- pattern = "[0-9]+"
- with open('~/data.txt') as f:
- for line in f:
- re.findall(pattern, line)
- if __name__ == 'main':
- main()
- compile
- import re
- def main() :
- pattern = "[0-9]+"
- re_obj = re.compile(pattern)
- with open("~/data.txt") as f:
- for line in f:
- re_obj.findall(line)
- if __name__ == "main":
- main( )
(3)上传文件到 Linux
底部出现以下信息, 上传成功
(4)Linux 测试下载速度
进入上传的目录 / opt
- [[email protected] ~]# cd /opt/
- [[email protected] opt]# cd 练习
[[email protected] 练习]# ls
001.py findall.py compile.py
测试
[[email protected] 练习]# time python3 findall.py
- real 0m0.058s
- user 0m0.005s
- sys 0m0.029s
[[email protected] 练习]# time python3 compile.py
- real 0m0.018s
- user 0m0.014s
- sys 0m0.004s
经测试可看出 compile 读取的方式更快
二, 常用的 re 函数
- data = 'What is the difference between python 2.7.5 and Python 3.8.1 ?'
- import re
- print(re.findall('[0-9]\.[0-9]\.[0-9]',data))
- print(re.findall('python [0-9]\.[0-9]\.[0-9]',data))
- print(re.findall('Python [0-9]\.[0-9]\.[0-9]',data))
- print(re.findall('ython [0-9]\.[0-9]\.[0-9]',data))
- print(data.startswith('What'))
- print(data.endswith('?'))
- print(re.match('What',data))
- Word = "123 is one hender and twentyu-there"
- print(re.match('\d+',Word))
- r = re.match('\d+',Word)
- print(r)
- print(r.start())
- print(r.end())
- print(r.re)
- print(r.group())
- print(r.string)
- rr = re.finditer('[0-9]\.[0-9]\.[0-9]',data)
- print(rr)
- # print([r for r in rr])
- for it in rr:
- print(it.group(0))
以上实例输出结果:
- # 输出'x.x.x'类型的数字
- ['2.7.5', '3.8.1']
- # 输出'python x.x.x'类型的数字
- ['python 2.7.5']
- # 输出'Python x.x.x'类型的数字
- ['Python 3.8.1']
- # 输出'ython x.x.x'类型的数字
- ['ython 2.7.5', 'ython 3.8.1']
- # 查找 data 中是否有'What'
- True
- # 查找 data 中是否有'J'
- True
- # 查找 data 中是否有'What'
- <re.Match object; span=(0, 4), match='What'>
- # 查找 data 中是否有'数字字符'
- <re.Match object; span=(0, 3), match='123'>
- # 查找 data 中是否有'数字字符'
- <re.Match object; span=(0, 3), match='123'>
- # 匹配的子串在整个字符串中的起始位置
- 0
- # 匹配的子串在整个字符串中的结束位置
- 3
- # 获取 re 函数的类型
- re.compile('\\d+')
- # 获得一个或多个分组匹配的字符串
- 123
- # 匹配的字符串
- 123 is one hender and twentyu-there
- # 输出 rr
- <callable_iterator object at 0x000001B92D1613D0>
- # 一行一行输出 rr 文件的'x.x.x'类型的数字
- 2.7.5
- 3.8.1
(一)匹配类
1,re.match 函数
re.match 尝试从字符串的起始位置匹配一个模式, 如果不是起始位置匹配成功的话, match()就返回 none.
函数语法:
re.match(pattern, string, flags=0)
函数参数说明:
参数 | 描述 |
---|---|
pattern | 匹配的正则表达式 |
string | 要匹配的字符串。 |
flags | 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。参见: 正则表达式修饰符 - 可选标志 |
匹配成功 re.match 方法返回一个匹配的对象, 否则返回 None.
我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式.
匹配对象方法 | 描述 |
---|---|
group(num=0) | 匹配的整个表达式的字符串,group() 可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。 |
groups() | 返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。 |
- import re
- print(re.match('www', 'www.runoob.com').span()) # 在起始位置匹配
- print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配
以上实例输出结果:
- (0, 3) None
- import re
- line = "Cats are smarter than dogs"
- # .* 表示任意匹配除换行符 (\n,\r) 之外的任何单个或多个字符
- matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
- if matchObj:
- print ("matchObj.group() :", matchObj.group())
- print ("matchObj.group(1) :", matchObj.group(1))
- print ("matchObj.group(2) :", matchObj.group(2))
- else:
- print ("No match!!")
以上实例输出结果:
- matchObj.group() : Cats are smarter than dogs
- matchObj.group(1) : Cats
- matchObj.group(2) : smarter
2,compile 函数
compile 函数用于编译正则表达式, 生成一个正则表达式 ( Pattern ) 对象, 供 match() 和 search() 这两个函数使用.
语法格式为:
re.compile(pattern[, flags])
参数:
pattern : 一个字符串形式的正则表达式
flags 可选, 表示匹配模式, 比如忽略大小写, 多行模式等, 具体参数为:
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为'.'并且包括换行符在内的任意字符('.'不包括换行符)
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性, 忽略空格和'#'后面的注释
实例
- >>>import re
- >>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I) # re.I 表示忽略大小写
- >>> m = pattern.match('Hello World Wide Web')
- >>> print( m ) # 匹配成功, 返回一个 Match 对象
- <_sre.SRE_Match object at 0x10bea83e8>
- >>> m.group(0) # 返回匹配成功的整个子串
- 'Hello World'
- >>> m.span(0) # 返回匹配成功的整个子串的索引
- (0, 11)
- >>> m.group(1) # 返回第一个分组匹配成功的子串
- 'Hello'
- >>> m.span(1) # 返回第一个分组匹配成功的子串的索引
- (0, 5)
- >>> m.group(2) # 返回第二个分组匹配成功的子串
- 'World'
- >>> m.span(2) # 返回第二个分组匹配成功的子串索引
- (6, 11)
- >>> m.groups() # 等价于 (m.group(1), m.group(2), ...)
- ('Hello', 'World')
- >>> m.group(3) # 不存在第三个分组
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- IndexError: no such group
在上面, 当匹配成功时返回一个 Match 对象, 其中:
group([group1, ...])
方法用于获得一个或多个分组匹配的字符串, 当要获得整个匹配的子串时, 可直接使用 group() 或 group(0);
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引), 参数默认值为 0;
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引 + 1), 参数默认值为 0;
span([group]) 方法返回
- (start(group), end(group))
- .
3,re.search 方法
re.search 扫描整个字符串并返回第一个成功的匹配.
函数语法:
re.search(pattern, string, flags=0)
函数参数说明:
参数 | 描述 |
---|---|
pattern | 匹配的正则表达式 |
string | 要匹配的字符串。 |
flags | 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。参见: 正则表达式修饰符 - 可选标志 |
匹配成功 re.search 方法返回一个匹配的对象, 否则返回 None.
我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式.
匹配对象方法 | 描述 |
---|---|
group(num=0) | 匹配的整个表达式的字符串,group() 可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。 |
groups() | 返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。 |
实例
- import re
- print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配
- print(re.search('com', 'www.runoob.com').span()) # 不在起始位置匹配
以上实例输出结果:
(0, 3) (11, 14)
4,re.match 与 re.search 的区别
re.match 只匹配字符串的开始, 如果字符串开始不符合正则表达式, 则匹配失败, 函数返回 None, 而 re.search 匹配整个字符串, 直到找到一个匹配.
- import re
- line = "Cats are smarter than dogs"
- matchObj = re.match( r'dogs', line, re.M|re.I)
- if matchObj:
- print ("match --> matchObj.group() :", matchObj.group())
- else:
- print ("No match!!")
- matchObj = re.search( r'dogs', line, re.M|re.I)
- if matchObj:
- print ("search --> matchObj.group() :", matchObj.group())
- else:
- print ("No match!!")
以上实例输出结果:
- No match!!
- search --> matchObj.group() : dogs
5, 参数:
参数 | 描述 |
---|---|
pattern | 匹配的正则表达式 |
string | 要匹配的字符串。 |
flags | 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。参见: 正则表达式修饰符 - 可选标志 |
实例
- import re
- it = re.finditer(r"\d+","12a32bc43jf3")
- for match in it:
- print (match.group() )
输出结果:
12 32 43 3
(二)修改类
1, 检索和替换
Python 的 re 模块提供了 re.sub 用于替换字符串中的匹配项.
语法:
re.sub(pattern, repl, string, count=0, flags=0)
参数:
pattern : 正则中的模式字符串.
repl : 替换的字符串, 也可为一个函数.
string : 要被查找替换的原始字符串.
count : 模式匹配后替换的最大次数, 默认 0 表示替换所有的匹配.
flags : 编译时用的匹配模式, 数字形式.
前三个为必选参数, 后两个为可选参数.
- import re
- phone = "2004-959-559 # 这是一个电话号码"
- # 删除注释
- num = re.sub(r'#.*$', "", phone)
- print ("电话号码 :", num)
- # 移除非数字的内容
- num = re.sub(r'\D', "", phone)
- print ("电话号码 :", num)
输出结果:
电话号码 : 2004-959-559
电话号码 : 2004959559
repl 参数是一个函数
以下实例中将字符串中的匹配的数字乘于 2:
- import re
- # 将匹配的数字乘于 2
- def double(matched):
- value = int(matched.group('value'))
- return str(value * 2)
- s = 'A23G4HFD567'
- print(re.sub('(?P<value>\d+)', double, s))
输出结果:
- A46G8HFD1134
- 2,re.split
split 方法按照能够匹配的子串将字符串分割后返回列表, 它的使用形式如下:
re.split(pattern, string[, maxsplit=0, flags=0])
参数 | 描述 |
---|---|
pattern | 匹配的正则表达式 |
string | 要匹配的字符串。 |
maxsplit | 分隔次数,maxsplit=1 分隔一次,默认为 0,不限制次数。 |
flags | 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。参见: 正则表达式修饰符 - 可选标志 |
- >>>import re
- >>> re.split('\W+', 'runoob, runoob, runoob.')
- ['runoob', 'runoob', 'runoob', '']
- >>> re.split('(\W+)', 'runoob, runoob, runoob.')
- ['',' ','runoob',', ','runoob',', ','runoob','.','']
- >>> re.split('\W+', 'runoob, runoob, runoob.', 1)
- ['','runoob, runoob, runoob.']
- >>> re.split('a*', 'hello world') # 对于一个找不到匹配的字符串而言, split 不会对其作出分割
- ['hello world']
(三)贪婪和非贪婪模式
1, 概念
首先举个例子:
- example = "abbbbbbc"
- pattern = re.compile("ab+")
贪婪模式: 正则表达式一般趋向于最大长度匹配, 也就是所谓的贪婪匹配. 如上面使用模式 pattern 匹配字符串 example, 匹配到的结果就是 "abbbbbb" 整个字符串.
非贪婪模式: 在整个表达式匹配成功的前提下, 尽可能少的匹配. 如上面使用模式 pattern 匹配字符串 example, 匹配到的结果就只是 "ab" 整个字符串.
2, 使用方法
在 python 中默认采用的是贪婪模式, 使用非贪婪模式的话, 只需要在量词后面直接加上一个问号 "?".
在第一篇文章中介绍了正则表达式当中的量词一共有五种:
3, 原理分析
在正则表达式中一般默认采用的是贪婪模式, 在上面的例子当中已经匹配到了 "ab" 时已经可以使整个表达式匹配成功, 但是由于采用的是贪婪模式, 所以还需要往后继续匹配, 检查时候存在更长的可以匹配成功的字符串. 一直到匹配到最后一个 "b" 的时候, 后面已经没有可以成功匹配的字符串了, 匹配结束. 返回匹配结果 "abbbbbb".
所以, 我们可以将贪婪模式理解为: 在整个表达式匹配成功的前提下, 尽可能多的匹配.
非贪婪模式也就是将我们例子中的正则表达式 "ab+" 改为 "ab+?", 当匹配到 "ab" 时, 已经匹配成功, 直接结束匹配, 不在向后继续尝试, 返回匹配成功的字符串 "ab".
所以, 我们可以将非贪婪模式理解为: 在整个表达式匹配成功的前提下, 尽可能少的匹配
4, 实例
- import re
- text = 'Beautifulis better than ugly. Explicit is better than implicit.'
- print(re.findall('Beautifulis.*\.',text))
- print(re.findall('Beautifulis.*?\.',text))
输出结果:
- ['Beautifulis better than ugly. Explicit is better than implicit.']
- ['Beautifulis better than ugly.']
5, 总结
1. 从应用角度看贪婪与非贪婪
贪婪与非贪婪模式影响的是被量词修饰的子表达式的匹配行为, 贪婪模式在整个表达式匹配成功的前提下, 尽可能多的匹配; 而非贪婪模式在整个表达式匹配成功的前提下, 尽可能少的匹配.
2. 从匹配原理角度看贪婪与非贪婪
能达到同样匹配结果的贪婪与非贪婪模式, 通常是贪婪模式的匹配效率较高. 所有的非贪婪模式, 都可以通过修改量词修饰的子表达式, 转换为贪婪模式. 贪婪模式可以与固化分组结合, 提升匹配效率, 而非贪婪模式却不可以.
(四)Python3 replace()方法
描述
replace() 方法把字符串中的 old(旧字符串) 替换成 new(新字符串), 如果指定第三个参数 max, 则替换不超过 max 次.
语法
replace()方法语法:
str.replace(old, new[, max])
参数
old -- 将被替换的子字符串.
new -- 新字符串, 用于替换 old 子字符串.
max -- 可选字符串, 替换不超过 max 次
返回值
返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串, 如果指定第三个参数 max, 则替换不超过 max 次.
实例
以下实例展示了 replace()函数的使用方法:
- data = 'What is the difference between python 2.7.5 and Python 3.8.1 ?'
- print(data)
- import re
- r_data = data.replace('2.7.5','x.x.x')
- r_data2 = r_data.replace('3.8.1','x.x.x')
- print(r_data2)
- print(re.sub('[0-9]\.[0-9]\.[0-9]','x.x.x',data))
- print(data.split())
- print(re.split('[ .]+',data))
输出结果:
- What is the difference between python 2.7.5 and Python 3.8.1 ?
- What is the difference between python x.x.x and Python x.x.x ?
- What is the difference between python x.x.x and Python x.x.x ?
- ['What', 'is', 'the', 'difference', 'between', 'python', '2.7.5', 'and', 'Python', '3.8.1', '?']
- ['What', 'is', 'the', 'difference', 'between', 'python', '2', '7', '5', 'and', 'Python', '3', '8', '1', '?']
(五)绘制一个简单的疫情地图
- from pyecharts.charts import Map
- from pyecharts import options as opt
- import requests
- import JSON
- # 获取数据
- data = requests.get( 'https://gwpre.sina.cn/interface/fymap2020_data.json').content
- data = JSON.loads(data)
- print(data)
- # 筛选数据
- sub_data = list()
- for i in data['data']['list']:
- sub_data.append((i['name'],i['value']))
- print(sub_data)
- # 绘制中国地图
- map_info = Map()
- # 设置地图的基本信息
- map_info.set_global_opts(title_opts=opt.TitleOpts('实时疫情地图 --'+data['data' ]['times']
- ,subtitle='数据来源',
- subtitle_link='https://news.sina.cn/zt_d/yiqing0121?vt=4&pos=222')
- ,visualmap_opts=opt.VisualMapOpts (max_=1500,is_piecewise=True))
- map_info.add('确诊', sub_data, maptype='china')
- # 生成网页文件
- map_info.render( '20200403.html' )
输出之后会生成一个网页信息, 执行一下这个网页即可看到:
(六)使用正则表达式解析拉勾网某页面内的所有 http 或者 https 链接
- import re
- import requests
- r = requests.get('https://www.lagou.com/beijing')
- # print(r)
- result = re.findall('"(https?://.*?)"',r.content.decode('utf-8'))
- print(result)
输出结果:
- ['https://www.lagou.com/beijing/', 'https://www.lagou.com/', 'https://www.lagou.com/about.html', 'http://www.beian.gov.cn/portal/registerSystemInfo?recordcode=11010802024043', 'https://www.lagou.com/upload/oss.js?v=1010']
- -----
python 的正则表达式(re 函数, 贪婪和非贪婪)
来源: http://www.bubuko.com/infodetail-3500177.html