【大模型开发】python基础（二）

基础语法讲解

一、列表（List）

核心知识点：创建、索引/切片、增删改查、列表方法、列表推导式、嵌套列表、排序、复制、迭代
# 列表的特点：元素类型是不限的，列表里的元素有顺序索引，可以被for循环去遍历，排序（sort），列表推导式
# 例题
# 1. 基础操作
fruits = ["apple", "banana", "cherry"]
print(fruits[1])          # 索引访问
print(fruits[-1])         # 负索引
print(fruits[1:])         # 切片

# 2. 增删改查
fruits.append("orange")   # 添加元素
fruits.insert(1, "mango") # 插入元素
fruits[0] = "avocado"     # 修改元素
fruits.remove("banana")   # 删除元素
popped = fruits.pop(2)    # 弹出元素

# 3. 列表方法
nums = [5, 2, 8, 1, 9]
nums.sort()               # 排序
nums.reverse()            # 反转
print(nums.index(8))      # 查找索引
print(nums.count(2))      # 计数

# 4. 高级操作
matrix = [[1,2,3], [4,5,6], [7,8,9]]  # 嵌套列表
flat = [num for row in matrix for num in row]  # 列表推导式
squares = [x**2 for x in range(10)]   # 条件推导式
filtered = [x for x in nums if x > 3] # 带条件的推导式

练习：
创建包含10个奇数的列表
将列表[1,2,3,4,5]反转为[5,4,3,2,1]（三种方法）
删除列表中所有小于10的元素：[15, 8, 22, 3, 10]
将两个列表[1,2,3]和[4,5,6]合并为一个
找出嵌套列表[[1,2], [3,4,5], [6]]中最长的子列表
使用列表推导式生成九九乘法表
实现列表的排序 lst=[i for i in range(20) if i%2!=0]

from collections import defaultdict
lst=[i for i in range(20) if i%2!=0]
lst=[1,2,3,4,5]
方法一
lst.reverse()
print(lst)
方法二
print(lst[::-1])
方法三
lst.sort(reverse=True)
print(lst)

lst=[x for x in lst if x>=10]
print(lst)

lst=[15, 8, 22, 3, 10]
for num in lst:
    if num<10:
        lst.remove(num)
print(lst)

lst1=[1,2,3]
lst2=[4,5,6]
#tmp=lst1+lst2 #可以直接相加
tmp=[]
tmp.extend(lst1)
tmp.extend(lst2)
print(tmp)
lst1.extend(lst2)
print(lst1)

max=0
max_lst=[]
for a in [[1,2], [3,4,5], [6]]:
    if len(a)>max:
        max=len(a)
        max_lst=a
print(max_lst)

# 生成二维列表!!!，每个元素是字符串算式
正确的二维乘法表生成方式，它利用了嵌套列表推导式的结构：外层控制行，内层控制列。
table = [[f"{j}*{i}={i*j:2d}" for j in range(1, i+1)] for i in range(1, 10)]
# 逐行打印
for row in table:
    print("  ".join(row))

lst=[15, 8, 22, 3, 10]
lst.sort()
print(lst)

二、字典（Dictionary）
核心知识点：创建、访问、增删改查、字典方法、字典推导式、嵌套字典、键值遍历

# 字典的结构是key-value键值对，字典没有下标索引，只能通过访问key来获取值
# 例题
# 1. 基础操作
student = {"name": "Alice", "age": 20, "courses": ["Math", "Physics"]}
print(student["name"])            # 键访问
print(student.get("grade", "A"))  # 安全访问
student["grade"] = "A"            # 添加键值
del student["age"]                # 删除键值

# 2. 字典方法
keys = student.keys()             # 所有键
values = student.values()         # 所有值
items = student.items()           # 键值对
student.update({"age": 21})       # 更新字典
copied = student.copy()           # 浅拷贝

# 3. 字典推导式
squares = {x: x**2 for x in range(1,6)}  # {1:1, 2:4, ...}
swapped = {v: k for k, v in student.items()}  # 键值互换

# 4. 嵌套字典
school = {
    "class1": {"teacher": "Smith", "students": 30},
    "class2": {"teacher": "Johnson", "students": 28}
}
print(school["class1"]["teacher"])  # 嵌套访问



练习：

创建包含5个国家及其首都的字典

统计字符串"mississippi"中每个字母的出现次数

合并两个字典，相同键时保留第二个字典的值

将字典按值排序：{"a":5, "b":2, "c":8} → [('b',2), ('a',5), ('c',8)]

使用字典推导式将两个列表["a","b","c"]和[1,2,3]组合成字典

实现嵌套字典的深度拷贝

