系列文章目录

1. Python数据类型：编程新手的必修课
2. 深入探索Python字符串：技巧、方法与实战
3. Python 函数基础详解
4. Python正则表达式详解：掌握文本匹配的魔法
5. Python文件操作宝典：一步步教你玩转文件读写
6. Python面向对象基础与魔法方法详解
7. Python面向对象进阶：深入解析面向对象三要素——封装、继承与多态
8. Python进阶之旅：深入理解变量作用域、垃圾回收、拷贝机制与异常处理
9. Python函数进阶：四大高阶函数、匿名函数、枚举、拉链与递归详解
10. 从零开始学迭代器生成器：打造高效、易读的Python代码
11. Python进阶：深入剖析闭包与装饰器的应用与技巧

---

前言

Python函数进阶涵盖四大高阶函数（map、reduce、filter、sorted）、匿名函数、枚举、拉链及递归。本博客将深入解析这些高级特性，助你提升代码效率与可读性。从序列处理到递归算法，一同探索Python函数的进阶奥秘。

---

一、匿名函数

语法：

def 函数名(形参):
	代码块
函数名(实参)

# 变量-->函数对象
变量 = lambda 形参:表达式
变量名(实参)

分类：

# f = lambda 形参:表达式


# 1.无参数无返回值的函数
def func1():
    print("这是无参数无返回值的def函数")
func1()

f1 = lambda :print("这是无参数无返回值的lambda函数")
f1()


# 2.有参数无返回值的函数
def func2(a):
    print(f"这是有参数无返回值的def函数，参数为：{a}")
func2(10)

f2 = lambda a,b:print(f"这是有参数无返回值的lambda函数，参数为：{a+b}")
f2(20,30)


# 3.无参数有返回值的函数
def func3():
    return "这是无参数有返回值的def函数"
print(func3())

f3 = lambda :"这是无参数有返回值的lambda函数"
print(f3())


# 4.有参数有返回值的函数
def func4(a):
    return f"这是有参数有返回值的def函数。参数为：{a}"
print(func4(5))

f4 = lambda a:f"这是有参数有返回值的lambda函数。参数为：{a}"
print(f4(3))

二、四大高阶函数

1.概念

高阶函数：将另外一个函数作为参数使用
作为参数的函数一定要有返回值

2.map

代码如下（示例）：

# map
# 语法：map(函数,可迭代对象)
# 作用：将函数依次作用于可迭代对象中的每一个数据；返回的结果是一个迭代器对象


# 案例一：将所有的数据取平方值存放在一个新的列表中返回
list1 = [1,2,3,4,5]

def func1(x):
    return x**2

ret = map(func1,list1)
print(list(ret))

3.reduce

# reduce高阶函数比较特殊，使用需要导包
from functools import reduce

# reduce
# 语法：reduce(函数,可迭代对象)
# 作用：对可迭代对象中的数据进行累计操作
# 		返回一个值
# 案例一：利用高阶函数实现对可迭代对象中的数据进行求和
list1 = [11,12,13,14,15]

def func1(a,b):
    return a+b

ret = reduce(func1,list1)
print(ret)

# 第一次：a=11   b=12    23
# 第二次：a=23   b=13    36
# 第三次：a=36   b=14    50
# 第四次：a=50   b=15    65

4.filter

# filter
# 语法：filter(函数,可迭代对象)
# 作用：通过函数对可迭代对象中的数据依次进行过滤，保留满足条件的数据；返回的结果是一个迭代器对象

# 案例一：100-999之间的水仙花数
list1 = [i for i in range(100,1000)]

def func1(x):
    return int(str(x)[0]) ** 3 + int(str(x)[1]) ** 3 + int(str(x)[2]) ** 3 == x

ret = filter(func1,list1)
print(list(ret))

5.sorted

# abs()
# 语法：abs(数字)
# 作用：获取当前数字的绝对值
num = -10
print(abs(num))   # 10


