零基础学python：第19节正则表达式

小英子架构

于 2024-07-26 11:17:11 发布

阅读量340

点赞数 2

分类专栏： python新手入门文章标签： python 正则表达式 mysql

本文链接：https://blog.csdn.net/2402_83194310/article/details/140710816

版权

python新手入门专栏收录该内容

19 篇文章 0 订阅

订阅专栏

19. 正则表达式

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

需要引入内置模块re
缺点：效率低下，能用字符串方法完成尽量使用字符串的方法
优点：编码简单

一、正则表达式

###1. 为什么使用正则表达式

使用场景
- 敏感词过滤
- 手机、邮箱等验证
- 爬虫

2. 正则表达式的组成

原子

组成正则表达式的最小单位，任何字符都可以

原子	含义	原子	含义
\d	0-9中任何一个字符	\w	0-9a-z_的中任何一个字符
\D	非0-9中的任何一个字符 `[^0-9]`	\W	非0-9a-zA-Z_的中任何一个字符[^0-9a-z_A-Z]
\s	\n\r\t 空格	.	代表除\n之外的任何字符
\S	非\n\r\t 空格中任何一个字符`[^\n\t\r ]`	\b	词边界
[]	自己创建的原子表，[0-4]代表0-4中任何一个字符	\B	非词边界
[^]	排除原子表中的字符	`\A`	字符串开始
^	行首；在原子表中表示排除	`\Z`	字符串的结尾
$	行结尾	-	表示域，0-9就表示0到9所有数字字符

元字符

元字符能够增强原子的描述能力

元字符	含义	元字符	含义
{}	表示重复前一个原子的次数	*	重复0次或多次 {0,}
{m}	表示重复前一个原子的m次	+	至少出现1次 {1,}
{m,n}	表示重复前一个原子的最少m次，最多n次	?	出现0次或1次 {0,1}
{m,}	表示重复前一个原子的最少m次	*？，+？	取消贪婪
()	改变优先级，取子元素	x\|y	表示匹配x或者y

模式修正符

修饰符含义修饰符含义
re.S 使.匹配所有字符 re.I 不区分大小写
re.L 本地化识别 re.M 多行匹配
re.U 根据Unicode字符集解析字符，会影响\b、\B、\w、\W

修饰符	含义	修饰符	含义
re.S	使.匹配所有字符	re.I	不区分大小写
re.L	本地化识别	re.M	多行匹配
re.U	根据Unicode字符集解析字符，会影响\b、\B、\w、\W

注意：

模式字符串一定要使用原字符串，也就是用r开头的字符串。r’www’
严格区分大小写
如果正则表达式中有{，}，[,],-,?,*,|^,$,.等做普通字符，则要将其转义

3. 正则常用方法

re.match()

原型：re.match(pattern,string,flags=0)
功能：从字符串起始位置匹配一个模式，如果不是从起始位置匹配则返回None
参数：patter  模式
     string  要匹配的字符串
     flag    模式修正符
返回值： 匹配成功返回一个Match object，失败返回None

print(re.match(r'www','www.baidu.com'))
print(re.match(r'www','http:///www.baidu.com')) #None
print(re.match(r'www','cctv.www.baidu.com'))  #None

re.search()

原型：re.search(pattern, string, flags=0)
功能：顺序扫描字符串，找到第一个匹配项结束
参数：patter 模式
     string  要匹配的字符串
     flag  模式修正符
返回值：匹配成功，返回match object，否则返回None

print(re.search(r'll','hello'))
print(re.search(r'll','heLLo',re.I))

re.findall()

原型：findall(pattern, string, flags=0)
功能：扫描整个字符串，并返回结果列表
参数：patter: 匹配的正则表达式
	 string: 要匹配的字符串
	 flags:模式修正符
返回值：如果匹配成功返回一个列表，包含了所有匹配项，失败返回空列表
print(re.findall(r'oo','kksdkoosdflsdfooksdfsdoOppppweOo',re.I)) #['oo', 'oo', 'oO', 'Oo']

re.split

原型：split(pattern, string,maxsplit=0,, flags=0)
功能：用模式做分隔符，将字符串分隔，返回分隔列表，如果模式加上括号，则分隔符会被保留
参数：patter: 匹配的正则表达式
     string: 要匹配的字符串
     maxsplit 匹配次数，0不限制次数
     flags:模式修正符
     
print(re.split(r'\d|,|;','w1w2w3w,w;w'))#['w', 'w', 'w', 'w', 'w', 'w']

re.sub和re.subn

sub(pattern, repl, string, count=0)
subn(pattern, repl, string, count=0)
功能：在目标字符串中以正则表达式的规则匹配字符串，再把他们替换成指定的字符串。可以指定替换的次数,
     如果 不指定，替换所有的匹配字符串
参数：
    pattern:  正则表达式(规则)
    repl:     指定的用来替换的字符串
    string:   目标字符串
    count:    最多替换次数
区别：前者返回一个替换后的字符串，后者返回一个元组，第一个元素替换后的字符串，
     第二个元素表示被替换的次数
print(re.sub(r"(good)", "nice", "cheng is good man"))
print(re.subn(r"(good)", "nice", "cheng is good man"))

re.group()和re.groups()

用于提取子元素，模式中一个括号就是一个子元素，group和groups只能在match和search方法里使用，通过返回的match object获取子元素。在模式串和sub和subn中的替换字符串中可以使用\1，\2，\3…来引用子元素
```
m = re.match(r"(\d{3})-(\d{8})", "010-53247654")
#使用序号获取对应组的信息，group(0)一直代表的原始字符串
print(m.group(0))
print(m.group(1))
print(m.group(2))
#查看匹配的各组的情况
print(m.groups())
```

