字符串操作

列表可以进行增删改查，有下标，可切片；

字符串可以进行读取，由下表，可前片，但是不可修改；

特性：不可修改　——所有看上去似乎是修改的attribute，比方capitalize(),upper(),lower()其实是改写为全新的内容，而不是在原字符串上进行修改。

下面介绍关于Python3.6版本中的字符串的所有可用的操作方法。

以上截图的所有attribute是我们可以调用的字符串的所有的方法。

具体的操作方法和使用方法如下：

1.S.capitalize() 首字母大写，其余字母小写

help(str.capitalize)
Help on method_descriptor:

capitalize(...)
    S.capitalize() -> str
    
    Return a capitalized version of S, i.e. make the first character have upper case and the rest lower case. #返回首字母大写，其余字母小写的字符串。

‘this is a string'.capitalize() #首字母大写
Out[7]: 'This is a string'

 

2.S.casefold() 字母全部小写，适用于任何编码

help(str.casefold)
Help on method_descriptor:

casefold(...)
    S.casefold() -> str
    
    Return a version of S suitable for caseless comparisons.
#转换所有字母为小写模式；
#Python3.3中引入了str.casefold()方法，其效果和 string.lower()非常类似，都可以把字符串变成小写，那么它们之间有什么区别？他们各自的应用场景？
'''对 Unicode 的时候用 casefold()
Casefolding is similar to lowercasing but more aggressive because it is intended to remove all case distinctions in a string. For example, the German lowercase letter 'ß' is equivalent to "ss". Since it is already lowercase, lower() would do nothing to 'ß'; casefold()converts it to "ss".
The casefolding algorithm is described in section 3.13 of the Unicode Standard
lower() 只对 ASCII 也就是 'A-Z'有效，但是其它一些语言里面存在小写的情况就没办法了。文档里面举得例子是德语中'ß'的小写是'ss'：
s = 'ß' s.lower() # 'ß' s.casefold() # 'ss'
'''

'aAAAAA'.casefold()
Out[4]: 'aaaaaa'

 

3.S.lower()  字母全部小写，仅适合ascii码

help(str.lower)
Help on method_descriptor:

lower(...)
    S.lower() -> str
    
    Return a copy of the string S converted to lowercase.
#返回小写的字符串副本

'AAa'.lower()
Out[6]: 'aaa'

 

4.S.upper()  字母全部大写

help(str.upper)
Help on built-in function upper:

upper(...) method of builtins.str instance
    S.upper() -> str
    
    Return a copy of S converted to uppercase. #返回字符串的副本，转换为大写字母的字符串。

'aABb'.upper()
Out[7]: 'AABB'

 

5.S.title() 字符串按标题格式转换，首字母大写，其余小写

help(str.title)
Help on built-in function title:

title(...) method of builtins.str instance
    S.title() -> str
    
    Return a titlecased version of S, i.e. words start with title case
    characters, all remaining cased characters have lower case. #返回字符串的标题格式。首字母大写，其余小写。

'this is a string'.title()
Out[102]: 'This Is A String'

 

6.S.islower()  判断字符串的所有字符是否为小写

help(str.islower)
Help on built-in function islower:

islower(...) method of builtins.str instance
    S.islower() -> bool
    
    Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise. #如果字符串的所有字符是小写字母则返回为True。

'aaaa'.islower()
Out[8]: True

'Aaaaa'.islower()
Out[9]: False

 

7.S.isupper()  判断字符串的所有字符是否为大写

help(str.isupper)
Help on built-in function isupper:

isupper(...) method of builtins.str instance
    S.isupper() -> bool
    
    Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise.  #如果字符串的所有字母都是大写的则返回True。

'AAAA'.isupper()
Out[10]: True

'AAAAa'.isupper()
Out[11]: False

 

8.S.istitle() 判断字符串格式是否为标题格式

help(str.istitle)
Help on built-in function istitle:

istitle(...) method of builtins.str instance
    S.istitle() -> bool
    
    Return True if S is a titlecased string and there is at least one character in S, i.e. upper- and titlecase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise.  #如果字符串是标题格式则为True。
