python---函数的应用,闭包,装饰器

# 加载顺序:#         内置名称空间 ---> 全局名称空间(程序运行时)---> 局部名称空间(函数执行时)#     取值顺序:#     局部名称空间(函数执行时)---> 全局名称空间(程序运行时)---> 内置名称空间#         LEGB#     执行顺序:#         当代码运行时,从上至下依次执行。#     函数的嵌套。#     global#     1,声明一个全局变量。#     2,更改一个全局变量。#     nonlocal#     1,不能改变一个全局变量。

# def funcl(*args , **kwargs):#     pass# funcl()

#   *的魔性用法      #运用场景:累加# def funcl (*args,**kwargs):#     for i in args:#         print(i)    # print(args)    # print(*args)    # print(kwargs)    # print(**kwargs)# funcl(*[1,2,3], **{‘name‘:‘alex‘})## def funcl():#     print(666)# def func2():#     funcl()#     print(333)#     def inner():#         print(222)#     inner()# print(111)# func2()# print(555)# 111  666 333 222 555

# 局部名称空间(函数执行时)---> 全局名称空间(程序运行时)---> 内置名称空间# nam=‘老男孩‘# def funcl():#     global name#     name=‘alex‘# funcl()# print(name)

# nam=‘老男孩‘# def funcl():#     global name#     name=‘alex‘#     def funcl3():#         print(name)#     funcl3()# funcl()# print(name)

# def add_b():#     b=42#     def do_global():#         b=10#         print(b)#         def dd_nonlocal():#             nonlocal b#             b=b+20#             print(b)#         dd_nonlocal()#         print(b)#     do_global()#     print(b)# add_b()

#函数名的应用:# 1,直接打印函数名得到的是函数的内存地址 <function func1 at 0x0000000002876B70># print(func1)

#2,函数名可以赋值运算。# def func1():#     print(666)# f1 = func1# f1()# 3, 函数名可以作为函数的参数。

# def func1():#     print(666)## def func2(x):#     x()#     print(555)# func2(func1)

# 4,函数名可以作为容器类数据类型的元素。

# def func1():#     print(666)## def func2():#     print(222)## def func3():#     print(111)## def func4():#     print(777)# l1 = [func1, func2, func3, func4]# for i in l1:#     i()# dic1 = {#     1:func1,#     2:func2,#     3:func3,#     4:func4,# }# dic1[1]()

# #函数名可以当做函数的返回值### def func1():#     print(666)### def func2(x):  # x = func1#     print(222)#     return x# ret = func2(func1)# ret()

#函数闭包

# 内层函数对外层函数非全局变量的引用就叫闭包#判断是不是闭包 函数名.__closure__# 返回的None则不是闭包,返回的是cell.... 则是闭包# 闭包有什么用?#当执行一个函数时,如果解释器判断此函数内部闭包存在,这样#Python就一个机制,闭包的所在的临时名称空间不会随着函数的执行完毕而消失。# def funcl():#     name=‘老男孩‘#     def inner():#         print(name)#     inner()#     print(inner.__closure__) #检测函数是不是闭包(<cell at 0x00000000006F5D68: str object at 0x0000000000E108A0>,)# funcl()## def funcl():#     global name#     name=‘老男孩‘#     def inner():#         print(name)#     inner()#     print(inner.__closure__)#  None    不是闭包# funcl()## def func1(x):#     def inner():#         print(x)#     inner()#     print(inner.__closure__)## name = ‘老男孩‘# func1(name)

# def func():#     def func1():#         name=‘老男孩‘#     def func2():#         nonlocal name#         name=‘alex‘#     def func3():#         global name   #global name 发给改变的只是全局的变量,函数内部的不受它的影响#         name=‘太白‘#     name=‘日天‘#     func1()#     print(name)#     func2()#     print(name)#     func3()#     print(name)# func()# print(name)## from urllib.request import urlopen# def index():#     url=‘http://www.xiaohua100.cn/index.html‘#     def get():#         return urlopen(url).read()#     return get# xiaohua = index()# content = xiaohua()## print(content)### def f1():#     a=0#     def f2():#         nonlocal a#         a += 1#         return a#     return f2## b=f1()# print(b())# print(b())# print(b())

#装饰器

import time# ‘‘‘第一版本,测试函数low‘‘‘# def login():#     time.sleep(0.3)#     print(‘洗洗更健康‘)# def timmer():#     start_time=time.time()#     login()#     end_time=time.time()#     print(‘次函数的执行时间%s‘ % (end_time-start_time))# timmer()

