day09_Python

迭代器：

迭代在Python就是属于可以做for循环遍历的对象，被叫做可迭代对象
可迭代对象分为容器和迭代器两个，迭代器又有生成器分支
使用print无法查看其中元素个数
使用len方法也无法查看里面的元素个数
迭代器(iterator)
迭代器类似数据结构中的队列(先进先出)，迭代器中的元素，被取出即在该迭代器中消失
任何容器型数据类型都可以使用iter方法转为迭代器。

str1 = 'hello'
str1_iter = iter(str1)
print(str1_iter, type(str1_iter))

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

如何获取迭代器中的元素：

迭代器中的元素取出一个少一个，取出后迭代器中就没有该元素了
for循环
next()方法

print(next(str1_iter))
print(next(str1_iter))

for i in str1_iter:
    print(i)

迭代器的应用场景:一个迭代器中的元素被全部取出后，该迭代器消失；迭代器所占内存被释放，程序就可以减小内存占用生成器：

生成器是为了生成迭代器(所以说生成器就是迭代器，但是迭代器不一定是生成器)
生成器是一个函数
调用生成器函数时，函数不执行，只有在获取元素时生成器函数才执行，并且是获取一个元素，才能够让生成器函数执行一次。
生成器函数返回内部结果使用yield代替return
yield执行几次生成器就产生几个元素

def myGener():
    print('123')
    yield 100
    for i in range(20):
        yield i
    yield 200
    if 100 > 200:
        yield 300
    return 1
    # return 后面的代码不会再执行了
    yield 400


f = myGener()
print(next(f))
for i in f:
    print(i)
# print(next(f))  # 生成器中没有元素了，再取会报错StopIteration

yield和return的区别：

return 被触发，函数立即结束，yield不会结束函数执行
return和yield都可以将函数内部结果的返回到外部
return yield垢面都是跟表达式

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


f = myNum()
# for i in f:
#     print(i)
print(f.__next__())

匿名函数：

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))

# 练习
sum1 = lambda start, end: sum([i for i in range(start, end+1)])
print(sum1(1, 100))

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

leapYear = lambda year: '闰年' if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else '平年'
print(leapYear(2020))

递归函数：

递归就是一种循环的思想
函数之间是一个相互调用的过程，递归是相对于函数来说的，但是递归是一种特殊的函数，自己调用自己
递推思维：斐波那契数列：根据已有的数据推算规律(正向的推算)
递归思维：根据规律逆向推算。
递归虽然是循环的思想，但是要注意循环结束的条件，不然就陷入死循环

# 斐波那契数列
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)


fib(9)
"""
fib(9) = fib(8) + fib(7) 
fib(8)= fib(7) + fib(6)
fib(7) = fib(6) + fib(5)
......
fib(3) = fib(2) + fib(1)
"""

如何写出递归思想的代码：

知道最终结果的计算规律
从需要算的结果往前推
要知道递归结束的条件
学会使用自己调自己的方式

# 递归练习：N阶乘
def sum1(N):
    if N == 1:
        return 1
    return N * sum1(N - 1)


print(sum1(3))


def sum2(N):
    if N == 1:
        return 1
    return N + sum2(N - 1)

# 能使用的循环解决的就能使用递归。
# 但是递归使用的时候需要谨慎，如果设计计算量很大，有一个拓栈和压栈的过程，拓栈时容易溢出
# 栈：先进后出
print(sum2(100))

高阶函数的应用：

将一个函数当作另一个函数的参数，叫做高阶函数
自定义函数相当于定义了一个数据类型为function的变量

Python常用高阶函数：max/min/sorted/map/reduce max/min:获取容器中最大或最小的元素：

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 x: x % 10))

sorted:

sorted(容器，key=函数)：按照函数指定的形式对容器中的元素排序
函数的要求：(1)函数有且仅有一个形参。(2)必须有返回值

nums = [10, 55, 67, 666, 900]
print(sorted(nums, key=lambda num: num % 10))

reduce:

根据传递的容器对容器中的每个元素做累计。
reduce(函数, 容器,初始值)
函数要求：函数要有两个形参。第一个形参开始指向初始值，然后再指向每次累计的结果，
第二个形参指向容器每个元素
必须要有返回值
reduce和for循环对比：reduce性能明显不及for循环，
从代码可读性(优雅的写法)reduce是更好的

from functools import reduce

nums = [10, 55, 67, 666, 900]
# 对列表中的元素做累乘
print(reduce(lambda total, num: total * num, nums, 1))
def sum11(a):
    sum = 1
    for i in a:
        sum *= i
    return sum

map:

根据容器产生一个新的序列
map(函数, 容器1，容器2，容器3…)
函数有N(容器数量)个形参，
有返回值
map函数的结果是一个可迭代对象，可以将可迭代对象使用构造器语法转换为列表、元组、集合等容器

names = ['小王', '小明', '小李']
chinese = [95, 90, 80]
english = [60, 70, 80]
map_iter = map(lambda a, b, c: {'name': a, 'chinese': b, 'english': c}, names, chinese, english)
print(map_iter)
# for i in map_iter:
#     print(i)

print(list(map_iter))
nese = [95, 90, 80]
english = [60, 70, 80]
map_iter = map(lambda a, b, c: {'name': a, 'chinese': b, 'english': c}, names, chinese, english)
print(map_iter)
# for i in map_iter:
#     print(i)

print(list(map_iter))

day09

Python相关栏目本月热门文章