基本数据类型

• Number（数字）
• String（字符串）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Number

        数字Number包括int（整数），float（浮点数），complex（复数）。Number是不可变的，虽然变量是同一个，但是变量指向的内存地址变了（原地址由 Python 的GC机制回收）。

# 不可变：修改会生成新对象
x = 5
print(id(x))  
x = x + 1     
print(id(x)) 

# 输出结果
# 140727733242424
# 140727733242456

String

        字符串String由字符组成的有序序列，用单引号 / 双引号 / 三引号包裹，用于表示文本。

# 定义
s1 = 'hello'
s2 = "world"
s3 = '''多行
字符串'''         # 三引号支持换行

# 常用操作
print(s1[0])     # 索引：取第1个字符，输出 h（字符串有序，从0开始）
print(s1[1:4])   # 切片：取第2-4个字符，[1,4)
print(s1 + s2)   # 拼接：输出 helloworld
print(s1 * 2)    # 重复：输出 hellohello
len(s1)          # 长度：5

       String是不可变的，只能生成新对象。 字符串可通过for循环遍历，但是不能通过索引修改单个字符。

s = 'hello'
print(id(s))
s = 'H' + s[1:]    # s[0] = 'H'报错
print(id(s))

# 输出结果
# 1941506332144
# 1941506334352

bool

        布尔值bool只有两个值：True（真，1）和False（假，0），用于条件判断。不可变。

List

        列表List是有序、可重复的元素集合，用[]包裹，元素可以是任意类型（数字、字符串、列表等），是 Python 最常用的可变类型。

# 定义
lst = [1, 'hello', True, [3,4]]  # 支持嵌套
print(lst, type(lst))  # 输出：[1, 'hello', True, [3, 4]] <class 'list'>

# 常用操作（增删改查）
# 查：索引/切片
print(lst[1])          # 输出 hello
print(lst[2:4])        # 输出 [True, [3, 4]]

# 改：直接修改元素
lst[0] = 100
print(lst)             # 输出：[100, 'hello', True, [3, 4]]

# 增：append（末尾加）、insert（指定位置加）
lst.append('world')
lst.insert(2, 'python')
print(lst)             # 输出：[100, 'hello', 'python', True, [3, 4], 'world']

# 删：pop（删指定位置）、remove（删指定值）
lst.pop(3)             # 删除第4个元素（True）
lst.remove('hello')    # 删除值为hello的元素
print(lst)             # 输出：[100, 'python', [3, 4], 'world']

        List可变，修改List后内存地址不变，但修改的具体元素指向的内存地址变化依赖于自身特点。

 Tuple

        元组Tuple是有序、可重复的元素集合，用 () 包裹（空元组为 ()，单元素元组需加逗号，如 (1, )），可理解为 “不可变的列表”，和列表相比更节省内存。

# 1. 定义
t1 = (1, 'hello', True)
t2 = (1,)  # 单元素元组必须加逗号，否则会被识别为数字
t3 = ()    # 空元组
print(t1, type(t1))  # 输出：(1, 'hello', True) <class 'tuple'>

# 2. 常用操作（只能查，不能改）
print(t1[0])     # 输出 1
print(t1[1:3])   # 输出 ('hello', True)

# 不可变：无法修改元素
# t1[0] = 100  # 报错：TypeError: 'tuple' object does not support item assignment

# 特殊：元组内的可变元素（如列表）可修改（但元组本身的引用不变）
t = (1, [2,3])
t[1].append(4)
print(t)  # 输出：(1, [2, 3, 4])（元组地址仍不变）

Dictionary

        字典Dict是无序的 “键值对” 集合，用 {key:value} 包裹，键唯一且不可变（如数字、字符串、元组），值（value）可任意类型，是 Python 中存储结构化数据的核心类型。字典可变。

# 1. 定义
dic = {
    'name': '小明',
    'age': 18,
    'hobbies': ['篮球', '游戏']  # 值可以是列表（可变）
}
print(dic, type(dic))  # 输出：{'name': '小明', 'age': 18, 'hobbies': ['篮球', '游戏']} <class 'dict'>

# 2. 常用操作（增删改查）
# 查：通过键取值
print(dic['name'])        # 输出 小明
print(dic.get('age'))     # 输出 18（推荐用get，键不存在返回None，不报错）
print(dic.get('gender'))  # 输出 None

# 改：直接通过键修改值
dic['age'] = 19
print(dic)  # 输出：{'name': '小明', 'age': 19, 'hobbies': ['篮球', '游戏']}

# 增：新增键值对
dic['gender'] = '男'
print(dic)  # 输出：{'name': '小明', 'age': 19, 'hobbies': ['篮球', '游戏'], 'gender': '男'}

# 删：pop（删指定键）、del
dic.pop('gender')
del dic['age']
print(dic)  # 输出：{'name': '小明', 'hobbies': ['篮球', '游戏']}

Set

        集合Set是无序、不可重复的元素集合，用 {} 包裹（空集合必须用set()表示，不能用{}，{}表示字典），主要用于去重、交集 / 并集等集合运算。集合可变。

# 1. 定义
s = {1, 2, 2, 'hello'}  # 自动去重
print(s, type(s))  # 输出：{1, 2, 'hello'} <class 'set'>
empty_set = set()  # 空集合

# 2. 常用操作（增删、集合运算）
# 增：add（单个元素）、update（多个元素）
s.add(3)
s.update([4,5])
print(s)  # 输出：{1, 2, 3, 4, 5, 'hello'}

# 删：remove（元素不存在报错）、discard（元素不存在不报错）
s.remove(2)
s.discard(10)  # 无报错
print(s)       # 输出：{1, 3, 4, 5, 'hello'}

# 集合运算：交集（&）、并集（|）、差集（-）
s1 = {1,2,3}
s2 = {3,4,5}
print(s1 & s2)  # 交集：{3}
print(s1 | s2)  # 并集：{1,2,3,4,5}
print(s1 - s2)  # 差集：{1,2}

复杂数据结构总结

核心方法：