XX学Python·函数

函数的定义和调用

 '''
# 函数定义的格式
def 函数名(参数1，参数2...):
    函数体
    return 返回值
 
# 函数调用格式
函数名(参数1，参数2...)
 
# 函数名：绝大多数函数都有函数名，没有函数名的函数不能被复用
# 参数：为了让函数灵活性更高，会动态对函数进行传值
# 函数体：写在函数内部特定功能的代码，调用函数时可全部执行
# 返回值：写在return后，将函数内计算或运行的结果传递到函数体外部
'''
 
# 定义函数时可以不传参，调用时也不传参
def sing():
    print('我在唱歌')
def dance():
    print('你在跳舞')
sing()
dance()
'''执行顺序：先将所有函数的函数名执行一遍储存在缓存中的方法列表中，
后续调用函数时去方法列表中查询，如果函数名存在，则调用函数内部的代码，
如果函数名不存在就报错。所以函数必须先定义后调用。
'''
 
# 函数的参数
# 在定义时传入的参数叫做形参，只能在函数体内部使用
def do_sth(who, sth):
    print(f'{who}在{sth}')
# 在调用时传入的参数叫实参，会传入到函数内部被形参接收，传值时保证数量一致。
do_sth('我', '唱歌')
do_sth('小明', '洗碗')

函数的返回值

函数可以不写返回值或者只写一个return不写返回值内容,都会默认返回一个None
return后将会立即跳出函数，如果在retrun后仍有代码,则不会被执行
return只能返回一个元素，如果想返回多个元素需要使用容器类型

 # 如果想将数据传递出来可以使用return
def sum1(a, b):
    return a + b
 
 
print(sum1(1, 3))  # 当函数执行完毕,函数调用位置就替换为函数的返回值
# 返回的数据可以参与计算
print(sum1(1, 3) + 12)
# 注:返回值内容不会自动打印到控制台,将数据返回后想要查看数据需手动打印或debug调试
 
# 如果没有书写返回值,则返回值为None
list1 = [1, 2]
# 因为此处,append方法,没有返回值,默认返回None
print(list1.append(3))  # None
 
def eat():
    print('猫吃鱼,狗吃肉,奥特曼吃小怪兽')
print(eat())  # None
 
 
# 如果只写了return 没有写返回值内容会怎么样?  None
def sum1(a, b):
    print(a + b)
    return
 
print(sum1(1, 2))  # None
 
# return执行后会跳出函数,return之后的所有代码将不会继续执行
# 当函数执行结束后，就会回到函数调用的地方继续向下执行
# 在函数中可以有多个return 但是只能执行一个
def function():
    print('hello python')
    return
    return
    # 同一分支中,在return之后的所有代码不会被执行
    print('hello bigdata')
 
 
function()
 
 
# 返回值只能是一个元素,如果要返回多个值只能通过容器类型进行打包
# 默认是元组类型。return后面可以连接列表、元组或字典，以返回多个值。
def function1():
    return 1, 2, 3, 4
print(function1())  # (1, 2, 3, 4)

函数的说明文档

 # def compute(num1, num2, symbol):
#     '''用于计算两个数的和差积商'''
#     if symbol == '+':
#         return num1 + num2
#     elif symbol == '-':
#         return num1 - num2
#     elif symbol == '*':
#         return num1 * num2
#     elif symbol == '/':
#         return num1 / num2
#     else:
#         print('输入有误')
 
# 在函数体的第一行，输入三对双引号，在中间敲击回车，自动提示提示注明参数和返回值含义
def compute(num1, num2, symbol):
    """
    用于计算
    :param num1:第一个参与计算的数字
    :param num2:第二个参与运算的数字
    :param symbol:计算的符合（+ - * /）
    :return:计算的结果
    """
    if symbol == '+':
        return num1 + num2
    elif symbol == '-':
        return num1 - num2
    elif symbol == '*':
        return num1 * num2
    elif symbol == '/':
        return num1 / num2
    else:
        print('输入有误')
 
 
print(compute(1, 2, '/'))  # 鼠标放这里就能看见说明文档提示内容
# 使用help（）方法可以查阅函数的说明文档

函数的嵌套

 def sum_3(num1, num2, num3):
    """求三个数的和"""
    return num1 + num2 + num3
 
 
def ave_3(num1, num2, num3):
    """求三个数的平均值"""
    return sum_3(num1, num2, num3) / 3
 
 
print(ave_3(1, 2, 3))  # 2.0

变量的作用域

局部变量和全局变量
- 局部变量就是在函数体内部进行定义，函数体外部无法调用的变量
- 全局变量就是在函数体外部，一般在文件顶格处书写，函数体内外都可使用的变量
- Python中if 、while、for结构中的控制语句中定义的变量都是全局变量
global 作用是声明我要使用的这个变量是全局变量

 a = 100
# def func1():
#     a = 1  # 这里a是在函数体内的一个局部变量，并没有修改全局变量的值
def func1():
    global a  # 要在函数体内修改全局变量就要使用global
    a = 1
 
 
func1()
print(a)  # 1
 
# 在python中所有的变量查询遵循LEDB原则
'''
L: local局部作用域的local命名空间  1、首先在函数体内部查询
E: edge(enclosing)嵌套函数外层函数的命名空间  2、在外层函数中查询
G: global全局作用域  3、在全局变量中查询
B: build-in内置模块的命名空间  4、在系统内置变量中查询
'''
def out_func():
    a = 2
    def in_func():
        print(a)
    in_func()
out_func()  # 2
 
# 可以在函数体内创建全局变量，只要用global修饰就行
def func2():
    global b
    b = 99
func2()
print(b)  # 99

函数的参数

