Python基础（四）

• 函数
• 函数参数
• 其他知识
• • 拆包
  • 交换俩个变量的值
  • 引用
  • 可变与不可变
• 函数加强篇
• • 递归
  • Lambda表达式
  • • 参数形式
    • 应用
  • 高阶函数
• 学员管理系统

函数就是将⼀段具有独⽴功能的代码块，整合到⼀个整体并命名，在需要的位置调⽤这个名称即可完成对应的需求。函数在开发过程中，可以更⾼效的实现代码重⽤。

def 函数名(参数):
代码1
代码2

函数名（参数）：调用函数

需求1：制作计算器，计算任意俩个数字之和，并且保存结果

def sum_num(a,b):
  return a+b

result = sum_num(1, 2)
print(result)

(1)说明文档：如果代码多，我们不需要在很多代码中找到这个函数定义的位置才能看到注释。如果想更⽅便的查看函数的作⽤，可以借助函数的说明文档。

（2）函数嵌套使用：一个函数里面又嵌套了另外一个函数。

如果函数A中，调⽤了另外⼀个函数B，那么先把函数B中的任务都执⾏完毕之后才会回到上次函数A执⾏的位置。

需求2:打印多条横线

def print_line():
    print('-'*20)

def print_lines():
    i=0
    while i<=10:
        print_line()
        i+=1

print_lines()

（3）变量作用域：局部变量和全局变量
作用：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量。

误区：

不是。因为第十五行得到a的数据仍然是100，仍然是定义全局变量a的时候的值，而没有返回值，而没有返回testB函数内部的200。综上，testB的内部a=200只是定义了一个局部变量。

如何在函数体内部修改全局变量：

（4）return：return a, b返回多个数据的时候，默认是元组类型。return后⾯可以连接列表、元组或字典，以返回多个值。

（5）多函数执行流程：

1. 位置参数：调用函数时根据函数定义的参数位置来传参。传递和定义参数的顺序要保持一致。
   
2. 关键字参数
   函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求。

def user_info(name, age, gender):
  print(f'您的名字是{name},年龄是{age},性别是{gender}')
  user_info('Rose', age=20, gender='⼥')
  user_info('⼩明',gender='男',age=16)

note：函数调⽤时，如果有位置参数时，位置参数必须在关键字参数的前⾯，但关键字参数之间不存在先后顺序。

3. 缺省参数
   缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）。
   函数调⽤时，如果为缺省参数传值则修改默认参数值；否则使⽤这个默认值。
4. 不定长参数：可变参数（用于不确定调用的时候传递多少个参数。此时，可以用包裹packing位置参数或者包裹关键字参数来进行参数传递）
   （1）包裹位置传递：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递。
   （2）包裹关键字传递

name指的是变量名，不加引号。

综上，无论是包裹位置传递或者包裹关键字传递，都是一个组包过程。

#拆包元组
def return_num():
  return 100, 200
  num1, num2 = return_num()
print(num1)# 100
print(num2)# 200

#拆包字典
dict1 = {'name':'TOM', 'age':18}
a, b = dict1#对字典进⾏拆包，取出来的是字典的key
print(a)# name
print(b)# age
print(dict1[a])# TOM
print(dict1[b])# 18

c=a
a=b
b=c

a,b=1,2
a,b=b,a
print(a)
print(b)

在python中，值都是靠引用传递的。（数据通过变量传递）我们可以⽤id()来判断两个变量是否为同⼀个值的引⽤。我们可以将id值理解为那块内存的地址标识。

# 1.不可变： int类型
a = 1
b = a
print(b)# 1
print(id(a))# 140708464157520
print(id(b))# 140708464157520
a = 2# 因为修改a的数据，内存需要再开辟另外一空间存储
print(b)# 1,说明int类型为不可变类型
print(id(a))# 140708464157552，此时得到是的数2的内存地址
print(id(b))# 140708464157520


# 2.列表
aa = [10, 20]
bb = aa
print(id(aa))# 2325297783432
print(id(bb))# 2325297783432
aa.append(30)
print(bb)# [10, 20, 30],列表为可变类型
print(id(aa))# 2325297783432
print(id(bb))# 2325297783432

引用当作实参：

def test1(a):
  print(a)
  print(id(a))
  a += a
  print(a)
  print(id(a))

# int：计算前后id值不同
b = 100
test1(b)

#列表：计算前后id值相同
c = [11, 22]
test1(c)

数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变类型

特点：函数内部自己调用自己+必须有出口

# 3+2+1
def sum(i):
  if i==1
    return 1
  return i+sum(i-1)

应用场景：一个函数有一个返回值，并且只有一句代码，可以用Lambda简化

lambda 参数列表：表达式

