Python基础教程第3版:第3章 使用字符串

字符串是不可变的:字符串是不可变的,因此所有的元素赋值和切片赋值都是非法的。

设置字符串的格式:精简版

Python提供了多种字符串格式设置方法。推荐字符串方法format

1. %百分号

类似于C语言中的经典函数 printf :

  • % 左边指定一个字符串(格式字符串),并在右边指定要设置其格式的值。
  • 指定要设置其格式的值时,可使用
  • 单个值(如字符串或数字),
  • 可使用元组(如果要设置多个值的格式),最常见的是元组。
  • 还可使用字典(这将在下一章讨论)
  • %s称为转换说明符,指出了要将值插入什么地方。 s 意味着将值视为字符串进行格式设置。如果指定的值不是字符串,将使用 str 将其转换为字符串。
  • %.3f 将值的格式设置为包含3位小数的浮点数。
>>> format = "Hello %s,your height is %.f meters"
>>> value = ('Jack',1.832423)
>>> print(format % value)
Hello Jack,your height is 2 meters
>>> format = "Hello %s,your height is %.2f meters"
>>> print(format % value)
Hello Jack,your height is 1.83 meters

2.$ 模板字符串

使用类似于UNIX shell的语法,旨在简化基本的格式设置机制。

  • 包含等号的参数称为关键字参数,第6章将详细介绍这个术语。
  • 在字符串格式设置中,可将关键字参数视为一种向命名替换字段提供值的方式。
from string import Template

tmpl = Template("Hello $name,your height is $height")
s = tmpl.substitute(name='Jack',height=round(1.832523,3))
print(s) # Hello Jack,your height is 1.833

3.{} 字符串方法format

字符串方法format融合并强化了早期方法的优点:

  • 使用这种方法时,每个替换字段都用花括号括起,
  • 其中可能包含名称,还可能包含有关如何对相应的值进行转换和格式设置的信息。
  • 如果变量与替换字段同名,还可使用一种简写。在这种情况下,可 使用 f 字符串——在字符串前面加上 f 。
# 替换字段没有名称
s = "{}, {} and {}".format("first", "second", "third") 
print(s) # first, second and third

# 将索引用作替换字段的名称
s = "{0}, {1} and {2}".format("first", "second", "third")
print(s) # first, second and third
s = "{2}, {1} and {0}".format("first", "second", "third")
print(s) # third, second and first

# 命名字段,与 $ 类似
from math import pi,e
s = "{name} is approximately {value:.2f}.".format(value=pi, name="π")
print(s) # π is approximately 3.14.
s = f"π is approximately {pi:.2f}."
print(s) # π is approximately 3.14.

s = f"Euler's constant is roughly {e}."
print(s) # Euler's constant is roughly 2.718281828459045.

# 与下面的语句等价 ,创建最终的字符串时,将把替换字段 e 替换为变量 e 的值
s = "Euler's constant is roughly {e}.".format(e=e)
print(s) # Euler's constant is roughly 2.718281828459045.

# 要在最终结果中包含花括号,
# 可在格式字符串中使用两个花括号(即 {{ 或 }} )来指定。
# 即:{{ ={, }}=}
s = "Euler's constant is roughly {{{e}}}.".format(e=e)
print(s) # Euler's constant is roughly {2.718281828459045}.

设置字符串的格式:完整版(使用format方法)

在格式字符串中,最激动人心的部分为替换字段。替换字段由如下部分组成,其中每个部分都是可选的。

  • 字段名:索引或标识符
  • 转换标志:跟在叹号后面的单个字符。
  • 格式说明符:跟在冒号后面的表达式

1.替换字段名

  • 未命名参数在前,命名参数在后
  • 在最简单的情况下,只需向 format 提供要设置其格式的未命名参数,并在格式字符串中使用未命名字段。此时,将按顺序将字段和参数配对。
  • 你还可给参数指定名称,这种参数将被用于相应的替换字段中。
  • 你可混合使用这两种方法。命名参数必须放在后面
  • 还可通过索引来指定要在哪个字段中使用相应的未命名参数,这样可不按顺序使用未命名参数。
  • 并非只能使用提供的值本身,而是可访问其组成部分(就像在常规Python代码中一样)
