Python函数

函数一种功能抽象：完成特定功能，与黑盒类似，对函数的使用不需要了解函数内部实现原理，只要了解函数的输入输出方式

函数的作用：

封装代码

函数使用步骤：

def 函数名():
      代码

调用函数：

函数名()

函数的参数：

形参：函数定义时书写的参数（虚假数据（a,b,c））
实参：函数调用时书写的参数（真实数据（1，2，3））

• 各个参数用逗号分割
• 不需要说明形参类型。Python解释器会根据实参的值自动推断形参类型

参数的传递

• 在Python中，类型属于对象，变量是没有类型的
• 变量仅仅是一个对象的引用（一个指针）

可更改（mutable）与不可更改（immutable）对象

• 不可变类型：变量赋值a=5后在赋值a=10，这里实际是新生成一个int值对象10，再让
  a指向它，而5被丢弃，但5还是占的有内存。故不是改变a的值，相当于新生成了a
• 可变类型：变量赋值yyqx=[1,2,3,4]后再赋值yyqx[2]=5,但其实yyqx本身没有动，只是其内部的一部分值被修改了

函数的返回值return

• 函数返回值
• 退出当前函数，如果return后还有函数体内部语句，那么这些语句不会执行
• 不需要指定函数返回值类型，这由函数中return语句返回的值的类型来确定。如果函数没有明确的返回值，Python认为返回空值None

定义函数的说明文档

def sum_num(a,b):
    """求和函数"""
    return a+b
print(sum_num(10,30))
help(sum_num)
def sum_num1(c,d):
    """
    求和函数sum_num1.
    :param c: 参数1
    :param d: 参数2
    :return: 返回值
    """
    return c+d
help(sum_num1)
输出：
40
Help on function sum_num in module __main__:
sum_num(a, b)
    求和函数
Help on function sum_num1 in module __main__:
sum_num1(c, d)
    求和函数sum_num1.
    :param c: 参数1
    :param d: 参数2
    :return: 返回值

函数的嵌套调用

def _num():
    return 50
def _num1(num):
    print(num)
result=_num()
_num1(result)

def return_num():
    return 1,2
result=return_num()
print(result)
#return a,b写法，返回多个数据，默认是元组类型
#return 后面可以连接到列表，元组或字典，以返回多个值

函数的参数

1. 位置参数：调用函数时根据函数定义的参数位置来传递参数（传递和定义参数的顺序及个数一致）

def user_(name,age,gender):
    print(f'名字是：{name},年龄是{age},性别是{gender}')
user_('YYQX',20,'Man')

2.关键字参数：函数调用，通过“键=值”形式加以指定。（函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序）

def user_(name,age,gender):
    print(f'崽子的名字是{name},年龄是{age}，性别是{gender}')
user_('YYQX',age=20,gender='Man')
user_('YangZai',gender='男',age='20')
输出：
崽子的名字是YYQX,年龄是20，性别是Man
崽子的名字是YangZai,年龄是20，性别是男

3. 缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（所有位置参数必须出现在默认参数前，包括函数定义和调用

def user_(name,age,gender='男'):
    print(f'崽子的名字是{name},年龄是{age}，性别是{gender}')
user_('yyqx',20)
user_('Brother',20,'女')
#函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值
输出：
崽子的名字是yyqx,年龄是20，性别是男
崽子的名字是Brother,年龄是20，性别是女    

4.不定长参数：也叫可变参数。用于不确定调用的时候回传递多少个参数(不传参也可以)的场景。此时，可以使用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便

def user_(*args):
    print(args)
user_('YYQX')
user_('YYQX',20)
#传进的所有参数都会被args变量收集，他会根据传进参数的位置合并为一个元组，
#args是元组类型，这就是包裹位置传递
输出：
('YYQX',)
('YYQX', 20)

不定长位置参数：收集所有位置参数，返回一个元组

• 包裹关键字传递

def user_(**kwargs):
    print(kwargs)
user_(name='YYQX',age=20,gender='男')
输出：
{'name': 'YYQX', 'age': 20, 'gender': '男'}

不定长关键字参数：收集所有关键字参数，返回一个字典
无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

拆包和交换变量值

• 拆包

#拆包（元组）
def return_num():
    return 3,7
num1,num2=return_num()
print(num1)
print(num2)

#拆包（字典）
dict1={'name':'YYQX','age':20}
a,b=dict1
#对字典进行拆包，取出来的是字典的键
print(a)
print(b)
print(dict1[a])
print(dict1[b])
输出：
3
7
name
age
YYQX
20

• 交换变量值

#方法一
a,b,c=10,20,0
c=a
a=b
b=c
print(a)
print(b)
#方法二
c,d=3,4
c,d=d,c
print(c)
print(d)
输出：
20
10
4
3

引用

在Python中，值是靠引用来传递到
id()来判断两个变量是否为同一个值的引用（内存的十进制值）