'this is a book'.istitle()

Out[12]: False

'this is a book'.title().istitle()
Out[13]: True

 

9.S.isalnum() 判断字符串内的字符是否都为字母或数字

help(str.isalnum)
Help on built-in function isalnum:

isalnum(...) method of builtins.str instance
    S.isalnum() -> bool
    
    Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.
#如果在字符串中的所有字符是字母数字的，返回为True；如果不是，则返回False。

'123tri'.isalnum()
Out[63]: True

'Tri123'.isalnum()
Out[65]: True

 

10.S.isalpha()  判断字符串内的字符是否都为字母

help(str.isalpha)
Help on built-in function isalpha:

isalpha(...) method of builtins.str instance
    S.isalpha() -> bool
    
    Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise.  #所有的字符串字符均为字母则返回为True；否则，返回False。

’this is a book'.isalpha()  #空格也是字符之一
Out[67]: False

'Aa'.isalpha()
Out[68]: True

 

11.S.isdecimal()  判断字符串是否为十进制

help(str.isdecimal)
Help on built-in function isdecimal:

isdecimal(...) method of builtins.str instance
    S.isdecimal() -> bool
    
    Return True if there are only decimal characters in S, False otherwise.  #如果字符串中只有十进制字符，返回True。

‘this is a book’.isdecimal()
Out[72]: False

'123'.isdecimal()
Out[73]: True

'0x123'.isdecimal()   #16进制
Out[76]: False

 

12.S.isdigit()  判断字符串中字符是否都是数字

help(str.isdigit)
Help on built-in function isdigit:

isdigit(...) method of builtins.str instance
    S.isdigit() -> bool
    
    Return True if all characters in S are digits and there is at least one character in S, False otherwise. #如果在字符串中的所有字符都是数字则返回True

'this is a book'.isdigit()
Out[80]: False

'123'.isdigit()
Out[81]: True

 

13.S.isnumeric() 判断字符串中的字符是否都是数字

help(str.isnumeric)
Help on built-in function isnumeric:

isnumeric(...) method of builtins.str instance
    S.isnumeric() -> bool
    
    Return True if there are only numeric characters in S,False otherwise. #如果在字符串中仅有数字则返回True。

‘this is a book’.isnumeric()
Out[98]: False

'123'.isnumeric()
Out[99]: True

上面的三个方法,str.isdigit(),str.sidecimal(),str.isnumeric()都是判断字符是否为数字，只是适用于不同的字符编码。

S.isnumeric()中小数也会返回false，因为小数点不是数字。

 

14.S.isidentifier() 判断字符串是不是一个合法的标识符

help(str.isidentifier)
Help on built-in function isidentifier:

isidentifier(...) method of builtins.str instance
    S.isidentifier() -> bool
    
    Return True if S is a valid identifier according to the language definition.  #如果字符串是一个合法的标识符，返回True。
    Use keyword.iskeyword() to test for reserved identifiers such as "def" and "class".

'def'.isidentifier()
Out[84]: True

'class'.isidentifier()
Out[85]: True

'123'.isidentifier()
Out[86]: False

 所有符合合法的标识符格式的变量都会返回True;反之，123abc,-aa等不符合变量命名规则的都会返回False。

15.S.isprintable() 判断字符串是否都是可打印字符  如：tty file,drive file

help(str.isprintable)
Help on built-in function isprintable:

isprintable(...) method of builtins.str instance
    S.isprintable() -> bool
    
    Return True if all characters in S are considered printable in repr() or S is empty, False otherwise. #如果字符串中的所有字符为空或都是可以打印字符，则为True。

'this is a book'.isprintable()
Out[106]: True

'***'.isprintable()
Out[107]: True

 

16.S.isspace() 所有字符都是空白字符、\t、\n、\r

help(str.isspace)
Help on built-in function isspace:

isspace(...) method of builtins.str instance
    S.isspace() -> bool
    
    Return True if all characters in S are whitespace and there is at least one character in S, False otherwise. #如果在字符串中的所有字符都是空白字符、\t、\n、\r，则返回True。

'   '.isspace()
Out[111]: True

'  1'.isspace()
Out[112]: False


