python四五事_python函数(四)

匿名函数/内置函数/函数闭包/装饰器

匿名函数

匿名函数就是一个句话函数，处理简单逻辑的函数

格式：lambda 参数：返回值

例如：接受一个可切片的数据，返回索引为0与2的对应元素(元祖形式)

func = lambda a:(a[0],a[2])

print(func('alex'))

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

例如2：写匿名函数，接受两个int函数，将较大的数据返回

func1 = lambda a,b:max(a,b)

print(func1(3,4))

print(func1(8,4))

内置函数

红色重点讲解：abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() reversed() set() sorted() sum() tuple() type() zip() dir()

int:函数用于将一个字符串或者数字转换成整数

float :函数用于整数和字符串转换成浮点数

complex: 复数

bin:将十进制转换成二进制并返回

a = 10

ret = bin(a)

print(ret) # 0b1010 二进制中1010代表十进制中的10

oct:将十进制转换成八进制字符串并返回

# oct

# ret = oct(10)

# print(ret) # 0o12 10用八进制代表12

hex:讲十进制转换成十六进制字符串并返回

ret = hex(11)

print(ret) # 0xb 11在十六进制里面就是b

divmod:计算除数与被除数的结果和余数的元祖

ret = divmod(20,3)

print(ret) # (6,2) divmod就是20/3的商和余数组成的元祖，分页的时候用的到

round:保留浮点数的小数位位数，默认保留整数

x = 12.3689878

y = round(x)

print(y) # 12 默认就是取整数位

y1 = round(x,2)

print(y1) # 12.37 round后面的2代表的就是取小数点后2位，并四舍五入

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

x = 2

y = 3

z = 3

ret = pow(x,y,z) # 相当于： ret = (x**y) % z

print(ret) # 2

bytes :把字符串转换成bytes类型

a = "中"

b = bytes(a,encoding='utf-8')

print(b) # b'\xe4\xb8\xad'

ord:输了支付找该字符编码的位置

print(ord('a')) # 97

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

print(chr(20102)) # '了'

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

print(repr('alex')) # 'alex' 在输出台有引号引起来

all:可迭代对象中，有一个True就是True

print(all([1,3,4,0])) # False

print(all([1,3,4])) # True

any:可迭代对象中，有一个人是True，返回的就是True

print(any([1,3,False,[],''])) # True

print(any(['',False,[]])) # False

print：

print(self, *args, sep=' ', end='\n', file=None)

list:

l1 = [1,2,3,4]

l2 = list('adfkskld')

print(l1) # [1, 2, 3, 4]

print(l2) # ['a', 'd', 'f', 'k', 's', 'k', 'l', 'd']

dict:  创建字典和转换成字典

print(dict([('one',1),('two',2),('three',3)])) # {'one': 1, 'two': 2, 'three': 3}

print(dict(one=1,two=2,three=3)) # {'one': 1, 'two': 2, 'three': 3}

dic = dict.fromkeys('123',['one','two','three'])

print(dic)

# {'1': ['one', 'two', 'three'], '2': ['one', 'two', 'three'], '3': ['one', 'two', 'three']}

dic = {}

dic.update([('one',1),('two',2)])

print(dic) # {'one': 1, 'two': 2}

abs: 绝对值

print(abs(-3)) # 3

sum: 求和

l = [2,3,4,7]

print(sum(l)) # 16

reverse ：反转

a = [1,3,7,9]

b = reversed(a)

print(list(b)) # [9, 7, 3, 1]

zip: 拉链方法

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

l2 = ['one','two','three','four','five']

b3 = ['True','False','False','True','False']

print(list(zip(l1,l2,b3)))

# [(1, 'one', 'True'), (2, 'two', 'False'), (3, 'three', 'False'), (4, 'four', 'True'), (5, 'five', 'False')]

min max凡事可以加key的：它会自动的讲可迭代对象中的每个元素按照顺序传入key对应的函数中，

以返回值比较大小print(min(1, 2, -5, 6, -3, key=lambda x: abs(x))) # 1dic = {'a':3,'b':2,'c':1}

# 求出值最小的键

print(min(dic,key=lambda a:dic[a])) # min默认会按照字典的键去比较大小sorted: 排序不是对原数据进行排序，而是形成一个新的列表数据

li = [('alex',100),('wusir',90),('tiabai',98),('yuan',89)]

li_new = sorted(li,key=lambda x:x[1],reverse=True)

print(li_new)

#显示结果： [('alex', 100), ('tiabai', 98), ('wusir', 90), ('yuan', 89)]语法:sorted(iterable,key=None,reverse=False)

iterable : 可迭代对象

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒叙,True 倒叙 False 正序

lst = [1,3,2,5,4]

lst2 = sorted(lst)

print(lst) #原列表不会改变

print(lst2) #返回的新列表是经过排序的

lst3 = sorted(lst,reverse=True)

print(lst3) #倒叙

结果:

[1, 3, 2, 5, 4]

[1, 2, 3, 4, 5]

[5, 4, 3, 2, 1]

字典使用sorted排序

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

print(sorted(dic)) # 字典排序返回的就是排序后的key

结果:

[1,2,3]

和函数组合使用

# 定义一个列表,然后根据一元素的长度排序

lst = ['天龙八部','西游记','红楼梦','三国演义']

# 计算字符串的长度