找出字典中值最大的键

处理JSON数据：从字典中提取特定路径的值

dict={"中国":"北京","日本":"东京"}
print(dict)

str="mississippi"
dic={}
for char in str:
    if dic.get(char,0)==0:
        dic[char]=1
    else:
        dic[char]+=1
print(dic)
str="mississippi"
dic={}
for item in str:
    dic[item]=dic.get(item,0)+1
print(dic)

dic1={1:2,2:3,6:8}
dic2={1:3,2:6,8:6}
dic1.update(dic2)
print(dic1)

# lambda表达式：
# lambda 参数1, 参数2, ... : 表达式
# 参数：与普通函数一样，可以有任意多个（包括0个），但必须用逗号分隔。
# 表达式：只能是一个表达式，不能包含语句（如 if、for、return）。表达式的结果就是函数的返回值。
dic={"a":5, "b":2, "c":8}
sort_dic=sorted(dic.items(),key=lambda item: item[1])
print(sort_dic)
#逆序
reverse_sort_dic=sorted(dic.items(),key=lambda item: item[1],reverse=True)
print(reverse_sort_dic)
key=dic.keys()
print(key)
value=dic.values()
print(value)

keys = ["a", "b", "c"]
values = [1, 2, 3]
#两种方法：
法一：
zip(keys, values) 将两个列表对应位置的元素打包成元组，例如 ('a', 1)、('b', 2)、('c', 3)。
字典推导式 {k: v for k, v in ...} 遍历这些元组，将第一个元素作为键，第二个元素作为值，构建字典。
如果两个列表长度不一致，zip() 会以较短的列表为准，多余的元素被忽略。
result = {k: v for k, v in zip(keys, values)}
法二：
dic={}
for i in range(len(values)):
    dic[keys[i]]=values[i]
print(result)  # 输出：{'a': 1, 'b': 2, 'c': 3}
print(dic)

import copy
original = {"a": 1, "b": {"c": 2, "d": [3, 4]}}
#深拷贝
deep_copied = copy.deepcopy(original)
#浅拷贝
copied=original.copy()
# 修改深拷贝后的嵌套对象，不会影响原字典
deep_copied["b"]["c"] = 99
print(original["b"]["c"])  # 输出 2
# 修改浅拷贝后的嵌套对象，会影响原字典
copied["b"]["c"] = 99
print(original["b"]["c"])  # 输出 99
print(copied["b"]["c"])    # 输出 99
print(deep_copied["b"]["c"])    # 输出 99

#max(dict, key=dict.get) 会遍历字典的键，根据 dict.get(key) 返回的值进行比较，最终返回最大值对应的键。
scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "Diana": 95}
max_score_peo=max(scores,key=scores.get)
print(max_score_peo)#最大的值对应的键
print(scores[max_score_peo])#最大的值

三、元组（Tuple）
核心知识点：创建、索引/切片、不可变性、元组拆包、命名元组、与列表转换


# 例题
# 1. 基础操作
coordinates = (10.5, 20.3)        # 创建元组
x, y = coordinates                # 元组拆包
print(coordinates[0])             # 索引访问
print(coordinates.index(20.3))    # 查找索引

# 2. 不可变性演示
try:
    coordinates[0] = 15.0         # 会引发TypeError
except TypeError as e:
    print("元组不可修改:", e)

# 3. 命名元组
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(11, y=22)
print(p.x, p.y)                   # 属性访问

# 4. 转换操作
colors = ("red", "green", "blue")
color_list = list(colors)         # 元组转列表
new_tuple = tuple(["cyan", "magenta"])  # 列表转元组



练习：

创建包含RGB颜色的元组(255,0,0)

交换两个变量的值（使用元组拆包）

从函数返回多个值（使用元组）

比较元组(1,2,3)和(1,2,4)的大小

使用命名元组表示日期(年,月,日)

实现元组的切片操作获取最后两个元素

将元组(('a',1), ('b',2))转换为字典

理解元组不可变性的实际意义

p=(255,0,0)
print(p)

a, b = 5, 10
# 右侧的 b, a 等价于 (10, 5)，然后拆包赋值给 a 和 b
a, b = b, a  # 等价于 a, b = (10, 5)
print(a, b)  # 输出 10 5

def min_max(data):
    return min(data),max(data)
data=[1,3,5,7,9]
print(min_max(data))

元组可以直接比较大小！
print((1,2,3) < (1,2,4))  # True

from collections import namedtuple
Point=namedtuple("Point",("year","month","day"))
p=Point(2026,3,16)
print(p)

Point=(2026,3,16)
print(Point[-2:])

