1. 数据容器

一种可以容纳多份数据的数据类型（容器），容纳的每一份元素数据称之为1个元素，每一个元素都可以是任意类型的数据，如：字符串、数字、布尔等。

列表（list）

字符串（str)

元组（tuple）

集合（set）

字典（dict）

2. 列表

2.1列表介绍

列表是数据容器中的一类，是一次性可以存储多个数据元素的。

定义：列表名称 = [元素1， 元素2，元素3.............]

特点：

1.可以存储不同类型的元素

2.元素有序、可以重复、元素可以修改

#定义列表  -  list
s = [1, 10, 145, 123, 123, "goog", "abc", True]

print(type(s))

#访问列表元素
print(s[0])
print(s[-8])

#修改列表元素
s[4] = "gys"
print(s[4])

#删除列表元素 del
del s[5]
print(s)

#遍历列表
for i in s:
    print(i)

运行结果

2.2列表-切片

切片是指对操作的数据截取其中一部分的操作。列表、字符串、元组都支持切片操作。

语法：序列数据[开始索引：结束索引：步长]

1.不包含结束索引位置对应的元素（开始索引未指定默认为0；结束索引未指定默认为列表长度；步长未指定默认为1）

2.索引采用正向、反向索引都可以

3.步长是选取间隔，默认步长为1

s = ["a", "b", "c", "d", "e", "f", "g", "h", "j"]
#切片操作 s[开始索引:结束索引:步长]
print(s[0:5:1])
print(type(s[0:5:1]))

print(s[0:5]) #步长不写默认为1
print(s[:5])  #开始不写默认从0开始

print(s[0:5:2])

运行结果

2.3 list常用方法

列表的常用方法就是指列表这种数据类型内置的常见功能（添加元素、删除元素、排序等）

2.3.1增加元素 (Add)

方法名	功能说明	语法示例	执行后列表变化
append()	追加： 在列表的最末尾添加一个元素。（最常用）	lst.append(4)	[1, 2] -> [1, 2, 4]
insert()	插入： 在指定的索引位置插入一个元素。	lst.insert(1, "A")	[1, 2] -> [1, "A", 2]
extend()	扩展： 将另一个列表（或任何可迭代对象）里的所有元素逐一拼接到原列表末尾。	lst.extend([3, 4])	[1, 2] -> [1, 2, 3, 4]

2.3.2删除元素 (Remove)

方法名	功能说明	语法示例	执行后列表变化
remove()	按值删除： 删除列表中第一个匹配该值的元素。如果值不存在会报错。	lst.remove("A")	[1, "A", 2] -> [1, 2]
pop()	按位置删除（弹出）： 删除并返回指定索引位置的元素。如果不写索引，默认删除并返回最后一个元素。	lst.pop()	[1, 2, 3] -> [1, 2]
clear()	清空： 删除列表中的所有元素，把它变成空列表。	lst.clear()	[1, 2, 3] -> []

2.3.3查询与统计 (Find & Count)

方法名	功能说明	语法示例	返回结果
index()	查找索引： 找某个值在列表中第一次出现的索引位置。找不到会报错。	lst.index(2)	返回数字 1
count()	统计次数： 统计某个值在列表中一共出现了多少次。	lst.count("A")	返回该元素出现的次数

2.3.4排序与反转 (Sort & Reverse)

方法名	功能说明	语法示例	执行后列表变化
sort()	排序： 对原列表里的元素按从小到大排序。加上 reverse=True 参数则为从大到小。	lst.sort()	[3, 1, 2] -> [1, 2, 3]
reverse()	反转： 把原列表的首尾顺序直接倒过来，不关心大小。	lst.reverse()	[1, 2, 3] -> [3, 2, 1]

#将用户输入的10个数字，存储到一个列表中，并将列表中的数字进行排序，输出其中的最小值和最大值以及平均值

# 1.定义列表
num_list = []

# 2.将用户输入的10个数字存到列表
for i in range(10):
    num = int(input("请输入一个有效数字："))
    num_list.append(num)
print("数字列表：", num_list)

# 3.排序
num_list.sort()
print("排序后的数字列表：", num_list)

# 4.输出最小值、最大值和平均值 sum():求和; len():获取列表长度
print("最小值为：", num_list[0])
print("最大值为：", num_list[-1])
print("平均值为：", sum(num_list) / len(num_list))

# 合并两个列表中的元素，并对合并后列表元素进行去重处理,并进行排序

num_list1 = [41, 0, 9, 28, 19, 99, 0, 32, 0, 18, 19]
num_list2 = [18, 8, 39, 38, 9, 32]

