【李刚-21天通关Python】第二章：列表、元组和字典
【李刚-21天通关Python】第二章：列表、元组和字典
- 第二章：列表、元组和字典
-
- 元组与列表
- 序列相关函数与封包解包
- 列表的用法及操作列表元素
- 字典
- 实操一：随机大写字符存入列表
- 实操二：列表去重
章节分篇链接：
【李刚-21天通关Python-05】之 元组与列表
【李刚-21天通关Python-06】之 序列相关函数与封包解包
【李刚-21天通关Python-07】之 列表的用法及操作列表元素
【李刚-21天通关Python-08】之 字典
【李刚-21天通关Python-09】之 实操：随机大写字符存入列表
【李刚-21天通关Python-10】之 实操：列表去重
第二章：列表、元组和字典
元组与列表
一、序列
1、序列指的是包含多项数据的数据结构，序列包含的多个数据项（也叫成员）按顺序排列，可通过索引来访问序列成员
2、Python常见的序列包括字符串、字节串、元组、列表、namedtuple等
二、元组与列表的概念
1、列表是可变的，程序可以修改列表所包含的元素;元组是不可变的，程序无法修改元组所包含的元素
2、区分
- 构建时，方括号是列表，圆括号是元组
- 列表用 list() 创建，元组用 tuple() 创建
三、元组与列表的创建
1、创建方法一
- 列表：[ele1, ele2, ele3, ……]
- 元组：(ele1, ele2, ele3, ……)
- 注意点：如果创建只包含一个元素的元组，不能仅在圆括号中放一个元素，还必须在元素后放一个逗号，例：(ele1, )
my_tuple = (1, 2, 'python')
print(my_tuple) # (1, 2, 'python')
simple_tuple1 = ('python')
print(simple_tuple_err1) # python
simple_tuple2 = ('python', )
print(simple_tuple_err2) # ('python', )
2、创建方法二
- 列表：list() 函数
- 元组：tuple() 函数
- 列表和元组可以互相转换
my_list1 = list(range(2, 6))
print(my_list1) # [2, 3, 4, 5]
my_tuple1 = tuple(range(4,8))
print(my_tuple1) # (4, 5, 6, 7)
my_list2 = list(my_tuple1)
print(my_list2) # [4, 5, 6, 7]
my_tuple2 = tuple(mt_list1)
print(my_tuple2) # (2, 3, 4, 5)
四、通过索引访问元素
- 正向访问（从左至右），索引从0开始，0，1，2，……
- 反向访问（从右至左），索引从-1开始，-1，-2，-3，……
my_tuple = tuple(range(2,10))
print(my_tuple[2]) # 4
print(my_tuple[-2]) # 9
五、子序列
slice（分片或切片）：[start : end : step]
my_tuple = ('python', 100, 20, 'java', 'kotlin','js')
print(my_tuple[2 : 5]) # (100, 20, 'java')
print(my_tuple[-5 : -2]) # (100, 20, 'java')
print(my_tuple[2 : -1]) # (20, 'java', 'kotlin')
print(my_tuple[2 : 5 : 2]) # (100, 'java')
print(my_tuple[2 : -1 : 2]) # (20, 'kotlin')
六、序列的加法
1、列表和元组支持加法，加法的和就是两个列表或元组所包含元素的总和
2、列表只能和列表相加，元组只能和元组相加
my_list1 = [20, 'python']
my_list2 = list(range(4))
print(mt_list2) # (0, 1, 2, 3)
print(my_list1 + my_list2) # [20, 'python', 0, 1, 2, 3]
七、序列的乘法
1、列表和元组可以和整数（N）执行乘法，其意义是把它们包含的元素重复N次
my_list = [20, 'python']
print(my_list * 3) # [20, 'python', 20, 'python', 20, 'python']
八、in 运算符
1、in 运算符用于判断列表或元组是否包含某个元素
my_list = [20, 'python']
print(20 in my_list) # True
print('java' in my_list) # False
序列相关函数与封包解包
一、使用函数
- len() 函数：获取元组、列表的长度
- min() 函数：获取元组、列表的最小值
- max() 函数：获取元组、列表的最大值
my_list = ['python', 'kotlin', 'swift', 'java', 'go']
print(len(my_list)) # 5
# 字符串比较大小规则：
# 先比较第一个字符，若第一个字符相同，比较第二个字符，以此类推……
print(min(my_list)) # go
print(max(my_list)) # swift
二、序列封包
1、把多个值赋给一个变量时，Python会自动将多个值封装成元组
data = 20, 100, 'python'
print(data) # (20, 100, 'python')
三、序列解包
1、序列可被直接赋值给多个变量，此时序列的各元素被依次赋值给每个变量（要求序列的元素个数与变量个数相同）
my_list = [20, 100, 'python']
a, b, c = mt_list
print(a) # 20
print(b) # 100
print(c) # python
2、如果只要解包某一个值，其他可用带 “*” 的变量来接收
my_list = ['python', 'kotlin', 'swift', 'java', 'go']
first, *rest = my_list
print(first) # python
print(rest) # ['kotlin', 'swift', 'java', 'go']
四、多变量同时赋值
1、Python的赋值运算符支持同时将多个值赋给多个变量（同时运用序列封包和解包）
列表的用法及操作列表元素
一、增加元素
1、append() 方法会把传入的参数追加到列表的最后面
my_list = ['python', 'swift']
my_list.append('kotlin')
print(my_list) # ['python', 'swift', 'kotlin']
2、append() 方法追加另一个列表（序列）时，列表被当成一个元素
my_list = ['python', 'swift']
my_list.append(tuple(range(3, 6)))
print(my_list) # ['python', 'swift', (3, 4, 5)]
3、extend() 方法用于追加另一个列表（序列），它会将列表（序列）中的元素追加进来
my_list = ['python', 'swift']
my_list.extend(range(20, 25))
print(my_list) # ['python', 'swift', 20, 21, 22, 23, 24]
my_list = ['python', 'swift']
my_list.extend('pyhton') # 字符串本身也是序列
print(my_list) # ['python', 'swift', 'p', 'y', 't', 'h', 'o', 'n']
4、insert() 方法将元素插入列表指定位置
my_list = ['python', 'swift', 'java', 'go']
my_list.isnert(2,'aaa') # 将'aaa'插入到第3个元素的位置
print(my_list) # ['python', 'swift', 'aaa', 'java', 'go']
二、删除元素
1、删除列表元素使用 del 语句
2、del 语句不仅可用于删除列表的元素，也可用于删除变量
3、del 语句即可删除列表中的单个元素，也可删除列表中的一段
my_list = ['python', 'swift', 'java', 'go', 'js', 'kotlin']
del my_list[2]
print (my_list) # ['python', 'swift', 'go', 'js', 'kotlin']
my_list = ['python', 'swift', 'java', 'go', 'js', 'kotlin']
del my_list[2: 5]
print (my_list) # ['python', 'swift', 'kotlin']
4、列表提供了 remove() 方法来删除元素，remove() 方法不根据索引删除元素，而是删除第一个找到的元素
三、替换元素
1、对列表的元素赋值即可修改列表中的元素
my_list = ['python', 'swift', 'java', 'go', 'js', 'kotlin']
my_list[2] = 'aaa'
print (my_list) # ['python', 'swift', 'aaa', 'go', 'js', 'kotlin']
2、还可通过 slice 语法对列表其中一部分赋值，且对列表其中一部分赋值时，并不要求新赋值的元素个数与原元素个数相同，这种方法即可为列表增加元素，也可为列表删除元素
my_list = ['python', 'swift', 'java', 'go', 'js', 'kotlin']
# 增加元素
my_list[2: 4] = ['aaa', 'bbb', 'ccc', 'ddd']
print (my_list) # ['python', 'swift', 'aaa', 'bbb', 'ccc', 'ddd', 'js', 'kotlin']
my_list = ['python', 'swift', 'java', 'go', 'js', 'kotlin']
# 删除元素
my_list[2: 4] = ['aaa']
print (my_list) # ['python', 'swift', 'aaa', 'js', 'kotlin']
3、对列表通过 slice 语法赋值时，不能使用单个值；如果使用字符串赋值，Python会自动将字符串当作序列处理
my_list = ['python', 'swift', 'java', 'go', 'js', 'kotlin']
my_list[2: 5] = 'python'
print (my_list) # ['python', 'swift', 'p', 'y', 't', 'h', 'o', 'n', 'kotlin']
四、列表方法
可通过快捷键 windows+R 并输入 cmd 进入命令提示符
输入 python 并回车 -> 输入 dir(list) 并回车
输入 help(list. ) 可查询每个函数的用法，括号内“list.”后为待查询的函数
- count() ：统计列表中某个元素出现的次数
- index() ：判断列表中某个元素在列表中出现的位置
- pop() ：该方法用于将列表当成“栈”使用，实现元素出栈功能
- reverse() ：该方法用于将列表中的元素反向存放
- sort() ：该方法用于对列表元素进行排序
my_list = ['python', 'java', 'go', 'js', 'kotlin']
# 判断元素的位置
print(my_list.index('python')) # 0
# 逆置
my_list.reverse()
print(my_list) # ['kotlin', 'js', 'go', 'java', 'python']
# 排序
my_list.sort()
print(my_list) # ['go', 'java', 'js', 'kotlin', 'python']
字典
一、字典的概念
1、字典用于保存具有映射关系的数据，字典相当于保存了两组数据，其中一组数据被称为key，另一组数据可通过key来访问，被称为value
2、字典中key和value的关系如下，且key不允许重复
二、创建字典
1、花括号法：花括号应包含多组key-value对，key与value之间用英文冒号隔开，多组key-value对之间用英文逗号隔开
scores = {'语文': 80, '数学': 100, '英语': 90}
print(scores) # {'语文': 80, '数学': 100, '英语': 90}
2、dict构造器：可以传入多个列表或元组参数作为key-value对，也可为dict指定关键字参数创建字典，此时字典的key不允许用表达式
scores = dict([('语文', 80), ('数学', 100), ('英语', 90)])
print(scores) # {'语文': 80, '数学': 100, '英语': 90}
scores = dict('语文' = 80, '数学' = 100, '英语' = 90)
print(scores) # {'语文': 80, '数学': 100, '英语': 90}
字典的key是不可变的，因此列表不能作为字典的key
三、通过key访问value
scores = dict('语文' = 80, '数学' = 100, '英语' = 90)
print(scores['语文']) # 80
四、修改key-value对
scores = dict('语文' = 80, '数学' = 100, '英语' = 90)
# 添加key-value对：对不存在的key赋值
score['生物'] = 91
print(scores) # {'语文': 80, '数学': 100, '英语': 90, '生物': 91}
# 替换key-value对：对原有的key赋值
score['数学'] = 95
print(scores) # {'语文': 80, '数学': 95, '英语': 90, '生物': 91}
# 删除key-value对：del 方法
del scores['数学']
print(scores) # {'语文': 80, '英语': 90, '生物': 91}
五、in 运算符
使用in、not in可判断dict是否包含指定的key
scores = dict('语文' = 80, '数学' = 100, '英语' = 90)
print('数学' in scores) # True
print('生物' in scores) # False
六、字典常用方法
1、调用 dir(dict) 可查看字典的所有方法
可通过快捷键 windows+R 并输入 cmd 进入命令提示符
输入 python 并回车 -> 输入 dir(dict) 并回车
- clear() ：用于清空字典中所有的key-value对
- get() ：根据key来获取value
- update() ：使用一个字典所包含的key-value对来更新已有的字典
- items() ：获取字典中所有key-value对
- keys() ：获取字典中所有key
- values() ：获取字典中所有value
scores = {'语文': 80, '数学': 100, '英语': 90}
scores.update({'语文': 89, '生物': 99})
print(scores) # {'语文': 80, '数学': 100, '英语': 90, '生物': 99}
scores = dict('语文' = 80, '数学' = 100, '英语' = 90)
for key in scores.keys():
print(key) # 语文 数学 英语
for value in scores.values():
print(value) # 80 100 90
for key, value in scores.items():
print(key, value) # 语文 80 数学 100 英语 90
- pop() ：用于获取并删除指定key对应的value
- popitem() ：用于随机地弹出字典中的一个key-value对
- setdefault() ：根据key来获取对应value的值，并为不存在的值设置默认值
- fromkeys() ：使用给定的多个key创建字典，这些key对应的value默认都是None，也可以额外传入一个参数作为默认的value
scores = dict('语文' = 80, '数学' = 100, '英语' = 90)
print(scores.setdefault('语文', 60)) # 60
print(scores.setdefault('生物', 80)) # 80
print(scores) # {'语文': 60, '数学': 100, '英语': 90, '生物': 80}
scores = dict.fromkeys(['语文', '数学', '英语'])
print(scores) # ['语文': None, '数学': None, '英语': None]
七、用字典格式化字符串
可在字符串模板中按key指定变量，然后通过字典为字符串模板中key设置值
# 用元组来格式化字符串，所以它根据位置来填充占位符
s1 = "图书名为：%s，价格为：%10.2f"
print(s1 % ("疯狂python讲义", 128))
# 图书名为：疯狂python讲义，价格为： 128.00
# 用字典来格式化字符串，所以它key来填充占位符
s2 = "图书名为：%(name)s，价格为：%(price)10.2f"
print(s2 % {price: 128, name: "疯狂python讲义"})
# 图书名为：疯狂python讲义，价格为： 128.00
实操一：随机大写字符存入列表
方法一
- 创建列表
- 生成指定范围内的随机数
- 随机数转字符
- 字符存入列表
NUM = 10
import random
# 创建空列表
result = []
# 循环十次，生成十个随机数
for i in range(NUM):
n = random.randint(65.90)
# 随机数转成字符，并添加到列表
result.append(chr(n))
print(result)
方法二
- 使用列表推导式
- range(10) 控制循环十次，控制生成十个大写字符
NUM = 10
import random
# 列表推导式
# random.randint(65,90)表达式用于生成随机大写字符
result = [random.randint(65,90) for i in range(NUM)]
print(result)
方法三
- 使用列表推导式
- 使用 numpy 模块一次生成N个随机数
NUM = 10
import numpy
# numpy.random.randint()函数可生成一个随机数的矩阵
result = [for i in random.randint(65,90，[NUM, 1])]
print(result)
实操二：列表去重
方法一
- 创建新列表
- 遍历原列表的所有元素，若该元素不在新列表中，将元素添加到新列表中
- 这种方法可保证元素顺序
# 使用列表推导式来创建一个包含重复元素的列表
import random
src_list = [random.randint(20, 30) for i in range(15)]
# 用新列表收集，只收集不重复的元素
target_list = []
# 遍历原列表中的每个元素
for ele in src_list:
if ele not in target_list:
target_list.append(ele)
print(target_list)
方法二
- 利用 set 集合，特征：不允许重复元素
- 将列表元素传给 set() ，自动去重
# 使用列表推导式来创建一个包含重复元素的列表
import random
src_list = [random.randint(20, 30) for i in range(15)]
# 将源列表传给set集合，自动去除重复元素
# 再次恢复成列表
target_list = set(src_list)
print(target_list)
方法三
- 使用 itertools 模块
- itertools 模块下提供了 groupby 函数，该函数用于分组，相同的就分为一组
- 注意：这种方式必须先对列表排序
# 使用列表推导式来创建一个包含重复元素的列表
import random
import itertools
src_list = [random.randint(20, 30) for i in range(15)]
# 对列表进行排序
src_list.sort()
it = itertools,groupby(src_list)
for k,g in it:
print(k, end=" ")