位置参数：根据函数定义的参数位置来传递参数，参数的顺序及个数必须一致
关键字参数：通过“键=值”形式，函数调用时，如有位置参数，位置参数必须在关键字参数前面，但关键字参数之间不存在先后顺序。
缺省参数：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用默认值。
位置不定长参数，被args接收打包为一个元组，是规定，args可以是其他名称替代，但习惯用args。格式：def 函数名(args):
关键字不定长参数，被kwargs接收打包为一个字典。格式：def 函数名(**kwargs):
形参和实参的排列顺序
- 形参：位置参数>>位置不定长参数>>缺省参数>>关键字不定长参数
  - 整体顺序：位置参数>>缺省参数>>不定长参数
- 实参：顺序赋值>>关键字参数赋值。
  - 传递实参的传递顺序：位置参数>>缺省参>>不定长参数
- 一般参数种类不超过3种，参数个数不超过5个

 # 关键字参数可以不按顺序，但必须在位置参数后面
def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
 
 
user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)
 
 
# 缺省参数，一般使用关键字参数给缺省参数赋值
def user2_info(name, age, gender='男'):  # 默认缺省参数gender='男'
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
 
 
user2_info('TOM', 20)  # 您的名字是TOM, 年龄是20, 性别是男
user2_info('Rose', 18, '女')
 
# 位置不定长参数
def func1(*args):
    print(*args)  # 相当于print(1,2,3),因为1,2,3传值给了*args
 
 
func1(1, 2, 3)  # 1 2 3，所以也就是*args=1，2，3
 
 
def user_info(*args):
    print(args)
    print(*args)  # TOM  下次运行TOM 18
 
 
user_info('TOM')  # ('TOM',)数据传入函数内部时进行打包，转换为一个元组被args接受
user_info('TOM', 18)  # ('TOM', 18)
 
 
def max1(*args):  # 案例：输入不确定数量多个数，判断其中最大值
    max_mun = args[0]  # args是元组类型
    for i in args:
        if i > max_mun:
            max_mun = i
    return max_mun
 
 
print(max1(1, 2, 5))  # 5
print(max(-3, -1, -10))  # -1
 
# 关键字不定长参数
# def func(**kwargs):
#     print(**kwargs)  # 相当于print(a=1, b=2)，给print输入多个关键字参数会报错
#
#
# func(a=1, b=2)  # a=1, b=2传给了**kwargs
def func(**kwargs):
    print(1, 2, **kwargs)  # 相当于print(1, 2, sep='$', end='a')
 
 
func(sep='$', end='a')  # 1$2a，把sep='$', end='a'传给了**kwargs
 
 
def func2(**kwargs):
    print(kwargs)  # 传参后，实参处所有未定义关键字参数转换为字典键值对，保存在kwargs中
 
 
func2(a=1, b=2)  # {'a': 1, 'b': 2}
 
 
def stu_info(**kwargs):  # 案例，创建一个函数保存学员信息
    print(f'学员信息为：{kwargs}')
 
 
stu_info(name='xx', age=18)  # 学员信息为：{'name': 'xx', 'age': 18}

不定长参数的使用

 def print_numbers(*args):
    print(args)  # ([1, 2, 3, 4],)
    print(*args)  # [1, 2, 3, 4]
 
 
l1 = [1, 2, 3, 4]
print_numbers(l1) # 将l1作为1个整体传入，函数接受的其实只有一个参数，且类型为list
 
 
def print_numbers(*args):
    print(args)  # (1, 2, 3, 4)
    print(*args)  # 1 2 3 4
 
 
l1 = [1, 2, 3, 4]
print_numbers(*l1)  # *l1等价于print_numbers(1, 2, 3, 4)

组包和拆包

 # 组包
a = 1,2,3,4
print(a)  # (1, 2, 3, 4)将多个数据打包为一个容器(元组)
 
 
def func1():
    return 1,2,3  # 返回多个数据默认打包为一个元组
 
 
print(func1())  # (1, 2, 3)
 
# 拆包（解包）
x, y, z = (1, 2, 3)  # 元组、列表一样
print(x, y, z)  # 1 2 3
 
list1 = ['xx', 'lsl']
for index, value in enumerate(list1):
    print(index, value)  # 0 xx 下一行 1 lsl
 
dict1 = {'name': 'xx', 'age': 18}
for key, value in dict1.items():
    print(key, value, end='$$')  # name xx$$age 18$$
 
dict2 = {'a': 1, 'b': 2}
char1, char2 = dict2  # 字典拆包得到的是字典的键
print(char1, char2)  # a b
 
set1 = {'xx', 'lsl', 'wzl'}
a, b, c = set1  # 可对集合拆包，但一般不会这样做，因为赋值顺序无法指定
print(a, b, c)  # wzl xx lsl顺序不一定
 
# 同时应用组包和拆包的案例
# 互换过程：先将a、b的值提取出来组包为一个元组；再进行拆包，将元组内的数据分别赋值给a，b两变量
a = 1
b = 2
a, b = b, a
print(a, b)  # 2 1

引用

数据的三个维度：值，数据类型，唯一标识
- 值：数据计算时使用的值
- 数据类型：数据的存储类型
- 唯一标识：id引用地址，也就是数据的内存地址的标识
如果我们想要判断id或者说唯一标识是否相等，我们使用is进行判断

 # 值相等的数据,唯一标识和数据类型不一定相等
bool1 = False
int1 = 0
print(bool1 == int1)  # True,0和False的值相等
print(type(bool1) == type(int1))  # False,数据类型不等
print(id(bool1) == id(int1))  # False,唯一标识不等
 
# 值和数据类型相等的,唯一标识不一定相等，
list1 = [1, 2, 3]
list2 = [1, 2, 3]  
print(list1 == list2)  # True,值相等
print(type(list1) == type(list2))  # True,数据类型相等
print(id(list1) == id(list2))  # False,id不等,也就是其所在的内存空间不一致
# 可变容器类型id地址不同
d1 = {'a':1,'b':2,'c':3}
d2 = {'a':1,'b':2,'c':3}
print(id(d1))  # 1864418858872
print(id(d2))  # 1864418858952 两个id不同
 
