Python基础globlal nonlocal和闭包函数装饰器语法糖

目录
  • 一、global与nonlocal
    • 1、global
    • 2、nonlocal
  • 二、函数名的多种用法
  • 三、闭包函数
    • 1、什么是闭包函数
    • 2、闭包函数需满足的条件
    • 3、闭包函数的作用
    • 4、闭包函数的实际应用
  • 四、装饰器
    • 1、装饰器推导流程
    • 2、装饰器语法糖
    • 3、装饰器模板

一、global与nonlocal

1、global

  • 在py文件中,一般无法调用函数体内变量名,而global可使函数体代码内的变量名直接在函数体外部调用,条件是在需要调用的代码体中使用global 调用需要的变量名

未使用global情况:

# 在外部绑定一个变量名
name = 'kangkng'
# 定义一个函数体代码
def func():
    # 函数体内部重新绑定一个变量名
    name = 'zhangzhang'
# 调用函数func
func()
# 这时无法打印函数体内部的变量名
print(name)
------------------------------------------------------------------------ kangkang

使用global情况:

# 在函数体内部使用global时,可在外部直接调用函数内部变量名
name = 'kangkng'
# 定义一个函数体代码
def func():
    # 使用global调用变量名
    global name
    # 函数体内部重新绑定一个变量名
    name = 'zhangzhang'
# 调用函数func
func()
# 外py中打印name
print(name)
------------------------------------------------------------------------
zhangzhang

2、nonlocal

  • 在函数嵌套使用时,通常在父代码体中无法调用子代码中变量名,

而nonlocal的作用是,可以在父代码中直接调用子代码中的变量名,条件是需要在子代码中使用nonlocal 调用需要的变量名

未使用nonlocal情况:

# 定义一个函数体代码
def outer():
    # 绑定一个变量名
    name = 'kangkang'
    # 代码体内部再次定义一段函数体
    def subcoat():
        # 内层中绑定变量名
        name = 'zhangzhang'
    # 在函数外层打印变量名
    print(name)
# 调用外层函数体代码
outer()
-----------------------------------------------------------------------
kangkang

使用nonlocal情况:

# 在函数体内部使用global时,可在外部直接调用函数内部变量名
def outer():
    # 函数外层绑定一个变量名
    name = 'kangkang'
    # 代码体内部再次定义一段函数体
    def subcoat():
        # 在函数体内层使用nonlocal,调用变量名
        nonlocal name
        # 内层中绑定变量名
        name = 'zhangzhang'
    # 调用内层函数
    subcoat()
    # 在函数外层打印变量名
    print(name)
# 调用外层函数体代码
outer()
----------------------------------------------------------------------
zhangzhang

二、函数名的多种用法

引言:

​ 函数名就相当于变量名,只不过函数名绑定的是一段函数体代码,在我们使用这个函数名加括号时就可以调用这段代码体,具体由以下几种用法:

1、当做变量名赋值

def func():
    print('我是func函数体代码')
res = func
print(res())
------------------------------------------------------------------------
我是func函数体代码
None

2、当作函数的参数

def func():
    print('我是func函数体代码')
def func1(a):
    print('我是func1函数体代码', a)
    a()
func1(func)
------------------------------------------------------------------------
我是func1函数体代码 <function func at 0x000001D0C14D6310>
我是func函数体代码

3、当作函数的返回值

def func():
    print('我是func函数体代码')
def func1():
    print('我是func1函数体代码')
    return func
res = func1()
print(res)
res()
------------------------------------------------------------------------
我是func1函数体代码
<function func at 0x00000218F95B6310>
我是func函数体代码

4、当作容器类型的数据

def spring():
    print('我是春季,生机盎然')
def summer():
    print('我是夏季,活力四射')
def autumn():
    print('我是秋季,翩翩起舞')
def winter():
    print('我是冬季,大雪纷飞')
while True:
    season_dict = { '1': spring,
               '2': summer,
               '3': autumn,
               '4': winter
                   }
    season_select = input('根据编号,选择您喜欢的季节>>>:').strip()
    if season_select in season_dict:
        season_dict.get(season_select)()
    else:
        print('你选择的编号不存在')