p=(('a',1), ('b',2))
p=dict(p)
print(p)

p=(10,2,5)
p[0]=(3) # 不支持修改
print(p)

四、集合（Set）
核心知识点：创建、增删、集合运算、集合方法、集合推导式、不可变集合

# 例题
# 1. 基础操作
primes = {2, 3, 5, 7}             # 创建集合
primes.add(11)                    # 添加元素
primes.discard(2)                 # 安全删除
primes.remove(3)                  # 删除元素（不存在时报错）

# 2. 集合运算
A = {1,2,3,4}
B = {3,4,5,6}
print(A | B)  # 并集 {1,2,3,4,5,6}
print(A & B)  # 交集 {3,4}
print(A - B)  # 差集 {1,2}
print(A ^ B)  # 对称差集 {1,2,5,6}

# 3. 集合方法
print(A.issubset({1,2,3,4,5}))   # 子集检查
print(A.isdisjoint({5,6,7}))      # 无交集检查

# 4. 不可变集合
frozen = frozenset([1,2,3])       # 创建不可变集合
try:
    frozen.add(4)                 # 会引发AttributeError
except AttributeError as e:
    print("不可变集合:", e)

# 5. 集合推导式
squares = {x**2 for x in range(10)}  # 平方数集合


练习：

从列表[1,2,2,3,3,3]中创建集合去重

检查两个集合{1,2,3}和{3,4,5}是否有交集

找出两个列表[1,2,3,4]和[3,4,5,6]的不同元素

使用集合运算求三个集合A∩(B∪C)

实现集合的子集、超集检查

使用集合过滤文本中的唯一单词

比较列表和集合在成员检查时的性能差异

创建不可变集合并尝试修改

lst=[1,2,2,3,3,3]
lst=set(lst)
print(lst)

s1={1,2,3}
s2={3,4,5}
print((s1&s2)!={})

lst1=[1,2,3,4]
lst2=[3,4,5,6]
lst1=set(lst1)
lst2=set(lst2)
print(lst1^lst2)

A={1,2,3}
B={2,3,4}
C={3,4,5}
print(A&(B|C))

A = {1,2,3,4}
B = {1,2,3,4,5}
print(A.issubset(B))   # 子、超集检查  # True-->A是B的子集，B是A的超集
若A=B，那么 A 既是 B 的超集，也是 B 的子集。
若A包含B的所有元素，且 A 中还有 B 没有的元素，那么 A 是 B 的真超集
A >= B：判断 A 是否是 B 的超集（允许相等）。
A > B：判断 A 是否是 B 的真超集（A 是 B 的超集且 A ≠ B）。

text = "Hello world! Hello Python. Python is great can't."
lst=text.split()
lst=set(lst)
print(lst)
# 正则表达式 r'\b\w+\b'：
# \b 表示单词边界（单词开始或结束的位置，如空格、标点或字符串开头/结尾）。
# \w+ 表示一个或多个单词字符（字母、数字或下划线，等价于 [a-zA-Z0-9_]）。
# 组合起来 \b\w+\b 匹配一个完整的单词，确保不会匹配到单词内部的一部分（例如 "can't" 中的 can 或 t 不会被单独匹配，但注意 \w 不匹配撇号，所以 "can't" 会被视为两个单词 "can" 和 "t"）。
import re
qulst=re.findall(r'\b\w+\b',text)
print(qulst)
qulst=set(qulst)
print(qulst)

列表：成员检查（item in list）需要遍历整个列表，时间复杂度为 O(n)，随着列表长度增加，耗时线性增长。
集合：基于哈希表，成员检查的时间复杂度为 O(1)（平均情况），无论集合大小，速度几乎恒定。

# Python 提供了 frozenset 类型，它与 set 类似，但不可变（哈希化）。一旦创建，不能添加或删除元素。
se=frozenset({1,2,3})
print(se)
try:
    se.add(4) #报错，无法修改
except AttributeError as e:
    print("不可变集合：",e)
print(se)

课堂小练~~~

# 输入数据
raw_data = [
    {"id": 1, "name": " Alice ", "scores": (85, "90")},
    {"id": 2, "name": "Bob", "scores": (92, 88)},
    {"id": 3, "name": "Cathy", "scores": (78, None)}
]

# 任务：
# 1. 清洗name字段：去除首尾空格
# 2. 转换scores为整数类型
# 3. 计算平均分（忽略None）
# 4. 添加评级字段（A:>=90, B:80-89, C:<80）

