目录：匿名函数，内置函数，递归调用
匿名函数
lambda函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方，执行完就会被回收
常规版本:
def fun(x,y):
return x*y
lambda版本:
f=lambda x,y:x*y print(f(2,6))
示例：
salaries={‘egon‘:5000,‘alex‘:100000,‘wupeiqi‘:10000,‘yuanhao‘:2000}
要求:找出工资最高的人的名字
def func(k):
return salaies[k]
print(max(salaies, key=func))
或
print(max(salaies, key=lambda k:salaries[k]))
要求按照工资大小进行排序：
print(sorted(salaries, key=lambda x:salaries[x])) #默认从小到大
print(sorted(salaries, key=lambda x:salaries[x], reverse=True)) # 从大到小
内置函数：
1,数学运算
abs(),round(),pow(),divmod(),max(),min(),sum()
abs(-1): 绝对值，结果是1
round(3.1415926, 4): 四舍五入，4为保留位数，结果是3.1416
pow(2,3,5): 2表示底数，3表示指数，5表示取模，2^3 % 5 = 余数为3
divmod(9, 2): 9表示被除数，2表示除数，结果是元组形式的商合余数：(4,1)
max(1,2,10,100,98,20): 求最大值
min(1,2,10,100,98,20): 求最小值
sum(2,-5,9,12): 求和
2,工厂函数
int(),float(),str(),bool(),slice(),list(),tuple(),dict(),set(),frozenset()
int(‘5‘): 转换为整数integer
float(2): 转换为浮点数float
str(2.3): 转换为字符串string
bool(0): 转换为布尔值，结果是真还是假,0,‘‘,[],{},(),None均为False
slice(2,6,9):
list(1,2,3): 转换为列表list
tuple([1,2,3]): 转换为元组
dict(a=1,b=‘hello‘,c=[1,2,3]): 转换为字典dict
set(): 转换为集合
forzenset(): 创建不可修改的集合
3,类型类型转换
ord(),chr(),bin(),hex(),oct(),complex()
print(ord(D)):将字母转换为ASCII码表上对应的数字
print(chr(9)):将数字转换为ASCII码表上对应的字母
print(hex(17)):转换为十六进制
print(bin(5)):转换为二进制
print(oct(2)):转换为八进制
#复数,有实部和虚部(不常用)
res=complex(2+8j)
print(res.real)
print(res.imag)
4,序列操作
all(),any(),sorted(),reversed()
all([1,2,3]): 判断是否为True，全部为真，才为真，有一个为假，则为假
any(0,1,None,3):判断是否为真，只要有一个为真，就为真，如果全部为假，则为假
sorted([1,3,2]):从小到大排序
sorted([1,3,2].reverse=True):从大到小排序
reversed(1,3,2):从大到小排序
5,编译执行函数
repr(),compile(),eval(),exec()
repr():返回对象me的字符串表示
print(type(repr(me)))
1,str
compile():解释字符串表达式，参数也可以是compile()返回的code对象
print(compile(‘hello‘, ‘test.py‘))
<code object <module> at 0x0000000000A33540, file "test.py", line 1>
eval():
cmd = ‘print("你瞅啥")‘
eval(cmd) #可将字符串中的命令执行出来
运行结果:
你瞅啥
exec():
exec("print(‘hello‘)")
执行字符串或complie方法编译过的字符串，没有返回值
6,帮助函数
dir(),help(),id(),len(),challables()
v = []
print(dir(v)) # 查看v下面的属性
print(help(v)) # 查看该对象的帮助文档
print(id(v)) # 查看该对象的内存空间地址
print(len(v)) # 返回该对象的长度
print(challables(v)) # 判断该对象是否可被调用,能被调用就是一个challables对象，比如函数和带有__call__的实例
7,作用域查看
globals() #返回一个描述当前全局变量的字典
locals() #打印当前可用的局部变量的字典
vars() #当函数不接收参数时，其功能和locals函数一样，返回当前作用域内的局部变量；
#当接收一个参数时，参数可以是模块，类，类实例,或者定义了__dict__属性的对象
8,迭代器函数
iter(),next(),enumerate(),range()
iter(o[, sentinel])
返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法），参数为整数，从零开始。如果不支持这两种功能，将处罚TypeError异常。如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。
next():返回一个可迭代数据结构中的下一项
enumerate(): 返回一个可以枚举的对象,该对象的next()方法将返回一个元组
x = range(10)
enumerate([1,2,3]).__next__()
range():根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数
9,其他
hash(),filter(),format(),input(),open(),print(),zip(),map(),__import__
hash():哈希值用于快递比价字典的键。
1. 只要校验的内容一致，那hash得到结果永远一样
2. 不可逆
3. 只要采用的哈希算法一样，那无论被校验的内容有多长，hash的到的结果长度都一样
print(hash(‘sjfoiqwwrf‘))
print(hash(‘sjfoiqwwrf‘))
运行结果：
-6140230450656353267
-6140230450656353267
filter():过滤器
和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素
例如：
l=[‘alex_sb‘, ‘wupeiqi_sb‘, ‘yuanhao_sb‘,‘egon‘]
res=filter(lambda x:x.endswith(‘sb‘), l)
print(res)
print(list(res))
运行结果:
[‘alex_sb‘, ‘wupeiqi_sb‘, ‘yuanhao_sb‘]
format():#格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法
‘‘‘
"I am {0}, I like {1}!".format("wang", "moon")
"I am {}, I like {}!".format("wang", "moon")
"I am {name}, I like {msg}!".format(name = "wang", msg ="moon")
‘‘‘
input():#获取用户输入内容
open():打开文件
print():输出函数
zip():拉链函数
zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素按顺序组合成一个tuple，每个tuple中包含的是原有序列中对应序号位置的元素，然后返回由这些tuples组成的list。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。在所有参数长度相同的情况下，zip()与map()类似，没有参数的情况下zip()返回一个空list
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz=zip(x,y,z)
print(list(zip(*xyz)))
运行结果:
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
运行机制：
在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))
所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
map(function, iterable,...)
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回，不会改变原数
例如：
为每个元素加一个‘sb‘字符串
l=[‘alex‘,‘wupeiqi‘,‘yuanhao‘]
res=map(lambda x:x+‘_sb‘, l)
print(res)
print(list(res))
运行结果:
<map object at 0x0000000000830710>
[‘alex_sb‘, ‘wupeiqi_sb‘, ‘yuanhao_sb‘]
获取每个元素的平方
num=[2,4,6,8]
res=map(lambda x:x**2, num)
print(list(res))
运行结果:
[4, 16, 36, 64]
reduce():
reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
例如：
l=[1,2,3,4,5]
print(reduce(lambda x,y:x+y, l, [10])) #[10]是一个初始值，不指定则直接将第一次迭代出来的值作为初始值,指定后，则会将初始值与迭代出来的值做运算
运行结果:
25
它是这样一个过程：每次迭代，将上一次的迭代结果（第一次时为init的元素，如没有init则为seq的第一个元素）与下一个元素一同执行一个二元的func函数。在reduce函数中，init是可选的，如果使用，则作为第一次迭代的第一个元素使用。
10,面向对象使用的内置函数
super(),isinstance(),issubclass(),classmethod(),staticmethod(),proerty(),hasattr(),getattr(),setattr()
super():调用父类的方法
isinstance():检查对象是否是类的对象，返回True或False
issubclass():检查一个类是否是另一个类的子类。返回True或False
classmethod():# 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法
staticmethod
property
delattr():# 删除对象的属性
hasattr
hasattr(object，name)
判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称
>>> hasattr(list, ‘append‘)
True
>>> hasattr(list, ‘add‘)
False
getattr():获取对象的属性
setattr():与getattr()相对应
import time
m=__import__(‘time‘) #以字符串的形式导入模块
m.sleep(3000)
递归调用
在函数调用过程中，直接或间接调用了函数本身，就是函数的递归调用
1，必须有一个明确的结束条件
2，每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3，递归效率不高，递归层次过多会导致栈溢出[在计算机中，函数调用是通过stack栈这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出]
例如:
def f1():
print(‘from f1‘)
f1()
f1()
python不会无限递归，当达到最大递归数时会提示错误并终端递归
RecursionError: maximum recursion depth exceeded while calling a Python object
# 查看递归最大层数
import sys
print(sys.getrecursionlimit())
#设置递归最大层数
print(sys.setrecursionlimit(10000))
典型示例：二分法
在一组数(可能会有成千上万个)中，查找某个数是否存在
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def binary_search(dataset, find_num):
print(dataset)
if len(dataset) > 1:
mid = int(len(dataset) // 2)
if dataset[mid] == find_num: # find it
print("找到数字", dataset[mid])
elif dataset[mid] > find_num: # 找的数在mid左面
print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
return binary_search(dataset[0:mid], find_num)
else: # 找的数在mid右面
print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
return binary_search(dataset[mid + 1:], find_num)
else:
if dataset[0] == find_num: # find it
print("找到数字啦", dataset[0])
else:
print("没的分了,要找的数字[%s]不在列表里" % find_num)
binary_search(data, 66)
运行结果:
[1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
找的数在mid[18]右面
[20, 21, 22, 23, 30, 32, 33, 35]
找的数在mid[30]右面
[32, 33, 35]
找的数在mid[33]右面
[35]
没的分了,要找的数字[66]不在列表里