# 1.合并列表
# 方法1
# for num in num_list2:
#     num_list1.append(num)

# 方法2
#组包：将多个值合并到一个容器
#num_list = [*num_list1, *num_list2] #解包：将列表这一类容器解开成一个一个独立的元素

# 方法3
num_list = num_list1 + num_list2

print("合并后的列表为：", num_list)

# 2.去重处理
new_list = []
for num in num_list:
    if  num not in new_list:
        new_list.append(num)
print("去重后列表为：", new_list)

1. 如何快速合并两个列表？

使用+运算符直接合并

使用*进行解包操作

1. 如何判断一个元素是否在于列表之中

可用in运算符，语法为：元素 in 列表

2.3.5列表推导式

列表推导式就是按照一定的规则快速生成一个列表的方法

语法格式1：[要添加的值 for i in 序列/列表]

语法格式2：[要添加的值 for i in 序列/列表 if 条件]

# 生成1~20的平方列表。---> range(1,21)
#方式一: 传统方式
num_list = []
for i in range(1,21):
    num_list.append(i**2)
print(num_list)

#方式二：列表推导式--->按照一定的规则快速生成一个列表的方法---> 语法格式：[要添加的值 for i in 序列/列表]
num_list2 = [i**2 for i in range(1,21)]
print(num_list2)

# 从生成的1~20平方列表中提取所有偶数,并再次计算其平方
num_list3 = [i**2 for i in num_list2 if i % 2 == 0]
print(num_list3)

、

3. 字符串Str

3.1字符串介绍

字符串是字符的容器，一个字符串中可以存放任意数量的字符。如“python” """python"""

特点：不可变性（无法修改）、有序性

字符串中的每一个字符串元素都有其对应的下标（索引），通过元素对应的索引，就可以获取到对应的元素。

注意：正向索引：下标从0开始；反向索引：下标从-1开始。

3.2字符串-切片

介绍：切片是指对对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作

语法：序列对象[开始索引:结束索引:步长]

注意：开始索引未指定默认为0；结束索引未指定默认为-1；步长未指定默认为1

# #字符串：不可修改，有序性、可迭代性
# s = "今天是星期六,我在学python!"

# print(s)
# print(s[6])

# #切片
# print(s[:6:])

# #步长: 正数从前往后截取; 负数从后往前截取
# print(s[:10:])
# print(s[::-1]) #可以用来字符串反转

3.3 str常用方法

3.3.1 格式化与清理 (Format & Clean)

用来对付那些不规范的文本（比如用户手滑多打的空格，或者大小写乱七八糟的拼音）。

方法名	功能说明	语法示例	返回结果
strip()	去除两端空白： 删掉字符串开头和结尾的空格、换行符（\n ）和制表符（\t ）。（爬虫和数据清洗最常用）	" hello ".strip()	"hello"
upper()	全大写： 将所有小写字母转为大写。	"python".upper()	"PYTHON"
lower()	全小写： 将所有大写字母转为小写。（常用于忽略大小写的比对）	"VIP".lower()	"vip"
title()	标题化： 将每个单词的首字母变成大写。	"hello world".title()	"Hello World"

3.3.2 查找与替换 (Search & Replace)

用来在一段长文本中寻找特定内容，或者进行“文本替换”。

方法名	功能说明	语法示例	返回结果
find()	查找位置： 找某个字符第一次出现的索引位置。如果找不到，会返回 -1 （不会报错）。	"apple".find("p")	1
count()	统计次数： 统计某个子字符串在文本中一共出现了几次。	"apple".count("p")	2
replace()	替换内容： 把字符串里的“旧内容”全替换成“新内容”。	"I like Java".replace("Java", "Python")	"I like Python"

3.3.3 拆分与拼接 (Split & Join) —— ⭐ 超级重要

字符串和列表（List）互相转换的桥梁，在实际开发中极其常用。

方法名	功能说明	语法示例	返回结果
split()	切片/拆分： 按照指定的符号，把一个长字符串切成好几块，返回一个列表。默认按空格切。	"A,B,C".split(",")	['A', 'B', 'C']
join()	拼接： （语法比较反直觉）把一个列表里的所有字符串，用指定的符号连接成一个新的长字符串。	"-".join(["2023", "10", "01"])	"2023-10-01"

3.3.4 条件判断 (Check)

用来做检查，返回的结果永远是布尔值（True 或 False）。