# id地址相等的, 值和数据类型必然相等
# 在同一内存空间中只能储存同一个值
str1 = 'abc'
str2 = 'abc'
print(id(str1) == id(str2))  # True
print(type(str1) == type(str2))  # True
print(str1 == str2)  # True
# 不可变类型id地址相同
tuple1 = (1,2,3)
tuple2 = (1,2,3)
print(id(tuple1))  # 1864423129960
print(id(tuple2))  # 1864423129960
 
# 使用is可以判断是否为同一个内存空间中的数据
print(list1 is list2)  # False
print(str1 is str2)  # True
#

可变类型和不可变类型
- 可变类型：内存空间中的数据可以被修改的数据类型
  - list set dict
- 不可变数据类型：内存空间中的数据不可被修改的数据类型
  - int float bool str tuple

 # 传参或者变量的传递是进行了值的传递，还是进行了引用地址的传递呢?
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
#id的值,我们称呼他为引用地址,list1和list2 的引用地址不同
print(id(list1))  # 140652966394496
print(id(list2))  # 140652968507776
 
list1.append(5)
print(list1)
print(list2)
# 在list1中添加了数据,那list1的引用地址会发生变化么?不会变化
# list1,在使用append方法时,是将内存空间中的值进行了变化,没有修改内存地址,所以id不变
print(id(list1))  # 140652966394496
 
# 如果我们使用list1 = list2,list1的引用地址发生变化了么? 变化
list1 = list2
# 此时,list1和list2指向同一块内存空间
print(id(list1))  # 140652968507776
# 如果在list1中删除下标为1的元素,list2会发生变化么? 会变化
# list1和list2指向同一块内存空间,所以内存空间中数据发生了改变,list1和list2均变化
list1.pop(1)
print(list1)  # [1, 3, 4]
print(list2)  # [1, 3, 4]
# list 内存空间中的数据可以发生改变,这种数据类型我们称之为可变数据类型
 
# 练习:
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
list1 = [1, 2, 3, 4, 5]
list2 = list1
list1.pop(2)
list1 + list2
# list1 和list2  分别是多少
print(list1)
print(list2)
 
# 练习:
str1 = '12345'
str2 = '12345'
str1 = str2
str1 = '123'
str2 + str1
print(str1)
print(str2)
 
str1 = '123'
str2 = '123'
print(id(str1))  # 140509725727984
print(id(str2))  # 140509725727984
 
# 可以修改str内部的元素么?  不可以
# TypeError: 'str' object does not support item assignment
# str1[0] = '2'
# 既然内部元素不可修改,系统定义其值相同时,数据引用地址也相同
# 这种内存空间中的数据无法被修改的值为不可变数据类型
 
# 结论:在数据的传递过程中,是引用传递,不是值的传递

引用当作参数传递
- 在函数传参过程中，变量会以引用的形式进行传参，也就是变量或参数传递是引用传递，不是值传递
  - 如果参数是可变数据类型，那么在函数内修改其引用地址指向空间内的数据，外部数据同时发生变化
  - 如果参数是不可变数据类型，其实也是引用传递，只不过引用地址指向的数据空间中的数据无法被修改

 # a = 1  # 将数字1所在空间的id(引用地址)赋值给了a
# b = a  # 将a所保存的引用地址给了b
 
def func(num_list):
    print(id(num_list))  # 140490414045760
    num_list.append(2)
    return num_list
 
# 参数传递时,是地址传递,将list1的id传递给了num_list
# num_list修改内存空间中的数据时,list1,也会发生变化
list1 = [1, 2, 3, 4]
# print(id(list1))  # 140490414045760
# print(func(list1))
# print(list1)
 
def func2(num_list):
    print(id(num_list))  # 140326362233472
    # 无论什么情况下,使用=赋值运算,就是将等号右侧数据的引用地址,赋值给等号左侧的变量
    num_list = [1, 2, 3, 4, 5]
    print(id(num_list))  # 140466340833664
    return num_list
 
print(id(list1))  # 140326362233472
print(func2(list1))  # [1, 2, 3, 4, 5]
print(list1)  # [1, 2, 3, 4]
 
# 不可变数据类型
def func1(char1):
    print(id(char1))  # 140228523715632
    # 不可变数据类型,参数传递时也是引用传递,但无法修改原有数据空间内的数据,
    # 如果想要修改只能改变引用地址,重新赋值(只有=才有改变引用的功能)
    char1.replace('a', 'b')
    return char1
 
 
str1 = 'abc'
print(id(str1))  # 140228523715632
print(func1(str1))  # abc
print(str1)  # abc

学生管理系统

 # 需求拆分:
'''
1.展示学生管理系统的功能有哪些,引导用户键入序号选择功能
2.获取用户键入的功能
3.分析具体要执行哪一项功能
4.执行功能
'''
 
 
def print_all_option():
    """用户功能界面展示"""
    print('-' * 20)
    print('欢迎登录学员管理系统')
    print('1: 添加学员信息')
    print('2: 删除学员信息')
    print('3: 修改学员信息')
    print('4: 查询学员信息')
    print('5: 遍历输出所有学员信息')
    print('6: 退出系统')
    print('-' * 20)
 
 
def choose_option(num):
    """分析要执行哪一项功能"""
    if num == '1':
        # 添加学员函数
        add_student_info()
    elif num == '2':
        # 删除学员函数
        delete_student_info()
    elif num == '3':
        # 修改学员函数
        modify_student_info()
    elif num == '4':
        # 查询学员函数
        search_student_info()
    elif num == '5':
        # 展示所有学员函数
        show_students_info()
    elif num == '6':
        # 退出程序函数
        exit_program()
    else:
        print('无此选项,请重新输入')
 
 
