📚 今日学习目标

1. 理解有序/无序、可变/不可变、可重复/不可重复的区别
2. 掌握列表、字符串、元组、集合、字典的定义与核心特性
3. 掌握运用各容器的增删改查操作及常用方法
4. 学会容器的合并技巧与解包组包机制

---

一、容器概述

1.1 什么是容器？

容器是一种可以容纳多份数据的类型，其中的每一份数据称为元素。元素可以是任意数据类型（数字、字符串、甚至另一个容器）。

1.2 容器的核心特性

我们通过三个维度来区分不同容器：

• 有序性：元素是否按照定义的顺序排列（可以通过索引访问）。
• 可重复性：是否允许相同值的元素存在。
• 可变性：容器本身是否可以修改（增删改元素）。

1.3 了解五种容器的特点

下表总结了Python中五种主要容器的特性：

容器类型	有序性	可重复性	可变性	定义符号
列表(list)	✅ 有序	✅ 可重复	✅ 可变	[ ]
字符串(str)	✅ 有序	✅ 可重复	❌ 不可变	’ ’ 或 " " 或 ‘’’ ‘’’
元组(tuple)	✅ 有序	✅ 可重复	❌ 不可变	( )
集合(set)	❌ 无序	❌ 不可重复	✅ 可变	{ } (空集用set())
字典(dict)	有序*	键不可重复	✅ 可变	{key:value}

*注：Python 3.7+ 中字典会保持插入顺序，在此之前字典无序。

---

二、列表（list)

2.1 特点

• 有序：元素按照定义顺序排列，可通过索引访问。
• 可重复：允许相同值的元素多次出现。
• 可变：可以增加、删除、修改元素。

2.2 定义

# 定义变量 列表名称=[元素1,元素2,元素3,..]
s=[1,2,"helloworld",1.314]
# 定义空列表 列表名称=[] or 列表名称=list()
a=[]
b=list()

2.3 访问元素

2.3.1 索引

访问形式：列表名[索引]

• 正向索引：从前向后，下标从0开始，范围是 0 ~ len-1
• 反向索引：从后往前，下标从-1开始，范围是 -1 ~ -len
  
  ⚠️ 注意索引不要越界！索引访问时，注意索引的范围不要越界！

2.3.2 切片

切片是对操作的数据截取其中的一部分。*序列类型容器均支持切片。

切片格式：容器名称[开始索引:结束索引:步长]

说明：

1. 左闭右开区间，取开始索引值，不取结束索引值
2. 开始索引默认值为0，结束索引默认值为列表长度len，步长默认值为1
3. 取默认值时，第2个冒号可以省略，第1个冒号不可省略
4. 索引可使用正向索引也可以使用反向索引，步长可以正数也可以负数

l=[0,1,2,3,4,5,6,7,8,9]
print(l[:-10]) #开始索引：0（元素0）结束索引：-10（元素0）步长：1 输出：[]
print(l[-1:])  #开始索引：-1（元素9）结束索引：9（元素9）步长：1 输出：[9]
print(l[:])    #开始索引：0 结束索引：列表末尾10 步长：1 输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l[2:-1]) #开始索引：2(元素2）结束索引：-1（元素9）步长：1 输出：[2, 3, 4, 5, 6, 7, 8]
print(l[::-1]) #开始索引：0 结束索引：列表末尾10 步长：-1 输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

*注：序列类型容器：元素有序、支持索引访问，可迭代。如：列表、字符串、元组。

2.4 增删改操作

操作	方法/语法	说明
增加	append(x)	在末尾添加元素x
	insert(i, x)	在索引i处插入元素x
	extend(iterable)	将另一个可迭代对象的所有元素追加到末尾
删除	del 列表[i]	删除索引i处的元素
	remove(x)	删除第一个值为x的元素
	pop(i)	删除并返回索引i处的元素（默认最后一个）
	clear()	清空所有元素
修改	列表[i] = 新值	直接赋值修改指定位置的元素

2.5 其他常用方法

• sort()：原地排序（可指定reverse=True）
• reverse()：原地反转
• index(x)：返回第一个x的索引
• count(x)：统计x出现的次数

2.6 练习案例：合并两个列表并去重排序

# 合并两个列表中的元素，并对合并的结果进行去重处理
num_list1=[19,23,54,64,875,20,109,232,123,54]
num_list2=[55,80,72,35,60,123,54,29,91]

# 合并
num_list1.extend(num_list2)
# 也可以：num_list1 += num_list2

# 去重
num_list=[]
for element in num_list1:
    if element not in num_list:
        num_list.append(element)

