Python 中的列表、字典和元组

列表

列表与字符串类似，也是一个序列，所不同的地方在于，字符串中的元素是字符，列表中的元素可以是任意类型，并且可以嵌套，例如，字典、元组、列表、字符串、数值类型都可以作为列表的元素。

创建列表

最简单的方式就是使用 [] 创建列表：

>>> l = []
>>> l
[]
>>> l = ['str', 2.0, 5, [10, 20]]
>>> l
['str', 2.0, 5, [10, 20]]

遍历列表

遍历一个列表元素最常见的方法，就是使用 for 循环：

>>> for i in l:
...     print(i)
str
2.0
5
[10, 20]

修改列表

列表是可变的，因此可以任意修改列表中的元素，修改的方法可以直接通过下标修改：

>>> l[1] = 10
>>> l
['str', 10, 5, [10, 20]]

还可以通过列表切片的方式修改：

>>> l[1:3] = 1, 2
>>> l
['str', 1, 2, [10, 20]]

需要注意的是，切片操作的第二个下标是不包含在内的。

添加列表元素

使用 append 方法在列表尾部添加元素：

>>> l.append('new')
>>> l
['str', 1, 2, [10, 20], 'new']

使用 extend 添加整个列表，extend 方法接收一个列表作为参数，并将其所有元素添加到原列表后面：

>>> l1 = [4, 5]
>>> l.extend(l1)
>>> l
['str', 1, 2, [10, 20], 'new', 4, 5]

同样可以通过切片操作添加列表元素：

>>> l[len(l):] = 'new2'
>>> l
['str', 1, 2, [10, 20], 'new', 4, 5, 'n', 'e', 'w', '2']

len(l) 计算列表的长度，同时没有指定切片操作第二个下标，表示将新元素全部添加到列表之后。

注意，使用切片操作添加或修改列表元素，如果元素长度超出了切片指定的下标长度，则会按照元素长度修改列表：

>>> l
['l', 'i', 's', 't']
>>> l[4:5] = 1, 2
>>> l
['l', 'i', 's', 't', 1, 2]
>>> l[0:1] = 2, 4, 6
>>> l
[2, 4, 6, 'i', 's', 't', 1, 2]

删除列表元素

如果知道元素的下标，可以使用 pop 方法删除：

>>> l.pop()
'2'
>>> l.pop(0)

不指定 pop 方法的参数的话，表示删除最后一个元素，同时 pop 可以返回删除的值。

del 方法同样可以删除元素，但是没有返回值：

>>> del l[2]
>>> l
[1, 2, 'new', 4, 5, 'n', 'e', 'w']

如果不知道要删除元素的下标，可以使用 remove 删除该元素：

>>> l
[2, 'new', 4, 5, 'n', 'e', 'w', 2]
>>> l.remove(2)
>>> l
['new', 4, 5, 'n', 'e', 'w', 2]

可以看到，这个列表中有两个 2，但是 remove 方法只删除了第一个 2，表示 remove 方法只会删除列表中第一个符合的元素就立即返回。

如果要删除多个元素，可以使用 del 和切片操作：

>>> del l[4:]
>>> l
['new', 4, 5, 'n']

字符串和列表的相互转换

使用 list 函数将字符串转换为列表：

>>> s = 'list'
>>> l = list(s)
>>> l
['l', 'i', 's', 't']

list 函数会将字符串中的每一个字符作为一个列表元素。

如果字符串可以按照分隔符分割，可以使用字符串方法 split：

>>> s = 'this is a str'
>>> s.split()
['this', 'is', 'a', 'str']

split 方法默认使用空格作为分隔符，当然也可采用其他分隔符，如 ‘-‘、’,’ 等，直接作为参数传入 split 方法即可。

使用 join 方法连接字符串列表：

>>> t
['this', 'is', 'a', 'str']
>>> ''.join(t)  # 不使用分隔符
'thisisastr'
>>> ' '.join(t)  # 空格作为分隔符
'this is a str'

列表操作注意事项

1. 修改列表的方法可以通过 append、extend、切片操作完成；
2. 删除列表元素可以通过 pop 方法、del 函数、remove 方法完成；
3. 切片操作可以对原列表修改，也可复制一个列表；
4. ‘+’ 操作符会创建一个新的列表；
5. 大部分列表方法没有返回值，这一点与字符串方法不同；
6. 列表的很多操作可以通过多种方式完成，应该选定一个操作并坚持不变。