'\t   \r  \n'.isspace()
Out[20]: True

 

17.S.endswith() 判断字符串（或字符串子串）的结尾的字符是否符合指定的后缀

help(str.endswith)
Help on built-in function endswith:

endswith(...) method of builtins.str instance
    S.endswith(suffix[, start[, end]]) -> bool
    
    Return True if S ends with the specified suffix, False otherwise.    With optional start, test S beginning at that position. With optional end, stop comparing S at that position.suffix can also be a tuple of strings to try.


str=''this is a string"

str.endswith('g')
Out[34]: True

str.endswith('g',1,8)   #对str切片，判断子串是否以'g'为结尾。
Out[35]: False

str.endswith(('s','g'))  #suffix can also be a tuple of strings to try.结果是只要元组中的其中之一为True，即为True。
Out[36]: True

str.endswith(('g','s'))
Out[37]: True

 

18.S.startswith() 判断字符串（或字符串子串）的开头的字符是否符合指定的前缀

help(str.startswith)
Help on built-in function startswith:

startswith(...) method of builtins.str instance
    S.startswith(prefix[, start[, end]]) -> bool
    
    Return True if S starts with the specified prefix, False otherwise.
    With optional start, test S beginning at that position.With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try.  #如果字符串前缀是指定的prefix，返回True。

'11113333'.startswith('1')
Out[189]: True

 

19.S.find() 在字符串（或字符子串）中找到指定的字符的最小的下标；找不到，返回-1.

help(str.find)
Help on built-in function find:

find(...) method of builtins.str instance
    S.find(sub[, start[, end]]) -> int   #返回在字符串中或字符串子串中的最小的下标
    
    Return the lowest index in S where substring sub is found,such that sub is contained within S[start:end].  Optional arguments start and end are interpreted as in slice notation.    
    Return -1 on failure.


'this is a string'.find('s')
Out[50]: 3

 

20.S.rfind() 在字符串（或字符子串）中找到指定的字符的最大的下标；找不到，返回-1.

help(str.rfind)
Help on built-in function rfind:

rfind(...) method of builtins.str instance
    S.rfind(sub[, start[, end]]) -> int
    
    Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].  Optional arguments start and end are interpreted as in slice notation.
    Return -1 on failure. #返回在字符串中指定的子字符串出现的最大的下标。如果未找到输出“-1”。

'01234567890'.rfind('0')
Out[172]: 10

'01234567890'.rfind('0',0,10)
Out[173]: 0

 

21.S.index() 在字符串（或字符子串）中找到指定的字符的最小的下标；找不到，会报错

help(str.index)
Help on built-in function index:

index(...) method of builtins.str instance
    S.index(sub[, start[, end]]) -> int
    
    Like S.find() but raise ValueError when the substring is not found.#如果未找到子串，则会报错；如果找到子串，则返回子串的最小的下标

'this is a string'.index('s')
Out[56]: 3

'this is a string'.index('S')
Traceback (most recent call last):

  File "<ipython-input-57-671a49dcd72c>", line 1, in <module>
    str.index('S')

ValueError: substring not found

'this is a string'.index('string')
Out[59]: 10

 

22.S.rindex()  在字符串（或字符子串）中找到指定的字符的最大的下标 ；找不到，会报错

help(str.rindex)
Help on built-in function rindex:

rindex(...) method of builtins.str instance
    S.rindex(sub[, start[, end]]) -> int
    
    Like S.rfind() but raise ValueError when the substring is not found. #如果子字符串没有在字符串中找到，会报错。除此之外和S.rfind()功能一样。但是S.rfind()找不到时返回的是-1.

'this is a string'.rindex('s')
Out[21]: 10

'this is a string'.rindex('s',0,9)
Out[22]: 6

 

23.S.center()  字符串居中，指定长度的两边根据指定的字符填充（默认为空格）

help(str.center)
Help on method_descriptor:

center(...)
    S.center(width[, fillchar]) -> str
    
    Return S centered in a string of length width. Padding is done using the specified fill character (default is a space)

’this is a string'.center(50)   
Out[12]: '                 this is a string                 '

