python-之名称空间与作用域闭包函数嵌套函数

Posted xiechao

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python-之名称空间与作用域闭包函数嵌套函数相关的知识,希望对你有一定的参考价值。

一、名称空间与作用域

技术分享图片
名称空间:存放名字的地方,准确的说名称空间是存放名字与变量值绑定关系的地方

内置名称空间:在python解释器启动时产生,存放一些python内置的名字
全局名称空间:在执行文件时产生,存放文件级别定义的名字
x=1
def func():
    y=2
    def f1():pass
    print


import os

class Foo:
    pass

if x==1:z=3

del x


局部名称空间:在执行文件的过程中,如果调用了函数,则会产生该函数的局部名称空间
用来存放该函数内定义的名字,该名字在函数调用时生效,在函数调用结束后失效



加载顺序:内置---》全局---》局部


优先掌握一:名字的查找顺序是:局部-》全局-》内置

# max=1
def foo():
    max=2
    # print(max)

foo()
print(max)




x=0
def f1():
    x=1
    def f2():
        x=2
        def f3():
            x=3
            print(x)
        f3()
    f2()
    print(=f1========,x)


f1()




def func1():
    print(from func1)

def func1():
    print(=====?>)

func1()

x=1
x=10
print(x)
View Code

 

1、什么是名称空间?

#名称空间:存放名字的地方,三种名称空间,(之前遗留的问题x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方)

2、名称空间的加载顺序

python test.py
#1、python解释器先启动,因而首先加载的是:内置名称空间
#2、执行test.py文件,然后以文件为基础,加载全局名称空间
#3、在执行文件的过程中如果调用函数,则临时产生局部名称空间

3、名字的查找顺序

技术分享图片
局部名称空间--->全局名称空间--->内置名称空间

#需要注意的是:在全局无法查看局部的,在局部可以查看全局的,如下示例

# max=1
def f1():
    # max=2
    def f2():
        # max=3
        print(max)
    f2()
f1()
print(max) 
技术分享图片

二、作用域

技术分享图片
作用域:作用的范围,
全局作用域:全局存活,全局有效:globals()
max=1111111
def f1():
    def f2():
        def f3():
            def f4():
                # print(x)
                print(max)
            f4()
        f3()
    f2()


f1()
局部作用域:临时存活,局部有效:locals()

x=11111111111111111111111111111111111111111111

def f1():
    x=1
    y=2
    def f2():pass
    # print(locals())
    print(globals())

f1()
print(locals() is globals())
print(locals())

print(dir(globals()[__builtins__]))


--------------------------------------------------
global nonlocal掌握    :global 修改全局的
x=1
def f1():
    global x       明确声明x就是全局的x ,所以就会把全局的x=1,改成局部的x=2。
    x=2

f1()
print(x)
-----------------------------------------------

l=[]
def f2():
    l.append(f2)    能直接把l的值改‘f2’,因为l是列表,列表是可变类型。

f2()
print(l)

----------------------------------------------------
x=0
def f1():
    # x=1
    def f2():
        # x=2
        def f3():
           # global x
           nonlocal x      //修改的是函数内部正上方的那个X,所有x被修改成2.只在函数内部有效。
           x=3
        f3()
        # print(x)
    f2()
    print(x)
f1()
print(x)

-----------------------------------------------------


优先掌握二:作用域关系,在函数定义时就已经固定
,与调用位置无关,在调用函数时,必须必须必须
回到函数原来定义的位置去找作用域关系

x=1
def  f1():
    def f2():
        print(x)
        return f2
def foo(func):
    x=300000
    func()
res=f1()
print(res)
func=f1()
print(func)
x=10000000
func()
x=10000000



def foo(func):
    x=300000000
    func() #f2()
x=10000000000000000000000



foo(f1())
# x=10000000000000000000000
# foo(f1())







x=1
def f1():
    global x
    x=2

f1()
print(x)
View Code
#1、作用域即范围
        - 全局范围(内置名称空间与全局名称空间属于该范围):全局存活,全局有效
      - 局部范围(局部名称空间属于该范围):临时存活,局部有效
#2、作用域关系是在函数定义阶段就已经固定的,与函数的调用位置无关,如下
x=1
def f1():
    def f2():
        print(x)
    return f2
