Python基础语法15 正则表达式 高阶函数

正则表达式:import re
匹配单个字符
. 匹配除换行符以外的任意字符
[good] 字符集合，表示匹配[]中的任意一个字符
[1-9] 表示匹配从1~9任意一个字符
[a-z] 表示匹配任意小写字母
[A-Z] 表示匹配任意的大写字母
[0-9a-zA-Z] 表示匹配任意的数字字母
[0-9a-zA-Z_] 表示匹配任意的数字字母以及下划线
[^0-9] ^写在[]中表示脱字节，匹配非数字的所有字符
\d 匹配所有的数字效果同[0-9]
\D 匹配所有的非数字字符效果同[^0-9]
\w 匹配数字字母下划线，效果同[0-9a-zA-Z_]
\W 匹配非数字字母下划线，效果同[^0-9a-zA-Z_]
\s 匹配任意的空白符,效果同[ \r\n\f\t]
\S 匹配非空白符，效果同[^ \r\n\f\t]

正则表达式其实就是一个字符串，使用这个字符串来进行描述某个语法规则搜索的模式

匹配单个字符
. 匹配除换行符以外的任意字符
[] 字符集合，表示匹配[]中任意一个字符
[0-9] 表示匹配任意的数字
[a-z] 表示匹配所有小写字母
[A-Z] 表示匹配所有的大写字母
[0-9a-zA-Z_] 表示匹配数字字母下划线
[^0-9] ^在[]括号中表示脱字节，非数字
\d 表示匹配数字，效果同[0-9]
\D 表示匹配非数字，效果同[^0-9]
\w 表示匹配数字字母下滑线，效果同[0-9a-zA-Z_]
\W 表示匹配非数字字母下滑线，效果同[^0-9a-zA-Z_]
\s 表示匹配空白符效果同[ \r\n\f\t]
\S 表示非匹配空白符效果同[^ \r\n\f\t]

re.findall(pattren,string)
参数一：正则表达式
参数二：被正则的字符串
功能：对string进行正则匹配，将匹配到的结果作为列表返回
边界匹配
^ 行首匹配，从每一行的开始进行匹配
$ 行尾匹配，匹配每一行的结束
\A 匹配字符串的开始，与^的区别是，即使在re.M的模式下，也不会匹配其他的行首
\Z 匹配字符串的结束，与$的区别是，即使在re.M的模式下，也不会匹配其他的行尾
\b 匹配单词的边界 \b写在左边匹配左边界，写在右边匹配右边界
\B 匹配单词的非边界 写在左边，左边界不匹配，写在右边右边界不匹配
匹配多个字符
(xyz) 将括号中的内容作为一个整体来进行匹配
x？匹配0个或者1个x 尽可能少的匹配
x* 匹配0个或者多个x 贪婪匹配，尽可能多的匹配
x+ 匹配至少一个，贪婪匹配，尽可能多的匹配
x{n} 匹配确定的n个x
x{n,} 匹配至少n个x 贪婪匹配
x{n,m} 匹配至少n个最多m个x

正则表达式的常用函数

re.compile(pattern,flags)
参数一：正则表达式
参数二：标志位
功能：将正则表达式编译成一个正则对象然后返回。调用的时候调用正则对象即可。

print(re.match(r"¹{5,11}(@qq.com|@163.com|@sina.cn)$",“11222@qq.cn”))

comobj = re.compile(r"²{5,11}(@qq.com|@163.com|@sina.cn)$")

comobj.findall()

re.match(pattern,string,flags)
参数一：正则表达
参数二：string
参数三：标志位
功能：对string从字符串开始进行匹配，若匹配的上则返回匹配成功的对象，若匹配不上则返回None
注意：这并不是一个完全匹配，若匹配成功之后，string有剩余仍然匹配成功，若要完全匹配，可以在正则
的末尾添加$即可

print(re.match(“hello”,“hellohaha”))

re.search(pattern,string,flags)
参数一：正则表达式
参数二：字符串
参数三：标志位
功能：以指定的正则格式在string进行查找若找到则直接返回第一匹配成功的对象，不再继续匹配。
若找不到返回None

print(re.search(“hello”,“ohahellha”))

re.findall(pattern,string,flags)
功能：以指定的正则表达式去string中进行匹配，把所有匹配的结果作为list返回。若没有匹配上则返回空列表。

re.finditer(pattern,string,flags)
功能：以指定的正则表达式去string中进行匹配，把所有匹配的结果作为迭代器返回.

