“这是我参与8月更文挑战的第7天，活动详情查看：8月更文挑战”

一、Python中的正则表达式

1、为什么需要正则表达式

在实际开发过程中经常会有查找符合某些复杂规则的字符串的需要比如：邮箱、图片地址、手机号码等这时候想匹配或者查找符合某些规则的字符串就可以使用正则表达式了

简单来说，正则表达式就是字符串的一种匹配规则，用于匹配某些有规律的字符串。

2、正则表达式的应用场景

① 数据验证（135 7500 9699），（123 4567 8901）

② 数据检索（匹配满足条件的字符串，匹配想要获取的数据）

③ 数据过滤（某些论坛，敏感关键字过滤）

中国 => 过滤 => 华夏（zg），共产党 => 过滤 => （***）

Python学正则表达式主要是为爬虫服务的

另外，目前大多数的编程语言都是支持正则表达式的，无论Python、JavaScript、Java、Go...

3、正则表达式

正则表达式(regular expression)描述了一种==字符串匹配的模式==，可以用来检查一个串是否含有某种子串、将匹配的子串做替换或者从某个串中取出符合某个条件的子串等。

==模式：一种特定的字符串模式，这个模式是通过一些特殊的符号组成的。==

某种：也可以理解为是一种模糊匹配。

精准匹配：select * from blog where title='python';

模糊匹配：select * from blog where title like ‘%python%’;

4、举个栗子

使用正则表达式，匹配字符串中的数字

import re

# 定义一个字符串
str1 = '6helloworld'
# 匹配str1中的数字
result = re.match('\d', str1)
# 输出结果
print(result.group())

5、正则表达式三步走

# 第一步：导入re模块
import re

# 第二步：使用match方法进行匹配操作
result = re.match(pattern正则表达式, string要匹配的字符串, flags=0)

# 第三步：如果数据匹配成功，使用group方法来提取数据
result.group()

match()方法有限制，只能匹配字符串的第一个字符

findall()方法，可以用于匹配所有满足正则的结果，返回结果是一个列表

6、正则表达式如何编写

☆ 查什么（匹配什么内容，决定使用什么表达式）

目标：能够使用re模块匹配单个字符

代码	功能
.	匹配任意1个字符（除了\n），万能字符（谁都能匹配，但是一次只能匹配1个）
[ ]	匹配[ ]中列举的字符，[0-9]，[a-z]，[A-Z]，[0-9a-zA-Z]，[aeiou] => 匹配字符a、e、i、o、u中的任意某个字符
\d	匹配数字，即0-9 等价于 [0-9]
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，tab键
\S	匹配非空白
\w	匹配非特殊字符，即a-z、A-Z、0-9、_、汉字
\W	匹配特殊字符，即非字母、非数字、非下划线、非汉字

# 1、导入模块
import re

# 定义一个字符串
str1 = '0yz'
# 2、使用match或findall方法匹配内容（使用.点号匹配任意某个字符）
result = re.match('.', str1)
# 3、提取正则匹配到的数据
print(result.group())

# 定义一个字符串
str2 = 'xbcdefg'
result = re.match('[a-z]', str2) # None
print(result.group())

# 定义一个字符串
str3 = '9helloworld'
result = re.match('\d', str3)
print(result.group())

# 定义一个字符串
str4 = '+abcdefg'
result = re.match('\D', str4)  # \D代表非数字
print(result.group())

# 定义一个字符串
str5 = 'abcdefg'
result = re.match('abcd', str5)
print(result.group())

# 定义一个字符串
str6 = ' 0123456'
result = re.match('\s', str6)
print(len(result.group()))  # 匹配到空格

# 定义一个字符串
str7 = '^&*(abcd'
result = re.match('\S', str7)
print(result.group())

# 定义一个字符串（匹配非特殊字符数字、字母、下划线、汉字）
str8 = '中国'
result = re.match('\w', str8)
print(result.group())

# 定义一个字符串（匹配特殊字符，非数字、非字母、非下划线、非汉字）
str9 = '#$abc_xxx'
result = re.match('\W', str9)
print(result.group())