'this is a string'.center(50,'---')
Traceback (most recent call last):

  File "<ipython-input-13-a1b9271e33e1>", line 1, in <module>
    str.center(50,'---')

TypeError: The fill character must be exactly one character long


'this is a string'.center(50,'-')      #str.center(self,width,fillchar)  返回字符串宽度（即长度）为50的字符串，字符串内容居中，两边缺少的以fillchar填充两边，如无具体指定值，默认为“”（空格）。
Out[14]: '-----------------this is a string-----------------'

 

24.S.ljust()  返回字符串指定长度的字符串，其中原字符串的字符在左侧，添加的指定填充字符在右边（默认指定空格）。

help(str.ljust)
Help on built-in function ljust:

ljust(...) method of builtins.str instance
    S.ljust(width[, fillchar]) -> str
    
    Return S left-justified in a Unicode string of length width. Padding is done using the specified fill character (default is a space).  #返回字符串指定长度的字符串，其中原字符串的字符在左侧，添加的指定填充字符在右边（默认指定空格）。

‘this is a string'.ljust(30,'-')
Out[128]: 'this is a string--------------'

 

25.S.rjust()  返回字符串指定长度的字符串，其中原字符串的字符在右侧，添加的指定填充字符在左边（默认指定空格）。

help(str.rjust)
Help on built-in function rjust:

rjust(...) method of builtins.str instance
    S.rjust(width[, fillchar]) -> str
    
    Return S right-justified in a string of length width. Padding is done using the specified fill character (default is a space).#返回字符串指定长度的字符串，其中原字符串的字符在右侧，添加的指定填充字符在左边（默认指定空格）。

str.rjust(30,'-')
Out[129]: '--------------this is a string'

 

26.S.strip()  返回移除字符串头尾指定的字符生成的新字符串

help(str.strip)
Help on built-in function strip:

strip(...) method of builtins.str instance
    S.strip([chars]) -> str
    
    Return a copy of the string S with leading and trailing whitespace removed.If chars is given and not None, remove characters in chars instead.  #返回移除字符串头尾指定的字符生成的新字符串。

'  123     '.strip()   #去除两侧的空格
Out[135]: '123'

' 1  2  3  '.strip()   #去除两侧的空格
Out[136]: '1  2  3'


'\t \n \r  123  456   \t \n\r'.strip()  #去除两侧的空白字符、\n,\t,\r
Out[24]: '123  456'

'0000 123   000'.strip('0')  #去除指定的参数'0'
Out[25]: ' 123   '  

 

27.S.lstrip()  返回移除字符串左侧指定的字符生成的新字符串

help(str.lstrip)
Help on built-in function lstrip:

lstrip(...) method of builtins.str instance
    S.lstrip([chars]) -> str
    
    Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead.#返回去除了字符串左边（领先的）空格的字符串的副本。

'0000   123 4 000'.lstrip('0')
Out[26]: '   123 4 000'

'\n \t \r  123 455   \n \t\r'.lstrip()
Out[27]: '123 455   \n \t\r'

 

28.S.rstrip()  返回移除字符串右侧指定的字符生成的新字符串

help(str.rstrip)
Help on built-in function rstrip:

rstrip(...) method of builtins.str instance
    S.rstrip([chars]) -> str
    
    Return a copy of the string S with trailing whitespace removed.If chars is given and not None, remove characters in chars instead.  #返回去除了字符串右边（尾部的）空格的字符串的副本。

'\n \t \r  123 455   \n \t\r'.rstrip()
Out[28]: '\n \t \r  123 455'

'0000 123   000'.rstrip('0')
Out[29]: '0000 123   '

 

29.S.split() 返回的是一个行的列表，默认是空白字符作为分隔符，也可以指定分隔的个数（即分隔符的个数），从左往右

help(str.split)
Help on built-in function split:

split(...) method of builtins.str instance
    S.split(sep=None, maxsplit=-1) -> list of strings
    
    Return a list of the words in S, using sep as the delimiter string.  If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator and empty strings are removed from the result.#返回在字符串中的单词列表，使用sep的值作为分隔符。如果最大的分隔数给定了，最多最大分隔数已经完成。
