复习： 1、迭代器：不需要索引的取值方式 2、生成器：通过特殊的语法自定义的迭代器 3、枚举对象：为可迭代对象创建索引（按照迭代的顺序创建索引） 迭代器对象：装有多个值的容器     1. 可用通过.__next__()进行取值     2. 取一个少一个     3. 通过.__iter__()得到的还是自身     优点：可以不用依赖索引的统一取值方式（可以产生装有无限个元素的容器）     缺点：只能从前往后取，一次只能取一个（不能获取元素个数） 可迭代对象：可以被迭代的对象     可以通过.__iter__()转换为迭代器对象 for 循环迭代器：     1. 自动获取操作对象的迭代器对象     2. 内部一次调用一个.__next__()获取值     3. 取到末尾自动处理异常，结束循环     for v in [1, 2, 3].__iter__():         print(v) 重点：     1. for 的工作原理     2. 有哪些可迭代对象 思考：迭代器对象能不能按索引取值  # 有限的可以考虑一下，无限的免谈 枚举对象：     obj = enumerate('abc')     print(obj)     obbj = list(obj)     print(obj[0])     可以将有限的直接强转为list进行索引取值     for i, v in enumerate('abc'):         print(i, v) 生成器：     1. 结构通过函数方式实现     2. 函数内部返回值不是通过return，而是通过yield     3. 生成器（函数）名 + （）不是调用函数，而是得到生成器对象（自定义迭代器对象）     4. 可以通过.__next__()进行取值，取值一次进入到下一个yield     def fn():         # 为得到第一个yield结果的逻辑的代码         yield 1         # 为得到第二个yield结果的逻辑的代码         yield 2         # ...         yield 3         # ...         yield 4     obj = fn()     print(obj)  # generator object (生成器对象)     print(list(obj)) 今日内容：     1. 三元运算符 | 三目运算符     2. 列表元组推导式 | 字典推导式     3. 递归     4. 匿名函数     5. 内置函数     6. 作业与面向过程概念 一、三元运算符就是 if...else... 的简化语法（语法糖）     前提：if 和 else 只有一条语句     # 判断两数之大     a = 10     b = 20     if a > b：         print(a)     else:         print(b)     # 上面的代码用三元表达式来写就是：     a = 10     b = 20     print(a if a > b else b)     三元运算符不一定要与条件有直接性关系     a = 10     b = 20     print(b if a > b else a)  # 取最小值 二、推导式：列表与字典的转换语法糖     列表（元组）推导式     dic = {'a':1, 'b':2, 'c': 3}  # => [('a', 1), ('b', 2), ('c', 3)]     res = [(k, v) for k, v in dic.items()]     print(res)     print(tuple(res))  # 将结果的列表tuple一下就可以获得元组了     run==>     [('a', 1), ('b', 2), ('c', 3)]     (('a', 1), ('b', 2), ('c', 3))     字典推导式     ls = [('a', 1), ('b', 2), ('c', 3)]  # => {'a': 1, 'b': 2, 'c': 3}     res = {k:v for k, v in ls}     print(res)     run==>     {'a': 1, 'b': 2, 'c': 3}     案例：     range(10)  # range可以被推导为列表     range(10) 其实就是一个[1,2,3,4,5,6,7,8,9]的列表     打印显示时是为[1, 10]，是python为了节省内存空间的一种显示方式     res_ls = [arg for arg in range(10)]     print(res_ls)     # 迭代出可解压的单列容器，可以推导出字典     enumerate('abc')  # 取出其中的元素与其相对应的索引，一一配对为元组放入列表中     res_dic = {k:v for k,v in enumerate('abc')}     print(res_dic)     run==>     {0: 'a', 1: 'b', 2: 'c'} 三、递归     递归：回溯 与 递推     回溯：询问答案的过程     递推：推出答案的过程     前提：*****     回溯到一个有具体结果的值，便会开始递推     回溯与递推的条件要有规律     递归的本质：函数的自我调用（自己调自己）     import sys     sys.setrecursionlimit(100)  # 手动设置递归深度     print(sys.getrecursionlimit())  # 默认1000     # 直接调用: 直接调自己         def a():             a()  # 执行函数a         a()  # 执行函数a     # 间接调用： 调用别人，别人最终调回自己         def b():             c()  # 执行函数c         def c():             d()  # 执行函数d         def d():             b()  # 执行函数b         b()  # 执行函数b     递归案例：     # 询问第一个人年龄，回溯条件 小两岁，第五个人说出自己的年龄，推导出第一个人年龄     # 条件：下一个人的年龄比这个人年纪大两岁         def age_get(num):             if num == 1:                 return 58             age = age_get(num - 1) - 2             return age         print(age_get(11))     # 阶乘         def factorial(num):             if num == 1:                 return 1             factorial_num = factorial(num - 1) * num             return factorial_num         print(factorial(6)) 四、匿名函数：没有名字的函数     定义语法：         lambda 参数列表： 一个返回值表达式     没有函数名，没有函数体，只有一个返回值     关键字： lambda | 参数列表省略()     f = lambda x, y: (x +y, x -y)  #想要返回多个值就要括号括起来     print(f)     print(f(10, 20))     应用场景：     1. 匿名函数函数地址可以被一个变量接受，该变量就可以作为函数名来使用     2. 结合内置函数来使用：内置函数某些参数需要一个函数地址，        可以复制一个有名函数名，也可以直接赋值匿名函数     # 内置函数max() 可以设置两个参数，后面一个参数需要是一个函数读内存地址     def fn(arg):         print(arg)         return arg     ls = [100, 200, 50, 10]     res = max(ls, key=fn)  # 函数fn从前面的ls中取值     print('------------------------')     print(res)     res1 = max(ls, key=lambda ele: ele)     # 直接给后面的参数一个匿名函数用来取值     print(res1)