python3命名空间与作用域,闭包函数,装饰器

一.命名空间与作用域

命名空间是名字和对象的映射,就像是字典,key是变量名,value是变量的值

1.命名空间

name=‘egon‘  #定义变量

def func():  #定义函数
    pass

class Foo:  #定义类
    pass

2.命名空间的分类

(1)内置名称空间: 随着python解释器的启动而产生,包括异常类型、内建函数和特殊方法,可以代码中任意地方调用

print(sum)
print(max)
print(min)

print(max([1,2,3]))

import builtins
for i in dir(builtins):   #打印所有的内置函数
    print(i)

(2)全局名称空间:文件的执行会产生全局名称空间,指的是文件级别定义的名字都会放入该空间

x=1 #全局命名空间

def func():
    money=2000   #非全局
    x=2
    print(‘func‘)
print(x)
print(func)
func()

(3)局部名称空间:调用函数时会产生局部名称空间,只在函数调用时临时绑定,调用结束解绑定

x=10000    #全局
def func():
    x=1    #局部
    def f1():
        pass

3.作用域

命名空间的可见性就是作用域

  • 1. 全局作用域:内置名称空间,全局名称空间
  • 2. 局部作用域:局部名称空间

名字的查找顺序:局部名称空间---》全局名层空间---》内置名称空间

查看全局作用域内的名字:gloabls()

查看局部作用域内的名字:locals()

全局作用域的名字:全局有效,在任何位置都能被访问到,除非del删掉,否则会一直存活到文件执行完毕

局部作用域的名字:局部有效,只能在局部范围调用,只在函数调用时才有效,调用结束就失效

x=1000
def func(y):
    x=2
    print(locals())
    print(globals())

func(1)输出:
{‘y‘: 1, ‘x‘: 2}
{‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x10c436c88>, ‘__package__‘: None, ‘__cached__‘: None, ‘__file__‘: ‘/Users/hexin/PycharmProjects/py3/day4/2.py‘, ‘func‘: <function func at 0x10c3c9f28>, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__spec__‘: None, ‘__doc__‘: None, ‘time‘: <module ‘time‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘x‘: 1000}
四.闭包函数

简单来说,一个闭包就是你调用了一个函数A,这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。

闭包函数须满足以下条件:

1. 定义在内部函数;
2. 包含对外部作用域而非全局作用域的引用;

def f1():
    x = 1
    def f2():
        print(x)
    return f2

f=f1()
print(f)

x=100
f()
print(x)

输出:
<function f1.<locals>.f2 at 0x107714400>
1
100

 闭包的应用

from urllib.request import urlopen

def index(url):
    def get():
        return urlopen(url).read()
    return get

