Python字符串操作与正则表达式详解-优快云博客

本文链接：https://blog.youkuaiyun.com/linshuo1994/article/details/83688785

基本方法

判断方法	islower()是否全部为小写	'Hello world!'.islower() # False 'abc12345'.islower()# True
	isupper()是否全部为大写	'Hello world!'.isupper() # False '12345'.isupper() # False
	isalpha()只包含字母并非空，返回 True	'hello'.isalpha() # True 'hello123'.isalpha() # False
	isalnum()只包含字母和数字且非空，返回 True	'hello123'.isalnum() # True 'hello'.isalnum() # True
	isdecimal()只包含数字字符并非空，返回 True	'123'.isdecimal() # True
	isspace()只包含空格、制表符和换行并非空，返回 True	' '.isspace() # True
	istitle()仅包含以大写字母开头、后面都是小写字母的单词，返回True	'This Is Case'.istitle() # True 'This Is Case 123'.istitle() # True 'This Is not Case'.istitle() # False 'This Is NOT Case Either'.istitle() # False
	startswith(str)如果字符串以str为开始	'Hello world!'.startswith('Hello') # True 'abc123'.startswith('abcdef') # False 'Hello world!'.startswith('Hello world!') # True
	endswith(str)如果字符串以str为结束	'Hello world!'.endswith('world!') # True 'abc123'.endswith('12') # False 'Hello world!'.endswith('Hello world!') # True
对齐文本	rjust() 右对齐	'Hello'.rjust(10) # ' Hello' 'Hello'.rjust(6, '') # '*****Hello'
	ljust() 左对齐	'Hello'.ljust(10) # 'Hello ' 'Hello'.ljust(5, '-') # 'Hello-----'
	center() 中间对其	'Hello'.center(20)# ' Hello ' 'Hello'.center(20, '=') # '=======Hello========'
删除空白字符	strip() 删除两边空格	' Hello World '.strip() # 'Hello World' spam = 'SpamSpamBaconSpamEggsSpamSpam' spam.strip('Samp') # 'BaconSpamEggs
	rstrip() 删除右空格	' Hello World '.rstrip() # ' Hello World'
	lstrip() 删除左空格	' Hello World '.rstrip() # ' Hello World'
分割与合并	split()	', '.join(['cats', 'rats', 'bats']) # 'cats, rats, bats' ' '.join(['My', 'name', 'is', 'Simon']) # 'My name is Simon' 'ABC'.join(['My', 'name', 'is', 'Simon']) # 'MyABCnameABCisABCSimon'
分割与合并	join()	'My name is Simon'.split()# ['My', 'name', 'is', 'Simon'] 'MyABCnameABCisABCSimon'.split('ABC') # ['My', 'name', 'is', 'Simon'] 'My name is Simon'.split('m') # ['My na', 'e is Si', 'on']
反转	str[::-1]	"abc"[::-1] # "cba"
计数	str.count(sub,start,end)统计字符串里某个字符出现的次数	str = "this is string example....wow!!!"; sub = "i" str.count(sub, 4, 40) #2 sub = "wow" str.count(sub) #1

格式化输出

def printTable(origin_list):
    max_size = len(max(max(origin_list, key=len), key=len)) #   查找最长的字符串
    for (i,j,k) in zip(*origin_list):
        print(i.rjust(max_size),j.ljust(max_size),k.ljust(max_size))

tableData = [['apples', 'oranges', 'cherries', 'banana'],
['Alice', 'Bob', 'Carol', 'David'],
['dogs', 'cats', 'moose', 'goose']]
printTable(tableData)
"""
  apples Alice    dogs    
 oranges Bob      cats    
cherries Carol    moose   
  banana David    goose 

"""

模式匹配与正则表达式