方法名	功能说明	语法示例	返回结果
startswith()	是否以...开头： 常用来检查网址是否合法，或文件格式。	"http://xxx".startswith("http")	True
endswith()	是否以...结尾： 常用来检查文件后缀。	"pic.jpg".endswith(".png")	False
isdigit()	是否全是纯数字： 检查字符串是不是全由数字组成。	"12345".isdigit()	True
isalpha()	是否全是纯字母： 检查字符串是不是全由字母组成（中文也算字母类）。	"Python".isalpha()	True

# 案列:处理用户不规范的输入
raw_input = input("请输入您的邮箱：")

# 1.先检验邮箱是否合法（包含1个'@'和至少1个'.'）
if raw_input.count("@") == 1 and '.' in raw_input:
    print("邮箱有效:",raw_input)

    # 2. 去掉两边多余的空格和换行
    clean_text = raw_input.strip()
    print(f"去除多余空格后的邮箱：{clean_text}")

    # 3.邮箱统一转换为小写
    email = clean_text.lower()
    print(f"最终邮箱：{email}")
else:
    print("有效无效")

4. 元组tuple

元组和列表最大的不同点在于：元组一旦定义完成，不可修改

4.1 元组介绍

元组是不可变的序列，类似于列表，但创建后不可修改。

特点：

1.可以存储不同类型的元素

2.元素可以重复、有序、不可修改（支持索引、切片）

#定义元组
元组名称 = (元素1, 元素2......)

#定义空元组
元组名称 = ()
元组名称 = tuple()

4.2 tuple常用方法

方法名	功能说明	语法示例	返回结果
index()	查找位置： 从左到右寻找某个值，返回它第一次出现的索引位置。找不到会报错。	(10, 20, 30).index(20)	1
count()	统计次数： 统计某个特定值在元组中一共出现了多少次。	(1, 2, 2, 3).count(2)	2

#定义元组
t1 = (1, 4, 5, 2, 6, 6, 2, 5)

print(t1)
print(type(t1))

#索引访问
print(t1[2])
print(t1[-3])

#切片
print(t1[:3:])

#count() 统计元素个数
print(t1.count(5))

#index() 获取元素的索引（第一个元素的位置）
print(t1.index(5))

4.3 tuple组包和解包

组包(packing):将多个值合并到一个容器（元组、列表）中。

解包(unpacking):将容器（元组、列表）解开独立的元素，分别赋值给多个变量。

#组包
t1 = (1, 2, 3, 4, 5, 6, 7, 8)
t2 = 1, 2, 3, 4, 5, 6

#解包
a, b, c, d, e, f, g, h = t1
print(a, b, c, d, e, f, g, h)

#扩展解包 （*收集剩余的所有元素，封装列表list中）
first, second, *other, last = t2
print(first, second, other, last)

# 计算每个学生的总分、各科平均分，然后一并输出

print("学号\t 姓名\t 语文\t 数学\t 英语\t 总分\t 平均分")

for s in student: #s: ("s001", "小明", 82, 98, 78)
    total = s[2] + s[3] + s[4]
    avg = total / 3
    print(f"{s[0]}\t {s[1]}\t {s[2]}\t {s[2]}\t {s[3]}\t {total}\t {avg:.1f}")

# 2.统计各科成绩的最低分、最高分、平均分并输出
#2.1 获取各科的成绩列表
chinese_score = [s[2] for s in student]
math_score = [s[3] for s in student]
english_score = [s[4] for s in student]

print()
#2.2统计各科成绩的最低分、最高分、平均分
print(f"语文最低分:{min(chinese_score)}\t 最高分:{max(chinese_score)}\t 平均分:{sum(chinese_score) / len(chinese_score)}")
print(f"数学最低分:{min(math_score)}\t 最高分:{max(math_score)}\t 平均分:{sum(math_score) / len(math_score)}")
print(f"英语最低分:{min(english_score)}\t 最高分:{max(english_score)}\t 平均分:{sum(english_score) / len(english_score)}")

print()
print("优秀学生")
# 3.查找成绩优秀（平均分大于90的学生）
for s in student:
    total = s[2] + s[3] + s[4]
    avg = total / 3

    if avg > 90:
        print(f"学号:{s[0]}\t 姓名:{s[1]}\t 平均分:{avg:.1f}")

5. 集合set

5.1集合介绍

介绍：集合是一种无序的、不可重复的、可修改的数据容器。

定义：

#定义
s1 = {"A", "B", "C", "D", "E", "F"}

#定义空集合
S2 = set()

注意：空集合的定义不可以使用{}，{}表示的是空字典；由于集合是无序的，因此不支持下标索引访问。

