python之内置函数，匿名函数

什么是内置函数？

就是Python给你提供的，拿来直接用的函数，比如print，input等等。其实就是我们在创建.py的时候python解释器所自动生成的内置的函数，就好比我们之前所学的作用空间

内置空间就是python文件在创建的时候python解释器所自动创建的

重要的 内置函数：

***

eval：

eval：执行字符串类型的代码，并返回最终结果。（其实就是对字符串内的类型进行操作 比如你字符串内事int类型的  相加相乘之类的  直接进行操作 如果字符串内事列表或者字典直接把列表字典给原样返还）

print(eval('3+4'))  #
print(eval("{'name':'老南京', 'age':17}")) #{'name':'老南京', 'age':17}
print(eval("['1+3']")) # ['1+3']

exec:执行字符串类型的代码,流程语句。   就是字符串内的该执行的内容给执行出来 （你字符串的只是在里面是一种显示没有执行exec是把它给执行）

ret = '''
li = [1, 2, 3]
for i in li :
    print(i)

'''
exec(ret)  #就是把字符串内的所有该执行的用这个方法在字符串外面给执行了

sum：对可迭代对象进行求和计算（可设置初始值）。 但是最多只能两个元素相加

print(sum([1,2,3,4])) #
print(sum((1,2,3,),100)) #
print(sum({1:2,3:4}))#字典只是把key值给相加

max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）

print(max([1,2,3,4])) #
print(max([1, 2, 3, 4,-9], key=abs)) #-9  abs表示绝对值

min和max所有的使用都一样只不过是返回最小值 两个都是只能对可迭代对象进行使用

print(min((1,2,3,4,5)))
print(min({3:2,4:1}))  #对字典使用只能对字典的key进行比较

reversed：将一个序列翻转，并返回此翻转序列的迭代器。  就是你用reversed在对一个可迭代的队形进行操作的就把它变成了迭代器

ret  =reversed(['a', 'b', 1, 2, 3])
print(ret)
print(ret.__next__())  #因为reversed已经把可迭代的对象给转化为迭代器了所以需要用__next__来取值  

repr:返回一个对象的string形式（原形毕露）。  就是字符串内是什么形式就返还什么形式

print(repr('{"name":"alex"}'))  #字符串内含有的字典给返回出来  因为字典也是放在了字符串内 此时它就是字符串了
print(repr('(1,2,3)'))                                                      

sorted 对所有可迭代的对象进行排序操作。 可加key它和sort相比较就是多加了个key就是可以定义怎么进行翻转

li = [1, -2, -7, 8, 5, -4, 3]
print(sorted(li))          #从小到大排序
print(sorted(li , reverse = True)) #从大到小排序
print(sorted(li, reverse = True, key =abs))      #按照绝对值给排序         

enumerate 枚举 就是返回一个枚举对象 (0, seq[0]), (1, seq[1]), (2, seq[2]),

li = ['老男孩','alex','wusir','嫂子','zhaoyun']  #返回一个枚举对象你一一打印这个枚举对象内的所有值就会出现对应的序列号
for k, v in enumerate(li):  #0 老男孩
    print(k,v)               #1 alex
                             #2 wusir
                             #3 嫂子
                             #4 zhaoyun       

l1 = ('laowang', 'zhangsan',1, 2, 3,4)
for i in enumerate(l1):
    print(i)

zip 拉链方法   就是按照最短的可迭代对象来进行组合这个组合只能是从上到下 并且按照最短的那个迭代对象来组合

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

l1 = [1, 2, 3, 4, 5]
l2 =(5, 6, 7,)
l3 =['laowang', 'sb', 5, 6]
# print(zip(l1, l2, l3))
for i in zip(l1, l2, l3) :       #     (1, 5, 'laowang')
    print(i)                     # (2, 6, 'sb')
                                 # (3, 7, 5)
                                                             

filter：过滤·。（判读条件） 其实就是提供一个场所让你传进俩条件和可迭代对象进行判断  同时也是生成了一个迭代器

def func(x):return x%2 == 0
ret = filter(func,[1, 2, 3, 4, 5, 6, 7])  #func是判断条件 后面是需要判断的内容
print(ret)
for i in ret :
    print(i)                            

map:  （判读条件）会根据提供的函数对指定序列做映射。使用map的同时也是创建了一个迭代器 需要用__next__来取值或者转化为list之类的来取值

def s(x):
    return x**2
ret =map(s, [1,2,3,4,5])
print(ret.__next__())
print(ret.__next__())     

L = [1,2,3]
L = map(str,L) # 把L转化位str类型的生成器
print(L.__next__())

小应用：如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?

L = [1,2,3]
NL = list(map(str,L))
print(NL)

map和fifter都是判读条件但是map不可以删除东西 fifter可以删除里面的元素

匿名函数：

匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。

#这段代码
def calc(n):
    return n**n
print(calc(10))

#换成匿名函数
calc = lambda n:n**n
print(calc(10))

res=map(lambda x,y:x+y,[1, 3, 5, 7, 9],[2,4,6,8])   #就是把两个列表相加一起  但是是一一对应相加
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())        #但是 不能超过那个最少个映射

函数名 = lambda 参数 ：返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

我们可以看出，匿名函数并不是真的不能有名字。

匿名函数的调用和正常的调用也没有什么分别。 就是 函数名(参数) 就可以了～～～

匿名函数与内置函数举例：

res = filter(lambda x: x>10,[5,8,9,11,13])
# for i in res :
#     print(i)
print(res.__next__())
print(res.__next__())