字符串
- 1.基本内容
- 2.方法
- 2.1 大小写
- str.capitalize()
- str.casefold()
- str.islower()
- str.lower()
- str.isupper()
- str.upper()
- str.swapcase()
- str.title()
- 2.2 显示位置
- str.center(width[, fillchar])
- str.endswith(suffix[, start[, end]])
- str.startswith(prefix[, start[, end]])
- str.ljust(width[, fillchar])
- str.rjust(width[, fillchar])
- str.lstrip([chars])
- str.rstrip([chars])
- str.strip([chars])
- str.expandtabs(tabsize=8)
- str.zfill(width)
- 2.3 子串查找
- str.find(sub[, start[, end]])
- str.index(sub[, start[, end]])
- str.rfind(sub[, start[, end]])
- str.rindex(sub[, start[, end]])
- 2.4 分割
- str.split(sep=None, maxsplit=-1)
- str.rsplit(sep=None, maxsplit=-1)
- str.splitlines([keepends])
- str.partition(sep)
- str.rpartition(sep)
- str.replace(old, new[, count])
- 2.5 性质判断
- str.isalnum()
- str.isalpha()
- str.isascii()
- str.isdecimal()
- str.isdigit()
- str.isidentifier()
- str.isnumeric()
- str.isprintable()
- str.isspace()
- str.istitle()
- 2.6 其他
- 3.格式化
1.基本内容
1.1 概念
字符串就是一段文本（可能只有一个字母），由文本两端的引号引起； Python中的文本数据由str对象或strings进行处理。
特点：字符串是不可变（的Unicode码点）序列
1.2 构造方法
（1）文本是字符串字面值：
- 单引号:
'，允许文本中嵌入多对 双引号"。 - 双引号:
"，允许 嵌入多对 单引号'。 - 三引号：
'''或"""，允许嵌入多对单引号，双引号。
（2）如果是一个对象，对对象使用str()方法
1.3 组成
stringliteral ::= [stringprefix](shortstring | longstring)
stringprefix ::= "r" | "u" | "R" | "U"
shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::= shortstringchar | stringescapeseq
longstringitem ::= longstringchar | stringescapeseq
shortstringchar ::= <any source character except "\" or newline or the quote>
longstringchar ::= <any source character except "\">
stringescapeseq ::= "\" <any source character>
字符串用字母’r’或’R’作为前缀；这样的字符串称为raw string并将反斜杠作为原义字符。因此，原始字符串中的’\U’ 和’\u’ 转义符是不会特殊对待。
1.3.1 转义
（1）除非出现前缀’r’ 或’R’，否则字符串和字节字面量中的转义序列依照类似标准C使用的规则解释。可识别的转义序列有：
| 转义序列 | 含义 |
|---|---|
| \newline | 忽略反斜杠和换行 |
| \ | 反斜杠() |
| ’ | 单引号(’) |
| " | 双引号(") |
| \a | ASCII响铃(BEL) |
| \b | ASCII退格(BS) |
| \f | ASCII换页(FF) |
| \n | ASCII换行(LF) |
| \r | ASCII回车(CR) |
| \t | ASCII水平制表(TAB) |
| \v | ASCII垂直制表(VT) |
| \ooo | 八进制值为ooo的字符 （注意点1，3） |
| \xhh | 十六进制值为hh的字符 （注意点2，3） |
（2）只在字符串字面值中识别的转义序列是︰
| 转义序列 | 含义 | 注意点 |
|---|---|---|
| \N{name} | Unicode数据库中名为name的字符 | （4） |
| \uxxxx | 16位的十六进制值为xxxx的字符 | （5） |
| \Uxxxxxxxx | 32位的十六进制值为xxxxxxxx的字符 | （6） |
（3）注意点：
-
与标准C 一样，最多接受三个八进制数字。
-
与标准C 不同，要求两个精确的十六进制数字。
-
在字符串字面值中，这些转义表示给定的值的Unicode字符。
-
版本 3.3 中的更改︰名称别名 [1] 支持已被添加。
-
四个十六进制数字是必需的。
任何 Unicode 字符可以以这种方式被编码。恰好八个十六进制数字是必需的。
1.4 例子：
（1）定义字符串：
def str_define():
s1 = '单引号引起双引号"内容"'
s2 = "双引号引起单引号'内容'"
s3 = '''三引号引起"内容1",'内容2','''
s4 = """三引号引起"内容1",'内容2',"""
print(s1)
print(s2)
print(s3)
print(s4)
#输出结果
单引号引起双引号"内容"
双引号引起单引号内容''
三引号引起"内容1",'内容2',
三引号引起"内容1",'内容2',
（2）前缀和转义字符
def str_escape_prefix():
s1 = 'hello\tMr,lengfengyuyu\nworld'
s2 = 'hello\u0009Mr,lengfengyuyu\nworld'
s3 = r'hello\tMr,lengfengyuyu\nworld'
s4 = r'hello\u0009Mr,lengfengyuyu\nworld'
s5 = u'hello\tMr,lengfengyuyu\nworld'
s6 = u'hello\u0009Mr,lengfengyuyu\nworld'
print("s1:",s1)
print("s2:", s2)
print("s3:", s3)
print("s4:", s4)
print("s5:", s5)
print("s6:", s6)
# 输出结果
s1: hello Mr,lengfengyuyu
world
s2: b'hello\tMr,lengfengyuyu\n\xd6\xd0world'
s3: hello\tMr,lengfengyuyu\nworld
s4: hello\u0009Mr,lengfengyuyu\nworld
s5: hello Mr,lengfengyuyu
world
s6: hello Mr,lengfengyuyu
world
上面的结果能看出r前缀的作用，但是u前缀的作用不明显，下面再解释
（3）其他转义内容：
def str_escape():
s1 = 'hello\N{TAB}Mr,lengfengyuyu\nworld'
s2 = 'i have \x61n apple & 5 \x62ananas & \141 pen'
s3 = 'i have \u0061n apple & 5 \U00000062ananas & \141 pen'
print("s1:",s1)
print("s2:",s2)
print("s3:",s3)
# 输出结果
s1: hello Mr,lengfengyuyu
world
s2: i have an apple & 5 bbananas & a pen
s3: i have an apple & 5 bbananas & a pen
2.方法
2.1 大小写
首先定义一个字符串s:
s = 'hello , Welcome to my worLd!ß'
str.capitalize()
功能：返回字符串的一个副本，其首字母大写，其余的小写。
s.capitalize()
#输出结果
Hello , welcome to my world!ß
str.casefold()
功能：获得字符串小写的副本。
版本：python 3.3中的新方法。
与lower()方法很像，但是lower() 只对 ASCII 也就是 ‘A-Z’有效，但是其它一些语言里面存在小写的情况就没办法了，文档里面举得例子是德语中’ß’的小写是’ss’。
Unicode标准的第3.13节描述了casefolding算法。
s.casefold()
#输出结果
hello , welcome to my world!ss
str.islower()
功能：如果字符串中的所有字母字符都是小写字母且至少有一个字符，则返回true，否则返回false。
def str_lower():
s = '123!@#book'
s1 = 'Book'
print(s.islower())
print(s1.islower())
#输出结果
True
False
str.lower()
功能：返回原字符串的副本，副本把所有字母字符转换为小写字母。
Unicode标准的第3.13节描述了使用的小写字母转换算法。
def str_upper_lower():
s1 = 'BOOK123'
s2 = 'book123'
print(s1.lower())
print(s2.upper())
#输出结果
book123
BOOK123
str.isupper()
功能：如果字符串中的所有字母字符都是大写且至少有一个字符，则返回true，否则返回false。
def str_upper():
s = '123!@#book'
s1 = 'BOOK123'
print(s.isupper())
print(s1.isupper())
#输出结果
False
True
str.upper()
功能：返回原字符串的副本，副本把所有字母字符转换为大写字母。
注意：str.upper().isupper()可能判断有误，因为字符串可能含有非字母字符或者Unicode类的字符（非’Lu’,是’Lt’）。
Unicode标准的第3.13节描述了使用的大写字母算法。
def str_upper():
s = '123!@#book'
s1 = 'BOOK123ß'
print(s.upper())
print(s1.upper())
print(s1.upper().isupper())
#输出结果
123!@#BOOK
BOOK123
True
str.swapcase()
功能：返回原始字符串大小写转换之后的新字符串（大小写转换）。
def str_swapcase():
s = 'aBcDeFg,hh123'
print(s.swapcase())
print(s.swapcase().swapcase())
# 输出结果
AbCdEfG,HH123
aBcDeFg,hh123
str.title()
功能：字符串中单词的首字母大写，单词中的其他部分变小写。
def str_title():
s = 'hello, mR lengYengYuyu'
print(s.title())
s = "hello, mR leng,they're bill's friends from the UK"
print(s.title())
# 输出结果
Hello, Mr Lengyengyuyu
Hello, Mr Leng,They'Re Bill'S Friends From The Uk
该算法使用简单的与语言无关的单词作为连续字母组的定义。该定义在许多情况下都有效，但这意味着收缩和占有者中的撇号会形成单词边界，这可能不是理想的结果，如上面的第二个输出。
可以使用正则表达式构造撇号的解决方法：
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)
def str_title():
s = "hello, mR l,they're bill's friends from the UK"
print(s.title())
print(titlecase(s))
if __name__ == "__main__":
str_title()
# 输出结果
Hello, Mr L,They'Re Bill'S Friends From The Uk
Hello, Mr L,They're Bill's Friends From The Uk
2.2 显示位置
str.center(width[, fillchar])
功能：返回以width为长度的字符串，str在中心。填充是使用指定的fillchar完成的（默认是ASCII空格）。如果你指定的长度小于字符串的长度，默认返回原始字符串.
s.center(5)
s.center(50)
s.center(50,'-')
s.center(50, '中')
#输出结果
hello , Welcome to my worLd!ß
hello , Welcome to my worLd!ß
----------hello , Welcome to my worLd!ß-----------
中中中中中中中中中中hello , Welcome to my worLd!ß中中中中中中中中中中中
str.endswith(suffix[, start[, end]])
功能：如果字符串以指定的suffix结尾则返回True，否则返回False。
suffix也可以是元组形式。使用可选的start，从该位置开始测试。使用可选的结束位置。
def str_endwidth():
s = 'de encoding'
print(s.startswith('g'))
print(s.startswith(('g','d')))
print(s.endswith('g'))
print(s.endswith(('g','s')))
print(s.endswith('g',len(s),len(s)+1))
# 输出结果
False
True
True
True
False
str.startswith(prefix[, start[, end]])
功能：如果字符串以prefix开头则返回True，否则返回False。
prefix也可以是元组形式。使用可选的start，测试字符串从该位置开始。使用可选的结束位置。参数用法同str.endswith()。
str.ljust(width[, fillchar])
功能：以width宽度的字符串将字符串左对齐。填充是使用指定的fillchar完成的（默认是ASCII空格）。如果指定的长度小于字符串的长度，返回原字符串.
def str_ljust():
s = '*****'
print(s.ljust(50,'-'))
print(s.rjust(50, '-'))
print(s.ljust(5,'-'))
# 输出结果
*****---------------------------------------------
---------------------------------------------*****
*****
str.rjust(width[, fillchar])
功能：以width宽度的字符串返回右对齐的字符串。
参数用法同str.ljust()。
str.lstrip([chars])
功能：返回删除前导字符的字符串的副本。
chars参数是一个字符串，用于指定要删除的字符集。如果省略或None，chars参数默认为删除空白。字符参数不是前缀；相反，其值的所有组合都要被剥离，而且是贪婪的：
def str_strip():
s= '\taa\tbcd'
print(s.lstrip())
s = 'aabcd'
print(s.lstrip('a'))
s = 'www.google.com'
print(s.lstrip('abcdw.zgo'))
#输出结果
aa bcd
bcd
le.com
str.rstrip([chars])
功能：返回删除尾随字符的字符串的副本。
参数用法同str.lstrip()。
str.strip([chars])
功能：返回删除前导字符和尾随字符的字符串副本。
参数用法同str.lstrip()。
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'
str.expandtabs(tabsize=8)
功能：返回字符串的副本，其中所有制表符由一个或多个空格替换，具体取决于当前列和给定制表符大小。
每个tabsize字符都会出现制表符位置（默认值为8，在列0,8,16等处提供制表位置）。要扩展字符串，当前列设置为零，字符串逐个检查。如果该字符是一个制表符（\t），则在结果中插入一个或多个空格字符，直到当前列等于下一个制表符位置。（制表符本身不被复制。）如果该字符是换行符（\n）或返回（\r），则会将其复制并将当前列重置为零。任何其他字符都将被不变地复制，而当前列增加1，无论打印时字符如何表示。
s = 'what the\tff'
print(s.expandtabs())
print(s.expandtabs(2))
print(s.expandtabs(4))
print(s.expandtabs(8))
# 输出结果
what the ff
what the ff
what the ff
what the ff
str.zfill(width)
功能：返回左侧填充有ASCII 0位的字符串的副本，以生成宽度为width的字符串。
前导符号前缀（’+’ / ‘-’）通过在符号字符后面插入填充符来处理，而不是在之前。指定的width超过字符串的长度会返回原字符串。
def str_fill():
print("42".zfill(8))
print("-42".zfill(8))
print("--42".zfill(8))
print("---42".zfill(8))
print("+42".zfill(8))
print("++42".zfill(8))
# 输出结果
00000042
-0000042
-0000-42
-000--42
+0000042
+0000+42
例如：
2.3 子串查找
str.find(sub[, start[, end]])
功能：返回在片段str[start:end]内找到子字符串sub的字符串中最小的索引。可选参数start和end被解释为切片表示法。如果未找到sub，则返回-1。
注意只有当你需要知道sub的位置时，才应该使用find()方法。要检查sub是否为子字符串，请使用运算符中的in
s = 'wow, wow a cow'
print(s.find('ow'))
print(s.find('ow',2))
print(s.find('ow', 2,3))
print(s.find('ww', 2, 3))
print('cow' in s)
# 输出结果
1
6
-1
-1
True
str.index(sub[, start[, end]])
功能：像find()一样，但在找不到子字符串时引发ValueError。
def str_index():
s = 'wow, wow a cow'
print(s.index('ow'))
print(s.index('ow',2))
print(s.index('ww', 2, 3))
# 输出结果
1
6
Traceback (most recent call last):
File "xx/cu02-datatype-str.py", line 95, in str_index
print(s.index('ww', 2, 3))
ValueError: substring not found
str.rfind(sub[, start[, end]])
功能：返回找到子字符串sub的字符串中的最大索引，使得sub包含在s[start:end]内。可选参数start和end被解释为切片表示法。失败时返回-1。
def str_replace():
s = 'wow, wow a cow'
print(s.rfind('w'))
print(s.rfind('w',7,12))
print(s.rindex('w'))
print(s.rindex('w', 7, 12))
# 输出结果
13
7
13
7
str.rindex(sub[, start[, end]])
功能：像上面的rfind()一样，但当子字符串sub未找到时引发ValueError。
2.4 分割
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']）。用指定的分隔符分割空字符串会返回[’’]。
def str_split():
s = 'a.b.c.d.e.f.g'
print(s.split('.'))
print(s.split('.',maxsplit=2))
s = 'a.b.c.d.e.f.g..'
print(s.split('.'))
#输出结果
['a', 'b', 'c', 'd', 'e', 'f', 'g']
['a', 'b', 'c.d.e.f.g']
['a', 'b', 'c', 'd', 'e', 'f', 'g', '', '']
如果没有指定sep或者是None，则应用不同的分割算法：将连续空白的运行视为单个分隔符，结果将不包含空字符串如果字符串具有前导或尾随空白。因此，使用None分隔符将空字符串或仅由空白组成的字符串拆分返回[]。
def str_split():
s = '1\t2 3 4 5'
print(s.split())
s = ' \t'
print(s.split())
# 输出结果
['1', '2', '3', '4', '5']
[]
str.rsplit(sep=None, maxsplit=-1)
功能：在字符串中，使用sep作为分隔符分割字符串，返回分割后的列表。如果给出maxsplit，则最多分割maxsplit次，从最右边开始。如果未指定sep或None，则任何空格字符串都是分隔符。除了从右边分割外，rsplit()的行为与split()的行为类似，下面详细介绍。
def str_split():
s = 'a.b.c.d.e.f.g'
print(s.rsplit())
print(s.rsplit('.'))
print(s.rsplit('.',3))
# 输出结果
['a.b.c.d.e.f.g']
['a', 'b', 'c', 'd', 'e', 'f', 'g']
['a.b.c.d', 'e', 'f', 'g']
str.splitlines([keepends])
功能：返回字符串中行的列表，在行边界处断开。换行符不包含在结果列表中，除非给出keepends且为true。
此方法分割在以下行边界上。特异指出，边界是universal newlines的超集。
| 表示 | 描述 |
|---|---|
| \n | 换行 |
| \r | 回车 |
| \r\n | 回车+换行 |
| \v或\x0b | 线条制表 |
| \f或\x0c | 表单换页 |
| \x1c | 文件分隔符 |
| \x1d | 组分隔符 |
| \x1e | 记录分隔符 |
| \x85 | 下一行（C1控制代码） |
| \u2028 | 行分隔符 |
| \u2029 | 段落分隔符 |
在python 3.2中更改： \v和\f添加到行边界列表中。
>>> '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']
与给定分隔符字符串sep时的split()不同，结尾的行分隔符不会导致额外的行：
>>> "One line\n".splitlines()
['One line']
>>> 'Two lines\n'.split('\n')
['Two lines', '']
str.partition(sep)
功能：在第一次出现sep时分割字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的3元组。如果未找到分隔符，则返回包含该字符串本身的三元组，然后返回两个空字符串。
def str_partition():
s = 'abc.efg.hij'
print(s.partition('.'))
print(s.partition('c.e'))
print(s.partition('?'))
# 输出结果
('abc', '.', 'efg.hij')
('ab', 'c.e', 'fg.hij')
('abc.efg.hij', '', '')
str.rpartition(sep)
功能：在最后出现的sep处拆分字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的3元组。如果未找到分隔符，则返回包含两个空字符串的三元组，然后返回字符串本身。
def str_rpartition():
s = 'abc.efg.hij'
print(s.rpartition('.'))
print(s.rpartition('c.e'))
print(s.rpartition('?'))
# 输出结果
('abc.efg', '.', 'hij')
('ab', 'c.e', 'fg.hij')
('', '', 'abc.efg.hij')
str.replace(old, new[, count])
功能：返回字符串的副本，其中所有出现的子字符串old由new替换。如果给出可选参数count，则仅替换count次。
def str_replace():
s = 'wow, wow a cow'
print(s.replace('w','?'))
print(s.replace('w', '?',3))
# 输出结果
?o?, ?o? a co?
?o?, ?ow a cow
2.5 性质判断
str.isalnum()
功能：如果字符串中的所有字符都是字母数字并且至少有一个字符，则返回true，否则返回false。
A character c is alphanumeric if one of the following returns True: c.isalpha(), c.isdecimal(), c.isdigit(), or c.isnumeric().
s = 'abc123'
print(s.isalnum())
#输出结果
True
str.isalpha()
功能：如果字符串中的所有字符都是字母并且至少有一个字符，则返回true，否则返回false。字母字符是在Unicode字符数据库中定义为“Letter”的那些字符，即具有一般类别属性为“Lm”，“Lt”，“Lu”，“Ll”或“Lo”之一的那些字符。请注意，这与Unicode标准中定义的“字母”属性不同。
s = 'abc中文ß'
print(s.isalpha())
#输出结果
True
str.isascii()
功能：如果字符串为空或者所有字母都是ASCII字符则返回True，否则返回False。ASCII字符的码点在U+0000-U+007F之间。
版本：python 3.7中的新方法
s = 'abc\u0058'
print(s.isascii())
s = '中文'
print(s.isascii())
# 输出结果
True
False
str.isdecimal()
功能：如果字符串中的所有字符都是十进制字符并且至少有一个字符，则返回true，否则返回false。十进制字符是来自一般类别“Nd”的字符。该类别包括数字字符和可用于形成十进制小数数字的所有字符，例如U + 0660，阿拉伯数字ZERO。
s = '123'
print(s.isdecimal())
s = '123.5'
print(s.isdecimal())
s = '\u0661'
print(s)
print(s.isdecimal())
#输出结果
True
False
١
True
str.isdigit()
功能：如果字符串中的所有字符都是数字，并且至少有一个字符，则返回真，否则返回假。数字包含需要特殊处理的十进制字符和数字，例如兼容性上标数字。形式上，数字是具有属性值Numeric_Type = Digit或Numeric_Type = Decimal的字符。
s = '123'
print(s.isdigit())
s = '\u0660'
print(s.isdigit())
#输出结果
True
True
str.isidentifier()
功能：根据语言定义Identifiers and keywords，如果字符串是有效标识符，则返回true。
使用keyword.iskeyword()来测试保留的标识符，例如def和class。
def str_identifier():
s = '123book'
s1 = 'b123 ook'
s2 = 'book123'
print(s.isidentifier())
print(s1.isidentifier())
print(s2.isidentifier())
# 输出结果
False
False
True
str.isnumeric()
功能：如果字符串中的所有字符都是数字字符，并且此字符串至少有一个字符（译者注：非空），则返回true，否则返回false。数字字符包括数字字符（0~9）和具有Unicode数字值属性的所有字符，例如U+2155，VULGAR FRACTION ONE FIFTH。形式上，数字字符是具有属性值Numeric_Type = Digit，Numeric_Type = Decimal或Numeric_Type = Numeric的字符。
def str_isnumeric():
s = '1235'
print(s.isnumeric())
s = '\u2155'
print(s)
print(s.isnumeric())
# 输出结果
True
⅕
True
str.isprintable()
功能：如果字符串中的所有字符都可打印或字符串为空，则返回true，否则返回false。非可打印字符是在Unicode字符数据库中定义为“Other”或“Separator”的字符，但ASCII空格（0x20）被认为是可打印的。（请注意，在此上下文中的可打印字符是在字符串上调用repr()时不应该转义的字符。它对写入sys.stdout或sys.stderr的字符串的处理没有任何影响。）
s = '\t'
print(s.isprintable())
s = 'abc123!~@#* '
print(s.isprintable())
# 输出结果
False
True
str.isspace()
功能：如果字符串中只有空格字符，并且至少有一个字符，则返回true，否则返回false。空格字符是在Unicode字符数据库中定义为“其他”或“分隔符”并且具有双向属性为“WS”、“B”或“S”之一的那些字符。
s = '\t\n\r '
print(s.isspace())
# 输出结果
True
str.istitle()
功能：字符串中的单词首字母大写，其它字母小写则返回true，否则返回false
s = 'hello leng'
print(s.istitle())
s = 'Hi Leng 123'
print(s.istitle())
# 输出结果
False
True
2.6 其他
str.count(sub[, start[, end]])
功能：返回范围[start，end]中子字符串sub的出现次数。可选参数start和end被解释为切片表示法。
s = 'wow, wow a cow'
print(s.count('wo'))
print(s.count(s[:2]))
print(s.count(s[:2],2))
print(s.count(s[:2],13,14))
print(s.count(''),len(s))
# 输出结果
2
2
1
0
15 14
注意最后一个，count(’’)，它查找的是相邻字符之间的间隙，所以是15。
str.encode(encoding=“utf-8”, errors=“strict”)
功能：以字节对象的形式返回字符串的编码版本。默认编码为’utf-8’。
可能会给出错误来设置不同的错误处理方案。错误的缺省值是’strict’，这意味着编码错误会引发一个UnicodeError。其他可能的值是’ignore’，‘replace’，‘xmlcharrefreplace’，'backslashreplace’以及其他任何可能的值通过codecs.register_error()注册的名称，请参见Error Handlers部分。有关可能的编码列表，请参见Standard Encodings部分。
在版本3.1中更改：添加了对关键字参数的支持。
def str_encoding():
s = '用于中文de encoding'
print(s.encode())
print(s.encode(encoding='ascii', errors='ignore'))
print(s.encode(encoding='ascii', errors='replace'))
print(s.encode(encoding='ascii', errors='xmlcharrefreplace'))
print(s.encode(encoding='ascii', errors='backslashreplace'))
print(s.encode(encoding='ascii',errors='strict')) # 报错 UnicodeEncodeError
# 输出结果
b'\xe7\x94\xa8\xe4\xba\x8e\xe4\xb8\xad\xe6\x96\x87de encoding'
b'de encoding'
b'????de encoding'
b'用于中文de encoding'
b'\\u7528\\u4e8e\\u4e2d\\u6587de encoding'
Traceback (most recent call last):
File "F:/zzzzz-wang/py-proj/learn/cu02-datatype-str.py", line 61, in str_encoding
print(s.encode(encoding='ascii',errors='strict'))
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-3: ordinal not in range(128)
str.format(*args, **kwargs)
功能：执行字符串格式化操作。调用此方法的字符串可以包含由大括号{}分隔的文本文本或替换字段。每个替换字段包含位置参数的数字索引或关键字参数的名称。返回字符串的副本，其中每个替换字段将替换为相应参数的字符串值。
name = 'lengfengyuyu'
age = 24
desc = 'My name is {0},age {1},have {1} articles\n\t\t\t--by {0}'
print(desc.format(name,age).expandtabs(16))
# 输出结果
My name is lengfengyuyu,age 24,have 24 articles
--by lengfengyuyu
有关可以在格式字符串中指定的各种格式选项的说明，请参阅Format String Syntax。
str.format_map(mapping)
功能：与str.format(**mapping)类似，除了直接使用字典参数mapping并且不拷贝到dict。如果例如mapping是字典子类，这很有用。
版本：Python 3.2中的新方法。
class Default(dict):
def __missing__(self, key):
return key+"(missing"+" attribute)"
print('{name} was born in {china}'.format_map(Default(name='lengfengyuyu')))
# 输出结果
lengfengyuyu was born in china(missing attribute)
str.join(iterable)
功能：返回一个字符串，它是iterable 可迭代中字符串的串联。如果iterable中包含bytes对象或者任何非字符串值，则会引发TypeError。元素之间的分隔符是提供此方法的字符串。
def str_join():
iter = 'abcdef'
print(",".join(iter))
iter = ['www','google','com']
print(".".join(iter))
iter.append(123)
print(".".join(iter)) #TypeError
#输出结果
a,b,c,d,e,f
www.google.com
Traceback (most recent call last):
File "xx/cu02-datatype-str.py", line 168, in str_join
print(".".join(iter))
TypeError: sequence item 3: expected str instance, int found
static str.maketrans(x[, y[, z]])
功能：这个静态方法返回一个可用于str.translate()的转换表。
如果只有一个参数，它必须是一个将Unicode序数（整数）或字符（长度为1的字符串）映射到Unicode序号，字符串（任意长度）或None的字典。字符键将被转换为序号。
如果有两个参数，它们必须是等长的字符串，并且在结果字典中，x中的每个字符将映射到y中相同位置的字符。如果有第三个参数，它必须是一个字符串，在结果中这些字符将被映射到“None”。
def str_trans():
print(str.maketrans("123","abc"))
# 输出结果
{49: 97, 50: 98, 51: 99}
str.translate(table)
功能：返回通过给定转换表映射每个字符的字符串的副本。
该表必须是通过__getitem__()方法实现了索引的对象，通常是mapping或sequence。当通过Unicode序数（整数）索引时，表对象可以执行以下任何操作：返回Unicode序号或字符串，将字符映射为一个或多个其他字符；返回None，从返回字符串中删除字符；将字符映射到自身会引发LookupError异常。
您可以使用str.maketrans()从不同格式的字符到字符映射创建转换映射。
另请参阅codecs模块，以获得更灵活的自定义字符映射方法。
def str_translate():
intab = 'abcde'
outtab = '12345'
deltab = "i"
str1 = 'i am a example string for test! wow...!!!'
transtab = str.maketrans(intab,outtab)
transtab1 = str.maketrans(intab,outtab,deltab)
print(transtab)
print(str1.translate(transtab))
print(str1.translate(transtab1))
# 输出结果
{97: 49, 98: 50, 99: 51, 100: 52, 101: 53}
i 1m 1 5x1mpl5 string for t5st! wow...!!!
1m 1 5x1mpl5 strng for t5st! wow...!!!
3.格式化
3.1 printf风格的字符串格式化
注意：
这里描述的格式化操作表现出各种各样的问题，导致许多常见错误（如未能正确显示元组和字典）。使用新的str.format()接口有助于避免这些错误，并且还提供了一种通用的功能更强大，灵活且可扩展的文本格式化方法。
3.1.1 定义
format % values（其中format是一个字符串），format中的%转换说明被values的零个或多个元素替换。其效果与在C语言中使用sprintf()类似。
如果格式需要单个参数，则值可能是单个非元组对象。需要多个参数，值应该是一个元组（元组内元素的个数要匹配）或mapping对象（如字典）。
3.2.2 组成
转换说明符包含两个或多个字符，并具有以下组件，它们必须按以下顺序出现：
- '%'字符表示说明符的开始。
- 映射键（可选），由括号括起来的字符序列（例如，
(somename)）组成。 - 转换标志（可选），影响某些转换类型的结果。
- 最小字段宽度（可选）。如果指定为’*’（星号），则实际宽度将从值中的元组的下一个元素中读取，并且要转换的对象位于最小字段宽度和可选精度。
- 精度（可选），作为’.‘给出（点），然后是精度。如果指定为’*’（星号），则从values中的元组的下一个元素读取实际精度，并且要转换的值在精度之后。
- 长度修饰符（可选）。
- 转换类型。
当右侧参数是一个字典（或其它映射类型）时，那么字符串中的formats必须包含一个圆括号括起来的映射到那个字典的键，并紧接在’%'字符之后。映射键从映射中选择要格式化的值。例如：
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.
在这种情况下format中不可以出现*指示符（因为它们需要一个序列参数的列表）。
| flag | 含义 |
|---|---|
| ‘#’ | 值转换将使用“替代形式”（如下定义） |
| ‘0’ | 对于数值，转换将用零填充 |
| ‘-’ | 转换的值被左调整（如果给出两者，则覆盖’0’转换标志） |
| ’ ’ | （空格）空白应留在由有符号转换产生的正数（或空字符串）之前 |
| ‘+’ | 将在转换说明之前加上符号字符（’+‘或’-’）（覆盖“空格”标志） |
长度修饰符（h，l或L）可能会出现，但会被忽略，因为它对Python不是必需的 - 例如，%ld与%d完全相同。
转换类型是：
| flag | 含义 | 注意点 |
|---|---|---|
| ‘d’ | 带符号的整数小数 | |
| ‘i’ | 带符号的整数小数。 | |
| ‘o’ | 带符号的八进制值。 | （1） |
| ‘u’ | 已过时的类型 - 与’d’完全相同。 | （6） |
| ‘x’ | 带符号的十六进制（小写）。 | （2） |
| ‘X’ | 带符号的十六进制（大写）。 | （2） |
| ‘e’ | 浮点指数格式（小写）。 | （3） |
| ‘E’ | 浮点指数格式（大写）。 | （3） |
| ‘f’ | 浮点十进制格式。 | （3） |
| ‘F’ | 浮点十进制格式。 | （3） |
| ‘g’ | 浮点格式。如果指数小于-4或小于精度，则使用小写指数格式，否则使用小数格式。 | （4） |
| ‘G’ | 浮点格式。如果指数小于-4或者不小于精度，则使用大写指数格式，否则使用小数格式。 | （4） |
| ‘c’ | 单个字符（接受整数或单个字符串）。 | |
| ‘r’ | 字符串（使用repr()转换任何Python对象）。 |
（5） |
| ‘s’ | String（使用str()转换任何Python对象）。 |
（5） |
| ‘a’ | 字符串（使用ascii()转换任何Python对象）。 |
（5） |
| ‘%’ | 没有参数被转换，导致结果中有一个%字符。 |
注意点：
-
替代形式为在第一个数字之前插入八进制符号
0o。 -
替代形式为在第一个数字之前插入十六进制符号
0x或0X。 -
替代形式为结果始终包含小数点，即使没有数字跟着它。
默认精度为6 -
替代形式为结果总是包含小数点，尾随零不会被删除。
默认精度为6 -
如果精度 N，则输出将被截断为N个字符。
-
参见 PEP 237。
由于Python字符串具有明确的长度，因此%s转换不会假定\0是字符串的结尾。
在版本3.1中进行了更改：在%f中绝对值超过1e50的数字不再被转换为%g。
3.2.3 例子
def str_printf():
print("House number is: |%d| " % (1))
print("House number is: |%5d| " % (1))
print("House number is: |% 5d| " % (1))
print("House number is: |%05d| " % (1))
print("House number is: |%-5d| " % (1))
print("House number is: |%+5d| " % (1))
print("House number is: |%+05d| " % (1))
print("House number is: |%-05d| " % (1)) # 覆盖0的作用
print('-'.center(30,'-'))
print("House number is: |%05s| " % ('x'))
print("House number is: |%-5s| " % ('x'))
print('-'.center(30, '-'))
print("%f kg" % (5))
print("%10f kg" % (5))
print("%010f kg" % (5))
print("%-010f kg" % (5))
print("oct(%o)=(%d) kg" % (33,33))
print("hex(%x)=(%d) kg" % (33,33))
print("milk has 25% pure milk")
print('-'.center(30, '-'))
a = 3.555555555555
b = 3.5555
c = 3e-7
d = 3e-2
print('%f' % a, '%f' % b, '%f' % c, '%f' % d)
print('%.8f' % a, '%.8f' % b, '%.8f' % c, '%.8f' % d) #指定精度8(>默认的6)
print('%g'%a,'%g'%b,'%g'%c,'%g'%d)
# 输出结果
House number is: |1|
House number is: | 1|
House number is: | 1|
House number is: |00001|
House number is: |1 |
House number is: | +1|
House number is: |+0001|
House number is: |1 |
------------------------------
House number is: | x|
House number is: |x |
------------------------------
5.000000 kg
5.000000 kg
005.000000 kg
5.000000 kg
oct(41)=(33) kg
hex(21)=(33) kg
milk has 25% pure milk
------------------------------
3.555556 3.555500 0.000000 0.030000
3.55555556 3.55550000 0.00000030 0.03000000
3.55556 3.5555 3e-07 0.03
3.2 str.format字符串格式化
本节与 模块 string关联甚密，请移步 Python 3.7.1 模块 string