5.2 set常用方法

5.2.1元素的增删与清空 (基础操作)

方法名	功能详细说明	代码示例	结果变化
add(x)	增加单个元素： 如果元素已存在，则忽略。	s = {1, 2} s.add(3)	{1, 2, 3}
update(*others)	批量增加： 把列表、元组、字符串或其他集合里的元素全部加进来，并自动去重。	s = {1} s.update([2, 3])	{1, 2, 3}
remove(x)	严格删除： 删除指定元素。注意：如果元素不存在，会引发 KeyError 报错！	s = {1, 2}   s.remove(1)	{2}
discard(x)	安全删除： 删除指定元素。就算元素不存在，也不会报错。	s = {1, 2}   s.discard(99)	没报错，还是 {1, 2}
pop()	随机弹出： 随机删除并返回一个元素。因为集合是无序的，所以你不知道它会弹哪个。若集合为空会报错。	s = {"A", "B"}   val = s.pop()	删掉一个，val 接收被删的值
clear()	清空： 清空集合里的所有元素，变成空集合 set() 。	s = {1, 2}   s.clear()	set()

5.2.2集合的数学运算（生成“新”集合）

这是集合最强大的地方。有两种写法：操作符（更简洁）或 方法调用（兼容性更好，方法里可以传列表等其他容器，而操作符要求两边必须都是集合）。

(假设 A = {1, 2, 3}, B = {3, 4, 5})

运算类型	操作符写法	方法写法	逻辑含义	返回结果
交集	A & B	A.intersection(B)	找共同点（都有的）	{3}
并集	A | B	A.union(B)	大融合去重（所有的）	{1, 2, 3, 4, 5}
差集	A - B	A.difference(B)	我有你没有的（A里剔除B的元素）	{1, 2}
对称差集	A ^ B	A.symmetric_difference(B)	非共同部分（独有元素的集合）	{1, 2, 4, 5}

5.2.3集合的高级数学运算

方法名	功能说明	代码示例与结果
intersection_update()	原地保留交集： 把 A 变成它和 B 的交集。	A = {1, 2, 3}   A.intersection_update({3, 4})   结果 A 变成了 {3}
difference_update()	原地剔除： 直接从 A 里面删掉 B 中也存在的元素。	A = {1, 2, 3}   A.difference_update({3, 4})   结果 A 变成了 {1, 2}
symmetric_difference_update()	原地保留对称差集： 把 A 变成双方不重合的部分。	同理，直接修改原集合 A

5.2.4关系判断（返回 True / False）

写条件判断语句（if）时极其有用，用来侦测两个集合之间的关系。

(假设 S1 = {1, 2}, S2 = {1, 2, 3})

方法名	操作符	功能说明	语法示例	返回结果
issubset()	<=	是否是子集： 检查前者的所有元素是否都在后者里面。	S1.issubset(S2)	True
issuperset()	>=	是否是超集： 检查前者是否包含了后者的所有元素。	S2.issuperset(S1)	True
isdisjoint()	无	是否无交集： 检查两个集合是否完全没有共同元素。	S1.isdisjoint({4, 5})	True

football_set = {"王琳", "阿牛", "徐丽", "韩立", "唐三", "小舞", "厉飞雨", "紫灵", "妖啸天", "紫燕", "萧炎", "古帝", "霍雨浩"}
basketball_set = {"比比东", "唐昊", "奥斯卡", "贝贝", "韩立", "萧炎", "唐三", "霍雨浩", "李化元", "魂天帝", "古元", "徐三石"}
french_set = {"雅妃", "宁荣荣", "霍雨浩", "唐三", "萧炎", "彩麟", "唐舞桐", "韩立", "云韵", "李化元", "奥斯卡", "比比东"}
art_set = {"美杜莎", "霍雨浩", "姜楠", "菜头", "王冬", "唐三", "萧炎", "古熏儿", "小医仙", "云韵", "马小桃", "小舞"}

# 1.找出同时选修了法语和艺术的学生
fa_set = french_set.intersection(art_set)
print(f"同时选修法语和艺术的学生：{fa_set}")

# 2.找出同时选修了所有课程的同学
all_set = football_set & basketball_set & french_set & art_set
print(f"同时选修了所有课程的同学：{all_set}")

# 3.找出选修了足球，但是没有选修篮球的学生
ff_set = football_set.difference(basketball_set)
print(f"选修了足球，但是没有选修篮球的学生：{ff_set}")

# 4.统计每一个学生选修的课程数量
all_set = football_set | basketball_set | french_set | art_set