#错误：代码中将None视为0并计入计数，导致平均分偏低。应只对非None元素求和并计数：
sum=0
cnt=0
for peo in raw_data:
    peo["name"]=peo["name"].strip()
    cnt=0
    sum=0
    for s in peo["scores"]:
        if s != None:
            s=int(s)
            cnt += 1
            sum += s
        else:
            s=0
    avg=sum/cnt
    if(avg>=90):
        peo["avg"]="A"
    elif(avg>=80):
        peo["avg"] = "B"
    else:
        peo["avg"] = "C"
    print(peo)

# 电商订单分析系统
orders = [
    {"order_id": 1001, "products": {"A":2, "B":1}, "total": 150},
    {"order_id": 1002, "products": {"C":3}, "total": 90},
    {"order_id": 1003, "products": {"A":1, "C":2}, "total": 110}
]

# 任务：
# 1. 找出最受欢迎的产品（被订购次数最多）
# 2. 计算所有订单的总金额
# 3. 生成产品销售额排名
# 4. 找出包含特定产品组合的订单

#product_quantity = defaultdict(int)
#defaultdict 是 Python 内置模块 collections 中的一个类，它是普通字典 dict 的子类。
#它的特殊之处在于：当访问的键不存在时，不会抛出 KeyError，而是自动调用一个工厂函数来生成默认值。
#int 是一个工厂函数（即调用 int() 会返回整数 0）。当 defaultdict 被创建时，指定的工厂函数（这里是 int）会在键缺失时被调用，返回的值作为该键的默认值。
#所以 defaultdict(int) 的效果是：任何不存在的键的默认值都是 0。
#使用字典的 .items() 方法同时获取键和值，不加的话默认只遍历字典的键
lst=defaultdict(int)
sum=0
for obj in orders:
    sum+=obj["total"]
    for pro,s in obj["products"].items():
        lst[pro]+=s
print("最受欢迎的产品为:",max(lst))
print("所有订单的总金额:",sum)
lst=sorted(lst.items(),key=lambda item:item[1])
print("生成产品销售额排名为:",lst)
pjt={"A","C"}
dingdan=[]
for obj in orders:
    if all(x in obj["products"] for x in pjt):#注意不要写成这个：all(x in pjt for x in obj["products"])，这个思路反了
        dingdan.append(obj["order_id"])
print("含特定产品的订单号为:",dingdan)

以下是练习题（难度从基础->进阶）题目及答案，可以自己选择进行练习~~~

'''
【列表操作】
创建一个包含数字1到5的列表，然后修改第3个元素为10
'''
# lst=[x for x in range(1,6)]
# print(lst)
# lst[2]=10
# print(lst)

'''
【字典访问】
给定字典 person = {"name": "Alice", "age": 25}，打印出年龄值
'''
# person = {"name": "Alice", "age": 25}
# print("age:",person["age"])

'''
【元组创建】
创建一个表示RGB红色值的元组（255, 0, 0）
'''
# from collections import namedtuple
# RGB=namedtuple("RGB",("red","green","blue"))
# rgb=RGB(255,0,0)
# print(rgb)

'''
【集合去重】
使用集合将列表 [1, 3, 3, 5, 5, 5] 中的重复元素去除
'''
# lst=[1, 3, 3, 5, 5, 5]
# lst=set(lst)
# print(lst)

'''
【列表推导式】
使用列表推导式创建包含0-4的平方值的列表
'''
# lst=[x**2 for x in range(0,5)]
# print(lst)

'''
【字典安全访问】
使用get方法安全访问字典 {"a": 1, "b": 2} 中不存在的键"c"，返回默认值0
'''
# dic={"a": 1, "b": 2}
# print(dic.get("c", 0))

'''
中等难度练习题（6道）
【字典统计】
统计字符串 "hello" 中每个字符出现的次数，存储为字典
'''
# str="hello"
# dic={}
# for i in str:
#     if dic.get(i,0)==0:
#         dic[i]=1
#     else:
#         dic[i]+=1
# print(dic)

'''
【列表嵌套处理】
将嵌套列表 [[1,2], [3,4,5], [6]] 展开为平铺列表 [1,2,3,4,5,6]
'''
# lst=[[1,2], [3,4,5], [6]]
# l=[]
# for id in lst:
#     for ik in id:
#         l.append(ik)
# l2=[x for id in lst for x in id]
# print(l)
# print(l2)

'''
【字典合并】
合并两个字典 {"a": 1, "b": 2} 和 {"b": 3, "c": 4}，相同键时保留第二个字典的值
'''
# di={"a": 1, "b": 2}
# dc={"b": 3, "c": 4}
# di.update(dc)
# print(di)

'''【元组拆包应用】
使用元组拆包交换两个变量 x = 10, y = 20 的值'''
# x=10
# y=20
# x,y=y,x
# print("x=",x,",y=",y)

