【Python 零基础入门】列表 & 字典
【Python 零基础入门】第三课 列表 & 字典
-
【Python 零基础入门】第三课 列表 & 字典+ 为什么要学习列表和字典+ 列表+
-
创建列表
-
列表增删改查+
-
索引+ 增+ 删+ 改+ 查
-
其他操作+
-
切片操作+ 合并列表+ 查找元素+ 列表常用方法+ 常见错误
-
字典+
-
创建字典+ 查看值
-
字典操作+
-
访问字典的键值对+ 获取指定键对应的值+ 添加键值对+ 修改字典+ 键重复+ 常见错误
-
列表 vs 字典+ 列表 & 字典 高级操作+
-
列表 & 字典 推导+ 嵌套字典
-
总结+ 练习+
-
列表基础练习+ 字典基础练习+ 列表高级练习+ 字典高级练习+ 综合应用
-
参考答案+
-
列表基础练习+ 字典基础练习+ 高级列表练习+ 字典高级练习+ 综合应用
【Python 零基础入门】第三课 列表 & 字典
在编程的世界里, 数据结构就像是各种不同的容器，每种容器都有其独特的属性和用途. 在 Python 中, 列表和字典是两种最常用的数据结构. 它们提供了一种高效的方法来组织, 存储, 和操作数据. 本篇文章将为你深入介绍这两大数据结构的核心概念, 常见操作和实际应用.
为什么要学习列表和字典
我们为什么需要列表和字典? 为了更高效地存储和处理数据. 当我们有几个数据项时, 单独的变量可能就足够了. 但当我们需要处理成百上千的数据项时, 逐个为它们分配变量显然是不现实的. 这时, 我们需要一种方法来将这些数据组织成结构化的形式, 以便我们可以轻松地对其进行操作. 列表和字典分别为我们提供了这种能力. 但它们的应用场景和使用方法有所不同. 在这一部分, 我们将重点介绍列表的基础知识.
列表
列表 (List) 是一个有序的数据结合. 在 Python 中是一种特殊的变量. 列表可以容纳多个元素, 且元素可为不同的数据类型. 列表允许重复的元素, 且列表的元素可以随时被更改, 添加, 或删除.
创建列表
格式:
列表名 = [元素1, 元素2, 元素3]
例子:
list1 = [1, 2, 3] # 创建由整数型 (int) 构成的数组
list2 = ["我是小白呀", True] # 创建包含不同数据类型的数组
print(list1, list2) # 调试输出
print(type(list1), type(list2)) # 调试输出类型
输出结果:
[1, 2, 3] ['我是小白呀', True]
<class 'list'> <class 'list'>
通过list()函数将其他数据类型转换为列表. 例子:
str1 = "我是小白呀" # 创建字符串对象
print(str1, type(str1)) # 调试输出
list3 = list(str1) # 使用 list 函数将其转化为列表
print(list3, type(list3)) # 调试输出
输出结果:
我是小白呀 <class 'str'>
['我', '是', '小', '白', '呀'] <class 'list'>
列表增删改查
索引
索引 (Index) 是一种特殊的数据结构, 类似于图书的目录. 列表会为其中的每个元素分配一个索引 (index), 从 0 开始向后递推. 通过索引我们可以对列表进行更新, 删除元素, 切片等操作.
例子:
list1 = ["我是小白呀", "王二狗", "李铁柱"] # 创建列表
print("索引 0:", list1[0]) # 通过索引调试输出元素1
print("索引 1:", list1[1]) # 通过索引调试输出元素2
print("索引 2:", list1[2]) # 通过索引调试输出元素3
输出结果:
索引 0: 我是小白呀
索引 1: 王二狗
索引 2: 李铁柱
增
格式:
list.append(elmnt)
参数:
- elmnt: 在数组末尾添加的元素
例子:
# 创建列表
list1 = [12, 23, 34, 45]
print("原始列表:", list1) # 调试输出
# 利用append在末尾添加
list1.append(56)
print("append后的列表:", list1) # 调试输出
# 利用insert添加元素
list1.insert(0, 99) # 向列表头插入元素, 99
print("insert后的列表:", list1) # 调试输出
输出结果:
原始列表: [12, 23, 34, 45]
append后的列表: [12, 23, 34, 45, 56]
insert后的列表: [99, 12, 23, 34, 45, 56]
删
例子:
# 创建列表
list1 = [12, 23, 34, 45]
print("原始列表:", list1) # 调试输出
# 删除索引为0的元素, 即12
del list1[0]
print("删除元素后的列表:", list1) # 调试输出
输出结果:
原始列表: [12, 23, 34, 45]
删除元素后的列表: [23, 34, 45]
改
例子:
# 创建列表
list1 = [12, 23, 34, 45]
print("原始列表:", list1) # 调试输出
# 修改索引0对应元素的值
list1[0] = 0
print("修改元素后的列表:", list1) # 调试输出
输出结果:
原始列表: [12, 23, 34, 45]
修改元素后的列表: [0, 23, 34, 45]
查
例子:
list1 = ["我是小白呀", "王二狗", "李铁柱"] # 创建列表
print("索引 0:", list1[0]) # 通过索引调试输出元素1
print("索引 1:", list1[1]) # 通过索引调试输出元素2
print("索引 2:", list1[2]) # 通过索引调试输出元素3
输出结果:
索引 0: 我是小白呀
索引 1: 王二狗
索引 2: 李铁柱
其他操作
切片操作
格式:
list[起始索引(包含) : 结束索引(不包含)]
list[起始索引(包含) : 结束索引(不包含): 间隔]
例 1:
# 创建列表
list1 = ["我是小白呀", "王二狗", "张三", "李四", "李铁柱"]
print(list1[0:2]) # 切片操作
print(list1[:2]) # 和上一行相同, 省略起始索引
输出结果:
['我是小白呀', '王二狗']
['我是小白呀', '王二狗']
例 2:
# 创建列表
list1 = ["我是小白呀", "王二狗", "张三", "李四", "李铁柱"]
print(list1[::2]) # 切片操作, 每2个提取一个元素
print(list1[::3]) # 切片操作, 每3个提取一个元素
输出结果:
['我是小白呀', '张三', '李铁柱']
['我是小白呀', '李四']
重点: 切片后的列表包含起始索引位置的元素, 但是不包含结束索引位置的元素.
合并列表
例子:
# 创建列表
list1 = [1, 2, 3, 4] # 创建列表1
list2 = [5, 6, 7, 8] # 创建列表2
list_combine = list1 + list2 # 合并列表
print(list_combine) # 调试输出
输出结果:
[1, 2, 3, 4, 5, 6, 7, 8]
查找元素
通过命令in判断列表中是否存在元素.
格式:
元素 in list
例子:
# 创建列表
list = [1, 2, 3, 4]
# 判断列表是否包含元素
print(1 in list)
print(2 in list)
print(3 in list)
print(4 in list)
print(5 in list)
print(6 in list)
输出结果:
True
True
True
True
False
False
列表常用方法
列表常用方法:
len(): 返回数组长度+sort(): 对列表进行排序+reverse(): 反转列表+count(): 返回指定元素在列表中的数量
例子:
# 创建列表
list1 = [1, 2, 5, 3]
print("初始数组:", list1)
# 获取数组长度
print("数组长度为:", len(list1))
# 排序
list1.sort()
print("排序后的数组:", list1)
# 反转
list1.reverse()
print("反转后的数组:", list1)
# 获取指定元素数量
print("1的数量:", list1.count(1))
输出结果:
初始数组: [1, 2, 5, 3]
数组长度为: 4
排序后的数组: [1, 2, 3, 5]
反转后的数组: [5, 3, 2, 1]
1的数量: 1
常见错误
数组下标超出定义范围.
例子:
list1 = [1, 2, 3, 4]
print(list1[0])
print(list1[1])
print(list1[2])
print(list1[3])
print(list1[4]) # list1列表不存在索引4
输出结果:
1
2
3
4
Traceback (most recent call last):
File "C:/Users/Windows/Desktop/讲课/第二课/第二课 常见错误1.py", line 6, in <module>
print(list1[4])
IndexError: list index out of range
字典
字典 (Dictionary) 由键 (Key) 和值 (Value) 组成. 键具有唯一性.
创建字典
格式:
dict = {key1:value1, key2, value2, key3, value3...}
参数:
- key: 键+ value: 值
例子:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
print(dict) # 调试输出
print(type(dict)) # 调试输出类型
输出结果:
{'名字': '我是小白哎呀', '年龄': 20}
<class 'dict'>
查看值
例子:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
print(dict["名字"]) # 通过键获取对应的值
print(dict["年龄"]) # 通过键获取对应的值
输出结果:
我是小白哎呀
20
字典操作
访问字典的键值对
方法 1, 通过items()命令获取字典键值对:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
# 方法一
for key, value in dict.items():
# 输出每个键值对
print("键:", key, "值:", value)
输出结果:
{'名字': '我是小白哎呀', '年龄': 20}
键: 名字 值: 我是小白哎呀
键: 年龄 值: 20
方法 2, 通过键获取对应的值:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
# 方法二
for key in dict:
# 输出每个键值对
value = dict[key]
print("键:", key, "值:", value)
输出结果:
键: 名字 值: 我是小白哎呀
键: 年龄 值: 20
获取指定键对应的值
通过dict.get()可以帮我们获取键 (key) 对应的值 (value), 如果指定的键值在字典中不存在, 则返回一个默认值.
格式:
dict.get(key, default=None)
例子:
# 创建字典
dict1 = {'a': 100, 'b': 200, 'c':300}
# 获取键对应的值
print(dict1.get('a')) # 100
print(dict1.get('e', 0)) # 键 "e" 不存在, 返回 0
添加键值对
例子:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
print(dict) # 调试输出
# 添加键值对
dict["职位"] = "纽约Benail CEO"
print(dict) # 调试输出'
输出结果:
{'名字': '我是小白哎呀', '年龄': 20}
{'名字': '我是小白哎呀', '年龄': 20, '职位': '纽约Benail CEO'}
修改字典
例子:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
print(dict) # 调试输出
# 通过键修改值
dict["年龄"] = 18 # 小白永远18, 不接受反驳
print(dict) # 调试输出
调试输出:
{'名字': '我是小白哎呀', '年龄': 20}
{'名字': '我是小白哎呀', '年龄': 18}
键重复
例子:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20, "年龄": 18}
print(dict) # 调试输出
输出结果:
{'名字': '我是小白哎呀', '年龄': 18}
注: 当键重复时, 保留最新的值, 作为键值对.
常见错误
键不存在:
# 创建字典
dict = {"名字": "我是小白哎呀", "年龄": 20}
# 调试输出键对应的值
print(dict["名字"])
print(dict["年龄"])
print(dict["职位"]) # 不存在该键
输出结果:
我是小白哎呀
20
Traceback (most recent call last):
File "C:/Users/Windows/Desktop/讲课/第三课/第三课 字典常见错误.py", line 7, in <module>
print(dict["职位"])
KeyError: '职位'
列表 vs 字典
列表与字典的比较, 列表和字典都是存储数据重要的工具, 但是他们有不同的用途:
- 列表: 有序的, 适用于需要按顺序存储的场景, 如任务列表或数字列表+ 字典: 无序的, 适用于需要通过特定键快速访问数据的场景, 如词汇表或人员数据库
列表 & 字典 高级操作
列表 & 字典 推导
例子:
# 列表推导
squares = [x**2 for x in (1, 2, 3, 4, 5)]
print(squares) # 调试输出
# 字典推导
squares = {x: x**2 for x in (1, 2, 3, 4, 5)}
print(squares) # 调试输出
输出结果:
[1, 4, 9, 16, 25]
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
嵌套字典
字典可以存储其他字典, 使得复杂的数据结构变得简单.
例子:
# 嵌套字典
family = {
'father': {'name': 'John', 'age': 45},
'mother': {'name': 'Linda', 'age': 43},
'child': {'name': 'Sam', 'age': 20}
}
# 调试输出
print(family)
# 通过索引查询
print(family["child"])
输出结果:
{'father': {'name': 'John', 'age': 45}, 'mother': {'name': 'Linda', 'age': 43}, 'child': {'name': 'Sam', 'age': 20}}
{'name': 'Sam', 'age': 20}
总结
列表和字典是 Python 中两个非常强大的数据结构, 它们可以帮助我们有效地组织和处理数据. 选择使用哪一个应该基于你的具体需求.
在这篇博客中, 我们探讨了列表和字典的基础和高级特性, 并通过实际的示例展示了它们的使用方法.
如果你已经理解了这些概念, 并开始在自己的 Python 项目中使用它们, 那么恭喜你, 你已经向成为一名出色的Python程序员迈出了坚实的一步!
感谢你的阅读, 希望这篇文章能对你的 Python 学习之旅提供帮助. 如果你有任何问题或建议, 请在评论区留言. 祝你编程愉快!
练习
列表基础练习
- 创建一个列表, 包含你的五部最喜欢的电影+ 向这个列表添加两部你最近看过的电影+ 根据你的喜好, 对这个列表进行排序+ 删除你喜好度最低的电影+ 输出这个列表的第三部和第五部电影
字典基础练习
- 创建一个字典, 包含你三位最喜欢的作者和他们的代表作+ 向这个字典添加一位作者和他的代表作+ 修改其中一位作者的代表作+ 删除你不再喜欢的作者+ 输出这个字典的所有作者
列表高级练习
- 使用列表推导式, 创建一个列表, 其中包含1到10的平方+ 创建一个新列表, 其中包含上述列表中的偶数+ 对上述列表进行切片, 输出前三个数字
字典高级练习
- 使用字典推导式, 创建一个字典, 其中的键是 1 到 5, 值是这些数字的三次方+ 输出所有键值对, 其中值大于10
综合应用
- 创建一个字典, 其中的键是你的朋友的名字, 值是一个列表，包含他们的三部最喜欢的电影+ 输出其中一个朋友的第一部和第三部最喜欢的电影+ 为其中一个朋友添加一部新的电影
参考答案
列表基础练习
列表基础练习:
"""
@Module Name: 列表基础练习.py
@Author: CSDN@我是小白呀
@Date: October 10, 2023
Description:
列表基础练习
"""
# 初始化电影数组
movie_list = ["电影1", "电影2", "电影3", "电影4", "电影5"]
print("五部最喜欢的电影:", movie_list)
# 添加电影
movie_list.append("电影6")
movie_list.append("电影0")
print("5+2 部最喜欢的电影:", movie_list)
# 排序
movie_list.sort()
print("排序后的电影列表:", movie_list)
# 删除
del movie_list[0]
print("删除后的电影列表:", movie_list)
# 索引
movie_3 = movie_list[2]
movie_5 = movie_list[4]
print("通过索引找出第 3, 5 部:", movie_3, movie_5)
输出结果:
五部最喜欢的电影: ['电影1', '电影2', '电影3', '电影4', '电影5']
5+2 部最喜欢的电影: ['电影1', '电影2', '电影3', '电影4', '电影5', '电影6', '电影0']
排序后的电影列表: ['电影0', '电影1', '电影2', '电影3', '电影4', '电影5', '电影6']
删除后的电影列表: ['电影1', '电影2', '电影3', '电影4', '电影5', '电影6']
通过索引找出第 3, 5 部: 电影3 电影5
字典基础练习
字典基础练习:
"""
@Module Name: 字典基础练习.py
@Author: CSDN@我是小白呀
@Date: October 10, 2023
Description:
字典基础练习
"""
# 初始化字典
author_dict = {
"作者1":"作品1",
"作者2":"作品1",
"作者3":"作品1"
}
print("初始字典:", author_dict)
# 添加作者
author_dict["作者4"] = "作品1"
print("添加后的字典:", author_dict)
# 修改字典
author_dict["作者4"] = "新作品"
print("修改后的字典:", author_dict)
# 删除作者
del author_dict["作者1"]
print("删除后的字典:", author_dict)
# 输出所有作者
print(author_dict.keys())
输出结果:
初始字典: {'作者1': '作品1', '作者2': '作品1', '作者3': '作品1'}
添加后的字典: {'作者1': '作品1', '作者2': '作品1', '作者3': '作品1', '作者4': '作品1'}
修改后的字典: {'作者1': '作品1', '作者2': '作品1', '作者3': '作品1', '作者4': '新作品'}
删除后的字典: {'作者2': '作品1', '作者3': '作品1', '作者4': '新作品'}
dict_keys(['作者2', '作者3', '作者4'])
高级列表练习
"""
@Module Name: 列表高级练习.py
@Author: CSDN@我是小白呀
@Date: October 10, 2023
Description:
列表高级练习
"""
# 列表推导式
list_square = [i**2 for i in range(1, 11)]
print(list_square)
# 偶数列表
list_even = [i for i in list_square if i % 2 == 0]
print(list_even)
# 切片
sliced_list = list_even[:3]
print(sliced_list)
输出结果:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[4, 16, 36, 64, 100]
[4, 16, 36]
字典高级练习
"""
@Module Name: 字典高级练习.py
@Author: CSDN@我是小白呀
@Date: October 10, 2023
Description:
字典高级练习
"""
# 字典推导式
dict_cube = {i:i**3 for i in range(1, 6)}
print(dict_cube)
# 大于 10 的键值对
filtered_dict = {k:v for k, v in dict_cube.items() if v > 10}
print(filtered_dict)
输出结果:
{1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
{3: 27, 4: 64, 5: 125}
综合应用
"""
@Module Name: 综合应用.py
@Author: CSDN@我是小白呀
@Date: October 10, 2023
Description:
综合应用
"""
# 创建字典
dict_movie = {
"朋友1": ["电影1", "电影2", "电影3"],
"朋友2": ["电影1", "电影2", "电影3"],
"朋友3": ["电影1", "电影2", "电影3"]
}
print(dict_movie)
# 朋友1 喜欢的第一部和第三部
friend1_movie = [dict_movie["朋友1"][0], dict_movie["朋友1"][2]]
print(friend1_movie)
# 添加电影
dict_movie["朋友1"].append("电影4")
print(dict_movie)
输出结果:
{'朋友1': ['电影1', '电影2', '电影3'], '朋友2': ['电影1', '电影2', '电影3'], '朋友3': ['电影1', '电影2', '电影3']}
['电影1', '电影3']
{'朋友1': ['电影1', '电影2', '电影3', '电影4'], '朋友2': ['电影1', '电影2', '电影3'], '朋友3': ['电影1', '电影2', '电影3']}
文章来源： https://iamarookie.blog.csdn.net/article/details/133737790
版权声明： 本文为博主原创文章，遵循CC 4.0 BY-SA 知识共享协议，转载请附上原文出处链接和本声明。