------------------------------------------------------------------------

三、闭包函数

1、什么是闭包函数

一个函数的返回值是另外一个函数,返回的函数调用父函数内部的变量,如果返回的函数在外部被执行,就产生了闭包

2、闭包函数需满足的条件

满足以下两个条件的就是闭包函数:

条件一:定义在函数内部的函数

条件二:用到了外部函数空间名称中的名子

3、闭包函数的作用

作用:使函数外部能够调用函数内部放入属性和方法

缺点:闭包操作导致整个函数的内部环境被长久保存,占用大量内存

4、闭包函数的实际应用

1.函数内部变量名在外部被访问

def fun1():
    name = 'python'
    def inner():
        print(name)
    return inner
result = fun1()
result()
------------------------------------------------------------------------
python

2.函数体内部函数体代码可以通过外部访问

def fun2():
    def inner():
        print("执行了内部函数inner")
    def all():
        return inner
    return all
result = fun2()
result()()
------------------------------------------------------------------------
执行了内部函数inner

四、装饰器

​ 当我们需要将一段函数体代码在不改变调用方式和源代码的情况下,需要给这个段代码添加新的功能时,这时候我们就需要给这段代码安装一个装饰器,装饰器是指将这段代码封装在闭包函数内,来达到既能满足上述条件,又能增加新的功能的条件

概念

  • 在不修改被装饰对象源代码和调用方式的情况下给被装饰的对象添加新的功能

本质

  • 并不是一门新的技术,而是由函数参数、名称空间、函数名多种用法、闭包函数组合到一起的效果

口诀

  • 对修改封闭,对扩展开放

1、装饰器推导流程

1、首先定义一段函数体代码,当我们给这段函数传入指定的参数时,他就会暂停一秒,然后运行,使它在运行结束后,能够统计它的运行时间

import time
def index(a, b):
    time.sleep(1)
    print(index,a, b)

2、通常,我们只需要在这段代码运行前打印一个时间戳,运行后再次打印一个时间戳,在这段代码运行结束后通过前后时间的插值就能统计出这段代码的运行时间,但这种办法使用起来比较麻烦且只能使用一次

方法一:
    import time
    def index(a, b):
        start = time.time()
        time.sleep(1)
        print(index, a, b)
        end = time.time()
        print(end - start)
    index(1,2)
方式二:
    import time
    def index(a, b):
        time.sleep(1)
        print(index, a, b)
    start = time.time()
    index(1,2)
    end = time.time()
    print(end - start)

3、通过上述方法的方式二,我们可以得出将函数名包裹在统计时间功能代码内,这样在调用时相对便捷,进一步思考,若将这段代码使用函数封包,那样在调用时就可以更为便捷,在以后统计该代码时,只需要调用封包这段代码的函数名就可以直接统计这段代码的运行时间

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def time_():
    start = time.time()
    index()
    end = time.time()
    print(end - start)
time_()
------------------------------------------------------------------------
Traceback (most recent call last):
  File "D:/pytcharm项目文件路径/38/11.py", line 297, in <module>
    time_()
  File "D:/pytcharm项目文件路径/38/11.py", line 293, in time_
    index()
TypeError: index() missing 2 required positional arguments: 'a' and 'b'

4、虽然这种方式可以行得通,但只能针对没有参数的函数体代码,若这段代码需要传参者无法运行,并直接报错。再次进一步思考,只需要将封包的这段函数设置为有参函数就可解决这个问题

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def core(a,b):
    start = time.time()
    index(a, b)
    end = time.time()
    print(end - start)
core(1, 2)
------------------------------------------------------------------------
<function index at 0x000001F4A0026310> 1 2
1.0047826766967773

5、由上推导可看出,虽然此功能可以更为便捷的统计代码执行时间,但若是源代码的参数需要修改则封包它的参数也需要修改,这时我们可联想到将参数修改为可变长参数,就不会出现这个问题

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def core(*args,**kwargs):
    start = time.time()
    index(*args, **kwargs)
    end = time.time()
    print(end - start)