# sort()
# 语法：列表.sort(key排序规则，reverse降序)
# 作用：按照指定的排序规则对列表中的数据进行升降序排序；不指定任何参数时，列表升序排序；指定reverse=True实现降序排序
list1 = [78,60,-34,51,0,-14]
def func1(x):
    return abs(x)
list1.sort(reverse=True,key=func1)
print(list1)


# sorted
# 语法：sorted(可迭代对象，key排序规则，reverse降序)
# 作用：将可迭代对象按照指定的排序规则进行升降序排序
list1 = [78,60,-34,51,0,-14]
def func1(x):
    return abs(x)
ret = sorted(list1,reverse=True,key=func1)
print(ret)

6.总结

map：  1.所有的数据都要   
		2.对所有的数据都进行相同的操作  
		 3.返回的结果是一个迭代器对象
reduce：1.对数据进行累积操作(累加，累乘)  
		 2.返回的结果是一个具体的值  
		  3.使用需要导包
filter：1. 不是所有的数都要，仅保留满足条件的数据  
		 2.返回的结果时一个迭代器对象
sorted：排序

---

三、枚举函数

# 枚举函数
# enumerate()
# 语法：enumerate(可迭代对象，start)
# 作用：获取可迭代对象中的数据及对应的序号；序号默认从0开始，充当下标；通过start参数执行序号的起始值

list1 = ["hello","你好","玛卡巴卡"]

ret1 = enumerate(list1,start=100)

for i,j in ret1:
    print(i)

四、拉链函数

# 拉链函数
# zip
# 语法：zip()
# 作用：从多个可迭代对象中按照顺序取对应的数据，组合成一个个小元组；返回的结果是一个zip对象

list1 = ["张三","李四","王五","赵六"]
list2 = ["喜羊羊","美羊羊","懒羊羊"]

ret = zip(list1,list2)

for i in ret:
    print(i)

五、递归函数

简单案例

# 递归函数
# 本质：自己调用自己

# 编写递归函数
# 1.在定义和调用函数时传递起始值
# 2.大范围的判断(何时结束递归)
# 3.实现本质：自己调用自己(参数发生变化)

# 案例一：用递归函数实现1到10的和
def func1(n):
    if n == 10:
        return 10
    return n+func1(n+1)
print(func1(1))

# 案例二：用递归函数实现10到1的和
def func2(n):
    if n == 1:
        return 1
    return n+func2(n-1)
print(func2(10))

# 案例三：用递归函数实现10以内偶数的和
def func3(x):
    if x == 10:
        return 10
    else:
        return x + func3(x+2)
print(func3(0))
-------------------------------------
def func3(n):
    if n <= 0:
        return 0
    if n % 2 == 0:
        return n + func3(n-1)
    else:
        return func3(n-1)

print(func3(10))

二分查找算法

# 递归函数实现二分查找算法
# 1.在定义和调用函数时传递起始值
# 2.大范围判断(结束递归)
# 3.实现自己调用自己(参数发生变化)

# 递归实现获取指定数据的下标
# 列表数据：1.数量没有要求   2.数字的大小   3.数据必须有规律的排放
list1 = [5,13,26,45,63,79,81,96,102,304,706,958,1200]
# lst:指定要从这个列表中查询数据-->列表不会发生变化
# n:要查询的数据-->数据不会发生变化
# start:查询范围的起始值的下标
# end：查询范围的结束值的下标
def func(lst,n,start,end):
    # 查询范围内有数据：结束下标大于等于开始下标
    if end >= start:
        # 查询中间值下标   mid = (start + end ) / 2
        mid = (start + end) // 2
        # 将要查询的数据于中间值进行比较
        # 要查询的数据 = 中间值
        if n == lst[mid]:
            return f"要查询的数据的下标为：{mid}"
        # 要查询的数据 > 中间值    start为mid+1
        elif n > lst[mid]:
            return func(lst,n,mid+1,end)
        # 要查询的数据 < 中间值    end为mid-1
        elif n < lst[mid]:
            return func(lst,n,start,mid-1)
    # 如果查询范围内没有数据了，需要结束递归
    else:
        return "当前列表中没有要查询的数据"
print(func(list1,6300,0,len(list1)-1))