# 排序
print(num_list) # [19, 23, 54, 64, 875, 20, 109, 232, 123, 55, 80, 72, 35, 60, 29, 91]
num_list.sort()
print(num_list) # [19, 20, 23, 29, 35, 54, 55, 60, 64, 72, 80, 91, 109, 123, 232, 875]

---

三、字符串（str)

3.1 特点

• 有序：字符按顺序排列，支持索引和切片。
• 可重复：允许相同字符多次出现。
• 不可变：不能直接修改字符串本身，任何修改操作都会生成新字符串。

3.2 定义

使用单引号、双引号或三引号（三引号可跨行）

# 单引号
s1='Helloworld'
# 双引号
s2="Helloworld"
# 三引号
s3='''Helloworld'''

3.3 访问元素

访问格式：字符串名称[索引]
与列表一样支持索引和切片

3.4 常用方法

方法	说明
find(sub)	返回子串sub第一次出现的索引，找不到返回-1
count(sub)	统计子串sub出现的次数
upper() / lower()	全部大写/小写
split(sep)	按sep分割成列表
strip()	去除两端空白字符
replace(old, new)	替换所有old为new
startswith(x)	检查是否以x开头

---

四、元组(tuple)

4.1 特点

• 有序：元素按照定义顺序排列，可通过索引访问。
• 可重复：允许相同值的元素多次出现。
• 不可变：不能直接修改元组本身，任何修改操作都会生成新元组。

4.2 定义

# 定义元组：元组名称=（元素1，元素2，元素3，..）
t=(1,2,3,"hello",1.314)
# 定义空元组：元组名称=（） or  元组名称=tuple（）
t1=()
t2=tuple()
# 注意定义单个元素为元组时，后要加逗号 ,
t3=(1)
print(type(t3)) # <class 'int'>
t4=(1,)
print(type(t4)) # <class 'tuple'>

4.3 访问元素

访问格式：元组名称[索引]
与列表一样支持索引和切片

4.4 常用方法

• index(x)：返回第一个x的索引
• count(x)：统计x出现的次数

---

五、集合(set)

5.1 特点

• 无序：元素没有固定顺序。
• 不可重复：自动去重，相同元素只保留一个。
• 可变：可以增删改元素。

5.2 定义

# 定义集合变量 集合名称={元素1，元素2，元素3，..}
s={1,2,3,"hello",3.14}
# 定义空集合 集合名称=set()
s1=set()

*注意：集合的定义符号是花括号{}，但是定义空集合不能写成：集合名称={} 这个定义的是字典(dict)

s={1,2,3,1,2,3.14}
print(s) # {3, 1, 2, 3.14} (无序，不允许重复，自动删除重复元素）

5.3 访问元素

集合不能索引访问：因为集合设计为无序，顺序不可预测且可能变化。

5.4 增删改操作

操作	方法/语法	说明
增加	add(x)	添加元素x，如果已存在则无效果
删除	remove(x)	删除x
	pop()	随机删除并返回一个元素（常用于获取任意元素）
	clear()	清空集合

s = {1, 2, 3}
s.add(4)            # {1, 2, 3, 4}
s.remove(2)         # {1, 3, 4}
elem = s.pop()      # 随机弹出一个元素（可能是1）
print(elem)         # 1 (剩余 {3, 4})

5.5 集合运算

• 差集：s1 - s2 或 s1.difference(s2)
• 并集：s1 | s2 或 s1.union(s2)
• 交集：s1 & s2 或 s1.intersection(s2)

---

六、字典(dict)

什么是字典？通过字，找到对应的解释，且字是不可能重复的。在python中，字典(dict)存储的是键值对(key：value)类型的数据，可以根据键(key)找到对应的值(value)。

6.1 特点

• 有序：Python 3.7+ 保持插入顺序（此前无序）。
• 键不可重复：字典中的键必须是唯一的，值可以重复。
• 可变：可以增删改键值对。

6.2 定义

# 定义集合变量 字典名称={key1：1，key2：2，key3：3，...}
d={"张三":91,"丽丝":100}
# 定义空集合 字典名称={} or 字典名称=dict()
d1={}
d2=dict()

*注意：键必须是不可变类型（如数字、字符串、元组），值可以是任意类型。

6.3 访问

• 通过键获取值：字典[键]，若键不存在会报错
• 安全获取方法：字典.get(键, 默认值)，不存在时返回默认值
• 获取所有键/值/项：
  • keys() → dict_keys对象（可迭代）
  • values() → dict_values对象
  • items() → dict_items对象（键值对元组）

