函数名的应用(第一对象) 闭包 装饰器

函数名的应用(第一对象)。
# 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]()


 
# 5,函数名可以当做函数的返回值

  运行流程为再给ret赋值操作时调用了一次func2函数,并把func1函数名赋值给x,此时print 222,并且返回x也就是返回func1,此时:x = func1 = ret,然后执行ret()打印666。

或者写成:

输出结果一样,x = func1 ,x() = func1()

03,闭包。
# 内层函数对外层函数非全局变量的引用就叫闭包#判断是不是闭包 函数名.__closure__# 返回的None则不是闭包,返回的是cell.... 则是闭包# 闭包有什么用?#当执行一个函数时,如果解释器判断此函数内部闭包存在,这样#Python就一个机制,闭包的所在的临时名称空间不会随着函数的执行完毕而消失。

  关于输出结果:函数内的print打印的都是函数内的name,函数内的name的初始值为sky,在func2的nonlocal name 修改为alex。函数外的print打印的为全局变量,被func3修改后的wit。

from urllib.request import urlopen

def index():
    url = ‘http://www.xiaohua100.cn/index.html‘
    def get():
        return urlopen(url).read()
    return get

scf = index()
content = scf()
print(content)

等于 content = index()()

  print(content)

04,装饰器。

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


测试程序的效率 
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(‘洗洗更健康22222...‘)
# # 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):  # f = login函数名
#
#     def inner():
#         start_time = time.time()
#         f()  # login()
#         end_time = time.time()
#         print(‘此函数的执行时间%s‘ % (end_time - start_time))
#     return inner
#
# login = timmer(login)  # inner 此login是新变量
# login()  # inner()
# 简单版装饰器  语法糖
# 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...‘)



原文地址:https://www.cnblogs.com/wenxingxu/p/9529540.html

时间: 2024-08-28 23:59:05

函数名的应用(第一对象) 闭包 装饰器的相关文章

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,

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()

函数名的运用(第一类对象)以及闭包与迭代器

一.函数名的应用(第一类对象) 1.函数的命名规范和变量是一样的,函数名其实就是变量名. 2.函数名的内存地址 def func(): print("呵呵" print(func) 结果: <function func at 0x1101e4ea0> 3.函数名可以赋值给其他变量 def func(): print("呵呵") print(func) a = func # 把函数当成一个变量赋值给另一个变量 a() # 函数调用 func() 结果: &

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

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

十、闭包函数、函数对象、装饰器

函数对象: 函数是第一类对象 第一类对象: 指可以在执行期创造并作为参数传递给其他函数或存入一个变量的实体 第一类对象所特有的特性为: 可以当容器被存入变量或其他结构 可以被作为参数传递给其他函数 可以被作为函数的返回值 可以在执行期创造,而无需完全在设计期全部写出 即使没有被系结至某一名称,也可以存在 函数.类.模块等所有对象都是第一类的 闭包函数: 函数内定义的函数为内部函数 内部函数包含对外部作用域而非全局作用域的引用 定义闭包函数的基本形式: def 外部函数名(): 内部函数需要的变量

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

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

Python 函数名,可迭代对象及迭代器

函数名是什么?1,函数名就是函数的内存地址a = 2b = ac = bprint(c)2,函数名可以作为变量.def func1(): print(666)f1 = func1()f2 = f1print(f2)3,函数名可以作为函数的参数.def func1(): print(666)def func2(x): print(x) x()print(func1)函数名可以当做函数的返回值.def wapper(): def inner(): print('inner') return inne

D20-05 函数闭包 装饰器 06 ..解压序列

框架 #装饰器的框架 import time def timmer(func): #func=test def wrapper(): start_time=time.time() func() #就是在运行test stop_time=time.time() print('运行时间是%s'%(start_time-stop_time)) return wrapper def test(): time.sleep(3) print('test函数运行完毕') test = timmer(test)

【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都是典型的