# 未命名字段将按顺序取值,放在format方法的前面
s = "{named1} {} {named2} {}".format("未命名字段1","未命名字段2",
                                     named2='命名字段2',named1='命名字段1')
print(s) # 命名字段1 未命名字段1 命名字段2 未命名字段2

# 使用索引引用未命名字段
s = "{named1} {1} {named2} {0}".format("未命名字段1","未命名字段2",
                                     named2='命名字段2',named1='命名字段1')
print(s) # 命名字段1 未命名字段2 命名字段2 未命名字段1

# 使用列表中的元素
names = ["Tom","Jerry","Alfred"]
s = "Your name is {names[2]}".format(names=names)
print(s) # Your name is Alfred

2.基本转换

指定要在字段中包含的值后,就可添加有关如何设置其格式的指令了

  • 可以提供一个转换标志。标志( s 、 r 和 a )指定分别使用 str 、 repr 和 ascii 进行转换。
  • 函数 str 通常创建外观普通的字符串版本(这里没有对输入字符串做任何处理)。
  • 函数 repr 尝试创建给定值的Python表示(这里是一个字符串字面量)。
  • 函数 ascii 创建只包含ASCII字符的表示,类似于Python 2中的repr 。
  • 可指定要转换的值是哪种类型,更准确地说,是要将其视为哪种类型。 为此可在格式说明(即冒号后面)使用字符 f (表示定点数)。 可指定的类型见下表
类型 含义
b 将整数表示为二进制数
c 将整数解读为Unicode码点
d 将整数视为十进制数进行处理,这是整数默认使用的说明符
e 使用科学表示法来表示小数(用 e 来表示指数)
E 与 e 相同,但使用 E 来表示指数
f 将小数表示为定点数
F 与 f 相同,但对于特殊值( nan 和 inf ),使用大写表示
g 自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符,但在默认情况下至少有1位小数
G 与 g 相同,但使用大写来表示指数和特殊值
n 与 g 相同,但插入随区域而异的数字分隔符
o 将整数表示为八进制数
s 保持字符串的格式不变,这是默认用于字符串的说明符
x 将整数表示为十六进制数并使用小写字母
X 与 x 相同,但使用大写字母
% 将数表示为百分比值(乘以100,按说明符 f 设置格式,再在后面加上%)
print("{pi!s} {pi!r} {pi!a}".format(pi="π")) # π 'π' '\u03c0'

print('数字:{num}'.format(num=42)) # 数字:42
# 设置浮点数(或其他更具体的小数类型)的格式时,默认在小数点后面显示6位小数,
# 并根据需要设置字段的宽度,而不进行任何形式的填充。
print('数字:{num:f}'.format(num=42)) # 数字:42.000000
print('数字:{num:.3f}'.format(num=42)) # 数字:42.000
print('数字:{num:b}'.format(num=42))  # 数字:101010

3.宽度、精度和千位分隔符

设置浮点数(或其他更具体的小数类型)的格式时,默认在小数点后面显示6位小数,并根据需要设置字段的宽度,而不进行任何形式的填充。

  • 使用整数指定宽度:默认数字右对齐,字符左对齐
  • 使用整数指定精度,但需要在它前面加上一个表示小数点的句点
  • 可使用逗号来指出你要添加千位分隔符.同时指定其他格式设置元素时,这个逗号应放在宽度和表示精度的句点之间
import math

