3.python-str

python-字符串

[TOC]

字符串序列用于表示和存储文本，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

format

用法：它通过 {} 和 ： 代替传统的 % 方法

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']