def add_student_info():
    stu_id = input('请输入要添加学员的id:')
    students_id = [i['id'] for i in students_list]
    if stu_id in students_id:
        print('该id值已经存在,无法添加学员')
    else:
        name = input('请输入要添加学员的姓名:')
        age = int(input('请输入要添加学员的年龄:'))
        mobile = input('请输入要添加学员的手机号:')
        students_list.append({'id': stu_id, 'name': name, 'age': age, 'mobile': mobile})
        print('学员添加完成')
 
 
def delete_student_info():
    stu_id = input('请输入要删除学员的id:')
    for stu_info in students_list:
        if stu_info['id'] == stu_id:
            students_list.remove(stu_info)
            print('该学员已删除')
            return
    else:
        print('该学员不存在,无法删除')
 
 
def modify_student_info():
    stu_id = input('请输入要修改学员的id:')
    for dict_stu in students_list:
        if stu_id == dict_stu['id']:
            name = input('请输入您要修改为的名字:')
            age = int(input('请输入您要修改为的年龄:'))
            mobile = input('请输入您要修改为的手机号:')
            dict_stu['name'] = name
            dict_stu['age'] = age
            dict_stu['mobile'] = mobile
            print('学员信息修改完成')
            break
    else:
        print('该学员不存在,修改失败')
 
 
def search_student_info():
    stu_id = input('请输入要查询学员的id:')
    for dict_stu in students_list:
        if stu_id == dict_stu['id']:
            print(dict_stu)
            break
    else:
        print('该学员不存在,查询失败')
 
 
def show_students_info():
    for dict_stu in students_list:
        print(dict_stu)
 
 
def exit_program():
    global is_stop
    is_stop = True
 
 
students_list = [{'id': '001', 'name': 'xx', 'age': 18, 'mobile': '18181818188'},
                 {'id': '002', 'name': 'lsl', 'age': 17, 'mobile': '18181818168'},
                 {'id': '003', 'name': 'rose', 'age': 22, 'mobile': '18181818168'}]
 
is_stop = False
while not is_stop:
    print_all_option()
    user_num = input('请输入您要执行的功能序号：')
    choose_option(user_num)

函数递归(recursion)

函数内部调用函数本身
函数有明确的递归跳出条件
不超出最大调用深度

 # 需求:
'''
func(1) = 1
func(2) = 1 + 2 = func(1) + 2
func(3) = 1 + 2 + 3 = func(2) + 3
func(4) = 1 + 2 + 3 + 4 = func(3) + 4
.....
func(n) = 1 + 2 + 3 .... + n = func(n-1) + n
'''
 
# RecursionError: maximum recursion depth exceeded
# 这种方式无法跳出递归,所以在使用的时候就会无限递归下去
# def func(n):
#     return func(n-1) + n
 
'''
func(1) = 1
func(2) = func(1) + 2
func(3) = func(2) + 3
func(4) = func(3) + 4
.....
func(n) = func(n-1) + n
'''
 
def func(n):
    if n == 1:
        return 1
    return func(n-1) + n
 
 
print(func(999))
# Python中默认的最大调用深度是1000,也就是Python中函数最多嵌套1000层
# 最大调用深度是为了保证系统性能的,否则无限递归下去,一会内存就满了
# 最大调用深度可以调整,可以调整到非常大的数字只要系统性能跟得上
# RecursionError: maximum recursion depth exceeded in comparison
 
# 注意事项:
# 在编程初期,尽量少使用递归,但是要理解递归的特性,别人写的递归函数也要能看懂

lambda函数

lambda表达式(匿名函数),在函数定义时没有函数名，格式: lambda 参数: 返回值
可以用变量保存，在变量之后添加括号即可调用
lambda缺点:
- 没办法书写复杂函数,因无函数体,只有返回值,返回值后边只能书写一个表达式
- lambda可读性极差
lambda应用场景：
- 可以用于一次性函数使用
- 可以作为函数的参数进行传递

 # 需求: 根据传入的参数返回最大值  使用lambda函数书写
# 三目运算  :  条件成立时返回的代码 if 条件 else 条件不成立时返回的代码
max_num = lambda a, b: a if a > b else b  # 使用变量可以储存lambda函数
print(max_num(1, 2))  # 2
print(max_num(9, 2))  # 9
print(type(max_num))  # <class 'function'>
 
 
def func():
    print('abc')
 
 
print(type(func))  # <class 'function'>
# 通过对数据类型的查看,发现lambda和普通函数本质上是一样的,只是在使用时构造更简单
 
# 在使用lambda函数时可以不用变量接收
print((lambda a, b: a if a > b else b)(3, 4))  # 4
# 但不用变量接收,lambda函数只能使用一次,使用后集被释放,无法再次使用
 
# 使用lambda完成递归(了解,一般不建议写复杂的代码)
func1 = lambda n: func1(n-1) + n if n != 1 else 1
print(func1(3))  # 6
 
# list sort排序方法中的key所需要的参数就是一个函数,我们可以传入lambda表示
list1 = [{'name': 1, 'age': 18}, {'b': 12}, {'c': 10}]
# 排序规则:根据字典的第一个键所对应的值进行排序
list1.sort(key=lambda x: list(x.values())[0])  # x是list1里每个元素，即字典
print(list1)  # [{'name': 1, 'age': 18}, {'c': 10}, {'b': 12}]
print(list1[0].values())  # dict_values([1, 18])
print(type(list1[0].values()))  # <class 'dict_values'>
 
list2 = [11, 34, 2, 5]
list2.sort(key=lambda x: x % 5)  # 除以5的余数排序，默认升序
print(list2)  # [5, 11, 2, 34]
 
