python内置函数与闭包_python内置函数，闭包

1.内置函数：首先来说，函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能(比如len)给我们封装成了一个一个的函数，供我们使用，他们不仅效率高(底层都是用C语言写的)，而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个

#python 提供了68个内置函数。

#大部分了解即可

#eval 剥去字符串的外衣，运算里面的代码，有返回值

# s1 = '1 + 3'

# print(s1)#1 + 3

# print(eval(s1))#4

#网络传输的str input 输入时，sql注入时绝不能使用eval.

#exec 与eval几乎一样，代码流

# msg = """

# for i in range(10):

# print(i)

# """

# exec(msg)

#hash 哈希值

# print(hash('edhui'))

#help 帮助

# s1 = 'weyui'

# # print(help(str))

# print(help(str.upper))

#callable 函数用于检查一个对象是否是可调用的。

# s1 = 'ed'

# print(callable(s1))

#int：函数用于将一个字符串或数字转换为整型。

#float：函数用于将整数和字符串转换成浮点数。

#bin：将十进制转换成二进制并返回。

#oct：将十进制转化成八进制字符串并返回。

#hex：将十进制转化成十六进制字符串并返回。

#divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

#round：保留浮点数的小数位数，默认保留整数。

#pow：求x**y次幂。(三个参数为x**y的结果对z取余)

#bytes：用于不同编码之间的转化。

#ord:输入字符找该字符编码的位置

#chr:输入位置数字找出其对应的字符

#repr:返回一个对象的string形式(原形毕露)。

#all：可迭代对象中，全都是True才是True

#any：可迭代对象中，有一个True 就是True

2.匿名函数：

语法

函数名 = lambda 参数:返回值

1.此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.

2.lambda 是定义匿名函数的关键字，相当于函数的def.

3.lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。

#匿名函数：一句话函数，比较简单的函数。

# def func(a,b):

# return a + b

# #构建匿名函数

# func1 = lambda a,b:a + b

# print(func1(1,2))

#写匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素(元组形式)。

# func = lambda l1:(l1[0],l1[2])

# print(func([1,2,3,4,5]))

#写匿名函数：接收两个int参数，将较大的数据返回。

# func = lambda a,b:a if a>b else b

# print(func(4,3))

3.重要的内置函数

#list

# l1 = [1,2,3,4]

# l2 = list()

# l2 = list('hduiwe')

# print(l2)

#dict创建字典的几种方式

#直接创建

#利用元组的解构

# dic = dict([(1,'one'),(2,'two'),(3,'three')])

# dic = dict(one=1,two=2)

# print(dic)

#fromkeys

# dic = dict.fromkeys('abcd','太白')

# print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}

#update

# dic = dict()

# dic.update(sex='男', height=175)

# print(dic)

#字典推导式

# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}

# print(dic)

#abs()

# print(abs(-8))

#sum

# l1 = [i for i in range(10)]

# print(sum(l1))

# print(sum(l1,100))#设置初始值100

#reversed将一个序列翻转, 返回翻转序列的迭代器

# l1 = [i for i in range(10)]

# l1.reverse()#对列表的方法

# print(l1)

# l1 = [i for i in range(10)]

# obj = reversed(l1)#返回迭代器

# print(list(obj))

#zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,

#然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，

# l1 = [1,2,3,4,5]

# tu1 = ('太白','wecyu','ww')

# s1 = 'echui'

# obj = zip(l1,tu1,s1)

# print(obj)

# for i in obj:

# print(i)

# print(list(obj))

#min max

# l1 = [1,2,3,4,5,-9,-4,-489,478]

# print(min(l1))

#以绝对值的方式取最小值

# l2 = []

# func = lambda a:abs(a)

# for i in l1:

# l2.append(func(i))

# print(min(l2))

# print(min(l1,key=abs))

#凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中

# dic = {'a':3,'b':2,'c':1}

#求出值最小的键

# print(min(dic))#min默认会按照字典的键去比较大小。

# def func(a):

# return dic[a]

# print(min(dic,key=func))

# print(min(dic,key=lambda a:dic[a]))

# l2 = [('太白',18),('alex',73),('duiwe',76),('yhe',54)]

# print(min(l2))

# print(min(l2,key=lambda x:x[1]))#('太白', 18)

# print(min(l2,key=lambda x:x[1])[1])#18

#max 和min差不多

#sorted

# l1 = [22,33,1,2,8,6,5,7]

# l2 = sorted(l1)

# print(l1)#[22, 33, 1, 2, 8, 6, 5, 7]

# print(l2)#[1, 2, 5, 6, 7, 8, 22, 33]

# l2 = [('太白',18),('alex',73),('duiwe',76),('yhe',54)]

# l3 = sorted(l2,key=lambda x:x[1])

# print(l3)#[('太白', 18), ('yhe', 54), ('alex', 73), ('duiwe', 76)]

#filter 列表推导式的筛选模式

# l1 = [2,3,4,1,7,54,6]

# # print([i for i in l1 if i>3])#[4, 7, 54, 6]#返回一个列表

# ret = filter(lambda x:x>3,l1)#返回一个迭代器

# print(list(ret))#[4, 7, 54, 6]

#map 列表推导式的循环模式

# l1 = [1,4,9,16,25]

# print([i**2 for i in range(1,6)])#[1, 4, 9, 16, 25]

# ret = map(lambda x:x**2,range(1,6))

# print(ret)#返回迭代器

# print(list(ret))#[1, 4, 9, 16, 25]

#reduce

# from functools import reduce

# def func(x,y):

# return x * 10 + y

# # 第一次的时候 x是1 y是2 x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了

# # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了

# # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了

# l = reduce(func,[1,2,3,4])

# print(l)

4.闭包

#封装的东西：保证数据的安全性

# l1 = []

# def make_averager(new_value):

# l1.append(new_value)

# total = sum(l1)

# averager = total/len(l1)

# return averager

# print(make_averager(100000))

# print(make_averager(110000))

# print(make_averager(120000))

# print(make_averager(130000))

#数据安全，l1不能是全局变量

#闭包

# def make_averager():

# l1 = []

# def averager(new_value):

# l1.append(new_value)

# total = sum(l1)

# return total/len(l1)

# return averager

# avg = make_averager()

# print(avg(100000))

# print(avg(110000))

# print(avg(120000))

#闭包：

#闭包只能存在嵌套函数中。

#内层函数对外层函数非全局变量的引用，就会形成闭包

#被引用的非全局变量也称自由变量，这个自由变量就会与内层函数产生一个绑定关系。

#自由变量不会在内存中消失

#闭包的作用：保证数据的安全。

#如何判断一个嵌套函数是不是闭包

#列1

# def wrapper():#是闭包

# a = 1

# def inner():

# print(a)

# return inner

# ret = wrapper()

# #列2

# a = 2#不是闭包

# def wrapper():

# def inner():

# print(a)

# return inner

# ret = wrapper()

# #列3

# def wrapper(a,b):#是闭包

# def inner():

# print(a)

# print(b)

# return inner

# a = 2

# b = 3

# ret = wrapper(a,b)#传进去的值是非全局变量

# def make_averager():

# l1 = []

# def averager(new_value):

# l1.append(new_value)

# total = sum(l1)

# return total/len(l1)

# return averager

# avg = make_averager()

# print(avg.__code__.co_freevars)#('l1',)#查看函数的自由变量