# def login():#     time.sleep(0.3)#     print(‘洗洗更健康...‘)# login()# def register():#     time.sleep(0.4)#     print(‘洗洗更健康222222....‘)# register()# def timmer(f):#     start_time=time.time()#     f()#     end_time=time.time()#     print(‘此函数的执行时间%s‘ % (end_time-start_time))# timmer(login)# timmer(register)

# # 虽然执行函数的方式已经无限接近于原方式,但是更麻烦了,增加了两步代码。改# # def login():# #     time.sleep(0.3)# #     print(‘洗洗更健康...‘)$$$$$$$$$$$$$$$$$$$$$$$$$$$$$# # login()# ## # def timmer(f):# #     start_time = time.time()# #     f()# #     end_time = time.time()# #     print(‘此函数的执行时间%s‘ % (end_time - start_time))# ## # f1 = login  # 将login函数名给了f1# # login = timmer  # 将timmer函数名给了login# login(f1)  # timmer(login)$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

# def login():#     time.sleep(0.3)#     print(‘洗洗更健康...‘)# login()

# def timmer(f):#     start_time = time.time()#     f()#     end_time = time.time()#     print(‘此函数的执行时间%s‘ % (end_time - start_time))## f1 = login  # 将login函数名给了f1# login = timmer  # 将timmer函数名给了login# login(f1)  # timmer(login)

#初级装饰器# def login():#     time.sleep(0.3)#     print(‘洗洗更健康...‘)# # login()# def timmer(f):#     def inner():#         start_time=time.time()#         f()#         end_time=time.time()#         print(‘此函数的执行时间%s‘ % (end_time-start_time))#     return inner# login=timmer(login)# login()

# 简单版装饰器  语法糖# def timmer(f):#     def inner():#         start_time=time.time()#         f()#         end_time=time.time()#         print(‘此函数的执行时间%s‘ % (end_time-start_time))#     return inner# @timmer# def login():#     time.sleep(0.3)#     print(‘洗洗更健康...‘)# login()# @timmer# def register():#     time.sleep(0.2)#     print(‘洗洗更健康22...‘)# login()

# def timmer(f):  # f = login函数名#     def inner():#         start_time = time.time()#         f()  # login()#         end_time = time.time()#         print(‘此函数的执行时间%s‘ % (end_time - start_time))#     return inner## @timmer  # login = timmer(login)  # inner 此login是新变量# def login():#     time.sleep(0.3)#     print(‘洗洗更健康...‘)# login()## @timmer  # register = timmer(register)# def register():#     time.sleep(0.2)#     print(‘洗洗更健康22...‘)## login()  # inner()

#被装饰的函数带参数的装饰器## def timmer(f):#     def inner(*args,**kwargs):#         start_time=time.time()#         f(*args,**kwargs)#         end_time=time.time()#         print(‘此函数的执行时间%s‘ % (end_time-start_time))#     return inner# @timmer# def login(a,b):#     print(a,b)#     time.sleep(0.3)#     print(‘洗洗更健康...‘)# login(2,3)# @timmer# def register(a):#     time.sleep(0.2)#     print(‘洗洗更健康22...‘)# register(1)# def funcl(x):#     x=0#     print(x)# funcl(0)

#函数带返回值的装饰器(万能装饰器)def timmer(f):    def inner(*args,**kwargs):        start_time=time.time()        ret=f(*args,**kwargs)        end_time=time.time()        print(‘此函数的执行时间%s‘ % (end_time-start_time))        return ret    return inner@timmerdef login(a,b):    print(a,b)    time.sleep(0.3)    print(‘洗洗更健康...‘)    return 666print(login(2,3))

# def wrapper(f):#     def inner(*args,**kwargs):#         ‘‘‘执行被装饰函数之前的操作‘‘‘#         ret = f(*args,**kwargs)#         """执行被装饰函数之后的操作"""#         return ret#     return inner

#装饰器功能:在不改变原函数的基础上,为原函数增加一些额外的功能,log,登录注册,等等.

原文地址:https://www.cnblogs.com/weilaixiaochaoren/p/9028390.html

时间: 2024-08-02 04:19:04

python---函数的应用,闭包,装饰器的相关文章

python 函数名 、闭包 装饰器 day13

1,函数名的使用. 函数名是函数的名字,本质就是变量,特殊的变量.函数名()加括号就是执行此函数. 1,单独打印函数名就是此函数的内存地址. def func1(): print(555) print(func1) # <function func1 at 0x0000027B7CF1A048> 2,函数名的赋值 def func(): print(666) f = func print(f()) 3,函数名可以作为容器类数据的元素. def f1(): print(111) def f2()

Python学习(十)—— 装饰器和函数闭包

