第三部分-Python列表、元组和字典

Python列表、元组和字典

Python序列（列表list和元组tuple）用法完全攻略

创建列表和元组

创建列表和元组的语法也有点相似，区别只是创建列表使用方括号，创建元组使用圆括号，并在括号中列出元组的元素，元素之间以英文逗号隔开。

列表和元组切片

与前面介绍的字符串操作类似的是，列表和元组同样也可使用索引获取中间一段，这种用法被称为 slice（分片或切片）。slice 的完整语法格式如下：
[start : end : step]
start、end 两个索引值都可使用正数或负数，其中负数表示从倒数开始。
该语法表示从 start 索引的元素开始（包含），到 end 索引的元素结束（不包含）的所有元素，这和所有编程语言的约定类似。
step 表示步长，因此 step 使用负数没有意义。

加法

列表和元组支持加法运算，加法的和就是两个列表或元组所包含的元素的总和。

乘法

列表和元组可以和整数执行乘法运算，列表和元组乘法的意义就是把它们包含的元素重复 N 次（N 就是被乘的倍数）。

in 运算符

in 运算符用于判断列表或元组是否包含某个元素

a_tuple = ('crazyit' , 20, -1.2)
print(20 in a_tuple) # True
print(1.2 in a_tuple) # False
print('fkit' not in a_tuple) # True

长度、最大值和最小值

Python 提供了内置的 len()、max()、min() 全局函数来获取元组或列表的长度、最大值和最小值。

注：
由于 max()、min() 要对元组、列表中的元素比较大小，因此程序要求传给 max()、min() 函数的元组、列表的元素必须是相同类型且可以比较大小。

# 元素都是数值的元组
a_tuple = (20, 10, -2, 15.2, 102, 50)
# 计算最大值
print(max(a_tuple)) # 102
# 计算最小值
print(min(a_tuple)) # -2
# 计算长度
print(len(a_tuple)) # 6
# 元素都是字符串的列表
b_list = ['crazyit', 'fkit', 'Python', 'Kotlin']
# 计算最大值（依次比较每个字符的ASCII码值，先比较第一个字符，若相同，继续比较第二个字符，以此类推）
print(max(b_list)) # fkit（26个小写字母的ASCII码为97~122）
# 计算最小值
print(min(b_list)) # Kotlin （26个大写字母的ASCII码为65~90）
# 计算长度
print(len(b_list)) # 4

序列封包和序列解包

Python 还提供了序列封包（Sequence Packing）和序列解包（Sequence Unpacking）的功能。简单来说，Python 允许支持以下两种赋值方式：
程序把多个值赋给一个变量时，Python 会自动将多个值封装成元组。这种功能被称为序列封包。
程序允许将序列（元组或列表等）直接赋值给多个变量，此时序列的各元素会被依次赋值给每个变量（要求序列的元素个数和变量个数相等）。这种功能被称为序列解包。

# 序列封包：将10、20、30封装成元组后赋值给vals
vals = 10, 20, 30
print(vals) # (10, 20, 30)
print(type(vals)) # <class 'tuple'>
print(vals[1]) # 20

a_tuple = tuple(range(1, 10, 2))
# 序列解包: 将a_tuple元组的各元素依次赋值给a、b、c、d、e变量
a, b, c, d, e = a_tuple
print(a, b, c, d, e) # 1 3 5 7 9
a_list = ['fkit', 'crazyit']
# 序列解包: 将a_list序列的各元素依次赋值给a_str、b_str变量
a_str, b_str = a_list
print(a_str, b_str) # fkit crazyit

在序列解包时也可以只解出部分变量，剩下的依然使用列表变量保存。

first, second, *rest = range(10)
print(first) # 0
print(second) # 1
print(rest) # [2, 3, 4, 5, 6, 7, 8, 9]

first保存第一个元素，last保存最后一个元素，middle保存中间剩下的元素