# 使用整数指定宽度:默认数字右对齐,字符左对齐
print('{num:10}'.format(num=42))
print('{name:10}'.format(name='Jack'))
print('{name:10}'.format(name='Jack'))
print("{pi:10.5f}".format(pi=math.pi)) # 宽度为10,精度为5
# 同时指定其他格式设置元素时,这个逗号应放在宽度和表示精度的句点之间
print("10^10 PI:{pi:20,.10f}".format(pi=math.pi**10)) # 千分位
'''
        42
Jack    
   3.14159  
10^10 PI:   93,648.0474760830
'''

4.符号、对齐和用 0 填充

有很多用于设置数字格式的机制,比如便于打印整齐的表格。在大多数情况下,只需指定宽度和精度,但包含负数后,原本漂亮的输出可能不再漂亮。

字符串和数的默认对齐方式不同。在一栏中同时包含字符串和数时,你可能想修改默认对齐方式。

在指定宽度和精度的数前面,可添加一个标志。这个标志可以是零、加号、减号或空格:

  • 零表示使用0来填充数字。
  • 可以使用填充字符来扩充对齐说明符,这样将使用指定的字符而不是默认的空格来填充。
  • 要指定左对齐、右对齐和居中,可分别使用 <>^
  • 说明符 =,它指定将填充字符放在符号和数字之间。
  • 如果要给正数加上符号,可使用说明符 + (将其放在对齐说明符后面),而不是默认的 - 。如果将符号说明符指定为空格,会在正数前面加上空格而不是 +
  • 井号( # )选项,你可将其放在符号说明符和宽度之间(如果指定了这两种设置)。这个选项将触发另一种转换方式,转换细节随类型而异。例如,对于二进制、 八进制和十六进制转换,将加上一个前缀。
import math

# 零表示使用0来填充数字
print("{pi:010.4f}".format(pi=math.pi)) # 00003.1416
# 要指定左对齐、右对齐和居中,可分别使用 < 、 > 和 ^
print("{pi:<10.4f}".format(pi=math.pi))
print("{pi:>10.4f}".format(pi=math.pi))
print("{pi:^10.4f}".format(pi=math.pi))
'''
3.1416    
    3.1416
  3.1416  
'''
# 可以使用填充字符来扩充对齐说明符,这样将使用指定的字符而不是默认的空格来填充。
print("{pi:<<10.4f}".format(pi=math.pi))
print("{pi:>>10.4f}".format(pi=math.pi))
print("{pi:*^10.4f}".format(pi=math.pi))
'''
3.1416<<<<
>>>>3.1416
**3.1416**
'''
# 说明符 = ,它指定将填充字符放在符号和数字之间。
print('{0:10.2f}\n{1:10.2f}'.format(math.pi, -math.pi))
print('{0:10.2f}\n{1:=10.2f}'.format(math.pi, -math.pi))
print('{0:10.2f}\n{1:*=10.2f}'.format(math.pi, -math.pi))
'''
      3.14
     -3.14
      3.14
-     3.14
-*****3.14
'''

# 如果要给正数加上符号,可使用说明符 + (将其放在对齐说明符后面),而不是默认的 - 。
# 如果将符号说明符指定为空格,会在正数前面加上空格而不是 + 。
print('{0:+.2f}\n{1:+.2f}'.format(math.pi, -math.pi))
print('{0: .2f}\n{1: .2f}'.format(math.pi, -math.pi))
'''
+3.14
-3.14
 3.14
-3.14
'''
# 宽度在 + 之后
print('{0:+10.2f}\n{1:+10.2f}'.format(math.pi, -math.pi))
'''
     +3.14
     -3.14
'''

# 井号( # )选项,你可将其放在符号说明符和宽度之间(如果指定了这两种设置)。
# 这个选项将触发另一种转换方式,转换细节随类型而异。例如,对于二进制、
# 八进制和十六进制转换,将加上一个前缀。
print('{num:#b}'.format(num=42)) # 0b101010

示例:根据指定的宽度打印格式良好的价格列表

# 根据指定的宽度打印格式良好的价格列表

width = 40
price_width = 10
item_width = width - price_width

header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width)
# '{:30}{:>10}'