d = {"name": "Alice", "age": 25}
print(d["name"])          # Alice
print(d.get("gender"))    # None
print(d.get("gender", "未知"))  # 未知

print(list(d.keys()))     # ['name', 'age']
print(list(d.values()))   # ['Alice', 25]
print(list(d.items()))    # [('name', 'Alice'), ('age', 25)]

6.4 增删改操作

操作	语法	说明
增加	字典[新键] = 新值	键不存在时添加新的键值对
修改	字典[已存在的键] = 新值	键存在时修改对应的值
删除	del 字典[键]	删除指定键的键值对
	pop(键)	删除并返回该键对应的值
	clear()	清空字典

---

七、容器间的操作

7.1 合并容器

• 序列类型（列表、字符串、元组）：使用 + 运算符拼接，生成新容器。
• 集合：使用 | 求并集，& 求交集，- 求差集 等。
• 字典：使用 update()
• 通用合并（解包方式）

l=[1,2,3]
s="Hello"
t=(1,2,3,"hello")
se={4,9,8}
d={"张三":100}
n=(*t,*s,*l,*se,*d)
print(n) #(1, 2, 3, 'hello', 'H', 'e', 'l', 'l', 'o', 1, 2, 3, 8, 9, 4, '张三')

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged_dict = {**dict1, **dict2}
print(merged_dict)  
# 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

*注意：+ 对序列是拼接，|、-、& 对集合是集合运算，这些都是运算符重载的体现。这些运算符通常只能作用于相同类型，因为每个类只实现了与自己类型匹配的运算逻辑。

# 列表 + 列表
print([1, 2] + [3, 4])      # [1, 2, 3, 4]

# 字符串 + 字符串
print("Hello" + " " + "World")  # Hello World

# 元组 + 元组
print((1, 2) + (3, 4))       # (1, 2, 3, 4)

7.2 解包和组包

7.2.1 组包

组包：将多个值合并到一个容器中。

• 基础组包：

# 定义元组，组包
t1=(5,7,9,1)
# 定义元组，组包
t2=5,7,9,1

print(type(t1),type(t2)) # <class 'tuple'> <class 'tuple'>

• 函数参数组包
  在定义函数时，*args 将任意数量的位置参数打包成一个元组；**kwargs 将任意数量的关键字参数打包成一个字典。

def my_func(*args, **kwargs):
    print("位置参数:", args)
    print("关键字参数:", kwargs)

my_func(1, 2, 3, a=4, b=5)
# 输出:
# 位置参数: (1, 2, 3)
# 关键字参数: {'a': 4, 'b': 5}

7.2.2 解包

解包：将容器拆开成独立的元素，赋给多个变量。

• 基础解包：变量数量必须与元素个数一致。

# 元组解包
a, b, c = (1, 2, 3)
print(a, b, c)   # 输出: 1 2 3
# 列表解包
x, y, z = [10, 20, 30]
print(x, y, z)   # 10 20 30
# 字符串解包
p, q, r = "ABC"
print(p, q, r)   # A B C

# 集合（注意顺序可能不固定）
s = {5, 6, 7}
m, n, p = s
print(m, n, p)   # 例如 5 6 7（顺序可能不同）

# 字典（默认解包键）
d = {'a': 1, 'b': 2}
k1, k2 = d
print(k1, k2)    # a b

# 生成器
gen = (i**2 for i in range(3))
u, v, w = gen
print(u, v, w)   # 0 1 4

• 扩展解包（使用 *）：收集多余的元素到列表

first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 1
print(middle)  # [2, 3, 4] *middle 将中间部分收集为一个列表
print(last)    # 5

head, *tail = "Hello"
print(head)    # H
print(tail)    # ['e', 'l', 'l', 'o']

• 函数调用解包
  在调用函数时，可以使用 * 将可迭代对象拆开作为位置参数传递，使用 ** 将字典拆开作为关键字参数传递。

def add(a, b, c):
    return a + b + c

nums = [1, 2, 3]
print(add(*nums))          # 6

def greet(name, age):
    print(f"{name} is {age} years old.")

info = {'name': 'Alice', 'age': 25}
greet(**info)              # Alice is 25 years old.

*dict 与 **dict 的区别:

语法	解包结果	常用场景
*dict	字典的键	将字典的键展开到列表/元组/集合中，或作为函数的位置参数
**dict	字典的键值对	合并字典，或作为函数的关键字参数

---

以上为个人学习总结，旨在梳理个人理解。如有疏漏或不当之处，欢迎指正与交流。