'''
【集合运算】
给定两个集合 A = {1,2,3,4}, B = {3,4,5,6}，求只在A中出现但不在B中出现的元素
'''
# A = {1,2,3,4}
# B = {3,4,5,6}
# print(A-B)

'''
【列表排序1】
将列表 ["apple", "Banana", "cherry"] 按字母顺序排序（不区分大小写）
【列表排序2】根据水果价格排序
{"橘子":"10元","香蕉":"6元","西瓜":"8元"}
'''
# lst=["apple", "Banana", "cherry"]
# dic={"橘子":"10元","香蕉":"6元","西瓜":"8元"}
# # 下面这种写法改变了原元素，是不对的
# # for i in range(len(lst)):
# #     lst[i]=lst[i].lower()
# # lst.sort()
# sort_lst=sorted(lst, key=str.lower)
# print(sort_lst)
# dicc=sorted(dic.items(),key=lambda item:int(item[1][:-1]))#[('香蕉', '6元'), ('西瓜', '8元'), ('橘子', '10元')]
# print(dicc)
# #转化为字典格式
# di={k:v for k,v in dicc}
# print(di)

'''
混合知识点进阶题（2道）
1、数据转换综合
将嵌套数据结构：
data = {
    "users": [
        ("Alice", 25, ["reading", "hiking"]),
        ("Bob", 30, ["gaming", "cooking"])
    ]
}
转换为字典列表：
[
    {"name": "Alice", "age": 25, "hobbies": ["reading", "hiking"]},
    {"name": "Bob", "age": 30, "hobbies": ["gaming", "cooking"]}
]
'''
# data = {
#     "users": [
#         ("Alice", 25, ["reading", "hiking"]),
#         ("Bob", 30, ["gaming", "cooking"])
#     ]
# }
# lst=[]
# for peo in data["users"]:
#     dic={}
#     dic["name"]=peo[0]
#     dic["age"]=peo[1]
#     dic["hobbies"]=peo[2]
#     lst.append(dic)
# print(lst)

'''
2、数据分析处理
给定数据集：
transactions = [
    {"id": 1, "amount": 150, "category": "food"},
    {"id": 2, "amount": 200, "category": "electronics"},
    {"id": 3, "amount": 80, "category": "food"},
    {"id": 4, "amount": 300, "category": "clothing"}
]
完成：
计算每个类别的总消费金额
找出消费金额最高的交易记录
过滤出金额大于100的交易ID列表
按金额降序排序交易记录
'''
# transactions = [
#     {"id": 1, "amount": 150, "category": "food"},
#     {"id": 2, "amount": 200, "category": "electronics"},
#     {"id": 3, "amount": 80, "category": "food"},
#     {"id": 4, "amount": 300, "category": "clothing"}
# ]
# dic={}
# for idx in transactions:
#     # if dic.get(idx["category"],0)==0:
#     #     dic[idx["category"]]=idx["amount"]
#     # else:
#     #     dic[idx["category"]] += idx["amount"]
#     dic[idx["category"]]=dic.get(idx["category"],0)+idx["amount"]
# print("每个类别的总消费金额:",dic)
# price=0
# idx={}
# for x in transactions:
#     if(x["amount"]>price):
#         price=x["amount"]
#         idx=x
# max_tran=max(transactions,key=lambda x:x["amount"])
# print("消费金额最高的交易记录:",idx,max_tran)
# idx_bigthan=[x["id"] for x in transactions if x["amount"]>100]
# print("金额大于100的交易ID列表:",idx_bigthan)
# sort_tran=sorted(transactions,key=lambda x:x["amount"],reverse=True)
# print("按金额降序排序交易记录:",sort_tran)

'''
进阶难度一（5道） - 实际应用场景
1、数据清洗
给定包含重复项和空值的列表：[12, None, 7, 12, "error", 7, 25]
创建新列表：去除重复、过滤非数值、替换None为0，结果应为[12, 0, 7, 25]
'''
# lst=[12, None, 7, 12, "error", 7, 25]
# one=[]
# for idx in lst:
#     if idx==None:
#         one.append(0)
#     elif isinstance(idx,int):
#         one.append(idx)
# print(one)
# two=[]
# for idx in one:
#     if idx not in two:
#         two.append(idx)
# print(two)

