# 空列表
empty_list = []
# 包含不同类型元素的列表
mixed_list = [1,"Python",True,3.14,[10,20]]
# 通过 list()函数创建(可将其他可迭代对象转为列表)
from_str = list("hello")    # ['h','e','l','l','o']
from_range = list(range(5))    # [0,1,2,3,4]

nums = [10,20,30,40,50]
# 单个元素
print(nums[0])    # 10(正向索引)
print(nums[-1])    # 50(反向索引)
# 切片
print(nums[1:4])    # [20,30,40](索引 1 到 3)
print(nums[:3])    # [10,20,30](从开头到索引 2)
print(nums[::2])    # [10,30,50](步长 2,隔一个取一个)

fruits = ["苹果","香蕉","橙子"]
fruits[1] = "葡萄"    # 修改第二个元素
print(fruits)    # ['苹果','葡萄','橙子']

# 增
nums = [10,20,30]
nums.append(40)    # [10,20,30,40]
nums.extend([50,60])    # [10,20,30,40,50,60]
nums.insert(1,15)    # [10,15,20,30,40,50,60]
# 删
nums.remove(30)    # [10,15,20,40,50,60]
pop_num = nums.pop()    # 删除最后一个元素 60,pop_num=60
nums.clear()    # 清空列表→[]
# 查/统计
fruits = ["苹果","香蕉","苹果","橙子"]
print(fruits.index("苹果"))    # 0
print(fruits.count("苹果"))    # 2
# 排序/反转
scores = [85,92,78,90]
scores.sort()    # 升序→[78,85,90,92]
scores.sort(reverse=True)    # 降序→[92,90,85,78]
scores.reverse()    # 反转→[78,85,90,92]

# 基本格式:[表达式 for 变量 in 可迭代对象 if 条件]
# 示例1:生成1~10的平方列表
squares = [x * x for x in range(1,11)]    # [1,4,9,...,100]
# 示例2:筛选偶数
evens = [x for x in range(1,20) if x % 2 == 0]    # [2,4,...,18]

# 遍历元素
fruits = ["苹果","香蕉","橙子"]
for fruit in fruits:
    print(fruit)

a = [1,2,3]
b = [4,5,6]
# 拼接
c = a + b    # [1,2,3,4,5,6]
# 重复
d = a * 3    # [1,2,3,1,2,3,1,2,3]

# 空元组
empty_tuple = ()
# 多元素元组(标准写法)
num_tuple = (10,20,30,40)
# 多元素元组(省略括号:Python 仍识别为元组)
fruit_tuple = "苹果","香蕉","橙子"
# 单元素元组(必须加逗号！否则只是普通变量)
single_tuple = (50,)    # 正确的单元素元组
wrong_single = (50)    # 本质是整数 50,不是元组
print(type(single_tuple))    # <class 'tuple'>
print(type(wrong_single))    # <class 'int'>
# 通过 tuple()函数创建(转换其他可迭代对象)
from_list = tuple([1,2,3])    # (1,2,3)
from_str = tuple("hello")    # ('h','e','l','l','o')

t = (100,200,300,400,500)
# 单个元素访问
print(t[0])    # 100(正向索引,第一个元素)
print(t[-1])    # 500(反向索引,最后一个元素)
# 切片(左闭右开,步长可选)
print(t[1:4])    # (200,300,400)(索引 1 到 3)
print(t[::2])    # (100,300,500)(步长 2)
print(t[::-1])    # (500,400,300,200,100)(反转元组)

# 错误示例:直接修改元组元素(报错)
t1 = (1,2,3)
# t1[0] = 100    # TypeError:'tuple' object does not support item assignment
# 合法示例:修改元组中的可变元素(列表)
t2 = (1,[2,3],4)
t2[1][0] = 200    # 修改元组内列表的元素
print(t2)    # (1,[200,3],4)
# 间接"修改"元组:拼接生成新元组
t3 = (10,20)
t4 = t3 + (30,40)    # 生成新元组,原元组 t3 不变
print(t3)    # (10,20)
print(t4)    # (10,20,30,40)