first, *middle, last = range(10)
print(first) # 0
print(middle) # [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(last) # 9

Python list()和tuple()函数用法

list() 函数可用于将元组、区间（range）等对象转换为列表。
tuple() 函数可用于将列表、区间（range）等对象转换为元组。

Python list列表添加元素的3种方法

Python list 列表增加元素可调用列表的 append() 方法，该方法会把传入的参数追加到列表的最后面。

a_list = ['crazyit', 20, -2]
# 追加元素
a_list.append('fkit')
print(a_list) # ['crazyit', 20, -2, 'fkit']
a_tuple = (3.4, 5.6)
# 追加元组，元组被当成一个元素
a_list.append(a_tuple)
print(a_list) # ['crazyit', 20, -2, 'fkit', (3.4, 5.6)]
# 追加列表，列表被当成一个元素
a_list.append(['a', 'b'])
print(a_list) # ['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]

不将被追加的列表当成一个整体，而只是追加列表中的元素，则可使用列表的 extend() 方法。

b_list = ['a', 30]
# 追加元组中的所有元素
b_list.extend((-2, 3.1))
print(b_list) # ['a', 30, -2, 3.1]
# 追加列表中的所有元素
b_list.extend(['C', 'R', 'A'])
print(b_list) # ['a', 30, -2, 3.1, 'C', 'R', 'A']
# 追加区间中的所有元素
b_list.extend(range(97, 100))
print(b_list) # ['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

列表中间增加元素，则可使用列表的 insert() 方法，使用 insert() 方法时要指定将元素插入列表的哪个位置。

c_list = list(range(1, 6))
print(c_list) # [1, 2, 3, 4, 5]
# 在索引3处插入字符串
c_list.insert(3, 'CRAZY' )
print(c_list) # [1, 2, 3, 'CRAZY', 4, 5]
# 在索引3处插入元组，元组被当成一个元素
c_list.insert(3, tuple('crazy'))
print(c_list) # [1, 2, 3, ('c', 'r', 'a', 'z', 'y'), 'CRAZY', 4, 5]

Python list列表删除元素（3种方法）

删除列表元素使用 del 语句。del 语句是 Python 的一种语句，专门用于执行删除操作。

a_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']
# 删除第3个元素
del a_list[2]
print(a_list) # ['crazyit', 20, (3, 4), 'fkit']
# 删除第2个到第4个（不包含）元素
del a_list[1: 3]
print(a_list) # ['crazyit', 'fkit']
b_list = list(range(1, 10))
# 删除第3个到倒数第2个（不包含）元素，间隔为2
del b_list[2: -2: 2]
print(b_list) # [1, 2, 4, 6, 8, 9]
# 删除第3个到第5个（不包含）元素
del b_list[2: 4]
print(b_list) # [1, 2, 8, 9]

使用 del 语句不仅可以删除列表元素，也可以删除普通变量。

name = 'crazyit'
print(name) # crazyit
# 删除name变量
del name
#print(name) # NameError

除使用 del 语句之外，Python 还提供了 remove() 方法来删除列表元素，该方法并不是根据索引来删除元素的，而是根据元素本身来执行删除操作的。该方法只删除第一个找到的元素，如果找不到该元素，该方法将会引发 ValueError 错误。

c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
# 删除第一次找到的30
c_list.remove(30)
print(c_list) # [20, 'crazyit', -4, 'crazyit', 3.4]
# 删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list) # [20, -4, 'crazyit', 3.4]

列表clear() 方法，正如它的名字所暗示的，该方法用于清空列表的所有元素。

c_list.clear()
print(c_list) # []

Python list列表修改元素（入门必读）

列表的元素相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素。

a_list = [2, 4, -3.4, 'crazyit', 23]
# 对第3个元素赋值
a_list[2] = 'fkit'
print(a_list) # [2, 4, 'fkit', 'crazyit', 23]

