| 数据科学、数据分析、人工智能必备知识汇总-----Python爬虫-----持续更新：https://blog.csdn.net/grd_java/article/details/140574349 |
|---|
文章目录
一、正则基础
1. 为什么使用正则
2. 正则与re模块简介
二、正则表达式
1. 匹配单个字符与数字
| 匹配 | 说明 |
|---|
| . | 匹配除换行符以外的任意字符，当flags被设置为re.S时，可以匹配包含换行符在内的所有字符 |
| [] | 里面是字符集合，匹配[里任意一个字符 |
| [0123456789] | 匹配任意一个数字字符 |
| [0-9] | 匹配任意一个数字字符 |
| [a-z] | 匹配任意一个小写英文字母字符 |
| [A-Z] | 匹配任意一个大写英文字母字符 |
| [A-Za-z] | 匹配任意一个英文字母字符 |
| [A-Za-z0-9] | 匹配任意一个数字或英文字母字符 |
[^lucky] | []里的^称为脱字符，表示非，匹配不在内的任意一个字符 |
^[lucky] | 以[]中内的某一个字符作为开头 |
| \d | 匹配任意一个数字字符，相当于[0-9] |
| \D | 匹配任意一个非数字字符，相当于[^0-9] |
| \w | 匹配字母、下划线、数字中的任意一个字符，相当于[0-9A-Za-z_] |
| \W | 匹配非字母、下划线、数字中的任意一个字符，相当于[^0-9A-za-z_] |
| \s | 匹配空白符(空格、换页、换行、回车、制表)，相当于[ \f\n\r\t]；注意[]里面有空格哦 |
| \S | 匹配非空白符(空格、换页、换行、回车、制表)，相当于[^ \f\n\r\t];注意[]里面有空格哦 |
2. 限定符
| 符号 | 描述 | 示例 | 示例解析 |
|---|
{num} | 按指定规则一次性匹配num个字符 | \d{3} | 按照\d规则，匹配连续的3个字符，这3个字符全部满足\d规则 |
? | 按照指定规则，匹配0或1个字符 | \d? | 按照\d规则，匹配0或1个字符 |
* | 相当于{0,}。按照指定规则，匹配任意个字符（0个，1个或多个） | \d* | 按照\d规则匹配任意个 |
+ | 相当于{1,}。按照指定规则，匹配1个或多个字符 | \W+ | 按照\W规则，匹配非数字或字母字符，1个或多个 |
java\\d*?表示java开头，后面跟随0或多个数字，并且非贪婪匹配。则会匹配出java，因为是非贪婪匹配，优先尽可能少的匹配，而*表示匹配0或多个，最少就是0个，所以非贪婪优先最少，也就是0个
| {num}:按照指定规则，连续num个字符匹配。就是至少连续num个符合指定规则的字符才能完成匹配 |
|---|
3. 定位符
| 符号 | 描述 | 示例 | 示例解析 |
|---|
^ | 指定起始字符 | ^[0-9]+[a-z]* | 至少1个数字开头，后接任意个小写字母 |
$ | 指定结束字符 | ^[0-9]\-[a-z]+$ | 以一个数字开头，接连字符"-"，至少1个小写字母结尾 |
\b | 匹配以指定规则结尾的边界 | yin\b* | 边界：用空格分开的子串的两边，或目标字符串的起始和结束位置，例如这个字符串“yinabcdyin aaaayin”，标黄的位置就是以yin结尾的边界 |
\B | 与\b的含义正好相反，匹配以指定规则开头的边界 | yin\B | “yinabcdyin aaaayin”，其中标黄的是以yin为开头的边界 |
| \A | 匹配字符串的开始，和^的区别是\A只匹配整个字符串的开头即使在re.M模式下也不会匹配每行的行尾 | | |
| \Z | 匹配字符串的结尾，只匹配整个字符串的结尾 | | |
4. 选择匹配符
一个竖杠|就是选择匹配符，和或运算符||有异曲同工之妙.表示只要满足一个条件就匹配 |
|---|
5. ()小括号的作用
三、re模块中常用函数
1. 通用flags（修正符）
| 值 | 说明 |
|---|
| re.I | 匹配时对大小写不敏感 |
| re.M | 多行匹配，影响到^和$ |
| re.S | 是.匹配包括换行符在内的所有字符 |
'''导包(start)'''
import re
'''导包(end)'''
string = 'alksdjflksjal====192.168.0.1==186.725.111.565==kfjlkasjflkjdsladf'
pattern = ("(?P<one>[0-9]{1,3})."
"(?P<two>[0-9]{1,3})."
"(?P<three>[0-9]{1,3})."
"(?P<four>[0-9]{1,3})")
print(pattern)
matcher = re.findall(pattern, string,re.I|re.S|re.M)
print("matcher:",matcher)
2. 通用函数
3. match函数
def match(pattern, string, flags=0):
'''
pattern: 匹配的正则表达式(一种字符串的模式)
string: 要匹配的字符串
flags: 标识位，用于控制正则表达式的匹配方式
'''
4. search函数
def search(pattern, string, flags=0):
'''
pattern: 匹配的正则表达式(一种字符串的模式)
string: 要匹配的字符串
flags: 标识位，用于控制正则表达式的匹配方式
'''
4.1 捕获分组
- (?P< name>pattern):命名捕获。将匹配的子字符串捕获到一个组名称或编号名称中，用于name的字符串不能包含任何标点符合，并且不能以数字开头。
'''导包(start)'''
import re
'''导包(end)'''
string = 'alksdjflksjal====192.168.0.1==186.725.111.565==kfjlkasjflkjdsladf'
pattern = ("(?P<one>[0-9]{1,3})." +
"(?P<two>[0-9]{1,3})." +
"(?P<three>[0-9]{1,3})." +
"(?P<four>[0-9]{1,3})")
matcher = re.search(pattern, string)
print("matcher:",matcher)
print("matcher.group():",matcher.group())
print("matcher.groups():",matcher.groups())
print("matcher.group('one'):",matcher.group('one'))
print("matcher.group('two'):",matcher.group('two'))
print("matcher.group('three'):",matcher.group('three'))
print("matcher.group('four'):",matcher.group('four'))
'''导包(start)'''
import re
'''导包(end)'''
string = 'alksdjflksjal====192.168.0.1==186.725.111.565==kfjlkasjflkjdsladf'
pattern = ("([0-9]{1,3})." +
"([0-9]{1,3})." +
"([0-9]{1,3})." +
"([0-9]{1,3})")
matcher = re.search(pattern, string)
print("matcher:",matcher)
print("matcher.group():",matcher.group())
print("matcher.groups():",matcher.groups())
print("matcher.group(1):",matcher.group(1))
print("matcher.group(2):",matcher.group(2))
print("matcher.group(3):",matcher.group(3))
print("matcher.group(4):",matcher.group(4))
5. findall()函数（返回列表）
def findall(pattern, string, flags=0):
'''
pattern: 匹配的正则表达式(一种字符串的模式)
string: 要匹配的字符串
flags: 标识位，用于控制正则表达式的匹配方式
'''
6. finditer()函数（返回match对象迭代器）
def finditer(pattern, string, flags=0):
'''
pattern: 匹配的正则表达式(一种字符串的模式)
string: 要匹配的字符串
flags: 标识位，用于控制正则表达式的匹配方式
'''
'''导包(start)'''
import re
'''导包(end)'''
string = 'alksdjflksjal====192.168.0.1==186.725.111.565==kfjlkasjflkjdsladf'
pattern = ("(?P<one>[0-9]{1,3})."
"(?P<two>[0-9]{1,3})."
"(?P<three>[0-9]{1,3})."
"(?P<four>[0-9]{1,3})")
print(pattern)
matcher = re.finditer(pattern, string)
print("matcher:",matcher)
for match in matcher:
print("================================================")
print(match)
print("match.group():",match.group())
print("match.groups():",match.groups())
print("match.group('one'):",match.group('one'))
print("match.group('two'):",match.group('two'))
print("match.group('three'):",match.group('three'))
print("match.group('four'):",match.group('four'))
print("================================================")
def next(iterator, default=None):
"""
next(iterator[, default])
返回迭代器中下一个条目
Return the next item from the iterator. If default is given and the iterator
is exhausted, it is returned instead of raising StopIteration.
"""
pass
'''导包(start)'''
import re
'''导包(end)'''
string = 'alksdjflksjal====192.168.0.1==186.725.111.565==kfjlkasjflkjdsladf'
pattern = ("(?P<one>[0-9]{1,3})."
"(?P<two>[0-9]{1,3})."
"(?P<three>[0-9]{1,3})."
"(?P<four>[0-9]{1,3})")
print(pattern)
matcher = re.finditer(pattern, string)
print("matcher:",matcher)
match1 = next(matcher)
print("match1:",match1)
match2 = next(matcher)
print("match2:",match2)
7. split()函数
def split(pattern, string, maxsplit=0, flags=0):
'''
pattern: 匹配的分隔符（依据什么进行分隔）
string: 要分割的字符串
maxsplit: 如果非0，则最多分隔出maxsplit个，剩下的会作为list中最后一个元素进行返回
flags: 标识位，用于控制正则表达式的匹配方式
'''
'''导包(start)'''
import re
'''导包(end)'''
string = '010203,121314,222324;686967'
pattern = (",|;")
matcher = re.split(pattern=pattern,string=string,maxsplit=0,flags=0)
print("matcher:",matcher)
8. 编译
def compile(pattern, flags=0):
'''导包(start)'''
import re
'''导包(end)'''
string = '010203,121314,222324;686967'
pattern = (",|;")
compile = re.compile(pattern=pattern, flags=re.S)
print(type(compile))
print(compile.split(string))
