Python 列表

Python 列表、字典、元组

列表

相当于java中的list集合，列表 是由多个值组成的序列。在字符串中，每个值都是字符； 在列表中，值可以是任何数据类型。列表中的值称为 元素（element） ，有时也被称为 项（item） 。

列表的创建

最简单的方法是用方括号( [ 和 ] )将元素包括起来:

[10, 20, 30, 40]
['crunchy frog', 'ram bladder', 'lark vomit']

下面的列表包含一个字符串、一个浮点数、一个整数和另一个列表：

['spam', 2.0, 5, [10, 20]]

一个不包含元素的列表被称为空列表；你可以用空的方括号 [] 创建一个空列表。

>>> cheeses = ['Cheddar', 'Edam', 'Gouda']
>>> numbers = [42, 123]
>>> empty = []
>>> print(cheeses, numbers, empty)
['Cheddar', 'Edam', 'Gouda'] [42, 123] []

列表是可变的

和字符串不同的是，列表是可变的。当括号运算符出现在赋值语句的左边时，它就指向了列表中将被赋值的元素。

>>> numbers = [42, 123]
>>> numbers[1] = 5
>>> numbers
[42, 5]

in运算符在列表中同样可以使用。

>>> cheeses = ['Cheddar', 'Edam', 'Gouda']
>>> 'Edam' in cheeses
True
>>> 'Brie' in cheeses
False

遍历列表

最常用的遍历列表的方式是使用for循环。语法和字符串遍历类似：

for cheese in cheeses:
    print(cheese)

然而，如果你想要写入或者更新列表中的元素，你需要通过下标访问。一种常用的方法是结合内置函数 range 和 len ：

for i in range(len(numbers)):
    numbers[i] = numbers[i] * 2

对一个空列表执行for循环时，将不会执行循环的主体：

for x in []:
    print('This never happens.')

列表操作

+运算符拼接多个列表：

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = a + b
>>> c
[1, 2, 3, 4, 5, 6]

运算符 * 以给定次数的重复一个列表:

>>> [0] * 4
[0, 0, 0, 0]
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

列表切片

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> t[1:3]
['b', 'c']
>>> t[:4]
['a', 'b', 'c', 'd']
>>> t[3:]
['d', 'e', 'f']

如果你省略第一个索引，切片将从列表头开始。如果你省略第二个索引，切片将会到列表尾结束。 所以如果你两者都省略，切片就是整个列表的一个拷贝。

由于列表是可变的，通常在修改列表之前，对列表进行拷贝是很有用的。

切片运算符放在赋值语句的左边时，可以一次更新多个元素：

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> t[1:3] = ['x', 'y']
>>> t
['a', 'x', 'y', 'd', 'e', 'f']

列表方法

Python为列表提供了一些方法. 例如, append 添加一个新元素到列表的末端:

>>> t = ['a', 'b', 'c']
>>> t.append('d')
>>> t
['a', 'b', 'c', 'd']

extend将接受一个列表作为参数，并将其其中的所有元素添加至目标列表中：

>>> t1 = ['a', 'b', 'c']
>>> t2 = ['d', 'e']
>>> t1.extend(t2)
>>> t1
['a', 'b', 'c', 'd', 'e']

sort将列表中的元素从小到大进行排序

>>> t = ['d', 'c', 'e', 'b', 'a']
>>> t.sort()
>>> t
['a', 'b', 'c', 'd', 'e']

映射、筛选和归并

你可以这样使用循环，对列表中所有元素求和:

def add_all(t):
    total = 0
    for x in t:
        total += x
    return total

把一个列表中的元素加起来是一个很常用的操作， 所以Python将其设置为一个内建内置函数 sum ：

>>> t = [1, 2, 3]
>>> sum(t)
6

一个像这样的将一系列的元素合并成一个单一值的操作有时称为 归并（reduce） 。

有时，你在构建一个列表时还需要遍历另一个列表。 例如，下面的函数接受一个字符串列表作为参数，返回包含大写字符的新列表：

def capitalize_all(t):
    res = []
    for s in t:
        res.append(s.capitalize())
    return res

删除元素

使用 pop

>>> t = ['a', 'b', 'c']
>>> x = t.pop(1)
>>> t
['a', 'c']
>>> x
'b'

使用 del 运算符

>>> t = ['a', 'b', 'c']
>>> del t[1]
>>> t
['a', 'c']

如果你知道要删除的值（但是不知道其下标），你可以使用 remove

>>> t = ['a', 'b', 'c']
>>> t.remove('b')
>>> t
['a', 'c']

要移除多个元素，你可以结合切片索引使用 del ：

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> del t[1:5]
>>> t
['a', 'f']

列表和字符串

一个字符串是多个字符组成的序列，一个列表是多个值组成的序列。但是一个由字符组成的列表不同于字符串。可以使用 list 将一个字符串转换为字符的列表:

>>> s = 'spam'
>>> t = list(s)
>>> t
['s', 'p', 'a', 'm']

list函数将字符串分割成单独的字符。如果你想将一个字符串分割成一些单词，你可以使用 split 方法：

