第2章 列表和元组

1. 数据结构是以某种方式(如通过编号)组合起来的数据 元素(如数、字符乃至其他数据结构)集合。
2. Python中，最基本的数据结构为序列。
3. 0开始指出相对于序列 开头的偏移量。
4. 用负索引表示序列末尾元素的位置。

1. 对序列进行概述
2. 介绍一些适用于所有序列(包括列表和元组)的操作（note：这些操作也适用于字符串）
3. 介绍列表，
4. 介绍元组，元组是一种特殊的序列，类 似于列表，只是不能修改

Python内置了多种序列，列表、元组、字符串等。
列表和元组的主要不同在于：

1. 列表是可以修改的，适用于需要中途添加元素的情形
2. 元组不可以，适用于出于某种考虑需要禁止修改序列的情形

几乎在所有情况下都可使用列表来代替元组。一种例外情况是将元组用作 字典键，这将在第4章讨论。在这种情况下，不能使用列表来代替元组，因为字典键是不允许修改的。

Python支持一种数据结构的基本概念，名为容器(container)。主要的容器包含：

1. 序列，序列中， 每个元素都有编号
2. 映射，在映射中，每个元素都有名称(也叫键)

1. 索引、切片、相加、相乘和成员资格检查，适用于所有序列。
2. 一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。

1. 序列中的所有元素都有编号——从0开始递增，这称为索引(indexing)。
2. 可使用索引来获取元素。
3. 使用负数索引时，将从右(即从最后一个元素)开始往左数，因此-1是最后一个元素的位置。
4. 对于字符串字面量(以及其他的序列字面量)，可直接对其执行索引操作，无需先将其赋给变量。这与先赋给变量再对变量执行索引操作的效果是一样的。

>>> greeting = 'Hello'
>>> greeting[0] 
>'H'
>>> greeting[-1] 
>'o'
>>>"hello"[1]
>'e'

5. 如果函数调用返回一个序列，可直接对其执行索引操作。

fourth = input('Year: ')[3]

字符串就是由字符组成的序列。不同于其他一 些语言，Python没有专门用于表示字符的类型，因此一个字符就是只包含一个元素的字 符串。

1. 还可使用切片(slicing)来访问特定范围内的元素。为此， 可使用两个索引，并用冒号分隔.
2. 第一个索引是包含的第一 个元素的编号，但第二个索引是切片后余下的第一个元素的编号.
3. 第一个索引指定的元素包含在切片内， 但第二个索引指定的元素不包含在切片内

>>> tag = 'Python web site' 
>>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'

简写

>>> numbers[7:10] # 1）获取列表中的最后三个元素
>[8, 9, 10]
>>> numbers[-3:-1] # 2）如果要从列表末尾开始数，可使用负数索引
>[8, 9]
# 3）然而，这样好像无法包含最后一个元素，如果使用索引0呢？
>>> numbers[-3:0] 
>[]
# 4）这并不是想要的结果。执行切片操作时，如果第一个索引指定的元素位于第二个索引指定的元素后面，结果就为空序列。
# 5）一种简写:如果切片结束于序列末尾，可省略第二个索引。
>>> numbers[-3:] 
>[8, 9, 10]
# 6）同样，如果切片始于序列开头，可省略第一个索引
>>> numbers[:3] 
>[1, 2, 3]
# 7）实际上，要复制整个序列，可将两个索引都省略
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

更大的步长

# 1. 在普通切片中，步长默认为1。这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。
>>> numbers[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 2. 如果指定的步长大于1，将跳过一些元素。例如，步长为2时，将从起点和终点之间每隔一个元素提取一个元素。
>>> numbers[0:10:2] 
[1, 3, 5, 7, 9] 
>>> numbers[3:6:3]
[4]
# 3. 显式地指定步长时，也可使用前述简写。例如，要从序列中每隔3个元素提取1个，只需提供长4即可
>>> numbers[::4] 
[1, 5, 9]
# 4.步长不能为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]
# 5. 步长为负数时，第一个索引必须比第二个索引大.
# 6.  步长为负数时，省略起始和结束索引时，步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点。

可使用加法运算符来拼接序列。

>>> [1, 2, 3] + [4, 5, 6] 
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!' 
'Hello, world!'
>>> [1, 2, 3] + 'world!' 
Traceback (innermost last):
File "", 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]

1. 空列表是使用不包含任何内容的两个方括号([])表示的。
2. 如果要创建一个可包含10个元素的列表，但没有任何有用的内容，准确的做法是使用[0]*10， 这将创建一个包含10个零的列表。
3. 有些情况下，可能想使用表示“什么都没有”的值， 如表示还没有在列表中添加任何内容。在这种情况下，可使用None

>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

in
要检查特定的值是否包含在序列中，可使用运算符in。
满足时返回True， 不满足时返回False。

>>> permissions = 'rw' 12 >>> '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和min时指定的实参并不是序列，而直接将数作为实参
>>> max(2, 3)
3
>>> min(9, 3, 2, 5) 
2

不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。 为此，可使用函数list。

>>> list('Hello')
['H', 'e', 'l', 'l', 'o'] 

请注意，可将任何序列(而不仅仅是字符串)作为list的参数。

