graph LR
    List[List对象] --> |索引0| E1[元素1: 'apple']
    List --> |索引1| E2[元素2: 'banana']
    List --> |索引2| E3[元素3: 100]

# 1. 创建与增加
fruits = ['apple', 'banana']
fruits.append('orange')      # ['apple', 'banana', 'orange']
fruits.insert(1, 'grape')    # ['apple', 'grape', 'banana', 'orange']

# 2. 删除
x = fruits.pop()             # 弹出 'orange'
if 'grape' in fruits:        # 安全删除前先检查
    fruits.remove('grape')   # 删除 'grape'

# 3. 修改
fruits[0] = 'pear'           # ['pear', 'banana']

# 4. 查找与统计
nums = [1, 2, 3, 2, 4, 2]
print(f"2出现了 {nums.count(2)} 次") # 统计次数
print(f"3的索引是 {nums.index(3)}")   # 查找索引

# 5. 高级排序
students = [('Tom', 80), ('Jerry', 90), ('Spike', 85)]
# 按分数(第二个元素)倒序排序
students.sort(key=lambda x: x[1], reverse=True)
print(students) # [('Jerry', 90), ('Spike', 85), ('Tom', 80)]

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[1:4])    # [1, 2, 3] (索引1到3)
print(nums[:3])     # [0, 1, 2] (从头开始)
print(nums[7:])     # [7, 8, 9] (直到末尾)
print(nums[::2])    # [0, 2, 4, 6, 8] (步长为2)
print(nums[::-1])   # [9, 8, ..., 0] (列表反转)
print(nums[1:-1])   # [1, ..., 8] (去掉首尾)

# 需求：生成 [1, 4, 9, 16, ..., 100]
# 推导式写法 (推荐)
squares = [x**2 for x in range(1, 11)]

# 带条件的推导式 (只计算偶数平方)
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]

# 嵌套推导式 (生成扑克牌)
colors = ['♠', '♥', '♣', '♦']
ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
deck = [c + r for c in colors for r in ranks]

t1 = (10)    # <class 'int'> (这是整数)
t2 = (10,)   # <class 'tuple'> (这是元组)

# 1. 交换变量
a, b = 10, 20
a, b = b, a  # a=20, b=10

# 2. 接收剩余元素 (*)
data = (1, 2, 3, 4, 5)
head, *middle, tail = data
print(middle) # [2, 3, 4]

locations = {
    (39.9, 116.4): "Beijing",
    (31.2, 121.5): "Shanghai"
}
print(locations[(39.9, 116.4)]) # Beijing

s1 = {1, 2, 3}
s2 = set([1, 2, 2, 3]) # {1, 2, 3} 自动去重
s3 = set() # 注意：空集合必须用 set()，{} 是空字典

names = ['Tom', 'Jerry', 'Tom', 'Spike']
unique_names = list(set(names)) # ['Spike', 'Tom', 'Jerry'] (顺序可能打乱)
# 如果需要保持顺序：
unique_names_ordered = sorted(list(set(names)), key=names.index)

python_devs = {'Tom', 'Jerry', 'Spike'}
java_devs = {'Tom', 'Tyke'}

print(python_devs & java_devs)  # 交集 (都会的人): {'Tom'}
print(python_devs | java_devs)  # 并集 (所有人): {'Tom', 'Jerry', 'Spike', 'Tyke'}
print(python_devs - java_devs)  # 差集 (只会Python): {'Jerry', 'Spike'}
print(python_devs ^ java_devs)  # 对称差集 (只懂一门的): {'Jerry', 'Spike', 'Tyke'}

# 1. 创建
info = {"name": "Tom", "age": 18}
d2 = dict(name="Jerry", age=20) # 使用工厂函数

# 2. 访问
print(info["name"])        # Tom
print(info.get("sex"))     # None (安全访问，不存在不报错)
print(info.get("sex", "男")) # 男 (设置默认值)

# 3. 增改
info["city"] = "Beijing"   # 新增
info["age"] = 19           # 修改

# 4. 检查Key
if "age" in info:
    print("年龄已存在")

# 将两个列表组合成字典
keys = ['name', 'age', 'city']
values = ['Tom', 18, 'Beijing']
info = {k: v for k, v in zip(keys, values)}
# {'name': 'Tom', 'age': 18, 'city': 'Beijing'}

data = [("fruit", "apple"), ("fruit", "banana"), ("veg", "carrot")]
group = {}
for category, name in data:
    group.setdefault(category, []).append(name)