fmt= '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width)
# '{:30}{:>10.2f}'

print('=' * width)
print(header_fmt.format('Item', 'Price'))
print('-' * width)
print(fmt.format('Apples', 0.4))
print(fmt.format('Pears', 0.5))
print(fmt.format('Cantaloupes', 1.92))
print(fmt.format('Dried Apricots (16 oz.)', 8))
print(fmt.format('Prunes (4 lbs.)', 12))
print('=' * width)
'''
========================================
Item                               Price
----------------------------------------
Apples                              0.40
Pears                               0.50
Cantaloupes                         1.92
Dried Apricots (16 oz.)             8.00
Prunes (4 lbs.)                    12.00
========================================
'''

字符串方法

字符串的方法太多了,这里只介绍一些最有用的。

1.模块 string

虽然字符串方法完全盖住了模块 string 的风头,但这个模块包含一些字符串没有的常量和函数。下面就是模块 string 中几个很有用的常量 :

  • string.digits :包含数字0~9的字符串。
  • string.ascii_letters :包含所有ASCII字母(大写和小写)的字符串。
  • string.ascii_lowercase :包含所有小写ASCII字母的字符串。
  • string.printable :包含所有可打印的ASCII字符的字符串。
  • string.punctuation :包含所有ASCII标点字符的字符串。
  • string.ascii_uppercase :包含所有大写ASCII字母的字符串。虽然说的是ASCII字符,但值实际上是未解码的Unicode字符串。
import string 

print(string.digits)
print(string.ascii_letters)
print(string.ascii_lowercase)
print(string.ascii_uppercase)
print(string.printable)
print(string.punctuation)
'''
0123456789
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~  


!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
'''

2.部分常用字符串方法

  • center:方法 center 通过在两边添加填充字符(默认为空格)让字符串居中。类似的:ljust 、 rjust 和 zfill
  • find:方法 find 在字符串中查找子串。如果找到,就返回子串的第一个字符的索引,否则返回 -1。参考类似方法:rfind 、 index 、 rindex 、 count 、 startswith 、 endswith 。
  • join:join 是一个非常重要的字符串方法,其作用与 split 相反,用于合并序列的元素。所合并序列的元素必须都是字符串。相关: split
  • lower:方法 lower 返回字符串的小写版本。相关: islower 、 istitle 、 isupper 、 translate、capitalize 、 casefold 、 swapcase 、 title 、 upper 。
  • 词首大写问题:要实现真正的词首大写你得自己编写代码. 一个与 lower 相关的方法是 title 。它将字符串转换为词首大写,即所有单词的首字母都大写,其他字母都小写。然而,它确定单词边界的方式可能导致结果不合理。模块 string 中的函数 capwords也不能解决词首大写问题。
  • replace:方法 replace 将指定子串都替换为另一个字符串,并返回替换后的结果。另请参见: translate , expandtabs 。
  • split:split 是一个非常重要的字符串方法,其作用与 join 相反,用于将字符串拆分为序列。另请参见: join , partition 、 rpartition 、 rsplit 、 splitlines 。如果没有指定分隔符,将默认在单个或多个连续的空白字符(空格、制表符、换行符等)处进行拆分。
  • strip:方法 strip 将字符串开头和末尾的空白(但不包括中间的空白)删除,并返回删除后的结果。你还可在一个字符串参数中指定要删除哪些字符,这个方法只删除开头或末尾的指定字符,因此中间的星号未被删除。
  • 判断字符串是否满足特定的条件:很多字符串方法都以 is 打头,如 isspace 、 isdigit 和 isupper ,它们判断字符串是否具有特定的性质(如包含的字符全为空白、数字或大写)。如果字符串具备特定的性质,这些方法就返回True ,否则返回 False 。

translate:方法 translate 与 replace 一样替换字符串的特定部分,但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符,因此效率比 replace 高。