如果sep没有指定特别的，或者没有指定分隔符，那么默认空格为分隔符，并且将字符串中的空白字符串从结果中删除。

'1 22 3 3 4 . 6'.split(sep="3",maxsplit=1)  #分隔符一定是字符串格式，另外设置了maxsplit为1个，导致输出结果仅用了最前面的“3”作为分隔符
Out[163]: ['1 22 ', ' 3 4 . 6']

'1 22 3 3 4 . 6'.split(sep="3")   #使用默认的maxsplit值，两个“3“都作为分隔符处理完了。
Out[166]: ['1 22 ', ' ', ' 4 . 6']

#str.split()和str.rsplit()的区别在于取指定的分隔符进行分列时，从前向右，还是从右（尾）向前的执行选择顺序。

 

30.S.rsplit()   返回的是一个行的列表，默认是空白字符作为分隔符，也可以指定分隔的个数（即分隔符的个数），从右向左

help(str.rsplit)
Help on built-in function rsplit:

rsplit(...) method of builtins.str instance
    S.rsplit(sep=None, maxsplit=-1) -> list of strings
    
    Return a list of the words in S, using sep as the delimiter string, starting at the end of the string and working to the front.  If maxsplit is given, at most maxsplit splits are done. If sep is not specified, any whitespace string is a separator. #同上，只是是从字符串的末尾开始，运行至最前面。

'1 22 3 3 4 . 6'.rsplit(sep="3",maxsplit=1) #分隔符一定是字符串格式，另外设置了maxsplit为1个，导致输出结果仅用了最后面的“3”作为分隔符
Out[164]: ['1 22 3 ', ' 4 . 6']

'1 22 3 3 4 . 6'.rsplit(sep="3")  #使用默认的maxsplit值，两个“3“都作为分隔符处理完了。
Out[165]: ['1 22 ', ' ', ' 4 . 6']

'this is a string'.rsplit(sep=' ',maxsplit=2)  
Out[33]: ['this is', 'a', 'string']

 

31.S.splitlines()  返回的是一个行的列表，根据换行符进行拆分

help(str.splitlines)
Help on built-in function splitlines:

splitlines(...) method of builtins.str instance
    S.splitlines([keepends]) -> list of strings
    
    Return a list of the lines in S, breaking at line boundaries.Line breaks are not included in the resulting list unless keepends is given and true. #返回字符串列表，在边界出打破，边界指的是\n新行，\r换行。分隔行不会在返回结果的列表中出现，除非keepends=True。

'123 \n '.splitlines()
Out[185]: ['123 ', ' ']  #针对的是\n,\r这样指定的换行符。

'this is a string \n  hello word'.splitlines(2)
Out[40]: ['this is a string \n', '  hello word']

 

32.S.format()  返回一个格式化的字符串，使用后面的参数对前面进行替换。替换参数通过{}来标识。可以用下标，“=”，下标对应等方式映射。

help(str.format)
Help on built-in function format:

format(...) method of builtins.str instance
    S.format(*args, **kwargs) -> str
    
    Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces ('{' and '}').
#返回一个格式化的字符串，使用后面的参数对前面进行替换。替换参数通过{}来标识。

'I am a {sex}.'.format(sex='girl')
Out[52]: 'I am a girl.'

 

33.S.format_map() 返回一个格式化的字符串，使用后面的参数对前面进行替换。替换参数通过{}来标识。必须用字典形式表示。

help(str.format_map)
Help on built-in function format_map:

format_map(...) method of builtins.str instance
    S.format_map(mapping) -> str
    
    Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces ('{' and '}').

'I am a {sex}.I am {age} years old.'.format_map({'sex':'girl','age':18})  #用S.format_map的字典映射的方式替换
Out[54]: 'I am a girl.I am 18 years old.'

 

34.S.count()  返回的数量范围内出现的子串子[开始，结束]。片符号被解释为可选参数的开始和结束。

help(str.count)
Help on built-in function count:

