字符串操作方法

生成字符串
str = ‘Python string Function study‘

sequence类型都支持的一些通用操作：
成员检查：in、not in                ‘Py‘ in str    ‘python‘ not in str
连接：+                             str_new = str1 + str2
复制：*                             str * 2
下标取值：s[i]                      str[3]
切片：s[i : j]                      str[3:8]
长度检查：len(s)                    len(str)         print(‘%s length = %d‘ % (str,len(str)))
最小值：min(s)                      min(str)                           空格在上面字符串中是最小的
最大值：max(s)                      max(str)                            大写字母要小于小写字母

字符串切片
1. 字符串变量名[x:y]，表示下标从x到y的一段字符串（不包括y）。
当x不写，像[:y]，表示从头开始，相当于[0:y]。当y不写时，表示一直到尾。当x和y两个都不写时，就表示整个字符串。
str_result = str[3:8]               
2. 步长切片截取
使用两个冒号来实现按一定“步数”来取值的 [x:y:z]
str_result = str[1:9:3]             #即从第1个字符开始，每隔3个位移取一个值,到第9个字符截止（不包括第9个字符）

一. 查找 & 替换类方法

1. str.count(sub, start= 0,end=len(string))
返回字符串里某个字符或是子字符串出现的次数。可选参数为在字符串搜索的开始(默认为第一个字符)与结束(默认为最后一个字符)位置。
str = ‘Python string Function‘
str_result = str.count(‘th‘, 2, 15)

2. str.find(str, beg=0, end=len(string))   str.rfind(sub[, start[, end]])    str.index(sub[, start[, end]])    str.rindex(sub[, start[, end]])
检测字符串中是否包含子字符串 str ，如果指定可选参数 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
index()方法与find()方法一样，如果包含子字符串则返回开始的索引值，只不过index()方法如果str不在 string中会报一个异常。
str = ‘Python string Function‘
str_result = str.find(‘python‘, 1, len(str))        #find()查找的是子字符串在全字符串中出现的第一个位置，匹配到字符串就结束查找，不管后面还有没有匹配的字符串。
str_result = str.rfind(‘string‘, 1, len(str))        #从最右边开始查找，但返回的index位置却是从原字符串的最左边开始算的
str_result = str.index(‘Python‘, 0, len(str))
str_result = str.rindex(‘string‘, 0, len(str))

3. str.replace(old, new[, count])
返回一个新字符串，原串中的old被替换为new，可选参数count指定替换次数。
str = ‘aaalllaaannn‘
str_result = str.replace(‘a‘, ‘d‘, 4)

4. str.maketrans(x[, [y, z]])      str.translate(map)
用于创建字符映射的转换表，接受两个参数x, y的最简单的调用方式，第一个参数是字符串中需要转换的字符组成的字符串，第二个参数也是字符串表示要转换的目标。 可选参数Z 的意思是删除原字符串中的相应字符
两个参数字符串的长度必须相同，且为一一对应的关系。
table = str.maketrans(‘al‘, ‘bc‘, ‘n‘)
str = ‘alan‘
str_result = str.translate(table)

二. 判断类方法，通常返回True和False

5. str.endswith(suffix[, start[, end]])    str.startswith(str, beg=0,end=len(string))
用于判断字符串是否以指定子字符串 结尾和开头，如果是则返回True，否则返回False。如果可选参数指定值，则在指定范围内检查。默认检索字符串的开始(默认为第一个字符)与结束(默认为最后一个字符)位置。
str_result = str.endswith(‘dy‘, 10, 30)
str_result = str.startswith(‘P‘, 0, 10)

6. str.isalnum()
检测字符串是否由字母和数字组成，如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
str = ‘abc 123‘
str_result = str.isalnum()          #字符串中包含空格也会返回False, 中文字符是被允许的，也会返回True

7. str.isalpha()
检测字符串是否只由字母组成, 如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
str = ‘abc‘
str_result = str.isalpha()          #中文字符是被允许的，也会返回True

