字符串 & 正则表达式
一、字符串
字符串主要用于编程，概念说明、函数解释、用法详述见正文，这里补充一点：字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如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']