程序也可通过 slice 语法对列表其中一部分赋值，在执行这个操作时并不要求新赋值的元素个数与原来的元素个数相等。

b_list = list(range(1, 5))
print(b_list)
# 将第2个到第4个（不包含）元素赋值为新列表的元素
b_list[1: 3] = ['a', 'b']
print(b_list) # [1, 'a', 'b', 4]

对列表中空的 slice 赋值，就变成了为列表插入元素。

b_list[2: 2] = ['x', 'y']
print(b_list) # [1, 'a', 'x', 'y', 'b', 4]

将列表其中一段赋值为空列表，就变成了从列表中删除元素。

b_list[2: 5] = []
print(b_list) # [1, 'a', 4]

使用字符串赋值，Python 会自动把字符串当成序列处理，其中每个字符都是一个元素。

b_list[1: 3] = 'Charlie'
print(b_list) # [1, 'C', 'h', 'a', 'r', 'l', 'i', 'e']

指定了 step 参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等。

c_list = list(range(1, 10))
# 指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
c_list[2: 9: 2] = ['a', 'b', 'c', 'd']
print(c_list) # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']

Python list常用方法（count、index、pop、reverse和sort）快速攻略

count()：用于统计列表中某个元素出现的次数。
index()：用于判断某个元素在列表中出现的位置。
pop()：用于将列表当成“栈”使用，实现元素出栈功能。
reverse()：用于将列表中的元素反向存放。
sort()：用于对列表元素排序。

count()用法

a_list = [2, 30, 'a', [5, 30], 30]
# 计算列表中30的出现次数
print(a_list.count(30)) # 2
# 计算列表中[5, 30]的出现次数
print(a_list.count([5, 30])) # 1

index()方法

则用于定位某个元素在列表中出现的位置，如果该元素没有出现，则会引发 ValueError 错误。在使用 index() 方法时还可传入 start、end 参数，用于在列表的指定范围内搜索元素。

a_list = [2, 30, 'a', 'b', 'crazyit', 30]
# 定位元素30的出现位置
print(a_list.index(30)) # 1
# 从索引2处开始、定位元素30的出现位置
print(a_list.index(30, 2)) # 5
# 从索引2处到索引4处之间定位元素30的出现位置，找不到该元素
print(a_list.index(30, 2, 4)) # ValueError

pop()用法

pop() 方法用于实现元素出栈功能。栈是一种特殊的数据结构，它可实现先入后出（FILO）功能，即先加入栈的元素，反而后出栈。

stack = []
# 向栈中“入栈”3个元素
stack.append("fkit")
stack.append("crazyit")
stack.append("Charlie")
print(stack) # ['fkit', 'crazyit', 'Charlie']
# 第一次出栈：最后入栈的元素被移出栈
print(stack.pop())
print(stack) # ['fkit', 'crazyit']
# 再次出栈
print(stack.pop())
print(stack) # ['fkit']

reverse()用法

reverse() 方法会将列表中所有元素的顺序反转。

a_list = list(range(1, 8))
# 将a_list列表元素反转
a_list.reverse()
print(a_list) # [7, 6, 5, 4, 3, 2, 1]

sort()用法

sort() 方法用于对列表元素进行排序。

a_list = [3, 4, -2, -30, 14, 9.3, 3.4]
# 对列表元素排序
a_list.sort()
print(a_list) #[-30, -2, 3, 3.4, 4, 9.3, 14]
b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
# 对列表元素排序：默认按字符串包含的字符的编码大小比较
b_list.sort()
print(b_list) # ['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift'

sort() 方法除支持默认排序之外，还可传入 key 和 reverse 两个参数，而且这两个参数必须通过参数名指定（这种参数叫关键字参数)
key 参数用于为每个元素都生成一个比较大小的“键”;
reverse 参数则用于执行是否需要反转排序，默认是从小到大排序；如果将该参数设为 True，将会改为从大到小排序。

