You are here:  Home » Python » (最全资料)列表、元组、数组、文本序列的字符串操作详解(6)Python语言(必读进阶学习教程)(参考资料)

序列类型- ,,list tuplerange

有三种基本序列类型:列表,元组和范围对象。专门用于处理二进制数据文本字符串的附加序列类型 在专门章节中描述。

 

公共序列操作

大多数序列类型都支持下表中的操作,包括可变和不可变。在collections.abc.Sequence美国广播公司提供,使其更容易正确地执行自定义序列类型这些操作。

此表列出按升序排序的顺序操作。在表中,st是相同类型的序列,nijk是整数,x是满足s强加的任何类型和值限制的任意对象。

in和操作具有比较操作相同的优先级。的(串联)和(重复)操作具有相同的优先级对应的数字操作。[3]notin+*

手术 结果 笔记
x in s True如果s的项等于x,否则False (1)
x not in s False如果s的项等于x,否则True (1)
s + t s和 t的连接 (6)(7)
s * n 要么 n * s 相当于将s添加到自身n (2)(7)
s[i] 的个项小号,原点0 (3)
s[i:j] 的切片小号Ĵ (3)(4)
s[i:j:k] 的切片小号Ĵ 与步骤ķ (3)(5)
len(s) 的长度小号
min(s) 最小的项目小号
max(s) 最大的项目小号
s.index(x[, i[, j]]) 的第一次出现的指数X小号(在或索引后和指数前Ĵ (8)
s.count(x) 出现的总次数 X小号

相同类型的序列也支持比较。特别是,通过比较相应的元素,按字典顺序比较元组和列表。这意味着要比较相等,每个元素必须比较相等,并且两个序列必须是相同类型并且具有相同的长度。(有关完整详细信息,请参阅语言参考中的。)

笔记:

  1. 虽然in和操作仅用于一般情况下的简单包容测试,但一些专门的序列(例如,和)也将它们用于子序列测试:not instrbytesbytearray

    >>>
    >>> "gg" in "eggs"
    True

     

  2. n小于的值0被视为0(其产生与s相同类型的空序列)。请注意,序列s 中的项目不会被复制; 它们被多次引用。这常常困扰着新的Python程序员; 考虑:

    >>>
    >>> lists = [[]] * 3
    >>> lists
    [[], [], []]
    >>> lists[0].append(3)
    >>> lists
    [[3], [3], [3]]

     

    发生的事情是[[]]包含空列表的单元素列表,因此所有三个元素都是对这个空列表的引用。修改任何元素都会修改此单个列表。您可以通过以下方式创建不同列表的列表:[[]] * 3lists

    >>>
    >>> lists = [[] for i in range(3)]
    >>> lists[0].append(3)
    >>> lists[1].append(5)
    >>> lists[2].append(7)
    >>> lists
    [[3], [5], [7]]

     

    FAQ条目中提供了进一步的说明 如何创建多维列表?

  3. 如果ij为负,则索引相对于序列s的结尾: 或被替换。但请注意,这仍然是。len(s) + ilen(s) + j-00

  4. 的切片小号Ĵ被定义为物品的具有索引序列 ķ使得。如果ij大于,请使用 。如果被省略或使用。如果省略j或 ,请使用。如果i大于或等于j,则切片为空。i <= k < jlen(s)len(s)None0Nonelen(s)

  5. 的切片小号Ĵ与步骤ķ被定义为物品的索引序列 ,使得。换句话说,在指数,,,等等,停车时 Ĵ达到(但绝不包括Ĵ)。当k为正时,如果它们更大,则 ij减小。当k为负时,如果它们更大,则ij减小。如果省略ijx = i + n*k0 <= n < (j-i)/kii+ki+2*ki+3*klen(s)len(s) - 1None,它们成为“结束”值(结束取决于k的符号)。注意,k不能为零。如果kNone,它被视为1

  6. 连接不可变序列总是会产生一个新对象。这意味着通过重复级联构建序列将在总序列长度中具有二次运行时成本。要获得线性运行时成本,您必须切换到以下替代方案之一:

    • 如果连接str对象,您可以构建一个列表并str.join()在最后使用 ,或者写入io.StringIO 实例并在完成时检索其值
    • 如果连接bytes对象,您可以类似地使用 bytes.join()io.BytesIO,或者您可以使用bytearray对象进行就地连接。 bytearray 对象是可变的并且具有有效的过度分配机制
    • 如果级联tuple对象,扩展list代替
    • 对于其他类型,请调查相关的类文档
  7. 某些序列类型(例如range)仅支持遵循特定模式的项序列,因此不支持序列连接或重复。

  8. indexs中找不到xValueError时引发。并非所有实现都支持传递附加参数ij。这些参数允许有效搜索序列的子部分。传递额外的参数大致相当于使用,只是没有复制任何数据,返回的索引相对于序列的开头而不是切片的开头。s[i:j].index(x)

 

不可变序列类型

不可变序列类型通常实现的唯一操作(也不是由可变序列类型实现)是对hash() 内置函数的支持。

这种支持允许不可改变的序列,如tuple实例中,以用作dict密钥,并存储在setfrozenset 实例。

尝试散列包含不可变值的不可变序列将导致TypeError

 

可变序列类型

下表中的操作是在可变序列类型上定义的。在collections.abc.MutableSequence美国广播公司提供,使其更容易正确地执行自定义序列类型这些操作。

在表中,s是可变序列类型的实例,t是任何可迭代对象,x是满足s强加的任何类型和值限制的任意对象(例如,bytearray只接受满足值限制的整数)。0 <= x <= 255

手术 结果 笔记
s[i] = x 小号被替换为 X
s[i:j] = t ijs片段 被可迭代t的内容替换
del s[i:j] 与…一样 s[i:j] = []
s[i:j:k] = t 元素s[i:j:k] 被t的元素取代 (1)
del s[i:j:k] s[i:j:k]从列表中删除元素
s.append(x) x附加到序列的末尾(与)相同s[len(s):len(s)] = [x]
s.clear() s中删除所有项目 (相同)del s[:] (5)
s.copy() 创建一个s的浅表副本 (相同s[:] (5)
s.extend(t) 要么 s += t 使用t的内容扩展s(大部分相同 )s[len(s):len(s)] = t
s *= n 更新s,其内容重复n (6)
s.insert(i, x) 在由i给出的索引处将x插入s (相同)s[i:i] = [x]
s.pop([i]) i处检索项目并将其从s中删除 (2)
s.remove(x) s 中删除第一项s[i]等于x的项 (3)
s.reverse() 反转的项目小号到位 (4)

笔记:

  1. t必须与它所替换的切片具有相同的长度。

  2. 默认使用可选参数-1,因此默认情况下会移除并返回最后一项。

  3. removes中找不到xValueError时引发。

  4. reverse()当反转大序列时,该方法修改了用于空间经济性的序列。为了提醒用户它是由副作用操作,它不会返回相反的顺序。

  5. clear()并且copy()包含与不支持切片操作的可变容器的接口(例如dictset)的一致性

    版本3.3中的新功能:clear()copy()方法。

  6. n是整数或实现的对象 __index__()n的零和负值清除序列。序列中的项目不会被复制; 他们被多次引用,作为解释下常见的操作顺序s * n

 

列表

列表是可变序列,通常用于存储同类项目的集合(其中精确的相似程度将根据应用而变化)。

class listiterable 
列表可以通过以下几种方式构建:

  • 使用一对方括号表示空列表: []
  • 使用方括号,用逗号分隔项目:[a][a, b, c]
  • 使用列表理解: [x for x in iterable]
  • 使用类型构造函数:list()list(iterable)

构造函数构建一个列表,其项目与iterable的项目相同且顺序相同。 iterable可以是序列,支持迭代的容器,也可以是迭代器对象。如果iterable 已经是一个列表,则会生成并返回一个副本,类似于iterable[:]。例如,list('abc')退货和 退货。如果没有给出参数,构造函数会创建一个新的空列表。['a', 'b', 'c']list( (1,2, 3) )[1, 2, 3][]

许多其他操作也会生成列表,包括sorted() 内置列表。

列表实现所有常见和 可变序列操作。列表还提供以下附加方法:

sort*key = Nonereverse = False 
此方法仅使用<项之间的比较对列表进行排序。不会禁止异常 – 如果任何比较操作失败,整个排序操作将失败(并且列表可能会处于部分修改状态)。

sort()接受两个只能通过关键字传递的参数(仅限关键参数):

key指定一个参数的函数,该函数用于从每个列表元素中提取比较键(例如,key=str.lower)。对应于列表中每个项目的密钥计算一次,然后用于整个分类过程。默认值None 表示列表项直接排序而不计算单独的键值。

functools.cmp_to_key()实用程序可用于将2.x样式的cmp函数转换为函数。

reverse是一个布尔值。如果设置为True,则列表元素将按照每个比较相反的方式进行排序。

当对大序列进行排序时,该方法修改了用于空间经济性的序列。为了提醒用户它是由副作用操作,它不返回已排序的序列(用于sorted()显式请求新的已排序列表实例)。

sort()方法保证稳定。如果排序保证不更改比较相等的元素的相对顺序,则排序是稳定的 – 这有助于在多个过程中进行排序(例如,按部门排序,然后按工资等级排序)。

CPython实现细节:在对列表进行排序时,尝试变异甚至检查列表的效果是未定义的。Python的C实现使得列表在持续时间内显示为空,并且ValueError如果它可以检测到列表在排序期间已经变异,则会引发该列表。

 

元组

元组是不可变序列,通常用于存储异构数据的集合(例如由enumerate() 内置函数生成的2元组)。元组还用于需要不可变的同类数据序列的情况(例如允许在一个set或 一个dict实例中存储)。

class tupleiterable 
元组可以通过多种方式构建:

  • 使用一对括号表示空元组: ()
  • 对单例元组使用尾随逗号:a,(a,)
  • 用逗号分隔项目:或a, b, c(a, b, c)
  • 使用tuple()内置:tuple()tuple(iterable)

构造函数构建一个元组,其项目与iterable的项目相同且顺序相同。 iterable可以是序列,支持迭代的容器,也可以是迭代器对象。如果iterable 已经是一个元组,则返回不变。例如, tuple('abc')退货和 退货。如果没有给出参数,构造函数会创建一个新的空元组。('a', 'b', 'c')tuple( [1, 2, 3] )(1, 2, 3)()

请注意,它实际上是一个逗号,它产生一个元组,而不是括号。括号是可选的,除了空元组情况,或者需要它们以避免语法歧义。例如, 是一个带有三个参数 的函数调用,而是一个以3元组作为唯一参数的函数调用。f(a, b, c)f((a, b, c))

元组实现所有常见的序列操作。

对于通过名称访问比索引访问更清晰的异构数据集合,collections.namedtuple()可能是比简单元组对象更合适的选择。

 

范围

range类型表示不可变的数字序列,通常用于在循环中循环特定次数for 。

class range停止
class rangestartstop [step 
范围构造函数的参数必须是整数(内置函数 int或实现__index__特殊方法的任何对象)。如果省略step参数,则默认为1。如果省略start参数,则默认为0。如果step为零,ValueError则引发。

对于正步骤,范围的内容r由公式确定,其中和 。r[i] = start + step*ii >= 0r[i] < stop

对于否定步骤,范围的内容仍然由公式确定,但约束是 和。r[i] = start + step*ii >= 0r[i] > stop

如果r[0]不满足值约束,则范围对象将为空。范围确实支持负指数,但这些指数被解释为从正指数确定的序列末尾开始索引。

包含绝对值大于sys.maxsize允许但是某些特征(例如len())的范围可能会增加 OverflowError

范围示例:

>>>
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

 

范围实现除串联和重复之外的所有常见序列操作(由于范围对象只能表示遵循严格模式的序列,并且重复和连接通常会违反该模式)。

start
start参数的值(或者0如果未提供参数)
stop
stop参数的值
step
参数的值(或者1如果未提供参数)

所述的优点range类型通过常规list或 tuple是一个range对象将始终以相同的内存(小)数量,无论它代表的范围内的大小(因为它仅存储startstopstep值,计算各个项目和子范围需要)。

Range对象实现collections.abc.SequenceABC,并提供包含测试,元素索引查找,切片和负索引支持等功能(请参阅序列类型 – 列表,元组,范围):

>>> r = range(0, 20, 2) 
>>> r 
range(0, 20, 2) 
>>> 11 in r 
False 
>>> 10 in r 
True 
>>> r.index(10) 
5 
>>> r[5] 
10 
>>> r[:5] 
range(0, 10, 2) 
>>> r[-1] 
18

 

测试对象范围与平等==!=比较它们作为序列。也就是说,如果两个范围对象表示相同的值序列,则它们被认为是相等的。(请注意,比较相等的两个范围的对象可能有不同的start, stopstep属性,例如 或)。range(0)== range(2, 1, 3)range(0, 3, 2) == range(0, 4, 2)

版本3.2中更改:实现序列ABC。支持切片和负索引。int以恒定时间测试对象的成员资格,而不是遍历所有项目。

在版本3.3中更改:定义’==’和’!=’以基于它们定义的值序列来比较范围对象(而不是基于对象标识进行比较)。

新的3.3版:startstopstep 属性。

也可以看看

  • 该linspace配方 展示了如何实现一个懒惰的版本的范围适用于浮点应用程序。

文本序列类型 – str

Python中的文本数据由str对象或字符串处理。字符串是Unicode代码点的不可变 序列。字符串文字以多种方式编写:

  • 单引号: 'allows embedded "double" quotes'
  • 双引号:。"allows embedded 'single' quotes"
  • 三重引用:,'''Three single quotes'''"""Three double quotes"""

三引号字符串可能跨越多行 – 所有相关的空格都将包含在字符串文字中。

字符串文字是单个表达式的一部分,它们之间只有空格,将隐式转换为单个字符串文字。就是这样。("spam ""eggs") == "spam eggs"

有关各种形式的字符串文字的更多信息,包括支持的转义序列,以及禁用大多数转义序列处理的(“raw”)前缀,请参阅字符串和字节文字r

也可以使用str 构造函数从其他对象创建字符串。

由于没有单独的“字符”类型,索引的字符串产生一个长度1。也就是说,对于一个非空字符串的字符串小号,。s[0] == s[0:1]

也没有可变的字符串类型,但str.join()还是 io.StringIO可以用来有效地构造从多个片段字符串。

版本3.3中已更改:为了向后兼容Python 2系列,u字符串文字再次允许使用前缀。它对字符串文字的含义没有影响,不能与r前缀结合使用。

class strobject =” 
class strobject = b”encoding =’utf-8′errors =’strict’ 
返回对象字符串版本。如果未提供object,则返回空字符串。否则,行为 取决于是否给出编码错误,如下所示。str()

如果既没有编码也不错误给出,str(object)返回 object.__str__(),这是“非正规”或很好的可打印字符串表示对象。对于字符串对象,这是字符串本身。如果object没有__str__() 方法,则str()返回返回repr(object)

如果给出了编码错误中的至少一个,则对象应该是类似 字节的对象(例如bytesbytearray)。在这种情况下,如果objectbytes(或bytearray)对象,则等效于 。否则,在调用之前获取缓冲区对象下的字节对象。有关缓冲区对象的信息,请参阅二进制序列类型 – 字节,字节数组,内存视图和 缓冲区协议str(bytes,encoding, errors)bytes.decode(encoding, errors)bytes.decode()

bytesstr()没有编码 或错误参数的情况下传递对象属于第一种返回非正式字符串表示的情况(另请参阅-bPython 的命令行选项)。例如:

>>>
>>> str(b'Zoot!')
"b'Zoot!'"

 

有关str类及其方法的更多信息,请参阅下面的 文本序列类型 – str字符串方法部分。要输出格式化字符串,请参阅格式化字符串文字格式字符串语法 部分。另外,请参阅“ 文本处理服务”部分。

 

字符串方法

字符串实现所有常见的序列操作,以及下面描述的其他方法。

字符串还支持两种样式的字符串格式,一种提供了很大的灵活性和自定义(参见str.format(), 格式字符串语法自定义字符串格式),另一种基于C printf样式格式,处理较窄的类型范围,并且稍微难以使用正确,但对于它可以处理的情况(printf样式的字符串格式)通常更快。

标准库的文本处理服务部分涵盖了许多其他模块,这些模块提供了各种与文本相关的实用程序(包括re模块中的正则表达式支持)。

str.capitalize
返回字符串的副本,其首字符大写,其余字符小写。
str.casefold
返回字符串的包含案例的副本。表壳折叠字符串可用于无壳匹配。

Casefolding类似于lowercasing但更具攻击性,因为它旨在删除字符串中的所有大小写区别。例如,德语小写字母'ß'相当于"ss"。因为它已经是小写的,所以lower()什么都不做'ß'casefold() 将其转换为"ss"

案例折叠算法在Unicode标准的3.13节中描述。

版本3.3中的新功能。

str.centerwidth [fillchar 
以长度宽度的字符串为中心返回。使用指定的fillchar完成填充(默认为ASCII空间)。如果width小于或等于,则返回原始字符串len(s)
str.countsub [start [end 
返回[ startend ] 范围内substring sub的非重叠出现次数。可选参数startend被解释为切片表示法。
str.encodeencoding =“utf-8”errors =“strict” 
将字符串的编码版本作为字节对象返回。默认编码是'utf-8'。可以给出错误以设置不同的错误处理方案。错误的默认值是'strict',意味着编码错误会引发错误UnicodeError。其他可能的值'ignore''replace''xmlcharrefreplace', 'backslashreplace'和其他任何名义通过挂号codecs.register_error(),见错误处理程序。有关可能的编码列表,请参阅标准编码部分。

在3.1版中更改:添加了对关键字参数的支持。

str.endswith后缀[start [end 
返回True字符串是否与指定的结束后缀,否则返回 False。 后缀也可以是要查找的后缀元组。通过可选的 启动,从该位置开始测试。使用可选结束,停止在该位置进行比较。
str.expandtabstabsize = 8 
返回字符串的副本,其中所有制表符由一个或多个空格替换,具体取决于当前列和给定的制表符大小。每个制表符字符都会出现制表符位置(默认值为8,在第0,8,16列等位置给出制表符位置)。要展开字符串,请将当前列设置为零,并逐个字符地检查字符串。如果字符是制表符(\t),则在结果中插入一个或多个空格字符,直到当前列等于下一个制表符位置。(不会复制制表符本身。)如果字符是换行符(\n)或返回(\r),将其复制并将当前列重置为零。任何其他字符都将保持不变,当前列将加1,无论打印时字符的表示方式如何。

>>> '01\t012\t0123\t01234'.expandtabs() 
'01 012 0123 01234' 
>>> '01\t012\t0123\t01234'.expandtabs(4) 
'01 012 0123 01234'

 

str.findsub [start [end 
返回在切片中找到substring sub的字符串中的最低索引s[start:end]。可选参数startend被解释为切片表示法。-1如果未找到sub,则返回。

注意

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'

 

有关可以在格式字符串中指定的各种格式选项的说明,请参阅格式字符串语法

注意

当格式化数(intfloatcomplex, decimal.Decimal和亚类)与n类型(例如:'{:n}'.format(1234)),功能暂时设定 LC_CTYPE的区域设置到LC_NUMERIC区域解码 decimal_pointthousands_sep领域localeconv()如果它们是非ASCII或长于1个字节,而LC_NUMERIC区域设置为不同的比LC_CTYPE当地的。此临时更改会影响其他线程。

在版本3.7中更改:在使用n类型格式化数字时,该函数会在某些情况下临时将LC_CTYPE语言环境设置为LC_NUMERIC语言环境。

str.format_map映射
类似于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'

 

版本3.2中的新功能。

str.indexsub [start [end 
喜欢find(),但是ValueError在找不到子串的时候会加注。
str.isalnum
如果字符串中的所有字符都是字母数字且至少有一个字符,则返回true,否则返回false。字符c是字母数字,如果下面的返回之一Truec.isalpha()c.isdecimal(), c.isdigit(),或c.isnumeric()
str.isalpha
如果字符串中的所有字符都是字母并且至少有一个字符,则返回true,否则返回false。字母字符是在Unicode字符数据库中定义为“字母”的那些字符,即具有一般类别属性的那些字符是“Lm”,“Lt”,“Lu”,“L1”或“Lo”之一。请注意,这与Unicode标准中定义的“字母”属性不同。
str.isascii
如果字符串为空或字符串中的所有字符都是ASCII,则返回true,否则返回false。ASCII字符的代码点范围为U + 0000-U + 007F。

版本3.7中的新功能。

str.isdecimal
如果字符串中的所有字符都是十进制字符并且至少有一个字符,则返回true,否则返回false。十进制字符是可用于在基数10中形成数字的字符,例如U + 0660,ARABIC-INDIC DIGIT ZERO。正则小数字符是Unicode常规类别“Nd”中的字符。
str.isdigit
如果字符串中的所有字符都是数字并且至少有一个字符,则返回true,否则返回false。数字包括十进制字符和需要特殊处理的数字,例如兼容性上标数字。这包括不能用于在基数10中形成数字的数字,如Kharosthi数字。形式上,数字是具有属性值Numeric_Type = Digit或Numeric_Type = Decimal的字符。
str.isidentifier
如果字符串是根据语言定义,标识符和关键字部分的有效标识符,则返回true 。

使用keyword.iskeyword()测试保留的标识符,例如 defclass

str.islower
如果字符串中的所有外壳字符[4]都是小写且至少有一个外壳字符,则返回true,否则返回false。
str.isnumeric
如果字符串中的所有字符都是数字字符,则返回true,并且至少有一个字符,否则返回false。数字字符包括数字字符,以及具有Unicode数值属性的所有字符,例如U + 2155,VULGAR FRACTION ONE FIFTH。形式上,数字字符是具有属性值Numeric_Type = Digit,Numeric_Type = Decimal或Numeric_Type = Numeric的字符。
str.isprintable
如果字符串中的所有字符都是可打印的或字符串为空,则返回true,否则返回false。不可打印的字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符,但ASCII空间(0x20)除外,它被认为是可打印的。(请注意,此上下文中的可打印字符repr()是在字符串上调用时不应转义 的字符。它与写入sys.stdout或的字符串的处理无关sys.stderr。)
str.isspace
如果字符串中只有空格字符并且至少有一个字符,则返回true,否则返回false。空白字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符,以及具有双向属性的字符是“WS”,“B”或“S”之一。
str.istitle
如果字符串是一个带有标题的字符串并且至少有一个字符,则返回true,例如,大写字符可能只跟随无框字符,而小写字符只能跟随字符。否则返回false。
str.isupper
如果字符串中的所有外壳字符[4]都是大写且至少有一个外壳字符,则返回true,否则返回false。
str.join可迭代的
返回一个字符串,它是iterable中字符串的串联。TypeError如果在iterable中有任何非字符串值,包括bytes对象,则会引发 A. 元素之间的分隔符是提供此方法的字符串。
str.ljustwidth [fillchar 
返回长度的字符串左对齐字符串宽度。使用指定的fillchar完成填充(默认为ASCII空间)。如果width小于或等于,则返回原始字符串len(s)
str.lower
返回字符串的副本,并将所有套接字符[4]转换为小写。

所使用的小写算法在Unicode标准的3.13节中描述。

str.lstripchars 
返回删除了前导字符的字符串副本。的字符 参数是要除去的字符串指定的字符集。如果省略或None,则chars参数默认为删除空格。该字符 参数不是前缀; 相反,它的所有值组合都被剥离:

>>>
>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

 

static str.maketrans[[
此静态方法返回可用于的转换表str.translate()

如果只有一个参数,则它必须是将Unicode序数(整数)或字符(长度为1的字符串)映射到Unicode序数,字符串(任意长度)或字典的字典None。然后将字符键转换为序数。

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

str.partitionsep 
在第一次出现sep时拆分字符串,并返回包含分隔符之前的部分的3元组,分隔符本身以及分隔符之后的部分。如果未找到分隔符,则返回包含字符串本身的3元组,后跟两个空字符串。
str.replace旧的新的[计数
返回字符串的副本,其中所有出现的substring old都替换为 new。如果给出可选参数计数,则仅 替换第一次计数
str.rfindsub [start [end 
返回找到substring sub的字符串中的最高索引,以便包含subs[start:end]。可选参数start 和end被解释为切片表示法。-1失败时返回。
str.rindexsub [start [end 
喜欢rfind()ValueError在找不到子串子时加注。
str.rjustwidth [fillchar 
以长度宽度的字符串返回右对齐的字符串。使用指定的fillchar完成填充(默认为ASCII空间)。如果width小于或等于,则返回原始字符串len(s)
str.rpartitionsep 
在最后一次出现sep时拆分字符串,并返回包含分隔符之前的部分的3元组,分隔符本身以及分隔符之后的部分。如果找不到分隔符,则返回包含两个空字符串的3元组,后跟字符串本身。
str.rsplitsep = Nonemaxsplit = -1 
使用sep作为分隔符字符串,返回字符串中单词的列表。如果给出maxsplit,则最多完成maxsplit分割,最右边的分割。如果未指定sepNone,则任何空格字符串都是分隔符。除了从右边分裂之外,rsplit()其行为类似于split()下面详细描述的。
str.rstripchars 
返回删除了尾随字符的字符串副本。的字符 参数是要除去的字符串指定的字符集。如果省略或None,则chars参数默认为删除空格。该字符 参数不是后缀; 相反,它的所有值组合都被剥离:

>>>
>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

 

str.splitsep = Nonemaxsplit = -1 
使用sep作为分隔符字符串,返回字符串中单词的列表。如果给出maxsplit,则最多完成maxsplit拆分(因此,列表将具有最多maxsplit+1元素)。如果未指定maxsplit-1,则对分割数量没有限制(进行所有可能的分割)。

如果给出了sep,则连续的分隔符不会组合在一起,并被视为分隔空字符串(例如,'1,,2'.split(',')返回)。该的参数可以由多个字符(例如,返回)。返回使用指定分隔符拆分空字符串。['1', '','2']'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.splitlineskeepends 
返回字符串中的行列表,在行边界处断开。除非给出keepends且为true,否则换行符不包括在结果列表中。

此方法在以下行边界上分割。特别是,边界是普遍换行的超集。

表示 描述
\n 换行
\r 回程
\r\n 回车+换行
\v 要么 \x0b 行列表
\f 要么 \x0c 换页
\x1c 文件分隔符
\x1d 组分隔符
\x1e 记录分隔符
\x85 下一行(C1控制代码)
\u2028 行分隔符
\u2029 段落分隔符

在版本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']

 

与给定split()分隔符字符串sep时不同,此方法返回空字符串的空列表,并且终端换行符不会产生额外的行:

>>>
>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']
为了比较,split('\n')给出:
>>>
>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

 

str.startswith前缀[start [end 
返回True字符串是否与开始前缀,否则返回False。 前缀也可以是要查找的前缀元组。使用可选的启动,测试字符串从该位置开始。使用可选结束,停止比较该位置的字符串。
str.stripchars 
返回删除了前导和尾随字符的字符串副本。的字符参数是要除去的字符串指定的字符集。如果省略或None,则chars参数默认为删除空格。该字符参数不是前缀或后缀; 相反,它的所有值组合都被剥离:

>>>
>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

 

最外层的前导和尾随字符参数值将从字符串中删除。从前端删除字符,直到到达字符集中未包含的字符串字符。在尾端发生类似的动作。例如:

>>>
>>> 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.translate
返回字符串的副本,其中每个字符已通过给定的转换表进行映射。该表必须是通过__getitem__()(通常是映射或 序列)实现索引的对象。当由Unicode序数(整数)索引时,表对象可以执行以下任何操作:返回Unicode序号或字符串,以将字符映射到一个或多个其他字符; return None,从返回字符串中删除字符; 或者引发 LookupError异常,将角色映射到自身。

您可以使用str.maketrans()不同格式的字符到字符映射创建转换映射。

另请参阅该codecs模块,以获得更灵活的自定义字符映射方法。

str.upper
返回字符串的副本,并将所有套接字符[4]转换为大写。请注意,s.upper().isupper()可能是False如果s 包含无套管的字符或如果所得到的字符(县)的Unicode类别不是“吕氏春秋”(字母,大写),但如“LT”(字母,首字母大写)。

使用的大写算法在Unicode标准的3.13节中描述。

str.zfill宽度
返回用ASCII '0'数字填充的字符串的副本,以生成长度为宽度的字符串。一个前置符号前缀('+''-')是通过将填充处理的符号字符,而不是之前。如果width小于或等于,则返回原始字符串len(s)

例如:

>>>
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

 

 

printf式字符串格式

注意

这里描述的格式化操作表现出各种怪癖,导致许多常见错误(例如无法正确显示元组和字典)。使用较新的格式化字符串文字str.format()接口或模板字符串可以帮助避免这些错误。这些替代方案中的每一个都提供了它们自身的权衡和简单性,灵活性和/或可扩展性的益处。

String对象有一个独特的内置操作:%operator(modulo)。这也称为字符串格式插值运算符。给定(格式为字符串),格式的转换规范将替换为零个或多个元素。效果类似于在C语言中使用。format % values%sprintf()

如果format需要单个参数,则可以是单个非元组对象。[5] 否则,必须是具有格式字符串指定的项目数的元组,或者是单个映射对象(例如,字典)。

转换说明符包含两个或多个字符,并具有以下组件,这些组件必须按以下顺序出现:

  1. '%'字符,标记说明符的开头。
  2. 映射键(可选),由带括号的字符序列组成(例如(somename))。
  3. 转换标志(可选),它会影响某些转换类型的结果。
  4. 最小字段宽度(可选)。如果指定为'*'(星号),则从的元组的下一个元素读取实际宽度,并且要转换的对象在最小字段宽度和可选精度之后。
  5. 精度(可选),以'.'(点)表示,后跟精度。如果指定为'*'(星号),则从的元组的下一个元素读取实际精度,并且要转换的值在精度之后。
  6. 长度修饰符(可选)。
  7. 转换类型。

当右参数是字典(或其他映射类型)时,字符串中的格式必须包括括号中的映射键,该字符串紧接在'%'字符后面插入的字典中。映射关键字从映射中选择要格式化的值。例如:

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

 

在这种情况下*,格式中不会出现说明符(因为它们需要顺序参数列表)。

转换标志字符是:

含义
'#' 值转换将使用“备用表单”(在下面定义)。
'0' 对于数值,转换将为零填充。
'-' 保留转换后的值('0' 如果给出两者,则覆盖转换)。
' ' (空格)在签名转换产生的正数(或空字符串)之前应留空。
'+' 符号字符('+''-')将在转换之前(覆盖“空格”标志)。

可以存在长度修饰符(hlL),但忽略它,因为它不是Python所必需的 – 因此例如%ld是相同的%d

转换类型包括:

转变 含义 笔记
'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' String(使用转换任何Python对象 repr())。 (5)
's' String(使用转换任何Python对象 str())。 (5)
'a' String(使用转换任何Python对象 ascii())。 (5)
'%' 不转换参数,导致结果中出现'%' 字符。

笔记:

  1. 替代形式导致'0o'在第一个数字之前插入前导八进制说明符()。

  2. 在另一种形式使得领先'0x''0X'(取决于是否'x''X'使用格式)的第一位数字之前插入。

  3. 替代形式导致结果始终包含小数点,即使后面没有数字也是如此。

    精度确定小数点后的位数,默认为6。

  4. 替代形式导致结果始终包含小数点,并且不会删除尾随零,否则它们将被删除。

    精度确定小数点前后的有效位数,默认为6。

  5. 如果是precision N,则输出将截断为N字符。

  6. 看到 PEP 237

由于Python字符串具有明确的长度,因此%s转换不会假定它'\0'是字符串的结尾。

版本3.1中已更改:%f绝对值超过1e50的数字的%g转换不再由转化替换。

脚注

[1] 有关这些特殊方法的更多信息,请参阅Python参考手册(基本自定义)。
[2] 因此,列表被认为是等同的,并且类似于元组。[1, 2][1.0, 2.0]
[3] 它们必须具有,因为解析器无法分辨操作数的类型。
[4] (1,2,3,4)下套管字符是那些具有一般类别属性是“路”(字母,大写),“LL”(字母,小写),或“LT”(字母,首字母大写)中的一个。
[5] (1,2)要格式化只有一个元组因此,你应该提供一个单元组的唯一元件是要格式化的元组。