Python初学者

Posted 2020-08-06 慢慢向前

　　1、正则表达式是用于处理字符串的功能强大的工具，但它并不是Python所独有的，许多编程语言都支持正则表达式，用法也都区别不大；

　　2、Python中正则表达式的应用在re模块中，re模块中的方法使用正则表达式来匹配字符串；

　　3、Python中的数量词默认是贪婪的，总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符（例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"；而如果使用非贪婪的数量词"ab*?"，将找到"a"。）；

　　4、与大多数编程语言相同，正则表达式里使用"\\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\\\"表示。

　　5、如下是常用正则表达式语法：

语法	说明	正则表达式实例	匹配字符串	匹配结果
.	匹配任意字符，除换行符“\\n”外	r\'a.\'	\'abc\'	\'ab\'
\\	转义字符，可以用来匹配特殊的字符 特殊字符也可以放在[]字符集中来匹配	r\'a\\*\' r\'a[*]\'	\'a*b\' \'a*b\'	\'a*\' \'a*\'
[]或[^...]	字符集[]，匹配字符集中的一个字符，从开始匹配直到匹配成功 开头加上“^”表示取反，即只要不是字符集中列出的字符都可匹配成功 可以在[]列出全部想要匹配的字符，也可以列出字符的范围，如[a-c]或[abc] 所有特殊字符放在字符集中都失去在正则表达式中的原有的意义	r\'a[efg]\'	\'afggg\'	\'af\'
\\d	匹配单个数字字符：0到9	r\'a\\d\'	\'a345b\'	\'a3\'
\\D	匹配非数字字符	r\'a\\D\' r\'a[^\\d]\'	\'ab3\' \'ab3\'	\'ab\' \'ab\'
\\s	匹配空白字符：空格，\\t，\\r，\\n，\\f，\\v	r\'a\\s\'	\'a\\n\'	\'a\\n\'
\\S	匹配非空白字符	r\'a\\S\' r\'a[^\\s]\'	\'ab\' \'ab\'	\'ab\' \'ab\'
\\w	匹配单词字符：[a-zA-Z0-9_]	r\'a\\w\'	\'a9\'	\'a9\'
\\W	匹配非单词字符	r\'a\\W\'	\'a+\'	\'a+\'
*	匹配前一个字符0到无限次	r\'ab*\'	\'a\'	\'a\'
+	匹配前一个字符1到无限次	r\'ab+\'	\'abbbcde\'	\'abbb\'
?	匹配前一个字符0次或1次	r\'ab?\'	\'abbbcde\'	\'ab\'
{m}	匹配前一个字符m次	r\'ab{2}\'	\'abbbcde\'	\'abb\'
{m,n}	匹配前一个字符m次至n次 m和n可省略，{m,}匹配前一个字符m次至无限次，{,n}匹配前一个字符0次至n次	r\'ab{1,2}\'	\'abbbbcde\'	\'abb\'
*？或+?或??或{m,n}?	使*、+、?和{m,n}的匹配变成非贪婪模式（Python默认是贪婪模式）	r\'ab+?\'	\'abbbcde\'	\'ab\'
^	匹配字符串的开头（用在字符集中[]表示取反）	r\'^ab\'	\'abbb\'	\'ab\'
$	匹配字符串的结尾	r\'cd$\'	\'abcd\'	\'cd\'
()	括号中的内容被作为分组 ()后可以接数量词	r\'a(def){2}b\'	\'adefdefbcc\'	\'adefdefb\'
|	相当于“或”，从左到右匹配被|分隔的表达式，一旦匹配成功就不会继续往后匹配了。	r\'abb(c|d)\'	\'abbdefg\'	\'abbd\'
?:	取消分组。想使用括号，但是不想它成为分组，就可以使用这个语法。	re.findall(r\'abb(?:c|d)\', \'abbdefg\')		\'abbd\'
\\<num>	引用指定编号的分组结果。	re.sub(r\'a(a)b(b)\', r\'\\2dd\\1\', \'aabbcc\')		\'bddacc\'

 

　re模块中的几个常用方法（pattern为正则表达式，string为需要匹配查找的字符串）：

• re.compile(pattern)：编译正则表达式，返回编译后的模正则表达式对象，该对象同样拥有match、search等方法。如果某个正则表达式需要多次使用，建议使用此函数先预编译正则表达式，可以提升正则表达式部分的程序性能。
• re.match(pattern, string)：匹配字符串的开头，成功则返回匹配对象，否则返回None。
• re.search(pattern, string)：从字符串开头开始查找匹配，直到匹配成功，则不再往后继续查找匹配，成功返回匹配对象，否则返回None。
• re.findall(pattern, string)：查找匹配字符串中所有内容，返回查找成功的字符串的列表，如果字符串中没有匹配成功的内容，则返回空列表，如果pattern中有括号()分组，则列表中只返回匹配成功后的分组中的字符串内容。
• re.sub(pattern, repl, string, count=0)：使用正则表达式pattern在字符串string中匹配查找，匹配查找成功后使用新字符串repl替换掉匹配成功的字符串，并返回，count为替换次数，默认0不是替换0次，而是替换所有。repl中可以使用“\\<num>”形式引用pattern中的分组内容。repl也可以是函数，该函数的参数为匹配对象，且应该返回一个字符串用于替换匹配成功的字符串，具体示例见下方的代码。
• re.split(pattern, string, maxsplit=0)：使用匹配成功后的字符串作为“分割符”，返回分割后的字符串列表，maxsplit为分割的次数，默认0不是分割0次，而是分割所有。建议简单的字符串分割首选字符串本身的split方法，复杂的分割才考虑正则表达式。
• re.finditer(pattern, string)：返回全部查找结果的迭代器，每个迭代对象为匹配对象，可以使用group()和groups()获取匹配成功的结果，如果没有匹配成功的字符串，则返回一个空的迭代器（不是None）。

　注：

• group(*args)：匹配对象的group()默认返回匹配成功的整个字符串，如果正则表达式中有括号分组，可以指定返回第几个分组结果，指定时从1开始计数，比如group(2)返回匹配成功的字符串中的第二个分组结果；也可以指定返回多个分组结果，结果以元组的形式返回，比如group(1, 2, 3)以元组返回匹配成功的字符串中的第一、第二和第三个分组结果；如果正则表达式中给某个或某几个分组指定了别名，则可以使用别名来代替分组编号来获取匹配成功的对应分组结果。
• groups()：匹配对象的groups()以元组的形式返回匹配成功后括号中分组的内容，相当于group(1,..., n)，但是正则表达式中没有括号分组，则返回空元组，即使匹配成功，也是返回空元组。

 

>>> import re
>>> pattern = re.compile(\'python\') # compile将字符串当做正则表达式来编译
>>> result = pattern.search(\'hello python!\')
>>> result
<_sre.SRE_Match object; span=(6, 12), match=\'python\'>
>>> result.group()
\'python\'

>>>
>>> # match方法
>>> result = re.match(\'a\', \'abc\') # match是从字符串的开头开始匹配
>>> result
<_sre.SRE_Match object; span=(0, 1), match=\'a\'>
>>> result.group() # 并不直接返回匹配成功的字符串，需要使用group()方法
\'a\'
>>> result = re.match(\'a\', \'dabc\')
>>> result
>>> result.group() # 没有匹配成功
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
result.group()
AttributeError: \'NoneType\' object has no attribute \'group\'

>>>

>>> # search方法
>>> result = re.search(\'python\', \'abcpythondef\') # 在字符串的全文中搜索匹配一次，同样也不会直接返回匹配成功的字符串
>>> result
<_sre.SRE_Match object; span=(3, 9), match=\'python\'>
>>> result.group()
\'python\'

>>>

>>> # findall方法
>>> result = re.findall(\'python\', \'abc python def python ghi\')
>>> result
[\'python\', \'python\']
>>> # sub方法
>>> result = re.sub(\'c\', \'z\', \'click\', 1) # 使用匹配成功的字符串替换成指定的字符串，参数依次为正则表达式，匹配成功后要去替换的字符串，原字符串，替换次数
>>> result # 返回替换后的字符串
\'zlick\'

>>> def sub_no_use_match(match_obj): # 用不到模式对象match_obj，但是该函数必须有这个参数
return \'36\'

>>> re.sub(r\'\\d+\', sub_no_use_match, \'Python27\') # 以函数返回的字符串替换匹配成功的字符串
\'Python36\'
>>> def sub_use_match(match_obj): # 使用模式对象match_obj来返回最终的字符串
return match_obj.group() + \'hahahaha\'

>>> re.sub(r\'\\d+\', sub_use_match, \'Python27\')
\'Python27hahahaha\'
>>>

>>> # split方法
>>> result = re.split(\'a\', \'1a2a3a4guyuyun\') # 将匹配成功的字符串用作字符串分隔符，返回分隔后的字符串列表
>>> result
[\'1\', \'2\', \'3\', \'4guyuyun\']

>>>

>>> # group和groups方法的区别
>>> result = re.search(\'(python)python(\\d{1,3})\', \'pythonpython22\')
>>> result.groups() # groups方法是匹配pattern中括号里的格式，以元组的形式返回括号里匹配成功的字符串
(\'python\', \'22\')
>>> result.group() # group是正常的匹配，返回匹配成功的字符串
\'pythonpython22\'
>>>

>>> string = \'python\'
>>> import re
>>> result = re.search(r\'(yt)h(o)\', string)
>>> result
<_sre.SRE_Match object at 0x000000000293DE88>
>>> result.group()
\'ytho\'
>>> result.group(0) # 参数0无效
\'ytho\'
>>> result.group(1) # 从1开始计数
\'yt\'
>>> result.group(2)
\'o\'

>>> result.group(1, 2)
(\'yt\', \'o\')
>>>

>>> result.groups()
(\'yt\', \'o\')
>>> result.groups(0) # 传入参数无效
(\'yt\', \'o\')
>>> result.groups(1)
(\'yt\', \'o\')
>>>

>>> # finditer方法

>>> string = \'one11python, two22, three33python \'
>>> result = re.finditer(r\'(\\d+)(python)\', string)
>>> for p in result:
print(p.group())

11python
33python
>>> for p in result:
print(p.group(2))

python
python
>>> for p in result:
print(p.groups()) # 若是pattern中没有括号，则返回的是每个迭代器对应的空元组。

(\'11\', \'python\')
(\'33\', \'python\')