compile

当我们使用正则表达式时，re模块会干两件事
1、编译正则表达式，如果正则表达式本身不合法，会报错
2、用编译后的正则表达式去匹配对象

编译正则表达式使用compile

原型：re.compile(pattern, flags=0)
功能：将正则表达式模式编译成正则表达式对象，其 match() 和 search() 方法可用于匹配
参数：pattern 模式
     flags 模式修正符

re_telephon = re.compile(r"^1(([3578]\d)|(47))\d{8}$") #编译，返回
print(re_telephon.match("13600000000")) #

###4. 应用实例

看样子
写一点，测一点

二、排列和组合

排列从n个不同元素中取出m（m≤n）个元素，按照一定的顺序排成一列，叫做从n个元素中取出m个元素的一个排列(Arrangement)。特别地，当m=n时，这个排列被称作全排列(Permutation)，其值为n!/(n-m)!

组合从n个不同的元素中，任取m（m≤n）个元素为一组，叫作从n个不同元素中取出m个元素的进行组合，计算公式：n!/(m!*(n-m)!)

#排列
mylist = list(itertools.permutations([1,2,3,4], 2))
print(mylist)
print(len(mylist))

#组合
mylist = list(itertools.combinations([1,2,3,4,5], 5))
print(mylist)
print(len(mylist))

#笛卡尔积
#repeat 重复3次
mylist = list(itertools.product("QWERTYUIOP", repeat=3))
print(mylist)
print(len(mylist))

三、常用的高阶函数

如果一个函数的参数是另外一个函数，那么这个函数就可以称为高阶函数

3.1 map

map是系统内置函数，map函数接收两个参数，一个是函数，一个是可迭代对象(Iterable)，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

"""
map(function,iterable)
参数1：function，函数,函数的参数个数取决于后面序列的个数
参数2：iterable，一个序列或多个序列

功能：将传入的函数依次作用于序列中的每一个元素，并把结果作为新的Iterator返回
"""
#1.传入函数一个参数
def fun(x):
    return  x ** 2

#需求：获取一个列表中每个元素的平方，生成一个新的列表
l1 = map(fun,[1,2,3,4])
print(l1)   #<map object at 0x000001E86D3DA6D8> #返回的是迭代器
print(list(l1))  #[1, 4, 9, 16]  #将迭代器转换为迭代对象

#传入函数2个参数
l1 = [1,2,3,4]
l2 = [2,3,4,5,6,7]
def mul(x, y):
    return x * y
#注意如果两个列表长度不一样，以短的为主计算，函数是平行取值，也就是说x取l1的值，y取l2的值
gen1 = map(mul,l1,l2)  #可以使用lambda表达式
print(list(gen1))  #[2, 6, 12, 20]

#提取字典的键
gen3 = map(lambda x:int(x),{'1':10,'2':20})
print(list(gen3)) #[1,2]

#元组
gen4 = map(lambda x,y:(x,y),[1,2,3,4,5],[1,2,3])
print(list(gen4))  #[(1, 1), (2, 2), (3, 3)]

3.2 reduce

reduce()函数也是functools模块中的一个高阶函数。需要引入functools模块才能使用。

'''
functools.reduce(f, iterable[, initializer])
参数1：函数，这个函数需要两个参数。
参数2：可迭代对象
参数3：可选，是默认值
返回值：f函数计算的结果
'''
from functools import reduce
#1.累加求和
def add(x,y)
    return x + y
print(reduce(f,[1,2,3,4,5],5))
计算过程：
 （1）a = f(1,2)  #将1赋值给x，2赋值给y
 （2）a = f(a,3)  #a赋值给x，3赋值给y
 （3）a = f(a,4)
  (4）a = f(a,5)
  (5）f(d,10) = 20

#将序列变成整数
print(reduce(lambda x,y:x*10+y,[9,0,7,8])) #9078

3.3 filter

filter是内建函数，可以对可迭代对象进行过滤，去除不满足条件的元素

filter(function, iterable) 
参数： function 确定是否保留元素，为真保留，为假去除元素,function的值可以None
       iterable 可迭代对象
返回值：一个新的迭代器或迭代对象
#1 过滤掉非字符串数据
print(filter(lambda x:isinstance(x,str),['1',8,'2',3,True,0.9])) 
等价于:
  [s for s in ['1',8,'2',3,True,0.9] if isinstance(s,str)]
  
#2 回文数
#回文数判断
def is_palindrome(n):
    l1 = list(str(n))  #将数字转换为字符串，再将字符串转为列表
    l2 = l1[::-1] #获取反向列表
    if l1 == l2:  #列表比较,长度相同，每一个元素都相同则为真
        return True
    return False

#找出1-1000内所有的回文数
print(list(filter(is_palindrome,range(1,1001))))

3.4 sorted

sorted是内建函数，用于对有序序列进行排序，生成一个新序列

sorted(iterable[, key][, reverse]) 
参数：iterable  排序对象，可以列表、元组、字符串等有序序列
      key 一个函数，作用于序列的每一个元素，根据函数返回值进行排序，
           具体的函数的参数就是取自于可迭代对象中，
      reverse 默认从小到大排序，如果reverse为True则从大到小排序
返回值： 新的序列
#字符串排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)) #指定把元素变为小写后再排序

#多维数据排序
l=[('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
print(sorted(l,key=lambda x:x[1]))  #使用元组的第二个元素排序

students = [{'name':'abc','gender':'男','age':23} ,
            {'name': 'kkd', 'gender': '男', 'age': 19} ,
            {'name': 'ccxsbc', 'gender': '男', 'age': 20}]
print(sorted(students,key=lambda elem:elem['age']))  #指定用age排序