基于上次的公共操作和简单的推导式运算，本次学习函数的相关知识。

函数

函数基本形式

def f(a,b):
    """ 
    说明文档内容
    """
    代码
    return a + b
# 调用时，help(f)查看说明文档

局部变量和全局变量

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

a = 100

def testA():
    print(a)

def testB():
    #global 关键字声明a是全局变量
    global a
    a = 200
    print(a)

返回值

返回多个值，return a,b，默认是返回元组类型
return后面可以连接列表、元组或字典，以返回多个值

参数

调用有参数的函数时，参数可有多种方式写入。

关键字参数

def user_info(name, age, gender):
    print()

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

缺省参数

def user_info(name, age, gender='男'):
    print()
#带有缺省值的参数可以不输入
user_info('Tom', 20)

不定长参数

包裹位置传递

def user_info(*args):
    print(args)
    
user_info('Tom', 18) # ('Tom',18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple）。

包裹关键字传递

def user_info(**kwargs):
    print(kwargs)
    
user_info(name='Tom',age=18) # {'name': 'Tom','age': 18}

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

拆包

元组拆包

def return_num():
    return 100, 200

num1, num2 = return_num()

字典拆包

dict1 = {'name': 'Tom', 'age': 18}
a, b = dict1

#对字典进行拆包，取出来的是字典的key
print(a) # name
print(b) # age

print(dict1[a]) #Tom

交换变量值

定义第三变量传值
1
2
3
c = a
a = b
b = c

方法二

1 2	a, b = 1, 2 # 把1和2分别赋值给a和b b, a = a, b

引用

在python中，值是靠引用传递的。

可以用方法id(变量) ，得到变量的地址

int数据类型不可变（数值改变地址改变），列表数据类型可变（数值改变地址不变）

可变和不可变类型

所谓可变不可变：即该数据能否直接修改，如果直接修改那么可变（不改变内存地址），否则不可变。

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

lambda表达式（匿名函数）

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

语法

1	lambda 参数列表 : 表达式

注意：

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用

lambda表达式能接受任何数量的参数但只能返回一个表达式的值

lambda的参数形式

无参数

# 函数
def fn1():
    return 200

#lambda表达式
fn2 = lambda: 100
print(fn2) # lambda内存地址
print(fn2()) # 对应的函数的返回值

有参

# 计算a + b
# 函数实现
def add(a, b):
    return a + b
print(add(1,2))

#lambda实现
fn1 = lambda a, b: a + b
print(fn1(1, 2))

默认参数

1	fn1 = lambda a = 0, b = 0: a + b

可变参数：*args

1 2	fn1 = lambda *args: args print(fn1(1, 2, 3))

注意：这里的可变参数传入到lambda中，返回的类型为元组

可变参数：**kwargs

1 2	fn1 = lambda **kwargs: kwargs print(fn1(name = 'python', age = 20))

返回字典类型。

以上与函数部分的规则完全一致。

lambda的应用

带判断的lambda

1 2	fn1 = lambda a, b: a if a > b else b print(fn1(1, 2))

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

students = [
    {'name':'Tom', 'age': 20},
    {'name':'Rose', 'age': 19},
    {'name':'Jack', 'age': 22}
]

# 按name值升序排序
students.sort(key = lambda x: x['name'])
print(students)
# sort函数：如果要排序的列表里数据为字典，则指定key值则可排序

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

高阶函数

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

示例：任意两个数字，求绝对值abs（或四舍五入 round）后进行求和。

方法1

1
2
3

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

方法2

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

#灵活性变高
result = sum_num(-1, 2, abs)
result = sum_num(-1, 2, round)

内置高阶函数

map()

map(func, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的迭代器返回。

例子：

list1 = [1, 2, 3, 4, 6]
def func(x):
    return x ** 2
result = map(func, list1) 
print(result) #为地址
print(list(result)) # list()，将数据转换为列表 [1, 4, 9, 16, 25]

reduce()

reduce(func, lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累计计算。

例子：计算list1序列中各个数字的累加和

import functools # 导入reduce所需的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) # filter对象
print(list(result)) # [2, 4, 6, 8, 10]