# 原
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 countcount += 1if count > 50:returna()
a()# 函数间接调用自己：一旦形成循环调用，就产生了递归
def b():c()
def c():d()
def d():b()
b()

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

def func():return [lambda x: x * i for i in range(4)]  # [6,6,6,6]  for调用不产生局部名称空间：值产生4个值，没被调用，后一个覆盖前一个，调用的时候只余最后一个值# return [lambda x, i=i: x * i for i in range(4)]  # [0, 2, 4, 6] lambda：函数调用产生局部名称空间# def m(2):
#     return 2 * 0|1|2|3print([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=20  # ①
def aaa(arg=y): # ②print(y)    # 40  ⑤ 调用的永远是调用函数前的最后一个yprint(arg)  # 20  ⑥
y=30
y=40  # ③
aaa() # ④
y=50def fn(x):print(x)return 0res = max([11, 9, 7, 5], key=fn)  # 列表第一个元素不作为函数参数调用函数
print('>>>:', res) #11 ←[11,0,0,0]------------------------------------------------
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)

res = max(10, 20, 50, 30)
print(res)
res = max({10, 20, 50, 30})
print(res)def fn(arg):print(arg)return argls = [100, 200, 50, 10]
res = max(ls, key=fn)
-------------------------------------print(res)res1 = max(ls, key=lambda ele: ele)
print(res1)

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)    # 传入两个值后相乘，返回一个值，与下一个传入的相乘，直到传完最后一个：120# 重点：
# classmethod()
# staticmenthod()
# super()
# object()# 名称空间
# globals()
# locals()# 反射
# getattr()
# setattr()
# delattr()# 名称空间 <=> 可执行字符串
# exec()# enumerate()
# isintance()
# len()
# max()
# min()
# open()
# range()
# type()
---------------------------------------------------------# 运算
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 = 10b = 20print(locals())
a()# hash算法处理
# print(hash([]))  # 可变类型不可hash
# print(hash(()))  # 不可变可以hash
# import uuid
# print(uuid.uuid4())
t = max(iter, fn)  max(iter lambda k: i[k])temp = Nonefor k in iter:res = fn(k)# res作为比较的条件# temp存放以res比较得到的最大值return temp