python高阶函数简述

这篇文章介绍一下python的高阶函数。

目录

1.偏函数

2.lambda表达式（匿名函数）

3.递归函数

4.推导式

5.函数闭包

6.命名元组

6.zip函数

7.filter函数

8.map函数

9.global() 和 locals() 函数

---

1.偏函数

作用：固定函数的参数，重写原函数，设置函数参数的默认值。

from functools import partial


def func(name, age, gender):
    print(F"名字：{name},性别:{age},性别:{gender}")


# 使用偏函数固定参数，遵循函数传参的规则
# 将func作为偏函数的第一个参数，设定func原有参数的固定值
new_fun1 = partial(func, "小明")  # 固定func的name为小明
new_fun2 = partial(func, age=18)  # 固定func的age为18
new_fun1(19, "男")
new_fun1(20, "女")
new_fun2(name='小李', gender='boy')

运行结果：

名字：小明,性别:19,性别:男
名字：小明,性别:20,性别:女
名字：小李,性别:18,性别:boy

2.lambda表达式（匿名函数）

作用：实现某些简单的函数，而不用给函数命名

lambda 参数列表: 返回值

foo = lambda x, y: x + y
print(foo)
print(foo(11, 22))

<function <lambda> at 0x0000023DDEACC1E0>
33

3.递归函数

作用：函数内部调自身 ，python最大递归深度限制:1000次 ，python使用递归比较耗内存

def fun(number):
    """
    实现 1+50的和
    :param number:
    :return:
    """
    if number == 1:
        return number
    else:
        return number + fun(number - 1)


print(fun(100))

4.推导式

（1）列表推导式: 快速生成一个有规律的列表数据

         普通使用方法：[i for i in range(100)]

         结合if条件一起使用：[i for i in range(100) if i%2==0]

（2）字典推导式 普通使用： {key:value for i in xxx} 

注：没有元组推导式，那个叫生成器

# 列表推导式
li = [F'hello{i}' for i in range(5)]
print(li)

# 列表推导式后加上条件判断
li_3 = [i for i in range(100) if i % 2 == 0]
print(li_3)

# 字典推导式
dic = {i: 'data{}'.format(i) for i in range(100)}
print(dic)

5.函数闭包

函数闭包的三大条件：

（1）函数中有嵌套函数

（2）外层函数的返回值是内层函数的函数名

（3）内存函数对外部作用域有非全局变量的引用: 定义的变量 传进来的参数 闭包函数的作用

def fun():
    a = 100
    def in_fun():
        print("这个是内部定义的函数")
        print(a)
    return in_fun  # 可以外部调用

f = fun()

6.命名元组

给列表中的值加上“表头”

python中的基本数据类型：

数值：int  float  bool complex

序列：str list tuple range

散列：set dict 命名元组类型

from collections import namedtuple

Student = namedtuple("students", ['name', 'age', 'gender'])
s1 = Student('s1', 18, '男')
s2 = Student('s2', 16, '女')
print(s1.age)
print(s1.name)
print(s1.gender)

6.zip函数

作用：聚合打包函数，以最短的为准，进行对应打包。

使用方法：zip()

str1 = 'beijing'
title = ('a', 'b', 'c')
data0 = [1, 2, 3, 4]
data1 = [1, 2, 3, 4, 5, 6]
data2 = [1, 2, 3, 3, 5, 6, 7]
# 进行聚合打包
res1 = zip(str1, data0)
res2 = zip(title, data0, data1, data2)
# 只聚合了两组数据时，可以转为字典对象
print(dict(res1))
# 聚合了多组数据时，转换为嵌套元组的列表
print(list(res2))

运行结果：

{'b': 1, 'e': 2, 'i': 3, 'j': 4}
[('a', 1, 1, 1), ('b', 2, 2, 2), ('c', 3, 3, 3)]

7. filter函数

参数1：函数

参数2：可迭代对象

作用：过滤器函数 ，自动遍历第二个参数，把每个元素当成参数传到第一个参数中，根据函数返回值是true还是fasle来进行过滤 将可迭代对象中的数据再次进行返回。返回的是一个fliter对象，需要转换为list、tuple等进行输出。

li = [22, 33, 44, 55]
res3 = filter(lambda x: x > 33, li)
print(tuple(res3))

(44, 55)

8.map函数

参数1：函数

参数2：可迭代对象

作用：将可迭代对象的每项作为参数传给前面的函数。

res = map(lambda x: x * 2, [11, 22, 33, 44])
res = list(res)
print(res)

res2 = map(lambda x, y: x + y, [11, 22, 33, 44], [22, 33, 44, 55, 66])
res2 = list(res2)
print(res2)

[22, 44, 66, 88]
[33, 55, 77, 99]

9. global() 和 locals() 函数

作用：

locals:获取当前作用域的全局变量，并打包成字典

def foo(c):
    aa = 100
    bb = 100
    dic1 = locals()
    print(dic1)

foo(999)

{'c': 999, 'aa': 100, 'bb': 100}

globals:获取全局作用域的变量，并打包成字典

def foo2(c):
    dic1 = globals()
    c = 1000
    print(dic1)


foo2(100)

name = 999
if name in globals():
    print('name已经在全局作用域中了')
else:
    name = 999

{'__name__': '__main__', '__doc__': '\n内置函数\nlocals:获取当前作用域的全局变量，并打包成字典\nglobals:获取全局作用域的变量，并打包成字典\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027216F91CF8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/PythonPro/free_lemon_sdet/day_02/内置函数.py', '__cached__': None, 'foo2': <function foo2 at 0x0000027216FCC1E0>}

<完>