【Python基础】字符串 & 正则表达式

一、字符串

字符串主要用于编程，概念说明、函数解释、用法详述见正文，这里补充一点：字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如s=“abcdefghij”，则s[1]=“b”，s[9]=“j”，这可以给我们提供很多方便，如高精度运算时每一位都可以转化为数字存入数组。

• Python 字符串支持' '、" "、''' '''三种定义方式。
• Python 字符串是序列的一种，属于不可变序列。
• Python 字符串支持双向索引取出字符、切片操作（无法赋值）。

字符串（str）的基本操作：

#创建字符串
a = 'abc'
b = '123'
#连接字符串
c = a + b	#c = 'abc123'
#查看类型
type(c)		#<class 'str'>
#迭复字符串
a * 2		#'abcabc'
#判断字串是否在字符串内
b in c		#True
#判断长度
len(c)		#6
#双向索引取出取字符
c[1]		#'b'
c[-2]		#'2'
#切片操作
c[::]		#等同于c[:]，'abc123'
c[1:]		#等同于c[1::1]，'bc123'
c[1::2]		#'b13'
c[:2]		#'ab'
c[:-2]		#'abc1

二、函数处理

1、查找

方法名	作用	参数
find / rfind	查找字串在母串指定范围中 首次 / 最后一次 出现的位置 不存在返回-1	find / rfind(sub_str [, start_index [, end_index]])
index / rindex	查找字串在母串指定范围中 首次 / 最后一次 出现的位置 不存在抛出异常substring not found	index / rindex(sub_str [, start_index [, end_index]]
count	计算字串在母串中出现的次数	count(sub_str)

其中,sub_str代表模式子串，start_index 代表起始索引，end_index 代表结束索引。如若省略 end_index 则查询范围从起始索引至串尾，如若同时省略 start_index 则默认查询范围为整个母串。

#创建字符串
s = 'haha,blue,ground,approach,haha,red,yellow,blue,ground'
#调用 find / rfind 方法
s.find('haha')		#结果：0
s.rind('haha')		#结果：26
#调用 index / rindex 方法
s.index('blue')		#结果：5
s.rindex('blue')	#结果：42
#指定范围查找
s.index('haha',4)	#结果：26
s.find('ha',4,9)	#结果：-1
#比较异同
s.rindex('haa')
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#ValueError: substring not found
s.rfind('haa')
#-1
#调用 count 方法
s.count('approach')	#结果：1
s.count('ground')	#结果：2
s.count('haa')		#结果：0

2、分割

方法名	作用	参数
split / rsplit	指定字符为分隔符（不指定默认为任何空白字符），从左端 / 右端 开始，将字符串分割为字符串列表，并返回	split / rsplit([pattern_sub])
partition / rpartition	指定字符为分隔符（必须指定字符），从左端 / 右端 开始，将字符串分割为“前串”，“分隔符”，“后串”三部分组成的字符串元组，并返回	partition / rpartition(pattern_sub)

#split / rsplit：
#创建字符串
s = 'haha,blue,ground,approach,haha,red,yellow,blue,ground'
t = 'a sd dfg \n\r sadadas asdasd\v asdasd \t asdasdas'
#分割字符串
s.split(',')		#['haha', 'blue', 'ground', 'approach', 'haha', 'red', 'yellow', 'blue', 'ground']
#规定最大分割次数，并逆向（从右端）开始分割
s.rsplit(',',maxsplit=6)	#['haha,blue,ground', 'approach', 'haha', 'red', 'yellow', 'blue', 'ground']
#不传入参数（默认为任何空白字符）
t.split()			#['a', 'sd', 'dfg', 'sadadas', 'asdasd', 'asdasd', 'asdasdas']
#partition / rpartition：
#三分字符串
s.partition(',')	#('haha', ',', 'blue,ground,approach,haha,red,yellow,blue,ground')
s.rpartition(',')	#('haha,blue,ground,approach,haha,red,yellow,blue', ',', 'ground')

3、大小写转换

方法名	作用
lower / upper	转换为 全小写 / 大写 串
capitalize	字符串首字母大写
title	标题化，每个单词首字母大写（以空格为分隔）
swapcase	所有字母大小写互换

大小写转换的所有方法均为无参方法。

#创建字符串
s = 'What is that?'
t = 'why students should be encouraged to develop creativity'
r = 'sASSASAS.rAaaaA'
#全大小写串转换
s.upper()	#'WHAT IS THAT?'
s.lower()	#'what is that?'
#字符串首字母大写
r.capitalize()	#'Sassasas.raaaa'
#标题化字符串
t.title()		#'Why Students Should Be Encouraged To Develop Creativity'
#大小写互换
r.swapcase()	#'Sassasas.RaAAAa'

4、修剪

方法名	作用	参数
strip	删除两端连续空白字符(无参数) / 指定字符	strip([pattern_str])
lstrip	删除左端连续空白字符(无参数) / 指定字符	lstrip([pattern_str])
rstrip	删除右端连续空白字符(无参数) / 指定字符	rstrip([pattern_str])

#创建字符串
s = '   \t \v\n I am fine! \r'
u = '     username     '
x = ' aaa aa a x a aa aaa'
#修剪字符串
s.strip()		#'I am fine!'
u.lstrip()		#'username     '
x.lstrip('a')	#串首有空格所以不会发生变化，' aaa aa a x a aa aaa'
x.rstrip('a')	#只会删除首次相遇的连续指定字符，' aaa aa a x a aa '

5、检测开头结尾

方法名	作用	参数
startswith	判断是否以子串开头	startswith(start_str)
endswith	判断是否以子串结尾	endswith(end_str)

#创建字符串
s = '001|Have a nice day!'
#判断开头结尾
s.startswith('001')		#True
s.endswith('001')		#False

6、排版

方法名	作用	参数
center	居中对齐，需指定长度，填充字符默认为空格，亦可自定义填充字符	center(length [,fill_char])
ljust	左对齐，需指定长度，填充字符默认为空格，亦可自定义填充字符	ljust(length [,fill_char])
rjust	右对齐，需指定长度，填充字符默认为空格，亦可自定义填充字符	rjust(length [,fill_char])
zfill	返回指定宽度字符串，其余位以‘0’作为填充	zfill(length)

#创建字符串
s = 'I am fine'
t = '12589'
#字符串居中，默认填充字符
s.center(15)		#'   I am fine   '
#字符串居中，指定填充字符'-'
s.center(15,'-')	#'---I am fine---'
#字符串左、右对齐
s.ljust(20)			#'I am fine           '
s.rjust(20)			#'           I am fine'
#字符串填充0
t.zfill(len(t) + 10)	#原串长度为5，向串前填充10个0，'000000000012589'

7、串型判断

• 串型判断的所有方法均为无参方法。

数字型判断

方法名	功能
isalnum	判断串是否由 字母 / 数字 组成
isdigit	判断串是否由 全数字 组成
isdecimal	判断串是否 只包含十进制数字 字符
isnumeric	判断串是否由 具有数字含义的字符 构成 （支持纯阿拉伯数字、汉字大小写数字、罗马数字及其组合）

#创建字符串
s1 = '一'
s2 = '玖'
s3 = 'Ⅸ'
s4 = '0.1250'
s5 = '010'
s6 = 'a1234'
#判断
#isalnum()				判断串是否由 字母 / 数字 组成
s6.isalnum()				#数字 + 字母：True
s5.isalnum()				#全数字：True
#isnumeric()			具有数字含义的字符 构成
#支持纯阿拉伯数字、汉字大小写数字、罗马数字及其组合
s1.isnumeric				#小写汉字数字：True
s2.isnumeric()				#大写汉字数字：True
s3.isnumeric()				#罗马数字：True
s5.isnumeric()				#阿拉伯数字：True
(s3+s2+s1).isnumeric()		#混合数字字符：True
s4.isnumeric()				#包含'.'：False
#isdecimal()			判断串是否 只包含十进制数字 字符
s4.isdecimal()				#包含'.'：False
s5.isdecimal()				#仅包含十进制数字：True
#isdigit()				断串是否由 全数字 组成
s4.isdigit()				#包含'.'：False
s5.isdigit()				#仅包含数字：True

字母型判断

方法名	功能
isalnum	判断串是否由 字母 / 数字 组成
isalpha	判断串是否由 全字母 组成
isupper	判断串是否为 全大写 字母串
islower	判断串是否为 全小写 字母串

#创建字符串
s1 = 'AAAA'
s2 = 'bbb'
s3 = 'I am fine.'
s4 = 'Abcd@'
s5 = 'a1234'
#isalnum()			判断串是否由 字母 / 数字 组成
s4.isalnum()			#包含特殊字符：False
s5.isalnum()			#数字 + 字母：True
s1.isalnum()			#纯字母：True
#isalpha()			判断串是否由 全字母 组成
s3.isalpha()			#纯字母：True
s4.isalpha()			#包含特殊字符：False
s5.isalpha()			#数字 + 字母：False
#isupper()			判断串是否为 全大写 字母串
s1.isupper()			#纯大写字母：True
s2.isupper()			#纯小写字母：False
s3.isupper()			#大小写混合：False
#islower()			判断串是否为 全小写 字母串
s1.islower()			#纯大写字母：False
s2.islower()			#纯小写字母：True
s3.islower()			#大小写混合：False

空白型判断

方法名	功能
isspace	判断串是否为纯空白字符串

#创建字符串
s = '   \n \r \v   \t '
#判断是否为空白字符串
s.isspace()		#True

8、语句转化

核心函数：eval(str)

• 用途：将字符串转化为语句并执行，这意味着我们可以让程序自动拼出语句执行

#创建变量
a = 3
b = 4
#执行字符串型语句
eval('6+9')				#15
eval("a + b")			#7
#导包执行其他语句
import math
eval('math.pow(4,3)')	#64.0

三 、正则表达式匹配

常用字符	功能匹配
.	任意单字符（除换行符外）
*	子模式 0 次 / 多次出现
+	子模式 1 次 / 多次出现
-	在[ ]中表示范围
^	模式开头
$	模式结尾
?	匹配位于“?”之前的0个或1个字符或子模式
\w	字母、数字、下划线
\n	换行符
\d	数字
\b	单词头 / 单词尾
()	将()中内容作为一个整体来看待
[]	匹配位于[]中的任意一个字符
{}	按{}中指定的次数进行匹配，例如，{3,8}表示前面的字符或模式至少重复3次而最多重复8次

正则表达式模式串前须加字母r：r'模式串'

1、正则模块处理

一般方法：

方法名	功能	参数
compile	创建模式对象	compile(pattern_str [, flags])
escape	将字符串所有特殊正则表达式字符转义	escape(str)
findall	字符串所有模式匹配项	findall(pattern_str , str [, flags])
purge	清空正则表达式内存	purge()
split	根据模式匹配项，分割字符串	split(pattern_str , str [, maxspilt=0])

#导入正则模块处理包re
import re
#创建字符串：
s = 'apple,approach,agree'
x = ' aaa aa a x a aa aaa'
#寻找所有以a开头的单词
re.findall('a\w+',s)		#['apple', 'approach', 'agree']
#清空正则表达式内存
re.purge()
#分割字符串，指定多个可能的分隔符
re.split(r'[,.\|]',s)		#['apple', 'approach', 'agree']
#分割字符串，指定多个可能的分隔符、最大分割次数
re.split(r'[,.\|]',s,1)		#['apple', 'approach,agree']

Match对象支持方法：

方法名	功能	参数
fullmatch
match	字符串串首单一模式匹配项，若不匹配则返回None
search	字符串整串单一模式匹配项，若不匹配则返回None
sub	字符串替换，返回结果为替换后字符串	sub(pat, repl , str [, count=0])
subn	字符串替换，返回结果为替换后字符串与替换次数组成的元组	subn(pat, repl , str [, count=0])

#导入正则模块处理包re
import re
#创建字符串：
s = 'apple,approach,agree'
x = ' aaa aa a x a aa aaa'

#查找
re.findall(r'\ba\w*\b',s)		#['apple', 'approach', 'agree']
re.findall(r'\ba\w*\b',x)		#['aaa', 'aa', 'a', 'a', 'aa', 'aaa']
#查找长度为5的单词
#从串首匹配模式，若不匹配则返回None
re.match(r'\b[a-zA-Z]{5}\b'，s)		#<re.Match object; span=(0, 5), match='apple'>
#对整个字符串（起始位置不定）匹配模式，若不匹配则返回None
re.search(r'\b[a-zA-Z]{5}\b'，s)		#<re.Match object; span=(0, 5), match='apple'>

#替换
#指定寻找模式（以a开头的单词）
re.sub(r'\ba\w+\b','*',s,1)	#将满足条件的字符替换为指定字符*，只替换一次：'*,approach,agree'
re.subn(r'\ba\w+\b','*',s,1)	#与上语句唯一不同之处在于，返回值为结果串与替换次数组成的元组：('*,approach,agree', 1)

2、正则对象处理

• 相较于模块re处理，提高了处理速度，功能更强大，提高模式串复用率

方法名	功能	参数
findall	字符串所有模式匹配项	findall(str [, pos [ , endpos]])
match	字符串串首单一模式匹配项，若不匹配则返回None	match(str [, pos [ , endpos]])
search	字符串整串单一模式匹配项，若不匹配则返回None	search(str [, pos [ , endpos]])
sub	字符串替换，返回结果为替换后字符串	sub(repl , str [, count=0])
subn	字符串替换，返回结果为替换后字符串与替换次数组成的元组	subn(repl , str [, count=0])
split	根据模式匹配项，分割字符串	split(str [, maxspilt=0])

正则对象处理的方法名与正则模块处理相同：

#导入正则模块处理包re
import re
#创建字符串：
s = 'apple,approach,agree'
x = ' aaa aa a x a aa aaa'
#查找以字母'a'开头的单词，创建正则对象
pattern = re.compile(r'\ba\w*\b')
#查找
pattern.findall(s)		#['apple', 'approach', 'agree']
pattern.findall(x)		#['aaa', 'aa', 'a', 'a', 'aa', 'aaa']
#查找长度为5的单词，创建正则对象
pattern = re.compile(r'\b[a-zA-Z]{5}\b')
#从串首匹配模式，若不匹配则返回None
pattern.match(s)		#<re.Match object; span=(0, 5), match='apple'>
#对整个字符串（起始位置不定）匹配模式，若不匹配则返回None
pattern.search(s)		#<re.Match object; span=(0, 5), match='apple'>

#替换
#指定寻找模式（以a开头的单词）
pattern = re.compile(r'\ba\w+\b');
pattern.sub('*',s,1)	#将满足条件的字符替换为指定字符*，只替换一次：'*,approach,agree'
pattern.subn('*',s,1)	#与上语句唯一不同之处在于，返回值为结果串与替换次数组成的元组：('*,approach,agree', 1)

#分割字符串，指定多个可能的分隔符
pattern = re.compile(r'[,.\|]')
pattern.split(s)		#['apple', 'approach', 'agree']
#分割字符串，指定多个可能的分隔符、最大分割次数
pattern.split(s,1)		#['apple', 'approach,agree']