1. 可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘。
2. 列表的有趣之处在于它是可以修改的。介绍一些修改列表的方式:给元素赋值、删除元素、给切片赋值以及使用列表的方法。

#1. 修改列表:给元素赋值
>>> x 14
>>> x = [1, 1, 1] >>> x[1] = 2
[1, 2, 1]

#2. 删除元素,使用del语句。
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl'] >>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']
# 除用于删除列表元素外，del语句还 可用于删除其他东西。你可将其用于字典(参见第4章)乃至变量

# 3. 给切片赋值 切片是一项极其强大的功能，而能够给切片赋值让这项功能显得更加强大。
>>> 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]
#可采取相反的措施来删除切片。与del numbers[1:4]等效
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = [] 
>>> numbers
[1, 5]

列表包含多个可用来查看或修改其内容的方法。

#1. append 方法append用于将一个对象附加到列表末尾。
>>> lst = [1, 2, 3] 
>>> lst.append(4) 
>>> lst
[1, 2, 3, 4]
# 与其他几个类似的方法一样，append也就地修改列表。这意味着它不会返回修改后的新列表，而是直接修改旧列表。

#2. clear方法clear就地清空列表的内容
>>> lst = [1, 2, 3] 
>>> lst.clear()
>>> lst
[]
# 这类似于切片赋值语句lst[:] = []。

#3. copy 复制列表。
# 常规复制只是将另一个名称关联到列表
>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4 13 
>>>> 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。

# 4. count 方法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

# 5.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]

# 6. index 方法index在列表中查找指定值第一次出现的索引。
>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni'] 
>>> knights.index('who')
4
>>> knights.index('herring')
Traceback (innermost last):
File "", line 1, in ?
knights.index('herring')
ValueError: list.index(x): x not in list

# 7. 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媲美。

# 8. pop从列表中删除一个元素(末尾为最后一个元素)，并返回这一元素。
>>> x = [1, 2, 3]
>>> x.pop() 
3
>>> x
[1, 2]
>>> x.pop(0) 
1
>>> x 
[2]
# 使用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。有关这方面的详细信息，请参阅第10章。
# 注意 pop是唯一既修改列表又返回一个非None值的列表方法。


# 9. remove用于删除第一个为指定值的元素。
>>> x = ['to', 'be', 'or', 'not', 'to', 'be'] 
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
>>> x.remove('bee') 
Traceback (innermost last):
File "", line 1, in ? x.remove('bee')
ValueError: list.remove(x): x not in list
# remove是就地修改且不返回值的方法之一。不同于pop的是，它修改列表，但不返 回任何值。

# 10. reverse按相反的顺序排列列表中的元素。
>>> x = [1, 2, 3] 
>>> x.reverse() 
>>> x
[3, 2, 1]
# 注意到reverse修改列表，但不返回任何值(与remove和sort等方法一样)。

# 如果要按相反的顺序迭代序列，可使用函数reversed。这个函数不返回列表，而是返回一个迭代器(迭代器将在第9章详细介绍)。可使用list将返回的对象转换为列表。
>>> x = [1, 2, 3]
>>> list(reversed(x)) [3, 2, 1]

# 11. sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。
>>> x = [4, 6, 2, 1, 7, 9] 
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]

# 需要排序后的列表副本并保留原始列表不变时，通常会遭遇这种困惑。正确的方式之一是先将y关联到x的副本，再对y进行排序。只是将x赋给y是不可行的，因为这样x和y将指向同一个列表。需要使用 copy。
>>> 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('Python')
['P', 'h', 'n', 'o', 't', 'y']

# 12. 高级排序
# sort接受两个可选参数:key和reverse。这两个参数通常是按名称指定的，称为关键字 参数，将在第6章详细讨论。参数key类似于参数cmp:你将其设置为一个用于排序的函数。然而， 不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个 键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate'] >>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
# 对于另一个关键字参数reverse，只需将其指定为一个真值(True或False，将在第5章详细介 绍)，以指出是否要按相反的顺序对列表进行排序。
>>> x = [4, 6, 2, 1, 7, 9] 
>>> x.sort(reverse=True) 
>>> x
[9, 7, 6, 4, 2, 1]
# 函数sorted也接受参数key和reverse。在很多情况下，将参数key设置为一个自定义函数很有 用。第6章将介绍如何创建自定义函数。

元组是不能修改的(字符串也不能修改)。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。

>>> 1, 2, 3
(1, 2, 3)
>>> (1, 2, 3) 
(1, 2, 3)
>>> () 
()
# 如何表示只包含一个值的元组呢?
>>> 42 
42
>>> 42, 
(42,)
>>> （42）
42

函数tuple的工作原理与list很像:它将一个序列作为参数，并将其转换为元组 。如果参数已经是元组，就原封不动地返回它。

>>> tuple([1, 2, 3]) 
(1, 2, 3)
>>> tuple('abc') 
('a', 'b', 'c')
>>> tuple((1, 2, 3)) 
(1, 2, 3)

元组的创建及其元素的访问方式与其他序列相同。
元组的切片也是元组。为何要熟悉元组呢?原因有以下两个。

1. 它们用作映射中的键(以及集合的成员)，而列表不行。映射将在第4章详细介绍。
2. 有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们(需要使用元组没有的index和count 10 等方法时例外)
3. 一般而言，使用列表足以满足对序列的需求