字符串str

最新推荐文章于 2024-05-28 14:33:40 发布

hd51cc

最新推荐文章于 2024-05-28 14:33:40 发布

阅读量460

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/hd51cc/article/details/123981415

版权

Python 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

字符串

字符串是不可变的。

字符串字面值有多种不同的写法：

单引号: '允许包含有 "双" 引号'
Double quotes: "allows embedded 'single' quotes"
三重引号: '''三重单引号''', """三重双引号"""

方法

str.capitalize()

返回原字符串的副本，其首个字符大写，其余为小写。

myString = 'abcdefg'
print(myString.capitalize())

# result: Abcdefg

str.casefold()

返回原字符串消除大小写的副本。消除大小写的字符串可用于忽略大小写的匹配。

myString = 'aBcDeFg'
print(myString.casefold())

# result: abcdefg

str.center(width[, fillchar])

返回长度为 width 的字符串，原字符串在其正中。使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。如果 width 小于等于 len(s) 则返回原字符串的副本。

myString = 'aaaa'
print(myString.center(10, '*'))
# result: ***aaaa***

print(myString.center(3, '*'))
# result: aaaa

print(myString.center(20, '\U0001F408'))    # \u \U unicode编码
# result: 🐈🐈🐈🐈🐈🐈🐈🐈aaaa🐈🐈🐈🐈🐈🐈🐈🐈

str.count(sub[, start[, end]])

返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。可选参数 start 与 end 会被解读为切片表示法。

myString = '112233112233123123'
print(myString.count('1'))
# result: 6
print(myString.count('1', 6))
# result: 4
print(myString.count('1', 6, 13))
# result: 3

str.encode(encoding='utf-8', errors='strict')

返回原字符串编码为字节串对象的版本。默认编码为 'utf-8'。可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通过 codecs.register_error() 注册的值

myString = '编码解码'
print(myString)
# result: 编码解码
print(myString.encode('utf-8'))
# result: b'\xe7\xbc\x96\xe7\xa0\x81\xe8\xa7\xa3\xe7\xa0\x81'
print(myString.encode('gb2312'))
# result: b'\xb1\xe0\xc2\xeb\xbd\xe2\xc2\xeb'

str.endswith(suffix[, start[, end]])

如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。如果有可选项 start，将从所指定位置开始检查。如果有可选项 end，将在所指定位置停止比较。

myString = 'abcde123'
print(myString.endswith('123'))
# result: True
print(myString.endswith('123', 6))
# result: False
print(myString.endswith('123', 0, 6))
# result: False
print(myString.endswith('abc'))
# result: False

str.expandtabs(tabsize=8)

返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。

要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。（制表符本身不会被复制。）如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。

print('01\t012\t0123\t01234'.expandtabs())
# result: 01      012     0123    01234
print('01\t012\t0123\t01234'.expandtabs(4))
# result: 01  012 0123    01234

str.find(sub[, start[, end]])

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。可选参数 start 与 end 会被解读为切片表示法。如果 sub 未被找到则返回 -1。

myString = 'Python'
print(myString.find('y'))
# result: 1
print(myString.find('y', 3))
# result: -1
print(myString.find('n', 1,3))
# result: -1

注解

find() 方法应该只在你需要知道 sub 所在位置时使用。要检查 sub 是否为子字符串，请使用 in 操作符:

myString = 'Python'
str1 = 'False'
for s in myString:
    if s == 'y': str1 = 'True'
print(str1)
# result: True

str.format(*args, **kwargs)

执行字符串格式化操作。调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。

myString = 'Python'
print('The string is {}'.format(myString))
# result: The string is Python
print('The number is {:f}'.format(123))
# result: The string is 123.000000

str.format_map(mapping)

类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。

class Default(dict):
    def __missing__(self, key):
        return key


print('{name} was born in {country}'.format_map(Default(name='Guido')))
# result: Guido was born in country

str.index(sub[, start[, end]])

类似于 find()，但在找不到子字符串时会引发 ValueError。

myString = 'Python'
print('The index is {}'.format(myString.index('t', 0, 6)))
# result: The index is 2

str.isalnum()

如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False 。

字母字符是指那些在 Unicode 字符数据库中定义为 "Letter" 的字符，即那些具有 "Lm"、"Lt"、"Lu"、"Ll" 或 "Lo" 之一的通用类别属性的字符。注意，这与 Unicode 标准中定义的"字母"属性不同。