count(...) method of builtins.str instance
    S.count(sub[, start[, end]]) -> int
    
    Return the number of non-overlapping occurrences of substring sub in string S[start:end].  Optional arguments start and end are     interpreted as in slice notation.  #返回字符串（切片的子串）中的非重叠出现的次数

str.count('s')
Out[17]: 3

str.count('s',4,)
Out[18]: 2

 

35.S.join()  将序列中的元素以指定的字符连接生成一个新的字符串。指定的字符.join('字符串')

help(str.join)
Help on built-in function join:

join(...) method of builtins.str instance
    S.join(iterable) -> str
    
    Return a string which is the concatenation of the strings in the iterable.  The separator between elements is S. #用str字符串作为分隔符，将传入的iterable（可迭代对象）分隔开来。

str.join('123')  #用S填充在1,2,3之间
Out[114]: '1this is a string2this is a string3'

str.join('*')   #“*”不可迭代，所以无效
Out[115]: '*'

str.join('==')  #str作为分隔符，将“==”可迭代对象进行分隔。
Out[119]: '=this is a string='

'+'.join(str)
Out[120]: 't+h+i+s+ +i+s+ +a+ +s+t+r+i+n+g'

'+'.join('123456789')
Out[121]: '1+2+3+4+5+6+7+8+9'

#故，前面是  分隔符.join(iterable)

 

36.S.replace() 将字符串中的指定的旧字符更改为新字符，可以限定替换的个数

help(str.replace)
Help on built-in function replace:

replace(...) method of builtins.str instance
    S.replace(old, new[, count]) -> str
    
    Return a copy of S with all occurrences of substring old replaced by new.  If the optional argument count is given, only the first count occurrences are replaced. #返回所有旧子字符串被新的子字符串替换的字符串的副本。如果可选参数count给定了具体值，仅仅替换给定的count的前几个出现的值。

'11111'.replace("1","2",2)
Out[170]: '22111'

 

37.S.encode() 对字符串按照指定编码进行编码，解码

help(str.encode)
Help on built-in function encode:

encode(...) method of builtins.str instance
    S.encode(encoding='utf-8', errors='strict') -> bytes
    
    Encode S using the codec registered for encoding. Default encoding
    is 'utf-8'. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
    'xmlcharrefreplace' as well as any other name registered with
    codecs.register_error that can handle UnicodeEncodeErrors.

'this is a string'.encode(encoding='ASCII',errors='strict') #对str向ascii码进行编码；
Out[22]: b'this is a string'

'this is a string'.encode(encoding='ASCII',errors='strict').decode('utf-8')  
#对二进制进行解码
Out[25]: 'this is a string'

 

38.S.swapcase()  大小写字母切换，大写变小写，小写变大写

help(str.swapcase)
Help on built-in function swapcase:

swapcase(...) method of builtins.str instance
    S.swapcase() -> str
    
    Return a copy of S with uppercase characters converted to lowercase and vice versa. #返回字符串转换完成的副本，大小字符转换为小写字母，小写字母转换为大写字母。

'aA'.swapcase()
Out[192]: 'Aa'

 

39.S.expandtabs()  返回在制表符，即通过空格进行了扩展字符串，' '的副本。

help(str.expandtabs)
Help on built-in function expandtabs:

expandtabs(...) method of builtins.str instance
    S.expandtabs(tabsize=8) -> str
    
    Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed.


'this is a string'.expandtabs(tabsize=50)  #由于str中没有制表符，所以没有起到作用。
Out[39]: 'this is a string'

'a\t'.expandtabs(tabsize=50)  #仅对制表符tab characters起到作用。最终结果是字符串加上空格键=50
Out[41]: 'a                                                 '

 

40.S.maketrans()   

用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。

help(str.maketrans)
Help on built-in function maketrans:

maketrans(x, y=None, z=None, /)
    Return a translation table usable for str.translate().
    
    If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals.
 #如果仅有一个参数，那么这个参数必须是一个字典映射的序列（整数），字符序列或字符串。字符的键必须被转换成序列。
If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. #如果有两个参数，他们必须是两个等长的，并且在返回结果的字典中是一一对应的关系。参数x上的每个字符将会对应在相同的下标位上的参数y的字符。
If there is a third argument, it must be a string, whose characters will be mapped to None in the result. #如果有三个参数，参数必须是一个字符串，其字符在结果中会映射到None。