list3 = [[2, 1, 3], [0, 2, 4], [7, 8, 9]]
list3.sort(key=lambda x: x[0])
print(list3)  # [[0, 2, 4], [2, 1, 3], [7, 8, 9]]
 
# 可以使用不定长参数
sum1 = lambda *args: sum(args)
print(sum1(1, 2, 3))  # 6
 
# 格式: lambda 参数: 返回值，参数可以省略
hei = lambda: print('hello world')
hei()  # hello world
 
# lambda里面还有lambda
fn = lambda string: lambda msg: f'{string}: {msg}!'
# 重点：fn返回的依旧是一个lambda表达式lambda msg: f'{string}: {msg}!'
fnh = fn("hello")  # fnh是fn调用后的结果fnh=lambda msg: f'{hello}: {msg}!'
print(fnh("MrSun"))  # hello: MrSun!
 
fnw = fn("welcome to")  # fnw同样是fn调用后的结果
print(fnw("China"))  # welcome to: China!

posted @ 2022-10-04 22:56 PORTB 阅读(35) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· XX学Python·高级语法

· XX学Python·面向对象

· 函数的调用方式、函数的参数、类型提示语、名称空间

· Python基础（六）：函数

· 函数调用、函数参数、类型提示、名称空间

阅读排行：
· winform 绘制太阳，地球，月球运作规律
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 上周热点回顾（3.3-3.9）
· AI 智能体引爆开源社区「GitHub 热点速览」

XX学Python·函数

函数的返回值

函数的说明文档

函数的嵌套

变量的作用域

函数的参数

组包和拆包

引用

学生管理系统

函数递归(recursion)

lambda函数

公告

随笔分类 (61)