# 指定key为len，指定使用len函数对集合元素生成比较的键，
# 也就是按字符串的长度比较大小
b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
b_list.sort(key=len)
print(b_list) # ['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']
# 指定反向排序
b_list.sort(key=len, reverse=True)
print(b_list) # ['Erlang', 'Kotlin', 'Python', 'Swift', 'Ruby', 'Go']

Python字典及基本操作（超级详细）

字典是 Python 提供的一种常用的数据结构，它用于存放具有映射关系的数据。
由于字典中的 key 是非常关键的数据，而且程序需要通过 key 来访问 value，因此字典中的 key 不允许重复。
程序既可使用花括号语法来创建字典，也可使用 dict() 函数来创建字典。实际上，dict 是一种类型，它就是 Python 中的字典类型。
在使用花括号语法创建字典时，花括号中应包含多个 key-value 对，key 与 value 之间用英文冒号隔开；多个 key-value 对之间用英文逗号隔开。

scores = {'语文': 89, '数学': 92, '英语': 93}
print(scores)
# 空的花括号代表空的dict
empty_dict = {}
print(empty_dict)
# 使用元组作为dict的key
dict2 = {(20, 30):'good', 30:'bad'}
print(dict2)

注：

元组可以作为 dict 的 key，但列表不能作为字典的 key。这是由于 dict 要求 key 必须是不可变类型，但列表是可变类型，因此列表不能作为字典的 key。

在使用 dict() 函数创建字典时，可以传入多个列表或元组参数作为 key-value 对，每个列表或元组将被当成一个 key-value 对，因此这些列表或元组都只能包含两个元素。

vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
# 创建包含3组key-value对的字典
dict3 = dict(vegetables)
print(dict3) # {'celery': 1.58, 'brocoli': 1.29, 'lettuce': 2.19}
cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]
# 创建包含3组key-value对的字典
dict4 = dict(cars)
print(dict4) # {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}

还可通过为 dict 指定关键字参数创建字典，此时字典的 key 不允许使用表达式。

# 使用关键字参数来创建字典
dict6 = dict(spinach = 1.39, cabbage = 2.59)
print(dict6) # {'spinach': 1.39, 'cabbage': 2.59}

字典的基本用法

应牢记字典包含多个 key-value 对，而 key 是字典的关键数据，因此程序对字典的操作都是基于 key 的。基本操作如下：
通过 key 访问 value 。
通过 key 添加 key-value 对。
通过 key 删除 key-value 对。
通过 key 修改 key-value 对。
通过 key 判断指定 key-value 对是否存在。
通过 key 访问 value 使用的也是方括号语法，就像前面介绍的列表和元组一样，只是此时在方括号中放的是 key，而不是列表或元组中的索引。

通过 key 访问 value

scores = {'语文': 89}
# 通过key访问value
print(scores['语文'])

为 dict 添加 key-value 对，只需为不存在的 key 赋值

# 对不存在的key赋值，就是增加key-value对
scores['数学'] = 93
scores[92] = 5.7
print(scores) # {'语文': 89, '数学': 93, 92: 5.7}

删除宇典中的 key-value 对，则可使用 del 语句。

# 使用del语句删除key-value对
del scores['语文']
del scores['数学']
print(scores) # {92: 5.7}

对 dict 中存在的 key-value 对赋值，新赋的 value 就会覆盖原有的 value，这样即可改变 dict 中的 key-value 对。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 对存在的key-value对赋值，改变key-value对
cars['BENS'] = 4.3
cars['AUDI'] = 3.8
print(cars) # {'BMW': 8.5, 'BENS': 4.3, 'AUDI': 3.8}

如果要判断字典是否包含指定的 key，则可以使用 in 或 not in 运算符。需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

# 判断cars是否包含名为'AUDI'的key
print('AUDI' in cars) # True
# 判断cars是否包含名为'PORSCHE'的key
print('PORSCHE' in cars) # False
print('LAMBORGHINI' not in cars) # True