print(group) # {'fruit': ['apple', 'banana'], 'veg': ['carrot']}

d = {'a': 1, 'b': 2}
# 遍历 Key
for k in d:
    print(k)

# 遍历 Value
for v in d.values():
    print(v)

# 遍历 Key-Value
for k, v in d.items():
    print(f"{k} -> {v}")

import copy
a = [1, [2, 3]]
b = copy.deepcopy(a) 
# 此时修改 a[1] 不会影响 b

def 函数名 (参数列表) :
        函数体
        return [表达式]

# -----------------------函数的演示----------------------------
# 定义函数
def print_hello():
    """
    打印hello world
    """
    print("hello world")

# 调用函数。先定义，再调用。
print_hello()
print("--------")
print_hello()
print()

# -----------------------
# 定义函数，并接收参数
def print_star(line,column):
    """
    打印指定行数和列数的星号
    """
    for i in range(line):
        for j in range(column):
            print("*", end=" ")
        print()
# 调用函数
print_star(5,10)
print()

# -----------------------
# 定义函数，并返回结果
def add(a, b):
    """
    返回两个数的和
    """
    return a + b

# 调用函数
print("add(1, 2) = ", add(1, 2))
print("add(2, 3) = ", add(2, 3))

# =================函数说明文档的演示========================
# 定义一个函数，可以判断一个数是否是素数
def is_prime(num):
    """
    判断num是否是素数
    :param num: 待判断的整数
    :return: 如果是素数返回True，否则返回False
    """
    if num < 2:
        return False
    import math
    for i in range(2, int(math.sqrt(num)+1)):
        if num % i == 0:
            return False
    return True

# 调用函数
print("7是素数吗？", is_prime(7))
print(help(is_prime))

# 普通的自定义函数：
def dog(name, species, age):
    print(f"{name} 的品种是：{species}，年龄是：{age}")
# 调用函数
dog("旺财", "泰迪", 5)

# 添加了注释的自定义函数：
def dog(name: str, species: "狗狗的品种", age: (1, 99) = 1) -> "返回None":
    print(f"{name} 的品种是：{ species}，年龄是：{age}")
# 获取函数的注释信息
print(dog.__annotations__)
# 调用函数
dog("旺财", "泰迪")

# =================函数返回值的演示========================
# 定义函数，函数体没有return语句，表示没有返回值
def print_hello():
    """
    打印hello
    """
    print("hello")

# 调用函数
print_hello() # print_hello函数没有返回值，所以不用接收返回值
# 在Python中函数没有返回值，也可以打印它的结果，但结果是None
print("结果：", print_hello()) # print_hello函数没有返回值，所以结果是None
result = print_hello() # 在Python中函数没有返回值，也可以用变量接收返回值，但结果是None
print("result=",result)

# 定义函数，函数体有return语句，但return后面没有值，表示没有返回值
def print_star(line,column):
    """
    打印指定行数和列数的星号
    """
    if line <= 0 or column <= 0:
        return # 作用是提前结束函数的执行
    for i in range(line):
        for j in range(column):
            print("*", end=" ")
        print()

# 调用函数
print_star(5,10) # print_star函数没有返回值，所以不用接收返回值
print("结果是", print_star(3,5)) # 结果是None
result = print_star(5,10)  # 结果是None
print("result=",result)

# 定义函数
def add(a, b):
    """
    返回两个数的和
    """
    return a + b # 返回结果

# 调用函数
add(1, 2) # add函数有返回值，不接收返回值也是可以的，返回值就丢失了。因为add函数中没有打印语句，看起来像没有执行一样
print("add(1, 2) = ", add(1, 2)) # 直接输出返回值
result = add(1, 2) # 可以用变量接收返回值
print("result=",result)

# 1. 位置参数
# 定义函数
def print_info(name, age):
    print(f"{name} 的年龄是：{age}")

# 调用函数    
print_info("张三", 18)

# 2. 默认参数，默认参数必须放在非默认参数后面
# 定义函数
def print_info(name, age=18):
    print(f"{name} 的年龄是：{age}")

# 调用函数
print_info("张三", 20) # 可以正常给age形参赋值
print_info("张三") # 也可以不给age形参赋值，此时age就是默认值

# 3. 关键字参数
# 定义函数
def print_info(name, age, gender='男'):
    print(f"{name} 的年龄是：{age}，性别是：{gender}")

# 调用函数
# 可以通过关键字参数给形参赋值, 此时name和age，gender的顺序可以任意
print_info(age=18, name="张三")
print_info(gender='女',name="张三", age=18)