core(1,2)
------------------------------------------------------------------------
<function index at 0x000002ECDD4E6310> 1 2
1.004744529724121

6、这样无论源代码参数如何修改,我们都可以进行传参,虽然这个问题解决了,但考虑使用的广泛性,若有其他函数体也需要用到这个功能时,还需要重新修改封包内代码,这时,我们可以使用闭包的方式来满足这个条件

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def func(x, y, z):
    time.sleep(2)
    print(func, x, y, z)
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        index(*args, **kwargs)
        end = time.time()
        print(end - start)
    return core
res = outer(func)
res(1, 2, 3)
------------------------------------------------------------------------
<function func at 0x0000018C23686670> 1 2 3
2.00856614112854

7、通过将源代码函数名放至闭包函数参数内,就可以达到可以调动任何函数体代码都可以执行此功能的方法,但并未满足闭包函数的条件,源代码的调用方式改变了,这时我们可以通过将原函数体代码赋值的方式来达到调用方式和源代码都未改变的情况下来增加此功能

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
def func(x, y, z):
    time.sleep(2)
    print(func, x, y, z)
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        index(*args, **kwargs)
        end = time.time()
        print(end - start)
    return core
index = outer(index)
index(1,2)
func = outer(func)
func(1, 2, 3)
------------------------------------------------------------------------
<function outer.<locals>.core at 0x0000026C17F58280> 1 2
1.004807710647583
<function outer.<locals>.core at 0x0000026C17F58940> 1 2 3
2.0077626705169678

8、虽然上述推导过程都已满足装饰器条件,但是考虑到源代码有返回值的情况,我们没有并没有获取,这时在进一步推导,可在装饰器函数内部调用源代码函数名的位置设置一个变量名用于接收返回值,传给装饰器底层return用于接收即可解决这个问题

import time
def index(a, b):
    time.sleep(1)
    print(index, a, b)
    return 'index'
def func(x, y, z):
    time.sleep(2)
    print(func, x, y, z)
    return 'func'
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        res = index(*args, **kwargs)
        end = time.time()
        print(end - start)
        return res
    return core
index = outer(index)
res = index(1,2)
print(res)
func = outer(func)
res = func(1, 2, 3)
print(res)
------------------------------------------------------------------------
<function outer.<locals>.core at 0x0000020C50A78280> 1 2
1.0050580501556396
index
<function outer.<locals>.core at 0x0000020C50A78940> 1 2 3
2.0094454288482666
func

2、装饰器语法糖

什么是装饰器语法糖

当我们使用装饰器调用被装饰的函数体代码时,总是需要在调用前通过赋值的方式来调用,这样的方式相对比较麻烦,这时我们就可以用到装饰器语法糖来节省时间和代码

语法糖的使用方法和条件

用法:在源代码函数体上方使用@加装饰器函数名

条件:源代码需在装饰器下方

具体用法

import time
def outer(index):
    def core(*args, **kwargs):
        start = time.time()
        res = index(*args, **kwargs)
        end = time.time()
        print(end - start)
        return res
    return core
@outer
def index(a, b):
    time.sleep(1)
    print(index, a, b)
    return 'index'
index(1,2)

3、装饰器模板

def outer(func):
    def inner(*args, **kwargs):
        # 执行被装饰对象之前可以做的额外操作
        res = func(*args, **kwargs)
        # 执行被装饰对象之后可以做的额外操作
        return res
    return inner

以上就是Python基础globlal nonlocal和闭包函数装饰器语法糖的详细内容,更多关于Python基础globlal nonlocal的资料请关注我们其它相关文章!

(0)