8. str.isdigit()       str.isdecimal()        str.isnumeric()
检测字符串是否只由数字组成, 如果字符串至少有一个字符并且只包含数字则返回 True 否则返回 False
str.isdecimal()：判断字符串是否只包含十进制数字字符，包括多国语言的十进制数字字符表现形式
str.isdigit()：判断字符串是否只包含数字，这里的数字包括十进制数字和其它特殊数字（如上标数字等），一个数字是拥有如下属性值的字符：Numeric_Type=Digit或Numeric_Type=Decimal。
str.isnumeric()：判断字符串是否只包含数字字符。数字字符范围很大，一般来说，数字字符是拥有如下属性值的字符：Numeric_Type=Digit, Numeric_Type=Decimal或Numeric_Type=Numeric。
str = ‘12345‘
str_result = str.isdigit()
str_result = str.isdecimal()
str_result = str.isnumeric()

9. str.isspace()
检测字符串是否只由空格或制表符(\t)组成. 是则返回True, 否则返回False
str = ‘   ‘
str_result = str.isspace()

10. str.islower()   str.isupper()
检测字符串中的字母字符是否全部由小写字母组成. 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isupper()方法检测字符串中所有的字母是否都为大写。同样返回True, 或是False
这两种方法仅判断字符串中的字母字符，不理会其它字符。字符串必须至少包含一个字母字符，否则返回False
str = ‘al%an‘
str_result = str.islower()
str_result = str.isupper()

11. str.istitle()
检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。是则返回 True，否则返回 False.
字符串必须至少包含一个字母字符，否则返回False。即使首字母字符前面有非字母字符，如中文、数字、下划线等，也不影响对首字母字符的判断。
str = "Alan Python"
str_result = str.istitle()                     #"Alan‘s Python" 返回的结果是False

12. str.isidentifier()
判断字符串是否是合法的标识符，字符串仅包含中文字符合法，实际上相当于判断的是变量名是否合法
str = "_Alan_Python"
str_result = str.isidentifier()

13. str.isprintable()
判断字符串所包含的字符是否全部可打印。字符串包含不可打印字符，如转义字符，将返回False
str = ‘alan\n python‘
str_result = str.isprintable()

三. 格式化类方法，返回一个格式化的新字符串

14. str.lower()    str.upper()     str.swapcase()
把全部字母字符转换成小写 / 大写，不去管其它非字母字符。字符串全部为非字母字符也是合法的，但返回原字符串.
swapcase()方法把字符串中的大小写字母互换，大写转换成小写，小写转换成大写。不去管非字母类字符。
str = ‘中国 Alan Xu‘
str_result = str.lower()
str_result = str.upper()
str_result = str.swapcase()

15. str.capitalize()
将字符串的第一个字符转换为大写， 其余转换为小写
如果字符串首字符为非字母字符，将返回原字符,但其余字符仍转换为小写。字符串仅包含非字母字符合法，但返回原字符串。
str = ‘中Alan Xu‘
str_result = str.capitalize()

16. str.title()
字符串中每个单词的首字母大写，其余小写。单词的首字符为非字母字符也不影响转换。字符串仅包含非字母字符合法，但返回原字符串
str = ‘中alAn xU‘
str_result = str.title()

17. str.center(width[, fillchar])      str.ljust(width[, fillchar])        str.rjust(width[, fillchar])
返回一个指定的宽度 width 居中 / 左对齐 / 右对齐 的字符串，可选参数fillchar 为填充的字符，默认为空格。 如果 width 小于字符串长度直接返回字符串
str = ‘Alan Xu‘
str_result = str.center(50, ‘*‘)    #width为偶数时，fillchar将平均地填充到原字符串的开头和结尾；为奇数时，fillchar优先填充前面
str_result = str.ljust(50, ‘*‘)
str_result = str.rjust(50, ‘*‘)

