python基础-2-字符串内置方法

S.capitalize() -> str-将字符串S的第一个字符改为大写

>>> 'special thing'.capitalize()
'Special thing'

S.casefold() -> str-将字符串S的所有字符改为小写

>>> 'SPEcial THing'.casefold()
'special thing'

S.center(width[, fillchar]) -> str-将字符串S居中，S的宽度变成width，fillchar表示填充字符(若不填则默认用空格填充)

>>> 'special'.center(50,'$')
'$$$$$$$$$$$$$$$$$$$$$special$$$$$$$$$$$$$$$$$$$$$$'
>>> 'special'.center(50)
'                     special                      '

S.count(sub[, start[, end]]) -> int-返回sub在字符串S里出现的次数，start和end参数表示范围，可选

>>> 'abc###abc###   abc###ab###bc###'.count('ab')
4
>>> 'abc###abc###   abc###ab###bc###'.count('ab',1)
3
>>> 'abc###abc###   abc###ab###bc###'.count('ab',1,8)
1

S.encode(encoding='utf-8', errors='strict') -> bytes-以encoding指定的编码格式对字符串进行编码

>>> 'special'.encode(encoding='utf-8',errors="strict")
b'special'

S.endswith(suffix[, start[, end]]) -> bool-检查字符串S是否以sub子字符串结束，如果是返回True，否则返回False。start和end参数表示范围，可选

>>> 'special_special'.endswith('al')
True
>>> 'special_special'.endswith('al',5)
True
>>> 'special_special'.endswith('al',5,15)
True
>>> 'special_special'.endswith('al',5,14)
False

S.expandtabs(tabsize=8) -> str-把字符串S中的tab符号(\t)转换为空格，如不指定tabsize参数，默认为8

>>> "special\tspecial".expandtabs()
'special special'
>>> "special\tspecial".expandtabs(tabsize=8)
'special special'
>>> "special\tspecial".expandtabs(tabsize=50)
'special                                           special'

S.find(sub[, start[, end]]) -> int-检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1，start和end参数表示范围，可选

>>> 'abc###abc###   abc###ab###bc###'.find(' abc')
14
>>> 'abc###abc###   abc###ab###bc###'.find('abc')
0     #这是索引值
>>> 'abc###abc###   abc###ab###bc###'.find('abc',1,20)
6

S.format(*args, **kwargs) -> str-格式化字符串的方法，接受位置参数和关键字参数，如果位置参数和关键字参数一起使用，那么位置参数必须在关键字参数之前(位置颠倒会报错)。

>>> "{0} love {1}.{2}".format("I","alex","smith")
'I love alex.smith'
>>> "{a} love {b}.{c}".format(a="I",c="alex",b="smith")
'I love smith.alex'
>>> "{0} love {b}.{c}".format("I",c="alex",b="smith")
'I love smith.alex'
>>> "{a} love {b}.{2}".format(a="I",b="alex","smith")
SyntaxError: positional argument follows keyword argument

>>> "{0} love {1:.2f}".format("I",3.1415926)  #冒号表示格式化符号的开始，.2f表示四舍五入到保留两位小数点，f是浮点数的意思
'I love 3.14'

S.format_map(mapping) -> str-利用字典格式化字符串

>>> "{a} love {b}.{c}".format_map({"a":"I","c":"alex","b":"smith"})
'I love smith.alex'

S.index(sub[, start[, end]]) -> int-跟find方法一样，字符串S中找不到sub时，产生一个异常

>>> 'abc###abc###   abc###ab###bc###'.index('bc')
1

S.isalnum() -> bool-如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False

>>> 'abc###abc###   abc###ab###bc###'.isalnum()
False
>>> 'abcdefghijklmnopqrstuvwxyz123'.isalnum()
True

S.isalpha() -> bool-如果字符串字符串S至少有一个字符且所有字符都是字母则返回True，否则返回False

>>> 'abcdefghijklmnopqrstuvwxyz123'.isalpha()
False
>>> 'abcdefghijklmnopqrstuvwxyz'.isalpha()
True

S.isdecimal() -> bool-如果字符串只包含十进制数字则返回True，否则返回False

