# 【day10作业】
# 【深浅拷贝基础】
# 1：浅拷贝学生信息复制
# 需求：
# 列表样例：stu = {"name": "小明", "age": 18, "scores": [80, 90]}
# 使用浅拷贝复制学生字典给变量 stu_new。
# 修改新字典 stu_new 里的基础类型字段和嵌套列表里的数据，观察原字典 stu 与新字典 stu_new 是否变化。
stu = {"name": "小明", "age": 18, "scores": [80, 90]}
import copy
stu_new=copy.copy(stu)
print(stu,stu_new)
stu_new['name']='小刚'
stu_new['scores'][0]=60
# print(stu_new)
print(stu,stu_new)
print(id(stu_new),id(stu))
# 2：深拷贝学生信息
# 需求：使用深拷贝复制学生字典给变量 stu_deep。
# 修改新字典 stu_deep 里的嵌套列表，观察原字典是否改变。
stu_deep=copy.deepcopy(stu)
print(stu,stu_deep)
stu_deep['name']='小红'
stu_deep['scores'][0]=30
print(stu,stu_deep)
print(id(stu_deep),id(stu))
# 3：总结一下，变量的赋值引用、浅拷贝、深拷贝之间的区别差异
# 赋值引用:a=b a与b完全相等，修改任意一方，另一方也跟着改变。
# 浅拷贝：b=copy.copy(a) 修改b中的基础类型字段（外层）a中的基础类型字段不会改变；修改b嵌套列表里的数据（内层）a会跟着改变。
# 深拷贝：b=copy.deepcopy(a) 修改b中的基础类型字段（外层）a中的基础类型字段不会改变；修改b嵌套列表里的数据（内层）a也不会改变。
# 【容器基础】
# 1.总结列表、元组、字典、集合四大容器之间的特点和区别
# 特点
# 列表list：有序，数据可变，用[]把元素包起来，切片用 列表[] 切片，可for遍历
# 元组tuple:有序，不可变数据类型，用()把元素包起来，切片用 元组[] 切片，可for遍历
# 集合set：无序，数据可变，用{}把元素包起来，不能切片，可for遍历，可以去重元素
# 字典dict：有序，数据可变，用{key:value}把元素包起来,每个元素都是键值对存在，key不会重复，重复即更新。key必须是一个不可变的数据类型
# 区别：
# 列表、集合、字典：内部数据可变，可以增删改
# 元组：内部元素不可变，不能增删改，但是如果内部元素本身是个可变的容器，那么也可以修改

# 2.总结列表、字典的常用方法和函数
# 列表：
#     统计列表的元素个数函数 len()
#     列表元素的新增方法(末尾)append()
#     列表元素的新增方法(插入)insert()
#     列表元素的删除（根据元素去删除）方法remove()
#     取列表的元素以及对应的索引函数 enumerate()
#     常用的聚合函数 sum() max()  min()
#     统计元素出现的次数方法 count()
#     列表的排序方法sort()
#     列表的排序函数 sorted()
# 字典：
#     统计字典的键值对个数函数len()
#     一次性添加多个键值对方法update()
#     得到字典所有的键方法keys()
#     得到字典的所有的值方法values()
#     得到字典的所有键值对方法items()
# 3.用列表推导式生成10个[0-100]之间的随机数
import random
n = random.randint(0,100)
num_rand= [ random.randint(0,100) for i in range(1,11) ]
print(num_rand)
# 4.将第3题的列表转成集合进行去重，去重后再转成元组
l=[75, 23, 33, 45, 77, 24, 65, 5, 92, 41]
s=set(l)
print(s)
t=tuple(s)
print(t)
# 5.定义一个字典 stu = {name：xx，sex：xx，age：xx，hobby：[1,2,3,4]}，
# 用来记录学生的属性信息，属性里的hobby键值对是记录爱好，爱好是列表，多个爱好
stu = {'name':'南方宇','sex':'男','age':24,'hobby':['吃饭','睡觉','打豆豆','打代码']}
# 6.取出字典stu中的名字、性别、以及第2个爱好
print(stu['name'],stu['sex'],stu['hobby'][1])
# 7.将年龄改成30岁
stu['age']=30
print(stu)
# 8.将第三个爱好改成'篮球'
stu['hobby'][2]='篮球'
print(stu)
# 9. 新增一个键值对 手机号
stu['phone_num']='13836812345'
print(stu)
# 10. 删除性别
del stu['sex']
print(stu)
# 11. 遍历字典中的所有key、value、以及键值对，键值对要拆包的形式
x=stu.keys()
print(x)
for k in x:
    print(k)
y=stu.values()
print(y)
for v in y:
    print(v)
z=stu.items()
print(z)
for k,v in stu.items():
    print(k,v)
# 12. 将字典中的所有values转成 列表
v=stu.values()
l=list(v)
print(l)
# 【进阶】
#
# 1. 使用列表推导式，生成如下结果
# 返回的结果：
# [
# {"id": 1, "name": "学生1", "scores": []},
# {"id": 2, "name": "学生2", "scores": []},
# {"id": 3, "name": "学生3", "scores": []},
# ]
student= [ {'id':i,'name':f'学生{i}','scores':[]} for i in range(1,4) ]
print(student)
# 2.基于上一题返回的学生列表，给所有学生成绩添加三个分数元素
student=[{'id': 1, 'name': '学生1', 'scores': []}, {'id': 2, 'name': '学生2', 'scores': []}, {'id': 3, 'name': '学生3', 'scores': []}]
for i in student:
    i['scores']=[60,80,100]
    print(i)
print(student)
# 3.计算每个学生的平均分
for s in student:
    print(s)
    total_score=0
    for z in s['scores']:
        print(z)
        total_score+=z
avg_score=total_score/len(s['scores'])
print(avg_score)
#
# 4.单词统计，数据示例： "I love Python love"，统计后返回结果是元组嵌套字典： ("love", {"i":1, "love":2, "python":1})，出现次数最大的单词放到最前面。
s='I love Python love'
print(s.split(' '))
w=s.split(' ')
d = {}
for i in w:
    # d[i] = d.get(i,0) + 1
    d[i]=w.count(i)
s = ''
for k,v in d.items():
    if v == max(d.values()):
        s += k
t = (s,d)
print(t)
# 【附加题】（选做，可ai或百度这种排序算法！）
# 列表 lst = [1,2,3,5,2,2,93,1],使用冒泡排序的方式来进行排序，注意不是选择排序！对比下冒泡排序跟选择排序的区别！
# 核心思想：重复走访待排序序列，相邻两个元素两两比较，如果顺序大于或小于就交换，每一轮都会把当前未排序部分最大（或最小）的元素 “冒泡” 到末尾。
#
# 排序算法动画地址演示：
# https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html

喵喵喵喵喵  #新增 0919
哈哈哈哈哈哈 #新增 0919:2