字符串内置函数

一.字符串
1.内置函数

str.capitalize()	将字符串的第一个字母变成大写,其他字母变小写，该方法返回一个首字母大写的字符串
str.center(width[, fillchar])	width – 字符串的总宽度，fillchar – 填充字符，返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充
str.count(sub, start= 0,end=len(string))	sub – 搜索的子字符串，start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0，end – 字符串中结束搜索的位置，默认为字符串的最后一个位置，返回子字符串在字符串中出现的次数
str.encode(encoding=‘UTF-8’,errors=‘strict’)	encoding – 要使用的编码，如: UTF-8，errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值，该方法返回编码后的字符串，它是一个 bytes 对象
bytes.decode(encoding=“utf-8”, errors=“strict”)	encoding – 要使用的编码，如"UTF-8"，errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值，该方法返回解码后的字符串
str.endswith(suffix[, start[, end]])	suffix – 该参数可以是一个字符串或者是一个元素，start – 字符串中的开始位置，end – 字符中结束位置，如果字符串含有指定的后缀返回 True，否则返回 False

>>> a='asdF'
>>> a.capitalize()
'Asdf'
>>> a='1asdFG'
>>> a.capitalize()
'1asdfg'#首字符如果是非字母，首字母不会转换成大写，会转换成小写
>>> a='www.wade.com'
>>> a.center(20,'！')
'！！！！www.wade.com！！！！'#第二个参数默认是空格，若填充则为一个字符的字符串
>>> a.center(4,'1')
'www.wade.com'#宽度不够时返回字符串
>>> a.count('w')
4
>>> a.count('w',1,2)
1
>>> a.count('w',0,4)
3
>>> a.count('m',0,len(a))
1
>>> a.count('a',0,5)#后两个参数不填则默认整个字符串计算，第二个参数》=len()，则计算到最后一个子字符（包含），第二个参数<len(),则计算到第二个参数索引（不包含当前位置）
>>> a.count('wa')
1
>>> a.count('aw')#子字符未出现计数0
0
>>> a.encode('UTF-8','strict')
b'www.wade.com'
>>> a='菜鸟教程'
>>> a.encode('UTF-8','strict')
b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
>>> a.encode('UTF-8','strict').decode('UTF-8','strict')
'菜鸟教程'#先编码再解码
>>> a='012345'
>>> a.endswith('h')
False
>>> a.endswith('5')
True
>>> a.endswith('5',0,5)
False
>>> a.endswith('5',0,6)
True
>>> a.endswith('5',1,5)
False
>>> a.endswith('5',1,6)
True
>>> a.endswith('345',0,6)
True

str.expandtabs(tabsize=8)	tabsize – 指定转换字符串中的 tab 符号(’\t’)转为空格的字符数，把字符串中的 tab 符号(’\t’)转为空格，tab 符号(’\t’)默认的空格数是 8
str.find(str, beg=0, end=len(string))	str – 指定检索的字符串，beg – 开始索引，默认为0，end – 结束索引，默认为字符串的长度，如果包含子字符串返回开始的索引值，否则返回-1
str.index(str, beg=0, end=len(string))	str – 指定检索的字符串，beg – 开始索引，默认为0，end – 结束索引，默认为字符串的长度，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常
str.join(sequence)	sequence – 要连接的元素序列,返回通过指定字符连接序列中元素后生成的新字符串
len( s )	s – 对象,返回对象长度
str.lower()	lower() 方法转换字符串中所有大写字符为小写
str.upper()	upper() 方法将字符串中的小写字母转为大写字母
str.title()	title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写

>>> a='asdfa'
>>> a.find('a')# 从下标0开始，查找在字符串里第一个出现的子串
0
>>> a.find('a',1)# 从下标1开始，查找在字符串里第一个出现的子串
4
>>> a.find('a',8)
-1
>>> a.find('1')# 查找不到返回-1
-1
>>> a.index('a')
0
>>> a.index('a',1)
4
>>> a.index('a',8)
Traceback (most recent call last):
  File "<pyshell#53>", line 1, in <module>
    a.index('a',8)
ValueError: substring not found
>>> a=''
>>> b='-'
>>> a.join(['w','a','d','e'])
'wade'
>>> b.join(['w','a','d','e'])	   
'w-a-d-e'
>>> a='I  am  xIaOLIAngpEnG!'	   
>>> a.lower()	   
'i  am  xiaoliangpeng!'
>>> a.upper()	   
'I  AM  XIAOLIANGPENG!'
>>> a.title()	   
'I  Am  Xiaoliangpeng!'

str.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
str.isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
str.isdigit()	如果字符串只包含数字则返回 True 否则返回 False
str.isnumeric()	isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象，如果字符串中只包含数字字符，则返回 True，否则返回 False
str.islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
str.isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
str.istitle()	如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False
str.isspace()	如果字符串中只包含空格，则返回 True，否则返回 False
str.isdecimal()	isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象，如果字符串是否只包含十进制字符返回True，否则返回False
str.lstrip([chars])	chars --指定截取的字符，返回截掉字符串左边的空格或指定字符后生成的新字符串