字典的常用方法

 字典由 dict 类代表，因此我们同样可使用 dir(dict) 来查看该类包含哪些方法。

print(dir(dict))
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

clear()方法

clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
print(cars) # {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 清空cars所有key-value对
cars.clear()
print(cars) # {}

get()方法

get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 获取'BMW'对应的value
print(cars.get('BMW')) # 8.5
print(cars.get('PORSCHE')) # None
print(cars['PORSCHE']) # KeyError

update()方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
cars.update({'BMW':4.5, 'PORSCHE': 9.3})
print(cars)

items()、keys()、values()

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象，Python 不希望用户直接操作这几个方法，但可通过 list() 函数把它们转换成列表。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 获取字典所有的key-value对，返回一个dict_items对象
ims = cars.items()
print(type(ims)) # <class 'dict_items'>
# 将dict_items转换成列表
print(list(ims)) # [('BMW', 8.5), ('BENS', 8.3), ('AUDI', 7.9)]
# 访问第2个key-value对
print(list(ims)[1]) # ('BENS', 8.3)
# 获取字典所有的key，返回一个dict_keys对象
kys = cars.keys()
print(type(kys)) # <class 'dict_keys'>
# 将dict_keys转换成列表
print(list(kys)) # ['BMW', 'BENS', 'AUDI']
# 访问第2个key
print(list(kys)[1]) # 'BENS'
# 获取字典所有的value，返回一个dict_values对象
vals = cars.values()
# 将dict_values转换成列表
print(type(vals)) # [8.5, 8.3, 7.9]
# 访问第2个value
print(list(vals)[1]) # 8.3

pop方法

pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
print(cars.pop('AUDI')) # 7.9
print(cars) # {'BMW': 8.5, 'BENS': 8.3}

popitem()方法

popitem() 方法用于随机弹出字典中的一个 key-value 对。
此处的随机其实是假的，正如列表的 pop() 方法总是弹出列表中最后一个元素，实际上字典的 popitem() 其实也是弹出字典中最后一个 key-value 对。由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”弹出的，但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value 对。

cars = {'AUDI': 7.9, 'BENS': 8.3, 'BMW': 8.5}
print(cars)
# 弹出字典底层存储的最后一个key-value对
print(cars.popitem()) # ('BMW', 8.5)
print(cars) # {'BMW': 8.5, 'BENS': 8.3}

由于实际上 popitem 弹出的就是一个元组，因此程序完全可以通过序列解包的方式用两个变量分别接收 key 和 value。

k, v = cars.popitem()
print(k, v) # BENS 8.3
print(cars)

setdefault()方法

setdefault() 方法也用于根据 key 来获取对应 value 的值。但该方法有一个额外的功能，即当程序要获取的 key 在字典中不存在时，该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 设置默认值，该key在dict中不存在，新增key-value对
print(cars.setdefault('PORSCHE', 9.2)) # 9.2
print(cars)
# 设置默认值，该key在dict中存在，不会修改dict内容
print(cars.setdefault('BMW', 3.4)) # 8.5
print(cars)

使用字典格式化字符串

在格式化字符串时，如果要格式化的字符串模板中包含多个变量，后面就需要按顺序给出多个变量，这种方式对于字符串模板中包含少量变量的情形是合适的，但如果字符串模板中包含大量变量，这种按顺序提供变量的方式则有些不合适。可改为在字符串模板中按 key 指定变量，然后通过字典为字符串模板中的 key 设置值。

# 字符串模板中使用key
temp = '教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'
book = {'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'}
# 使用字典为字符串模板中的key传入值
print(temp % book)
book = {'name':'C语言小白变怪兽', 'price':159, 'publish': 'C语言中文网'}
# 使用字典为字符串模板中的key传入值
print(temp % book)