“”"
性质：
1.使用print无法查看迭代器中的元素。
2.使用len方法也无法查看其中元素个数。
3.迭代器（iterator）
4.迭代器类似数据结构中的队列（先进先出），迭代器中的元素被取出，即消失。
5.任何容器型数据类型都可以使用iter方法转为迭代器。
“”"
str1 = ‘hello’
str1_iter = iter(str1)
print(str1_iter, type(str1_iter))
list1 = [1, 2, 3]
list_iter = iter(list1)
print(list_iter, type(list_iter))
print(next(str1_iter))
print(next(str1_iter))
for i in str1_iter:
print(i)
“”"
性质：
1.生成器为了生成迭代器（生成器就是迭代器，但是迭代器不一定是生成器）。
2.生成器是一个函数。
3.调用生成器函数时，函数不执行，只有在获取元素时生成器函数才执行,
并且是获取一个元素才能够让生成器函数执行一次。
4.生成器函数返回内部结果使用yield代替return
5.yield执行几次，生成器就产生几个元素
“”"
def myGener():
print(‘123’)
yield 100
yield 200
if 100 > 200:
yield 300
return 1
yield 400
f = myGener()
print(f)
print(next(f))
for i in f:
print(i)
“”"
1.return 被触发，函数立即结束。yield不会结束函数执行。
2.return和yield都可以将函数内部结果返回到外部
3.return和yield后面都是跟表达式
“”"
ef stuId():
for i in range(1, 1000):
yield f’python{i:0>3}’
f = stuId()
print(f)
print(next(f))
for _ in range(100):
print(next(f))
print(next(f))
匿名函数 一、概念 Python中有一个lambda表达式，lambda有匿名的意思，并且lambda表达式就是简化的函数，所以被叫做匿名函数。 二、理解 匿名函数和普通函数的关系理解为单分支结构和三目运算符的关系。 三、匿名函数在语法上就是有单一的严格限制的固定语法。在语义上是普通函数的语法糖。 语法糖（糖衣语法），是英国的计算机学家提出的一个概念。语法糖就是对已经存在的语法的简化。 语法糖能提高代码的可读性，但是不影响功能。 案例：计算两个数字的和def numSum(num1, num2):
return num1 + num2
print(numSum(10, 20))
------------------------------------numSumLambda = lambda num1, num2: num1 + num2
print(numSumLambda(10, 20))
def total(start=1, end=100):
sum = 0
for i in range(start, end + 1):
sum += i
return sum
totalLambda = lambda start, end: sum([i for i in range(start, end + 1)])
print(totalLambda(1, 100))
leapYear = lambda year: True if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else False
print(leapYear(2005))
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)
“”"
“”"
如何写出递归思想的代码：
- 知道最终结果的计算规律。
- 从需要算的结果向前推。
- 了解递归结束的条件
- 学会自己调自己的方式
“”"
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
print(factorial(10))
能使用循环解决的就能使用递归。尽量使用for循环来解决。 但是递归使用时需要谨慎，如果涉及计算量很大，有一个拓栈和压栈的过程，拓栈是容易内存溢出。 栈：先进后出 高阶函数 将一个函数当做另一个函数的参数，叫做高阶函数。print(max)
def func1():
print(‘这是一个函数’)
print(func1)
func1()
a = func1
a()
def func2(func):
print(‘这是另一个函数’)
func()
func2(func1)
Python常用高阶函数：max、min、sorted、map、reduce max、min：获取容器中最大（最小）的元素nums = [10, 55, 67, 666, 900]
print(max(nums))
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))
nums = [10, 55, 67, 666, 900]
print(sorted(nums, key=lambda num: num % 10))
from functools import reduce
nums = [10, 55, 67, 666, 900]
对列表中元素做累乘。print(reduce(lambda total, num: total * num, nums, 1))
reduce和for循环对比： reduce性能明显不及for循环，但是如果从代码可读性（优雅的写法）reduce是更好的。 map():根据容器产生一个新的序列 map(自定义函数, 容器1, 容器2, …) 自定义函数要求： a.函数有N（容器数量）个形参。 b.有返回值。 map函数的结果是一个可迭代对象，可以将这个可迭代对象使用构造器语法转换为列表、元组、集合等容器。names = [‘小明’, ‘小王’, ‘小李’]
chinese = [90, 95, 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))