myString = 'Python'
print(myString.isalpha())
# result: True

str.isascii()

如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F 。

myString = 'Python'
print(myString.isascii())
# result: True

str.isdecimal()

如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ，否则返回 False 。

十进制字符指那些可以用来组成10进制数字的字符，例如 U+0660 ，即阿拉伯字母数字0 。严格地讲，十进制字符是 Unicode 通用类别 "Nd" 中的一个字符。

myString = 'Python'
print(myString.isdecimal())
# result: False
myNumber = '123'
print(myNumber.isdecimal())
# result: True

str.isdigit()

如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。

数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成 10 进制数的数字，如 Kharosthi 数。严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。

myString = 'Python'
print(myString.isdigit())
# result: False
myNumber = '123'
print(myNumber.isdigit())
# result: True

str.isidentifier()

如果字符串是有效的标识符，返回 True ，依据语言定义，标识符和关键字节。

import keyword
print('hello'.isidentifier(), keyword.iskeyword('hello'))
# result: True False
print('def'.isidentifier(), keyword.iskeyword('def'))
# result: True True

str.islower()

如果字符串中至少有一个区分大小写的字符，且此类字符均为小写则返回 True ，否则返回 False 。

myString1 = 'Python'
print(myString1.islower())
# result: False
myString2 = 'python'
print(myString2.islower())
# result: True

str.isnumeric()

如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。

数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

myString1 = 'Python123'
print(myString1.isnumeric())
# result: False
number = '123'
print(number.isnumeric())
# result: True

str.isprintable()

如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。

不可打印字符是在 Unicode 字符数据库中被定义为 "Other" 或 "Separator" 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。（请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。）

myString1 = 'Python123'
print(myString1.isprintable())
# result: True
myString2 = 'Python123\n'
print(myString2.isprintable())
# result: False

str.isspace()

如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。

空白字符是指在 Unicode 字符数据库 (参见 unicodedata) 中主要类别为 Zs ("Separator, space") 或所属双向类为 WS, B 或 S 的字符。

myString1 = '    '
print(myString1.isspace())
# result: True
myString2 = ' 1'
print(myString2.isspace())
# result: False

str.istitle()

如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。否则返回 False 。

myString1 = 'Python'
print(myString1.istitle())
# result: True
myString2 = 'python'
print(myString2.istitle())
# result: False

str.isupper()

如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False 。

myString1 = 'BANANA'
print(myString1.isupper())
# result: True
myString2 = 'BANANa'
print(myString2.isupper())
# result: False
myString3 = 'baNANa'
print(myString3.isupper())
# result: False

str.join(iterable)

返回一个由 iterable 中的字符串拼接而成的字符串。

如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。调用该方法的字符串将作为元素之间的分隔。

myString1 = 'BANANA'
myString2 = '*@#'
print(myString1.join(myString2))
# result: *BANANA@BANANA#

str.ljust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠左对齐。

使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。如果 width 小于等于 len(s) 则返回原字符串的副本。

myString1 = 'BANANA'
fillChar = '*'
print(myString1.ljust(10,fillChar))
# result: BANANA****

str.lower()

返回原字符串的副本，其所有区分大小写的字符均转换为小写。

myString1 = 'banana'
print(myString1.lower())
# result: banana
myString2 = 'BANANa'
print(myString2.lower())
# result: banana
myString3 = 'baNANa'
print(myString3.lower())
# result: banana

str.lstrip([chars])

返回原字符串的副本，移除其中的前导字符。

chars 参数为指定要移除字符的字符串。如果省略或为 None，则 chars 参数默认移除空白符。实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:

myString1 = 'www.python.org'
print(myString1.lstrip('w.'))
# result: python.org

static str.maketrans(x[, y[, z]])

此静态方法返回一个可供 str.translate() 使用的转换对照表。

如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。字符键将会被转换为码位序号。

如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。

myString1 = 'abcde'     # 源
myString2 = '12345'     # 目标
myString3 = str.maketrans(myString1, myString2)     # 转换表
myStr='apple and banana'    # 要翻译的字符串
print(myStr.translate(myString3))
# result: 1ppl5 1n4 21n1n1

str.partition(sep)

在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

myString1 = 'ab*cd*e'
print(myString1.partition('*'))
# result: ('ab', '*', 'cd*e')
print(type(myString1.partition('*')))
# result: <class 'tuple'>

str.removeprefix(prefix, /)

如果字符串以前缀字符串开头，返回 string[len(prefix):] 。否则，返回原始字符串的副本：