t = ("苹果","香蕉","苹果","橙子","香蕉")
# 查找元素索引
print(t.index("香蕉"))    # 1
# 统计元素次数
print(t.count("苹果"))    # 2

t = ("周一","周二","周三")
# 遍历元素
for day in t:
    print(day)
# 遍历索引+元素(用 enumerate)
for idx,day in enumerate(t):
    print(f"索引{idx}:{day}")    # 索引 0:周一,索引 1:周二...

# 基础解包
t = (18,"小明","男")
age,name,gender = t    # 解包赋值
print(age)    # 18
print(name)    # 小明
# 扩展解包(*接收多个元素)
t2 = (1,2,3,4,5)
a,*b,c = t2    # a=1,c=5,b 接收中间所有元素
print(a)    # 1
print(b)    # [2,3,4](注意:*接收的结果是列表)
print(c)    # 5
# 函数返回多值(本质是元组解包)
def get_info():
    return "小红",20,"女"    # 省略括号的元组
name,age,gender = get_info()    # 解包函数返回的元组
print(f"姓名:{name},年龄:{age}")

t1 = (1,2)
t2 = (3,4)
# 拼接
t3 = t1 + t2    # (1,2,3,4)
# 重复
t4 = t1 * 3    # (1,2,1,2,1,2)

# 空字典
empty_dict = {}
# 标准创建(键值对形式)
user = {"name":"小明","age":18,"gender":"男"}
# 用 dict()函数创建(关键字参数)
user2 = dict(name="小红",age=20,gender="女")
# 从键值对列表创建(双值子序列)
kv_list = [("math",90),("chinese",85)]
scores = dict(kv_list)    # {'math':90,'chinese':85}
# 字典推导式(高效创建,后续讲解)
num_dict = {x: x*2 for x in range(1,4)}    # {1:2,2:4,3:6}

user = {"name":"小明","age":18}
# 方法1:直接通过键访问(键不存在会报错)
print(user["name"])    # 小明
# print(user["height"])    # KeyError:'height'
# 方法2:get()方法(键不存在返回 None 或指定默认值,推荐)
print(user.get("age"))    # 18
print(user.get("height"))    # None(不报错)
print(user.get("height",175))    # 175(键不存在时返回默认值)

user = {"name":"小明","age":18}
# 修改已有键的值
user["age"] = 19
print(user)    # {'name':'小明','age':19}
# 添加新的键值对(键不存在则自动新增)
user["height"] = 175
user["scores"] = [90,85,95]
print(user)    # {'name':'小明','age':19,'height':175,'scores':[90,85,95]}

user = {"name":"小明","age":18,"height":175}
# 方法1:del 语句(删除指定键值对,键不存在报错)
del user["height"]
print(user)    # {'name':'小明','age':18}
# 方法2:pop()方法(删除并返回指定键的值,键不存在可指定默认值)
age = user.pop("age")
print(age)    # 18(返回被删除的值)
print(user)    # {'name':'小明'}
# 键不存在时指定默认值,避免报错
height = user.pop("height",0)
# 方法3:clear()方法(清空所有键值对,保留字典对象)
user.clear()
print(user)    # {}

user = {"name":"小明","age":18,"gender":"男"}
# 1. 获取所有键、值、键值对
print("所有键:",list(user.keys()))    # ['name','age','gender']
print("所有值:",list(user.values()))    # ['小明',18,'男']
print("所有键值对:",list(user.items()))    # [('name','小明'),('age',18),('gender','男')]
# 2. 批量更新
user.update({"age":19,"height":175})
print("更新后:",user)    # {'name':'小明','age':19,'gender':'男','height':175}
# 3. 删除最后插入的键值对
last_item = user.popitem()
print("删除的键值对:",last_item)    # ('height',175)
print("删除后:",user)    # {'name':'小明','age':19,'gender':'男'}

user = {"name":"小明","age":18,"gender":"男"}
# 方法1:遍历键(默认遍历键)
for key in user:
    print(f"键:{key},值:{user[key]}")
# 方法2:遍历键值对
for key,value in user.items():
    print(f"{key}:{value}")
