0基础python组合数据类型学习-CSDN博客

1.列表

一、基础定义

列表是 Python 中最常用的组合数据类型，用于存储多个元素。
特点：

可变：可以修改、添加或删除元素。
有序：元素按插入顺序排列，可通过索引访问。
可重复：允许存储重复元素。
异构：可以存储不同类型的元素（如整数、字符串、列表等）。

二、创建列表

# 空列表
empty_list = []  # 或 list()

# 包含元素的列表
numbers = [1, 2, 3, 4]
mixed = [1, "hello", True, [5, 6]]  # 异构列表
nested = [[1, 2], [3, 4]]  # 嵌套列表

# 通过构造函数创建
constructed = list("hello")  # ['h', 'e', 'l', 'l', 'o']

三、基本操作

1. 访问元素

my_list = ["apple", "banana", "cherry"]

# 通过索引访问（从0开始）
print(my_list[0])  # 输出：apple
print(my_list[-1])  # 输出：cherry（负数索引表示从后往前）

# 切片：获取子列表 [start:stop:step]
print(my_list[1:3])  # 输出：['banana', 'cherry']
print(my_list[::2])  # 输出：['apple', 'cherry']（步长为2）

2. 修改元素

my_list = [1, 2, 3]
my_list[0] = 100  # 修改第一个元素
print(my_list)  # 输出：[100, 2, 3]

3. 添加元素

my_list = [1, 2]

my_list.append(3)  # 在末尾添加单个元素
my_list.extend([4, 5])  # 在末尾添加多个元素（扩展列表）
my_list.insert(1, 100)  # 在指定位置插入元素（索引1处）

print(my_list)  # 输出：[1, 100, 2, 3, 4, 5]

4. 删除元素

my_list = [1, 2, 3, 2]

my_list.remove(2)  # 删除首个值为2的元素
popped = my_list.pop()  # 删除并返回最后一个元素
del my_list[0]  # 删除指定索引的元素

print(my_list)  # 输出：[3]

5. 查询元素

my_list = [1, 2, 3, 2]

index = my_list.index(2)  # 返回首个值为2的索引（输出：1）
count = my_list.count(2)  # 统计值为2的元素数量（输出：2）
exists = 3 in my_list  # 判断元素是否存在（输出：True）

四、常用方法

方法	描述
`append(x)`	在列表末尾添加元素 `x`。
`extend(iterable)`	将可迭代对象（如列表、元组）的元素添加到列表末尾。
`insert(i, x)`	在索引 `i` 处插入元素 `x`。
`remove(x)`	删除首个值为 `x` 的元素，若不存在则报错。
`pop([i])`	删除并返回索引 `i` 处的元素（默认删除最后一个）。
`clear()`	清空列表所有元素。
`index(x)`	返回首个值为 `x` 的索引，若不存在则报错。
`count(x)`	统计值为 `x` 的元素出现的次数。
`sort(key=None, reverse=False)`	原地排序（升序），可通过 `reverse=True` 降序。
`reverse()`	原地反转列表元素的顺序。
`copy()`	返回列表的浅拷贝（创建新列表，但元素引用相同）。

五,进阶操作

1. 列表推导式

语法：[表达式 for 变量 in 可迭代对象 [条件]]
示例：

# 生成平方数列表
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# 过滤偶数
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# 嵌套推导式（二维列表转一维）
matrix = [[1, 2], [3, 4]]
flattened = [num for row in matrix for num in row]  # [1, 2, 3, 4]

2. 浅拷贝 vs 深拷贝

# 浅拷贝（仅复制外层结构，内部元素引用相同）
original = [1, [2, 3]]
shallow_copy = original.copy()  # 或 original[:]
shallow_copy[1][0] = 99  # 修改内部列表
print(original)  # 输出：[1, [99, 3]]（原列表也被修改）

# 深拷贝（完全独立的副本）
import copy
deep_copy = copy.deepcopy(original)
deep_copy[1][0] = 100
print(original)  # 输出：[1, [99, 3]]（原列表不受影响）

3. 常用内置函数

my_list = [3, 1, 4]

length = len(my_list)  # 长度：3
total = sum(my_list)  # 求和：8
max_val = max(my_list)  # 最大值：4
min_val = min(my_list)  # 最小值：1