myString1 = '*ab*cd*e'
print(myString1.removeprefix('*'))
# result: ab*cd*e

str.removesuffix(suffix, /)

如果字符串以后缀字符串结尾，并且后缀非空，返回 string[:-len(suffix)] 。否则，返回原始字符串的副本：

myString1 = '*ab*cd*e*'
print(myString1.removesuffix('*'))
# result: *ab*cd*e

str.replace(old, new[, count])

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。如果给出了可选参数 count，则只替换前 count 次出现。

myString1 = 'abc1abc2abc3abc4'
print(myString1.replace('a', '*'))
# result: *bc1*bc2*bc3*bc4
print(myString1.replace('a', '*', 2))
# result: *bc1*bc2abc3abc4

str.rfind(sub[, start[, end]])

返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。可选参数 start 与 end 会被解读为切片表示法。如果未找到则返回 -1。

myString = 'Python'
print(myString.rfind('h'))
# result: 3
print(myString.rfind('h', 3))
# result: 3
print(myString.rfind('h', 1,3))
# result: -1

str.rindex(sub[, start[, end]])

类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。

myString = 'my Python'
print('The rindex is {}'.format(myString.rindex('y', 0, 9)))
# result: The rindex is 4

str.rjust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠右对齐。使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。如果 width 小于等于 len(s) 则返回原字符串的副本。

myString1 = 'BANANA'
fillChar = '*'
print(myString1.rjust(10, fillChar))
# result: ****BANANA

str.rpartition(sep)

在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。

myString1 = 'ab*cd*e'
print(myString1.partition('*'))
# result: ('ab', '*', 'cd*e')
print(type(myString1.partition('*')))
# result: <class 'tuple'>

str.rsplit(sep=None, maxsplit=- 1)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。

string1 = "This*is*a*test*string*from*Andrew"
print(string1.rsplit('*'))
# result: ['This', 'is', 'a', 'test', 'string', 'from', 'Andrew']
print(string1.rsplit('*', 3))
# result: ['This*is*a*test', 'string', 'from', 'Andrew']

str.rstrip([chars])

返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。如果省略或为 None，则 chars 参数默认移除空白符。实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:

myString1 = 'www.python.org'
print(myString1.rstrip('.org'))
# result: www.python

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'])。使用指定的分隔符拆分空字符串将返回 ['']。

string1 = "This*is*a*test*string*from*Andrew"
print(string1.split('*'))
# result: ['This', 'is', 'a', 'test', 'string', 'from', 'Andrew']
print(string1.split('*', 3))
# result: ['This', 'is', 'a', 'test*string*from*Andrew']

str.splitlines(keepends=False)

返回由原字符串中各行组成的列表，在行边界的位置拆分。结果列表中不包含行边界，除非给出了 keepends 且为真值。

此方法会以下列行边界进行拆分。特别地，行边界是 universal newlines 的一个超集。

表示符	描述
`\n`	换行
`\r`	回车
`\r\n`	回车 + 换行
`\v` 或 `\x0b`	行制表符
`\f` 或 `\x0c`	换表单
`\x1c`	文件分隔符
`\x1d`	组分隔符
`\x1e`	记录分隔符
`\x85`	下一行 (C1 控制码)
`\u2028`	行分隔符
`\u2029`	段分隔符