18. str.lstrip([chars])    str.rstrip([chars])     str.strip([chars])
返回一个去除了特定字符的新字符串，chars参数是一个字符串，它包含了所有将要被移除的字符集合。默认为空格
从原字符串的 最左边 / 最右边 / 两端 开始，匹配chars里包含的所有字符，直至遇到第一个非chars字符为止，原字符串中匹配到的所有字符都被移除。
str = ‘alan xu python‘
str_result = str.lstrip(‘a ln‘)     #当遇到字符x不属于‘a ln‘时结束，移除x前的所有字符
str_result = str.rstrip(‘a ln‘)
str_result = str.strip(‘a ln‘)

19. str.expandtabs([tabsize])
把字符串中的所有制表符替换成零个或多个空格，每个制表符替换成多少个空格，由制表符在字符串中的位置和tabsize共同决定。tabsize指定每个制表符替换成的空格数，默认为8个
tr = ‘\t\talanhah\tis hero‘
str_result = str.expandtabs()            #制表符的制表位是从每行开头算起的，所以第三个制表符的制表位是从行首开始的第24个位置,所以就只有1个空格出现

20. str.zfill(width)
返回一个长度为width的字符串，最左边填充0。如果width小于等于原字符串长度，则返回原字符串。主要用于数字类字符串的格式化。
str = ‘123‘
str_result = str.zfill(8)

21. str.format(*args, **kwargs)   str.format_map(mapping)
增强了字符串格式化的功能, 基本语法是通过 {} 和 : 来代替以前的 %
format() 函数可以接受不限个参数，位置可以不按顺序。
21.1 通过位置
str_result = ‘{0},{1}‘.format(‘Alan‘, ‘Xu‘)     #Alan,Xu
str_result = ‘{},{}‘.format(‘Alan‘, ‘Xu‘)     #Alan,Xu  (不能出现同时一个{}和一个{1}这样)
str_result = ‘{1}{0}{1}‘.format(‘Alan‘, ‘Xu‘)   #XuAlanXu
21.2 通过关键字参数
str_result = ‘我的名字叫：{name}，我的年龄：{age}‘.format(name = ‘Alan‘, age = 26)
21.3 通过对象属性
class person:
    def __init__(self, name, age):
        self.name, self.age = name, age
    def __str__(self):
        return ‘我的名字叫：{self.name}, 年龄是：{self.age}‘.format(self = self)
str_result = person(‘Alan‘, 26)
21.4 通过下标
str_list = [‘Alan‘, 26]
str_result = ‘名字：{0[0]}, 年龄：{0[1]}‘.format(str_list)

格式限定符
21.5 填充与对齐
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
str_result = ‘{:*^16}‘.format(‘alan‘)       #******alan******
str_result = ‘{:*<16}‘.format(‘alan‘)       #alan************
str_result = ‘{:*>16}‘.format(‘alan‘)       #************alan
21.6 精度与类型f
str_result = ‘{:.2f}‘.format(3.1415926)     #3.14   其中.2表示长度为2的精度，f表示float类型。
21.7 其他类型
主要就是进制，b、d、o、x分别是二进制、十进制、八进制、十六进制。
str_result = ‘{:b}‘.format(26)              #11010
str_result = ‘{:d}‘.format(26)              #26
str_result = ‘{:o}‘.format(26)              #32
str_result = ‘{:x}‘.format(26)              #1a
用，号还能用来做金额的千位分隔符。
str_result = ‘{:,}‘.format(1234567890)      #1,234,567,890
用 % 号实现百分比
str_result = ‘{:.2%}‘.format(0.26)          #26.00%
指数记法
str_result = ‘{:.2e}‘.format(26)            #2.60e+01

str.format_map(mapping)类似 str.format(*args, **kwargs) ，不同的是 mapping 是一个字典对象。
People = {‘name‘:‘alan‘, ‘age‘:26}
str_result = ‘My name is {name},i am {age} old‘.format_map(People)     # ‘My name is john,i am 56 old‘

