目录
1.4可变参数：*args → 接收不定长的位置参数，返回元组
1.5可变参数：**kwargs → 接收不定长的关键字参数，返回字典
应用 —— 学员管理系统
def home():
print('------请选择功能------')
print('1. 添加学员')
print('2. 删除学员')
print('3. 修改学员')
print('4. 查询学员')
print('5. 显示所有学员')
print('6. 退出系统')
print('-' * 17)
# 定义空列表，每组信息存入一个字典放入列表中 —— [{}, {}, {}...]
info = []
def add_info():
"""添加学员信息"""
new_id = input('请输入学号：')
new_name = input('请输入姓名：')
new_gender = input('请输入性别：')
# 声明info为全局变量
global info
for i in info:
if new_id == i['id']:
print('用户已存在')
return
# 定义空字典
info_dict = {}
info_dict['id'] = new_id
info_dict['name'] = new_name
info_dict['gender'] = new_gender
info.append(info_dict)
print(info)
def delete_info():
"""删除学员信息"""
delete_id = input('请输入要删除的学员学号：')
global info
for i in info:
if delete_id == i['id']:
info.remove(i) # 将i整个删除
break
else:
print('用户不存在')
print(info)
def modify_info():
"""修改学员信息"""
modify_id = input('请输入要修改的学员学号：')
global info
for i in info:
if modify_id == i['id']:
mess = input('输入要更改的信息：')
i[mess] = input('改成：')
break
else:
print('用户不存在')
print(info)
def search_info():
"""查找学员信息"""
search_id = input('请输入要查找的学员学号：')
global info
for i in info:
if search_id == i['id']:
print('信息如下：')
print(f"学号为{i['id']}，姓名为{i['name']}，性别为{i['gender']}")
else:
print('用户不存在')
def all_info():
"""显示所有学员信息"""
print('学号\t姓名\t性别')
for i in info:
print(f'{i["id"]}\t\t{i["name"]}\t\t{i["gender"]}')
while True:
home()
num = int(input('请输入功能序号： '))
if num == 1:
add_info()
elif num == 2:
delete_info()
elif num == 3:
modify_info()
elif num == 4:
search_info()
elif num == 5:
all_info()
elif num == 6:
flag = input('确定退出系统？[y/n]：')
if flag == 'y':
break
elif flag == 'n':
continue
else:
print('请输入正确指令！！！！')
else:
print('输入有误\n')
一、递归
函数内部自己调用自己
# 3+2+1
def sum(num):
if num == 1:
return 1 # 返回到上次函数调用处，即上一轮num + 1，然后return
return num + sum(num-1)
print(sum(3))二、lambda表达式（匿名函数）
如果一个函数只有一个返回值，只有一句代码，可用lambda简化。
语法
lambda 参数列表：表达式 //表达式必须有返回值
- 参数可有可无
- 能接收任何数量的参数，但只能返回一个表达式的值
# 函数
def f1():
return 100
print(f1) # 内存地址
print(f1()) # 100
# lambda————匿名函数
f2 = lambda: 200
print(f2) # 内存地址
print(f2()) # 200# 计算a+b
# 函数
def add(a, b):
return a + b
print(add(1, 2))
# lambda
add1 = lambda a, b:a + b
print(add1(1, 2))1.lambda的参数形式
1.1无参数
lambda：表达式
# 无参数
f1 = lambda: 100
print(f1()) # 1001.2一个参数
lambda 参数：表达式
# 一个参数
f2 = lambda a: a
print(f2('hi')) # hi1.3默认参数
lambda key = value：表达式
# 默认参数
f3 = lambda a, b, c=10: a+b+c
print(f3(20, 30)) # 601.4可变参数：*args → 接收不定长的位置参数，返回元组
lambda *args：表达式
#可变参数 args
f4 = lambda *args: args
print(f4(10)) # (10,)
print(f4(10, 20, 30)) # (10, 20, 30)1.5可变参数：**kwargs → 接收不定长的关键字参数，返回字典
lambda **kwargs：表达式
# **kwargs
f5 = lambda **kwargs: kwargs
print(f5(name = 'Tom')) # {'name': 'Tom'}
print(f5(name = 'Tom', gender = 'MAN')) # {'name': 'Tom', 'gender': 'MAN'}应用
1.带判断的lambda
# 判断
f = lambda a,b: a if a > b else b
print(f(100, 1000)) # 10002.sort函数
# 列表数据排序
students = [{'name': 'Tom', 'age': 19}, {'name': 'Lucy', 'age': 20}, {'name': 'Jack', 'age': 18}]
# 按name升序排序
students.sort(key = lambda x: x['name'])
print(students) # [{'name': 'Jack', 'age': 18}, {'name': 'Lucy', 'age': 20}, {'name': 'Tom', 'age': 19}]
# 按name降序排序
students.sort(key = lambda x: x['name'], reverse = True)
print(students) # [{'name': 'Tom', 'age': 19}, {'name': 'Lucy', 'age': 20}, {'name': 'Jack', 'age': 18}]
# 按age升序排序
students.sort(key = lambda x: x['age'])
print(students) # [{'name': 'Jack', 'age': 18}, {'name': 'Tom', 'age': 19}, {'name': 'Lucy', 'age': 20}]
# 按name降序排序
students.sort(key = lambda x: x['age'], reverse = True)
print(students) # [{'name': 'Lucy', 'age': 20}, {'name': 'Tom', 'age': 19}, {'name': 'Jack', 'age': 18}]三、高阶函数
把一个函数作为另一个函数的参数传入的函数。
函数式编程的体现。
1.求绝对值计算 —— abs()
# abs()
print(abs(-10)) # 102.四舍五入计算 —— round()
#round()
print(round(1.2)) # 1
print(round(2.7)) # 3应用
#将所有数字取绝对值之后计算
- 法一
def add(a, b):
return abs(a) + abs(b)
print(add(-10, 30)) # 40- 法二
def add(a, b, f):
return f(a) + f(b)
print(add(-10, 30, abs)) # 403.内置高阶函数
3.1map()
map(func, lst)
将传入的func函数的操作作用到lst变量的每个元素中。
# 计算list1中所有数字的平方
list1 = [1, 2, 3, 4, 5]
def func(x):
return x ** 2
print(list(map(func,list1))) # [1, 4, 9, 16, 25]3.2reduce()
reduce(func, lst)
func必有两个参数，每次func计算的结果继续和序列下一个元素做累积计算。
func函数必须有两个参数。
# 计算list中数字的累加和
# 导入模块
import functools # 类似于头文件??
list1 = [1, 2, 3, 4, 5]
def func(a, b):
return a + b
result = functools.reduce(func, list1)
print(result) # 153.3filter()
filter(func, lst)
用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。若要转化为列表，用list()来转换。
# 找出偶数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def func(a):
return a % 2 == 0
print(list(filter(func, list1))) # [2, 4, 6, 8]