intab='aeiou'

outtab='12345'

str_trantab=str.maketrans(intab,outtab)

test_str='csdn blog:http://blog.csdn.net/wirelessqa'

print(test_str.translate(str_trantab))
csdn bl4g:http://bl4g.csdn.n2t/w3r2l2ssq1

#可以用于暗码的，无解，仅能够通过得知源代码才能解析出原来的字符串的结果。

 

41.S.translate()  根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。

help(str.maketrans)
Help on built-in function maketrans:

maketrans(x, y=None, z=None, /)
    Return a translation table usable for str.translate().
    
    If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals.
 #如果仅有一个参数，那么这个参数必须是一个字典映射的序列（整数），字符序列或字符串。字符的键必须被转换成序列。
If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. 
#如果有两个参数，他们必须是两个等长的，并且在返回结果的字典中是一一对应的关系。参数x上的每个字符将会对应在相同的下标位上的参数y的字符。
If there is a third argument, it must be a string, whose characters will be mapped to None in the result.
#如果有三个参数，参数必须是一个字符串，其字符在结果中会映射到None。

intab='aeiou'

outtab='12345'

str_trantab=str.maketrans(intab,outtab)

test_str='csdn blog:http://blog.csdn.net/wirelessqa'

print(test_str.translate(str_trantab))
csdn bl4g:http://bl4g.csdn.n2t/w3r2l2ssq1

#可以用于暗码的，无解，仅能够通过得知源代码才能解析出原来的字符串的结果。

语法

translate()方法语法：str.translate(table[, deletechars]);

参数:table -- 翻译表，翻译表是通过maketrans方法转换而来。

       deletechars -- 字符串中要过滤的字符列表。

返回值：返回翻译后的字符串。

42.S.zfill()  指定字符串长度，填充0到字符串的左边。

help(str.zfill)
Help on built-in function zfill:

zfill(...) method of builtins.str instance
    S.zfill(width) -> str
    
    Pad a numeric string S with zeros on the left, to fill a field of the specified width. The string S is never truncated.#在左侧填充0，以填充指定宽度的字段。字符串永远不会被截断。

'this is a string'.zfill(30)
Out[43]: '00000000000000this is a string'

 

43.S.partition() 指定分隔符，在字符串中查找分隔符，返回分隔符之前的部分，分隔符本身和分隔符之后的部分。结果为一个元组。从左向右开始，仅将最小下标的指定分隔符作为分隔符。

help(str.partition)
Help on built-in function partition:

partition(...) method of builtins.str instance
    S.partition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, and return the part before it, the separator itself, and the part after it.  If the separator is not found, return S and two empty strings.  #在字符串中查找分隔符，返回分隔符之前的部分，分隔符本身和分隔符之后的部分。如果分隔符没有找到，返回字符串本身和两个空的字符串。

 "my name is {}, and age is {}".partition('is')
Out[178]: ('my name ', 'is', ' {}, and age is {}')
#分隔符之前的部分，分隔符本身，分隔符之后的部分。
#从前往后，选中第一个is作为分隔符

 

44.S.rpartition()  指定分隔符，在字符串中查找分隔符，返回分隔符之前的部分，分隔符本身和分隔符之后的部分。结果为一个元组。从右向左开始，仅将最大下标的指定分隔符作为分隔符。

help(str.rpartition)
Help on built-in function rpartition:

rpartition(...) method of builtins.str instance
    S.rpartition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, starting at the end of S, and return the part before it, the separator itself, and the part after it.  If the separator is not found, return two empty strings and S.
#在字符串中查找分隔符，在字符串的最后开始，返回分隔符之前的部分，分隔符本身和分隔符之后的部分。如果分隔符没有找到，返回两个空的字符串和字符串本身。

 "my name is {}, and age is {}".rpartition('is')
Out[179]: ('my name is {}, and age ', 'is', ' {}')
#分隔符之前的部分，分隔符本身，分隔符之后的部分。
#从后往前，选中第一个is作为分隔符