正则表达式_学习笔记

1. re模块

• python中处理正则表达式的模块是re

1.1 re.match方法

• 语法 re.match(pattern, str, flags)
  • pattern是正则表达式
  • str是待匹配的字符串
  • flags是标志位，控制正则表达式的匹配方式，比如是否区分大小写，多行匹配等
• re.match方法从字符串的起始位置开始匹配一个规则，匹配成功就返回match对象，否则返回None
• 可以使用group()方法获取匹配成功的字符串

1.1.1 re.match的无标志位示例

import re
strData = 'Python is the best language in the world'
result1 = re.match('P', strData )	# 无标识位 —> 是否以P开头
print(type(result1)) # 打印出来是是一个match对象
print(result1.group()) # P

result2 = re.match('y', strData ) # 无标识位 —> 是否以y开头
print(type(result2)) # 打印出来是不是match对象
print(result2) # None
print(result1.group()) # 此时报错，因为match是从字符串的起始位置开始匹配的，‘y’不是起始位置，所以匹配不到

result3 = re.match('Python', strData )	# 无标识位 —> 是否以Python开头
print(type(result3)) # 打印出来是是一个match对象
print(result3.group()) # Python

1.1.2 re.match的有标志位示例

• re.match方法的标志位flags
  • 可选参数
    • re.I 对大小写不敏感
    • re.L 做本地化识别匹配（啥意思？）
    • re.M 多行匹配
    • re.S 使.匹配包括换行在内的所有字符
  • 同时使用多个标志位，使用|来分割，比如re.M|re.I

有标志位示例

import re
strData = 'Python is the best language in the world'
result1 = re.match('p', strData )	# 无标识位 —> 是否以小写的p开头
print(type(result1)) # 打印出来是
print(result1) # None

result2 = re.match('p', strData, re.I)	# 有标识位，忽略大小写 —> 是否以小写的p开头
print(result2) #  可以匹配成功
print(result2.group()) # P 

1.1.3 groups()和group(num)方法示例

• groups()获取匹配到的所有数据，以元组形式呈现
• group(num)可以获取匹配到的数据，如果有多个匹配结果，会以元组的形式存放到group对象中，此时可以通过num下标来获取

import re
strData = 'Python is the best language in the world'
result = re.match('(.*) is (.*?) .*', strData, re.I|re.M)
if res: # 这里是判断res是否为None
	print('匹配成功')
	print(res) # 
	print(res.groups()) # ('python'， 'the')
	print(res.group(1)) # Python
	print(res.group(2))	# the

2. 正则表达式规则

2.1 点 .

• 点 . 匹配任意1个字符，但是不匹配换行符\n

import re

data = 'a1aaa'
pattern1 = '.'
res1 = re.match(pattern1, data)
print(res1.group()) # a

pattern2 = '..' 
res2 = re.match(pattern2, data) 
print(res2.group()) # a1, 因为是match，所以从起始位置开始匹配

data2 = '\naaaaa'
pattern3='..'
res3 = re.match(pattern3, data2) 
print(res3.group()) # 报错，因为点不匹配换行符,所以res3是None

names = '李磊', '小王', '小吴', '李明'
pattern4='李.' # 匹配李开头的
for name in names:
	res = re.match(pattern4, name)
	if res:
		print(res.group()) # 李磊  李明

这里的names外面没有括号，用type(names)可以查看到，是元组

2.2 中括号[]

• [abc]匹配abc中的任意一个字符
• [a-z]匹配a到z中的任意一个字符

import re
str1 = 'hello'
res=re.match('[he]', str1)
print(res.group()) # 打印出来是h,因为从起始位置开始，匹配一个字符，这个字符只要是在he中就行

str2 = 'elloh'
res=re.match('[he]', str2)
print(res.group()) # 打印出来是e

2.3 \d和\D

• \d匹配一个数字，即0-9

import re

data = '1234abc'
print(re.match('\d', data).group()) # 打印出来是1，因为此时match从起始位置匹配一个字符，\d限制这个字符是数字

data2 = 'w123ac'
print(re.match('\d', data2).group()) # 报错，因为w不是数字

data3 = '1234abc'
print(re.match('\d\d', data3).group()) # 打印出来是12，两个\d匹配两个数字

