13-0-内置函数二
一. 匿名函数
匿名函数,顾名思义就是没有名字的函数,那么什么函数没有名字呢?这个就是我们以后面试或者工作中经常用匿名函数 lambda,也叫一句话函数。
现在有一个需求:你们写一个函数,此函数接收两个int参数,返回和值。
def func(a,b):
return a+b
print(func(3,4))
那么接下来我们用匿名函数完成上面的需求:
func = lambda a,b: a+b
print(func(3, 4)) # 7
我们分析一下上面的代码:
语法:
函数名 = lambda 参数:返回值
1)此函数不是没有名字,他是有名字的,他的名字就叫做lambda
2)lambda 是定义匿名函数的关键字,相当于函数的def.
3)lambda 后面直接加形参,形参加多少都可以,只要用逗号隔开就行。
func = lambda a,b,*args,sex= 'alex',c,**kwargs: kwargs
print(func(3, 4,c=666,name='alex')) # {'name': 'alex'}
# 所有类型的形参都可以加,但是一般使用匿名函数只是加位置参数,其他的用不到。
4)返回值在冒号之后设置,返回值和正常的函数一样,可以是任意数据类型。(但是想要返回多个元素要以容器的形式返回)
5)匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据
接下来做几个匿名函数的小题:
写匿名函数:接收一个可切片的数据,返回索引为0与2的对应的元素(元组形式)。
func = lambda x:(x[0],x[2])
print(func('afafasd'))
写匿名函数:接收两个int参数,将较大的数据返回。
func = lambda x,y: x if x > y else y
print(func(3,100))
二. 内置函数Ⅱ
**红色重点讲解**:enumerate() open() range() len() str() list() tuple() dict() set() print() sum() abs() dir() zip() format() reversed() filter() map() sorted() max() min() reduce() |
昨天,我们已经比较重要的内置函数讲完了,那么今天我们要讲的是最重要的内置函数和高阶函数,这些内置函数是面试与工作中经常用到的,所以,今天的这些内置函数,我们一定要全部记住,并且熟练使用。
内置函数:
str() 将字节转换成字符串
1 | byte_str = bytes("你好",encoding="utf") |
list() 将可迭代对象转换成列表
1 | print(list("alex")) |
tuple() 将可迭代对象转换成元组
1 | print(tuple([1,2,3,4])) |
dict() 将元组和列表转换成字典
1 | print(dict([(1,2),(3,4)])) |
set() 将可迭代对象转换成一个集合
1 | print(set("alex")) |
print() 屏幕输出。
1 | ''' 源码分析 |
sum() 求和
sum求和必须是可迭代对象,对象中的元素必须都为整型,字符串类型不能使用
1 | print(sum([1,2,3])) |
abs() 返回绝对值
1 | i = -5 |
dir() 查看当前对象具有什么方法
1 | print(dir(list)) |
**zip() 拉链方法。**函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,
然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回,
1 | lst1 = [1,2,3] |
format() 格式转换
1 | # 对齐方式: |
reversed() 将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:
1 | l = reversed('你好') # l 获取到的是一个生成器 |
高阶函数:
filter筛选过滤
1 | 语法: filter(function,iterable) |
map映射
1 | 映射函数 |
sorted排序函数
1 | 语法:sorted(iterable,key=None,reverse=False) |
max() 最大值与最小值用法相同
min() 求最小值
1 | print(min([1,2,3])) # 返回此序列最小值 |
reduce 累计算
1 | from functools import reduce |
参考资料:
https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac
三.闭包
由于闭包这个概念比较难以理解,尤其是初学者来说,相对难以掌握,所以我们通过示例去理解学习闭包。
给大家提个需求,然后用函数去实现:完成一个计算不断增加的系列值的平均值的需求。
例如:整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢?就是从这个商品一出现开始,每天记录当天价格,然后计算他的平均值:平均值要考虑直至目前为止所有的价格。
比如大众推出了一款新车:小白轿车。
第一天价格为:100000元,平均收盘价:100000元
第二天价格为:110000元,平均收盘价:(100000 + 110000)/2 元
第三天价格为:120000元,平均收盘价:(100000 + 110000 + 120000)/3 元
………
series = []
def make_averager(new_value):
series.append(new_value)
total = sum(series)
return total / len(series)
print(make_averager(100000))
print(make_averager(110000))
print(make_averager(120000))
从上面的例子可以看出,基本上完成了我们的要求,但是这个代码相对来说是不安全的,因为你的这个series列表是一个全局变量,只要是全局作用域的任何地方,都可能对这个列表进行改变。
series = []
def make_averager(new_value):
series.append(new_value)
total = sum(series)
return total / len(series)
print(make_averager(100000))
print(make_averager(110000))
series.append(666) # 如果对数据进行相应改变,那么你的平均收盘价就会出现很大的问题。
print(make_averager(120000))
那么怎么办呢?有人说,你把他放在函数中不就行了,这样不就是局部变量了么?数据不就相对安全了么?
def make_averager(new_value):
series = []
series.append(new_value)
total = sum(series)
return total / len(series)
print(make_averager(100000)) # 100000.0
print(make_averager(110000)) # 110000.0
print(make_averager(120000)) # 120000.0
这样计算的结果是不正确的,那是因为执行函数,会开启一个临时的名称空间,随着函数的结束而消失,所以你每次执行函数的时候,都是重新创建这个列表,那么这怎么做呢?这种情况下,就需要用到我们要讲的闭包了,那什么是闭包呢?
在嵌套函数中使用外部非全局变量就是闭包
我们用闭包的思想改一下这个代码。
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
print(avg(100000))
print(avg(110000))
print(avg(120000))
大家仔细看一下这个代码,我是在函数中嵌套了一个函数。那么avg 这个变量接收的实际是averager函数名,也就是其对应的内存地址,我执行了三次avg 也就是执行了三次averager这个函数。那么此时你们有什么问题?
肯定有学生就会问,那么我的make_averager这个函数只是执行了一次,为什么series这个列表没有消失?反而还可以被调用三次呢?这个就是最关键的地方,也是闭包的精华所在。我给大家说一下这个原理,以图为证:
上面被红色方框框起来的区域就是闭包,被蓝色圈起来的那个变量应该是make_averager()函数的局部变量,它应该是随着make_averager()函数的执行结束之后而消失。但是他没有,是因为此区域形成了闭包,series变量就变成了一个叫自由变量的东西,averager函数的作用域会延伸到包含自由变量series的绑定。也就是说,每次我调用avg对应的averager函数 时,都可以引用到这个自用变量series,这个就是闭包。
闭包的定义:
-
闭包是嵌套在函数中的函数。
-
闭包必须是内层函数对外层函数的变量(非全局变量)的引用。
如何判断判断闭包?举例让同学回答:
# 例一:
def wrapper():
a = 1
def inner():
print(a)
return inner
ret = wrapper()
# 例二:
a = 2
def wrapper():
def inner():
print(a)
return inner
ret = wrapper()
# 例三:
def wrapper(a,b):
def inner():
print(a)
print(b)
return inner
a = 2
b = 3
ret = wrapper(a,b)
以上三个例子,最难判断的是第三个,其实第三个也是闭包,如果我们每次去研究代码判断其是不是闭包,有一些不科学,或者过于麻烦了,那么有一些函数的属性是可以获取到此函数是否拥有自由变量的,如果此函数拥有自由变量,那么就可以侧面证明其是否是闭包函数了(了解):
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
# 函数名.__code__.co_freevars 查看函数的自由变量
print(avg.__code__.co_freevars) # ('series',)
当然还有一些参数,仅供了解:
# 函数名.__code__.co_freevars 查看函数的自由变量
print(avg.__code__.co_freevars) # ('series',)
# 函数名.__code__.co_varnames 查看函数的局部变量
print(avg.__code__.co_varnames) # ('new_value', 'total')
# 函数名.__closure__ 获取具体的自由变量对象,也就是cell对象。
# (<cell at 0x0000020070CB7618: int object at 0x000000005CA08090>,)
# cell_contents 自由变量具体的值
print(avg.__closure__[0].cell_contents) # []
闭包的作用:保存局部信息不被销毁,保证数据的安全性。
闭包的应用:
- 可以保存一些非全局变量但是不易被销毁、改变的数据。
- 装饰器。