# 方法3:只遍历值
for value in user.values():
    print("值:",value)

# 嵌套字典:存储学生信息(包含成绩字典)
students = {
    "小明": {
        "age":18,
        "gender":"男",
        "scores":{"math":90,"chinese":85}
    },
    "小红": {
        "age":17,
        "gender":"女",
        "scores":{"math":95,"chinese":92}
    }
}
# 访问嵌套字典的值
print(students["小明"]["scores"]["math"])    # 90
# 修改嵌套字典的值
students["小红"]["age"] = 18
# 新增嵌套键值对
students["小明"]["scores"]["english"] = 88
print(students["小明"])
# {'age':18,'gender':'男','scores':{'math':90,'chinese':85,'english':88}}

# 空集合(必须用 set(),{}是空字典)
empty_set = set()
print(type(empty_set))    # <class 'set'>
print(type({}))    # <class 'dict'>
# 普通集合(自动去重)
num_set = {1,2,2,3,3,3}    # 重复元素会被自动去除
print(num_set)    # {1,2,3}
# 混合类型集合(元素为不可变类型)
mix_set = {1,"python",(10,20)}    # 合法
# 错误示例:包含可变元素(列表)会报错
# wrong_set = {1,[2,3]}    # TypeError:unhashable type:'list'
# 通过 set()函数创建(转换其他可迭代对象)
from_list = set([1,2,2,3])    # {1,2,3}
from_str = set("hello")    # {'h','e','l','o'}(自动去重 l)
from_range = set(range(5))    # {0,1,2,3,4}

s = {10,20,30,40}
# 判断元素是否存在(核心访问方式)
print(20 in s)    # True
print(50 not in s)    # True
# 遍历集合元素(顺序不固定)
for num in s:
    print(num)    # 输出顺序可能是 10,30,20,40(随机)

s = {1,2,3}
# 方法 1：add() —— 添加单个元素（元素已存在则无操作）
s.add(4)
s.add(2)      # 元素 2 已存在，无变化
print(s)      # {1,2,3,4}
# 方法 2：update() —— 批量添加可迭代对象的元素（如列表、字符串、集合）
s.update([5,6])        # 添加列表元素
s.update("ab",(7,8)) # 同时添加字符串和集合元素
print(s)  # {1,2,3,4,5,6,7,8,'a','b'}

s = {1,2,3,4,5}
# 方法 1：remove(x) —— 删除指定元素，元素不存在则报错
s.remove(3)
# s.remove(10)   # KeyError：10
# 方法 2：discard(x) —— 删除指定元素，元素不存在则无操作（推荐，更安全）
s.discard(4)
s.discard(10)     # 无错误，集合不变
print(s)  # {1,2,5}
# 方法 3：pop() —— 随机删除并返回一个元素（集合无序，无法指定）
pop_num = s.pop()
print("删除的元素：",pop_num)   # 可能是 1/2/5
print("删除后：",s)
# 方法 4：clear() —— 清空集合
s.clear()
print(s)  # set()

s1 = {1,2,3,4}
s2 = {3,4,5,6}
# 并集（合并所有元素，去重）
print("并集：",s1 | s2)               # {1,2,3,4,5,6}
print("并集（方法）：",s1.union(s2))   # 同上
# 交集（共同元素）
print("交集：",s1 & s2)                # {3,4}
print("交集（方法）：",s1.intersection(s2))  # 同上
# 差集（s1 有，s2 没有）
print("差集（s1-s2）：",s1 - s2)        # {1,2}
print("差集（方法）：",s1.difference(s2))  # 同上
# 对称差集（互不相同的元素）
print("对称差集：",s1 ^ s2)             # {1,2,5,6}
print("对称差集（方法）：",s1.symmetric_difference(s2))   # 同上

s1 = {1,2}
s2 = {1,2,3}
s3 = {4,5}
# 子集：s1 是否全部包含在 s2 中
print(s1.issubset(s2))    # True
print(s1 <= s2)          # True（运算符写法）
# 超集：s2 是否包含 s1 的所有元素
print(s2.issuperset(s1))  # True
print(s2 >= s1)  # True（运算符写法）