一、列表，字典，元组，集合复习
列表(list): []；可变，有序；元素是任何类型的数据
增：append， insert, extend
删：del, remove, pop, clear
改：列表[下标] = 新值
查：列表[下标], 切片, 遍历字典(dict): {}；可变，无序；元素是键值对，键是不可变的唯一的，值可以是任何类型的数据
增：字典[key] = 值, setdefault(key,默认值)，update
删：del, pop, clear
改：字典[key] = 值
查：字典[key], 字典.get(key), 字典.get(key,默认值)，遍历元组(tuple): ()；不可变，有序；元素是任何类型的数据
查：和列表一样
tuple1 = 2, 34, 90, 18, 90
tuple2 = ('abc',)
x,y = (10, 20)
x,y = 10, 20
*nums, x, y = tuple1集合(set): {}；可变，无序；元素是不可变的唯一的
增：add, update
删：remove
查：遍历
集合运算：包含(>=, <=)，并集(|)、交集(&)、差集(-)、补集(^)
二、浅拷贝和深拷贝
import copy
copy.copy(对象)：浅拷贝
copy.deepcopy(对象):深拷贝
a = 100
b = a
b = 200 # 整数类型只能直接赋值，b不会影响a
a = [1, 2]
b = a.copy()
b.append(3)
print(a) # [1, 2] # 将a复制一份，存到新的地址空间，再给b，b不会影响a
拷贝：将变量中的值赋值一份，产生新的数据。然后将新的数据对应的地址返回。
浅拷贝：直接拷贝地址（切片和字典列表的copy方法都是浅拷贝）
深拷贝：将地址对应值拷贝，产生新的地址
a1 = [1, 2]
a2 = {'a': 10}
list1 = [a1, a2]
# 浅拷贝
# list2 = list1.copy()
list2 = copy.copy(list1)
# 深拷贝
# list2 = copy.deepcopy(list1)
list2.append(1)
print(list2) # [[1, 2], {'a': 10}, 1]
print(list1) # [[1, 2], {'a': 10}]
list2[0].append(100)
print(list2) # [[1, 2, 100], {'a': 10}, 1]
print(list1) # [[1, 2, 100], {'a': 10}]
-
浅拷贝图示如下：
浅拷贝.png
list1和list2保存的都是a1和a2地址的值，所以list2修改a1和a2元素会影响到list1
-
深拷贝图示如下：
深拷贝.png
深拷贝如果检测到所拷贝的是地址，会将地址所指的值再拷贝一份到新的地址空间，把新的地址空间赋值给拷贝结果，所以list2和list1所存放的地址不同，list2不会影响到list1
并且深拷贝会对多层嵌套的所有地址进行类似拷贝操作
深拷贝执行过程.png
三、字典和列表的应用
列表的元素和字典的值可以是任何类型的数据
1.列表中有字典
persons = [
{'name': '张三', 'age': 30, 'gender': 'male'},
{'name': '李四', 'age': 28, 'gender': 'female'},
{'name': '王五', 'age': 40, 'gender': 'male'},
]
print(persons)
print(persons[1]['name']) # 李四
找出persons中年龄最大的人的名字
-老师答案：
max1 = 0
name = ''
for item in persons:
age = item['age']
if age > max1:
max1 = age
name = item['name']
print(max1, name)
-自己答案：
age_list = []
dict1 = {}
for person in persons:
age = person['age']
age_list.append(age)
dict1[age] = person['name']
max_age = max(age_list)
max_age_person = dict1[max_age]
print(max_age_person)
2.字典中有列表
写一个程序，保存一个班级的信息，包含班级名，位置，所有的学生（学生中需要保存名字，年龄，学校）
my_class = {
'name': 'python1807',
'location': '18-6',
'students': [
{'name': '小花', 'age': 18, 'school': '清华'},
{'name': '小明', 'age': 20, 'school': '川大'},
],
}
print(my_class['students'][1]['school']) # 川大
练习：在班级中添加一个学生，姓名：老王， 年龄：40, 学校：北大青鸟
name = input('请输入名字：')
age = int(input('请输入年龄：'))
school = input('请输入学校：')
# 根据输入的信息新建一个对应学生的字典
new_stu = {'name': name, 'age': age, 'school': school}
# 将字典加入到对应的列表中
my_class['students'].append(new_stu)
for stu in my_class['students']:
print(stu)
# {'name': '小花', 'age': 18, 'school': '清华'}
# {'name': '小明', 'age': 20, 'school': '川大'}
# {'name': '老王', 'age': 40, 'school': '北大'}
删除班级中，年龄小于20岁的人
-方法一：
for stu in my_class['students'][:]:
if stu['age'] < 20:
my_class['students'].remove(stu)
continue
print(stu)
- 方法二：
all_stu = my_class['students']
index = 0
while index < len(all_stu):
stu = all_stu[index]
if stu['age'] < 20:
del all_stu[index]
continue
print(all_stu[index])
index += 1
# {'name': '小明', 'age': 20, 'school': '川大'}
# {'name': '老王', 'age': 40, 'school': '北大'}
四、为什么要使用函数
没有函数的时候的问题：
- 同样的代码需要重复很多遍
- 功能发生改变需要修改很多地方
怎么解决：使用函数
# 左移，右移
# 左移
def left():
print('=======左移=========')
print('看后视镜')
print('打左转向灯')
print('踩油门')
print('向左打方向盘')
print('回正方向盘')
# 右移
def right():
print('=======右移=========')
print('看后视镜')
print('打右转向灯')
print('踩油门')
print('向右打方向盘')
print('回正方向盘')
left()
right()
left()
left()
right()
right()
right()
五、函数的声明
函数就是对实现某一特定功能的代码段的封装
sum()
max()
range()
- 分类：自定义函数(程序猿自己声明实现其功能)和内置函数（系统已经声明实现完成）
1. 声明函数的语法
- 语法：
def 函数名(参数列表) -> 返回值类型:
函数的描述信息
函数体
- 说明：
a. def ---> python中声明函数的关键字
b. 函数名 ---> 标识符，不能是关键字。遵守PEP8命名规范（所有字母小写，多个单词之间用下划线隔开）
见名知意（看见名字知道函数的功能）
c. () ---> 固定格式
d. 参数列表 ---> 形参列表，格式：参数名1，参数名2，……
可以有多个参数，也可以没有
参数是用来从函数的外部给函数里面传值用的
e. : ---> 固定格式
f. 函数体 ---> 实现函数功能的代码段
g. 函数的描述信息 ---> 描述函数功能，在指定位置用"""后回车自动出现，在调用函数时，对函数按ctrl可以看到函数描述
def func1(a, b):
"""
求两个数的和
:param a: 数字，整型
:param b: 数字，整型
:return: 和
"""
return a + b
补充：参数列表中，可以通过“参数名： 类型名”来指定参数的类型，也可以通过设置默认值来说明参数的类型
说明类型的好处：
a. 传什么类型的值一目了然
b. 实现函数体的时候，可以有相关提示
def func1(a: int, b: int) -> int:
"""
求两个数的和
:param a: 数字，整型
:param b: 数字，整型
:return: 和
"""
return a + b
2. 初学者声明函数的步骤
a. 确定函数的功能
b. 根据功能确定函数名
c. 确定参数：确定有没有，确定有几个
（看实现函数的功能是否需要从函数外面传值，需要传几个）
d. 实现函数功能
e. 确定返回值
3. 函数的调用
声明函数的时候，不会执行函数体。
函数体只有在函数调用的时候才会执行
语法：
函数名(实参列表)说明：
函数名 --> 必须是已经声明过的函数
() --> 固定的
实参列表 --> 数据1,数据2,……
实参用来给形参赋值
写一个函数，打印两个数的和
def sum_num(num1, num2):
sum1 = num1 + num2
print(sum1)
sum_num(5, 10)
写一个函数，打印5个'*'
def print_star():
print('*'*5)
print_star()
写一个函数，打印n个'*'
def print_star2(n):
print('*'*n)
print_star2(10)
print_star2(15)
练习：写一个函数，计算1+2+……+n的和
def sum_nums(n):
sum1 = sum(range(n+1))
# sum1 = 0
# for i in range(1,n+1):
# sum1 += i
print(sum1)
sum_nums(100)
六、函数的调用
1. 格式
函数名(实参列表)
2. 函数的调用过程（重点！！！)
- 第一步：回到函数声明的位置
- 第二步：用实参给形参赋值
- 第三步：执行函数体
- 第四步：返回返回值 --> 返回给函数调用表达式
- 第五步：回到函数调用的位置，接着执行后面的代码
# 第一步：回到函数声明的位置
def sum_num(num1, num2):
# 第二步：num1 = 5, num2 = 20
# 第三步：执行下面的函数体代码
sum1 = num1 + num2
print(sum1)
# 第四步：返回值（此处没有返回值）
sum_num(5, 10)
# 第五步：回到函数调用的位置，接着执行后面的代码
print('=============')
七、函数的参数
1.位置参数和关键字参数
- 位置参数：按照实参的顺序一一给形参赋值
- 关键字参数：形参1= 值1， 形参2= 值2， ……
def func1(a, b, c):
print('a:', a, 'b:', b, 'c:', c)
位置参数
func1(10, 20, 30) # a: 10 b: 20 c: 30
关键字参数
func1(c=300, a=200, b=100) # a: 200 b: 100 c: 300
2.默认参数
函数声明的时候，可以给参数设置默认值,但是有默认值的参数必须放在参数列表的最后
有默认值的参数，在调用的时候可以不用传参
def func2(a, c, b=0):
print('a:', a, 'b:', b, 'c:', c)
func2(10, 20) # a: 10 b: 0 c: 20
func2(100, 200, 300) # a: 100 b: 300 c: 200
def func3(a=10, c=30, b=20):
print('a:', a, 'b:', b, 'c:', c)
func3(a=100, b=200) # a: 100 b: 200 c: 30
func3(100, b=200) # a: 100 b: 200 c: 30
3.不定长参数
参数的个数不确定的时候，可以在形参的前面加*，将这个形参变成一个元组，用来接收多个参数
*参数名: 将位置参数作为元组的元素，参数就是一个元组
**参数名: 将关键字参数，参数名为key,实参为值组合成键值对，作为字典的元素；参数是一个字典
注意：如果函数有多个参数，那么不定长参数要放在最后
经常将*args和**kwargs组合在一起使用，但是使用的时候*args要放在**kwargs的前面！
def func4(*args):
print(args)
func4(23, 89, 90) # (23, 89, 90)
def func5(**kwargs):
print(kwargs)
func5(a=12, b=89, c=100, d=34) # {'a': 12, 'b': 89, 'c': 100, 'd': 34}
def func6(*args, **kwargs):
print(args, kwargs)
func6(12, 90) # (12, 90) {}
func6(a=10, b=20, c=30) # () {'a': 10, 'b': 20, 'c': 30}
func6(12, 20, a=10, b=20, c=30) # (12, 20) {'a': 10, 'b': 20, 'c': 30}
练习：写一个函数，计算多个数的和
def sum_nums(*nums):
print(nums,sum(nums))
sum_nums(1) # (1,) 1
sum_nums(1, 2) # (1, 2) 3
sum_nums(1, 2, 3) # (1, 2, 3) 6
sum_nums() # () 0
def func4(name, age, *scores):
print(scores,name,age)
func4('小花', 18) # () 小花 18
func4('小明', 20, 90, 88, 89, 95) # (90, 88, 89, 95) 小明 20
八、函数的返回值
函数的返回值就是函数调用表达式的值，就是return关键字后面的表达式的值。
python中所有的函数都有返回值，返回值默认是None
执行函数体没有遇到return，函数的返回值就是None
遇到了return，函数的返回值是return后面的值
- 函数调用表达式 --> 调用函数的语句（函数名(实参)）
return --> 关键字，只能写在函数体中，用来返回返回值和结束函数
注意：看一个函数的返回值，只看有没有遇到return，只要没有遇到就是None，遇到return就是return后面的值
调用函数的目的：a.执行函数体 b.获取返回值
- 情况一：没有遇到return
def func1():
print('hello python!')
# 将返回值赋给一个变量
re = func1()
print(re)
# hello python!
# None
# 直接打印返回值
print(func1())
# hello python!
# None
# 将返回值作为列表的元素
list1 = [func1(), 1]
print(list1)
# hello python!
# [None, 1]
- 情况二：有return
执行函数的时候，一旦遇到return，函数就直接结束。并且把return后面的结果作为返回值
def func2():
print('========')
print('!!!!!!!!!')
return 100
print('********')
func2()
# ========
# !!!!!!!!!
re = func2()
print(re)
# ========
# !!!!!!!!!
# 100
注意：并不是只要函数中有return，函数的返回值就是return后面的值
def func3(n):
if n % 2:
return '是奇数'
print(func3(4)) # None
print(func3(3)) # 是奇数
如果实现函数的功能会产生新的数据，就将新的数据返回。
如果不会产生新的数据，就不用返回值
练习：写一个函数，功能是计算一个数的阶乘
def jie_cheng(num):
sum1 = 1
for x in range(1, num+1):
sum1 *= x
return sum1
re = jie_cheng(10)
print(re) # 3628800
list1 = [re, re, 1]
print(list1) # [3628800, 3628800, 1]