字典

字典中的元素是一个键值对。作为键必须使用不可变类型，如字符串、元组等，而作为值则可以使用任意类型。这是因为，字典是通过散列表的形式实现的，因此字典的键必须是可散列的，可变类型是不可散列的。

在 3.7 版本之前，Python 字典中的元素是无序的，在 3.7 版本中解决了这个问题，元素的顺序按照添加的顺序确定。

字典的操作

创建字典

可以直接通过 {} 操作符创建字典：

>>> dic = dict()
>>> dic
{}
>>> dic1 = {}
>>> dic1
{}

同样可以使用 in 操作符遍历字典，不同的是，无论字典多大，in 操作符所花费的时间都差不多，这是采用散列表实现的原因。字典的修改直接对相应的键赋值即可。

反转字典

顾名思义，反转字典就是要将字典的值作为键，而键作为值，在原来的字典中，由于键是唯一的，所以可能会出现有多个相同的值，这个时候需要一个列表来存储新的值。

def invert_dict(d):
    inverse = {}
    for key in d:
        val = d[key]
        if val not in inverse:
            inverse[val] = [key]
        else:
            inverse[val].append(key)
    return inverse

优化的斐波那契数列

传统的斐波那契数列当参数变的较大时，函数运行的时间非常长，分析函数调用图可以发现，很多值是被重复计算的，因此可以将已经计算过的值保存在字典中。

known = {0: 0, 1: 1}
def fibonacci(n):
    if n in known:
        return known[n]
    else:
        res = fibonacci(n - 1) + fibonacci(n - 2)
        known[n] = res
        return res

使用字典作为备忘，可以使得程序的运行速度大大提高。

元组

作为另外一种内置类型，元组最大的特点就是不可变，元组和列表类似，可以通过下标索引。

创建元组

元组就是用 , 分割的一列值：

>>> t = 'a', 'b', 'c', 'd'  # 这种创建方法不常用，但是需要了解
>>> t
('a', 'b', 'c', 'd')

通常创建元组需要用括号括起来：

>>> t = ('a', 'b', 'c', 'd')

如果元组只包含一个元素，需要在元素后面加上逗号：

>>> t = 'a',
>>> t = ('a',)

还可以通过 tuple 函数创建：

>>> t = tuple()
>>> t
()
>>> t = tuple('tuple')
>>> t
('t', 'u', 'p', 'l', 'e')

不带参数会创建一个空的元组，如果参数是一个序列，结果就是一个包含序列的元素的元组。

除此之外，tuple 也支持切片操作，但不支持所有的修改操作。

元组赋值

Python 中交换两个变量的值非常轻松：

>>> a, b = b, a

一条语句即可完成交换，另外，语句的右边可以是任意类型的序列，例如想要拆分电子邮件地址：

>>> addr = 'monty@python.org'
>>> uname, domain = addr.split('@')
>>> uname
'monty'
>>> domain
'python.org'

参数的收集和分散

函数可以接收不定个数的参数，使用 * 操作符来收集参数：

def printall(*args):
    print (args)

* 会将所有的参数收集到一个元组中。

另外，如果有一个序列的值想将它们作为可变长参数传入到函数中，可以使用 * 操作符：

>>> t = (7, 3)
>>> divmod(*t)
(2, 1)

列表和元组

zip 函数可以接收多个序列，并返回一个元组列表，长度是序列中较短的一个，zip 是一种迭代器，可以使用 for 循环遍历，可以使用 zip 对象制作一个列表：

>>> list(zip('abc', '123'))
[('a', '1'), ('b', '2'), ('c', '3')]

如果需要遍历序列中的元素及其下标，可以使用 enumerate 函数：

>>> for index, element in enumerate('abc'):
...     print(index, element)
...
0 a
1 b
2 c

字典和元组

字典中的 items 方法返回元组序列，另外，使用 dict 和 zip 可以得到一个简洁的创建字典的方法：

>>> d = dict(zip('abc', range(3)))
>>> d
{'a': 0, 'b': 1, 'c': 2}