三元、列表表达式及递归、匿名函数

基础补充:三元运算 | 推导式

# 三元运算符:就是 if...else...语法糖
# 前提:if和else只有一条语句

# 原
# cmd = input('cmd: ')
# if cmd.isdigit():
#     print('可以转化为数字')
# else:
#     print('不可以转化为数字')
# 简化
# cmd = input('cmd: ')
# print('可以转化为数字') if cmd.isdigit() else print('不可以转化为数字')

# 案例:得到两个数大值
a = 20
b = 30
res = a if a > b else b  # 求大值
print(res)

# 三元运算符的结果不一定要与条件直接性关系
res = 'b为小值' if a > b else 'a为小值'  # 求小值
print(res)

# -------------------------------------------------------------------

# 推导式:列表(元组)与字典的转换语法糖
# 列表(元组)推导式
dic = {'a': 1, 'b': 2, 'c': 3}  # => [('a', 1), ('b', 2), ('c', 3)]
res = [(k, v) for k, v in dic.items()]
print(res)
# 元组推导式
# res = ((k, v) for k, v in dic.items())
print(tuple(res))

# 字典推导式
ls = [('a', 1), ('b', 2), ('c', 3)]  # => {'a': 1, 'b': 2, 'c': 3}
res = {k: v for k, v in ls}
print(res)

# 案例
# range(10)  # 可以被推导为列表
res_ls = [arg for arg in range(10)]
print(res_ls)
res_dic = {'a': arg for arg in range(10)}
print(res_dic)

# 迭代出可解压为的单列容器可以推导出字典
res_dic = {v: k for k, v in enumerate('abc')}
print(res_dic)

递归

# 递归:回溯与递推 ***
# 回溯:询问答案的过程
# 递推:推出答案的过程

# 前提:*****
# 回溯到一个有具体结果的值,开始递推
# 回溯与递推的条件要有规律

# 递归本质:函数的自我调用(自己调自己)
import sys
sys.setrecursionlimit(100)  # 手动设置递归深度
print(sys.getrecursionlimit())  # 默认1000

count = 0
自己调自己
def a():
    global count
    count += 1
    if count > 50:
        return
    a()
a()

# 函数间接调用自己:一旦形成循环调用,就产生了递归
def b():
    c()
def c():
    d()
def d():
    b()
b()

递归案例

# 询问第一个人年龄,回溯条件 小两岁,第五个人说出自己的年龄,推导出第一个人年龄
# 条件:下一个人的年龄比这个人年纪大两岁
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 参数列表: 一个返回值表达式

# 匿名函数:没有函数名,没有函数体,只有一个返回值
# 关键字:lambda  |  参数列表省略()  |  返回值return关键字也被省略
f = lambda x, y: (x + y, x - y)
print(f)
print(f(10, 20))

# 应用场景:
# 1.匿名函数函数地址可以被一个变量接受,该变量就可以作为函数名来使用,但就违背了匿名初衷
# 2.结合内置函数来使用: 内置函数某些参数需要一个函数地址,
#       -- 可以赋值一个有名函数名,也可以直接赋值匿名函数

res = max(10, 20, 50, 30)
print(res)
res = max({10, 20, 50, 30})
print(res)

def fn(arg):
    print(arg)
    return arg

ls = [100, 200, 50, 10]
res = max(ls, key=fn)
print('------------------------')
print(res)

res1 = max(ls, key=lambda ele: ele)
print(res1)

内置函数

# max

iterable = [1, 5, 3, 2, 7]
res = max(iterable, key=lambda x: x)  # 参数:可迭代对象遍历的元素;返回值:做比较的值
print(res)

# 薪资最高
iterable = {
    'Bob': 12000,
    'Tom': 37000,
    'Jerry': 76000,
    'Zero': 120,
}
res = max(iterable, key=lambda x: iterable[x])  # x: 字典的k  返回值:做比较的值
print(res)

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 k: iterable[k]['no'])
print(res)
res = max(iterable, key=lambda k: iterable[k]['salary'])
print(res)


# min
iterable = {
    'Bob': [100, 12000],
    'Tom': [200, 37000],
    'Jerry': [50, 76000],
    'Zero': [150, 120],
}
res = min(iterable, key=lambda k: iterable[k][1])  # 薪资最小
print(res)


#  sorted
res = sorted([1, 3, 4, 2, 5], key=lambda x: x, reverse=True)
print(res)

iterable = {
    'Bob': [100, 12000],
    'Tom': [200, 37000],
    'Jerry': [50, 76000],
    'Zero': [150, 120],
}
res = sorted(iterable, key=lambda x: iterable[x][0])  # 按no排序
print(res)


# map:映射
res = map(lambda x: x + 2, [12000, 36000, 27000, 21000, 10000])
print(list(res))

from functools import reduce
# reduce: 合并
res = reduce(lambda f, n: f * n, [1, 2, 3, 4, 5])
print(res)


# 重点:
# classmethod()
# staticmenthod()
# super()
# object()

# 名称空间
# globals()
# locals()

# 反射
# getattr()
# setattr()
# delattr()

# 名称空间 <=> 可执行字符串
# exec()

# enumerate()
# isintance()
# len()
# max()
# min()
# open()
# range()
# type()
print('-----------------------------------')

t = max(iter, fn)  max(iter lambda k: i[k])
    temp = None
    for k in iter:
        res = fn(k)
        # res作为比较的条件
        # temp存放以res比较得到的最大值
    return temp
原文地址:https://www.cnblogs.com/fuwei8086/p/10665322.html