疯狂Python讲义-李刚编著-第3章列表、元组和字典

第3章 列表、元组和字典

3.1.序列简介

3.1.1.Python 的序列

提示：列表和元组的关系就是可变和不可变的关系

3.1.2.创建列表和元组

创建列表的语法格式如下：

[ele1, ele2, ele3, ...]

创建元组的语法格式如下：

(ele1, ele2, ele3, ...)

my_list = ['crazyit', 20, 'Python']
print(my_list)
my_tuple = ('crazyit', 20, 'Python')
print(my_tuple)

3.2.列表和元组的通用用法

3.2.1.通过索引使用元素

3.2.2.子序列

列表和元组可使用索引获取中间一段，这种用法称为 slice（分片或切片）。

[start:end:step]

3.2.3.加法

3.2.4.乘法

3.2.5.in 运算符

3.2.6.长度、最大值和最小值

3.2.7.序列封包和序列解包

Python 允许支持以下两种赋值方式

1.程序把多个值给一个变量时，Python 会自动将多个值封装成元组。这种功能被称为序列封包。

2.程序允许将序列（元组或列表等）直接赋值给多个变量，此时序列的各元素会被依次赋值给每个变量（要求序列的元素个数和变量个数相等）。这个功能被称为序列解包

#序列封包
vals = 10， 20， 30
print(vals)
print(type(vals)) # <class 'tuple'>
print(vals[1])
a_tuple = tuple(range(1, 10, 2))

#序列解包
a, b, c, d, e = a_tuple
print(a, b, c, d, e)
a_list = ['fkit', 'crazyit']
a_str, b_str = a_list
print(a_str, b_str)

x, y, z = 10, 20, 30
print(x, y, z)

xyz = 10, 20, 30
x, y, z = xyz

在序列解包时也可以只解出部分变量，剩下的依然使用列表保存。为了使用这种解包方式，Python 允许在左边被赋值的变量之前添加 "*"，那么该变量就代表一个列表，可以保存多个集合元素。

first, second, *rest = range(10)
print(first)
print(second)
print(rest)

*begin, last = range(10)
print(begin)
print(last)

first, *middle, last = range(10)
print(first)
print(middle)
print(last)

3.3.使用列表　　

3.3.1.创建列表

Python 还提供了一个内置的 list() 函数来创建列表，list() 函数可用于将元组、区间（range）等对象转换为列表

a_tuple = ('crazyit', 20, -1.2)
a_list = list(a_tuple)
print(a_list)
a_range = range(1, 5)
print(a_range)
b_list = list(a_range)
print(b_list)
c_list = list(range(4, 20, 3))
print(c_list)

Python 也提供了一个 tuple() 函数，该函数可用于将列表、区间（range）等对象转换为元组

a_list = ['crazyit', 20, -1.2]
a_tuple = tuple(a_list)
print(a_tuple)
a_range = range(1, 5)
print(a_range)
b_tuple = tuple(a_range)
print(b_tuple)
c_tuple = tuple(range(4, 20, 3))
print(c_tuple)

3.3.2.增加列表元素

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

append() 方法既可接收单个值，也可接收元组、列表等，但该方法只是把元组、列表当成单个元素，这样就会形成在列表中嵌套列表、嵌套元组的情形

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

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

c_list = list(range(1, 6))
print(c_list)
c_list.insert(3, 'CRAZY')
print(c_list)
c_list.insert(3, tuple('crazy'))
print(c_list)

3.3.3.删除列表元素

删除列表元素使用 del 语句。del 语句是 Python 的一种语句，专门用于执行删除操作，不仅可用于删除列表的元素，也可用于删除变量等。

使用 del 语句既可删除列表中的单个元素，也可直接删除列表的中间一段。

a_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']
del a_list[2]
print(a_list)
del a_list[1:3]
print(a_list)
b_list = list(range(1, 10))
del b_list[2:-2:2]
print(b_list)
del b_list[2:4]
print(b_list)

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

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

c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
c_list.remove(30)
print(c_list)
c_list.remove('crazyit')
print(c_list)

列表还包含一个 clear() 方法，该方法用于清空列表的所有元素

3.3.4.修改列表元素

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

这意味着通过这种方式即可为列表增加元素，也可为列表删除元素

b_list = list(range(1, 5))·
print(b_list)
b_list[1:3] = ['a', 'b']
print(b_list)

