python-字符串
字符串序列用于表示和存储文本，python中字符串是不可变对象。字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，一对单，双或三引号中间包含的内容称之为字符串。其中三引号可以由多行组成，编写多行文本的快捷语法，常用文档字符串，在文件的特定地点，被当做注释。便捷的多行注释。
在 Python 中处理文本数据是使用 str 对象，也称为 字符串。
Python 有一组可以在字符串上使用的内建方法。
注释：处理判断方法，所有字符串方法都返回新值。它们不会更改原始字符串。
| 方法 |
描述 |
string.capitalize() |
把字符串的第一个字符大写 |
string.center(width) |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
string.count(str, beg=0, end=len(string)) |
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
string.decode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' |
string.encode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
string.endswith(obj, beg=0, end=len(string)) |
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
string.expandtabs(tabsize=8) |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
string.find(str, beg=0, end=len(string)) |
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
string.index(str, beg=0, end=len(string)) |
跟find()方法一样，只不过如果str不在 string中会报一个异常. |
string.isalnum() |
如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
string.isalpha() |
如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
string.isdecimal() |
如果 string 只包含十进制数字则返回 True 否则返回 False. |
string.isdigit()] |
如果 string 只包含数字则返回 True 否则返回 False. |
string.islower()] |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
string.isnumeric()] |
如果 string 中只包含数字字符，则返回 True，否则返回 False |
string.isspace()] |
如果 string 中只包含空格，则返回 True，否则返回 False. |
string.istitle()] |
如果 string 是标题化的(见 title())则返回 True，否则返回 False |
string.isupper()] |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
string.join(seq)] |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
string.ljust(width)] |
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
string.lower()] |
转换 string 中所有大写字符为小写. |
string.lstrip()] |
截掉 string 左边的空格 |
string.maketrans(intab, outtab])] |
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
max(str)] |
返回字符串 str 中最大的字母。 |
min(str)] |
返回字符串 str 中最小的字母。 |
string.partition(str)] |
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
string.replace(str1, str2, num=string.count(str1)) |
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
string.rfind(str, beg=0,end=len(string) ) |
类似于 find()函数，不过是从右边开始查找. |
string.rindex( str, beg=0,end=len(string)) |
类似于 index()，不过是从右边开始. |
string.rjust(width) |
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
string.rpartition(str) |
类似于 partition()函数,不过是从右边开始查找. |
string.rstrip()] |
删除 string 字符串末尾的空格. |
string.split(str="", num=string.count(str)) |
以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
string.splitlines(num=string.count('\n')) |
按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. |
string.startswith(obj, beg=0,end=len(string)) |
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
string.strip([obj]) |
在 string 上执行 lstrip()和 rstrip() |
string.swapcase()] |
翻转 string 中的大小写 |
string.title()] |
返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
string.translate(str, del="") |
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
string.upper() |
转换 string 中的小写字母为大写 |
string.zfill(width) |
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
string.isdecimal() |
isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
1、字符串切片
|
操作 |
说明 |
|
str[:] |
提取整个字符串 |
|
str[start:] |
从start 提取到结尾 |
|
str[:end] |
从开头提取到end - 1 |
|
str[start:end] |
从start 提取到end - 1 |
|
str[start:end:step] |
从start 提取到end - 1,每step 个字符提取一个 |
|
|
|
str = '0123456789′
print(str[0:3] #截取第一位到第三位的字符
print(str[:] #截取字符串的全部字符
print(str[6:] #截取第七个字符到结尾
print(str[:-3] #截取从头开始到倒数第三个字符之前
print(str[2] #截取第三个字符
print(str[-1] #截取倒数第一个字符
print(str[::-1] #创造一个与原字符串顺序相反的字符串
print(str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print(str[-3:] #截取倒数第三位到结尾
2、字符串分割和组合
|
方法 |
说明 |
| 1 |
split(sep,maxsplt) |
切割功能，切割后 形成的是列表。 |
|
rsplit() |
从右面切割 |
|
splitness([keepends]) |
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表, 结果列表中不包含行边界，除非给出了 keepends 且为真值。 |
|
partition(sep) |
用来根据指定的分隔符将字符串进行分割,如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。如果sep没有出现在字符串中，则返回值为(sep,",")。partition() 方法是在2.5版中新增的。 |
|
rpartition(sep) |
类似于 partition()函数,不过是从右边开始查找 |
|
join(seq) |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
|
|
|
str1 = 'ab c\n\nde fg\rkl\r\n'
print (str1.splitlines())
str2 = 'ab c\n\nde fg\rkl\r\n'
print (str2.splitlines(True))
# 结果
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
s = " hello world"
print(s.split()
print(s.split(' '))
# 结果
['hello', 'world']
['', '', 'hello', 'world']
t='I love you more than I can say'
t.split(' ',3)
# ['I','love','you','more than I can say']
a_str=’-‘
a_str.join("abdcd")
print(a_str)
# 结果
'a-b-d-c-d'
list1 = ['a','b','c']
r_str=''.join(list1)
print(r_str)
# 结果
’abc‘
3、查找替换
|
函数 |
说明 |
| 1 |
count(sub[,start[,end]]) |
统计字符串里某个字符sub出现的次数。可选参数为在字符串搜索的开始与结束位置。这个数值在调用replace方法时用得着。 |
|
find(sub[,start[,end]]) |
字符串中是否包含子字符串sub，如果指定start（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1 |
|
rfind(sub[,start[,end]]) |
类似于 find()函数，不过是从右边开始查找 |
|
index(sub[,start[,end]]) |
跟find()方法一样，只不过如果sub不在 string中会抛出ValueError异常。 |
|
rindex(sub[,start[,end]]) |
类似于 index()，不过是从右边开始。 |
|
replace(old,new[,count]) |
用来替换字符串的某些子串，用new替换old。如果指定count参数话，就最多替换count次，如果不指定，就全部替换 |
前面五个方法都可以接受start、end参数，善加利用可以优化性能。对于查找某个字符串中是否有子串，不推荐使用index族和find族方法，推荐使用in和not in操作
my_str = "hello world itcast and itcastcpp"
num = my_str.find("itcast") # 返回的是第一个
print(num) # 输出的值是 12
num1 = my_str.find("itcast", 15)
print(num1) # 输出的值是 23
num4 = my_str.count("itcast")
print(num4) # 输出的结果是 2
str = "this is string example....wow!!! this is really string"
print(str.replace("is", "was"))
print(str.replace("is", "was", 3)) # 替换三次
thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string
4、删减与填充
删除
|
函数 |
说明 |
|
strip([chars]) |
移除字符串头尾指定的字符（默认为空格），如果有多个就会删除多个 |
|
lstrip([chars]) |
用于截掉字符串左边的空格或指定字符。（默认为空格） |
|
rstrip([chars]) |
用于截掉字符串右边的空格或指定字符。（默认为空格） |
|
|
|
str = "00000003210Runoob01230000000"
print(str.strip( '0' )) # 3210Runoob0123
填充
|
函数 |
说明 |
|
center(width) |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
|
ljust(width[,fillchar]) |
返回一个原字符串左对齐,并使用fillchar填充至指定长度的新字符串，默认为空格 |
|
rjust(width[,fillchar]) |
返回一个原字符串右对齐,并使用fillchar填充至长度 width 的新字符串 |
|
zfill(width) |
返回指定长度的字符串，原字符串右对齐，前面填充0 |
|
expandtabs([tabsize]) |
把字符串中的 tab 符号('\t')转为适当数量的空格 |
a_txt = "banan"
x = a_txt.center(10,'0')
print(x) # 00banan000
b_txt = "banan"
x = b_txt.ljust(10,'0')
print(x) # banan00000
b_txt = "banan"
x = b_txt.rjust(10,'0')
print(x) # 00000banan
str = "this is string"
print(str.zfill(20))
print(str.zfill(30))
# 输出 跟 string.rjust(width,'0') 输出结果一样
000000this is string
0000000000000000this is string
5、字符串大小写
|
函数 |
说明 |
|
lower() |
转换 string 中所有大写字符为小写，不需要返回 |
|
upper() |
转换 string 中所有小写字符为大写 |
|
title() |
所有单词都是以大写开始，其余字母均为小写 |
|
|
|
|
capitalize() |
返回原字符串的副本，其首个字符大写，其余为小写。 |
|
swapcase() |
翻转 string 中的大小写 |
a_str = 'a, B'
as_str=a_str.capitalize()
print(as_str) # 'A, b'
b_str = ' a, B'
bs_str=b_str.capitalize()
print(bs_str) # ' a, b'
a_str = 'a, B'
as_str=a_str.title()
print(as_str) # ‘A, B’
6、字符串判断
|
函数 |
说明 |
|
isalnum() |
是否全是字母和数字，并至少有一个字符，返回True |
|
isalpha() |
是否全是字母，并至少有一个字符,返回True |
|
isdigit() |
是否全是数字，并至少有一个字符,返回True |
|
isdecimal() |
只包含十进制数字则返回 True |
|
isnumeric() |
只包含数字字符，则返回 True， |
|
islower() |
字符串中字母是否全是小写,返回True |
|
isupper() |
字符串中字母是否全是大写,返回True |
|
isspace() |
是否全是空白字符，并至少有一个字符,返回True |
|
istitle() |
是否每个单词都有且只有第一个字母是大写,返回True |
|
isascii() |
所有字符都是 ASCII ，返回 True |
|
startswith(prefix[,start[,end]]) |
用于检查字符串是否是以指定子字符串开头，如果是则返回 True |
|
endswith(suffix[,start[,end]]) |
用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True |
7、字符串格式化
format(*args, **kwargs)
format_map(map)
% 格式
|
转换说明符 |
解释 |
|
%d、 %i |
转换为带符号的十进制整数 |
|
%o |
转换为带符号的八进制整数 |
|
%x、 %X |
转换为带符号的十六进制整数 |
|
%e |
转化为科学计数法表示的浮点数（e 小写） |
|
%E |
转化为科学计数法表示的浮点数（E 大写） |
|
%f、 %F |
转化为十进制浮点数 |
|
%g |
智能选择使用 %f 或 %e 格式 |
|
%G |
智能选择使用 %F 或 %E 格式 |
|
|
|
age = 8
print("my age is " % age)
# % 格式的占位符
# 指定占位符宽度
print ("Name:%10s Age:%8d Height:%8.2f"%("Aviad",25,1.83))
Name: Aviad Age: 25 Height: 1.83
# 指定占位符宽度（左对齐）
s = ('%10s' * 2 + '%15g' * 3) % (1,2,3,4,5)
print(s)
# 1 2 3 4 5
用法：它通过 {} 和 ： 代替传统的 % 方法
1、位置参数
>>> li = ['zhangsan',18]
>>> 'my name is {} ,age {}'.format('zhangsan',18)
'my name is hoho ,age 18'
>>> 'my name is {1} ,age {0}'.format(10,'zhangsan')
'my name is hoho ,age 10'
>>> 'my name is {1} ,age {0} {1}'.format(10,'zhangsan')
'my name is hoho ,age 10 hoho'
>>> 'my name is {} ,age {}'.format(*li)
'my name is hoho ,age 18'
2、关键字参数
键字参数值要对得上，可用字典当关键字参数传入值，字典前加**即可
>>> hash = {'name':'zhangsan','age':18}
>>> 'my name is {name},age is {age}'.format(name='zhangsan',age=19)
'my name is zhangsan,age is 19'
>>> 'my name is {name},age is {age}'.format(**hash)
'my name is zhangsan,age is 18'
3、填充和对齐
'{:<20}'.format(10) #左对齐
'10 '
'{:>20}'.format(10) #右对齐
' 10'
'{:^20}'.format(10) #居中对齐
' 10
'f{}' f-字符串
f-string采用 {content:format} 设置字符串格式，其中 content 是替换并填入字符串的内容，可以是变量、表达式或函数等，format是格式描述符
可以 自定义格式：对齐、宽度、符号、补零、精度、进制
|
格式 |
作用 |
{name:>10} |
< |
左对齐 |
{name:<10} |
> |
右对齐 |
{name:^10} |
^ |
中间对齐 |
name='zhangsan'
age=19
print(F"Hello, {name}. You are {age}.")
# 右对齐10
name='zhangsan'
print (f"{name:>10}") # zhangsan
# 指定宽度和精度
s = 'hello'
print(f's is {s:8s}')
# s is hello
a = 123.456
print(f'a is {a:8.2f}')
'a is 123.46'
|
格式描述 |
作用 |
|
{s:8s} |
width |
指定整数width 宽度 |
|
{s:08s} |
0width |
整数width指定宽度，开头0指定高位用0补足宽度 |
不可用于复数类型和非数值类型 |
{s:8.2f} |
width.precision |
整数width指定宽度，整数precision指定显示精度 |
不可用于整数类型 |
案例
| 输入字符 |
格式化字符 |
输出 |
说明 |
| 3.1415926 |
{:.2f} |
3.14 |
保留小数点后两位 |
| 3.1415926 |
{:+.2f} |
+3.14 |
带符号保留小数点后两位 |
| -1 |
{:+.2f} |
-1.00 |
带符号保留小数点后两位 |
| 2.71828 |
{:.0f} |
3 |
不带小数 |
| 5 |
{:0>2d} |
05 |
数字补零 (填充左边, 宽度为2) |
| 5 |
{:x<4d} |
5xxx |
数字补x (填充右边, 宽度为4) |
| 10 |
{:x<4d} |
10xx |
数字补x (填充右边, 宽度为4) |
| 1000000 |
{:,} |
1,000,000 |
以逗号分隔的数字格式 |
| 0.25 |
{:.2%} |
25.00% |
百分比格式 |
| 1000000000 |
{:.2e} |
1.00e+09 |
指数记法 |
| 18 |
{:>10d} |
18' |
右对齐 (默认, 宽度为10) |
| 18 |
{:<10d} |
'18 ' |
左对齐 (宽度为10) |
| 18 |
{:^10d} |
18 ' |
中间对齐 (宽度为10) |
|
|
|
|
8、字符串转换
translate(table) # 每个字符按给定的转换表进行映射
使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表
9、string模块
ascii_letters # 获取所有ascii码中字母字符的字符串（包含大写和小写）
ascii_uppercase # 获取所有ascii码中的大写英文字母
ascii_lowercase # 获取所有ascii码中的小写英文字母
digits # 获取所有的10进制数字字符
octdigits # 获取所有的8进制数字字符
hexdigits # 获取所有16进制的数字字符
printable # 获取所有可以打印的字符
whitespace # 获取所有空白字符
punctuation # 获取所有的标点符号
10、常用技巧
反转字符串
>>> s = '1234567890'
>>> print s[::-1]
0987654321
字符串的拼接
尽量使用join()链接字符串，因为’+’号连接n个字符串需要申请n-1次内存,使用join()需要申请1次内存。
固定长度分割字符串
>>> import re
>>> s = '1234567890'
>>> re.findall(r'.{1,3}', s) # 已三个长度分割字符串
['123', '456', '789', '0']
