三元运算

三元运算符：就是if...else...（语法糖）
前提：if和else只有一条语句
a=10
b=20
if a>b:
    print(a)
else:
    print(b)
a=10
b=20
res=a if a>b else b
print(res)
res=b if a>b else a
print(res)
列表推导式

案例一：
dic1 = {'a': 1, 'b': 2, 'c': 3}
ls1 = []
for k, v in dic1.items():
    ls1.append((k, v))
print(ls1)
res = [(k,v) for k,v in dic1.items()]
print(res)
案例二：
dic2 = {'q': 1, 'w': 2, 'e': 'qwe'}
ls2 = []
for k, v in dic2.items():
    ls2.append((k, v))
print(ls2)
ls2 = [v for v in dic2.values()]
ls2 = [(k, v) for k, v in dic2.items()]
print(ls2)

字典推导式

案例一：
ls3 = [('a', 1),('q', 2),('e', 3)]
dic3 = {}
for k,v in ls3:
    dic3[k]=v
print(dic3)
dic3={k:v for k,v in ls3}
print(dic3)
案例二
ls = [('a', 1), ('b', 2), ('c', 3)]
dic = {}
for k, v in ls:
    k_v = k, v
    dic[k] = v
print(dic)
ls = [('a', 1), ('b', 2), ('c', 3)]
res = {k: v for k, v in ls}
print(res)

递归：回溯与递推
回溯：询问答案的过程
递推：推出答案的过程
前提：1.回溯到一个具体的值，开始递推
2.回溯与递推的条件要有规律
递归的本质：函数的自我调用（自己调用自己） 一旦形成循环就产生了递归
def fn(agr):
　　print(agr)
　　return agr

案例

询问第一个人年龄，回溯条件 小两岁，第五个人说出自己的年龄，推导出第一个人年龄
# 条件：下一个人的年龄比这个人年纪大两岁
def get_age(num):  # 得到年龄
    if num == 1:
        return 58
    age = get_age(num - 1) - 2
    return age
res = get_age(5)
print(res)
# 阶乘
# 5! = 5 * 4!    4! = 4 * 3!   ...   2! = 2 * 1
def factorial(num):
    if num == 1:
        return 1
    temp = num * factorial(num - 1)
    return temp
res = factorial(5)
print(res)

匿名函数：没有名字的函数
lambda x,y:x + y
匿名函数：没有函数名，没有函数体，只有一个返回值
关键字：lambda |参数列表()可以省略  |返回值return关键字也可被省略

f = lambda x,y:(x+y,x-y)
print(f)
print(f(10,20))
res = max(10, 20, 50, 30)
print(res)
res = max({10, 20, 50, 30})
print(res)
应用场景：
1：匿名函数地址可以被一个变量接受，该变量就可以作为函数来使用，
但就违背了匿名的初衷
2,：结合内置函数来使用：内置函数某些参数就需要一个函数地址
ls = [100, 23, 10, 200]
res = max(ls, key=fn)
print(res)
res1 = max(ls, key=lambda ele: ele)
print(res1)

三元表达式
结果1 if 条件 else 结果2

列表推导式
[列表元素 for v in iterable]

字典推导式
{字典元素 for k, v in iterable}

递归：函数的自调用
直接自调用：自己调自己
间接自调用：自己调别人，别人再调回自己

回溯(回溯条件) => 递推(递推开始，回溯的结束点)
def get_age(num):
    if num == 1:
        return 18
    age = get_age(num - 1) - 2

age = get_age(5)

匿名函数：
lambda 形参们: 返回值
1. 用变量接收
2. 结合内置函数使用


内置函数：
max
'''


def func():
    return [lambda x: x * i for i in range(4)]  # [6, 6, 6, 6]
    # return [lambda x, i=i: x * i for i in range(4)]  # [0, 2, 4, 6]

# def m(2):
#     return 2 * 0|1|2|3

print([m(2) for m in func()])
# 1.func()执行结果为list，所以被迭代
# 2.for i in range(4)能产生4次结果，所以func()的返回值list有四个元素
# 3.最终打印的列表推导式也有四个元素
# 4.func()返回值list中存放的是四个函数地址，匿名函数体没有被执行
# 5.m(2)时，匿名函数体才被调用，但四个匿名函数都已形成，再去获得i的值，i存放的是最后一次值3

# 理解案例
y = 10
def aaa(arg=y):
    print(y)
    print(arg)
y = 20
y = 30
y = 40
aaa()

print('------------------------------------------------')
def fn(x):
    print(x)
    return x
res = max([1, 5, 3, 2, 4], key=fn)
print('>>>', res)

dic = {'a': 100, 'b': 10}
res = max(dic, key=lambda k: dic[k])
print('>>>', res)