'''
2、配置文件处理
被注释的属于字符串类型，将该格式字符串转换为字典：
# 
# [database]
# host=localhost
# port=5432
# [auth]
# user=admin
# 
输出：{"database": {"host": "localhost", "port": 5432}, "auth": {"user": "admin"}}
'''
# # if line is None:
# # None 是一个特殊的空值对象，但字符串 split('\n') 得到的每一行元素永远不可能为 None（即使行是空的，也是空字符串 ''，而不是 None）。
# # 因此这个条件永远不会触发，空行不会被跳过。
# def file_handle(config_str):
#     lines=config_str.strip().split('\n')
#     dic={}
#     cur_key=''
#     for line in lines:
#         line=line.strip() #要先去除首位空格再判断是否空行
#         if not line: #注意空行的判断
#             continue
#         elif line.startswith('[') and line.endswith(']'):
#             cur_key=line[1:-1]
#             dic[cur_key]={}
#         elif cur_key and '='in line:
#             key,value=line.split('=',1)
#             # 可能会出现a = b的情况，分割后key的后面和value的前面会带着空格
#             key=key.strip()
#             value=value.strip()
#             if value.isdigit():
#                 value=int(value) #遇到整数要格式转换 #只能识别正整数，无法处理负数（如 port=-1）或浮点数（如 ratio=0.5）
#             dic[cur_key][key]=value  #这里不能直接创建两层字典，前面先创建第一层字典dic[cur_key]={}才行
#     return dic
# str='''
# [database]
# host=localhost
# port=5432
# [auth]
# user=admin
# '''
# print(file_handle(str))

'''
3、数据去重统计
从日志列表["192.168.1.1", "10.0.0.2", "10.0.0.2","10.0.0.2","192.168.1.1", "172.16.0.3"]
统计独立IP数量并找出最高频IP
'''
# lst=["192.168.1.1", "10.0.0.2", "10.0.0.2","10.0.0.2","192.168.1.1", "172.16.0.3"]
# unique_lst=set(lst)
# print("独立IP数量:",len(unique_lst))
# dic={}
# for idx in lst:
#     dic[idx]=dic.get(idx,0)+1
# print(dic)
# sort_dic=sorted(dic.items(),key=lambda item:item[1],reverse=True)
# print("最高频IP为:",sort_dic[0][0],",数量为:",sort_dic[0][1])
# #collections.Counter 是 Python 内置的一个字典子类，用于统计可哈希对象（如字符串）的出现次数。
# #most_common(n) 返回一个列表，包含出现次数最多的 n 个元素（及其次数）。
# from collections import Counter
# counter = Counter(lst)
# print(counter)
# most_common_ip, freq = counter.most_common(1)[0]
# print("最高频IP:", most_common_ip, "出现次数:", freq)

'''
4、权限验证
给定用户权限集合{"read", "write"}和所需权限{"write", "execute"}
检查用户是否满足所有所需权限，返回布尔值
'''
# user={"read", "write"}
# need={"write", "execute"}
# print(need.issubset(user))#need是否是user的子集

'''
5、数据序列化
将嵌套元组(("name", "Alice"), ("scores", (90, 85)))
转换为字典{"name": "Alice", "scores": [90, 85]}
'''
# tu=(("name", "Alice"), ("scores", (90, 85)))
# dic={}
# for idx in tu:
#     if idx[0]=="scores":
#         dic[idx[0]] = list[idx[1]]
#     else:
#         dic[idx[0]]=idx[1]
# print(dic)

'''
中等难度（6道） - 实际工程问题
1、交易数据分析
给定交易记录：

transactions = [
    {"id": 1, "amount": 150, "currency": "USD"},
    {"id": 2, "amount": 2000, "currency": "JPY"},
    {"id": 3, "amount": 80, "currency": "EUR"}
]
汇率字典：{"USD": 1.0, "JPY": 0.0075, "EUR": 1.08}
计算：总金额(USD)、最贵交易ID、货币种类集合
'''
# transactions = [
#     {"id": 1, "amount": 150, "currency": "USD"},
#     {"id": 2, "amount": 2000, "currency": "JPY"},
#     {"id": 3, "amount": 80, "currency": "EUR"}
# ]
# dic={"USD": 1.0, "JPY": 0.0075, "EUR": 1.08}
# id =0
# usd=0
# sum=0
# kinds=set() #这个才是创建集合的写法，kinds={}创建的是字典
# for idx in transactions:
#     if idx["currency"]=="USD":
#         idx["sum"]=idx["amount"]
#     elif idx["currency"]=="JPY":
#         idx["sum"]=idx["amount"]*dic["JPY"]
#     elif idx["currency"]=="EUR":
#         idx["sum"]=idx["amount"]*dic["EUR"]
#     if idx["sum"]>usd:
#         usd=idx["sum"]
#         id=idx["id"]
#     sum+=idx["sum"]
#     kinds.add(idx["currency"])
# print("总金额(USD):",sum)
# print("最贵交易ID:",id)
# print("货币种类集合:",kinds)