oldboy=index(‘http://crm.oldboyedu.com‘)

print(oldboy().decode(‘utf-8‘))

 五。装饰器

1.定义

装饰器:修饰别人的工具,修饰添加功能,工具指的是函数

装饰器本身可以是任何可调用对象,被装饰的对象也可以是任意可调用对象

2.为什么要用装饰器?

开放封闭原则:对修改是封闭的,对扩展是开放的
装饰器就是为了在不修改被装饰对象的源代码以及调用方式的前提下,为其添加新功能

3.装饰器的实现

装饰器的功能是将被装饰的函数当作参数传递给与装饰器对应的函数(名称相同的函数),并返回包装后的被装饰的函数”

直接看示意图,其中 a 为与装饰器 @a 对应的函数, b 为装饰器修饰的函数,装饰器@a的作用是:

简而言之:@a 就是将 b 传递给 a(),并返回新的 b = a(b)

def a(name):      #与装饰器对应的函数
    return name()

@a            #装饰器  b = a(b)
def b():        #被装饰函数
    print(‘hexin‘)

  

输出

hexin

解析过程是这样子的:
1.python 解释器发现@a,就去调用与其对应的函数( a 函数)
2.a 函数调用前要指定一个参数,传入的就是@a下面修饰的函数,也就是 b()
3.a() 函数执行,调用 b(),b() 打印“hexin”

装饰器的应用

import time

def timmer(func):
    def wrapper():
        start_time=time.time()
        func()       #index()
        stop_time=time.time()
        print(‘run time is %s‘ %(stop_time-start_time))
    return wrapper

@timmer       #index=timmer(index)
def index():
    time.sleep(1)
    print(‘welcome to index‘)

index()

输出:
welcome to index
run time is 1.005241870880127

#--------------------------------------------------------------
login_user={‘user‘:None,‘status‘:False}
def auth(func):
    def wrapper(*args,**kwargs):
        if login_user[‘user‘] and login_user[‘status‘]:
            res=func(*args,**kwargs)
            return res
        else:
            name=input(‘请输入用户名: ‘)
            password=input(‘请输入密码: ‘)
            if name == ‘hexin‘ and password == ‘123‘:
                login_user[‘user‘]=‘hexin‘
                login_user[‘status‘]=True
                print(‘\033[45mlogin successful\033[0m‘)
                res=func(*args,**kwargs)
                return res
            else:
                print(‘\033[45mlogin err\033[0m‘)
    return wrapper

@auth     #index=auth(index)
def index():
    print(‘welcome to index page‘)

@auth      #home=auth(home)
def home(name):
    print(‘%s welcome to home page‘ %name)

index()
home(‘hexin‘)

输出:
请输入用户名: heixn
请输入密码: 123
login err
请输入用户名: hexin
请输入密码: 123
login successful
hexin welcome to home page

装饰器的基本框架:

def timer(func):
    def wrapper():
        func()
    return wrapper

带参数

def timer(func):
    def wrapper(*args,**kwargs):
        func(*args,**kwargs)
    return wrapper

原文地址:https://www.cnblogs.com/qingsheng/p/9597182.html

时间: 2024-10-24 12:01:58

python3命名空间与作用域,闭包函数,装饰器的相关文章

Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

【Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数】

一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(First-Class Object)呢? 在 Python 中万物皆为对象,函数也不例外,函数作为对象可以赋值给一个变量.可以作为元素添加到集合对象中.可作为参数值传递给其它函数,还可以当做函数的返回值,这些特性就是第一类对象所特有的. 1.函数身为一个对象,拥有对象模型的三个通用属性:id.类型.和值.

函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数

函数嵌套名称空间与作用域闭包函数装饰器迭代器生成器三元表达式,列表解析,生成器表达式递归与二分法内置函数--------------------------------------------函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数函数的嵌套定义:在一个函数的内部,又定义另外一个函数def max(x,y): if x>y: return x else: return ydef max1(a,b,c,d): res=max(a,b) res2=max(res,c) res3=ma

Python作用域--&gt;闭包函数--&gt;装饰器

1.作用域: 在python中,作用域分为两种:全局作用域和局部作用域. 全局作用域是定义在文件级别的变量,函数名.而局部作用域,则是定义函数内部. 关于作用域,我要理解两点:a.在全局不能访问到局部定义的变量 b.在局部能够访问到全局定义的变量,但是不能修改全局定义的变量(当然有方法可以修改) 下面我们来看看下面实例: x = 1 def funx(): x = 10 print(x) # 打印出10 funx() print(x) # 打印出1 如果局部没有定义变量x,那么函数内部会从内往外

闭包函数 装饰器 有参装饰器

闭包函数: 1 内部函数 2 包含对外部作用域而非全局作用域的引用闭包函数的特点: 自带作用域  延迟计算 #闭包函数定义 1 def timmer(func): 2 def inner(*args,**kwargs): 3 re = func(*args,**kwargs) 4 return re 5 return inner 6 7 index(): 8 print("hello") 9 10 index = timmer(index) #index == inner 11 ind

&lt;04day&gt;_函数嵌套--闭包函数--装饰器--迭代器--生成器

一.函数的嵌套定义 1.python函数支持嵌套 def f1(): #f1函数的定义 def f2(): #f2函数的定义 print('from f2') def f3(): #f3函数的定义 print('from f3') f2() f1() 嵌套函数--运行结果说明: 1首先调用f1()结果,f1函数为空.担保函f2函数,f2函数有内容打印并且有调用,f2函数包含f3函数,但f3函数无调用. 运行结果: 列子:多个数据之间的大小比较. #!/usr/bin/python # -*- c

day12.1_闭包函数+装饰器

一.闭包函数 闭包的定义:①该函数是一个内部函数 ②该函数包含对外部的作用域(非全局作用域)中名字的引用 1. 为函数体传值的方式 1.1 使用参数形式 1.2 包给函数 def outter(x): def inner(): print(x) return inner #函数当返回值(对象) f=outter(1) #相当于赋值 f() 二.装饰器 1.装饰器是什么? ①为被装饰器对象添加额外的功能  ② 可以当成工具,函数就具备某一功能的工具 装饰器本省可以是任意可调用的对象,被装饰的对象也

闭包函数 装饰器

什么是闭包函数 闭:指的是闭包函数数定义在一个函数内部的函数 包:该内部函数包含对外城函数作用域名字的引用 需要结合函数对象的概念将闭包函数返回到全局作用域去使用,从而打破函数层级的限制 为什么要用闭包函数 闭包函数提供了一种为函数体传值的解决方案 如何用闭包函数 # 为函数体传值的方式一:参数 # def func(x,y): # print(x+y) # # func(1,2) 3 # 为函数体传值的方式二:闭包 def outter(x,y): # x=1 # y=2 def func()

python之闭包函数 装饰器 作业

一:编写函数,(函数执行的时间是随机的) import randomdef t(): time.sleep(random.randrange(1,3)) print('hello')二:编写装饰器,为函数加上统计时间的功能 import timeimport randomdef timebe(func): def wrapper(*args,**kwargs): start_time=time.time() res = func(*args, **kwargs) end_time=time.ti