Python——day14 三目运算、推导式、递归、匿名、内置函数

一、三目（元）运算符

定义：就是 if...else...语法糖
前提：简化if...else...结构，且两个分支有且只有一条语句
注：三元运算符的结果不一定要与条件直接性关系
​

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)

案例  求两个数最大值

a=20
b=30

res=a if a>b else b
print(res)
res='b为小值'if a>b else 'a为小值 ' # 求小值
print(res)
三元运算符的结果不一定要与条件有直接性关系
判断大小：不管前面赋值的一个结果，只需要在判断中考虑谁大就输出哪个值：如考虑a大就要将条件写在前面

 

二、推导式

列表推导式：[v for v in iterable]
dic = {'a': 1, 'b': 2, 'c': 3}  # => [('a', 1), ('b', 2), ('c', 3)]
res = [(k, v) for k, v in dic.items()]
字典推导式：{k: v fro k, v in iterable}
ls = [('a', 1), ('b', 2), ('c', 3)]  # => {'a': 1, 'b': 2, 'c': 3}
res = {k: v for k, v in ls}

dic={'a':1,'b':2,'c':3}    # 将字典转换成列表[('a',1),('b',2),('c',3)]

res=[(k,v)for k,v in dic.items()]
print(res)  # 输出结果[('a',1),('b',2),('c',3)]

print('=================================')

元祖推导式

res=((k,v)for k,v in dic.items())
  还可以直接强转为元祖
print(tuple(res))  #输出结果：(('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)  # 输出结果{'a': 1, 'b': 2, 'c': 3}

案例
rang(10)可以推导为列表
res_ls=[arg for arg in range(10)]
print(res_ls) # 输出结果[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
res_dic={'a':arg for arg in range(10)}
print(res_dic)  # 输出结果{'a': 9}
res_dic={arg:'a' for arg in range(10)}
print(res_dic) # 输出结果{0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a', 5: 'a', 6: 'a', 7: 'a', 8: 'a', 9: 'a'}


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

# 输出结果{'a': 0, 'b': 1, 'c': 2}

 

三、递归

递归：就是回溯与递推
前体：要有一个具体结果的值，开始递推
条件：要有规律（是有序的、一致的）
本质：函数的自我调用（自己调自己）

回溯：询问答案的过程
递推：推出答案的过程

import sys
sys.setrecursionlimit(100)  #手动设置递归的深度(没有意义)
print(sys.getrecursionlimit())

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)



阶乘
def factorial(num):
    if num==1:
        return 1
    temp=num*factorial(num-1)#  >>>> 5*4*3*3*1
    return temp
res=factorial(5)
print(res)

# 5 !=5*4! 4！=4*3!......2!=2*1

四、匿名函数

匿名函数：没有名字的函数
没有函数名和函数体，只有一个返回值
关键字  lambda |参数列表省略（）|返回值return关键字也被省略

lambda x,y:x+y
 需要和内置函数结合使用

 有函数名的函数运算
f=lambda  x,y:x+y
print(f)
print(f(10,20)) # 输出30

f=lambda x,y:(x+y,x-y)  # (x+y,x-y)还是代表是输出的是一个值
print(f)
print(f(10,20))  #输出（30  ,-10）

 

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


res=(10,20,50,30)
print(res)

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

print('====================================')
def fn(arg):
    print(arg)
    return  arg
ls =[100,200,50,10]
res=max(ls,key=fn)
print(res)  #  输出：100 200

print('====================================')
res1=max(ls,key=lambda   ele:ele)
print(res1)
# 输出结果200

五、内置函数

# 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('-----------------------------------')

# 运算
print(abs(-1))  # 绝对值
print(pow(2, 3, 3))  # 2 ** 3 % 3
print(sum([1, 2, 3]))  # 求和
print(divmod(100, 30))  # 100与30形成商与余数

# 集合判断操作
print(all([1, 2, 'abc']))  # 元素全真为真
print(any([1, "", None]))  # 元素有真则真
filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])  # 偶数才能通过过滤

# 原义字符串
print(ascii('\n-*..'))
print(repr('\n-*..'))
print(r'\n-*..')

# 进制
print(10)
print(bin(10))
print(oct(10))
print(hex(10))

# 类型转化
bool()
str()
bytes()
chr()
ord()
range(1, 5)  # [1, 2, 3, 4]
'''
def aaa():pass
print(callable(aaa))  # 可调用的

# 可以理解将最外层''去除，形成可执行的对象
s = 'print(123)'
# print(s)
eval(s)
s = '{"a": 1}'
res = eval(s)
print(res['a'])

res = divmod(100, 30)  # 100与30形成商与余数
print(res)

res = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])
print(list(res))

# 格式化
res = format(97, 'b')
print(res)

# 全局名称空间
print(globals())
def a():
    a = 10
    b = 20
    print(locals())
a()


# hash算法处理
# print(hash([]))  # 可变类型不可hash
# print(hash(()))  # 不可变可以hash
# import uuid
# print(uuid.uuid4())


open()
range()

先行了解
t = max(iter, fn)  max(iter lambda k: i[k])
    temp = None
    for k in iter:
        res = fn(k)
        # res作为比较的条件
        # temp存放以res比较得到的最大值
    return temp