使用 translate 前必须创建一个转换表。这个转换表指出了不同Unicode码点之间的转换关系。要创建转换表,可对字符串类型 str 调用方法 maketrans ,这个方法接受两个参数:两个长度相同的字符串,它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符 。也可传入字典,将一些字符映射到其他字符(如果要删除这些字符,则映射到 None ).

translate方法示例: 假设你要将一段英语文本转换为带有德国口音的版本,为此必须将 字符c和s分别替换为k和z。

  • c ===> s
  • k ===> z
# c--->k
# s--->z
table = str.maketrans('cs', 'kz') # table 类型其实就是个 dict
print(table)
# {99: 107, 115: 122}
# 创建转换表后,就可将其用作方法 translate 的参数。
print('this is an incredible test'.translate(table))
# thiz iz an inkredible tezt
# 调用方法 maketrans 时,还可提供可选的第三个参数,指定要将哪些字母删除。# 例如,要模仿语速极快的德国口音,可将所有的空格都删除。
table = str.maketrans('cs', 'kz',' ')
print('this is an incredible test'.translate(table))
# thizizaninkredibletezt

其他字符串方法示例:

# center:方法 center 通过在两边添加填充字符(默认为空格)让字符串居中。

print('hello,world')
print('hello,world'.center(40))
print('hello,world'.center(40,'#'))
'''
hello,world
              hello,world               
##############hello,world###############
'''

# ljust 、 rjust 和 zfill
print('hello,world'.ljust(40,'#'))
print('hello,world'.rjust(40,'#'))
print('hello,world'.zfill(40))
'''
hello,world#############################
#############################hello,world
00000000000000000000000000000hello,world
'''

# 方法 find 在字符串中查找子串。如果找到,就返回子串的第一个字符的索引,否则返回 -1

print('hello,world'.find('wor')) # 6
print('hello,world'.find('win')) # -1

# 指定起点或终点
# 起点和终点值(第二个和第三个参数)指定的搜索范围包含起点,但不包含终点。
subject = '$$$ Get rich now!!! $$$'
print(subject.find('!!!', 0, 16)) # -1

# join 所合并序列的元素必须都是字符串
numList = [str(i) for i in range(10)]
print(numList) # ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
print('+'.join(numList)) # 0+1+2+3+4+5+6+7+8+9

# 词首大写问题:要实现真正的词首大写你得自己编写代码.
print('Trondheim Hammer Dance'.lower()) 
# trondheim hammer dance

print("that's all folks".title()) 
# That'S All Folks

import string
print(string.capwords("that's all, folks"))
# That's All, Folks

print('This is a test'.replace('is', 'eez'))
# Theez eez a test

print('*** SPAM * for * everyone!!! ***'.strip(' *!'))
# SPAM * for * everyone
# 这个方法只删除开头或末尾的指定字符,因此中间的星号未被删除。

3.完整的字符串方法清单

