基础补充
三元运算符：就是 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)
案例：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|3 print([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 ⑤ 调用的永远是调用函数前的最后一个y print(arg) # 20 ⑥ y=30 y=40 # ③ aaa() # ④ y=50 def fn(x): print(x) return 0 res = 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)
匿名函数
没有名字的函数，
没有函数体，不会单独存在
只有一个返回值，多个加括号
关键字:lambda | 参数列表省略（）| 返回值return关键字也被省略
语法： lambda 参数列表：一个返回值表达式
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(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(' -*..')) print(repr(' -*..')) print(r' -*..') # 进制 print(10) print(bin(10)) # 二进制：0b1010 print(oct(10)) # 八进制：0o12
print(hex(10)) # 十六进制：0xa
# 类型转化 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) # 1100001 # 全局名称空间 print(globals()) def a(): a = 10 b = 20 print(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 = None for k in iter: res = fn(k) # res作为比较的条件 # temp存放与res比较得到的最大值 return temp
python内置函数官网 ： https://docs.python.org/zh-cn/3.7/library/functions.html#all