sorted_list = sorted(my_list)  # 返回新的排序列表：[1, 3, 4]
reversed_list = list(reversed(my_list))  # 返回反转后的列表：[4, 1, 3]

2,元组

一、基础定义

不可变：创建后不能修改元素。
有序：可通过索引访问。
异构：支持不同类型元素。

二、创建元组

empty = ()                # 空元组
single = (1,)             # 单元素元组（必须加逗号）
mixed = (1, "a", [2, 3])  # 异构元组
implicit = 1, 2, 3        # 省略括号（推荐）

三、核心操作

访问元素：

t = ("a", "b", "c")
print(t[0])     # 输出：a
print(t[-1])    # 输出：c（负数索引）
print(t[1:3])   # 输出：('b', 'c')（切片）

元组解包：

x, y = (1, 2)   # x=1, y=2
a, b= (1, 2, 3)  # a=1, b=[2, 3]

查询方法：

t = (1, 2, 2)
print(t.index(2))  # 输出：1（首个索引）
print(t.count(2))  # 输出：2（出现次数）

四、不可变性

元组本身不可变，但内部可变元素（如列表）可修改：

t = (1, [2, 3])
# t[0] = 100  # 报错！元组不可变
t[1][0] = 99  # 允许！修改列表内部
print(t)      # 输出：(1, [99, 3])

五、注意事项

单元素元组需逗号：(1,) 而非 (1)。
不可变元素限制：元组元素必须全部可哈希（如不可包含列表）。

3，字典

一、基础定义

无序键值对集合（3.7+ 保持插入顺序）
键必须唯一且可哈希（如字符串、数字、元组）
值可为任意类型

二、创建字典

empty = {}  # 空字典
person = {
    "name": "Alice",
    "age": 30,
    "hobbies": ["reading", "swimming"]
}

# 快捷方式
from_pairs = dict([("x", 1), ("y", 2)])  # {'x': 1, 'y': 2}

三、核心操作

1，访问值

print(d["name"])  # 输出：Alice
print(d.get("age", 25))  # 安全访问，默认值 25

2，修改/添加

d["age"] = 30     # 添加新键值对
d["name"] = "Bob" # 修改已有值
d.update({"city": "Beijing"})  # 批量更新

3，删除

del d["age"]
d.pop("city", None)  # 安全删除

四、常用方法

方法	作用
`keys()`	返回所有键
`values()`	返回所有值
`items()`	返回所有键值对
`get(key, default)`	安全获取值（不存在返回默认值）
`update()`	合并字典（覆盖重复键）
`pop(key)`	删除并返回值

五、字典推导式

# 生成平方数
squares = {x: x**2 for x in range(3)}  # {0: 0, 1: 1, 2: 4}

# 筛选偶数
evens = {x: x**2 for x in range(5) if x % 2 == 0}  # {0: 0, 2: 4, 4: 16}

六、注意事项

键必须不可变：

valid = {(1, 2): "point"}  # 元组可哈希
# invalid = {[1, 2]: "point"}  # 列表不可哈希（报错

4，集合

一、基础特性

无序、唯一、元素可哈希
空集合：set()（注意：{} 是字典）

二、核心操作

创建与去重

s = {1, 2, 2}  # 自动去重为 {1, 2}
s = set([1, 2, 2])  # 从列表转换

修改

s.add(3)        # 添加元素
s.update([3,4]) # 批量添加
s.remove(2)     # 删除（不存在则报错）
s.discard(2)    # 安全删除
s.pop()         # 随机删除并返回
s.clear()       # 清空

查询

3 in s          # 判断元素是否存在
len(s)          # 获取元素个数

三、集合运算

操作	语法	示例（`a={1,2}`, `b={2,3}`）
并集	`a	b`	`{1,2,3}`
交集	`a & b`	`{2}`
差集	`a - b`	`{1}`
对称差	`a ^ b`	`{1,3}`

四、推导式

s = {x**2 for x in [1,2,2]}  # {1,4}（自动去重）

五、注意事项

元素必须可哈希（如 int, str, tuple）
不可用列表、字典等可变类型作为元素