SN. 方法 描述
1 string.capitalize() 返回字符串的副本,但将第一个字符大写
2 string.casefold() 返回经过标准化(normalize)后的字符串,标准化类似于转换为小写,但更适合用于对Unicode字符串进行不区分大小写的比较
3 string.center(width[, fillchar]) 返回一个长度为 (len(string), width) 的字符串。这个字符串的中间包含当前字符串,但两端用 fillchar 指定的字符(默认为空格)填充
4 string.count(sub[, start[, end]]) 计算子串 sub 出现的次数,可搜索范围限定为 string[start:end]
5 string.encode([encoding[,errors]]) 返回使用指定编码和 errors 指定的错误处理方式对字符串进行编码的结果,参数 errors 的可能取值包含 'strict' 、 'ignore' 、 'replace' 等
6 string.endswith(suffix[,start[,end]]) 检查字符串是否以 suffix 结尾,还可使用索引 start 和 end 来指定匹配范围
7 string.expandtabs([tabsize]) 返回将字符串中的制表符展开为空格后的结果,可指定可选参数 tabsize(默认为8)
8 string.find(sub[, start[, end]]) 返回找到的第一个子串 sub 的索引,如果没有找到这样的子串,就返回 -1 ;还可将搜索范围限制为 string[start:end]
9 string.format(...) 实现了标准的Python字符串格式设置。将字符串中用大括号分隔的字段替换为相应的参数,再返回结果
10 string.format_map(mapping) 类似于使用关键字参数调用 format ,只是参数是以映射的方式提供的
11 string.index(sub[, start[, end]]) 返回找到的第一个子串 sub 的索引,如果没有找到这样的子串,将引发ValueError 异常;还可将搜索范围限制为 string[start:end]
12 string.isalnum() 检查字符串中的字符是否都是字母或数
13 string.isalpha() 检查字符串中的字符是否都是字母
14 string.isdecimal() 检查字符串中的字符是否都是十进制数
15 string.isdigit() 检查字符串中的字符是否都是数字
16 string.isidentifier() 检查字符串是否可用作Python标识符
17 string.islower() 检查字符串中的所有字母都是小写的
18 string.isnumeric() 检查字符串中的所有字符是否都是数字字符
19 string.isprintable() 检查字符串中的字符是否都是可打印的
20 string.isspace() 检查字符串中的字符是否都是空白字符
21 string.istitle() 检查字符串中位于非字母后面的字母都是大写的,且其他所有字母都是小写的
22 string.isupper() 检查字符串中的字母是否都是大写的
23 string.join(sequence) 将 string 与 sequence 中的所有字符串元素合并,并返回结果
24 string.ljust(width[, fillchar]) 返回一个长度为 max(len(string), width) 的字符串,其开头是当前字符串的副本,而末尾是使用 fillchar 指定的字符(默认为空格)填充的
25 string.lower() 将字符串中所有的字母都转换为小写,并返回结果
26 string.lstrip([chars]) 将字符串开头所有的 chars (默认为所有的空白字符,如空格、制表符和换行符)都删除,并返回结果
27 str.maketrans(x[,y[,z]]) 一个静态方法,它创建一个供 translate 使用的转换表。如果只指定了参数 x ,它必须是从字符或序数到Unicode序数或 None (用于删除)的映射;也可使用两个表示源字符和目标字符的字符串调用它;还可提供第三个参数,它指定要删除的字符
28 string.partition(sep) 在字符串中搜索 sep ,并返回元组 (sep 前面的部分 , sep, sep 后面的部分 )
29 string.replace(old,new[,max]) 将字符串中的子串 old 替换为 new ,并返回结果;还可将最大替换次数限制为 max
30 string.rfind(sub[,start[,end]]) 返回找到的最后一个子串的索引,如果没有找到这样的子串,就返回 -1 ;还可将搜索范围限定为 string[start:end]
31 string.rindex(sub[,start[,end]]) 返回找到的最后一个子串 sub 的索引,如果没有找到这样的子串,就引发ValueError 异常;还可将搜索范围限定为 string[start:end]
32 string.rjust(width[,fillchar]) 返回一个长度为 max(len(string), width) 的字符串,其末尾为当前字符串的拷贝,而开头是使用 fillchar 指定的字符(默认为空格)填充的
33 string.rpartition(sep) 与 partition 相同,但从右往左搜索
34 string.rstrip([chars]) 将字符串末尾所有的 chars 字符(默认为所有的空白字符,如空格、制表符和换行符)都删除,并返回结果
35 string.rsplit([sep[, maxsplit]]) 与 split 相同,但指定了参数 maxsplit ,从右往左计算划分次数
36 string.split([sep[, maxsplit]]) 返回一个列表,其中包含以 sep 为分隔符对字符串进行划分得到的结果(如果没有指定参数 sep ,将以所有空白字符为分隔符进行划分);还可将最大划分次数限制为 maxsplit
37 string.splitlines([keepends]) 返回一个列表,其中包含字符串中的所有行;如果参数 keepends 为 True ,将包含换行符
38 string.startswith(prefix[,start[,end]]) 检查字符串是否以 prefix 打头;还可将匹配范围限制在索引 start 和 end之间
39 string.strip([chars]) 将字符串开头和结尾的所有 chars 字符(默认为所有空白字符,如空格、制表符和换行符)都删除,并返回结果
40 string.swapcase() 将字符串中所有字母的大小写都反转,并返回结果
41 string.title() 将字符串中所有单词的首字母都大写,并返回结果
42 string.translate(table) 根据转换表 table (这是使用 maketrans 创建的)对字符串中的所有字符都进行转换,并返回结果
43 string.upper() 将字符串中所有的字母都转换为大写,并返回结果
44 string.zfill(width) 在字符串左边填充0 (但将原来打头的 + 或 - 移到开头),使其长度为 width

