01 recode
容器：
list[] dict{} tuple() set{}
使用频率依次降低
特点：
list[]: 可变，有序；元素是任何数据类型
增：append(), insert(), extend()
删: del, remove, pop
改: list[下标] = 新值
查: list[下标或切片], 遍历
dict{}: 可变，无序；元素为键值对，键不可变，唯一，值可以是任何类型数据
增: dict[key] = 值, dict.update(序列), setdefault(key, 默认值)key存在没有影响，不存在增加
a = {"a": 2}
b = {"c": 3}
a.setdefault("b", 8)
print(a)
删: del, pop, clear
改: dict[key] = 值
查: dict[key], dict.get(key), dict.get(key, 默认值), 遍历拿的是key值,get方法如果存在key，就返回值，不存在key，返回默认值，默认值可以设置，默认为None
print(a.get("d"))
tuple(): 不可变，有序；元素为任何类型数据
查：和列表一样，tuple[下标或切片], 遍历
tuple(1,)
tuple = 1, 2, 3, 4, 5, 6, 7
x, y = (10, 20)
x, *num, y = tuple
set{}: 可变，无序；元素是不可变的唯一的
增: add(), update()
c = {1, 2, 3}
d = {2, 3, 4}
c.update(d)
print(c, d)
删: remove()
查: 只能遍历通过for in
去重功能
相关数学运算: 包含 >= <=， 求并集 | ， 交集 & ， 差集 - ， 补集 ^
02 浅拷贝与深拷贝
a = 100
b = a
b = 200
print(a, b) # 100 200
a = [1, 2]
b = a
b = [2, 3]
print(a, b) # [1, 2] [2, 3]
a = [1, 2]
b = a
b.append(3)
print(a, b) # [1, 2, 3] [1, 2, 3]
a = [1, 2]
b = a.copy()
c = a[:]
d = a
a.append(100)
print(a, b, c, d) # [1, 2, 100] [1, 2] [1, 2] [1, 2, 100]
拷贝：就是讲变量中的值复制一份，产生新的数据新的地址，将新的数据的地址返回
1. 浅拷贝：直接拷贝地址:copy() 或 切片 import.copy ----copy.copy()
2. 深拷贝：将地址对应的值拷贝，产生新的地址:import copy ----copy.deepcopy()
浅拷贝
print("===================")
a1 = [1, 2]
a2 = {"a": 10}
list1 = [a1, a2]
list2 = list1.copy()
print(list1, list2, sep = "\n") # [[1, 2], {"a": 10}] [[1, 2], {"a": 10}]
list2.append(100)
print(list1, list2, sep = "\n") # [[1, 2], {"a": 10}] [[1, 2], {"a": 10}, 100]
list2[0].append(200)
print(list1, list2, sep = "\n") # [[1, 2, 200], {"a": 10}] [[1, 2, 200], {"a": 10}, 100]
深拷贝
print("----------------")
import copy
a1 = [1, 2]
a2 = {"a": 10}
list1 = [a1, a2]
list2 = copy.deepcopy(list1)
print(list1, list2, sep = "\n") # [[1, 2], {"a": 10}] [[1, 2], {"a": 10}]
list2.append(100)
print(list1, list2, sep = "\n") # [[1, 2], {"a": 10}] [[1, 2], {"a": 10}, 100]
list2[0].append(200)
print(list1, list2, sep = "\n") # [[1, 2], {"a": 10}] [[1, 2, 200], {"a": 10}, 100]
03 列表和字典的引用
列表的元素和字典的值可以是任何类型的数据
1. 列表中有字典
用列表保存多个人信息
persons = [{"name": "张三", "age": 22},
{"name": "李四", "age": 20},
{"name": "王二麻子", "age": 30}]
print(persons)
取出李四
for person in persons:
if person["name"] == "李四":
print(person)
找出年龄最大的人的名字
maxage = 0
person = " "
for out_person in persons:
x = out_person["age"]
if x > maxage:
maxage = x
person = out_person["name"]
print(maxage, person)
2. 字典中有列表
写一个程序，保存一个班级的信息，班级名，位置，所有学生,学生中需要保存名字，年龄，学校
class_information = {"班级名": 1807, "位置": 601,
"all_student": [{"name": "张三", "age": 22, "school": "清华" },
{"name": "李四", "age": 18, "school": "北大"},
{"name": "王二麻子", "age": 25, "school": "复旦"}]}
print(class_information["all_student"][0]["school"])
练习;添加学生：姓名， 年龄， 学校
addname = input("请输入添加的姓名: ")
addage = input("请输入年龄: ")
addschool = input("请输入毕业学校: ")
student = {"name": addname, "age": addage, "school": addschool}
class_information["all_student"].append(student)
print(class_information["all_student"])
练习 删除班级中年龄小于20岁的人
for student in class_information["all_student"][:]: # 不切片遍历会跳过一些元素
if student["age"] < 20:
print(student)
class_information["all_student"].remove(student)
print(class_information["all_student"])
print("==============")
stu = class_information["all_student"]
index = 0
while index < len(stu):
student == stu[index]
if student["age"] < 20:
del stu[index]
continue
index += 1
print(stu)
04 为什么要使用函数
没有函数的时候的问题：
- 同样的代码需要重复很多遍
- 功能发生改变需要修改很多地方
怎么解决？ 使用函数
左移
def left():
print("================左移=================")
print("看后视镜")
print("打左转向灯")
print("踩油门")
print("往左打方向盘")
print("回正方向盘")
右移
def right():
print("================右移=================")
print("看后视镜")
print("打右转向灯")
print("踩油门")
print("往右打方向盘")
print("回正方向盘")
left()
right()
left()
right()
05 函数的声明
函数就是对实现某一特定功能的代码段的封装
分类：自定义函数(由程序员声明实现对应的功能)和内置函数(python已经声明完成的)
1. 声明函数的语法
def 函数名(参数列表):
函数体
说明：
a. def ---> python 中声明函数的关键字
b. 函数名 ---> 标志服，不能是关键字，遵循pep8命名规范(所有字母小写，多个单词用"_"分开), 要见名知义(看见名字知道函数的功能)
c. () ---> 固定格式，存放参数(形参)
d. 参数列表 ---> 形参列表， 参数名1，参数名2，…… 可以有多个参数，也可以没有，参数是用来从函数外部给函数里面传值用的
e : ---> 固定格式
f 函数体 ---> 就是实现函数功能的代码段
2. 初学者声明函数的步骤
a. 确定函数功能
b. 根据功能确定函数名
c. 确定参数: 确定有没有，确定有几个(看实现函数的功能需不需要从函数外边传值，需要传几个)
d. 实现函数的功能
e. 确定返回值
3. 函数的调用
声明函数的时候，不会执行函数体，函数体只有在函数调用的时候才会执行
调用语法：
函数名(实参列表)
说明：
函数名 ---> 必须是已经声明过的函数
() ---> 固定写法
实参列表 ---> 参数1, 参数2, 参数3...... 多少个实参主要看声明函数的形参有多少个
作用：用来给形参赋值
练习1：写一个函数，打印两个数的和
def qiuhe(x, y):
print(x + y)
a = 4
b = 5
qiuhe(a, b)
练习2：写一个函数，打印五个*
def print_star():
print("*"*5)
print_star()
练习3：写一个函数，打印n个*
def print_stars():
n = int(input("需要打印多少颗*："))
print("*"*n)
print_stars()
练习:写一个函数，计算1 + 2 + 3 + ......n 的和
def num_sum(n):
sum1 = 0
for i in range(1, n + 1):
sum1 += i
print(sum1)
num_sum(100)
06 函数的格式和调试过程
1. 格式
函数名(实参列表)
2. 函数的调用过程(重点！！！！！！)
第一步：回到函数声明的位置
第二步：用实参给形参赋值
第三步：执行函数体
第四步：返回返回值
第五步：执行完函数体，回到函数调用的地方，接着之后后面的代码
07 函数的参数
根据调用的时候传参分类
1. 位置参数和关键字参数
传值：传参一定要保证每个参数都要有值
位置参数：按照实参的顺序一一给形参赋值
关键字参数：形参1 = 值1， 形参2 = 值2
位置参数
def func1(a, b, c):
print(a, b, c)
func1(10, 20, 30)
关键字参数
func1(a = 100, c = 200, b = 500)
2. 默认参数
函数声明的时候可以给参数设置默认值,有默认值的参数必须放在没有默认值的参数后面
def func2(c, b=5, a=10, d=2):
print(a, b, c, d)
func2(20)
func2(8, 6, 4)
def func3(a=10, c=30, b=20):
print(a, b, c)
func3(100, b=200)
3. 不定长参数
参数的个数不确定的时候，可以在形参的前面加*，将这个形参变成一个元组来接收多个参数
注意：如果函数有多个参数，那么不定长参数要放在最后
写一个函数，求多个数的和(遍历或者直接sum)
def my_sum(*num):
print(sum(num))
my_sum(1, 2, 3, 4)
def my_sum(*num):
sum_num = 0
for num in num:
sum_num += num
print(sum_num)
my_sum(1, 2, 3)
不定长参数需要写在形参后面
def func4(a, b, c, *num):
print(num, a, c, b)
func4(1, 2, 3, 4, 5, 6, 7)