'''
2、文本索引构建
处理文档：["apple orange", "banana apple", "orange juice"]
创建倒排索引：
{
    "apple": {0, 1},
    "orange": {0, 2},
    "banana": {1},
    "juice": {2}
}
'''
# txt=["apple orange", "banana apple", "orange juice"]
# dic={}
# for id in range(len(txt)):
#     lst=txt[id].split(" ")
#     for idx in lst:
#         if dic.get(idx,0)==0:
#             dic[idx]={id}
#         else:
#             dic[idx].add(id)
# print(dic)

'''
3、库存管理系统
初始库存：{"A": 50, "B": 30}
处理订单列表：[("A", -20), ("B", -10), ("C", 50)]
更新库存：处理负数（出库）、正数（入库）、检查缺货
输出最终库存和缺货商品列表
'''
# Warehouse={"A": 50, "B": 30}
# lst=[("A", -20), ("B", -10), ("C", 50)]
# for idx in lst:
#     Warehouse[idx[0]]=Warehouse.get(idx[0],0)+idx[1]
# less=set()
# for key,value in Warehouse.items():
#     if value<0:
#         less.add(key)
# print(Warehouse)
# print(less)

'''
4、网络配置合并
合并两个路由器配置：
base_config = {"interfaces": ["eth0"], "ip": "192.168.1.1"}
update = {"interfaces": ["eth0", "wlan0"], "security": "WPA2"}
输出：{"interfaces": ["eth0", "wlan0"], "ip": "192.168.1.1", "security": "WPA2"}
'''
# base_config = {"interfaces": ["eth0"], "ip": "192.168.1.1"}
# update = {"interfaces": ["eth0", "wlan0"], "security": "WPA2"}
# base_config.update(update)
# print(base_config)

'''
5、实验数据统计
给定温度读数：[(1, 23.5), (2, 24.1), (1, 23.8), (3, 22.9)]
（传感器ID, 温度）
计算：每个传感器的平均温度、全局最高温度读数
'''
# temp=[(1, 23.5), (2, 24.1), (1, 23.8), (3, 22.9)]
# dic={}
# ma=0
# for idx in temp:
#     if dic.get(idx[0],0)==0:
#         dic[idx[0]]=[] #不能用set集合来存储，不然会去除重复的读数，平均值不准确
#         dic[idx[0]].append(idx[1])
#     else:
#         dic[idx[0]].append(idx[1])
#     if idx[1]>ma:
#         ma=idx[1]
# avg={}
# for idy,lst in dic.items():
#     sum=0
#     cnt=0
#     for every in lst:
#         cnt+=1
#         sum+=every
#     avg[idy]=sum/cnt
# print(avg)
# print(ma)

'''
6、权限组管理
用户-角色关系：
users = {
    "alice": {"admin", "editor"},
    "bob": {"viewer"},
    "charlie": {"editor", "reviewer"}
}
角色-权限关系：
roles = {
    "admin": {"create", "delete", "update"},
    "editor": {"create", "update"},
    "reviewer": {"approve"},
    "viewer": {"read"}
}
验证用户"alice"是否有"delete"权限，列出用户"charlie"的所有权限
'''
# users = {
#     "alice": {"admin", "editor"},
#     "bob": {"viewer"},
#     "charlie": {"editor", "reviewer"}
# }
# roles = {
#     "admin": {"create", "delete", "update"},
#     "editor": {"create", "update"},
#     "reviewer": {"approve"},
#     "viewer": {"read"}
# }
# dele=False
# for role in users["alice"]:
#     for permission in roles[role]:
#         if permission=="delete":
#             dele=True
#             break#找到了就可以退出循环，减少浪费时间
# print(dele)
# permissions=set()
# for role in users["charlie"]:
#     for permission in roles[role]:
#         permissions.add(permission)
# print(permissions)