>>> 'abcdefghijklmnopqrstuvwxyz123'.isdecimal()
False
>>> "1234567890".isdecimal()
True

S.isdigit() -> bool-如果字符串只包含数字则返回True，否则返回False

>>> 'abc123'.isdigit()
False
>>> '123'.isdigit()
True

S.isnumeric() -> bool-如果字符串S中只包含数字字符，则返回True，否则返回False

>>> 'abc123'.isnumeric()
False
>>> '123456'.isnumeric()
True

S.isdecimal() -> bool、S.isdigit() -> bool、S.isnumeric() -> bool的区别

isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无

isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）

isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）

没经过验证

S.isidentifier() -> bool-判断字符串是否为合法的标识符

>>> '123'.isidentifier()
False
>>> 'abc 123'.isidentifier()
False
>>> '_abc'.isidentifier()
True

S.islower() -> bool-如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回True，否则返回False

>>> 'abc123'.islower()
True
>>> 'ABCabc'.islower()
False

S.isprintable() -> bool-字符串S中是可打印字符，则返回True，否则返回False

>>> 'as'.isprintable()
True
>>> '    'isprintable()  #tab键不可打印
SyntaxError: invalid syntax
>>> '   '.isprintable()  #空格可打印
True

S.isspace() -> bool-如果字符串S中只包含空格，则返回True，否则返回False

>>> '    '.isspace()
True
>>> ''.isspace()  #空字符串返回False
False
>>> 'abc  '.isspace()
False

S.istitle() -> bool-如果字符串是标题化的(所有的单词都是以大写开始，其余字母均小写)，则返回True，否则返回False

>>> "I'm a Student".istitle()
False
>>> "I'm A Student".istitle()
False
>>> "I Am A Student".istitle()
True

S.isupper() -> bool-如果字符串S中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回True，否则返回False

>>> "ABC123".isupper()
True

S.join(iterable) -> str-以字符串S作为分隔符，插入到iterable中

>>> '#$'.join("abcdefg")
'a#$b#$c#$d#$e#$f#$g'

S.ljust(width[, fillchar]) -> str-返回一个左对齐的字符串，并使用fillchar填充至长度为width的新字符串

>>> "abcdefg".ljust(50)
'abcdefg                                           '
>>> "abcdefg".ljust(50,"#")
'abcdefg###########################################'

S.lower() -> str-转换字符串S中所有大写字符为小写

>>> "abcDEFgh$###".lower()
'abcdefgh$###'

S.lstrip([chars]) -> str-去掉字符串S从左边起所有与chars(默认为空格)匹配的字符串

>>> "   abc   ".lstrip()
'abc   '
>>> "ababcab".lstrip("ab")
'cab'
>>> "ababab".lstrip("ab")
''
>>> "abcbcab".lstrip("bc")
'abcbcab'

str.maketrans()-返回一个字符映射转换表，常与S.translate()方法配合使用

#!/usr/bin/python3
 
intab = "aeiou"
outtab = "12345"
deltab = "thw"
 
trantab1 = str.maketrans(intab,outtab) # 创建字符映射转换表
trantab2 = str.maketrans(intab,outtab,deltab) #创建字符映射转换表，并删除指定字符
 
test = "this is string example....wow!!!"
 
print(test.translate(trantab1))
print(test.translate(trantab2))

=========输出结果如下=================
th3s 3s str3ng 2x1mpl2....w4w!!!
3s 3s sr3ng 2x1mpl2....4!!!

S.partition(sep) -> (head, sep, tail)-返回一个包含3个元素的元组(pre_sep,sep,after_sep)，如果字符串S中不包含seq，则返回('原字符串','','')

>>> "abcdefghijklmnopqrstuvwxyz".partition("jkl")
('abcdefghi', 'jkl', 'mnopqrstuvwxyz')
>>> "abcdefghijklmnopqrstuvwxyz".partition("lkj")
('abcdefghijklmnopqrstuvwxyz', '', '')

S.replace(old, new[, count]) -> str-把字符串中的old子字符串替换成new子字符串，如果count指定，则替换不超过count次