新增1. str.encode(encoding=‘UTF-8‘,errors=‘strict‘)
以 encoding 指定的编码格式编码字符串（如"UTF-8"）。errors参数可以指定不同的错误处理方案。该方法返回编码后的字符串。
errors -- 设置不同错误的处理方案。默认为 ‘strict‘,意为编码错误引起一个UnicodeError。
其他可能的值有 ‘ignore‘, ‘replace‘, ‘xmlcharrefreplace‘, ‘backslashreplace‘ 以及通过 codecs.register_error() 注册的任何值。
str = ‘我在学习Python‘
str_result = str.encode(‘UTF-8‘,‘strict‘)
str_result.decode(‘UTF-8‘, ‘strict‘)            #byte类型 方法 decode()解码

四. 拆分组合类方法

22. str.partition(sep)     str.rpartition(sep)
拆分字符串，返回一个包含三个元素的元组。
如果未能在原字符串中找到Sep，则元组的三个元素为：原字符串，空串，空串；否则，从原字符串中遇到的第一个Sep字符开始拆分，元组的三个元素为：Sep前的字符串，Sep字符，Sep之后的字符串；
rpartition(sep)从原字符串的最右边开始拆分，返回：倒数第一个Sep之前的字符串，Sep字符，Sep之后的字符串。
str = ‘aabcdefgdeh‘
str_result = str.partition(‘de‘)                        #sep为空时，会报错
str_result = str.rpartition(‘de‘)

23. str.split([sep[, maxsplit]])       str.rsplit([sep[, maxsplit]])
返回一个以Sep分隔的列表，maxsplit指定拆分次数（因此，列表中元素的个数为maxsplit + 1）。Sep默认为空格，maxsplit默认不限制拆分次数。
1）如果未指定Sep或指定Sep为None，str两端的空格将舍弃；如果指定Sep（不管能否在原字符串中找到Sep），str两端的空格将保留
2）如果未能在原字符串中找到Sep，则返回一个仅包含一个元素的列表，这个元素就是原字符串。
3) str.rsplit()只是从最右边开始拆分。只有在指定maxsplit的情况下才会看到不同效果
str = ‘  hello alan  ‘
str_result = str.split()    #结果[‘hello‘, ‘alan‘]
str_result = str.split(‘l‘, 2)    #结果[‘  he‘, ‘‘, ‘o alan  ‘]
str_result = str.rsplit(‘l‘, 2)    #结果[‘  hel‘, ‘o a‘, ‘an  ‘]

24. str.join(iterable)
以指定字符串str作为分隔符，将iterable对象中所有的元素(字符串表示)合并为一个新的字符串. 如果传入一个非iterable对象，如整数、布尔值等，将返回Type Error。
iterable object或iterator type最主要的特征是支持两个函数：__iter__()和__next__()，虽然不是很准确，但可以简单的认为支持使用for语句逐个取值的数据类型都是迭代器对象。
sequence type（六种：strings、byte objects、byte arrays、lists、tuples、range objects）和dictionary都属于iterable对象
str = ‘ab‘
str_result = str.join(‘cdef‘)   #结果cabdabeabf （即：cab dab eab f）

25. str.splitlines([keepends])
拆分一个包含多行的字符串，以每行为一个元素返回一个列表。如果字符串不是多行，则返回原字符串。keepends是一个True字符或非零整数，表示保留行尾标志（即换行符）。该方法多用于处理文件。
str = ‘‘‘ab
cd
ef‘‘‘
str_result = str.splitlines()

字符串方法实际操作

str = "my     name is {name} and age is {year}!"
str1 = "Abc123AA bb"
str2 = ‘‘‘aa
bb
cc‘‘‘
str3 = ‘我爱中国‘
strs = str.format(name="Alan",year=26)  
table = strs.maketrans(‘ma‘, ‘nb‘, ‘n‘)
print(strs)

print(‘\n 一. 查找 & 替换类方法 \n‘)