def func(s):

return len(s)

print(sorted(lst,key=func))

# 结果:

# ['西游记', '红楼梦', '天龙八部', '三国演义']

和lambda组合使用

lst = ['天龙八部','西游记','红楼梦','三国演义']

print(sorted(lst,key=lambda s:len(s)))

结果:

['西游记', '红楼梦', '天龙八部', '三国演义']

lst = [{'id':1,'name':'alex','age':18},

{'id':2,'name':'wusir','age':17},

{'id':3,'name':'taibai','age':16},]

# 按照年龄对学生信息进行排序

print(sorted(lst,key=lambda e:e['age']))

结果:

[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

filter ：类似列表推到式的筛选模式

语法: filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据

iterable:可迭代对象

lst = [{'id':1,'name':'alex','age':18},

{'id':1,'name':'wusir','age':17},

{'id':1,'name':'taibai','age':16},]

ls = filter(lambda e:e['age'] > 16,lst)

print(list(ls))

结果:

[{'id': 1, 'name': 'alex', 'age': 18},

{'id': 1, 'name': 'wusir', 'age': 17}]l1 = [1,3,5,7,9]

ret = filter(lambda x:x>3,l1)

print(list(ret)) # [5, 7, 9]

map: 类似列表中的循环模式

映射函数

语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

计算列表中每个元素的平方,返回新列表

lst = [1,2,3,4,5]

​

def func(s):

​

return s*s

​

mp = map(func,lst)

​

print(mp)

​

print(list(mp))

改写成lambda

lst = [1,2,3,4,5]

​

print(list(map(lambda s:s*s,lst)))

计算两个列表中相同位置的数据的和

lst1 = [1, 2, 3, 4, 5]

​

lst2 = [2, 4, 6, 8, 10]

​

print(list(map(lambda x, y: x+y, lst1, lst2)))

​

结果:

​

[3, 6, 9, 12, 15]

reduce:

from functools import reduce

def func(x,y):

return x + y

​

# reduce 的使用方式:

# reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行

​

ret = reduce(func,[3,4,5,6,7])

print(ret) # 结果 25

reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,

接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始

临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推

​

注意:我们放进去的可迭代对象没有更改

以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到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)

​

​

匿名函数版

l = reduce(lambda x,y:x*10+y,[1,2,3,4])

print(l)

在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入

龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce

最后lambda没删除是因为和一个人写信写了好多封,进行交流然后把lambda保住了.

函数的闭包

闭包的定义：

1. 闭包是嵌套在函数中的函数。

2. 闭包必须是内层函数对外层函数的变量(非全局变量)的引用。

如何判断是不是闭包：

def func1():

a = '123'

def inner():

print(a)

return inner

g = func1()

print(g.__code__.co_freevars) # 如果返回有值就代表是闭包

闭包的作用：保存局部信息不被销毁，保证数据的安全性。

闭包的应用：可以保存一些非全局变量但是不易被销毁、改变的数据。

装饰器。

装饰器# 闭包

闭包的作用：保存局部信息不能销毁，保证数据的安全

闭包的应用：1、可以保存一些非全局变量但是不易被销毁、改变的数据

​ 2、装饰器

# 开放封闭原则

+ 开放：对代码的拓展开放的，更新地图，加新枪，等等。

+ 封闭：对源码的修改是封闭的。闪躲用q,就是一个功能，一个函数，

注意：

+ 装饰器：完全遵循开放封闭原则

+ 装饰器：在不改变原函数的代码以及调用方式的前提下，为其增加新的功能

# 装饰器

目的：不改变原函数的代码和调用方式下给它添加新的功能

装饰器本质上就是一个函数。

###### \# 第一版

import time

def timmer(f):

def inner(*args,**kwargs):

start_time = time.time()

f(*args,**kwargs)

end_time = time.time()

print(f"该函数执行花费{end_time-start_time}s的时间")

return inner

@timmer

def index():

time.sleep(2)

print("这是index函数")

index()

# 显示结果

# 这是index函数

# 该函数执行花费2.000866651535034s的时间

###### \# 第二版

import time

def timmer(f):

def inner(*args,**kwargs):

start_time = time.time()

f(*args,**kwargs)

end_time = time.time()

print(f"该函数执行花费{end_time-start_time}s的时间")

return f(*args,**kwargs)

return inner

@timmer

def index(a):

time.sleep(1)

print("这是index函数")

return a

ret = index(10)

print(ret)

# 显示结果：

# 这是index函数

# 该函数执行花费1.0002458095550537s的时间

# 这是index函数

# 10

# 装饰器的应用

例如1:模拟做网站登陆验证功能，三次输入错误，程序退出

login_info = {

'name':None,

'status':False

}

def auther(f):

def inner(*args,**kwargs):

count = 0

while count < 3:

if login_info['status']:

return f(*args,**kwargs)

else:

username = input('请输入用户名：').strip()

password = input('请输入密码：').strip()

login(username,password)

count += 1

else:

print("三次输入错误，程序退出")

return inner

def login(username,password):

if username == 'alex' and password== '123456':

login_info['name'] = username

login_info['status'] = True

else:

print('用户名或者密码错误！！！')

def register():

pass

@auther

def article():

print("欢迎访问文章页面")

@auther

def drily():

print("欢迎访问日志页面")

article()