# 定义函数，，*hobby表示可变参数，*hobby会变成一个元组。
def print_info( *hobby):
    print(f"爱好是：{hobby}")
# 调用函数
print_info("跑步", "看电影", "看小说")

# 定义函数，习惯上普通参数在前，可变参数一般放在形参列表的最后
def print_info(name, *hobby):
    print(f"{name} 的爱好是：{hobby}")
# 调用函数
print_info("张三", "跑步", "看电影", "看小说")

# 定义函数，如果可变参数后面还有普通参数，那么普通参数必须使用关键字参数给普通参数赋值
def print_info(name, *hobby, age):
    print(f"{name} 的爱好是：{hobby}，年龄：{age}")
# 调用函数
print_info( "张三","跑步", "看电影", "看小说", age = 18)

# 定义函数，**contact_person表示可变参数，**contact_person会变成一个字典。
def print_info(name, **contact_person):
    print(f"{name} 的联系人有：{contact_person}")
# 调用函数
print_info("张三", mon = "12345678901", dad = "12345678902")

# 定义函数，**contact_person可变参数必须在最后
def print_info(name, *hobby, **contact_person):
    print(f"{name} 的爱好是：{hobby}，联系人有：{contact_person}")
# 调用函数
print_info("张三","跑步", "看电影", "看小说", mon = "12345678901", dad = "12345678902")

# 5. 解包传参
# 定义函数
def print_info(name, age):
    print(f"{name} 的年龄是：{age}")
# 调用函数
print_info(*["张三", 18]) # 列表解包，要求列表元素个数与参数个数一致
print_info(*("张三", 18)) # 元组解包，要求元组元素个数与参数个数一致
print_info(*{"张三", 18}) # 不推荐用集合，因为集合是无序的
print_info(**{"name": "张三", "age": 18}) # 字典解包，要求字典的key与参数名一致

# 6. 强制使用位置参数或关键字参数：/ 前的参数必须使用位置传参，* 后的参数必须用关键字传参。
# 定义函数
def print_info(name, age, /, gender, hobby, *,  city):
    print(f"{name} 的年龄是：{age}，性别是：{gender}，爱好是：{hobby}，城市是：{city}")
# 调用函数
print_info("张三", 18, "男", "看电影", city="上海")
print_info("张三", 18, gender="男", hobby="看电影", city="上海")

# 7、防止列表等参数被修改
# 定义函数
def change_list(la):
    print(f"{la} 的id是：{id(la)}")
    la[0] = 100
    print(f"{la} 的id是：{id(la)}")
    la.append(6)
    print(f"{la} 的id是：{id(la)}")
# 调用函数
import copy
listDemo = [1,2]
print(f"函数调用前：{listDemo}，listDemo.id = {id(listDemo)}")
change_list(copy.deepcopy(listDemo))
print(f"函数调用后：{listDemo}，listDemo.id = {id(listDemo)}")

def change_str(s):
    print(f"函数内修改前: {s}, id={id(s)}")
    s += "b"  # 创建新对象 "aab"，s 指向新地址
    print(f"函数内修改后: {s}, id={id(s)}")

x = "aa"
print(f"调用前: {x}, id={id(x)}")
change_str(x)
print(f"调用后: {x}, id={id(x)}") # x 仍然是 "aa"

def change_list(lst):
    # 修改内容 -> 影响外部
    lst.append(100) 
    
    # 重新赋值 -> 不影响外部
    lst = [9, 9, 9] 

my_list = [1, 2]
change_list(my_list)
print(my_list)  # 输出 [1, 2, 100]

# ==============2种列表乘法的区别=================
def multiply_list_One(la) :
    print(f"{la} 的id是：{id(la)}")
   # la *= 2 # 使用原地址
    la += [1,2]
    print(f"{la} 的id是：{id(la)}")

list1 = [1,2]
multiply_list_One(list1)
print(list1) # [1, 2, 1, 2]

def multiply_list_two(la) :
    print(f"{la} 的id是：{id(la)}")
    # la = la * 2 # 使用新地址
    la = la + [1,2]
    print(f"{la} 的id是：{id(la)}")

list2 = [1,2]
multiply_list_two(list2)
print(list2) # [1, 2]

# ================函数嵌套定义======================
def function_a():
    print("\t函数 A 开始执行")
    print("\t函数 A 执行中...")
    print("\t函数 A 结束执行")