在Python正则表达式中，[]代表字符簇，其表示的是一个范围，但是一次也只能匹配1个字符

正则表达式严格区分大小写

☆ 查多少（你是一个字符还是多个字符，决定匹配字符数量）

代码	功能
*	匹配前一个字符出现0次或者无限次，即可有可无 (0或多)
+	匹配前一个字符出现1次或者无限次，即至少有1次 (1或多)
?	匹配前一个字符出现1次或者0次，即要么有1次，要么没有 (0或1)
{m}	匹配前一个字符出现m次，\d{3}代表匹配3位连续的数字
{m,n}	匹配前一个字符出现从m到n次，\d{3, 5}代表至少匹配3位至多匹配5位连续的数字

基本语法：

匹配符*    匹配符+    匹配符?    匹配符{m}    匹配符{m,n}

示例代码：

# 导入模块
import re

# 定义字符串
str1 = 'abc123def456'
# 匹配字符串中3位连续的数字
result = re.findall('\d{3}', str1)
print(result)

# 定义字符串
str2 = 'abc123456789abc'
# 匹配所有的数字（要求最少要匹配1个，至多可以匹配n个）
result = re.findall('\d+', str2)
print(result)

# 定义字符串
str3 = 'hello5'
# 匹配hello或者匹配hello+一个数字
result = re.findall('hello\d?', str3)
print(result)

# 定义字符串
str4 = 'abcdefgh'
# 匹配所有的字符（要么可有可无）
result = re.findall('[a-z]*', str4)
print(result)

# 定义字符串
str5 = '中国人'
# 匹配汉字，要求最少匹配2个，最多匹配3g
result = re.findall('\w{2,3}', str5)
print(result)

贪婪匹配与非贪婪匹配，比如\w{2,3}匹配汉字遇到一个问题，正常情况下，{2,3}代表至少匹配2个，至多匹配3个，但是由以上运行结果可知，其匹配了3个汉字，为什么没有匹配2个呢？

贪婪匹配：限制数量时，默认采用的匹配模式就是能匹配多个的就不匹配少的，这种叫贪婪匹配

非贪婪匹配：与贪婪匹配相对应，能匹配少的就不匹配多个，这种叫非贪婪匹配

正则默认为贪婪匹配，如果想实现非贪婪匹配，可以在限定数量字符串的后面加一个问号？就可以使用非贪婪匹配原则了。

爬虫 => (.*?)，点号代表任意字符，*代表0或多，正常情况下，有多少匹配多少，加了？问号以后就只匹配满足条件的结果，不在多匹配了。

\w{2,3}?  =>  只会匹配2个字符，而不会匹配3个

☆ 从哪里查（你是从哪个字符串开始查询还是从开头开始查询）

代码	功能
^	匹配字符串开头
$	匹配字符串结尾
[^指定字符]	匹配除了指定字符以外的所有字符

在Python代码中，我们可以通过[]来代表字符簇，其主要功能用于匹配这个范围内的某个字符。

[a-z]代表匹配26个小写字母中的任意1个

字符簇还有一种特殊用法[^a-z]，如果在字符簇中添加了一个脱字节，则代表取反。就是匹配除了这个范围以外的任意1个字符

^ = Shift + 6

案例1：匹配除0-9以外的任意1个字符

import re

# 定义一个字符串
str1 = '012hello456world789'
# 使用正则匹配除数字以外的所有字符
result = re.findall('[^0-9]+', str1)
print(result)

案例1：匹配以数字开头的数据

import re

# 定义一个字符串
str1 = '4hello'
# 匹配以数字开头的字符串
result = re.match('^\d.*', str1)
print(result.group())

# 定义一个字符串
str2 = 'hello4'
# 匹配以数字结尾的字符串（开头任意）
result = re.match('.*\d$', str2)
print(result.group())

# 定义一个字符串
str3 = '13567998645'
# 编写一个正则表达式，匹配手机号码
result = re.match('^1[3456789]\d{9}$', str3)
print(result.group())