阅读排行榜

	'''
	# 函数定义的格式
	def 函数名(参数1，参数2...):
	函数体
	return 返回值

	# 函数调用格式
	函数名(参数1，参数2...)

	# 函数名：绝大多数函数都有函数名，没有函数名的函数不能被复用
	# 参数：为了让函数灵活性更高，会动态对函数进行传值
	# 函数体：写在函数内部特定功能的代码，调用函数时可全部执行
	# 返回值：写在return后，将函数内计算或运行的结果传递到函数体外部
	'''

	# 定义函数时可以不传参，调用时也不传参
	def sing():
	print('我在唱歌')
	def dance():
	print('你在跳舞')
	sing()
	dance()
	'''执行顺序：先将所有函数的函数名执行一遍储存在缓存中的方法列表中，
	后续调用函数时去方法列表中查询，如果函数名存在，则调用函数内部的代码，
	如果函数名不存在就报错。所以函数必须先定义后调用。
	'''

	# 函数的参数
	# 在定义时传入的参数叫做形参，只能在函数体内部使用
	def do_sth(who, sth):
	print(f'{who}在{sth}')
	# 在调用时传入的参数叫实参，会传入到函数内部被形参接收，传值时保证数量一致。
	do_sth('我', '唱歌')
	do_sth('小明', '洗碗')

	# 如果想将数据传递出来可以使用return
	def sum1(a, b):
	return a + b


	print(sum1(1, 3)) # 当函数执行完毕,函数调用位置就替换为函数的返回值
	# 返回的数据可以参与计算
	print(sum1(1, 3) + 12)
	# 注:返回值内容不会自动打印到控制台,将数据返回后想要查看数据需手动打印或debug调试

	# 如果没有书写返回值,则返回值为None
	list1 = [1, 2]
	# 因为此处,append方法,没有返回值,默认返回None
	print(list1.append(3)) # None

	def eat():
	print('猫吃鱼,狗吃肉,奥特曼吃小怪兽')
	print(eat()) # None


	# 如果只写了return 没有写返回值内容会怎么样? None
	def sum1(a, b):
	print(a + b)
	return

	print(sum1(1, 2)) # None

	# return执行后会跳出函数,return之后的所有代码将不会继续执行
	# 当函数执行结束后，就会回到函数调用的地方继续向下执行
	# 在函数中可以有多个return 但是只能执行一个
	def function():
	print('hello python')
	return
	return
	# 同一分支中,在return之后的所有代码不会被执行
	print('hello bigdata')


	function()


	# 返回值只能是一个元素,如果要返回多个值只能通过容器类型进行打包
	# 默认是元组类型。return后面可以连接列表、元组或字典，以返回多个值。
	def function1():
	return 1, 2, 3, 4
	print(function1()) # (1, 2, 3, 4)

	# def compute(num1, num2, symbol):
	# '''用于计算两个数的和差积商'''
	# if symbol == '+':
	# return num1 + num2
	# elif symbol == '-':
	# return num1 - num2
	# elif symbol == '*':
	# return num1 * num2
	# elif symbol == '/':
	# return num1 / num2
	# else:
	# print('输入有误')

	# 在函数体的第一行，输入三对双引号，在中间敲击回车，自动提示提示注明参数和返回值含义
	def compute(num1, num2, symbol):
	"""
	用于计算
	:param num1:第一个参与计算的数字
	:param num2:第二个参与运算的数字
	:param symbol:计算的符合（+ - * /）
	:return:计算的结果
	"""
	if symbol == '+':
	return num1 + num2
	elif symbol == '-':
	return num1 - num2
	elif symbol == '*':
	return num1 * num2
	elif symbol == '/':
	return num1 / num2
	else:
	print('输入有误')


	print(compute(1, 2, '/')) # 鼠标放这里就能看见说明文档提示内容
	# 使用help（）方法可以查阅函数的说明文档

	def sum_3(num1, num2, num3):
	"""求三个数的和"""
	return num1 + num2 + num3


	def ave_3(num1, num2, num3):
	"""求三个数的平均值"""
	return sum_3(num1, num2, num3) / 3


	print(ave_3(1, 2, 3)) # 2.0

	a = 100
	# def func1():
	# a = 1 # 这里a是在函数体内的一个局部变量，并没有修改全局变量的值
	def func1():
	global a # 要在函数体内修改全局变量就要使用global
	a = 1


	func1()
	print(a) # 1

	# 在python中所有的变量查询遵循LEDB原则
	'''
	L: local局部作用域的local命名空间 1、首先在函数体内部查询
	E: edge(enclosing)嵌套函数外层函数的命名空间 2、在外层函数中查询
	G: global全局作用域 3、在全局变量中查询
	B: build-in内置模块的命名空间 4、在系统内置变量中查询
	'''
	def out_func():
	a = 2
	def in_func():
	print(a)
	in_func()
	out_func() # 2

	# 可以在函数体内创建全局变量，只要用global修饰就行
	def func2():
	global b
	b = 99
	func2()
	print(b) # 99

	# 关键字参数可以不按顺序，但必须在位置参数后面
	def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


	user_info('Rose', age=20, gender='女')
	user_info('小明', gender='男', age=16)


	# 缺省参数，一般使用关键字参数给缺省参数赋值
	def user2_info(name, age, gender='男'): # 默认缺省参数gender='男'
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


	user2_info('TOM', 20) # 您的名字是TOM, 年龄是20, 性别是男
	user2_info('Rose', 18, '女')

	# 位置不定长参数
	def func1(*args):
	print(args) # 相当于print(1,2,3),因为1,2,3传值给了args


	func1(1, 2, 3) # 1 2 3，所以也就是*args=1，2，3


	def user_info(*args):
	print(args)
	print(*args) # TOM 下次运行TOM 18


	user_info('TOM') # ('TOM',)数据传入函数内部时进行打包，转换为一个元组被args接受
	user_info('TOM', 18) # ('TOM', 18)


	def max1(*args): # 案例：输入不确定数量多个数，判断其中最大值
	max_mun = args[0] # args是元组类型
	for i in args:
	if i > max_mun:
	max_mun = i
	return max_mun


	print(max1(1, 2, 5)) # 5
	print(max(-3, -1, -10)) # -1

	# 关键字不定长参数
	# def func(**kwargs):
	# print(**kwargs) # 相当于print(a=1, b=2)，给print输入多个关键字参数会报错
	#
	#
	# func(a=1, b=2) # a=1, b=2传给了**kwargs
	def func(**kwargs):
	print(1, 2, **kwargs) # 相当于print(1, 2, sep='$', end='a')


	func(sep='$', end='a') # 1$2a，把sep='$', end='a'传给了**kwargs


	def func2(**kwargs):
	print(kwargs) # 传参后，实参处所有未定义关键字参数转换为字典键值对，保存在kwargs中


	func2(a=1, b=2) # {'a': 1, 'b': 2}


	def stu_info(**kwargs): # 案例，创建一个函数保存学员信息
	print(f'学员信息为：{kwargs}')


	stu_info(name='xx', age=18) # 学员信息为：{'name': 'xx', 'age': 18}

	def print_numbers(*args):
	print(args) # ([1, 2, 3, 4],)
	print(*args) # [1, 2, 3, 4]


	l1 = [1, 2, 3, 4]
	print_numbers(l1) # 将l1作为1个整体传入，函数接受的其实只有一个参数，且类型为list


	def print_numbers(*args):
	print(args) # (1, 2, 3, 4)
	print(*args) # 1 2 3 4


	l1 = [1, 2, 3, 4]
	print_numbers(l1) # l1等价于print_numbers(1, 2, 3, 4)

	# 组包
	a = 1,2,3,4
	print(a) # (1, 2, 3, 4)将多个数据打包为一个容器(元组)


	def func1():
	return 1,2,3 # 返回多个数据默认打包为一个元组


	print(func1()) # (1, 2, 3)

	# 拆包（解包）
	x, y, z = (1, 2, 3) # 元组、列表一样
	print(x, y, z) # 1 2 3

	list1 = ['xx', 'lsl']
	for index, value in enumerate(list1):
	print(index, value) # 0 xx 下一行 1 lsl

	dict1 = {'name': 'xx', 'age': 18}
	for key, value in dict1.items():
	print(key, value, end='$$') # name xx$$age 18$$

	dict2 = {'a': 1, 'b': 2}
	char1, char2 = dict2 # 字典拆包得到的是字典的键
	print(char1, char2) # a b

	set1 = {'xx', 'lsl', 'wzl'}
	a, b, c = set1 # 可对集合拆包，但一般不会这样做，因为赋值顺序无法指定
	print(a, b, c) # wzl xx lsl顺序不一定

	# 同时应用组包和拆包的案例
	# 互换过程：先将a、b的值提取出来组包为一个元组；再进行拆包，将元组内的数据分别赋值给a，b两变量
	a = 1
	b = 2
	a, b = b, a
	print(a, b) # 2 1

	# 值相等的数据,唯一标识和数据类型不一定相等
	bool1 = False
	int1 = 0
	print(bool1 == int1) # True,0和False的值相等
	print(type(bool1) == type(int1)) # False,数据类型不等
	print(id(bool1) == id(int1)) # False,唯一标识不等

	# 值和数据类型相等的,唯一标识不一定相等，
	list1 = [1, 2, 3]
	list2 = [1, 2, 3]
	print(list1 == list2) # True,值相等
	print(type(list1) == type(list2)) # True,数据类型相等
	print(id(list1) == id(list2)) # False,id不等,也就是其所在的内存空间不一致
	# 可变容器类型id地址不同
	d1 = {'a':1,'b':2,'c':3}
	d2 = {'a':1,'b':2,'c':3}
	print(id(d1)) # 1864418858872
	print(id(d2)) # 1864418858952 两个id不同

	# id地址相等的, 值和数据类型必然相等
	# 在同一内存空间中只能储存同一个值
	str1 = 'abc'
	str2 = 'abc'
	print(id(str1) == id(str2)) # True
	print(type(str1) == type(str2)) # True
	print(str1 == str2) # True
	# 不可变类型id地址相同
	tuple1 = (1,2,3)
	tuple2 = (1,2,3)
	print(id(tuple1)) # 1864423129960
	print(id(tuple2)) # 1864423129960

	# 使用is可以判断是否为同一个内存空间中的数据
	print(list1 is list2) # False
	print(str1 is str2) # True
	#

	# 传参或者变量的传递是进行了值的传递，还是进行了引用地址的传递呢?
	list1 = [1, 2, 3, 4]
	list2 = [1, 2, 3, 4]
	#id的值,我们称呼他为引用地址,list1和list2 的引用地址不同
	print(id(list1)) # 140652966394496
	print(id(list2)) # 140652968507776

	list1.append(5)
	print(list1)
	print(list2)
	# 在list1中添加了数据,那list1的引用地址会发生变化么?不会变化
	# list1,在使用append方法时,是将内存空间中的值进行了变化,没有修改内存地址,所以id不变
	print(id(list1)) # 140652966394496

	# 如果我们使用list1 = list2,list1的引用地址发生变化了么? 变化
	list1 = list2
	# 此时,list1和list2指向同一块内存空间
	print(id(list1)) # 140652968507776
	# 如果在list1中删除下标为1的元素,list2会发生变化么? 会变化
	# list1和list2指向同一块内存空间,所以内存空间中数据发生了改变,list1和list2均变化
	list1.pop(1)
	print(list1) # [1, 3, 4]
	print(list2) # [1, 3, 4]
	# list 内存空间中的数据可以发生改变,这种数据类型我们称之为可变数据类型

	# 练习:
	list1 = [1, 2, 3, 4]
	list2 = [1, 2, 3, 4]
	list1 = [1, 2, 3, 4, 5]
	list2 = list1
	list1.pop(2)
	list1 + list2
	# list1 和list2 分别是多少
	print(list1)
	print(list2)

	# 练习:
	str1 = '12345'
	str2 = '12345'
	str1 = str2
	str1 = '123'
	str2 + str1
	print(str1)
	print(str2)

	str1 = '123'
	str2 = '123'
	print(id(str1)) # 140509725727984
	print(id(str2)) # 140509725727984

	# 可以修改str内部的元素么? 不可以
	# TypeError: 'str' object does not support item assignment
	# str1[0] = '2'
	# 既然内部元素不可修改,系统定义其值相同时,数据引用地址也相同
	# 这种内存空间中的数据无法被修改的值为不可变数据类型

	# 结论:在数据的传递过程中,是引用传递,不是值的传递

	# a = 1 # 将数字1所在空间的id(引用地址)赋值给了a
	# b = a # 将a所保存的引用地址给了b

	def func(num_list):
	print(id(num_list)) # 140490414045760
	num_list.append(2)
	return num_list

	# 参数传递时,是地址传递,将list1的id传递给了num_list
	# num_list修改内存空间中的数据时,list1,也会发生变化
	list1 = [1, 2, 3, 4]
	# print(id(list1)) # 140490414045760
	# print(func(list1))
	# print(list1)

	def func2(num_list):
	print(id(num_list)) # 140326362233472
	# 无论什么情况下,使用=赋值运算,就是将等号右侧数据的引用地址,赋值给等号左侧的变量
	num_list = [1, 2, 3, 4, 5]
	print(id(num_list)) # 140466340833664
	return num_list

	print(id(list1)) # 140326362233472
	print(func2(list1)) # [1, 2, 3, 4, 5]
	print(list1) # [1, 2, 3, 4]

	# 不可变数据类型
	def func1(char1):
	print(id(char1)) # 140228523715632
	# 不可变数据类型,参数传递时也是引用传递,但无法修改原有数据空间内的数据,
	# 如果想要修改只能改变引用地址,重新赋值(只有=才有改变引用的功能)
	char1.replace('a', 'b')
	return char1


	str1 = 'abc'
	print(id(str1)) # 140228523715632
	print(func1(str1)) # abc
	print(str1) # abc

	# 需求拆分:
	'''
	1.展示学生管理系统的功能有哪些,引导用户键入序号选择功能
	2.获取用户键入的功能
	3.分析具体要执行哪一项功能
	4.执行功能
	'''


	def print_all_option():
	"""用户功能界面展示"""
	print('-' * 20)
	print('欢迎登录学员管理系统')
	print('1: 添加学员信息')
	print('2: 删除学员信息')
	print('3: 修改学员信息')
	print('4: 查询学员信息')
	print('5: 遍历输出所有学员信息')
	print('6: 退出系统')
	print('-' * 20)


	def choose_option(num):
	"""分析要执行哪一项功能"""
	if num == '1':
	# 添加学员函数
	add_student_info()
	elif num == '2':
	# 删除学员函数
	delete_student_info()
	elif num == '3':
	# 修改学员函数
	modify_student_info()
	elif num == '4':
	# 查询学员函数
	search_student_info()
	elif num == '5':
	# 展示所有学员函数
	show_students_info()
	elif num == '6':
	# 退出程序函数
	exit_program()
	else:
	print('无此选项,请重新输入')


	def add_student_info():
	stu_id = input('请输入要添加学员的id:')
	students_id = [i['id'] for i in students_list]
	if stu_id in students_id:
	print('该id值已经存在,无法添加学员')
	else:
	name = input('请输入要添加学员的姓名:')
	age = int(input('请输入要添加学员的年龄:'))
	mobile = input('请输入要添加学员的手机号:')
	students_list.append({'id': stu_id, 'name': name, 'age': age, 'mobile': mobile})
	print('学员添加完成')


	def delete_student_info():
	stu_id = input('请输入要删除学员的id:')
	for stu_info in students_list:
	if stu_info['id'] == stu_id:
	students_list.remove(stu_info)
	print('该学员已删除')
	return
	else:
	print('该学员不存在,无法删除')


	def modify_student_info():
	stu_id = input('请输入要修改学员的id:')
	for dict_stu in students_list:
	if stu_id == dict_stu['id']:
	name = input('请输入您要修改为的名字:')
	age = int(input('请输入您要修改为的年龄:'))
	mobile = input('请输入您要修改为的手机号:')
	dict_stu['name'] = name
	dict_stu['age'] = age
	dict_stu['mobile'] = mobile
	print('学员信息修改完成')
	break
	else:
	print('该学员不存在,修改失败')


	def search_student_info():
	stu_id = input('请输入要查询学员的id:')
	for dict_stu in students_list:
	if stu_id == dict_stu['id']:
	print(dict_stu)
	break
	else:
	print('该学员不存在,查询失败')


	def show_students_info():
	for dict_stu in students_list:
	print(dict_stu)


	def exit_program():
	global is_stop
	is_stop = True


	students_list = [{'id': '001', 'name': 'xx', 'age': 18, 'mobile': '18181818188'},
	{'id': '002', 'name': 'lsl', 'age': 17, 'mobile': '18181818168'},
	{'id': '003', 'name': 'rose', 'age': 22, 'mobile': '18181818168'}]

	is_stop = False
	while not is_stop:
	print_all_option()
	user_num = input('请输入您要执行的功能序号：')
	choose_option(user_num)

	# 需求:
	'''
	func(1) = 1
	func(2) = 1 + 2 = func(1) + 2
	func(3) = 1 + 2 + 3 = func(2) + 3
	func(4) = 1 + 2 + 3 + 4 = func(3) + 4
	.....
	func(n) = 1 + 2 + 3 .... + n = func(n-1) + n
	'''

	# RecursionError: maximum recursion depth exceeded
	# 这种方式无法跳出递归,所以在使用的时候就会无限递归下去
	# def func(n):
	# return func(n-1) + n

	'''
	func(1) = 1
	func(2) = func(1) + 2
	func(3) = func(2) + 3
	func(4) = func(3) + 4
	.....
	func(n) = func(n-1) + n
	'''

	def func(n):
	if n == 1:
	return 1
	return func(n-1) + n


	print(func(999))
	# Python中默认的最大调用深度是1000,也就是Python中函数最多嵌套1000层
	# 最大调用深度是为了保证系统性能的,否则无限递归下去,一会内存就满了
	# 最大调用深度可以调整,可以调整到非常大的数字只要系统性能跟得上
	# RecursionError: maximum recursion depth exceeded in comparison

	# 注意事项:
	# 在编程初期,尽量少使用递归,但是要理解递归的特性,别人写的递归函数也要能看懂

	# 需求: 根据传入的参数返回最大值使用lambda函数书写
	# 三目运算 : 条件成立时返回的代码 if 条件 else 条件不成立时返回的代码
	max_num = lambda a, b: a if a > b else b # 使用变量可以储存lambda函数
	print(max_num(1, 2)) # 2
	print(max_num(9, 2)) # 9
	print(type(max_num)) # <class 'function'>


	def func():
	print('abc')


	print(type(func)) # <class 'function'>
	# 通过对数据类型的查看,发现lambda和普通函数本质上是一样的,只是在使用时构造更简单

	# 在使用lambda函数时可以不用变量接收
	print((lambda a, b: a if a > b else b)(3, 4)) # 4
	# 但不用变量接收,lambda函数只能使用一次,使用后集被释放,无法再次使用

	# 使用lambda完成递归(了解,一般不建议写复杂的代码)
	func1 = lambda n: func1(n-1) + n if n != 1 else 1
	print(func1(3)) # 6

	# list sort排序方法中的key所需要的参数就是一个函数,我们可以传入lambda表示
	list1 = [{'name': 1, 'age': 18}, {'b': 12}, {'c': 10}]
	# 排序规则:根据字典的第一个键所对应的值进行排序
	list1.sort(key=lambda x: list(x.values())[0]) # x是list1里每个元素，即字典
	print(list1) # [{'name': 1, 'age': 18}, {'c': 10}, {'b': 12}]
	print(list1[0].values()) # dict_values([1, 18])
	print(type(list1[0].values())) # <class 'dict_values'>

	list2 = [11, 34, 2, 5]
	list2.sort(key=lambda x: x % 5) # 除以5的余数排序，默认升序
	print(list2) # [5, 11, 2, 34]

	list3 = [[2, 1, 3], [0, 2, 4], [7, 8, 9]]
	list3.sort(key=lambda x: x[0])
	print(list3) # [[0, 2, 4], [2, 1, 3], [7, 8, 9]]

	# 可以使用不定长参数
	sum1 = lambda *args: sum(args)
	print(sum1(1, 2, 3)) # 6

	# 格式: lambda 参数: 返回值，参数可以省略
	hei = lambda: print('hello world')
	hei() # hello world

	# lambda里面还有lambda
	fn = lambda string: lambda msg: f'{string}: {msg}!'
	# 重点：fn返回的依旧是一个lambda表达式lambda msg: f'{string}: {msg}!'
	fnh = fn("hello") # fnh是fn调用后的结果fnh=lambda msg: f'{hello}: {msg}!'
	print(fnh("MrSun")) # hello: MrSun!

	fnw = fn("welcome to") # fnw同样是fn调用后的结果
	print(fnw("China")) # welcome to: China!