def function_b():
    print("函数 B 开始执行")
    print("函数 B 执行中...")
    function_a()
    print("函数 B 执行中...")
    print("函数 B 结束执行")

function_b()

函数 B 开始执行
函数 B 执行中...
	函数 A 开始执行
	函数 A 执行中...
	函数 A 结束执行
函数 B 执行中...
函数 B 结束执行

# =================变量作用域====================
# if-else语句块中定义变量，不会开启新的变量作用域
import random
a= random.randint(1,10) # 全局变量
if a>5:
    result = "big" # 全局变量，因为当前if不在函数，闭包中
    print("a的值是：",a)
else:
    result = "small"
print("result的值是：",result) # if-else语句块外，仍然可以访问result

# =================变量作用域====================
# 在函数中定义变量，会开启新的变量作用域
# G (Global): 模块级别变量
x = "global" # 全局变量
def outer():
    # E (Enclosing): 闭包
    y = "enclosing" # 外层函数变量，在整个outer函数中都可以访问

    # 在外部函数体中定义内部函数
    def inner():
        # L (Local): 函数内部变量
        z = "local" # 局部变量，仅限于inner函数内部访问
        print(f"\t在inner中访问局部变量z的值是：{z}")  # 访问局部变量
        print(f"\t在inner中访问嵌套变量y的值是：{y}")  # 访问外层函数变量
        print(f"\t在inner中访问全局变量x的值是：{x}")  # 访问全局变量
        print(f"\t在inner中访问内建函数的值是：{len}")  # 访问内建函数

    # 在外部函数体中调用内部函数
    print("在outer中调用inner函数")
    inner()
    # print(f"在outer中访问内层函数变量z的值是：{z}") # 报错
    print(f"在outer中访问外层函数变量y的值是：{y}")
    print(f"在outer中访问全局变量x的值是：{x}")
    print(f"在outer中访问内建函数的值是：{len}")

# 调用外部函数函数
print("调用outer函数")
outer()
# print(f"在main中访问内层函数变量z的值是：{z}") # 报错
# print(f"在main中访问外层函数变量y的值是：{y}") # 报错
print(f"在main中访问全局变量x的值是：{x}")
print(f"在main中访问内建函数的值是：{len}")

# =========可变类型在局部修改可以不使用global关键字===========
listDemo = [1,2,3] #  可变类型，全局变量
# 定义函数
def change_list():
    listDemo.append(4)
    print("change_list()函数中，listDemo的值是：",listDemo) # listDemo= [1,2,3,4]
    # listDemo = [4,5,6] # 错误，因为Python 默认会把这个变量当作局部变量

# 调用函数
print("调用change_list()函数之前，listDemo的值是：",listDemo)  # listDemo= [1,2,3]
change_list()
print("调用change_list()函数之后，listDemo的值是：",listDemo)  # listDemo= [1,2,3,4]

# =============未使用global关键字无法修改不可变类型全局变量的值=============
x = "global"
# 定义函数
def change_x_one():
    # x += "local" # 错误，因为没有global关键字，无法修改全局变量
    x = "local" # 没有global关键字，给x赋值，Python 默认会把这个变量当作局部变量
    print("change_x_one()函数中，x的值是：",x) # x= local

# 调用函数
print("调用change_x_one()函数之前，x的值是：",x) # x= global
change_x_one()
print("调用change_x_one()函数之后，x的值是：",x) # x= global
print()

# ===============使用global关键字才可以修改不可变类型全局变量的值=================
# global关键字，可以修改全局变量的值
x = "global"
# 定义函数
def change_x_two():
    global x # 添加global关键字，修改全局变量的值
    x = "local"
    print("change_x_two()函数中，x的值是：",x) # x= local

# 调用函数
print("调用change_x_two()函数之前，x的值是：",x) # x= global
change_x_two()
print("调用change_x_two()函数之后，x的值是：",x) # x= local
print()

# ========使用nonlocal关键字在内部作用域修改外部作用域不可变类型变量的值==============
def function_outer():
    str_demo = "outer"
    print("function_outer()函数中，str_demo的值是：",str_demo)
    def function_inner():
        nonlocal str_demo
        str_demo = "inner"
    # 调用内部函数
    print("调用内部函数function_inner()后")
    function_inner()
    print("function_outer()函数中，str_demo的值是：",str_demo)

# 调用外部函数
function_outer() 

# 函数是一种数据类型
# 定义函数
def my_function():
    print("我是函数体")

# 打印函数的类型
print(type(my_function))

# 可以使用函数可以给变量赋值
def greet():
    print("Hello!")