print(‘字符串strs中 a 出现的次数：‘, strs.count("a"))                   
print(‘字符串strs中 a 首次出现的位置：‘, strs.find(‘a‘))                
print(‘字符串strs中从右向左 a 首次出现的位置：‘, strs.rfind(‘a‘))
print(‘字符串strs中 a 首次出现的位置：‘, strs.index(‘a‘))               
print(‘字符串strs中从右向左 a 首次出现的位置(rindex)：‘, strs.rindex(‘a‘))
print(‘字符串strs中字符 a 被替换为 z 后生成的新字符串(replace)：‘, strs.replace(‘a‘, ‘z‘))  
print(‘字符串strs中的部分字符被替换后的新字符串(translate)：‘, strs.translate(table))   

print(‘\n 二. 判断类方法，通常返回True和False \n‘)

print(‘字符串str1中是否以 Ab 开头：‘, str1.startswith(‘Ab‘)) 
print(‘字符串str1中是否以 bb 结尾：‘, str1.endswith(‘bb‘))
print(‘字符串str1是否是由字母和数字组成：‘, str1.isalnum())
print(‘字符串str1是否是由字母组成：‘, str1.isalpha())
print(‘字符串str1是否是由数字组成，并在十进制整数的范围：‘, str1.isdecimal())
print(‘字符串str1是否是由数字组成，并在整数的范围：‘, str1.isdigit())
print(‘字符串str1是否是由数字组成，并在整数的范围：‘, str1.isnumeric())
print(‘字符串str1是否是全有空格或是制表符组成：‘, str1.isspace())
print(‘字符串str1是否是全是大写字母组成：‘, str1.isupper())
print(‘字符串str1是否是全是小写字母组成：‘, str1.islower())
print(‘字符串str1中单词首字母是否都是大写，并且其余字符都为小写：‘, str1.istitle())
print(‘字符串str1是否是合法的标识符：‘, str1.isidentifier())
print(‘字符串str1是否能够被打印：‘, str1.isprintable())

print(‘\n 三. 格式化类方法，返回一个格式化的新字符串 \n‘)

print(‘将字符串str1中的字符全部转换成小写：‘, str1.lower())
print(‘将字符串str1中的字符全部转换为大写:‘, str1.upper())
print(‘将字符串str1中的字符大小写互换：‘, str1.swapcase())
print(‘将字符串str1首字母大写，其余字母小写：‘, str1.capitalize())
print(‘将字符串str1中的每个单词首字母大写，其余字母小写：‘, str1.title())
print(‘将字符串str1按照指定长度居中显示，并用*号填充：‘, str1.center(50, ‘*‘))
print(‘将字符串str1按照指定长度左对齐显示，并用*号填充：‘, str1.ljust(50, ‘*‘))
print(‘将字符串str1按照指定长度左对齐显示，并用*号填充：‘, str1.rjust(50, ‘*‘))
print(‘将字符串str1中指定字符从两端移除：‘, str1.strip(‘Ab C‘))
print(‘将字符串str1中指定字符从左边移除：‘, str1.lstrip(‘Ab C‘))
print(‘将字符串str1中指定字符从右边移除：‘, str1.rstrip(‘Ab C‘))
print(‘将字符串中的制表符转换为空格：‘, ‘ab\tcd‘.expandtabs())
print(‘将数字类字符串返回指定长度：‘, ‘12345‘.zfill(9))
print(‘将字符串以UTF-8格式重新编码：‘, str3.encode(‘UTF-8‘, ‘strict‘))

print(‘\n 四. 拆分组合类方法 \n‘)

print(‘将字符串拆分为一个三个元素的元组：‘, str1.partition(‘23‘))
print(‘将字符串从右边开始拆分为一个三个元素的元组：‘, str1.rpartition(‘23‘))
print(‘将字符串以指定字符串分隔为一个列表：‘, str1.split(‘A‘))
print(‘将字符串从右边以指定字符串分隔为一个列表：‘, str1.rsplit(‘A‘, 2))
print(‘以指定字符串作为分隔符将字符串中的每一个字符分隔组合成新字符串：‘, ‘中国‘.join(str1))
print(‘将多行字符串拆分为一个列表：‘, str2.splitlines())

View Code

Python - 字符串的操作方法