print('ab c\n\nde fg\rkl\r\n'.splitlines())
# result: ['ab c', '', 'de fg', 'kl']
print('ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True))
# result: ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

str.startswith(prefix[, start[, end]])

如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。如果有可选项 start，将从所指定位置开始检查。如果有可选项 end，将在所指定位置停止比较。

myString = 'abc123456'
print(myString.startswith('abc'))
# result: True
print(myString.startswith('abc', 3))
# result: False
print(myString.startswith('abc', 3, 9))
# result: False
print(myString.startswith('123'))
# result: False

str.strip([chars])

返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。如果省略或为 None，则 chars 参数默认移除空白符。实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:

myString1 = 'www.python.org'
print(myString1.strip('worg.'))
# result: python

str.swapcase()

返回原字符串的副本，其中大写字符转换为小写，反之亦然。请注意 s.swapcase().swapcase() == s 并不一定为真值。

myString1 = 'abcABCDEF'
print(myString1.swapcase())
# result: ABCabcdef

str.title()

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。该定义在多数情况下都很有效，但它也意味着代表缩写形式与所有格的撇号也会成为单词边界，这可能导致不希望的结果:

myString1 = 'apple and banana'
myString2 = 'appleandbanana'
print(myString1.title())
# result: Apple And Banana
print(myString2.title())
# result: Appleandbanana

str.translate(table)

返回原字符串的副本，其中每个字符按给定的转换表进行映射。转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。

见static str.maketrans(x[, y[, z]])

str.upper()

返回原字符串的副本，其中所有区分大小写的字符，均转换为大写。请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。

myString1 = 'BANANA'
print(myString1.upper())
# result: BANANA
myString2 = 'BANANa'
print(myString2.upper())
# result: BANANA
myString3 = 'baNANa'
print(myString3.upper())
# result: BANANA

str.zfill(width)

返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。正负值前缀 ('+'/'-') 的处理方式是在正负符号之后填充而非在之前。如果 width 小于等于 len(s) 则返回原字符串的副本。

myString1 = 'BANANA'
print(myString1.zfill(10))
# result: 0000BANANA

`printf` 风格的字符串格式化

format % values

(其中 format 为一个字符串)，在 format 中的 % 转换标记符将被替换为零个或多个 values 条目。

转换标记符包含两个或更多字符并具有以下组成，且必须遵循此处规定的顺序：

'%' 字符，用于标记转换符的起始。
映射键（可选），由加圆括号的字符序列组成 (例如 (somename))。
转换旗标（可选），用于影响某些转换类型的结果。
最小字段宽度（可选）。如果指定为 '*' (星号)，则实际宽度会从 values 元组的下一元素中读取，要转换的对象则为最小字段宽度和可选的精度之后的元素。
精度（可选），以在 '.' (点号) 之后加精度值的形式给出。如果指定为 '*' (星号)，则实际精度会从 values 元组的下一元素中读取，要转换的对象则为精度之后的元素。
长度修饰符（可选）。
转换类型。

当右边的参数为一个字典（或其他映射类型）时，字符串中的格式必须包含加圆括号的映射键，对应 '%' 字符之后字典中的每一项。映射键将从映射中选取要格式化的值。例如：

print('%(language)s has %(number)03d quote types.' % {'language': "Python", "number": 2})
# result: Python has 002 quote types.

在此情况下格式中不能出现 * 标记符（因其需要一个序列类的参数列表）。

转换旗标

旗标	含意
`'#'`	值的转换将使用“替代形式”（具体定义见下文）。
`'0'`	转换将为数字值填充零字符。
`'-'`	转换值将靠左对齐（如果同时给出 `'0'` 转换，则会覆盖后者）。
`' '`	(空格) 符号位转换产生的正数（或空字符串）前将留出一个空格。
`'+'`	符号字符 (`'+'` 或 `'-'`) 将显示于转换结果的开头（会覆盖 "空格" 旗标）。

可以给出长度修饰符 (h, l 或 L)，但会被忽略，因为对 Python 来说没有必要 -- 所以 %ld 等价于 %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'`	字符串（使用 str() 转换任何 Python 对象）。	(5)
`'a'`	字符串（使用 ascii() 转换任何 Python 对象）。	(5)
`'%'`	不转换参数，在结果中输出一个 `'%'` 字符。

注释：

此替代形式会在第一个数码之前插入标示八进制数的前缀 ('0o')。
此替代形式会在第一个数码之前插入 '0x' 或 '0X' 前缀（取决于是使用 'x' 还是 'X' 格式）。
此替代形式总是会在结果中包含一个小数点，即使其后并没有数码。

小数点后的数码位数由精度决定，默认为 6。
此替代形式总是会在结果中包含一个小数点，末尾各位的零不会如其他情况下那样被移除。

小数点前后的有效数码位数由精度决定，默认为 6。
如果精度为 N，输出将截短为 N 个字符。
参见 PEP 237。

由于 Python 字符串显式指明长度，%s 转换不会将 '\0' 视为字符串的结束。

在 3.1 版更改: 绝对值超过 1e50 的 %f 转换不会再被替换为 %g 转换。

格式说明符

转换符	含意	备注
`'b'`	将整数表示为二进制数
`'c'`	将整数解读为Unicode码点
`'d'`	将整数视为十进制数进行处理，这是整数默认使用的说明符
`'e'`	使用科学表示法来表示小数（用e来表示指数）
`'E'`	与e相同，但使用E来表示指数
`'f'`	将小数表示为定点数
`'F'`	与f相同，但对于特殊值（nan和inf），使用大写表示
`'g'`	自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数
`'G'`	与g相同，但使用大写来表示指数和特殊值
`'n'`	与g相同，但插入随区域而异的数字分隔符
`'o'`	将整数表示为八进制数
`'s'`	保持字符串的格式不变，这是默认用于字符串的说明符
`'x'`	将整数表示为十六进制数并使用小写字母
`'X'`	将整数表示为十六进制数并使用小写字母
`'%'`	将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）

{}：替换字段

print("{}, {} and {}".format("first", "second", "third"))
# result: first, second and third

{0}、{1}、{2}：带索引的替换字段

print("{1}, {3}, {5}, {4}, {2}, {0}".format("a", "b", "c", "d", "e", "f"))
# result: b, d, f, e, c, a

{name}、{value}:带标志的替换字段

import  math
print("{name} is approximately {value:.6f}".format(value=math.pi, name="π"))
# result: π is approximately 3.141593

如果变量与替换字段同名，还可使用一种简写。在这种情况下，可使用f字符串——在字符串前面加上f。

name = 'Python'
print(f"{name} is so easy.")
# result: Python is so easy.

：格式说明符

print('the number is {num:b}'.format(num=15))
# result: the number is 1111

！转换符

print("{pi!s}".format(pi="π"))
# result: π
print("{pi!r}".format(pi="π"))
# result: 'π'
print("{pi!a}".format(pi="π"))
# result: '\u03c0'

宽度

print("{num:10}.".format(num=1))
# result:          1.
print("{name:10}.".format(name="Python"))
# result: Python    .

宽度+精度

import  math
print("{name} is approximately {value:10.4f}".format(value=math.pi, name="π"))
# result: π is approximately     3.1416

字符串的精度

print("{name:.5}".format(name='abcdefghijk'))
# result: abcde

千位分隔符

print("{number:,}".format(number=10**20))
# result: 100,000,000,000,000,000,000

在快递和精度前面，可以添加转换旗标

填充

import  math
print("{name} is approximately {value:010.4f}".format(value=math.pi, name="π"))
# result: π is approximately 00003.1416

左对齐<、右对齐>与剧中^及填充

import  math
print("{name} is approximately {value:<10.4f}.".format(value=math.pi, name="π"))
# result: π is approximately 3.1416    .
print("{name} is approximately {value:>10.4f}.".format(value=math.pi, name="π"))
# result: π is approximately     3.1416.
print("{name} is approximately {value:^10.4f}.".format(value=math.pi, name="π"))
# result: π is approximately   3.1416  .
print("{name} is approximately {value:$<10.4f}.".format(value=math.pi, name="π"))
# result: π is approximately 3.1416$$$$.
print("{name} is approximately {value:$>10.4f}.".format(value=math.pi, name="π"))
# result: π is approximately $$$$3.1416.
print("{name} is approximately {value:$^10.4f}.".format(value=math.pi, name="π"))
# result: π is approximately $$3.1416$$.

=说明符

import  math
print("{value:10.2f}.".format(value=math.pi))
# result:       3.14.
print("{value:10.2f}.".format(value=-math.pi))
# result:      -3.14.
print("{value:=10.2f}.".format(value=math.pi))
# result:       3.14.
print("{value:=10.2f}.".format(value=-math.pi))
# result: -     3.14.

+说明符

将符号说明符指定为空格，会在正数前面加上空格而不是+。

import  math
print("{value:10.2f}.".format(value=math.pi))
# result:       3.14.
print("{value:+10.2f}.".format(value=math.pi))
# result:      +3.14.
print("{value:=+10.2f}.".format(value=math.pi))
# result: +     3.14.

#，放在符号说明符和宽度之间，会触发转换方式，随类型而已

print("{:b}".format(15))
# result: 1111
print("{:#b}".format(15))
# result: 0b1111
print("{:#o}".format(15))
# result: 0o17
print("{:#g}".format(15))
# result: 15.0000
print("{:#f}".format(15))
# result: 15.000000

hd51cc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
字符串str

字符串字符串是不可变的。字符串字面值有多种不同的写法：单引号:'允许包含有"双"引号' Double quotes:"allowsembedded'single'quotes" 三重引号:'''三重单引号''',"""三重双引号""" 方法str.capitalize()返回原字符串的副本，其首个字符大写，其余为小写。myString = 'abcdefg'print(myString.capitalize())# result...
复制链接

扫一扫