• \D匹配一个非数字

import re

data = 'w123abc'
print(re.match('\D', data).group()) # 打印出来是w

data2 = '123abc'
print(re.match('\D', data2).group()) # 报错，因为\D不能匹配1

2.4 \s和\S

• \s匹配一个空白，即空格、tab键

import re

data = ' abc'
print(re.match('\s', data).group()) # 打印出来是一个空白字符，因为\s匹配一个空白字符

• \S匹配一个非空白字符

import re

data = ' abc'
print(re.match('\S', data).group()) # 报错，因为\S不能匹配空白字符

data2 = '1de abc'
print(re.match('\S', data2).group()) # 打印出来是1，因为\S可以匹配一个非空白字符
print(re.match('\S\S\S', data2).group()) # 打印出来是1de，3个\S匹配3个非空白字符

2.5 \w和\W

• \w匹配一个单词字符，即a-z、A-Z、0-9、下划线_

import re

data = 's7M_udf067'
print(re.match('\w\w\w\w', data).group()) # 打印出来s7M_,因为4个\w可以匹配4个单词字符

• \W匹配一个非单词的字符

import re

data = 's7M_udf067'
print(re.match('\W\W', data).group()) # 报错，因为\W不能匹配单词字符

data2 = '@# s7M_ud067'
print(re.match('\W\W\W', data).group()) # 打印@#和一个空白字符，因为3个\W可以匹配3个非单词的字符

2.6 匹配字符数量的规则

2.6.1 匹配字符数量的规则

• 星号* 匹配前一个字符出现0次或者无限次，即可有可无
• 加号+ 匹配前一个字符出现1次或者无限次，即至少1次
• \? 匹配前一个字符出现0次或者1次，即要么1次，要么没有
• {m} 匹配前一个字符出现m次
• {m,} 匹配前一个字符至少出现m次
• {m,n} 匹配前一个字符出现从m到n次

import re

# 星号* 匹配前一个字符出现0次或者无限次，即可有可无
print(re.match('[A-Z][A-Z]*', 'My').group()) # 打印的是M，因为第一个[A-Z]匹配到M，[A-Z]*没有匹配上y
print(re.match('[A-Z][a-z]*', 'Anyabc').group()) # 打印的是Anyabc，因为第一个[A-Z]匹配到A，[a-z]*匹配到nyabc
print(re.match('[A-Z][a-z]*', 'AnyabceeKsd').group()) # 打印的是Anyabcee，因为第一个[A-Z]匹配到A，[a-z]*匹配到nyabcee,到大写的K就没有匹配到了

# 加号+ 匹配前一个字符出现1次或者无限次，即至少1次
print(re.match('[A-Z]+', 'mYnameistom').group()) # 报错，因为[A-Z]+至少要匹配1次大写字符，所以m没有匹配上，所以返回None
print(re.match('[A-Z]+', 'MYNAmeistom').group()) # 打印的是MYNA
print(re.match('[a-zA-Z]+', 'MYNAmeistom').group()) # 打印的是MYNAmeistom

2.6.2 练习：匹配python的命名规范

• 匹配python的命名规范（不能以数字开头，只能包含字母、数字、下划线）

import re

res1 = re.match('[a-zA-Z_]+[\w]*', name)
print(res1.group()) # 打印出来是name，[a-zA-Z_]+排除了数字开头，而且至少出现1次，[\w]*是单词字符出现0次或者多次，即单词字符可有可无

res2 = re.match('[a-zA-Z_]+[\w]*', _name)
print(res2.group()) # 打印出来是_name,因为[a-zA-Z_]+可以匹配_

res3 = re.match('[a-zA-Z_]+[\w]*', 99name)
print(res3.group()) # 报错，因为[a-zA-Z_]+不可以匹配9

res4 = re.match('[a-zA-Z_]+[\w]*', na99me)
print(res4.group()) # 打印na99me,因为n已经满足了[a-zA-Z_]+至少1次,但是[a-zA-Z_]+也只能匹配到na，后面的99me是[\w]*匹配到的

res5 = re.match('[a-zA-Z_]+', na99me)
print(res5.group()) # 打印的是na，从9开始匹配不了