'''
进阶题目（2道） - 综合数据处理
1、日志分析系统
输入日志列表：
logs = [
    "2023-08-01 08:30:45 ERROR ModuleA: Failed to connect",
    "2023-08-01 08:31:10 INFO ModuleB: Process started",
    "2023-08-01 08:32:00 WARNING ModuleA: Low memory",
    "2023-08-01 08:33:22 ERROR ModuleC: Timeout exception"
]
要求：
（1）按日志级别统计计数
（2）提取错误日志的模块名和时间
（3）生成按分钟聚合的日志数量时间线
输出结构：
{
    "stats": {"ERROR": 2, "INFO": 1, "WARNING": 1},
    "errors": [
        {"time": "08:30:45", "module": "ModuleA"},
        {"time": "08:33:22", "module": "ModuleC"}
    ],
    "timeline": {
        "08:30": 1,
        "08:31": 1,
        "08:32": 1,
        "08:33": 1
    }
}
'''
# logs = [
#     "2023-08-01 08:30:45 ERROR ModuleA: Failed to connect",
#     "2023-08-01 08:31:10 INFO ModuleB: Process started",
#     "2023-08-01 08:32:00 WARNING ModuleA: Low memory",
#     "2023-08-01 08:33:22 ERROR ModuleC: Timeout exception"
# ]
# dic={}
# dic["stats"]={}
# dic["errors"]=[]
# dic["timeline"]={}
# for line in logs:
#     lst=line.split(" ")
#     print(lst)
#     dic["stats"][lst[2]]=dic["stats"].get(lst[2],0)+1
#     if lst[2]=="ERROR":
#         module_name = lst[3].rstrip(':')  # 去除末尾冒号
#         dic["errors"].append({"time": lst[1], "module": module_name})
#         #dic["errors"].append({"time": lst[1], "module": lst[3]}) #这一句提取出来的是"ModuleA:"，末尾多了冒号
#     dic["timeline"][lst[1][:5]]=dic["timeline"].get(lst[1][:5],0)+1
# print(dic)

'''
2、电商订入数据：
products = {
    101: {"name": "Keyboard", "price": 25.99, "stock": 100},
    102: {"name": "Mouse", "price": 15.50, "stock": 50}
}
orders = [
    {"order_id": 1001, "items": [(101, 2), (102, 1)]},
    {"order_id": 1002, "items": [(101, 3)]},
    {"order_id": 1003, "items": [(102, 10)]}
]
要求：
（1）验证订单库存并处理（库存不足则标记）
（2）计算订单总金额（含8%税）
（3）更新库存
（4）生成销售报告：
{
    "processed_orders": [1001, 1002],
    "failed_orders": [1003],
    "total_sales": 25.99*2 + 15.50*1 + 25.99*3,
    "inventory_after": {
        101: 100-2-3,
        102: 50-1
    },
    "best_seller": "Keyboard"
}
'''
# products = {
#     101: {"name": "Keyboard", "price": 25.99, "stock": 100},
#     102: {"name": "Mouse", "price": 15.50, "stock": 50}
# }
# orders = [
#     {"order_id": 1001, "items": [(101, 2), (102, 1)]},
#     {"order_id": 1002, "items": [(101, 3)]},
#     {"order_id": 1003, "items": [(102, 10)]}
# ]
# # 初始化结果
# processed_orders = []
# failed_orders = []
# total_sales = 0.0
# # 深拷贝初始库存，用于更新和后续检查
# inventory = {pid: products[pid]["stock"] for pid in products}
# # 记录每个商品的销售数量，用于计算最佳销量商品
# sales_count = {pid: 0 for pid in products}
# # 处理每个订单
# for order in orders:
#     order_id = order["order_id"]
#     items = order["items"]
#     # 1. 验证库存是否充足
#     sufficient = True
#     for pid, qty in items:
#         if inventory[pid] < qty:
#             sufficient = False
#             break
#     if not sufficient:
#         failed_orders.append(order_id)
#         continue
#     # 2. 处理订单（库存充足）# 要注意，只有库存充足才处理订单
#     processed_orders.append(order_id)
#     order_subtotal = 0.0
#     for pid, qty in items:
#         price = products[pid]["price"]
#         order_subtotal += price * qty          # 订单税前小计
#         sales_count[pid] += qty                # 累计销量
#         inventory[pid] -= qty                  # 扣减库存
#     # 3. 加8%税，累加到总销售额
#     total_sales += order_subtotal * 1.08
# # 4. 确定最畅销商品（销量最高）
# best_seller_id = max(sales_count.items(), key=lambda x: x[1])[0]
# # max()函数在可迭代对象中找出最大值。
# # key 参数指定一个函数，该函数用于从每个元素中提取用于比较的值。这里 lambda x: x[1] 表示对每个元组 x，取它的第二个元素（即销量）作为比较依据。
# # 因此，max()会返回销量最大的那个元组，例如 (101, 5)。
# # [0]对上一步返回的元组取索引0，即元组的第一个元素（商品ID），得到 101。
# best_seller_name = products[best_seller_id]["name"]
# # 5. 生成最终报告
# report = {
#     "processed_orders": processed_orders,
#     "failed_orders": failed_orders,
#     "total_sales": total_sales,
#     "inventory_after": inventory,
#     "best_seller": best_seller_name
# }
# print(report)