x=100
def f3(func):
    x=2
    func()
x=10000
f3(f1())

#3、查看作用域:globals(),locals()


LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间,包括局部变量和形参
enclosing 外部嵌套函数的名字空间(闭包中常见)
globals 全局变量,函数定义所在模块的名字空间
builtins 内置模块的名字空间

三、global与nonlocal关键字  

global nonlocal掌握    :global 修改全局的
x=1
def f1():
    global x       明确声明x就是全局的x ,所以就会把全局的x=1,改成局部的x=2。
    x=2

f1()
print(x)
-----------------------------------------------

l=[]
def f2():
    l.append(‘f2‘)    能直接把l的值改‘f2’,因为l是列表,列表是可变类型。

f2()
print(l)

----------------------------------------------------
x=0
def f1():
    # x=1
    def f2():
        # x=2
        def f3():
           # global x
           nonlocal x      //修改的是函数内部正上方的那个X,所有x被修改成2.只在函数内部有效。
           x=3
        f3()
        # print(x)
    f2()
    print(x)
f1()
print(x)

四、闭包函数

技术分享图片
大前提:作用域关系,在函数定义时就已经固定
,与调用位置无关,在调用函数时,必须必须必须
回到函数原来定义的位置去找作用域关系


闭包函数:
1. 定义在函数内部的函数
2. 包含对外部作用域名字的引用,而不是对全局作用域名字的引用
那么该内部函数就称为闭包函数
x=1
def  f1():
    x=11111111111
    def f2():
        print(x)
    return f2

func=f1()


x=1000
func()

def foo():
    x=12312312312312312312312312312312312313123
    func()


foo()


def deco():
    x=123123123123
    def wrapper():
        print(x)
    return wrapper

func=deco()


func()


#闭包函数的应用:惰性计算
import requests #pip3 install requests  安装pip3

def get(url):
    return requests.get(url).text

print(get(https://www.python.org))
print(get(https://www.python.org))
print(get(https://www.python.org))
print(get(https://www.python.org))

def index(url):
    # url=‘https://www.python.org‘
    def get():
        # return requests.get(url).text
        print(requests.get(url).text)

    return get

python_web=index(https://www.python.org)
baidu_web=index(https://www.baidu.com)

python_web()
baidu_web()






name=egon
def index(url):
    x=1
    y=2
    def wrapper():
        # x
        # y
        # return requests.get(url).text
        print(name)
    return wrapper

python_web=index(https://www.python.org)

# print(python_web.__closure__[0].cell_contents)
print(python_web.__closure__)
# print(python_web.__closure__[0].cell_contents)
# print(python_web.__closure__[1].cell_contents)
# print(python_web.__closure__[2].cell_contents)
View Code

五、嵌套函数

函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数
def bar():
    print(‘from nbar‘)

def foo():                       #再调用一个函数的过程中,又去调用了另外一个函数
    print(‘from foo‘)
    bar()

foo()

-----------------------------------------
求两个值最大的函数
def max2(x,y):
    if x > y:
        return x
    else:
        return y


def max4(a,b,c,d):      求四个值的最大值
    res1=max2(a,b)      把a b 传进去会得到第一个结果
    res2=max2(res1,c)   再调用一次,拿着这一次得到的结果在跟c进行比较
    res3=max2(res2,d)
    return res3         得到res3最终的结果


print(max4(1,2,3,-1))

-------------------------------------------------
函数的嵌套定义:在一个函数的内部,又定义另外一个函数

def f2():
    print(‘from f2‘)

def f1():
    x=1                    函数内部定义的名字,只是在函数被调用的时候生效。
    # def f2()
    #     print(‘from f2‘)
    f2()

f1()

  

 

以上是关于python-之名称空间与作用域闭包函数嵌套函数的主要内容,如果未能解决你的问题,请参考以下文章

python函数之进阶 函数嵌套,命名空间,闭包

python基础之====函数对象函数嵌套名称空间与作用域装饰器

函数对象函数嵌套名称空间与作用域闭包函数装饰器

python 全栈 python基础 作用域 函数嵌套 闭包

python基础:函数对象函数嵌套名称空间与作用域装饰器

Python--高阶函数函数嵌套名称空间及变量作用域闭包装饰器