三元运算符，推导式，匿名与内置函数

一、三元（目）运算符

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


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

3、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

 

6、filter过滤

函数模拟内置函数：