List 列表
序列在处理值的集合时非常有用。你可能有一个序列表示数据库中的一个人，第一个元素是他们的名字第二个元素是他们的年龄。如果写成列表(列表中的项目用逗号分隔，并用方括号括起来)，则会看起来像这样：
>>> edward = ['Edward Gumby', 42]
但是序列也可以包含其他序列，所以你可以列出这些人的列表
>>> edward = ['Edward Gumby', 42]
>>> john = ['John Smith', 50]
>>> database = [edward, john]
>>> database
[['Edward Gumby', 42], ['John Smith', 50]]
序列的操作
对于所有序列类型，您都可以做某些事情。这些操作包括索(indexing)、切片(slicing)、添加(adding)、倍增(multiplying)和检查成员关系。此外，Python还有用于查找的内置函数序列的长度，以及寻找它的最大和最小元素。
Indexing
序列中的所有元素都是被编号的——从零开始向上。您可以使用a单独访问它们数，例如:
>>> greeting = 'Hello'
>>> greeting[0]
'H
这叫做索引。使用索引来获取元素。所有序列都可以用这种方式建立索引。当使用一个负索引时，Python从右边计数，也就是从最后一个元素计数。最后一个元素位于-1位置
>>> 'Hello'[1]
'e
Listing 2-1 包含一个示例程序，它询问您一年、一个月(数字从1到12)和一天(1到31)，然后打印出日期和正确的月份名称，以此类推。
# Print out a date, given year, month, and day as numbers
months = [
'January',
'February',
'March',
'April',
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December'
]
# A list with one ending for each number from 1 to 31
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \
+ ['st', 'nd', 'rd'] + 7 * ['th'] \
+ ['st']
year = input('Year: ')
month = input('Month (1-12): ')
day = input('Day (1-31): ')
month_number = int(month)
day_number = int(day)
# Remember to subtract 1 from month and day to get a correct index
month_name = months[month_number-1]
ordinal = day + endings[day_number-1]
print(month_name + ' ' + ordinal + ', ' + year)
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，元素11并不存在，但位于您想要的最后一个元素之后的第一步。明白了吗?如果你想从末尾开始计数，你可以使用负指标。
>>> numbers[-3:-1]
[8, 9]
但是，您似乎不能以这种方式访问最后一个元素。使用0作为元素“一步”怎么样
>>> numbers[-3:0]
[]
这并不是我们想要的结果。实际上，当片中最左的索引出现在序列的后面时与第二个相比(在本例中，倒数第三个比第一个晚)，结果总是空的序列。幸运的是，您可以使用一个快捷方式:如果slice继续到序列的末尾，您可以简单地使用省略最后一个索引。
>>> numbers[-3:]
[8, 9, 10]
>>> numbers[:3]
[1, 2, 3]
事实上，如果你想复制整个序列，你可以把两个下标都去掉。
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Longer Steps
切片时，可以(显式或隐式)指定切片的起始点和结束点。另一个参数,它通常是隐式的，就是步长。在规则切片中，步长为1，意味着slice从一个元素“移动”到下一个元素，返回开始和结束之间的所有元素。
>>> 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]
您仍然可以使用前面提到的快捷方式。例如，如果你想要a的每四个元素
>>> numbers[::4]
[1, 5, 9]
当然，步长不可能是零——这不会有任何结果——但它可以是负的，也就是说从右到左提取元素。
>>> 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做了“正确的事情”——对于正步长，它从开始到结束，对于一个负步长，它从结束到开始。
Adding Sequences
序列可以用加法(plus)操作符连接起来。
Multiplication
一个序列乘以一个数字x会创建一个新的序列，其中原始序列重复x次:
>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
None, Empty Lists, and Initialization
空列表被简单地写成两个方括号([])—里面什么都没有。如果你想要房间的清单对于10个没有任何用处的元素，可以像以前一样使用[42]*10，或者可能更实际一些[0]* 10。现在，您有了一个包含10个0的列表。但是，有时候，你会想要一个值意思是“没有”，就像“我们这里还没有放任何东西。”这时你就不用None了。None是Python值确切的意思是“这里什么也没有。因此，如果您想初始化长度为10的列表，您可以执行以下操作:
>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]
Listing 2-3包含一个程序，它(在屏幕上)打印一个由字符组成的“框”，该“框”居中在屏幕上显示，并与用户提供的句子大小相适应。代码可能看起来很复杂，但它基本上只是一种算术——计算出你需要多少空格、破折号等等，以便位置正确的事情
# Prints a sentence in a centered "box" of correct width
sentence = input("Sentence: ")
screen_width = 80
text_width = len(sentence)
box_width = text_width + 6
left_margin = (screen_width - box_width) // 2
print()
print(' ' * left_margin + '+' + '-' * (box_width-2) + '+')
print(' ' * left_margin + '| ' + ' ' * text_width + ' |')
print(' ' * left_margin + '| ' + sentence + ' |')
print(' ' * left_margin + '| ' + ' ' * text_width + ' |')
print(' ' * left_margin + '+' + '-' * (box_width-2) + '+')
print()
Membership
要检查序列中是否可以找到值，可以使用in操作符。这个操作符有点不同从目前为止讨论的(如乘法或加法)。它检查某件事是否真实返回相应的值:真对真，假对假。这样的运算符称为布尔运算符，真值叫做布尔值。有关布尔表达式的更多信息。
下面是一些使用in操作符的例子:
>>> 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
前两个示例使用成员资格测试来检查是否分别找到“w”和“x”在字符串权限。这可以是UNIX机器上检查编写和执行的脚本文件的权限。下一个示例检查是否在用户列表中找到提供的用户名(mlh)。如果您的程序强制执行某些安全策略，这可能非常有用。(在这种情况下，你可能会想要使用密码。)最后一个示例检查字符串主题是否包含字符串'$$$'。例如，它可以用作垃圾邮件过滤器的一部分。
Length, Minimum, and Maximum
内置函数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
Lists: Python’s Workhorse (列表:Python的主力)
在前面的示例中，我使用了很多列表。您已经看到了它们是多么有用，但是本节讨论的是列表与元组和字符串的不同之处在于:列表是可更改的——也就是说，您可以更改它们它们有许多有用的专门方法。
The list Function
因为字符串不能像列表那样被修改，所以有时候从a中创建一个列表是很有用的字符串。您可以使用list函数来完成此操作。
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
注意，列表适用于所有类型的序列，而不仅仅是字符串。
基本的列表操作
您可以对列表执行所有标准序列操作，比如索引、切片、连接、和繁殖。但是列表的有趣之处在于它们是可以修改的。在本节中，您将看到更改列表的一些方法:项分配、项删除、切片分配和列表方法(注意，并非所有的列表方法实际上都更改了它们的列表。)
Changing Lists: Item Assignments
更改列表很容易。你只需要像第一章中解释的那样使用普通的赋值。然而,而不是写一些像x = 2这样的东西，您可以使用索引符号来指定一个特定的、现有的位置，例如x[1] = 2.
>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]
Deleting Elements
从列表中删除元素也很容易。您可以使用del语句。
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']
请注意塞西尔是如何完全消失的，列表的长度从5缩减到4。
Assigning to Slices
切片是一个非常强大的特性，而且可以为切片赋值这一事实使它更加强大。
>>> 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]
List Methods
方法是与某个对象紧密耦合的函数，该对象可以是列表、数字、字符串或其他对象。在通常，方法的调用是这样的:
object.method(arguments)
方法调用看起来就像函数调用，只不过对象放在方法名前面，带有一个点分离他们。(你会在第7章中得到更详细的方法解释。)列表有几种方法允许您检查或修改它们的内容。
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
extension方法允许您通过提供一个值序列来一次追加几个值想要追加。换句话说，原来的列表被另一个扩展了。
>>> 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的副本其次，它没有使用extend那么有效如果你想要的是这样的东西: >>> a = a + b
而且，这不是一个就地操作—它不会修改原始操作。延长的效果可以通过分配给切片，如下:
>>> 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]
remove方法用于删除第一次出现的值
>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
>>> x.remove('bee')
Traceback (innermost last):
File "<pyshell>", line 1, in ?
x.remove('bee')
ValueError: list.remove(x): x not in list
reverse方法反转列表中的元素。(我想，这并不奇怪。)
>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]
sort方法用于就地对列表进行排序。排序“在适当的地方”意味着改变原来的列表元素是按顺序排序的，而不是简单地返回列表的排序副本。
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]
您已经遇到了一些修改列表而不返回任何内容的方法，并且在大多数情况下这种行为是非常自然的(例如append)。但我想强调一下这个案例中的行为因为很多人都被它搞糊涂了。这种混淆通常发生在用户需要对列表的副本进行排序，而保留原始副本。一种直观的(但错误的)方法如下:
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = x.sort() # Don't do this!
>>> print(y)
None
因为sort修改x但不返回任何内容，所以最后得到的是一个已排序的x和一个不包含任何内容的y。一个
正确的做法是首先将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]
简单地将x赋值给y是行不通的，因为x和y都引用同一个列表。另一种方法获取一个列表的排序副本是使用排序函数。
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
这个函数实际上可以用于任何序列，但总是返回一个list
>>> sorted('Python')
['P', 'h', 'n', 'o', 't', 'y']
Advanced Sorting
sort方法接受两个可选参数:key和reverse。如果你想使用他们，你通常指定他们的名字(所谓的关键字参数;关键参数类似于cmp参数:你提供一个函数，它在排序过程中使用。但是，该函数不是直接用于确定一个元素是否比另一个元素小，而是用于为每个元素创建一个键，并根据这些键对元素进行排序。例如，如果你想根据长度对元素进行排序，你可以使用len作为键函数
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
另一个关键字参数，反向，只是一个真值(真或假;您将了解更多关于这些的信息表明是否应该反向排序的列表。
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]
元组:不变的序列（Tuples: Immutable Sequences）
元组是序列，就像列表一样。唯一的区别是元组不能更改。(正如你所见注意，字符串也是如此。)元组语法很简单——如果用逗号分隔一些值，您自动拥有一个元组。
>>> 1, 2, 3
(1, 2, 3)
如您所见，元组也可以(通常)括在括号中。
>>> (1, 2, 3)
(1, 2, 3)
空元组被写成两个不包含任何内容的括号。
>>> ()
()
因此，您可能想知道如何编写包含单个值的元组。这有点奇怪——你必须把它包括进去
逗号，尽管只有一个值。
>>> 42
42
>>> 42,
(42,)
>>> (42,)
(42,)
最后两个示例生成长度为1的元组，而第一个根本不是元组。逗号是至关重要的。简单地添加括号没有用:(42)与42完全相同。然而，一个孤独的逗号可以完全更改表达式的值
>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2,)
(42, 42, 42)
tuple函数的工作方式与list非常相似:它接受一个序列参数和将其转换为元组。如果参数已经是元组，则不加更改地返回。
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)
正如您可能已经收集到的那样，元组并不是非常复杂——并且实际上您可以使用它做的事情并不多
它们只是创建它们并访问它们的元素，这与其他序列的操作相同。
>>> x = 1, 2, 3
>>> x[1]
2
>>> x[0:2]
(1, 2)
元组的片也是元组，正如列表片本身也是列表一样。
您需要了解元组有两个重要的原因。
- 它们可以用作映射中的键(和集合的成员);列表不能用这个的方式。
- 它们由一些内置函数和方法返回，这意味着你必须处理它们。只要你不试图改变它们，就“处理”它们通常意味着将它们视为列表(除非您需要诸如之类的方法)索引和计数，元组没有)。
一般来说，列表可能足以满足您的排序需求。
参考：Beginning Python From Novice to Professional, 3rd Edition 第二章
扫一扫
145
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
