python基础——函数

python基础

函数

什么是函数？为什么要有函数？函数存在的意义是什么？
举一个小例子，现在有一个需求需要写一个学生管理系统，第一步是登陆，之后可以查询成绩、查询学生信息等。但每一个功能都会用到登陆功能，如果没有函数，则需要每个功能前面都写登录功能的代码，完全一样的代码copy过来，很麻烦，可读性也不高。
使用函数可以更高效的开发，并且实现代码重用。

定义函数

def 函数名(形参【可选，没有参数可以不写】):
    代码块
    return【可选，如果没有返回值可以不写return】

函数的调用

函数名(实参)

'''
计算两个数的和
'''
def figure_sum(a,b):
    return a+b

if __name__ == '__main__':
    sum = figure_sum(1,2)
    print('两数之和为：%s'%sum)

python是自上而下执行的，所以定义函数的代码必须要写在调用函数的前面。先定义后调用
返回值：返回函数计算的结果 return 变量1，变量2。 返回多个值时默认返回的是元组
函数嵌套调⽤:一个函数内部嵌套调用另外一个函数

参数

函数定义的参数为形参，用户调用函数时传递的实际数据为实参

形参

缺省参数

缺省参数也叫默认参数，在定义函数时为参数提供默认值，调用函数时可不传该参数的值。⚠️注意缺省参数需要放在最后，无论是在函数定义还是在调用函数时，缺省参数都必须在最后

# name,age,grand,addr 为形参
def get_info(name,age,grand,addr='beijing'):
    print(f'name:{name},age:{age},grand:{grand},addr:{addr}')
if __name__ == '__main__':
    # zhangsan为位置参数，剩下三个键值对为关键字参数
    get_info('lisi', 99, 21, 'shanghai')
    get_info('zhangsan',90,20)

不定长参数

不定长参数也叫可变参数，适用于在函数定义时不确定传递参数的个数，其分为元组类型args和字典类型kwargs

*args

调用函数时所有的位置参数都会被args变量收集，并将它们按顺序封装为一个tuple元组

def print_info(*args):
    print(args)
if __name__ == '__main__':
    print_info('zhangsan',90,20,'shanghai')  # ('zhangsan', 90, 20, 'shanghai')

**kwargs

调用函数时，需要按照key=value的方式传递参数，kwargs会将参数封装为一个dict字典

def print_info(**kwargs):
    print(kwargs)
if __name__ == '__main__':
    print_info(name = 'zhangsan', grand = 90, age = 20, addr = 'shanghai')  # {'name': 'zhangsan', 'grand': 90, 'age': 20, 'addr': 'shanghai'}

以上两种不定长参数都是组包的方式进行传递参数的

实参

位置参数

• 位置参数即直接写数据，⚠️注意顺序和个数要和函数定义时一致
  #####关键字参数
• 关键字参数为key=value形式，如果在一次函数调用中既有位置参数也有关键字参数，则位置参数要在关键字参数的前面,关键字参数之间没有顺序之分

# name,age,grand,addr 为形参
def get_info(name,age,grand,addr):
    print(f'name:{name},age:{age},grand:{grand},addr:{addr}')
if __name__ == '__main__':
    # zhangsan为位置参数，剩下三个键值对为关键字参数   
    get_info('zhangsan',grand=90,age=20,addr='beijing')

变量

局部变量

定义在函数内部的变量，只在函数体内部生效。只是临时保存数据，当函数执行完时，局部变量会被销毁

全局变量

定义在函数外部的变量，在函数内外都可以被使用。但是如果在函数内要修改全局变量需要加关键字global ，否则并不会修改全局变量，而是会重新定义一个同名的局部变量

拆包

元组

tup = ('zhangsan',20,90,'beijing')
name,age,grand,addr = tup
print(f'name:{name},age:{age},grand:{grand},addr:{addr}'). # name:zhangsan,age:90,grand:20,addr:beijing

字典

