文本是程序需要处理的最常见的数据形式。你已经知道如何用+操作符连接两个字符串， 但能做的事情还要多得多。可以从字符串中提取部分字符串， 添加或删除空白字符， 将字母转换成小写或大写， 检查字符串的格式是否正确。你甚至可以编写 Python 代码访问剪贴板， 复制或粘贴文本。
文章目录
处理字符串
原始字符串
可以在字符串开始的引号之前加上 r， 使它成为原始字符串。“原始字符串” 完全忽略所有的转义字符， 打印出字符串中所有的倒斜杠。
>>> print(r'That is Carol\'s cat.')
That is Carol\'s cat.
用三重引号的多行字符串
虽然可以用\n转义字符将换行放入一个字符串， 但使用多行字符串通常更容易。在 Python 中，多行字符串的起止是 3 个单引号或 3 个双引号。“三重引号” 之间的所有引号、 制表符或换行， 都被认为是字符串的一部分。 Python 的代码块缩进规则不适用于多行字符串。
print('''Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob''')
输出：
Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob
多行注释
虽然井号字符（#） 表示这一行是注释， 但多行字符串常常用作多行注释。下面是完全有效的 Python 代码：
"""This is a test Python program.
Written by Al Sweigart al@inventwithpython.com
This program was designed for Python 3, not Python 2.
"""
def spam():
"""This is a multiline comment to help
explain what the spam() function does."""
print('Hello!')
字符串下标和切片
字符串像列表一样，使用下标和切片。可以将字符串’Hello world!'看成是一个列表，字符串中的每个字符都是一个表项，有对应的下标。
' H e l l o w o r l d ! '
0 1 2 3 4 5 6 7 8 9 10 11
字符计数包含了空格和感叹号， 所以’Hello world!'有 12 个字符， H 的下标是 0， !的下标是 11。
>>> spam = 'Hello world!'
>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'
>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!
请注意， 字符串切片并没有修改原来的字符串。可以从一个变量中获取切片，记录在另一个变量中。
字符串的 in 和 not in 操作符
像列表一样，in和not in操作符也可以用于字符串。用 in 或 not in 连接两个字符串得到的表达式， 将求值为布尔值 True 或 False。
>>> 'Hello' in 'Hello World'
True
>>> 'Hello' in 'Hello'
True
>>> 'HELLO' in 'Hello World'
False
有用的字符串方法
字符串方法 upper()、 lower()、 isupper()和 islower()
upper()和 lower()字符串方法返回一个新字符串，其中原字符串的所有字母都被相应地转换为大写或小写。字符串中非字母字符保持不变。
>>> spam = 'Hello world!'
>>> spam = spam.upper()
>>> spam
'HELLO WORLD!'
>>> spam = spam.lower()
>>> spam
'hello world!'
请注意， 这些方法没有改变字符串本身， 而是返回一个新字符串。如果你希望改变原来的字符串， 就必须在该字符串上调用 upper()或 lower()， 然后将这个新字符串赋给保存原来字符串的变量。
如果字符串至少有一个字母， 并且所有字母都是大写或小写，isupper()和islower()方法就会相应地返回布尔值 True。否则， 该方法返回 False。
>>> spam = 'Hello world!'
>>> spam.islower()
False
>>> spam.isupper()
False
>>> 'HELLO'.isupper()
True
>>> 'abc12345'.islower()
True
>>> '12345'.islower()
False
>>> '12345'.isupper()
False
isX 字符串方法
除了 islower()和 isupper()， 还有几个字符串方法，它们的名字以 is 开始。这些方法返回一个布尔值， 描述了字符串的特点。下面是一些常用的 isX 字符串方法：
- isalpha()返回 True， 如果字符串只包含字母， 并且非空；
- isalnum()返回 True，如果字符串只包含字母和数字，并且非空；
- isdecimal()返回 True，如果字符串只包含数字字符，并且非空；
- isspace()返回 True，如果字符串只包含空格、制表符和换行，并且非空；
- istitle()返回 True，如果字符串仅包含以大写字母开头、后面都是小写字母的单词。
>>> 'hello'.isalpha()
True
>>> 'hello123'.isalpha()
False
>>> 'hello123'.isalnum()
True
>>> 'hello'.isalnum()
True
>>> '123'.isdecimal()
True
>>> ' '.isspace()
True
>>> 'This Is Title Case'.istitle()
True
>>> 'This Is Title Case 123'.istitle()
True
>>> 'This Is not Title Case'.istitle()
False
>>> 'This Is NOT Title Case Either'.istitle()
False
字符串方法 startswith()和 endswith()
startswith()和 endswith()方法返回 True， 如果它们所调用的字符串以该方法传入的字符串开始或结束。否则， 方法返回 False。
>>> 'Hello world!'.startswith('Hello')
True
>>> 'Hello world!'.endswith('world!')
True
>>> 'abc123'.startswith('abcdef')
False
>>> 'abc123'.endswith('12')
False
>>> 'Hello world!'.startswith('Hello world!')
True
>>> 'Hello world!'.endswith('Hello world!')
True
字符串方法 join()和 split()
如果有一个字符串列表， 需要将它们连接起来，成为一个单独的字符串，join()方法就很有用。 join()方法在一个字符串上调用， 参数是一个字符串列表， 返回一个字符串。返回的字符串由传入的列表中每个字符串连接而成。
>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'
请注意，调用 join()方法的字符串， 被插入到列表参数中每个字符串的中间。例如，如果在’, ‘字符串上调用 join([‘cats’, ‘rats’, ‘bats’])， 返回的字符串就是’cats, rats, bats’。
split()方法做的事情正好相反：它针对一个字符串调用， 返回一个字符串列表。
>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']
默认情况下，字符串’My name is Simon’按照各种空白字符分割， 诸如空格、 制表符或换行符。这些空白字符不包含在返回列表的字符串中。也可以向 split()方法传入一个分割字符串， 指定它按照不同的字符串分割。
>>> 'MyABCnameABCisABCSimon'.split('ABC')
['My', 'name', 'is', 'Simon']
>>> 'My name is Simon'.split('m')
['My na', 'e is Si', 'on']
一个常见的 split()用法， 是按照换行符分割多行字符串。
>>> spam = '''Dear Alice,
How have you been? I am fine.
There is a container in the fridge
that is labeled "Milk Experiment".
Please do not drink it.
Sincerely,
Bob'''
>>> spam.split('\n')
['Dear Alice,', 'How have you been? I am fine.', 'There is a container in the
fridge', 'that is labeled "Milk Experiment".', '', 'Please do not drink it.',
'Sincerely,', 'Bob']
用 rjust()、 ljust()和 center()方法对齐文本
rjust()和 ljust()字符串方法返回调用它们的字符串的填充版本， 通过插入空格来对齐文本。 这两个方法的第一个参数是一个整数长度， 用于对齐字符串。
>>> 'Hello'.rjust(10)
' Hello'
>>> 'Hello'.rjust(20)
' Hello'
>>> 'Hello World'.rjust(20)
' Hello World'
>>> 'Hello'.ljust(10)
'Hello
‘Hello’.rjust(10)是说我们希望右对齐，将’Hello’放在一个长度为 10 的字符串中。'Hello’有 5 个字符， 所以左边会加上 5 个空格， 得到一个 10 个字符的字符串， 实现’Hello’右对齐。
rjust()和 ljust()方法的第二个可选参数将指定一个填充字符， 取代空格字符。
>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')
'Hello---------------'
center()字符串方法与 ljust()与 rjust()类似， 但它让文本居中， 而不是左对齐或右对齐。
>>> 'Hello'.center(20)
' Hello '
>>> 'Hello'.center(20, '=')
'=======Hello========'
用 strip()、 rstrip()和 lstrip()删除空白字符
有时候你希望删除字符串左边、 右边或两边的空白字符（空格、制表符和换行符）。 strip()字符串方法将返回一个新的字符串， 它的开头或末尾都没有空白字符。lstrip()和 rstrip()方法将相应删除左边或右边的空白字符。
>>> spam = ' Hello World '
>>> spam.strip()
'Hello World'
>>> spam.lstrip()
'Hello World '
>>> spam.rstrip()
' Hello World'
有一个可选的字符串参数， 指定两边的哪些字符应该删除。
>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> spam.strip('ampS')
'BaconSpamEggs'
向 strip()方法传入参数’ampS’， 告诉它在变量中存储的字符串两端， 删除出现的a、 m、 p 和大写的 S。传入 strip()方法的字符串中， 字符的顺序并不重要： strip(‘ampS’)做的事情和 strip(‘mapS’)或 strip(‘Spam’)一样。
用 pyperclip 模块拷贝粘贴字符串
pyperclip 模块有 copy()和 paste()函数， 可以向计算机的剪贴板发送文本， 或从它接收文本。将程序的输出发送到剪贴板， 使它很容易粘贴到邮件、文字处理程序或其他软件中。 pyperclip 模块不是 Python 自带的。
>>> import pyperclip
>>> pyperclip.copy('Hello world!')
>>> pyperclip.paste()
'Hello world!'
expandtabs() 方法
str.expandtabs(tabsize=8)
expandtabs() 方法把字符串中的 tab 符号(’\t’)转为空格，tab 符号(’\t’)默认的空格数是 8。可选择使用给定的tabsize(默认8)扩展。
从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。
test='username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123'
v=test.expandtabs(20)
print(v)
输出：
函数
-
str.capitalize()
返回原字符串的副本，其首个字符大写，其余为小写。 -
str.casefold()
返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。
消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。 例如，德语小写字母 ‘ß’ 相当于 “ss”。 由于它已经是小写了，lower() 不会对 ‘ß’ 做任何改变；而 casefold() 则会将其转换为 “ss”。 -
str.center(width[, fillchar])
返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。 -
str.count(sub[, start[, end]])
反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。 -
str.encode(encoding="utf-8", errors="strict")
返回原字符串编码为字节串对象的版本。 默认编码为 ‘utf-8’。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 ‘strict’，表示编码错误会引发 UnicodeError。 其他可用的值为 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及任何其他通过 codecs.register_error() 注册的值，请参阅 Error Handlers 小节。 要查看可用的编码列表，请参阅 标准编码 小节。 -
str.endswith(suffix[, start[, end]])
如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。 -
str.expandtabs(tabsize=8)
返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。
>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234'
str.find(sub[, start[, end]])
返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。
注解 find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:
>>>
>>> 'Py' in 'Python'
True
str.format(*args, **kwargs)
执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。
>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'
注解 当使用 n 类型 (例如: ‘{:n}’.format(1234)) 来格式化数字 (int, float, complex, decimal.Decimal 及其子类) 的时候，该函数会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域以解码 localeconv() 的 decimal_point 和 thousands_sep 字段，如果它们是非 ASCII 字符或长度超过 1 字节的话，并且 LC_NUMERIC 区域会与 LC_CTYPE 区域不一致。 这个临时更改会影响其他线程。
在 3.7 版更改: 当使用 n 类型格式化数字时，该函数在某些情况下会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域。
str.format_map(mapping)
类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况：
>>> class Default(dict):
... def __missing__(self, key):
... return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'
-
str.index(sub[, start[, end]])
类似于 find()，但在找不到子类时会引发 ValueError。 -
str.isalnum()
如果字符串中至少有一个字符且所有字符均为字母或数字则返回真值，否则返回假值。 如果以下方法中的一个返回 True 则字符 c 为字母或数字: c.isalpha(), c.isdecimal(), c.isdigit(), or c.isnumeric()。 -
str.isalpha()
如果字符串中至少有一个字符且所有字符均为字母则返回真值，否则返回假值。 字母类字符是在 Unicode 字符数据库中被定义为 “Letter” 的字符，即一般分类特征属性为 “Lm”, “Lt”, “Lu”, “Ll” 或 “Lo” 其中之一。 请注意这不同于 Unicode 标准所定义的 “Alphabetic” 特征属性。 -
str.isascii()
如果字符串为空或所有字符均为 ASCII 字符则返回真值，否则返回假值。 ASCII 字符的码位范围为 U+0000-U+007F。 -
str.isdecimal()
如果字符串中至少有一个字符且所有字符均为十进制数字符则返回真值，否则返回假值。 十进制数字符是以 10 为基数的计数制会用来组成数值的字符，例如 U+0660, ARABIC-INDIC DIGIT ZERO。 正式的定义为：十进制数字符就是 Unicode 一般分类 “Nd” 中的字符。 -
str.isdigit()
如果字符串中至少有一个字符且所有字符均为数字字符则返回真值，否则返回假值。 数字字符包括十进制数字符和需要特别处理的数字，例如兼容性上标数字。 这也涵盖了不能被用来组成以 10 为基数的数值的数字，例如 Kharosthi 数字。 正式的定义为：数字字符就是特征属性值 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。 -
str.isidentifier()
如果字符串根据语言定义属于有效的标识符则返回真值，参见 标识符和关键字。 -
str.islower()
如果字符串中至少有一个区分大小写的字符 4 且此类字符均为小写则返回真值，否则返回假值。 -
str.isnumeric()
如果字符串中至少有一个字符且所有字符均为数值字符则返回真值，否则返回假值。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。 -
str.isprintable()
如果字符串中所有字符均为可打印字符或字符串为空则返回真值，否则返回假值。 不可打印字符是在 Unicode 字符数据库中被定义为 “Other” 或 “Separator” 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。 它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。） -
str.isspace()
如果字符串中至少有一个字符且所有字符均为空白字符则返回真值，否则返回假值。 空白字符是在 Unicode 字符数据库中被定义为 “Other” 或 “Separator” 并且其双向特征属性为 “WS”, “B” 或 “S” 之一的字符。 -
str.istitle()
如果字符串中至少有一个字符且为标题字符串则返回真值，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回假值。 -
str.isupper()
如果字符串中至少有一个区分大小写的字符 4 具此类字符均为大写则返回真值，否则返回假值。 -
str.join(iterable)
返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。 -
str.ljust(width[, fillchar])
返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。 -
str.lower()
返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写。 -
str.lstrip([chars])
返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:
>>>
>>> ' spacious '.lstrip()
'spacious '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'
static str.maketrans(x[, y[, z]])
此静态方法返回一个可供 str.translate() 使用的转换对照表。
如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。
如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。
-
str.partition(sep)
在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。 -
str.replace(old, new[, count])
返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。 -
str.rfind(sub[, start[, end]])
返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。 -
str.rindex(sub[, start[, end]])
类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。 -
str.rjust(width[, fillchar])
返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。 -
str.rpartition(sep)
在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。 -
str.rsplit(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。 -
str.rstrip([chars])
返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:
>>>
>>> ' spacious '.rstrip()
' spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
str.split(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。
如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 ‘1,2’.split(’,’) 将返回 [‘1’, ‘’, ‘2’])。 sep 参数可能由多个字符组成 (例如 ‘1<>2<>3’.split(’<>’) 将返回 [‘1’, ‘2’, ‘3’])。 使用指定的分隔符拆分空字符串将返回 [’’]。
例如:
>>>
>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。
例如:
>>>
>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']
str.splitlines([keepends])
返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
-
str.startswith(prefix[, start[, end]])
如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。 -
str.strip([chars])
返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:
>>>
>>> ' spacious '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'
``
最外侧的前导和末尾 chars 参数值将从字符串中移除。 开头端的字符的移除将在遇到一个未包含于 chars 所指定字符集的字符时停止。 类似的操作也将在结尾端发生。 例如:
comment_string = ‘#… Section 3.2.1 Issue #32 …’
comment_string.strip(’.#! ')
‘Section 3.2.1 Issue #32’
str.swapcase()
返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。
str.title()
返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。
例如:
>>>
>>> 'Hello world'.title()
'Hello World'
该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。 该定义在多数情况下都很有效，但它也意味着代表缩写形式与所有格的撇号也会成为单词边界，这可能导致不希望的结果:
>>>
>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"
可以使用正则表达式来构建针对撇号的特别处理:
>>>
>>> import re
>>> def titlecase(s):
... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
... lambda mo: mo.group(0)[0].upper() +
... mo.group(0)[1:].lower(),
... s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."
str.upper()
返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 “Lu” (Letter, uppercase) 而是 “Lt” (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。
所用转换大写算法的描述请参见 Unicode 标准的 3.13 节。
str.zfill(width)
返回原字符串的副本，在左边填充 ASCII ‘0’ 数码使其长度变为 width。 正负值前缀 (’+’/’-’) 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。
例如:
>>>
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'
856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