^	匹配字符串的开头，当flag=`re.MULTILINE，可以匹配每一行`
$	匹配字符串的末尾或新的一行之前的字符末尾，当flag=`re.MULTILINE`。	'foo$' # 匹配‘foo’ re.findall('foo.$','foo1\nfoo2\n',flags=re.MULTILINE) m#['foo1', 'foo2']
.	匹配除 "\n" 之外的任何单个字符。当flag=re.DOTALL，可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：	[Pp]ython #匹配 "Python" 或 "python" [amk] 匹配 'a'，'m'或'k' [0-9] #匹配任何数字。类似于 [0123456789] [a-z] #匹配任何小写字母 [A-Z] #匹配任何大写字母 [a-zA-Z0-9] #匹配任何字母及数字
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。	[^aeiou] #除了aeiou字母以外的所有字符 [^0-9] #匹配除了数字外的字符
*	匹配*号前的字符0次或多次	`'ab*'` # 匹配‘a’, ‘ab’, ‘abb’..等
+	匹配+号前的字符1次或多次	`'ab*'` # 匹配 ‘ab’, ‘abb’...等
?	匹配前一个字符1次或0次(可选的)，非贪婪方式，只匹配最少的	’ab?' #匹配'a' 'ab'
*`?`, `+?`, `??`**	非贪婪模式	m = re.match('<.>','<a> b <c>') #’<a> b <c>‘ m = re.match('<.?>','<a> b <c>') # '<a>'
{ n}	精确匹配前一个字符n次，	o{2} #匹配 "food" 中的两个 o
{ n, m}	匹配前一个字符n次到m次，贪婪方式	‘a{4,}b’ #匹配'aaaab'及以上，不能匹配'aaab'
{m,n}?	匹配前一个字符n次到m次，但尽可能匹配少，非贪婪	a{3,5} #会匹配 'aaaaaa'的5个字符 a{3,5}? #只匹配 'aaaaaa'的3个字符
\|	匹配"\|"左或"\|"右的字符，也称为“管道”，希望匹配许多表达式中的一个时	要匹配'\|',需使用'\\|'
(...)	分组匹配，从左到右,每遇到一个 ( 编号+1，分组后面可加数量词
\w	匹配字母数字及下划线,等价于'[A-Za-z0-9_]'
\W	匹配非（字母数字及下划线）,等价于 '[^A-Za-z0-9_]'
\s	匹配任意空白字符，等价于 [ \f\n\r\t\v]
\S	匹配任意非空字符,等价于 [^ \f\n\r\t\v]
\d	匹配任意数字，等价于 [0-9]
\D	匹配任意非数字,等价于 [^0-9]
\A	只从字符开头匹配
\Z	匹配字符结尾，如存在换行，只匹配到换行前的结束字符串，同"$"
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。	'er\b' #匹配"never" 中的 'er'，不匹配 "verb"
\B	匹配非单词边界。	'er\B '# 匹配 "verb" 中的 'er'，不匹配 "never" 'py\B' #匹配`'python'`, `'py3'`, `'py2'，不能'py'`, `'py.'`, or `'py!'`
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

re模块

Python 中所有正则表达式的函数都在 re 模块中，所有函数中的flags参数为可选标志修饰符来控制匹配的模式

修饰符	描述
re.I	忽略大小写
re.L	做本地化识别（locale-aware）匹配，表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M	多行匹配模式，影响 ^ 和 $
re.S	即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
re.U	表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X	为了增加可读性，忽略空格和 # 后面的注释

re.compile(pattern, flags=0)

将正则表达式模式编译成RegexObject 对象，可以使用其match()、search()和其他方法进行匹配。

#  方式一
prog = re.compile(pattern)
result = prog.match(string)
#  方式二
result = re.match(pattern, string)

虽然上述两者方法相同，但是方式一保存了表达式对象，可以多次高效地重复使用

re.match(pattern, string, flags=0)

匹配成功re.match方法返回一个相应的Match 对象，否则返回None。re.match只在字符串的开始匹配。

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配:(0, 3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配:None

正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
m.group(0) # '010-12345'
m.group(1) # '010'
m.group(2) # '12345'

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

`Match.group`([group1, ...])	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。	m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist") m.group(0) # The entire match：'Isaac Newton' m.group(1) # The first parenthesized subgroup：'Isaac' m.group(2) # The second parenthesized subgroup：'Newton' m.group(1, 2) # Multiple arguments give us a tuple.：('Isaac', 'Newton')
`Match.groups`(default=None)	返回一个包含所有小组字符串的元组，从 1 到所含的小组号。	m = re.match(r"(\d+)\.(\d+)", "24.1632") m.groups() # ('24', '1632')
`Match.start`([group])	用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0	email = "tony@tiremove_thisger.net" m = re.search("remove_this", email) email[:m.start()] + email[m.end():] #'tony@tiger.net' email[:m.span()[0]] + email[m.span()[1]:] #'tony@tiger.net'
`Match.end`([group])	方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
`Match.span`([group])	返回一个元组包含匹配 (开始,结束) 的位置,即返回返回 `(start(group), end(group))`

m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
m.group(0)       # The entire match：'Isaac Newton'
m.group(1)       # The first parenthesized subgroup：'Isaac'
m.group(2)       # The second parenthesized subgroup：'Newton'
m.group(1, 2)    # Multiple arguments give us a tuple.：('Isaac', 'Newton')

解析正则表达式：

r'(.*) are (.*?) .*'

这是一个字符串，前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个 r 可有可无。
(.*) 第一个匹配分组，.* 代表匹配除换行符之外的所有字符。
(.*?) 第二个匹配分组，.*? 后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符
后面的一个 .* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。

matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符

matchObj.group(1) 得到第一组匹配结果，也就是(.*)匹配到的

matchObj.group(2) 得到第二组匹配结果，也就是(.*?)匹配到的

因为只有匹配结果中只有两组，所以如果填 3 时会报错。

import re
 
line = "Cats are smarter than dogs" 
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
 if matchObj:
   print( matchObj.group())    #Cats are smarter than dogs
   print( matchObj.group(1))    #Cats
   print( matchObj.group(2))    #smarter
else:
   print "No match!!"

re.search(pattern, string, flags=0)

re.search 扫描整个字符串并返回第一个成功的匹配.

import re
print(re.search('www', 'www.runoob.com').span())         # 在起始位置匹配:(0, 3)
print(re.search('com', 'www.runoob.com').span())         # 不在起始位置匹配:(11, 14)

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

import re 
line = "Cats are smarter than dogs"; 
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print(matchObj.group())
else:
   print "No match!!"            #No match!!
 
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print(matchObj.group())       #dogs
else:
   print "No match!!"

re.sub(pattern, repl, string, count=0, flags=0)

用于替换字符串中的匹配项,其中repl：替换的字符串，也可为一个函数。count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import re
 
phone = "2004-959-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print(num)            #2004-959-559
 
# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print(num)            #2004959559

repl 参数是一个函数

import re
 
# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))    #A46G8HFD1134

re.findall(pattern, string, flags=0)

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有

import re
 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')        #['123', '456']
result2 = pattern.findall('run88oob123google456', 0, 10)  #['88', '12']

re.split(pattern, string, maxsplit=0, flags=0)

split 方法按照能够匹配的子串将字符串分割后返回列表，maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

re.split(r'\W+', 'Words, words, words.')    # ['Words', 'words', 'words', '']
re.split(r'(\W+)', 'Words, words, words.')    #['Words',',','words',',','words','.','']
re.split(r'\W+', 'Words, words, words.', 1)    #['Words', 'words, words.']
re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)    #['0', '3', '9']