按方法相关性分组:

SN. 方法 描述
1 string.center(width[, fillchar]) 返回一个长度为 (len(string), width) 的字符串。这个字符串的中间包含当前字符串,但两端用 fillchar 指定的字符(默认为空格)填充
2 string.ljust(width[, fillchar]) 返回一个长度为 max(len(string), width) 的字符串,其开头是当前字符串的副本,而末尾是使用 fillchar 指定的字符(默认为空格)填充的
3 string.rjust(width[,fillchar]) 返回一个长度为 max(len(string), width) 的字符串,其末尾为当前字符串的拷贝,而开头是使用 fillchar 指定的字符(默认为空格)填充的
4 string.zfill(width) 在字符串左边填充0 (但将原来打头的 + 或 - 移到开头),使其长度为 width
---- ---- --------
5 string.find(sub[, start[, end]]) 返回找到的第一个子串 sub 的索引,如果没有找到这样的子串,就返回 -1 ;还可将搜索范围限制为 string[start:end]
6 string.rfind(sub[,start[,end]]) 返回找到的最后一个子串的索引,如果没有找到这样的子串,就返回 -1 ;还可将搜索范围限定为 string[start:end]
7 string.index(sub[, start[, end]]) 返回找到的第一个子串 sub 的索引,如果没有找到这样的子串,将引发ValueError 异常;还可将搜索范围限制为 string[start:end]
8 string.count(sub[, start[, end]]) 计算子串 sub 出现的次数,可搜索范围限定为 string[start:end]
9 string.startswith(prefix[,start[,end]]) 检查字符串是否以 prefix 打头;还可将匹配范围限制在索引 start 和 end之间
10 string.endswith(suffix[,start[,end]]) 检查字符串是否以 suffix 结尾,还可使用索引 start 和 end 来指定匹配范围
---- ---- --------
11 string.join(sequence) 将 string 与 sequence 中的所有字符串元素合并,并返回结果
12 string.split([sep[, maxsplit]]) 返回一个列表,其中包含以 sep 为分隔符对字符串进行划分得到的结果(如果没有指定参数 sep ,将以所有空白字符为分隔符进行划分);还可将最大划分次数限制为 maxsplit
---- ---- --------
13 string.lower() 将字符串中所有的字母都转换为小写,并返回结果
14 string.islower() 检查字符串中的所有字母都是小写的
15 string.istitle() 检查字符串中位于非字母后面的字母都是大写的,且其他所有字母都是小写的
16 string.isupper() 检查字符串中的字母是否都是大写的
17 string.translate(table) 根据转换表 table (这是使用 maketrans 创建的)对字符串中的所有字符都进行转换,并返回结果
18 string.capitalize() 返回字符串的副本,但将第一个字符大写
19 string.casefold() 返回经过标准化(normalize)后的字符串,标准化类似于转换为小写,但更适合用于对Unicode字符串进行不区分大小写的比较
20 string.swapcase() 将字符串中所有字母的大小写都反转,并返回结果
21 string.title() 将字符串中所有单词的首字母都大写,并返回结果
22 string.upper() 将字符串中所有的字母都转换为大写,并返回结果
---- ---- --------
23 string.replace(old,new[,max]) 将字符串中的子串 old 替换为 new ,并返回结果;还可将最大替换次数限制为 max
17 string.translate(table) 根据转换表 table (这是使用 maketrans 创建的)对字符串中的所有字符都进行转换,并返回结果
24 string.expandtabs([tabsize]) 返回将字符串中的制表符展开为空格后的结果,可指定可选参数 tabsize(默认为8)
---- ---- --------
11 string.join(sequence) 将 string 与 sequence 中的所有字符串元素合并,并返回结果
12 string.split([sep[, maxsplit]]) 返回一个列表,其中包含以 sep 为分隔符对字符串进行划分得到的结果(如果没有指定参数 sep ,将以所有空白字符为分隔符进行划分);还可将最大划分次数限制为 maxsplit
25 string.partition(sep) 在字符串中搜索 sep ,并返回元组 (sep 前面的部分 , sep, sep 后面的部分 )
26 string.rpartition(sep) 与 partition 相同,但从右往左搜索
17 string.rsplit([sep[, maxsplit]]) 与 split 相同,但指定了参数 maxsplit ,从右往左计算划分次数
28 string.splitlines([keepends]) 返回一个列表,其中包含字符串中的所有行;如果参数 keepends 为 True ,将包含换行符
---- ---- --------
29 string.strip([chars]) 将字符串开头和结尾的所有 chars 字符(默认为所有空白字符,如空格、制表符和换行符)都删除,并返回结果
30 string.lstrip([chars]) 将字符串开头所有的 chars (默认为所有的空白字符,如空格、制表符和换行符)都删除,并返回结果
31 string.rstrip([chars]) 将字符串末尾所有的 chars 字符(默认为所有的空白字符,如空格、制表符和换行符)都删除,并返回结果
---- ---- --------
32 string.isalnum() 检查字符串中的字符是否都是字母或数
33 string.isalpha() 检查字符串中的字符是否都是字母
34 string.isdecimal() 检查字符串中的字符是否都是十进制数
35 string.isdigit() 检查字符串中的字符是否都是数字
36 string.isidentifier() 检查字符串是否可用作Python标识符
37 string.isnumeric() 检查字符串中的所有字符是否都是数字字符
38 string.isprintable() 检查字符串中的字符是否都是可打印的
39 string.isspace() 检查字符串中的字符是否都是空白字符
14 string.islower() 检查字符串中的所有字母都是小写的
15 string.istitle() 检查字符串中位于非字母后面的字母都是大写的,且其他所有字母都是小写的
16 string.isupper() 检查字符串中的字母是否都是大写的
---- ---- --------
40 string.encode([encoding[,errors]]) 返回使用指定编码和 errors 指定的错误处理方式对字符串进行编码的结果,参数 errors 的可能取值包含 'strict' 、 'ignore' 、 'replace' 等
41 string.format(...) 实现了标准的Python字符串格式设置。将字符串中用大括号分隔的字段替换为相应的参数,再返回结果
42 string.format_map(mapping) 类似于使用关键字参数调用 format ,只是参数是以映射的方式提供的
43 str.maketrans(x[,y[,z]]) 一个静态方法,它创建一个供 translate 使用的转换表。如果只指定了参数 x ,它必须是从字符或序数到Unicode序数或 None (用于删除)的映射;也可使用两个表示源字符和目标字符的字符串调用它;还可提供第三个参数,它指定要删除的字符
44 string.rindex(sub[,start[,end]]) 返回找到的最后一个子串 sub 的索引,如果没有找到这样的子串,就引发ValueError 异常;还可将搜索范围限定为 string[start:end]
© Licensed under CC BY-NC-SA 4.0

别向医生和律师提供错误的消息。—— 本杰明·富兰克林

发表我的评论
取消评论
表情

Hi,您需要填写昵称和邮箱!