diff --git a/南方宇 0903 作业.txt b/南方宇 0903 作业.txt
new file mode 100644
index 0000000..109e063
--- /dev/null
+++ b/南方宇 0903 作业.txt	
@@ -0,0 +1,149 @@
+# 【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
\ No newline at end of file
diff --git a/南方宇 0903Python思维导图.pdf b/南方宇 0903Python思维导图.pdf
new file mode 100644
index 0000000..2a31984
Binary files /dev/null and b/南方宇 0903Python思维导图.pdf differ
diff --git a/南方宇 0907 作业.txt b/南方宇 0907 作业.txt
new file mode 100644
index 0000000..1540429
--- /dev/null
+++ b/南方宇 0907 作业.txt	
@@ -0,0 +1,122 @@
+##【day13作业】
+'''先完成今天课程的模块、包、面向对象的理解和练习，再写以下作业！'''
+
+# 【包、模块】
+# 1、总结什么包？模块？
+# 包：本质上就是一个文件夹
+# 模块：就是py文件，将重复使用的功能代码写入一个py文件里，提供给其他人使用
+# 2、总结如何定义一个模块、并调用
+# 定义一个模块要新建一个python文件，将函数、变量等写在文件里，供其他文件调用；
+# ① from 模块名称(py文件名) import  模块内部的变量/函数/类；
+# ② import 模块名称(py文件名)
+# 3、总结如何定义一个包、并调用
+# 新建一个__init__.py文件夹，可以储存多个.py文件，管理多个模块；
+# ①from p1 import m1,m2   导入p1这个包下的m1模块、m2模块
+# ②from p1 import *       导入p1这个包下的所有模块
+
+# 【异常处理】
+# 1、总结异常处理有什么作用？
+# ①只要程序遇到报错了，通过异常处理，不阻塞后续的代码继续执行
+# ②无论代码程序报不报错，都需要记录程序执行的过程到日志文件里，方便日后的一个问题排查
+# ③为了更加友好的用户体验，自定义友好的异常输出
+# 2、总结异常处理的语法结构是什么样的？
+# try:
+#     print( '存放可能报错的代码块...' )
+# except Exception as e1:
+#     print('只要报错了，就执行这一段，并捕获报错信息！记录报错的日志信息到日志文件里面去！')
+# else:
+#     print('不会报错时才会执行的代码！')
+#     print('如果代码正常执行，可以利用这个步骤来记录程序执行的日志信息，记录到日志文件里面...')
+# finally:
+#     print('无论包不报错，都会执行的代码！')
+#     print('一般用来释放资源的！')
+#【基础练习1】
+# 1.创建一个学生类 Student，定义初始化方法__init__()初始化实例属性 name、sex、age、score（成绩列表）
+# ，以及类属性class_id=260824、class_name=Ai0824
+stu1={'name':'南方宇','sex':'男','age':24,'score':[80,70,60]}
+stu2={'name':'北方宇','sex':'女','age':28,'score':[90,100,70]}
+class Student:
+    class_id = 260824
+    class_name='Ai0824'
+    def __init__(self,n,s,a,sc):
+        self.name=n
+        self.sex=s
+        self.age=a
+        self.score=sc
+    def get_stuinfo(self):
+        print(self.name,self.sex,self.age,self.score)
+
+    def avg_score(self):
+        n=sum(self.score)/len(self.score)
+        print(n)
+
+# 2.实例化学生对象stu1、sut2，并挨个访问实例属性以及类属性，查看结果
+s1=Student('南方宇','男',24,[80,70,60])
+s2=Student('北方宇','女',28,[90,100,70])
+print(s1.name,s1.sex,s1.age,s1.score)
+print(s2.name,s2.sex,s2.age,s2.score)
+print(Student.class_id,Student.class_name)
+# 3.定义一个 get_stuinfo() 方法，调用该方法可以返回学生的所有属性
+s1.get_stuinfo()
+s2.get_stuinfo()
+# 4.定义成绩平均分的方法 avg_score() 来计算每个学生的平均分，实例对象调用方法后，返回该学生的平均分
+s1.avg_score()
+s2.avg_score()
+# 【基础练习2】
+# 1.创建一个老师类 Teacher，定义初始化方法__init__()初始化实例属性 name、age、project（科目）、salary
+# ，有类属性 company = '沃林数智'、boss = ['陈总','廖总']
+tea1={'name':'东方宇','age':35,'project':'python','salary':12000}
+tea2={'name':'西方宇','age':44,'project':'java','salary':15500}
+class Teacher:
+    company = '沃林数智'
+    boss = ['陈总', '廖总']
+    s1 = Student('南方宇', '男', 24, [80, 70, 60])
+    s2 = Student('北方宇', '女', 28, [90, 100, 70])
+    def __init__(self,n,a,p,s):
+        self.name=n
+        self.age=a
+        self.project=p
+        self.salary=s
+
+    def teaching(self, x):
+        print(f'{self.name}老师正在使用{x}的方法教学')
+
+# 2.实例化 t1、t2 两个老师实例对象，并访问对应的实例属性和类属性
+t1=Teacher('东方宇',35,'python',12000)
+t2=Teacher('西方宇',44,'java',15500)
+print(t1.name,t1.age,t1.project,t1.salary)
+print(t2.name,t2.age,t2.project,t2.salary)
+print(Teacher.company,Teacher.boss)
+# 3.定义一个 教学方法 teaching(self,x),x接收的是老师的教学方法
+# ，实例对象调用时，返回的结果是 f'{xxx}老师正在使用{x}的方法教学...'
+t1.teaching('寓教于乐')
+t2.teaching('因材施教')
+# 4.通过t1.company 调用类属性，然后再进行 t1.company = '沃林牛逼集团'
+# ，再次通过类Teacher和t1实例对象分别调用company看看有什么不同？为什么？
+print(t1.company)
+t1.company = '沃林牛逼集团'
+print(t1.company)
+print(Teacher.company)
+# t1.company被赋值成为'沃林牛逼集团'，是一个实例属性
+# Teacher.company保持不变，是一个类属性
+# 对实例属性的赋值并不会改变类属性。
+
+# 5.通过t1对象去调用Student类里的get_stuinfo()方法可以吗？测试一下并思考
+t1.s1.get_stuinfo()
+# 可以，将实例属性s1作为Teacher类里的类属性，可以使用get_stuinfo().
+# 6.总结目前学习的面向对象的语法结构框架
+class 类名:  # 定义一个类,类的命名都要大写开头
+    类属性1:''
+    类属性2:211321
+    def __init__(self,n,a,s):  # 使用一个初始化方法
+        self.name=n
+        self.age=a
+        self.sex=s   #将参数赋值给属性
+    def get_stu_info(self):  # 定义一个方法，用来打印每个对象的属性
+        print(self.name,self.sex,self.age)
+# 实例化
+s1 = 类名('姓名', 30, '男')  # 这个过程叫做实例化，得到的结果叫做示例对象
+#调用实例对象的属性
+print(s1.name,s1.sex,s1.age)
+# 调用实例对象自己的方法
+s1.get_stuinfo()
\ No newline at end of file