相关推荐

  • 基于Python编写简单实用的日志装饰器

    目录 1.简陋版装饰器 2.普通版装饰器 3.优化版装饰器 在写代码的时候,往往会漏掉日志这个关键因素,导致功能在使用的时候出错却无法溯源. 其实,只需要写一个非常简单的日志装饰器,我们就能大大提升排查问题的效率. 1.简陋版装饰器 写一个装饰器非常简单,因为本质上装饰器就是一个返回函数的“高阶”函数而已: 1) 函数作为参数传递进装饰器. 2) 装饰器内定义一个函数,处理作为参数传递进来的函数. 3) 返回这个装饰器内定义的函数 import datetime def log(func): "

  • Python中 Global和Nonlocal的用法详解

    nonlocal 和 global 也很容易混淆.简单记录下自己的理解. 解释 global 总之一句话,作用域是全局的,就是会修改这个变量对应地址的值. global 语句是一个声明,它适用于整个当前代码块. 这意味着列出的标识符将被解释为全局变量. 尽管自由变量可能指的是全局变量而不被声明为全局变量. global 语句中列出的名称不得用于该全局语句之前的文本代码块中. global 语句中列出的名称不能定义为形式参数,也不能在 for 循环控制目标. class 定义.函数定义. impo

  • 详解python函数的闭包问题(内部函数与外部函数详述)

    python函数的闭包问题(内嵌函数) >>> def func1(): ... print ('func1 running...') ... def func2(): ... print ('func2 running...') ... func2() ... >>> func1() func1 running... func2 running... 内部函数func2作用域都在外部函数func1作用域之内 如果试图在外部函数的外部调用内部函数将会报错 >>

  • python中的闭包函数

    闭包函数初探 通常我们定义函数都是这样定义的 def foo(): pass 其实在函数式编程中,函数里面还可以嵌套函数,如下面这样 def foo(): print("hello world in foo") def bar(): print("hello world in bar") 此时我们调用foo函数,执行结果会是什么样子的呢?? hello world in foo 结果如上所示,只会执行foo函数的第一层函数,bar函数是不会被执行的.为什么呢 实际上

  • Python中关键字nonlocal和global的声明与解析

    一.Python中global与nonlocal 声明 如下代码 a = 10 def foo(): a = 100 执行foo() 结果 a 还是10 函数中对变量的赋值,变量始终绑定到该函数的局部命名空间,使用global 语句可以改变这种行为. >>> a 10 >>> def foo(): ... global a ... a = 100 ... >>> a 10 >>> foo() >>> a 100 解析

  • Python中关键字global和nonlocal的区别详解

    前言 终于下定决心学习Python了.既然从头开始,就需要认认真真. 首先需要说的是,我是初学Python,这篇文章只是用于展示global和nonlocal关键字的区别,是很简单的知识点,如果你已经学过,可以绕道.因为不经常写博客,而且是个Python小白,所以内容有些啰嗦... 两个关键词都用于允许在一个局部作用域中使用外层的变量. global 表示将变量声明为全局变量 nonlocal 表示将变量声明为外层变量(外层函数的局部变量,而且不能是全局变量) 注意:我使用的是Python3.6

  • Python基础globlal nonlocal和闭包函数装饰器语法糖

    目录 一.global与nonlocal 1.global 2.nonlocal 二.函数名的多种用法 三.闭包函数 1.什么是闭包函数 2.闭包函数需满足的条件 3.闭包函数的作用 4.闭包函数的实际应用 四.装饰器 1.装饰器推导流程 2.装饰器语法糖 3.装饰器模板 一.global与nonlocal 1.global 在py文件中,一般无法调用函数体内变量名,而global可使函数体代码内的变量名直接在函数体外部调用,条件是在需要调用的代码体中使用global 调用需要的变量名 未使用g

  • Python装饰器语法糖

    Python装饰器语法糖代码示例 ####装饰器的固定格式 ##普通版本 def timer(func): def inner(*args,**kwargs): '''执行函数之前要做的''' ret = func(*args,**kwargs) '''执行函数之后要做的''' return ret return inner ##wraps版本 from functools import wraps def deco(func): @wraps(func) #加在最内层函数正上方 def wra

  • python高级语法之闭包和装饰器详解

    一.闭包 闭包的形成条件: 1.函数嵌套. 2.内部函数使用了外部函数的变量或者参数. 3.外部函数返回了使用外 部变量的内部函数. 二.一个简单的例子 def func_out(num1): def inner(num2): res = num1 + num2 print(res) return inner # a = func_out(10)(10) a = func_out(10) a(10) 闭包修改外部函数的变量: 在闭包内修改外部函数的变量需要使用nonlocal关键字 def fu

  • Python函数装饰器常见使用方法实例详解

    本文实例讲述了Python函数装饰器常见使用方法.分享给大家供大家参考,具体如下: 一.装饰器 首先,我们要了解到什么是开放封闭式原则? 软件一旦上线后,对修改源代码是封闭的,对功能的扩张是开放的,所以我们应该遵循开放封闭的原则. 也就是说:我们必须找到一种解决方案,能够在不修改一个功能源代码以及调用方式的前提下,为其加上新功能. 总结:原则如下: 1.不修改源代码 2.不修改调用方式 目的:在遵循1和2原则的基础上扩展新功能. 二.什么是装饰器? 器:指的是工具, 装饰:指的是为被装饰对象添加

  • Python 中闭包与装饰器案例详解

    项目github地址:bitcarmanlee easy-algorithm-interview-and-practice 1.Python中一切皆对象 这恐怕是学习Python最有用的一句话.想必你已经知道Python中的list, tuple, dict等内置数据结构,当你执行: alist = [1, 2, 3] 时,你就创建了一个列表对象,并且用alist这个变量引用它: 当然你也可以自己定义一个类: class House(object): def __init__(self, are

  • Python 中的函数装饰器和闭包详解

    函数装饰器可以被用于增强方法的某些行为,如果想自己实现装饰器,则必须了解闭包的概念. 装饰器的基本概念 装饰器是一个可调用对象,它的参数是另一个函数,称为被装饰函数.装饰器可以修改这个函数再将其返回,也可以将其替换为另一个函数或者可调用对象. 例如:有个名为 decorate 的装饰器: @decorate def target(): print('running target()') 上述代码的写法和以下写法的效果是一样的: def target(): print('running targe

  • Python必备基础之闭包和装饰器知识总结

    一.闭包 1.1 三要素 必须有一个内嵌函数 内嵌函数必须引用外部函数中变量 外部函数返回值必须是内嵌函数 1.2 语法 # 语法 def 外部函数名(参数): 外部变量 def 内部函数名(参数): 使用外部变量 return 内部函数名 # 调用 变量 = 外部函数名(参数) 变量(参数) 举个例子 def func01(): # 外部函数 a = 1 # 外部变量 print('外部变量:',a) def func02(num): #内部函数 print("调用内部函数后:",n

  • python总结之闭包和装饰器

    目录 一.装饰器 1. 装饰器的简单介绍 2. 装饰器的解析过程 二.闭包 三.闭包中nonlocal语句的使用 1. 外部变量的引用和改写 2. nolocal的使用及特点 四.闭包与装饰器 五.闭包的作用 六.几个小栗子 栗子1: 栗子2: 栗子3 七.特殊的装饰器 property 装饰器 1. 我们为什么需要用到property 2. 使用Getters和Setters 3. property的作用 4. 小栗子 staticmethod装饰器和classmethod装饰器 step1:

  • 详谈Python高阶函数与函数装饰器(推荐)

    一.上节回顾 Python2与Python3字符编码问题,不管你是初学者还是已经对Python的项目了如指掌了,都会犯一些编码上面的错误.我在这里简单归纳Python3和Python2各自的区别. 首先是Python3-->代码文件都是用utf-8来解释的.将代码和文件读到内存中就变成了Unicode,这也就是为什么Python只有encode没有decode了,因为内存中都将字符编码变成了Unicode,而Unicode是万国码,可以"翻译"所以格式编码的格式.Python3中

  • 深入理解python中的闭包和装饰器

    python中的闭包从表现形式上定义(解释)为:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure). 以下说明主要针对 python2.7,其他版本可能存在差异. 也许直接看定义并不太能明白,下面我们先来看一下什么叫做内部函数: def wai_hanshu(canshu_1): def nei_hanshu(canshu_2): # 我在函数内部有定义了一个函数 return canshu_1*canshu_2 return

随机推荐