all_list = [*football_set, *basketball_set, *french_set, *art_set]

for s in all_list:
    print(f"{s}选修了 {all_list.count(s)} 课程")

6. 字典dict

6.1 dict介绍

dict: 里面存储的是键值对（key: value）类型的数据，可以根据键（key）找到对应应的值（value）。

定义：

dict1 = {key: value, key: value, key: value, ...... }

#定义空字典
dict1 = {}
dict2 = dict()

特点：键值对（key: value）存储、键（key）不可重复、值可修改。

注意：字典中的value可以是任何类型的数据，而key不能为可变类型（如：列表list、集合set、字典dict）

dict1 = {"xiaoming":660, "xiaoshuai":720, "xiaopeng":680, "xiaomi":690}

print(dict1)
print(type(dict1))

#key必须是不可变类型：str\int\float\tuple; 不能是dict\set\list
dict2 = {0:660, 1.5:720, (1,2):680, "xiaomi":690}
print(dict2)

print(dict2[0])
dict2[0] = 730
print(dict2[0])

运行结果：

6.2 常用方法

6.2.1 核心基础：增、删、改、查

操作类型	语法示例	详细说明	结果
查 (精准查找)	d["name"]	通过 Key 获取 Value。注意：如果 Key 不存在，会直接报错 (KeyError)！	返回对应的值
查 (安全查找)	d.get("name")	⭐ 极度推荐！ 查找 Key 的值。如果找不到，默认返回 None ，绝对不会报错。	返回值或 None
增 / 改	d["age"] = 18	如果 age 这个键不存在，就是新增；如果已经存在，就是覆盖修改旧值。	字典中多了一项
删 (指定键)	del d["age"]	删除指定的键值对。如果键不存在会报错。	删掉 age 这一项
删 (弹出并返回)	val = d.pop("age")	删除指定的键，并且把对应的值拿出来赋给变量。	val 等于被删的值
清空	d.clear()	清空字典里的所有内容。	变成 {}

6.2.2 字典的“三驾马车”（视图方法）

当需要用 for 循环遍历字典，或者想整体查看字典内容时，这三个方法是必不可少的。它们会返回类似列表的“视图对象”。

(假设字典 user = {"name": "Tom", "age": 20, "vip": True})

方法名	功能说明	语法示例	返回结果概要
keys()	拿走所有的“锁”： 返回字典里所有的键（Key）。	user.keys()	['name', 'age', 'vip']
values()	拿走所有的“宝物”： 返回字典里所有的值（Value）。	user.values()	['Tom', 20, True]
items()	连锁带宝物全拿： 返回所有的键值对，每一个键值对打包成一个元组。	user.items()	[('name', 'Tom'), ...]

6.2.3 进阶实用方法

在处理复杂业务逻辑（比如合并配置、统计频率）时，这些方法能帮你省去写一堆 if-else 的麻烦。

方法名	功能说明	语法示例
update()	批量更新/合并： 把另一个字典（或键值对序列）里的内容合并到当前字典中。如果有相同的键，新字典的值会覆盖旧值。	d1.update(d2)
setdefault()	佛系赋值： 如果键存在，返回对应的值，什么都不做；如果键不存在，才增加这个键并赋给它一个默认值。	d.setdefault("score", 60)
popitem()	删除最后一项： 删除并返回字典中最后被加进去的那一个键值对（以元组形式返回）。	k, v = d.popitem()

dict1 = {"xiaoming":660, "xiaoshuai":720, "xiaopeng":680, "xiaomi":690}

#增加
dict1["xiaohua"] = 700
print(dict1)
print(dict1["xiaohua"])

#修改
dict1["xiaohua"] = 725
print(dict1["xiaohua"])

#查找
value1 = dict1["xiaoming"]
value2 = dict1.get("xiaoming")
print(value1, value2)

print(dict1.keys()) #获取所有的key
print(dict1.values()) #获取字典里所有的值
print(dict1.items()) #获取所有的键值对 key:value

#删除
value3 = dict1.pop("xiaohua")
print(value3)

运行结果;

7. 数据容器总结与对比

特性	字符串 (str)	列表 (list)	元组 (tuple)	集合 (set)	字典 (dict)
有序性	有序	有序	有序	无序	有序(3.7+)
重复元素	允许	允许	允许	不允许	key不允许
可变性	不可变	可变	不可变	可变	可变
索引访问	支持	支持	支持	不支持	不支持
切片操作	支持	支持	支持	不支持	不支持
使用场景	文本处理	有序可重复数据集合	固定数据记录	去重数据集合	键值对