#将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入元素
b_list[2:2] = ['x', 'y']
print(b_list)

#将第3个到第6个（不包含）元素赋值为空列表，就是删除元素
b_list[2:5] = []
print(b_list)

#Python 会自动将 str 分解为序列
b_list[1:3] = 'Charlie'
print(b_list) #[1, 'C', 'h', 'a', 'r', 'l', 'i', 'e']

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']

3.3.5.列表的其他常用方法

dir(list)：可看到列表包含的所有方法

count()：用于统计列表中某个元素出现的次数

index()：用于判断某个元素在列表中出现的位置，在使用时还可传入 start、end 参数，用于在列表的指定范围内搜索元素。

pop()：用于将列表当成”栈“使用，实现元素出栈功能

reverse()：用于将列表中的元素反向存放

sort()：用于对列表元素排序，还可传入 key 和 reverse 两个参数，而且这两个参数必须通过参数名指定。key 参数用于为每个元素都生成一个比较大小的”键“；reverse 参数则用于执行是否需要反转排序——默认是从小到大排序；如果将该参数设为 True，将会改为从大到小排序。

#dir
dir(list)

#count
a_list = [2, 30, 'a', [5, 30], 30]
print(a_list.count(30)) #2
print(a_list.count([5, 30])) #1

#index
a_list = [2, 30, 'a', 'b', 'crazyit', 30]
print(a_list.index(30)) #1
print(a_list.index(30, 2)) #5
print(a_list.index(30, 2, 4)) #ValueError

#pop
stack = []
stack.append('fkit')
stack.append('crazyit')
stack.append('Charlie')
print(stack)

#第一次出栈：最后入栈的元素被移出栈
print(stack.pop()) #['fkit', 'crazyit']
print(stack)

#再次出栈
print(stack.pop()) #['fkit']
print(stack)

#sort
#指定 key 为 len，指定使用 len 函数对集合元素生成比较大小的键
b_list.sort(key=len)
print(b_list)
b_list.sort(key=len, reverse=True)
print(b_list)

3.4.使用字典

3.4.1.字典入门　　

3.4.2.创建字典

scores = {'语文':89, '数学':92, '英语':93}
print(scores)
empty_dict = {}
print(empty_dict)
dict2 = {(20, 30):'good', 30:'bad'}
print(dict2)

#创建包含 3 个 key-value 对的字典
vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
dict3 = dict(vegetables)
print(dict3) # {'celery':1.58, 'brocoli':1.29, 'lettuce':2.19}

#创建包含 3 个 key-value 对的字典
cars = [['BMW', 8.5], ['BENS', 8.3], ['AUDI', 7.9]]
dict4 = dict(cars)
print(cars)

#创建空的字典
dict5 = dict()
print(dict5)

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

3.4.3.字典的基本用法

通过 key 访问 value

通过 key 添加 key-value 对

通过 key 删除 key-value 对

通过 key 修改 key-value 对

通过 key 判断指定 key-value 对是否存在　

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

列表的索引总是从0开始、连续增大的；但字典的索引即使是整数类型，也不需要从 0 开始，而且不需要连续。因此，列表不允许对不存在的索引赋值，但字典则允许直接对不存在的 key 赋值——这样就会为字典增加一个 key-value 对

3.4.4.字典常用的方法

dir(dict)：查看该类包含哪些方法

clear()：清空字典红所有的 key-value 对

get()：根据 key 来获取 value，如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误

update()：可使用一个字典所包含的 key-value 对来更新已有的字典，如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去

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

pop()：用户获取指定 key 对应的 value，并删除这个 key-value 对

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

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

fromkeys()：使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用，通常会使用 dict 类直接调用

#fromkeys
a_dict = dict.fromkeys(['a', 'b'])
print(a_dict) # {'a':None, 'b':None}
b_dict = dict.fromkeys((13, 17))
print(b_dict) # {13:None, 17:None}
c_dict = dict.fromkeys((13, 17), 'good')
print(c_dict) #{13:'good', 17:'good'}

3.4.5.使用字典格式化字符串

temp = '书名是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'
book = {'name':'疯狂 Python 讲义', 'price':88.9, 'publish':'电子社'}
print(temp % book)
book = {'name':'疯狂 Kotlin 讲义', 'price':78.9, 'publish':'电子社'}
print(temp % book)