递归、匿名函数、内置函数

三目运算符

# 三目(元)运算符：就是 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)

 

推导式

# 列表推导式：[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}
​

 

递归

# ***
# 递归：回溯与递推 
# 回溯：询问答案的过程
# 递推：推出答案的过程
​
# 本质：函数的自我调用
# 直接：自己调自己
# 间接：自己调别人，别人最终由调回自己
​

 

匿名函数

# 匿名函数：没有名字的函数
# 语法：lambda 参数列表: 一个返回值表达式
​
# 重点：
# 1.匿名函数：没有函数名，没有函数体，只有一个返回值
# 2.关键字：lambda  |  参数列表省略()  |  返回值return关键字也被省略
​
# 应用场景：
# 1.匿名函数函数地址可以被一个变量接受，该变量就可以作为函数名来使用，但就违背了匿名初衷
# 2.结合内置函数来使用: 内置函数某些参数需要一个函数地址，
#       -- 可以赋值一个有名函数名，也可以直接赋值匿名函数

 

内置函数

https://docs.python.org/zh-cn/3.7/library/functions.html#all
以下举部分内置函数例子：

# 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 （这里提一下sort方法，调用之后直接改变原迭代对象的值，而且没有返回值，以列表L=[1,3,2]为例，L.sort() 就行了，如果s = L.sort()，那么s值为None）
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(' -*..'))
print(repr(' -*..'))
print(r' -*..')

# 进制
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())

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