（1）使用Lanbda表达式相比函数，可以简化代码所占的内存
（2）Lambda的参数可有可⽆，函数的参数lambda在表达式中完全适⽤。
（3）lambda函数能接收任何数量的参数但只能返回⼀个表达式的值

fn2=lambda:100
print(fn2)#直接打印Lambda表达式，输出的是内存地址（匿名函数）
print(fn2())#无参调用

fn3=lambda a,b:a+b
print(fn3(1,2))
print((lambda a,b:a+b)(1,2))

# 无参
print((lambda:100)())
# 一个参数
print((lambda a:a)('hello'))
# 默认参数
print((lambda a,b,c=100:a+b+c)(10,20))
# 可变参数:接受不定长位置参数，返回元组
print((lambda *args:args)(10,20,30))
#接受不定长的关键字参数，返回字典
print((lambda**kwargs: kwargs)(name='python', age=20))

# 判断
fun=lambda a.b:a if a>b  else b
print(100,22)

#列表数据按照字典的key值进行排序
students = [{'name':'TOM', 'age':20},'name':'ROSE','age':19},{'name':'Jack','age':22}

#按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)
#按name值降序排列
students.sort(key=lambdax: x['name'],reverse=True)
print(students)

把函数作为另外一个函数的参数传入的编程模式称为高阶函数，高阶函数是函数式编程的体现，是一种高度抽象的编程形式。

# 求绝对值
abs(-10) # 10

def add_num(a, b):
   return abs(a) +abs(b)
result = add_num(-1, 2)
print(result)# 3

def sum_num(a, b, f):
  return f(a) + f(b)
result = sum_num(-1, 2, abs)
print(result)# 用f代替abs

函数式编程⼤量使⽤函数，减少了代码的重复，因此程序⽐较短，开发速度较快。

需求：
进⼊系统显示系统功能界⾯，功能如下：
（1）添加学员
（2）删除学员
（3）修改学员信息
（4）查询学员信息
（5）显示所有学员信息
（6）退出系统
系统共6个功能，⽤户根据⾃⼰需求选取。

步骤：
1.显示功能界⾯
2.⽤户输⼊功能序号
3.根据⽤户输⼊的功能序号，执⾏不同的功能(函数)

#功能函数的作用都是操作学员，每个学员的信息用字典存储，
# 存储全部学员信息应该是全局变量列表
info=[]

# 显示功能函数
def print_info():
  print('-'*20)
  print('欢迎登录学员管理系统')
  print('1:添加学员')
  print('2:删除学员')
  print('3:修改学员信息')
  print('4:查询学员信息')
  print('5:显示所有学员信息')
  print('6:退出系统')
  print('-'*20)

#添加学员信息
def add_info():
    new_id=input("请输入学号")
    new_name=input("请输入姓名")
    new_tel=input("请输入手机号")
    global info#声明全局变量
    for i in info:
        if new_name==i['name']:
            print("该用户已经存在")
            return
    info_dict={}
    info_dict["id"]=new_id
    info_dict["name"]=new_name
    info_dict["tel"]=new_tel
    info.append(info_dict)
    print(info)

# 删除学员信息
def del_info():
  """删除学员"""
  while True:
     del_id = int(input('请输⼊要删除的学员学号：'))
     global info
#检查学员是否存在
#如果存在则删除列表指定下标的数据
     if 0<= del_idinfo[modify_num]["id"]},姓名是{info[modify_num]["name"]},⼿机号是{info[modify_num]["tel"]}')
          info[modify_num]["id"] = input('请输⼊学号:')
          info[modify_num]["name"] = input('请输⼊姓名:')
          info[modify_num]["tel"] = input('请输⼊⼿机号:')
          print(info)
          break
  else:
    print('输⼊学员有误')

def search_info():
  """查询学员信息"""
  search_name = input('请输⼊要查找的学员姓名：')
  for i in info:
      if search_name == i['name']:
          print('***查询到信息如下***')
          print(f'该学员学号是{i["id"]},姓名是{i["name"]},⼿机号是{i["tel"]}')
          break
  else:print('查⽆此⼈......')
# 用户输入功能

while True:
    print_info()
    user_num=int((input("请输入功能序号")))
    if user_num == 1:
       add_info()
    elif user_num == 2:
       del_info()
    elif user_num == 3:
        modify_info()
    elif user_num == 4:
        search_info()
    elif user_num == 5:
        print('学号t姓名t⼿机号')
        for i in info:
          print(f'{i["id"]}t{i["name"]}t{i["tel"]}')
    elif user_num == 6:
        exit_flag = input('确定要退出吗？yes or no')
        if exit_flag == 'yes':
            break
    else:
        print("输入的功能有误")