str.maketrans(intab, outtab)	intab – 字符串中要替代的字符组成的字符串，outtab – 相应的映射字符的字符串，maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标，两个字符串的长度必须相同，为一一对应的关系
str.translate(table)，bytes.translate(table[, delete])，bytearray.translate(table[, delete])	table – 翻译表，翻译表是通过 maketrans() 方法转换而来，deletechars – 字符串中要过滤的字符列表，返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射
str.ljust(width[, fillchar])	width – 指定字符串长度，fillchar – 填充字符，默认为空格，返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
max(str)	返回字符串中最大的字母
min(str)	返回字符串中最小的字母
str.replace(old, new[, max])	old – 将被替换的子字符串，new – 新字符串，用于替换old子字符串，max – 可选字符串, 替换不超过 max 次返回字符串中的 old（旧字符串），替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次
str.split(str="", num=string.count(str))	str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等，num – 分割次数。默认为 -1, 即分隔所有，split()通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num+1 个子字符串，返回分割后的字符串列表
str.splitlines([keepends])	keepends – 在输出结果里是否去掉换行符(’\r’, ‘\r\n’, \n’)，默认为 False，不包含换行符，如果为 True，则保留换行符，splitlines() 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表

>>> intab='aeiou'	   
>>> outtab='12345'	   
>>> a='aeiou12345'	   
>>> a.maketrans(intab,outtab)	   
{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
>>> a='wade'	   
>>> a.maketrans(intab,outtab)	   
{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
>>> b.maketrans(intab,outtab)	   
{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
>>> a.translate(a.maketrans(intab,outtab))	   
'w1d2'
>>> c.translate(b.maketrans(intab,outtab))	   
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    c.translate(b.maketrans(intab,outtab))
NameError: name 'c' is not defined
>>> a.translate(b.maketrans(intab,outtab))	   
'w1d2'
>>> a.ljust(3,'#')	   
'wade'
>>> a.ljust(10,'#')	   
'wade######'
>>> max(a)	   
'w'
>>> min(a)
'a'
>>> a='Wade'	   
>>> max(a)#在有大小写的字符串中返回的是小写字母的最大值	   
'e'	
>>> min(a)#有大写字母的时候,返回是小的大写字符	   
'W'
#max(str)、min(str) 方法不只判断字母，会判断字符串中的所有字符，按照字符在 unicode 中的编码值来决定大小
>>> a='this is is is ista'
>>> a.replace('is','are')	   
'thare are are are areta'
>>> a.replace('is','are',3)	   
'thare are are is ista'
>>> a='this is string example....wow!!!'	   
>>> a.split()# 以空格为分隔符	   
['this', 'is', 'string', 'example....wow!!!']
>>> a.split('w')	   
['this is string example....', 'o', '!!!']
>>> a.split('i',1)	   
['th', 's is string example....wow!!!']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

str.startswith(substr, beg=0,end=len(string))	str – 检测的字符串，substr – 指定的子字符串，strbeg – 可选参数用于设置字符串检测的起始位置，strend – 可选参数用于设置字符串检测的结束位置，startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查
str.strip([chars])	chars – 移除字符串头尾指定的字符序列，strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列
str.swapcase()	返回大小写字母转换后生成的新字符串
str.zfill(width)	width – 指定字符串的长度。原字符串右对齐，前面填充0，返回指定长度的字符串
str.rstrip([chars])	chars – 指定删除的字符（默认为空格），返回删除 string 字符串末尾的指定字符后生成的新字符串
str.rfind(str, beg=0 end=len(string))	返回字符串最后一次出现的位置，如果没有匹配项则返回-1
str.rindex(str, beg=0 end=len(string))	rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间
str.rjust(width[, fillchar])	width – 指定填充指定字符后中字符串的总长度.fillchar – 填充的字符，默认为空格，返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串

>>> a='wadebosh'
>>> a.startswith('wade')
True
>>> a.startswith('ade')
False
>>> a.startswith('bosh',4)
True
>>> a.startswith('wade',4,6)
False
>>> a='   wade    '
>>> a.strip()#默认删除空格
'wade'
>>> a='123wade321'
>>> a.strip('123')#只要头尾有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止
'wade'
>>> a='*****wade***********'
>>> a.strip('*')
'wade'
>>> a='aSdGFhghFDhGhjHJ'
>>>> a.swapcase()
'AsDgfHGHfdHgHJhj'
>>> a.zfill(50)
'0000000000000000000000000000000000aSdGFhghFDhGhjHJ'
>>> a.rstrip()
'*****wade***********'
>>> a.rstrip('*')
'*****wade'
>>> str1 = "this is really a string example....wow!!!"
>>>> str1.rfind('is')
5
>>> str1.rindex('is')
5
>>> str1.rjust(50,'*')
'*********this is really a string example....wow!!!'

2.转义字符
在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：

>>> print('a')
a
>>> print('a'\
	  'b')
ab
>>> print('aaaa\
bbbbb')
aaaabbbbb
>>> print(r'\\\\\\\\')#原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，
没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，
与普通字符串有着几乎完全相同的语法
\\\\\\\\
>>> print('I\'M  xiaoliangpeng')
I'M  xiaoliangpeng
>>> print('as\\df')
as\df
>>> print('a ssd\"')
a ssd"
>>> print('a ssd\a')
a ssd
>>> print('a ssd\b')
a ssd
>>> print('a ssd\000')
a ssd

3.字符串格式化

>>> print('dhaddjkh%dge  pingguo'%3)
dhaddjkh3ge  pingguo
>>> print('dhaddjkh%sge  pingguo'%'asdf')
dhaddjkhasdfge  pingguo
>>> print('dhaddjkh%2fge  pingguo'%3.234567)
dhaddjkh3.234567ge  pingguo

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，函数 str.format()，它增强了字符串格式化的功能