>>> "abcabcabcabc".replace("abc","123")
'123123123123'
>>> "abcabcabc".replace("abc","123",2)
'123123abc'

S.rfind(sub[, start[, end]]) -> int-类似于find()方法，不过是从右边开始查找

>>> "abcabcabcabc".rfind("bc")
10
>>> "abcabcabc".rfind("bc",0,6)
4

S.rindex(sub[, start[, end]]) -> int-类似于index()方法，不过是从右边开始查找

>>> "abcabcabcabc".rindex('bc')
10
>>> "abcabcabcabc".rindex('bc',0,5)
1

S.rjust(width[, fillchar]) -> str-返回一个右对齐的字符串，并使用fillchar填充至长度为width的新字符串

>>> "abc".rjust(20,'#')
'#################abc'

S.rpartition(sep) -> (head, sep, tail)-类似于partition()方法，不过是从右边开始查找

>>> 'abcjklabcjkl'.rpartition("jkl")
('abcjklabc', 'jkl', '')

 S.rsplit(sep=None, maxsplit=-1) -> list of strings-类似于split()方法，不过是从右边开始查找(sep表示分隔字符串，maxsplit表示最多分隔几次)

>>> "123abc123abc".rsplit("123",1)
['123abc', 'abc']
>>> "123abc123abc".rsplit("123",3)
['', 'abc', 'abc']

S.rstrip([chars]) -> str-去掉字符串S从右边起所有与chars(默认为空格)匹配的字符串

>>> "123abc123abc".rstrip("abc")
'123abc123'
>>> "123abc123abc   ".rstrip()
'123abc123abc'

S.split(sep=None, maxsplit=-1) -> list of strings-通过指定分隔符sep对字符串S进行切片，如果参数maxsplit有指定值，maxsplit表示最多分隔几次

>>> "123abc123abc".split("123",2)
['', 'abc', 'abc']
>>> "123abc123abc".split("123",1)
['', 'abc123abc']

S.splitlines([keepends]) -> list of strings-按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

>>> "abc\nabc\nabc\rabc".splitlines()
['abc', 'abc', 'abc', 'abc']
>>> "abc\nabc\nabc\rabc".splitlines(1)
['abc\n', 'abc\n', 'abc\r', 'abc']

S.startswith(prefix[, start[, end]]) -> bool-检查字符串S是否以prefix开头，是则返回True，否则返回False。start和end参数可指定范围检查，可选

>>> "abcdefghijkl".startswith("abc")
True
>>> "abcdefghijkl".startswith("abc",1,10)
False

S.strip([chars]) -> str-删除字符串S前边和后边所有的字符串chars，没有指定chars，默认删除空格

>>> "abcdefghijkl".strip("abc")
'defghijkl'
>>> "   abc   defghijkl".strip()
'abc   defghijkl'

S.swapcase() -> str-翻转字符串的大小写，返回的是拷贝，原字符串S不变

>>> s = "ABCabc"
>>> s.swapcase()
'abcABC'
>>> s
'ABCabc'

S.title() -> str-返回标题化(所有的单词都是以大写开始，其余字母均小写)的字符串

>>> "i sd sklsdf".title()
'I Sd Sklsdf'

S.translate(table) -> str-根据table的规则(可以由str.maketrans('a','b')定制)转换字符串中的字符

#!/usr/bin/python3
 
intab = "aeiou"
outtab = "12345"
deltab = "thw"
 
trantab1 = str.maketrans(intab,outtab) # 创建字符映射转换表
trantab2 = str.maketrans(intab,outtab,deltab) #创建字符映射转换表，并删除指定字符
 
test = "this is string example....wow!!!"
 
print(test.translate(trantab1))
print(test.translate(trantab2))

=========输出结果如下=================
th3s 3s str3ng 2x1mpl2....w4w!!!
3s 3s sr3ng 2x1mpl2....4!!!

S.upper() -> str-转换字符串中的所有小写字符为大写

>>> "abcABC".upper()
'ABCABC'

S.zfill(width) -> str-返回长度为width的字符串，原字符串右对齐，前边用0填充

>>> "abcabc".zfill(20)
'00000000000000abcabc'