print(re.findall(“hello”,“ohahellha”))
print(list(re.finditer(“hello”,“ohahellha”)))

re.split(pattern,string,maxsplit,flags)
功能：以指定的正则对string进行切片，并且将切片后的结果作为列表返回。
maxsplit：指定最大切片次数，若不指定，全部切片

print(re.split(r"\d+",“dd1w3sd2333adfeeft344dfffg3df”))

re.sub(pattern,repl,string,count)
功能：将匹配到的字符以指定的repl进行替换并且返回替换后的结果
count：指定替换次数，若不指定则默认全部替换

print(re.sub(r"\d+"," ",“dd1w3sd2333adfeeft344dfffg3df”,count=3))

import functools
import operator

map(func，iter1)
参数一：函数 有且只有一个参数
参数二：可迭代对象
功能：将可迭代对象中的元素依次取出作用于func函数，
并将作用的结果作为迭代器返回。

创建一个函数实现将列表中的字符串转为int的功能

def func(list1):
list2 = []
for x in list1:
list2.append(int(x))
return list2

需求2；
使用map函数获取［1，4，9，16，…,10000]

def func2(n):
print(n)
return n**2

functools.reduce(func,iter1)
参数一：func 有且只有两个参数
参数二：可迭代对象

if name == ‘main’:
list1 = [“1”, “2”, “233”, “22”, “45”]
list2 = [1, 2, 233, 22, 45]
# print(func(list1))
# print(list(map(int,list1)))
# print(list(map(lambda x:x**2,range(1,101))))
print(functools.reduce(operator.add,list2))
‘’’
对list1中的元素求和，使用一行代码实现
‘’’
res = functools.reduce(operator.add,map(int,list2))
print(res)
‘’’
求100!
‘’’
print(functools.reduce(lambda x,y:x*y,range(1,6)))

filter(func，iter1)
参数一：func 有且只有一个参数，返回值必须是bool值
参数二：可迭代对象
功能：进行数据过滤，将iter1中的元素依次取出，作用于func，根据func返回的是True还是False
决定是否保留该元素。返回True的时候是保留该元素，返回False去除该元素

def func(l):
list2 = []
for x in l:
if x%2 != 0:
list2.append(x)

return list2

sorted(iterable，key，reverse)
参数一：可迭代对象
参数二：key，比较规则
参数三：默认升序，reverse＝True 降序排列
功能：将可迭代对象依次作用于key后面的函数，然后根据作用的结果进行排序。

sum(iter)
参数一：可迭代对象，元素必须是number类型
功能：返回可迭代对象相加的结果

zip(iter1,iter2,…)
功能：将多个可迭代对象的对应位置的数据进行打包处理，长度由最短的决定，返回一个打包好的zip对象［迭代器］
zip(*zipobj)
功能：将zip对象进行解包处理

if name == ‘main’:
‘’’
需求：将爱好无的元素剔除
‘’’
data = [[“张三”, 28, “吃”], [“tom”, 25, “无”], [“hanmeimei”, 26, “金钱”]]
list1 = [1,2,3,41,23,1,2,13,4,4,12,123]
print(func(list1))
# print(list(filter(lambda x: True if x%2 else False,list1)))
# print(list(filter(lambda x:False if x[-1]==“无” else True,data)))
print(list(sorted(list1,reverse=True)))
list2 = [“hello”,“12”,“sde4er”,“ass”,“4erre2dfff”]
‘’’
以列表中字符串的长度来进行排序
‘’’
print(list(sorted(list2,key=len,reverse=True)))
‘’’
需求：将data中的元素根据年龄的升序排列
‘’’
print(list(sorted(data,key=lambda x:x[1])))
‘’’
需求：
list3 ＝ [12,“333”,“22”,“45”,455,31,12,3,45,45667]
对list3根据字面量的值进行降序排列
‘’’
list3 = [12, “333”, “22”, “45”, 455, 31, 12, 3, 45, 45667]
print(list(sorted(list3,key=int,reverse=True)))

'''
需求：使用zip函数实现：
dict1 = {1:"hello",2:"good",3:"nice"}
==> dict2 = {"hello":1,"good":2,"nice":3}
'''
dict1 = {1: "hello", 2: "good", 3: "nice"}

print(dict(zip(dict1.values(),dict1.keys())))

print(sum(list1))

---

1. 0-9a-z ↩︎

2. 0-9a-z ↩︎