匿名函数

函数没有名字, 这样函数只能在定义的时使用一次(缺点); 优点是简洁明了;

格式 lambda 参数1, 参数2 ... 参数n : 返回值表达式

# 格式 lambda 参数1, 参数2 ... 参数n : 返回值表达式
sums = lambda x, y: x +y;
print(sums(10, 30))

高阶函数

高阶函数: 函数的参数中含有函数作为参数

# 格式 lambda 参数1, 参数2 ... 参数n : 返回值表达式
sums = lambda x, y: x +y;
print(sums(10, 30))
def calFunction(x, y, mode):
    if mode == '+':
        return x + y
    elif mode == '-':
        return x - y
    elif mode == '*':
        return x * y
    elif mode == '/':
        return x / y

print(calFunction(10, 20, '*'))
# 修改成高阶函数的写法
def calFunc(func, x, y):
    return func(x, y)
# 1. 传入正常函数
def add(x, y):
    return x + y
def sub(x, y):
    return x - y
# 这里传入函数名, 而不是 add() 函数的调用
print(calFunc(add, 20, 10)) # 30
print(calFunc(sub, 20, 10)) # 10
# 2. 传入匿名函数
print(calFunc(lambda x, y: x*y, 10, 50))

系统内置的常用高阶函数

系统高阶函数: python为我们提供的一些高数函数

map 函数
map(func,interable)该函数使用函数作为自己的一个参数，它可以将 interable(可迭代对象) 中的数据依次传递给 func 函数处理，最后把处理的结果作为新的可迭代对象返回。

例如 [1,2,3,4,5]->[1,4,9,16,25]

# map 函数:
# map(func, *iterables)
# func 是一个函数, iterables可迭代对象
# 作用: func 作用与迭代对象中的每一个元素中, 并返回处理后新的迭代对象
# 返回的是map对象, 需要list进行转换
ls = [i for i in range(10)]
print(ls)
print(list(map(lambda x: x**2, ls)))
def func(x):
    return x + 100
print(list(map(func, ls)))

text = "0 23 4 55 6 144 233" # 假设代表图像的像素值
tls = text.split()
print([int(v) for v in tls])
print(list(map(int, text.split())))

reduce 函数
reduce(func,inteable)函数例如可以累积操作。func函数必须接受两个参数，reduce会把 fuc 的运行结果做一个参数，然后从 interable 中再依次取出一个数据当作另一个参数

from functools import reduce
ls = [i for i in range(1, 6)]
print(ls) #[1, 2, 3, 4, 5]
print(reduce(lambda x, y: x*y, ls))
print(reduce(lambda x, y: x+y, ls))

filter函数
filter(func,interable) 根据函数 func 来过滤 interable ，将interable 中的数据传入 func 中，如果函数返回 True 则保留该数据，否则就不保留

# filter
from  random import randint
ls = [randint(-50, 50) for _  in range(10)]
print(ls)
# 选择温度大于0的
print(list(filter(lambda x: x > 0, ls)))
# 选出所有偶数
print(list(filter(lambda x:x%2==0, ls)))

sorted 函数
sorted(interable,key = None, reverse = False) 对数据进行排序，并返回一个新对象原对象不变。key 可以用来指定排序的规则，它接受的值是一个函数。reverse 是指定排序的顺序（升序或降序），默认为升序

from random import randint
import random
random.seed(111)
score_ls = [randint(10, 100) for _ in range(10)]
print(score_ls)
print(sorted(score_ls))
print("排序后score_ls", score_ls)
print("降序score_ls", sorted(score_ls, reverse=True))

# 复杂排序
text_ls = ['Andrew', 'This', 'a', 'from', 'is', 'string', 'test']
print(sorted(text_ls))
# 1 根据长度排序
print(sorted(text_ls, key=len))
print(sorted(text_ls, key=lambda ele: len(ele), reverse=True))
# 更为复杂的排序类型1
wcs = {'Oh': 2, 'Mister': 3, 'Sun': 5, 'Golden': 2, 'Please': 1, 'shine': 1, 'down': 1, 'on': 1, 'me': 1, 'SunMister': 1, 'Hiding': 1, 'behind': 1, 'a': 1, 'tree': 1}
# 选出出现频率最高的3个单词
# 转换成列表
print(list(wcs.items()))
res = sorted(list(wcs.items()), key=lambda tp: tp[1], reverse=True)
print(res)
print(res[:3])
print([w[0] for w in res[:3]])
# 更为复杂的排序类型2
hero_list = [
    {"name": "鲁班七号", 'grade': 13, 'money': 14000, 'kda': 12.1},
    {"name": "妲己", 'grade': 12, 'money': 10000, 'kda': 2.1},
    {"name": "张飞", 'grade': 10, 'money': 4000, 'kda': 6.1},
    {"name": "韩信", 'grade': 15, 'money': 20000, 'kda': 8.1},
    {"name": "程咬金", 'grade': 14, 'money': 12000, 'kda': 7.1},
]
# 按照金币进行坚降序排序
hero_list = sorted(hero_list, key= lambda d: d['money'], reverse=True)
for hero in hero_list:
    print(hero)

在这里插入图片描述

递归

递归是?种编程思想，应?场景：

在我们?常开发中，如果要遍历?个?件夹下?所有的?件，通常会使?递归来实现；
在后续的算法课程中，很多算法都离不开递归，例如：快速排序

递归的特点

函数内部??调???
必须有终止条件

求 1 ~ n 累加和

def sum_numbers(num):
    if num == 1:
        return 1;
    return num + sum_numbers(num - 1)
print(sum_numbers(5))
# sum_numbers(5)
# 5 + sum_numbers(4)
# 4 + sum_numbers(3)
# 3 + sum_numbers(2)
# 2 + sum_numbers(1)
# sum_numbers(1) == 1
# 2 + 1
# 3 + 3
# 4 + 6
# 5 + 10
print(sum_numbers(100))

在这里插入图片描述

斐波那契数列的第n项

# 1, 1, 2, 3, 5, 8, 13
# 1, 2, 3, 4, 5, 6, 7
def fibo(n):
    if n in [1, 2]:
        return 1
    return fibo(n-1) + fibo(n-2)
print(fibo(5))
print(fibo(7))