20220719 今日python学习
def isPhoneNumer(text): if len(text) != 12: return False for i in range(0, 3): if not text[i].isdecimal(): return False if text[3] != '-': return False for i in range(4, 7): if not text[i].isdecimal(): return False if text[7] != '-': return False for i in range(8, 12): if not text[i].isdecimal(): return False return True message = 'Call me at 415-555-1011 tomorrow. ' \ '415-555-9999 is my office.' for i in range(len(message)): chunk = message[i:i+12] if isPhoneNumer(chunk): print('Phone number found: ' + chunk) print('Done')
正则表达式
正则表达式，简称为regex，是文本模式的描述方法。
\d是一个正则表达式，表达一位数字字符，即一位0-9的数字。python使用正则表达式\d\d\d-\d\d\d-\d\d\d\d，来匹配前面isPhoneNumber()函数匹配的同样文本：3个数字，1个段横向、3个数字、1个短横线、4个数字。
正则表达式可以负责很多。例如，在一个模式后加上一个花括号包围的3（{3}），表示匹配这个模式3次。
创建正则表达式对象
Python中所有正则表达式的函数都在re模块中。
向re.compile()传入一个字符串，表示正则表达式，它将返回一个Regex模式对象（或就简称为Regex对象）。
>>> phoneNumRegex = re.compile(r'\d{3}-\d{3}-\d{4}')
现在phoneNumRegex变量包含了一个Regex对象。
import re phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') mo = phoneNumRegex.search('My number is 415-555-4242') print('Phone number found: ' + mo.group())
我们将期待的模式传递给re.compile()，并将得到的Regex对象保存在phoneNumRegex中，然后我们在phoneNumRegex上调用search()，向它传入想查找的字符串。查找的结果保存在变量mo中。知道mo包含一个Match对象，而不是空值None，我们就可以在mo变量上调用group()，返回匹配的记过。将mo.group()卸载打印语句中，显示完整的匹配。
用正则表达式匹配更多模式
利用括号分组
添加括号将在正则表达式中创建”分组“：(\d\d\d)-(\d\d\d-\d\d\d\d)。然后可以使用group()匹配对象方法，从一个分组中获取匹配的文本。
正则表达式字符串中的第一对括号是第1组。第二对括号是第2组。向group()匹配对象方法传入整数1或2，就可以取得匹配文本的不同部分。向group()方法传入0或不传入参数，将返回整个匹配的文本。
>>> phoneNumRegex = re.compile( r'(\d\d\d)-(\d\d\d-\d\d\d\d)') >>> mo = phoneNumRegex.search(' My number is 415-555-4242.') >>> mo.group(1) '415' >>> mo.group(2) '555-4242' >>> mo.group(0) '415-555-4242' >>> mo.group() '415- 555- 4242'
如果想要一次就获取所有分组，请使用groups()方法，主要函数名的复数形式。
>>> mo.groups() ('415', '555-4242') >>> areaCode, mainNumber = mo.groups() >>> print(areaCode) 415 >>> print(mainNumber) 555-4242
用管道匹配多个分组
字符"|"称为”管道“。希望匹配许多表达式中的一个时，就可以使用它。
例如，正则表达式r'Batman|Tina Fey'将匹配'Batman'或‘Tina Fey’。
>>> batRegex=re.compile(r'Bat(man|mobile|copter|bat)') >>> mo=batRegex.search('Batmobilelostawheel') >>> mo.group() 'Batmobile' >>> mo.group(1) 'mobile'
方法调用mo.group()返回了完全匹配的文本'Batmobile'，而mo.group(1)只是返回第一个括号分组内匹配的文本'mobile'。
用问号实现可选匹配
有时候，想匹配的模式是可选的。就是说，不论这段文本在不在，正则表达式都会认为匹配。字符?表示它前面的分组在这个模式中是可选的。
用星号匹配零次或多次
*（称为星号）意味着”匹配零次或多次“，即星号之前的分组，可以在文本中出现任意次。它可以完全不存在，或一次又一次地重复出现。
用加号匹配一次或多次
+（加号）意味着”匹配一次或多次“，加号前面的分组必须”至少出现一次“，这不是可选的。如果需要匹配真正的加号字符，在加号前面加上倒斜杠实现转义：\+
用花括号匹配特定次数
如果想要一个分组重复特定字数，就在正在表达式中该分组的后面，跟上花括号包围的数字。除了一个数组，还可以指定一个范围，即在花括号中写下一个最小值、一个逗号和一个最大值。
(Ha){3, 5} #Ha将出现3到5次。
也可不写花括号中的第一个或第二个数字，不限定最小值或最大值。例如(Ha){3, }将匹配3次或更多次实例。
贪心和非贪心匹配
Python正则表达式模式是”贪心的“，这表示在有二义的情况下，它们会尽可能匹配最长的字符串。花括号的”非贪心“版本匹配尽可能最短的字符串，即在结束的花括号后跟着一个问号。
请注意，问号在正则表达式中可能有两种含义：声明非贪心匹配或表示可选的分组。
findall()方法
除了search方法外，Regex对象也有一个findall()方法。search()将放回一个Match对象，包含备查找字符串中的”第一次“匹配的文本，而findall()方法将返回一组字符串，包含被查找字符串中的所有匹配。
另一方面，findall()不是返回一个Match对象，而是返回一个字符串列表，只要在正则表达式中没有分组。列表中的每个字符串都是一段被查找的文本，它匹配该正则表达式。
作为findall()方法的返回结果总结，请注意下面两点：
1）如果调用在一个没有分组的正则表达式上，例如\d\d\d-\d\d\d-\d\d\d\d，方法findall()将返回一个匹配字符串的列表，例如['415-555-9999','212-555-0000']；
2）如果调用在一个有分组的正则表达式上，例如(\d\d\d)-(\d\d\d)-(\d\d\d\d)，方法findall()将返回一个字符串的元组的列表（每个分组对应一个字符串），例如[('415','555','1122'), ('212','555','0000')]；
字符分类
字符分类对于缩短正则表达式很有用。
建立自己的字符分类
字符分类[aeiouAEIOU]将匹配所有元音字符，不论大小写。
请注意，在方括号内，普通的正则表达式符号不会被解释。这意味着，你不需要前面加上倒斜杠转义、*、？或()字符。
通过在字符分类的左方括号后加上一个插入字符（^），就可以得到”非字符类“。非字符类将匹配不在这个字符类中的所有字符。
>>> comsonantRegex = re.compiler(r'[^abcABC]')
插入字符和美元字符
可以在正则表达式的开始处使用插入符号（^），表明匹配必须发生在被查找文本开始处。类似的，可以再正则表达式的末尾加上美元符号（$），表示该字符串必须以这个正则表达式的模式结束。
可以同事使用^和$，表示整个字符串必须匹配该模式，也就是说，只匹配该字符串的某个子集是不够的。
正则表达式r'^Hello'匹配以'Hello'开始的字符串：
>>> beginsWithHello = re.compile(r'Hello') >>> beginsWithHello.search('Hello world!') <re.Match object; span=(0, 5), match='Hello'> >>> beginsWithHello.search('He said hello.') == None True
正则表达式r'\d$'匹配以数字0到9结束的字符串。
>>> endWithNumber = re.compile(r'\d$') >>> endWithNumber.search('Your number is 42') <re.Match object; span=(16, 17), match='2'> >>> endWithNumber.search('Your number is forty two.') == None True
正则表达式r'~\d+$'匹配从开始到结束都是数字的字符串
>>> wholeStringIsNum = re.compile(r'^\d+$') >>> wholeStringIsNum.search('1234567890') <re.Match object; span=(0, 10), match='1234567890'> >>> wholeStringIsNum.search('123456xyz7890') == None True >>> wholeStringIsNum.search('12 34567890') == None True
通配字符
在正则表达式中，.（句号）字符称为”通配符“。它匹配除了换行之外的所有字符。
>>> atRegex = re.compile(r'.at') >>> atRegex.findall('The cat in the hat sat on the flatmat.') ['cat', 'hat', 'sat', 'lat', 'mat']
要真正使用句号，就要用倒斜杠转义。
用点-星匹配所有字符
点-星（.*）表示”任意文本“。
>>> nameRegex = re.compile(r'First Name: (.*) Last Name: (.*)') >>> mo = nameRegex.search('First Name: Al Last Name: Sweigart') >>> mo.group(1) 'Al' >>> mo.group(2) 'Sweigart'
点-星使用”贪心“模式：它总是匹配尽可能多的文本。要用”非贪心“模式匹配所有文本，就使用点-星和问号（.*?）
>>> nongreedyRegex = re.compile(r'<.*?>') >>> mo = nongreedyRegex.search('< To server man >for dinner.>') >>> mo.group() '< To server man >' >>> greedyRegex = re.compile(r'<.*>') >>> mo = greedyRegex.search('< To server man >for dinner.>') >>> mo.group() '< To server man >for dinner.>'
在非贪心的正则表达式中，Python匹配最短可能的字符串：'< To server man >'。在贪心版本中，Python匹配最长可能的字符串：'< To server man >for dinner.>'
用句号字符串匹配换行
通过传入re.DOTALL作为re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。
>>> noNewlineRegex = re.compile('.*') >>> noNewlineRegex.search('Server the Public trust.\nProtect the innocent.\nUphold the law').group() 'Server the Public trust.' >>> newlineRegex = re.compile('.*', re.DOTALL) >>> newlineRegex.search('Server the public trus.\nProtect the innocent.\nUphold the law.').group() 'Server the public trus.\nProtect the innocent.\nUphold the law.'
正则表达式noNewlineRegex在创建时没有向re.compile()传入re.DOTALL，它将匹配所有字符，直到第一个换行字符。但是，newlineRegex在创建时向re.compile()传入了re.DOTALL，它将匹配所有字符。
正则表达式符号复习
?匹配零次或一次前面的分组。
*匹配零次或多次前面的分组。
+匹配一次或多次前面的分组。
{n}匹配n次前面的分组。
{n, }匹配n次或更多前面的分组。
{ ,m}匹配零次到m次前面的分组。
{n,m}匹配至少n次、至多m次前面的分组。
{n,m}?或*?或+?对前面的分组进行非贪心匹配。
^spam意味着字符串必须以spam开始。
spam$意味着字符串必须以spam结束。
.匹配所有字符，换行符除外。
\d、\w和\s分别匹配数字、单词和空格。
\D、\W和\S分别匹配数字、单词和空格外的所有字符。
[abc]匹配方括号内的任意字符。
[^abc]匹配不在方括号内的任意字符。
不区分大小写的匹配
通常，正则表达式用你指定的大小写匹配文本。
要让正则表达式不区分大小写，可以向re.compile()传入re.IGNORECASE或re.I，作为第二个参数。
>>> robocop = re.compile(r'robocop', re.I) >>> robocop.search('RoboCop is part man, part machine, all cop.').group() 'RoboCop' >>> robocop.search('ROBOCOP protects the innocent.').group() 'ROBOCOP' >>> robocop.search('Al, why does your programming book talk about robocop so much?').group() 'robocop'
用sub()方法替换字符串
Regex对象的sub()方法需要传入两个参数。第一个参数时一个字符串，用于取代发现的匹配。第二个参数是一个字符串，即正则表达式。
>>> namesRegex = re.compile(r'Agent \w+') >>> namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.') 'CENSORED gave the secret documents to CENSORED.'
假定想要隐去密探的名字，只显示他们姓名的第一个字母。要做到这一点，可能使用正则表达式Agent(\w)\w，传入r'\1*'作为sub()的第一个参数。字符串中的\1将由分组1匹配的文本所代替，也就是正则表达式的(\w)分组。
>>> agentNameRegex = re.compile(r'Agent (\w)(\w)') >>> agentNameRegex.sub(r'\1***', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.') 'A***ice told C***rol that E***e knew B***b was a double agent.'
管理负责的正则表达式
向re.compile()传入变量re.VERBOSE，作为第二个变量， 使得正则表达式忽略字符串中的空白符和注释。
phoneRegex = re.compile(r'''( (\d{3})|\(\d{3}\))? #are code (\s|-|\.)? #separator \d{3} #first 3 digits (\s|-|\.) #separator \d{4} #last 4 digits (\s*(ext|x|ext.) \s*\d{2, 5})? #extension )''', re.VERBOSE)
请注意，前面的例子使用了三重引号（'''），创建了一个多行字符串。
正则表达式字符串的注释规则，与普通的Python代码一样：#符号和它后面直到行末的内容，都被忽略。
组合使用re.IGNOREC ASE、re.DOTALL和re.VERBOSE
re.compile()函数只接受一个值作为它的第二个参数。可以使用管道字符（|）将变量组合起来，从而绕过这个显示。管道字符在这里称为”按位或“操作符。
>>> someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL)
