DAY7 列表类型内置方法 元组类型内置方法 字典类型内置方法 集合类型内置方法 数据类型总结+深浅拷贝

一、列表类型内置方法 (List)

特点：有序、可变、可存储多个值
内置方法：

# 定义列表
fruits = ['apple', 'banana', 'cherry']

# 常用操作
print(fruits[1])# 索引取值 → 'banana'
print(fruits[-1])# 反向索引 → 'cherry'
print(fruits[1:3])# 切片 → ['banana', 'cherry']
fruits.append('orange')# 追加 append
fruits.insert(1, 'pear')# 插入
fruits.remove('banana')# 移除元素
popped = fruits.pop(2)# 删除并返回

二、元组类型内置方法 (Tuple)

特点：有序、不可变
内置方法：

按键取值
tup = ("Alice", 25, "New York")
print(tup[0])  # 输出：Alice
print(tup[-1]) # 输出：New York（负索引表示从后往前）

获取长度（len()）
tup = (1, 2, 3, 4, 5)
print(len(tup))  # 输出：5

成员运算（in / not in）
tup = ("a", "b", "c")
print("a" in tup)    # 输出：True
print("d" not in tup) # 输出：True

for 循环遍历
tup = ("Python", "Java", "C++")
for lang in tup:
    print(lang)
# Python Java C++

三、字典类型内置方法 (Dict)

特点：无序、可变、键值对存储
内置方法：

按键取值
user = {"name": "Alice", "age": 25}
print(user["name"])  # 输出：Alice
print(user.get("age"))      # 输出：25
print(user.get("job", "N/A"))  # 不存在则添加，输出：N/A

计算长度（len()）
print(len(user))  # 输出：2（键值对数量）

成员运算（in / not in）
print("name" in user)     # 输出：True
print("job" not in user)  # 输出：True

for 循环遍历
for key, value in user.items():
    print(f"{key}: {value}")
# name: Alice  age: 25

方法	说明	示例
dict.keys()	返回所有键	print(user.keys()) → dict_keys(['name', 'age'])
dict.values()	返回所有值	print(user.values()) → dict_values(['Alice', 25])
dict.items()	返回所有键值对	print(user.items()) → dict_items([('name', 'Alice'), ('age', 25)])

总结

操作	方法	说明
按键取值	dict[key] / dict.get(key, default)	获取值，get() 更安全
长度	len(dict)	键值对数量
成员检查	key in dict	判断键是否存在
遍历	for key in dict / dict.items()	遍历键或键值对
获取键值	keys() / values() / items()	返回视图对象
删除	pop(key) / popitem() / del / clear()	删除键值对或清空

四、集合类型内置方法 (Set)

特点：无序、可变、自动去重
内置方法：

nums = {1, 2, 3}
nums.add(4)# 添加元素
nums.remove(2)# 移除
print(a & b)       # 交集 → {3}
print(a | b)       # 并集 → {1, 2, 3, 4, 5}
print(a - b)       # 差集（在a但不在b）→ {1, 2}
print(a ^ b)       # 对称差集（仅出现在一个集合中）→ {1, 2, 4, 5}

---

数据类型对比

类型	有序性	可变性	元素要求	典型用途
列表	有序	可变	任意类型	存储有序数据集合
元组	有序	不可变	任意类型	不可变数据记录
字典	无序	可变	键必须可哈希	键值对映射
集合	无序	可变	必须可哈希	去重和集合运算

---

深浅拷贝示例

import copy

# 原始列表
original = [1, [2, 3], 4]

# 浅拷贝
shallow = copy.copy(original)
original[1][0] = 'X'# 修改嵌套列表
print(shallow)# [1, ['X', 3], 4] (受影响)

# 深拷贝
deep = copy.deepcopy(original)
original[1][1] = 'Y'
print(deep)# [1, ['X', 3], 4] (不受影响)

关键区别：

• 浅拷贝：只复制第一层，嵌套对象共享引用
• 深拷贝：完全独立复制所有层级对象