a=1
b=a
print(b)
#a和b的ID值是相同的
print(id(a))
print(id(b))
a=2
#修改a的数据，a指向另一个内存
#因为修改了a的数据，内存要开辟另外一个内存存储2，所以id检测到的a和b地址不同
a=1
print(id(a))
print(id(b))
输出：
1
140710280618832
140710280618832
140710280618864
140710280618832

#可变类型
a=[10,20,30]
b=a
print(b)
print(id(a))
print(id(b))
a.append(40)
print(a)
print(id(a))
print(id(b))
输出：
[10, 20, 30]
2577069269640
2577069269640
[10, 20, 30, 40]
2577069269640
2577069269640

• 引用当做实参

def test1(a):
    print(a)
    print(id(a))
    a+=a
    print(a)
    print(id(a))
b=10
test1(b)
list1=[20,30]
test1(list1)
输出：
10
140710280619120
20
140710280619440
[20, 30]
2106779198088
[20, 30, 20, 30]
2106779198088

可变和不可变类型

• 可变类型
• 列表
• 字典
• 集合
• 不可变类型
• 整型
• 浮点型
• 字符串
• 元组

递归

• 函数内部自己调用自己
• 必须有出口

lambda表达式

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化
语法

lambda 参数列表：表达式

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
lambda表达式能接受任何数量的参数但只能返回一个表达式的值

def fn1():
    return 137
result=fn1()
print(result)
fn2=lambda :21#lambda 匿名函数
print(fn2)#打印出来lambda内存地址
print(fn2())
输出：
137
<function <lambda> at 0x0000027665E876A8>
21

#计算a+b
def add(a,b):
    return a+b
result=add(1,2)
print(result)
fn1=lambda a,b:a+b
print(fn1(1,2))
输出：
3
3

lambda的参数形式
无参数

fn1=lambda :100
print(fn1())
输出：
100

一个参数

fn2=lambda a:a
print(fn2("Hello World"))
输出
Hello World

默认参数

fn3=lambda a,b,c=100:a+b+c
print(fn3(10,20))
输出：
130

可变参数：*args

fn4=lambda *args:args
print(fn4(10,20,30,40))
输出：
(10, 20, 30, 40)
#可变参数传入到lambda之后，返回值为元组

可变参数：**kwargs

fn5=lambda **kwargs:kwargs
print(fn5(name='yyqx',age=20))
#接受不定长关键字参数，返回值是字典
输出：
{'name': 'yyqx', 'age': 20}

lambda的应用

带判断的lambda

fn1=lambda a,b:a if a>=b else b
print(fn1(10,20))
print(fn1(40,30))
输出：
20
40

列表数据按字典key的值排序

students=[{'name':'WaterMelon','age':20},{'name':'Grape','age':18},{'name':'Apple','age':19}]
print(students)
students.sort(key=lambda x:x['name'])
print(students)
students.sort(key=lambda x:x['name'],reverse=True)
print(students)
students.sort(key=lambda x:x['age'])
print(students)
输出：
[{'name': 'WaterMelon', 'age': 20}, {'name': 'Grape', 'age': 18}, {'name': 'Apple', 'age': 19}]
[{'name': 'Apple', 'age': 19}, {'name': 'Grape', 'age': 18}, {'name': 'WaterMelon', 'age': 20}]
[{'name': 'WaterMelon', 'age': 20}, {'name': 'Grape', 'age': 18}, {'name': 'Apple', 'age': 19}]
[{'name': 'Grape', 'age': 18}, {'name': 'Apple', 'age': 19}, {'name': 'WaterMelon', 'age': 20}]

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式

def add_num(a,b):
    return abs(a)+abs(b)
result=add_num(-10,-30)
print(result)
输出：
40

def add_num(a,b,f):
    return f(a)+f(b)
result=add_num(-1,2,abs)
print(result)
输出：
3
#函数名作为另一个函数的参数出现

内置高阶函数
map（）：map(func,lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表python迭代器返回（func为函数名，lst为列表序列）

list1=[1,2,3,4,5]
def func(x):
    return x**2
result=map(func,list1)
print(result)#打印内存地址
print(list(result))#将数据类型进行转换
输出：
<map object at 0x000002371EF02160>
[1, 4, 9, 16, 25]

reduce(func,lst),其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累计计算（reduce（）传入的参数func必须接受2个参数）（func函数名，lst序列名）

import functools
list1=[1,2,3,4,5]
def func(a,b):
    return a+b
result=functools.reduce(func,list1)
print(result)
输出:
15

filter()：filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list（）转换

list1=[1,2,3,4,5,6,7,8,9,10]
def func(x):
    return x%2==0
result=filter(func,list1)
print(result)
print(list(result))
输出：
<filter object at 0x00000140E53E2160>
[2, 4, 6, 8, 10]