say_hello = greet # 注意greet后面没有()
say_hello()

# 函数可以作为参数传递
def say_hi():
    print("Hi!")
    
def call_function(func): 
    func() # 这里要求传给func的实参是一个函数。

call_function(say_hi) # say_hi是一个函数，它作为参数被传给了call_function函数

# 函数可以作为返回值
def get_function():
    def inner_function():
        print("Inner function")
    return inner_function

#调用get_function函数
func = get_function() # 得到的是一个函数
func() # 调用func()函数

# 函数可以被存储到数据结构中
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    return a / b

# 将函数存储在列表中，同样也可以被存储在元组、字典等容器中
operations = [add, subtract, multiply, divide]
for operation in operations:
    result = operation(5, 3)
    print(operation.__name__ , ": ", result)

lambda 参数列表: 表达式

data = [1, 2, 3, 4, 5]

# 1. map: 每个元素平方
# Java: list.stream().map(x -> x*x).toList()
res_map = list(map(lambda x: x*x, data))
print(res_map)  # [1, 4, 9, 16, 25]

# 2. filter: 保留偶数
# Java: list.stream().filter(x -> x%2==0).toList()
res_filter = list(filter(lambda x: x % 2 == 0, data))
print(res_filter)  # [2, 4]

# 3. sorted: 按绝对值排序
# Java: list.stream().sorted(Comparator.comparingInt(Math::abs)).toList()
nums = [-5, 2, -10, 1]
res_sorted = sorted(nums, key=lambda x: abs(x))
print(res_sorted)  # [1, 2, -5, -10]

graph TD
    A["准备数据结构 list/dict/set/tuple"] --> B["封装函数：add/update/report"]
    B --> C["用推导式/循环统计"]
    C --> D["用 sorted + lambda 排序"]
    C --> E["用 setdefault 分组"]
    D --> F["打印/返回结果"]
    E --> F

# 学生列表：每个元素是一个字典，保存 name / score
students = [
    {"name": "Tom", "score": 80},
    {"name": "Jerry", "score": 59},
    {"name": "Spike", "score": 100},
]

def add_student(students, name, score):
    # 新增一条学生数据（列表是可变对象，函数内修改会影响外部）
    students.append({"name": name, "score": score})

def update_score(students, name, new_score):
    # 按姓名遍历查找，找到后修改分数并返回 True；找不到返回 False
    for s in students:
        if s["name"] == name:
            s["score"] = new_score
            return True
    return False

def report(students):
    # 约定：空列表时直接返回“空报表”
    if not students:
        return {"avg": 0, "pass_names": [], "top3": [], "group": {}}

    # 平均分：sum + 生成器表达式
    avg = sum(s["score"] for s in students) / len(students)

    # 及格名单：列表推导式
    pass_names = [s["name"] for s in students if s["score"] >= 60]

    # Top3：sorted + lambda，按 score 倒序取前三
    top3 = sorted(students, key=lambda s: s["score"], reverse=True)[:3]

    # 分组：setdefault 经典用法
    group = {}
    for s in students:
        key = "pass" if s["score"] >= 60 else "fail"
        group.setdefault(key, []).append(s["name"])

    return {"avg": round(avg, 2), "pass_names": pass_names, "top3": top3, "group": group}

# 测试：新增一个学生
add_student(students, "Tyke", 70)
# 测试：把 Jerry 的分数从 59 改成 61（刚好及格）
update_score(students, "Jerry", 61)

result = report(students)
print("avg:", result["avg"])
print("pass:", result["pass_names"])
print("top3:", [(s["name"], s["score"]) for s in result["top3"]])
print("group:", result["group"])

# price：商品 -> 单价
price = {"apple": 3.0, "banana": 2.5, "milk": 6.0}
# cart：每一项是 (商品名, 数量)
cart = [("apple", 2), ("banana", 3), ("milk", 1), ("cola", 1)]

def calc_total(price, cart):
    total = 0.0
    for name, qty in cart:
        if name in price:
            # 命中价格表：参与结算
            total += price[name] * qty
        # 未命中价格表：跳过（也可以选择抛异常/记录错误，这里保持简单）
    return round(total, 2)

def missing_items(price, cart):
    # 用集合差集找出“购物车里有、价格表里没有”的商品
    names_in_cart = {name for name, _ in cart}
    names_in_price = set(price.keys())
    return sorted(list(names_in_cart - names_in_price))

print("total:", calc_total(price, cart))
print("missing:", missing_items(price, cart))