序列[(list)，(tuple)]、映射(dictionary)、集合(set)
1 . 须知：
Python内置了多种序列，如列表（list）和元组(tuple),其实字符串（string)也是一种序列。
>>> "Hello,world!" >>> "Hello,world!"[0] 'H' >>>"Hello,world!"[-1] '!'
数据结构。数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。在有些编程语言中，从1开始给序列中的元素编号，但从0开始指出相对于序列开头的偏移量。这显得更自然，同时可回绕到序列末尾，用负索引表示序列末尾元素的位置。
注意 Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）。有一种既不是序列也不是映射的容器，它就是集合（set）。
2 . 列表是什么？
列表是由一系列按特定顺序排列的元素组成。你可以创建包括字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称(如letters、digits或names)是个不错的主意。
在Python中，用方括号([])来表示列表，并用逗号来分隔其中的元素。
>>> strings['A','B','C'] >>> strings ['A','B','C']
3 . 通用的序列操作方法
有几种操作适用于所有序列，包括索引、切片、相加、相乘和成员资格检查。另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。
索引：
序列中的所有元素都有编号——从0开始递增。你可像下面这样使用编号来访问各个元素：
>>> names = ["zhangsan","lisi"] >>> print(names[1]) lisi
索引（indexing）。你可使用索引来获取元素。这种索引方式适用于所有序列。当你使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置。
>>> names = ["zhangsan","lisi"] >>> print(names[-]) lisi
对于字符串字面量（以及其他的序列字面量），可直接对其执行索引操作，无需先将其赋给变量。这与先赋给变量再对变量执行索引操作的效果是一样的。
>>> ["zhangsan","lisi"] >>> ["zhangsan","lisi"][0] 'zhangsan'
如果函数调用返回一个序列，可直接对其执行索引操作。例如，如果你只想获取用户输入的年份的第4位，可像下面这样做：
>>> fourth = input('Year: ')[3] Year: 2005 >>> fourth '5'
切片：
除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素。为此，可使用两个索引，并用冒号分隔：
>>> tag = '<a href="http://www.python.org">Python web site</a>' >>> tag[9:30] 'http://www.python.org' >>> tag[32:-4] 'Python web site'
如你所见，切片适用于提取序列的一部分，其中的编号非常重要：第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。请看下面的示例：
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> numbers[3:6] [4, 5, 6] >>> numbers[0:1] [1]
简而言之，你提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。
简写：假设你要访问前述数字列表中的最后三个元素，显然可以明确地指定这一点。
>>> numbers[7:10]
[8, 9, 10]
在这里，索引10指的是第11个元素：它并不存在，但确实是到达最后一个元素后再前进一步所处的位置。明白了吗？如果要从列表末尾开始数，可使用负数索引。
>>> numbers[-3:-1]
[8, 9]
然而，这样好像无法包含最后一个元素。如果使用索引0，即到达列表末尾后再前进一步所处的位置，结果将如何呢？
>>> numbers[-3:0]
[]
结果并不是你想要的。事实上，执行切片操作时，如果第一个索引指定的元素位于第二个索引指定的元素后面（在这里，倒数第3个元素位于第1个元素后面），结果就为空序列。好在你能使用一种简写：如果切片结束于序列末尾，可省略第二个索引。
>>> numbers[-3:]
[8, 9, 10]
同样，如果切片始于序列开头，可省略第一个索引。
>>>> numbers[:3]
>[1, 2, 3]
实际上，要复制整个序列，可将两个索引都省略。
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
更大的步长(切片）：
执行切片操作时，你显式或隐式地指定起点和终点，但通常省略另一个参数，即步长。在普通切片中，步长为1。这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。
>>> numbers[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
在这个示例中，指定了另一个数。你可能猜到了，这显式地指定了步长。如果指定的步长大于1，将跳过一些元素。例如，步长为2时，将从起点和终点之间每隔一个元素提取一个元素。
>>> numbers[0:10:2] [1, 3, 5, 7, 9] numbers[3:6:3] [4]
显式地指定步长时，也可使用前述简写。例如，要从序列中每隔3个元素提取1个，只需提供步长4即可。
>>> numbers[::4]
[1, 5, 9]
当然，步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素。
>>> numbers[8:3:-1] [9, 8, 7, 6, 5] >>> numbers[10:0:-2] [10, 8, 6, 4, 2]
>>> numbers[0:10:-2] [] >>> numbers[::-2] [10, 8, 6, 4, 2] >>> numbers[5::-2] [6, 4, 2] >>> numbers[:5:-2] [10, 8
在这种情况下，要正确地提取颇费思量。如你所见，第一个索引依然包含在内，而第二个索引不包含在内。步长为负数时，第一个索引必须比第二个索引大。可能有点令人迷惑的是，当你省略起始和结束索引时，Python竟然执行了正确的操作：步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点。
序列相加：
可使用加法运算符来拼接序列。
>>> [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] >>> 'Hello,' + 'world!' 'Hello, world!' >>> [1, 2, 3] + 'world!' Traceback (innermost last): File "<pyshell>", line 1, in ? [1, 2, 3] + 'world!' TypeError: can only concatenate list (not "string") to list
从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。
乘法：
将序列与数x相乘时，将重复这个序列x次来创建一个新序列：
>>> 'python' * 5 'pythonpythonpythonpythonpython' >>> [42] * 10 [42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
None、空列表和初始化：
空列表是使用不包含任何内容的两个方括号（[]）表示的。如果要创建一个可包含10个元素的列表，但没有任何有用的内容，可像前面那样使用[42]*10。但更准确的做法是使用[0]*10，这将创建一个包含10个零的列表。然而，在有些情况下，你可能想使用表示“什么都没有”的值，如表示还没有在列表中添加任何内容。在这种情况下，可使用None。在Python中，None表示什么都没有。因此，要将列表的长度初始化为10，可像下面这样做：
>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]
成员资格：
要检查特定的值是否包含在序列中，可使用运算符in。这个运算符与前面讨论的运算符（如乘法或加法运算符）稍有不同。它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足时返回False。这样的运算符称为布尔运算符，而前述真值称为布尔值。
>>> permissions = 'rw' >>> 'w' in permissions True >>> 'x' in permissions False >>> users = ['mlh', 'foo', 'bar'] >>> input('Enter your user name: ') in users Enter your user name: mlh True >>> subject = '$$$ Get rich now!!! $$$' >>> '$$$' in subject True
长度、最小值和最大值：
内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素。
>>> numbers = [100, 34, 678] >>> len(numbers) 3 >>> max(numbers) 678 >>> min(numbers) 34 >>> max(2, 3) 3 >>> min(9, 3, 2, 5) 2
基于前面的解释，这些代码应该很容易理解，但最后两个表达式可能例外。在这两个表达式中，调用max和min时指定的实参并不是序列，而直接将数作为实参。
4 . Python的主力：列表(list)
列表不同于元组和字符串的地方——列表是可变的，即可修改其内容。另外，列表有很多特有的方法。
函数(list):
鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。为此，可使用函数list(类）。
>>> list('Hello') ['H', 'e', 'l', 'l', 'o']
将字符列表（如前述代码中的字符列表）转换为字符串，可使用下面的表达式：
''.join(somelist)
''' ' '.join(somelist)：将字符列表连接成字符串。 将字符列表、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串 ''' #:' '.join(somelist)将字符列表转换为字符串,前面' '里面设置连接符号 print(''.join(list_string)) #没有连接符 print('$'.join("China")) #连接符$
基本的列表操作：
可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘，但列表的有趣之处在于它是可以修改的。修改列表的方式：给元素赋值、删除元素、给切片赋值以及使用列表的方法。（请注意，并非所有列表方法都会修改列表。)
修改列表：给元素赋值
>>> x = [1, 1, 1] >>> x[1] = 2 >>> x [1, 2, 1]
不能给不存在的元素赋值，因此如果列表的长度为2，就不能给索引为100的元素赋值。要这样做，列表的长度至少为101。可先对列表初始化(None)。
删除元素
从列表中删除元素也很容易，只需使用del语句即可。
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl'] >>> del names[2] >>> names ['Alice', 'Beth', 'Dee-Dee', 'Earl']
注意到Cecil彻底消失了，而列表的长度也从5变成了4。除用于删除列表元素外，del语句还可用于删除其他东西。（比如字典内，还有可以删除变量）
>>> name = "zhang" >>> print(name) zhang >>> del name >>> print(name) #将会报错
给切片赋值
切片是一项极其强大的功能，而能够给切片赋值让这项功能显得更加强大。
>>> name = list('Perl') >>> name ['P', 'e', 'r', 'l'] >>> name[2:] = list('ar') >>> name ['P', 'e', 'a', 'r']
从上述代码可知，可同时给多个元素赋值。你可能认为，这有什么大不了的，分别给每个元素赋值不是一样的吗？确实如此，但通过使用切片赋值，可将切片替换为长度与其不同的序列。
>>> name = list('Perl') >>> name[1:] = list('ython') >>> name ['P', 'y', 't', 'h', 'o', 'n']
使用切片赋值还可在不替换原有元素的情况下插入新元素。
>>> numbers = [1, 5] >>> numbers[1:1] = [2, 3, 4] >>> numbers [1, 2, 3, 4, 5]
在这里，我“替换”了一个空切片，相当于插入了一个序列。你可采取相反的措施来删除切片。
>>> numbers [1, 2, 3, 4, 5] >>> numbers[1:4] = [] >>> numbers [1, 5]
与del numbers[1:4]等效
列表方法：
方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用方法：
object.method(arguments)
方法调用与函数调用很像，只是在方法名前加上了对象和句点。列表包含多个可用来查看或修改其内容的方法。
方法append用于将一个对象附加到列表末尾
>>> lst = [1, 2, 3] >>> lst.append(4) >>> lst [1, 2, 3, 4]
不会返回修改后的新列表，而是直接修改旧列表
方法clear就地清空列表的内容
>>> lst = [1, 2, 3] >>> lst.clear() >>> lst []
这类似于切片赋值语句lst[:] = []。
方法copy复制列表。前面说过，常规复制只是将另一个名称关联到列表
>>> a = [1, 2, 3] >>> b = a >>> b[1] = 4 >>> a [1, 4, 3]
要让a和b指向不同的列表，就必须将b关联到a的副本。
>>> a = [1, 2, 3] >>> b = a.copy() >>> b[1] = 4 >>> a [1, 2, 3]
这类似于使用a[:]或list(a)，它们也都复制a。
方法count计算指定的元素在列表中出现了多少次
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 2 >>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]] >>> x.count(1) 2 >>> x.count([1, 2]) 1
方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend。换而言之，你可使用一个列表来扩展另一个列表.
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6]
这可能看起来类似于拼接，但存在一个重要差别，那就是将修改被扩展的序列（这里是a）。在常规拼接中，情况是返回一个全新的序列。
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a + b [1, 2, 3, 4, 5, 6] >>> a [1, 2, 3]
如你所见，拼接出来的列表与前一个示例扩展得到的列表完全相同，但在这里a并没有被修改。鉴于常规拼接必须使用a和b的副本创建一个新列表，因此如果你要获得类似于下面的效果，拼接的效率将比extend低：
>>> a = a + b
另外，拼接操作并非就地执行的，即它不会修改原来的列表。要获得与extend相同的效果，可将列表赋给切片，如下所示：
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a[len(a):] = b >>> a [1, 2, 3, 4, 5, 6]
这虽然可行，但可读性不是很高。
方法index在列表中查找指定值第一次出现的索引
>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni'] >>> knights.index('who') 4 >>> knights.index('herring') Traceback (innermost last): File "<pyshell>", line 1, in ? knights.index('herring') ValueError: list.index(x): x not in list
方法insert用于将一个对象插入列表
>>> numbers = [1, 2, 3, 5, 6, 7] >>> numbers.insert(3, 'four') >>> numbers [1, 2, 3, 'four', 5, 6, 7]
与extend一样，也可使用切片赋值来获得与insert一样的效果。
>>> numbers = [1, 2, 3, 5, 6, 7] >>> numbers[3:3] = ['four'] >>> numbers [1, 2, 3, 'four', 5, 6, 7]
这虽巧妙，但可读性根本无法与使用insert媲美。
方法pop从列表中删除一个元素（末尾为最后一个元素），并返回这一元素。
>>> x = [1, 2, 3] >>> x.pop() 3 >>> x [1, 2] >>> x.pop(0) 1 >>> x [2]
注意 pop是唯一既修改列表又返回一个非None值的列表方法。
使用pop可实现一种常见的数据结构——栈（stack）。栈就像一叠盘子，你可在上面添加盘子，还可从上面取走盘子。最后加入的盘子最先取走，这被为后进先出（LIFO）。
push和pop是大家普遍接受的两种栈操作（加入和取走）的名称。Python没有提供push，但可使用append来替代。方法pop和append的效果相反，因此将刚弹出的值压入（或附加）后，得到的栈将与原来相同。
>>> x = [1, 2, 3] >>> x.append(x.pop()) >>> x [1, 2, 3]
提示 要创建先进先出（FIFO）的队列，可使用insert(0, ...)代替append。另外，也可继续使用append，但用pop(0)替代pop()。一种更佳的解决方案是，使用模块collections中的deque。
方法remove用于删除第一个为指定值的元素。
>>> x = ['to', 'be', 'or', 'not', 'to', 'be'] >>> x.remove('be') >>> x ['to', 'or', 'not', 'to', 'be']
请注意，remove是就地修改且不返回值的方法之一。不同于pop的是，它修改列表，但不返回任何值。
方法reverse按相反的顺序排列列表中的元素
>>> x = [1, 2, 3] >>> x.reverse() >>> x [3, 2, 1]
注意到reverse修改列表，但不返回任何值（与remove和sort等方法一样）。
提示 如果要按相反的顺序迭代序列，可使用函数reversed。这个函数不返回列表，而是返回一个迭代器.
>>> x = [1, 2, 3] >>> list(reversed(x)) [3, 2, 1]
方法sort用于对列表就地排序3。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。
>> x = [4, 6, 2, 1, 7, 9] >>> x.sort() >>> x [1, 2, 4, 6, 7, 9]
鉴于sort修改x且不返回任何值，最终的结果是x是经过排序的，而y包含None。为实现前述目标，正确的方式之一是先将y关联到x的副本，再对y进行排序，如下所示：
>>> x = [4, 6, 2, 1, 7, 9] >>> y = x.copy() >>> y.sort() >>> x [4, 6, 2, 1, 7, 9] >>> y [1, 2, 4, 6, 7, 9]
为获取排序后的列表的副本，另一种方式是使用函数sorted。
>>> x = [4, 6, 2, 1, 7, 9] >>> y = sorted(x) >>> x [4, 6, 2, 1, 7, 9] >>> y [1, 2, 4, 6, 7, 9]
实际上，这个函数可用于任何序列，但总是返回一个列表。(Sorted)
>>> sorted('Python') ['P', 'h', 'n', 'o', 't', 'y']
如果要将元素按相反的顺序排列，可先使用sort（或sorted），再调用方法reverse，也可使用参数reverse.
高级排序：
方法sort接受两个可选参数：key和reverse。这两个参数通常是按名称指定的，称为关键字参数。参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate'] >>> x.sort(key=len) >>> x ['add', 'acme', 'aerate', 'abalone', 'aardvark']
对于另一个关键字参数reverse，只需将其指定为一个真值（True或False)，以指出是否要按相反的顺序对列表进行排序。
>>> x = [4, 6, 2, 1, 7, 9] >>> x.sort(reverse=True) >>> x
[9, 7, 6, 4, 2, 1]
提示 如果你想更深入地了解排序，可以参阅文章“Sorting Mini-HOW TO”：https://wiki.python.org/moin/HowTo/Sorting。
元组：不可修改的序列
>>> 1, 2, 3
(1, 2, 3)
如你所见，元组还可用圆括号括起（这也是通常采用的做法）。
>>> (1, 2, 3)
(1, 2, 3)
空元组用两个不包含任何内容的圆括号表示。
你可能会问，如何表示只包含一个值的元组呢？这有点特殊：虽然只有一个值，也必须在它后面加上逗号。
>>> 42 42 >>> 42, (42,) >>> (42,) (42,)
你可能意识到了，元组并不太复杂，而且除创建和访问其元素外，可对元组执行的操作不多。元组的创建及其元素的访问方式与其他序列相同。
>>> x = 1, 2, 3 >>> x[1] 2 >>> x[0:2] (1, 2)
元组的切片也是元组，就像列表的切片也是列表一样。为何要熟悉元组呢？原因有以下两个。
- 它们用作映射中的键（以及集合的成员），而列表不行。
- 有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的
index和count等方法时例外）。
字符串基本操作
前面说过，所有标准序列操作（索引、切片、乘法、成员资格检查、长度、最小值和最大值）都适用于字符串，但别忘了字符串是不可变的，因此所有的元素赋值和切片赋值都是非法的。
>>> website = 'http://www.python.org' >>> website[-3:] = 'com' Traceback (most recent call last): File "<pyshell#19>", line 1, in ? website[-3:] = 'com' TypeError: object doesn't support slice assignment
设置字符串的格式：
将值转换为字符串并设置其格式是一个重要的操作，需要考虑众多不同的需求，因此随着时间的流逝，Python提供了多种字符串格式设置方法。以前，主要的解决方案是使用字符串格式设置运算符——百分号。这个运算符的行为类似于C语言中的经典函数printf：在%左边指定一个字符串（格式字符串），并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典，其中最常见的是元组。
>>> format = "Hello, %s. %s enough for ya?" >>> values = ('world', 'Hot') >>> format % values 'Hello, world. Hot enough for ya?'
上述格式字符串中的%s称为转换说明符，指出了要将值插入什么地方。s意味着将值视为字符串进行格式设置。如果指定的值不是字符串，将使用str将其转换为字符串。其他说明符将导致其他形式的转换。例如，%.3f将值的格式设置为包含3位小数的浮点数。
这种格式设置方法现在依然管用，且依然活跃在众多代码中，因此你很可能遇到。可能遇到的另一种解决方案是所谓的模板字符串。它使用类似于UNIX shell的语法，旨在简化基本的格式设置机制，如下所示：
>>> from string import Template >>> tmpl = Template("Hello, $who! $what enough for ya?") >>> tmpl.substitute(who="Mars", what="Dusty") 'Hello, Mars! Dusty enough for ya?'
编写新代码时，应选择使用字符串方法format，它融合并强化了早期方法的优点。使用这种方法时，每个替换字段都用花括号括起，其中可能包含名称，还可能包含有关如何对相应的值进行转换和格式设置的信息。
在最简单的情况下，替换字段没有名称或将索引用作名称
>>> "{}, {} and {}".format("first", "second", "third") 'first, second and third' >>> "{0}, {1} and {2}".format("first", "second", "third") 'first, second and third'
然而，索引无需像上面这样按顺序排列。
>>> "{3} {0} {2} {1} {3} {0}".format("be", "not", "or", "to") 'to be or not to be'
命名字段的工作原理与你预期的完全相同。
>>> from math import pi >>> "{name} is approximately {value:.2f}.".format(value=pi, name="π") 'π is approximately 3.14.'
当然，关键字参数的排列顺序无关紧要。在这里，我还指定了格式说明符.2f，并使用冒号将其与字段名隔开。它意味着要使用包含2位小数的浮点数格式。如果没有指定.2f，结果将如下：
>>> "{name} is approximately {value}.".format(value=pi, name="π") 'π is approximately 3.141592653589793.'
最后，在Python 3.6中，如果变量与替换字段同名，还可使用一种简写。在这种情况下，可使用f字符串——在字符串前面加上f。
>>> from math import e >>> f"Euler's constant is roughly {e}." "Euler's constant is roughly 2.718281828459045."
在这里，创建最终的字符串时，将把替换字段e替换为变量e的值。这与下面这个更明确一些的表达式等价：
>>> "Euler's constant is roughly {e}.".format(e=e) "Euler's constant is roughly 2.718281828459045."
在格式字符串中，最激动人心的部分为替换字段。替换字段由如下部分组成，其中每个部分都是可选的。
- 字段名：索引或标识符，指出要设置哪个值的格式并使用结果来替换该字段。除指定值外，还可指定值的特定部分，如列表的元素。
- 转换标志：跟在叹号后面的单个字符。当前支持的字符包括
r（表示repr）、s（表示str）和a（表示ascii）。如果你指定了转换标志，将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。 - 格式说明符：跟在冒号后面的表达式（这种表达式是使用微型格式指定语言表示的）。格式说明符让我们能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。
替换字段名
在最简单的情况下，只需向format提供要设置其格式的未命名参数，并在格式字符串中使用未命名字段。此时，将按顺序将字段和参数配对。你还可给参数指定名称，这种参数将被用于相应的替换字段中。你可混合使用这两种方法。
还可通过索引来指定要在哪个字段中使用相应的未命名参数，这样可不按顺序使用未命名参数。
>>> "{foo} {1} {bar} {0}".format(1, 2, bar=4, foo=3) '3 2 4 1'
然而，不能同时使用手工编号和自动编号，因为这样很快会变得混乱不堪。
你并非只能使用提供的值本身，而是可访问其组成部分（就像在常规Python代码中一样），如下所示：
>>> fullname = ["Alfred", "Smoketoomuch"] >>> "Mr {name[1]}".format(name=fullname) 'Mr Smoketoomuch' >>> import math >>> tmpl = "The {mod.__name__} module defines the value {mod.pi} for π" >>> tmpl.format(mod=math) 'The math module defines the value 3.141592653589793 for π'
如你所见，可使用索引，还可使用句点表示法来访问导入的模块中的方法、属性、变量和函数（看起来很怪异的变量__name__包含指定模块的名称）。
基本转换
指定要在字段中包含的值后，就可添加有关如何设置其格式的指令了。首先，可以提供一个转换标志。
>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π")) π 'π' '\u03c0'
上述三个标志（s、r和a）指定分别使用str、repr和ascii进行转换。函数str通常创建外观普通的字符串版本（这里没有对输入字符串做任何处理）。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量）。函数ascii创建只包含ASCII字符的表示，类似于Python 2中的repr。
你还可指定要转换的值是哪种类型，更准确地说，是要将其视为哪种类型。例如，你可能提供一个整数，但将其作为小数进行处理。为此可在格式说明（即冒号后面）使用字符f（表示定点数）。
>>> "The number is {num}".format(num=42) 'The number is 42' >>> "The number is {num:f}".format(num=42) 'The number is 42.000000'
你也可以将其作为二进制数进行处理。
>>> "The number is {num:b}".format(num=42) 'The number is 101010'
这样的类型说明符有多个，完整的清单如下：
字符串格式设置中的类型说明符
|
类型 |
含义 |
|---|---|
|
|
将整数表示为二进制数 |
|
|
将整数解读为Unicode码点 |
|
|
将整数视为十进制数进行处理，这是整数默认使用的说明符 |
|
|
使用科学表示法来表示小数（用 |
|
|
与 |
|
|
将小数表示为定点数 |
将其为哪种类型。例如，你可能提供一个整数，但将其作为小数进行处理。为此可在格式说明（即冒号后面）使（表示点
|
|
与 |
|
|
自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数 |
|
|
与 |
|
|
与 |
|
|
将整数表示为八进制数 |
|
|
保持字符串的格式不变，这是默认用于字符串的说明符 |
|
|
将整数表示为十六进制数并使用小写字母 |
|
|
与 |
|
|
将数表示为百分比值（乘以100，按说明符 |
宽度、精度和千位分隔符
设置浮点数（或其他更具体的小数类型）的格式时，默认在小数点后面显示6位小数，并根据需要设置字段的宽度，而不进行任何形式的填充。当然，这种默认设置可能不是你想要的，在这种情况下，可根据需要在格式说明中指定宽度和精度。
宽度是使用整数指定的，如下所示：
>>> "{num:10}".format(num=3) ' 3' >>> "{name:10}".format(name="Bob") 'Bob '
如你所见，数和字符串的对齐方式不同。
精度也是使用整数指定的，但需要在它前面加上一个表示小数点的句点。
>>> "Pi day is {pi:.2f}".format(pi=pi) 'Pi day is 3.14'
当然，可同时指定宽度和精度：
>>> "{pi:10.2f}".format(pi=pi) ' 3.14'
实际上，对于其他类型也可指定精度，但是这样做的情形不太常见。
>>> "{:.5}".format("Guido van Rossum") 'Guido'
最后，可使用逗号来指出你要添加千位分隔符。
>>> 'One googol is {:,}'.format(10**100) 'One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00 0,000,000,000,000,000,000,000,000,000,000,000,000,000,000'
同时指定其他格式设置元素时，这个逗号应放在宽度和表示精度的句点之间。
符号、对齐和用0填充
有很多用于设置数字格式的机制，比如便于打印整齐的表格。在大多数情况下，只需指定宽度和精度，但包含负数后，原本漂亮的输出可能不再漂亮。另外，正如你已看到的，字符串和数的默认对齐方式不同。在一栏中同时包含字符串和数时，你可能想修改默认对齐方式。在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。
>>> '{:010.2f}'.format(pi) '0000003.14'
要指定左对齐、右对齐和居中，可分别使用<、>和^。
>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi)) 3.14 3.14 3.14
可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。
>>> "{:$^15}".format(" WIN BIG ") '$$$ WIN BIG $$$'
如果要给正数加上符号，可使用说明符+（将其放在对齐说明符后面），而不是默认的-。如果将符号说明符指定为空格，会在正数前面加上空格而不是+。
>>> print('{0:-.2}\n{1:-.2}'.format(pi, -pi)) #默认设置 3.1 -3.1 >>> print('{0:+.2}\n{1:+.2}'.format(pi, -pi)) +3.1 -3.1 >>> print('{0: .2}\n{1: .2}'.format(pi, -pi)) 3.1 -3.1
需要介绍的最后一个要素是井号（#）选项，你可将其放在符号说明符和宽度之间（如果指定了这两种设置）。这个选项将触发另一种转换方式，转换细节随类型而异。例如，对于二进制、八进制和十六进制转换，将加上一个前缀。
“{索引或变量参数：指定长度或指定说明符 ，(此处的逗号是千分符) .3f (指定数值的精度）}”.format(pi = pi)
>>> "{:b}".format(42) '101010' >>> "{:#b}".format(42) '0b101010'
对于各种十进制数，它要求必须包含小数点（对于类型g，它保留小数点后面的零）。
>>> "{:g}".format(42) '42' >>> "{:#g}".format(42) '42.0000'
示例：
# 根据指定的宽度打印格式良好的价格列表 width = int(input('Please enter width: ')) price_width = 10 item_width = width - price_width header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width) fmt = '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width) 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)
这个程序的运行情况类似于下面这样：
Please enter width: 35 =================================== Item Price ----------------------------------- Apples 0.40 Pears 0.50 Cantaloupes 1.92 Dried Apricots (16 oz.) 8.00 Prunes (4 lbs.) 12.00 ===================================
常用字符串方法：
模块string未死
虽然字符串方法完全盖住了模块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字符串。
方法：center
方法center通过在两边添加填充字符（默认为空格）让字符串居中。
>>> "The Middle by Jimmy Eat World".center(39) ' The Middle by Jimmy Eat World ' >>> "The Middle by Jimmy Eat World".center(39, "*") '*****The Middle by Jimmy Eat World*****'
方法：find
方法find在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回-1。
>>> 'With a moo-moo here, and a moo-moo there'.find('moo') 7 >>> title = "Monty Python's Flying Circus" >>> title.find('Monty') 0 >>> title.find('Python') 6 >>> title.find('Flying') 15 >>> title.find('Zirquss') -1
在前面我们有提到在垃圾邮件过滤器中检查主题是否包含'$$$'。这种检查也可使用find来执行。（在Python 2.3之前的版本中，这种做法也管用，但in只能用于检查单个字符是否包含在字符串中。）
>>> subject = '$$$ Get rich now!!! $$$' >>> subject.find('$$$') 0
注意 字符串方法find返回的并非布尔值。如果find像这样返回0，就意味着它在索引0处找到了指定的子串。
你还可指定搜索的起点和终点（它们都是可选的）。
没有指定起点就找第一个出现的；
指定起点的默认就也指定了终点且不会忽略最后一个元素；
即指定起点又指定终点的将会忽略掉最后一个元素（解决方法：终点+1即可），且直接以最后面识别到的为最终位置。
>>> subject = '$$$ Get rich now!!! $$$' >>> subject.find('$$$') 0 >>> subject.find('$$$', 1) # 只指定了起点 20 >>> subject.find('!!!') 16 >>> subject.find('!!!', 0, 16) # 同时指定了起点和终点 -1
请注意，起点和终点值（第二个和第三个参数）指定的搜索范围包含起点，但不包含终点。这是Python惯常的做法。
join
join是一个非常重要的字符串方法，其作用与split相反，用于合并序列的元素。
>>> seq = [1, 2, 3, 4, 5] >>> sep = '+' >>> sep.join(seq) # 尝试合并一个数字列表 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: sequence item 0: expected string, int found >>> seq = ['1', '2', '3', '4', '5'] >>> sep.join(seq) # 合并一个字符串列表 '1+2+3+4+5' >>> dirs = '', 'usr', 'bin', 'env' >>> ''.join(dirs) ' usrbinenv' >>> print('C:' + '\\'.join(dirs)) C:\\usr\\bin\\env
lower
方法lower返回字符串的小写版本。
>>> 'Trondheim Hammer Dance'.lower() 'trondheim hammer dance'
在你编写代码时，如果不想区分字符串的大小写（即忽略大小写的差别），这将很有用。例如，假设你要检查列表中是否包含指定的用户名。如果列表包含字符串'gumby'，而指定的用户名为'Gumby'，你将找不到它。
>>> if 'Gumby' in ['gumby', 'smith', 'jones']: print('Found it!') ... >>>
当然，如果列表包含'Gumby'，而指定的用户名为'gumby'或'GUMBY'，结果同样找不到。对于这种问题，一种解决方案是在存储和搜索时，将所有的用户名都转换为小写。这样做的代码类似于下面这样：
>>> name = 'Gumby' >>> names = ['gumby', 'smith', 'jones'] >>> if name.lower() in names: print('Found it!') ... Found it! >>>
词首大写
一个与lower相关的方法是title.它将字符串转换为词首大写，即所有单词的首字母都大写，其他字母都小写。然而，它确定单词边界的方式可能导致结果不合理。
>>> "that's all folks".title() "That'S All, Folks"
另一种方法是使用模块string中的函数capwords。
>>> import string >>> string.capwords("that's all, folks") That's All, Folks"
replace
方法replace将指定子串都替换为另一个字符串，并返回替换后的结果。
>>> 'This is a test'.replace('is', 'eez') 'Theez eez a test'
如果你使用过字处理程序的“查找并替换”功能，一定知道这个方法很有用。
split
split是一个非常重要的字符串方法，其作用与join相反，用于将字符串拆分为序列。
'1+2+3+4+5'.split('+') ['1', '2', '3', '4', '5'] >>> 'Using the default'.split() ['Using', 'the', 'default']
注意，如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。
strip
方法strip将字符串开头和末尾的空白（但不包括中间的空白）删除，并返回删除后的结果。
>>> ' internal whitespace is kept '.strip() 'internal whitespace is kept'
与lower一样，需要将输入与存储的值进行比较时，strip很有用。回到前面介绍lower时使用的用户名示例，并假定用户输入用户名时不小心在末尾加上了一个空格。
>>> names = ['gumby', 'smith', 'jones'] >>> name = 'gumby ' >>> if name in names: print('Found it!') ... >>> if name.strip() in names: print('Found it!') ... Found it! >>>
你还可在一个字符串参数中指定要删除哪些字符。
>>> '*** SPAM for everyone!!! ***'.strip(' *!') 'SPAM for everyone'
这个方法只删除开头或末尾的指定字符，因此中间的星号未被删除。
lstrip、rstrip
translate
方法translate与replace一样替换字符串的特定部分，但不同的是它只能进行单字符替换。这个方法的优势在于能够同时替换多个字符，因此效率比replace高。
这个方法的用途很多（如替换换行符或其他随平台而异的特殊字符），但这里只介绍一个比较简单（也有点傻）的示例。假设你要将一段英语文本转换为带有德国口音的版本，为此必须将字符c和s分别替换为k和z。
然而，使用translate前必须创建一个转换表。这个转换表指出了不同Unicode码点之间的转换关系。要创建转换表，可对字符串类型str调用方法maketrans，这个方法接受两个参数：两个长度相同的字符串，它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字符3。就这个简单的示例而言，代码类似于下面这样：
>>> table = str.maketrans('cs', 'kz')
如果愿意，可查看转换表的内容，但你看到的只是Unicode码点之间的映射。
>>> table
{115: 122, 99: 107}
创建转换表后，就可将其用作方法translate的参数。
>> 'this is an incredible test'.translate(table) 'thiz iz an inkredible tezt'
调用方法maketrans时，还可提供可选的第三个参数，指定要将哪些字母删除。例如，要模仿语速极快的德国口音，可将所有的空格都删除。
>>> table = str.maketrans('cs', 'kz', ' ') >>> 'this is an incredible test'.translate(table) 'thizizaninkredibletezt'
判断字符串是否满足特定的条件
很多字符串方法都以is打头，如isspace、isdigit和isupper，它们判断字符串是否具有特定的性质（如包含的字符全为空白、数字或大写）。如果字符串具备特定的性质，这些方法就返回True，否则返回False。
(isalnum、isalpha、isdecimal、isdigit、isidentifier、islower、isnumeric、isprintable、isspace、istitle、isupper)
方法center通过在两边添加填充字符（默认为空格）让字符串居中。法center通过在两边添加填充字符（默认为空格）让字符串居中。一样，元组也是序列，唯一的差别在于元组是不能修改的（你可能注意到了，字符串也不能修改）。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。