装饰器 装饰器:本质就是函数,功能是为其他函数添加附加功能 原则: 1.不修改被修饰函数的源代码 2.不修改被修饰函数的调用方式 统计程序运行的时间(不使用装饰器): 这种方法修改了源代码,不能用于已经上线的程序 1 import time 2 def calc(l): 3 res = 0 4 start_time = time.time() 5 for i in l: 6 res += i 7 time.sleep(0.01) 8 stop_time = time.time() 9 print

【Python基础】高阶函数+函数嵌套+闭包 ==装饰器

高阶函数+函数嵌套+闭包 == 装饰器 一 什么是装饰器 二 装饰器需要遵循的原则 三 实现装饰器知识储备 四 高阶函数 五 函数嵌套 六 闭包 七 无参装饰器 八 装饰器应用示例 九 超时装饰器 参考: https://www.cnblogs.com/linhaifeng/articles/6140395.html https://www.cnblogs.com/haiyan123/p/8387769.html 原文地址:https://www.cnblogs.com/XJT2018/p/11

函数对象,函数的嵌套,名称空间与作用域,闭包,装饰器,迭代器,内置函数

一,函数对象 函数对象:函数是第一类对象,即函数可以当做数据传递 1,可以被引用 2,可以做参数的传递 3,返回值可以是函数 4,可以当作容器类型的元素 二,函数嵌套 1,函数的嵌套调用 2,函数的嵌套定义 三,名称空间与作用域 名称空间:存放名字的地方叫名称空间,存放这些值与名字的绑定关系 查看内置名称的两种方法: 三种名称空间 1,内置名称空间:随着python解释器的启动而产生 2,全局名称空间:文件的执行会产生全局名称空间,指的是文件级别定义的名字都会放入该空间 3,局部名称空间:调用函

Python的函数式编程-传入函数、排序算法、函数作为返回值、匿名函数、偏函数、装饰器

函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计.函数就是面向过程的程序设计的基本单元. 传入函数 函数的本身也可以作为参数. Python内建的mapreduce的函数.(来源于谷歌的,后来被道格这家伙开源了,成为当今处理大数据最火热的hadoop中的计算模型---MapReduce) 我们先看map.map()函数接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序

【Python笔记】Python的几个高级语法概念浅析:lambda表达式 &amp;&amp; 闭包 &amp;&amp; 装饰器

本文主要记录自己对几个高级语法概念的理解:匿名函数.lambda表达式.闭包.装饰器. 这几个概念并非Python特有,但本文只限于用Python做说明. 1. 匿名函数 匿名函数(anonymous function)是指未与任何标识符绑定的函数,多用在functional programming languages领域,典型应用场合: 1) 作为参数传给高阶函数(higher-order function ),如python中的built-in函数filter/map/reduce都是典型的

python_day04 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式

本节课重要知识点内容如下: 函数嵌套 名称空间和作用域 闭包 装饰器 迭代器 生成器 列表解析 三元表达式 生成器表达式 1.函数嵌套 函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数 def bar(): print('from nbar')def foo(): print('from foo') bar()foo()def max2(x,y): if x > y: return x else: return ydef max4(a,

闭包函数、无参装饰器2

一.闭包函数 闭包函数:函数内部定义函数,成为内部函数.该内部函数包含对外部作用域,而不是对全局作用域名字的引用,那么该内部函数成为闭包函数. name='alex' #定义全局变量name='alex' def func(): name='egon' #定义局部变量name='egon' def bar(): print(name) return bar #返回bar函数名 b=func() #执行func()结果为bar的函数名 相当于b=bar name='haha' #重新定义全局变量n

Python学习之三大名器-装饰器、迭代器、生成器

Python学习之三大名器-装饰器.迭代器.生成器 一.装饰器     装饰,顾名思义就是在原来的基础上进行美化及完善,器这里指函数,所以说装饰器就是装饰函数,也就是在不改变原来函数的代码及调用方式的前提下对原函数进行功能上的完善.其核心原理其实是利用闭包.     格式 @关键字+装饰函数          被装饰函数()      注意:@行必须顶头写而且是在被装饰函数的正上方     按照形式可以分为:无参装饰器和有参装饰器,有参装饰器即给装饰器加上参数     以下示例是一个无参装饰器,

【函数】04、装饰器

一.高阶函数 python中函数是一等对象(first class):函数也是对象,并且它可以像普通对象一样复制.作为参数.作为返回值. 返回函数或者参数是函数的函数就是高阶函数,也被称为函数式编程 In [23]: def counter(base):     ...:     def inc(x=1):     ...:         nonlocal base     ...:         base += x     ...:         return base     ...: