Py3 正则表达式re

Powered by:AB_IN 局外人

搬运一下之前学时记的笔记

import re
#正则表达式 re


'''
正则表达式的组成:
    普通字符： 大小写字母，数字，符号，etc
    转义字符： \\w \\W\ \\d \\D \\s \\S etc
    特殊符号：. * ？ + ^ $ [] () {}
    匹配模式：I U etc
'''

#定义字符串
vars='iloveyou521tosimida'

#定义正则表达式
reg='\\d' #代表一个数字
reg1='521'#代表一个串
#调用正则函数方法

res=re.findall(reg,vars) #相当于找里面的所有数字
#['5', '2', '1']
print(res)


res=re.findall(reg1,vars) 
#['521']
print(res)


res=re.finditer(reg1,vars) #返回一个迭代器保存了匹配对象
print(next(res))
#

#re模块相关函数
import re
'''
re.match() 函数
    功能：从头开始匹配，要么第一个就符合要求，要么不符合,匹配成功则返回Match对象，否则返回None，可以使用group()方法获取返回的数据
re.search()
    功能：从开头到结尾进行搜索式 匹配，开头可以不是头，要么第一个就符合要求，要么不符合,匹配成功则返回Match对象，否则返回None，可以使用group()方法获取返回的数据
re.findall()
re.finditer()
re.sub()
'''
vars='ilovelby'
reg='ilo'


# 调用正则match 函数方法
res=re.match(reg,vars) #None(因是从头开始匹配 )
print(res) #这个为迭代器
print(res.group()) #返回当前结果
print(res.span()) #返回下标范围


#search 
res=re.search(reg,vars)
print(res)
print(res.group())
print(res.span())

'''
re.findall()
    按照正则表达式的规则在字符串中匹配元素，结果返回一个列表，如果没有则返回空列表
re.finditer()
    返回一个迭代器
re.sub()
    搜索替换功能，按照正则表达式的规则，在字符串中找到需要被替换的字符串
    参数：
    pattern：正则表达式的规则
    repl:替换后的字符串
    string:被替换的原始字符串
compile()
    可以直接正则表达式定义为正则对象，使用正则对象操作
'''
import re
vars='iloveyou521tosimida511'
reg='\d{3}'#可以三个函数为一组 ['521', '511']
#reg='\d{2}' ['52', '51']
#reg='\d{4}' []


res=re.findall(reg,vars)
print(res)


res=re.finditer(reg,vars)
print(list(res)) #有几个返回几个 [, ]


#替换成其它
res=re.sub(reg,'AAA',vars)#iloveyouAAAtosimidaAAA
print(res)


#直接定义正则表达式对象
reg= re.compile('\d') #取代re,相当于不用传正则对象
res= reg.findall(vars)
print(res)

#正则表达式的规则定义
import re


#普通字符
vars = 'ilovelby'

reg='lby'

res=re.search(reg,vars).group()
print(res)

#转义字符 \\w \\W\ \\d \\D \\s \\S
vars='ilove521lby'
reg='\w' # 代表单个字母，数字，下划线。
reg='\W' # 代表单个非字母数字下划线。
reg='\d' # 代表单个数字。
reg='\D' # 代表单个非数字。
reg='\s' # 代表单个的空格符或制表符
reg='\S' # 代表单个的非空格符或制表符
reg='\w\w\w\w' #连续四个，也可组合使用

res=re.search(reg,vars).group()
print(res)


#特殊字符 . * + ? {} [] () ^ $
vars='ilove521you hello'
reg='.' # 代表单个的任意字符，除了换行符\n
reg='.*'# * 代表匹配次数 任意次数(包括0) ，如果.一开始没有匹配到，那就没有；如果.中途没有匹配到，就把之前符合的返回
reg='\w+'# + 代表匹配次数，至少匹配一次，匹配一次之后就和*语法相同 ilove521you
reg='\w+?' # ? 拒绝贪婪，前面的匹配规则只要达成则返回 i
reg='\w*?' # 就直接返回没有，因为0也是任意次数，0已经达成了
reg='\w{4}'# 代表必须匹配次数n，{n}；{n,m} 两个数字时，表示必须匹配的区间次数
reg='[a-z]+'#[] 代表字符的范围，[a-z,A-Z] 两个范围时。
reg='\w+(\d{3})' # () 代表子组，括号中的表达式首先作为整个正则的一部分，另外会把符合小括号中的内容单独提取一份，就是存在一个元组里
#res=re.search(reg,vars).groups()
#print(res) ('521',)

vars='123456789' 
#定义一个匹配手机号的正则表达式
reg='^1\d{10}8$' # ^代表开头(如例子，必须是1 ，匹配9个(不算开头)       $代表结尾,(匹配长度不算结尾)，整个串就结尾了
reg='^1\d{3}5\d{6}' #5前面不用加^,这里代表，从1匹配完三个后，必须从5开始匹配
res=re.search(reg,vars).group()
print(res)


#正则模式 re.I 不区分大小写
vars='iloveYOU'
reg='[a-z]{4,8}'
res=re.search(reg,vars,re.I)
print(res.group())

$re$主要用于爬虫。用在AC纯属偷鸡取巧

兔子的名字

题意：在字符串中找“子串”，这个“子串”是有这个字母并顺序对就行。
比如$uy$就在$funny$里
那么我们就要找$uy$的正则表达式。
其实就是问的$...u...y...$在不在原串里。
自然而然就写出来了$$...u...y...=(.\ast ?)u(.\ast ?)y(.\ast ?)$$

import re
lst=[];tmp=[]
n,m=map(int,input().split())
for _ in range(n):
    lst.append(input())
for _ in range(m):
    s=input()
    reg=''
    for i in s:
        reg+=i
        reg+='.*?'
    tmp.append(reg)
for i in lst:
    ans=0
    for j in tmp:
        if re.findall(j,i):
            ans+=1
    print(ans)

也可以直接暴力。

#include 
using namespace std;
const int N = 1005;
string s[N],t[N];
int n,m;

bool check(string s1,string s2){
	int j=0;
	for(int i = 0;i < s1.size();i++){
		if(s1[i] == s2[j]){
			j++;
		}
	}
	return (j == s2.size());
} 
int main(){
	scanf("%d%d",&n,&m);
	for(int i = 1;i <= n;i++) cin>>s[i];
	for(int i = 1;i <= m;i++) cin>>t[i];
	for(int i = 1;i <= n;i++){
		int ans = 0;
		for(int j = 1;j <= m;j++){
			ans += check(s[i],t[j]);
		}
		printf("%d\n",ans);
	}
	return 0;
}

牛牛爱字符串

题意：找数字。
那么用一个$findall$即可。
$$\begin{gathered} reg=r^{\prime }\text{}d{+}^{\prime } \\ 或者reg{=}^{\prime }\text{}d{+}^{\prime } \end{gathered}$$
最后生成一个全是字符串的列表。

import re
while True:
    try:
        s=input()
        reg='\\d+'
        res=re.findall(reg, s)
        print(' '.join(map(str,list(map(int,res)))))
    except:
        break