第三次笔记（高阶函数）

迭代在Python中就是属于可以做for循环遍历的对象，被叫做可迭代对象。

可迭代对象分为容器和迭代器两个，迭代器又有生成器分支

迭代器：

性质：

1.使用print无法查看迭代器中的元素

2.使用len方法也无法查看其中元素的个数。

3.迭代器（iterator）

4.迭代器类似数据结构中的队列（先进先出），迭代器中的元素被去除，即消失。

5.任何容器型数据类型都可以用iter方法转为迭代器。

str1 = 'hello'
str1_iter = iter(str1)
list1 = [1,2,3]
list_iter = iter(list1)
print(len(list_iter))  # TypeError: object of type 'list_iterator' has no len()

如何获取迭代器中的元素

方法一：for 循环遍历

方法二：next()

for i in str1_iter
print(i)

print(next(str1_iter))

迭代器能做什么？

元素被全部取出，迭代器小时，迭代器所占内存被释放，程序就可以减小内存使用。

生成器（generator）

性质：

1.生成器为了生成迭代器（生成器就是迭代器，但是迭代器不一定是生成器）

2.生成器是一个函数。

3.调用生成器时，函数不执行，只有在获取元素时生成器函数才执行。

4.生成器函数返回内部结果使用yield代替return

5.yield执行几次，生成器就产生几个元素

def myGener():
    yield 100
    yield 200
    if 100 > 200:
        yield 300
    return 1


f = myGener()
print(f)
print(next(f))
for i in f:
print(i)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-38qrAvdM-1659697333349)(C:\Users\Wayne\Desktop\5IPFU`IY19EV~PYNGX1QLGQ.png)]

yield 和return 区别

1.return 被触发，函数立即结束。yield不会结束函数执行。

2.return和yield都可以将函数内部结果返回到函数外部

3.return和yield后面都是跟表达式

def Id():
    for i in range(1, 1000):
        yield f'pythot{i:0>3}'
        # yield 'python'+f'{i}'.rjust(3,'0')


result = Id()
for _ in range(1000):
    print(next(result))

匿名函数

概念：python中有一个lambda表达式，lambda有匿名的意思，并且lambda表达式就是简化版的函数，所以被叫做匿名函数。

理解：匿名函数和普通函数的关系理解为但分支结构和三目运算符的关系

匿名函数在语法上就是有单一严格限制的固定语法。在语义上是普通函数的语法糖。

语法糖（糖衣语法），是英国计算机科学家提出的一个概念，语法糖就是对已经存在的语法的简化

语法糖能提高代码的可读性，但不影响功能

匿名函数语法：

函数名 = lambda 形参：返回值

函数名（实参）

计算两个数字的和：
def numSum(num1, num2):
    return num1 + num2


print(numSum(10, 20))
# ------------------------------------
numSumLambda = lambda num1, num2: num1 + num2
print(numSumLambda(10, 20))

计算1-100的和（使用匿名函数）：
Sum = lambda a,b:sum([i for i in range(a,b)])
print(Sum(1,101))

并不是所有普通函数都可以转为匿名函数

练习：使用匿名函数判断年份是否是闰年
leapYear = lambda year: True if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else False
print(leapYear(2005))

一：递归

1.递归就是一种循环的思想

2.函数之间是一个相互调用的过程，递归是对于函数来说的，但是递归是一种特殊的函数调用（自己调自己）

二：迭代（递推）思维和递归思维

1.递推思维：斐波那契数列：根据已有的数据推算规律（正向的推算）

2.递归思维：根据规律逆向推算

三：递归虽然是循环的思想，但是要注意循环结束的条件，不然就陷入了死循环。

# 斐波那契数列
a = 1
b = 1
N = 9
for i in range(N - 2):
    MID = a + b
    a = b
    b = MID
print(b)

递归思想
def fib(N):
    if N == 1 or N == 2:
        return 1
    else:
        return fib(N - 1) + fib(N - 2)


print(fib(9))
"""
fib(9) = fib(8) + fib(7)
fib(8) = fib(7) + fib(6)
fib(7) = fib(6) + fib(5)
fib(6) = fib(5) + fib(4)
fib(5) = fib(4) + fib(3)
fib(4) = fib(3) + fib(2)
fib(3) = fib(2) + fib(1)
"""
"""
如何写出递归思想的代码：
1. 知道最终结果的计算规律。
2. 从需要算的结果向前推。
3. 了解递归结束的条件
4. 学会自己调自己的方式
"""

高阶函数：

1.将一个函数当作另一个函数的参数，叫做高阶函数。

def func1():
    print('这是一个函数')
    
def func2(func):
    print('这是另一个函数')
    func()
    
    
func2(func1)

结果为：
这是另一个函数
这是一个函数

2.Python常用高阶函数：max、min、sorted、map、reduce

max(容器,key=函数)：按照函数定义的方式获取容器中的最大值
函数的要求：（1）函数有且仅有一个形参。（2）必有有返回值。
nums = [10, 55, 67, 666, 900]
def unitNum(num):
    return num % 10
    
    
print(max(nums, key=unitNum))

print(max(nums, key=lambda num: num % 10))
print(min(nums, key=unitNum))

sorted(容器,key=函数)：按照函数指定的形式对容器中元素排序
函数的要求：（1）函数有且仅有一个形参。（2）必有有返回值
nums = [10, 55, 67, 666, 900]。
print(sorted(nums, key=lambda num: num % 10))

reduce:根据传递的容器对容器中每个元素做累计。
reduce(函数,容器,初始值)
函数要求：
a.函数有两个形参。第一个形参开始指向初始值，然后再指向每次累计的结果。第二个形参指向容器中每个元素。
b.必须有返回值
from functools import reduce

nums = [10, 55, 67, 666, 900]
对列表中元素做累乘:
print(reduce(lambda total, num: total * num, nums, 1))

map():根据容器产生一个新的序列
map(函数, 容器1, 容器2, .......)
函数要求：
a.函数有N（容器数量）个形参
b.有返回值。
map函数的结果是一个可迭代对象，可以将这个可迭代对象使用构造器语法转换为列表、元组、集合等容器。
names = ['小明', '小王', '小李']
chinese = [90, 95, 80]
english = [60, 70, 80]
转成：{'name':'小明','chinese':90,'english':60}
map_iter = map(lambda a, b, c: {'name': a, 'chinese': b, 'english': c}, names, chinese, english)
print(map_iter)

ap函数的结果是一个可迭代对象，可以将这个可迭代对象使用构造器语法转换为列表、元组、集合等容器。
names = [‘小明’, ‘小王’, ‘小李’]
chinese = [90, 95, 80]
english = [60, 70, 80]
转成：{‘name’:‘小明’,‘chinese’:90,‘english’:60}
map_iter = map(lambda a, b, c: {‘name’: a, ‘chinese’: b, ‘english’: c}, names, chinese, english)
print(map_iter)