dic = {
        'name':'zhangsan',
        'age':20,
        'grand':90,
        'addr':'shanghai'
    }
    name,age,grand,addr = dic
    print(name,age,grand,addr)  # name age grand addr

字典拆包后得到的是key

递归

• 自己调用自己
• 必须有出口

def recursive_sum(num):
    if num == 1:
        return 1
    result = num + recursive_sum(num-1)
    return result
if __name__ == '__main__':
    print(recursive_sum(6))  # 21

匿名函数lambda表达式

如果函数逻辑简单可以使用lambda表达式来简化代码，只需要一行代码可以替换原有五六行代码的内容，开发更加简便

语法

lambda 参数列表 : 表达式
lambda可以接收无数个参数但只能返回一个表达式的值

fn = lambda x,y:x+y
print(fn(1,2))  # 3

lambda支持的参数

无参数

    # 无参数
    print((lambda :'你好呀')())  # 你好呀

一个参数

# 一个参数
    print((lambda x:x)('hello world'))  # hello world

默认参数

# 默认参数
    print((lambda name,age,addr='beijing':'name:%s,age:%d,addr:%s'%(name,age,addr))('zhangsan',20))  # name:zhangsan,age:20,addr:beijing

args

    # args
    print((lambda *args:args)('zhangsan',20,'beijing'))  # ('zhangsan', 20, 'beijing')

kwargs

    # kwargs
    print((lambda **kwargs:kwargs)(name='zhangsan',age=20,addr='shanghai'))  # {'name': 'zhangsan', 'age': 20, 'addr': 'shanghai'}

lambda应用

• lambda带判断

    print((lambda age:'你今年%d岁，你成年了，可以进入'%age if age >= 18 else '你今年%d岁，还是未成年，不可以进入网吧'%age)(19))  # 你今年19岁，你成年了，可以进入

• 排序函数sort中使用lambda

dics = [
        {'name':'zhangsan','age':20,'addr':'shanghai'},
        {'name':'lisi','age':21,'addr':'beijing'},
        {'name':'wangwu','age':22,'addr':'suzhou'}
    ]
print(sorted(dics, key=lambda x:x['age'],reverse=True))  # [{'name': 'wangwu', 'age': 22, 'addr': 'suzhou'}, {'name': 'lisi', 'age': 21, 'addr': 'beijing'}, {'name': 'zhangsan', 'age': 20, 'addr': 'shanghai'}]

高阶函数

把函数作为参数传入的函数即为高阶函数
由于在python中值都是以引用地址来传递的，函数也不例外。函数调用是需要函数名加小括号来进行调用，单纯函数名是可以作为参数参与其他函数的定义的

def print_info(str):
    print(str)
print_info_new = print_info
print(print_info_new)  # <function print_info at 0x7ff17820dca0>
print_info_new('hello world')  # hello world

内置高阶函数

map

语法：map(func, *iterables)
用途：创建一个迭代器，使用参数中的计算函数计算每个可迭代对象中的每一个元素。并将结果组合成新的迭代器返回。⚠️注意这里返回的是map对象，需要转换成自己想要的对象

print(list(map(lambda x,y,z:x+y+z,[1,2,6,9,10],[1,6,2,8,3],[1,9,6,4,3])))  # [3, 17, 14, 21, 16]

reduce

语法：reduce(function, sequence[, initial]
用途：function必须有两个参数。每次function计算的结果继续和序列的下一个元素做累加计算。最终返回计算的最终结果

print(functools.reduce(lambda x,y:x+y,[1,4,8,2,19]))  # 34

filter

语法：filter(function or None, iterable)
用途：该函数用于过滤可迭代对象， 保留执行指定函数逻辑后为true的元素。如果function为None，则返回为true的项。⚠️注意这里返回的是filter对象，需要转换成自己想要的对象

print(list(filter(lambda x:x%2==0,[1,5,8,2,9,3,False])))  # [8, 2, False]
print(list(filter(None,[1,5,8,2,9,3,False])))  # [1, 5, 8, 2, 9, 3]