>>> s = 'pining for the fjords'
>>> t = s.split()
>>> t
['pining', 'for', 'the', 'fjords']

可以提高一个叫做 分隔符（delimiter） 的可选参数，指定什么字符作为单词之间的分界线。下面的例子使用连字符作为分隔符：

>>> s = 'spam-spam-spam'
>>> delimiter = '-'
>>> t = s.split(delimiter)
>>> t
['spam', 'spam', 'spam']

join的功能和 split 相反。它将一个字符串列表的元素拼接起来。join 是一个字符串方法，所以你需要在一个分隔符上调用它，并传入一个列表作为参数：

>>> t = ['pining', 'for', 'the', 'fjords']
>>> delimiter = ' '
>>> s = delimiter.join(t)
>>> s
'pining for the fjords'

在这个例子中，分隔符是一个空格，所以 join 在单词之间添加一个空格。如果不使用空格拼接字符串，你可以使用空字符串 '' 作为分隔符。

创建字符串的时候，如果字符串的内容是一样的，生成一个字符串对象，然后同时指向它。

但是当你创建两个列表时，你得到的是两个对象：

>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> a is b
False

在这个例子中，我们称这两个列表是 相等（equivalent） 的，因为它们有相同的元素。但它们并不 相同（identical） ，因为他们不是同一个对象。如果两个对象 相同 ，它们也是相等的，但是如果它们是相等的，它们不一定是相同的。

别名

如果 a 指向一个对象，然后你赋值 b = a ，那么两个变量指向同一个对象：

>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True

变量和对象之间的关联称为 引用（reference） 在这个例子中，有两个对同一个对象的引用。

如果一个对象有多于一个引用，那它也会有多个名称， 我们称这个对象是 有别名的（aliased） 。

如果一个有别名的对象是可变的，对其中一个别名（alias）的改变对影响到其它的别名：

>>> b[0] = 42
>>> a
[42, 2, 3]

个人理解：在这里指向的都是一样的，即所有的改变都会同步过去。

尽管这个行为很有用，但是容易导致出现错误。 通常，避免对于可变对象使用别名相对更安全

a和 b 是否指向同一个字符串基本上没有什么影响。

列表参数

当你将一个列表作为参数传给一个函数，函数将得到这个列表的一个引用。如果函数对这个列表进行了修改，会在调用者中有所体现。例如， delete_head 删除列表的第一个元素：

def delete_head(t):
    del t[0]
    
 
>>> letters = ['a', 'b', 'c']
>>> delete_head(letters)
>>> letters
['b', 'c']

需要注意的是修改列表操作和创建列表操作间的区别。 例如，append 方法是修改一个列表，而 + 运算符是创建一个新的列表

>>> t1 = [1, 2]
>>> t2 = t1.append(3)
>>> t1
[1, 2, 3]
>>> t2
None

append修改列表并返回None。

>>> t3 = t1 + [4]
>>> t1
[1, 2, 3]
>>> t3
[1, 2, 3, 4]
>>> t1

运算符 + 创建了一个新列表，而不改变原始的列表。

调试

粗心地使用列表（以及其他可变对象）会导致长时间的调试。 下面列举一些常见的陷阱以及避免它们的方法：

1. 大多数的列表方法会对参数进行修改，然后返回 None 。这和字符串方法相反，后者保留原始的字符串并返回一个新的字符串。

   如果你习惯这样写字符串代码：

   word = word.strip()
   

   那么你很可能会写出下面的列表代码：

   t = t.sort()           # 错误！
   

   因为 sort 返回 None ，所以你的下一个对 t 执行的操作很可能会失败。

   在使用 list 方法和操作符之前，你应该仔细阅读文档，然后在交互模式下测试。

2. 选择一种写法，坚持下去。

   列表的一个问题就是有太多方法可以做同样的事情。 例如，要删除列表中的一个元素，你可以使用 pop 、remove 、del 甚至是切片赋值。

   要添加一个元素，你可以使用 append 方法或者 + 运算符。假设 t 是一个列表，x 是一个列表元素，以下这些写法都是正确的：

   t.append(x)
   t = t + [x]
   t += [x]
   

   而这些是错误的：

   t.append([x])          # 应该是正确的！ 备注：实验下这个方法，笔者测试可以，结果会将[x]值直接存进去
   t = t.append(x)        # 错误！
   t + [x]                # 错误！
   t = t + x              # 错误！
   

   

   在交互模式下尝试每一个例子，保证你明白它们做了什么。 注意只有最后一个会导致运行时错误；其他的都是合乎规范的的，但结果却是错的。

3. 通过创建拷贝来避免别名.

   如果你要使用类似 sort 这样的方法来修改参数， 但同时有要保留原列表，你可以创建一个拷贝。

   >>> t = [3, 1, 2]
   >>> t2 = t[:] # 创建备份
   >>> t2.sort()  
   >>> t
   [3, 1, 2]
   >>> t2
   [1, 2, 3]
   

   在这个例子中，你还可以使用内置函数 sorted ，它将返回一个新的已排序的列表，原列表将保持不变。

   >>> t2 = sorted(t)
   >>> t
   [3, 1, 2]
   >>> t2
   [1, 2, 3]