一、三元（目）运算符
1、就是if...else...语法糖
前提：if和else只有一条语句
# 原来的做法
cmd = input('cmd:>>>')
if cmd.isdigit():
print('可以转化为数字')
else:
print('不可以转化为数字')
# 现在的做法
cmd = input('cnd:>>>')
print('可以转化为数字') if cmd.isdigit() else print('不可以转化为数字')
# 案例：得到两个数大值
a = 1000
b = 200
res = a if a > b else b # 求大值
print(res)
# 三元运算符的结果不一定要与条件直接性关系
res = b if a > b else a # 求小值
print(res)2、推导式：列表(元组)与字典的转换语法糖
# 列表(元组)推导式
dic = {'a': 100, 'b': 200, 'c': 300} # > [('a', 100), ('b', 200), ('c', 300)]
res = [(k, v) for k, v in dic.items()]
print(res) # 结果为 [('a', 100), ('b', 200), ('c', 300)] # 字典推导式
ls = [('a', 100), ('b', 200), ('c', 300)] # > {'a': 100, 'b': 200, 'c': 300}
res = {k: v for k, v in ls}
print(res) # 结果为 {'a': 100, 'b': 200, 'c': 300}
3、案例
# range(10) 可以被推倒为列表 res= [arg for arg in range(10)]
print(res) # 结果为 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] dic = {arg: 'a' for arg in range(10)}
print(dic) # 迭代出可解压为的单列容器可以推导出字典
res = {k: v for k, v in enumerate('abcd')}
print(res) # 结果为 {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
二、递归
1、定义：回溯与递推
回溯：询问答案的过程
递推：推出答案的过程
2、前提：
回溯到一个有具体结果的值，开始递推
回溯与递推的条件要有规律
3、递归本质：函数的自我调用（自己调自己）
count = 0
def fn():
global count
count += 1
if count > 10:
return
fn()
fn() # 函数间接调用自己：一旦产生了循环调用，就产生了递归
def a():
b()
def b():
c()
def c():
a()
a()
4、案例
# 询问第一个人年龄，回溯条件 小两岁，第五个人说出自己的年龄，推导出第一个人年龄
# 条件：下一个人的年龄比这个人年纪大两岁
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)
三、匿名函数
1、定义：没有函数名，没有函数体，只有一个返回值的函数
2、语法 lambda 参数列表 ：一个返回值表达式
3、关键字：lambda | 参数列表省略() | 返回值return关键字也被省略
res = lambda x, y: x + y
print(res) # 结果为 <function <lambda> at 0x0000000002051E18>
print(res(100, 200)) # 结果为 300
4、应用场景
匿名函数函数地址可以用一个变量接收，该变量就可以作为函数名来使用，但就违背了匿名初衷
结合内置函数来使用：内置函数某些参数需要一个函数地址。可以赋值一个有名函数名，也可以直接赋值匿名函数
res = max(100, 200, 500, 800)
print(res) # 结果为 800 res = max({100, 200, 500, 800})
print(res) # 结果为 800
def fn(arg):
print(arg)
return arg
ls = [100, 500, 400, 600, 300]
res = max(ls, key=fn)
print(res) ls = [100, 500, 400, 600, 300]
res1 = max(ls, key=lambda ele:ele)
print(res1) # 结果为 600
四、内置函数
1、max
iterable = [100, 200, 300, 500, 400]
res = max(iterable, key=lambda x: x)
print(res) # iterable = {
'bob':25000,
'jerry':360000,
'tom':4500,
'judy':10000
}
res = max(iterable, key=lambda x: iterable[x]) # x: 字典的k 返回值：做比较的值
print(res) # jerry iterable = {
'Bob': {'no': 100, 'salary': 12000},
'Tom': {'no': 200, 'salary': 37000},
'Jerry': {'no': 50, 'salary': 76000},
'Zero': {'no': 150, 'salary': 120},
}
res = max(iterable, key=lambda x: iterable[x]['no']) # 编号最大
print(res) # Tom res = max(iterable, key=lambda x: iterable[x]['salary']) # 薪资最高
print(res) # Jerry
2、min
iterable = {
'Bob': [100, 12000],
'Tom': [200, 37000],
'Jerry': [50, 76000],
'Zero': [150, 120],
}
res = min(iterable, key=lambda x: iterable[x][1]) # 薪资最低
print(res) # Zero3、sorted
res = sorted([300, 200, 800, 1000, 600], key=lambda x: x)
print(res) # [200, 300, 600, 800, 1000]
res = sorted([300, 200, 800, 1000, 600], key=lambda x: x, reverse=True)
print(res) # [1000, 800, 600, 300, 200] iterable = {
'Bob': [100, 12000],
'Tom': [200, 37000],
'Jerry': [50, 76000],
'Zero': [150, 120],
}
res = sorted(iterable, key=lambda x: iterable[x][1]) # 按薪资排序由小到大
print(res) # ['Zero', 'Bob', 'Tom', 'Jerry']
4、map映射
res = map(lambda x: x+100, [10000, 20000, 30000, 40000])
print(list(res)) # [10100, 20100, 30100, 40100]
5、reduce合并
from functools import reduce
res = reduce(lambda f, n: f*n, [1, 2, 3, 4, 5])
print(res) # 结果为 120