526互联

Python名称空间和作用域，闭包函数

发布时间 2023-09-11 08:31:11作者: jntmwl

什么是名称空间?

名称空间即存放名字与对象映射/绑定关系的地方。
就是存放变量名与变量值关系的地方

名称空间的分类
1.内置的名称空间
内置:就在python解释器里面，可以直接使用
"""一般大多数都是在函数内部存在的都是局部的!"""
def index():
a=1
b=2
2.全局的名称空间
全局：在py文件中顶格编写的变量名就是全局变量
name='jerry'
def index():
pass

         if a:
            pass
        
         while b:
                pass
            
         for i in range(10):
            pass

全局变量：
在函数外的变量就是全局变量
局部变量：
在函数内部的变量就是局部变量

名称查询顺序
既然有全局变量和局部变量那么就一定会有查询顺序

名称空间的加载顺序是（在内置）：内置名称空间->全局名称空间->局部名称空间
如果你在全局：全局--->内置
局部变量在外部是不能被使用的
在函数内部打印出来的结构都属于当前函数的局部名称空间
"""局部名称空间的嵌套！"""

def f1():
# x = 222
def f2():
print('f2')
# x = 333
def f3():
print('f3')
# x = 444
def f4():
# x = 555
print(x)
f4()
f3()
f2()
f1()
名称空间的作用域
域：范围

作用域：变量的作用范围

  1. 内置名称空间

    在全局的任意位置都能够使用

  2. 全局名称空间

    在全局的任意位置任意时间都能够使用

  3. 局部名称空间

    一般情况只能够在局部使用

def index():
x = 666

global和nonlocal的使用
global

如果你想在局部修改全局的变量：
1. 如果你修改的是不可变的类型，需要global关键字的声明
2. 如果你修改的是可变类型的，无需使用global关键字声明

x = 10

def index():

global x # 声明这个x用的是全局的x

x = 20 # 我想在局部修改全局的x的值

# print(x)

index()

print(x) # 10

name_list = ['kevin', 'jerry']

def func():
name_list.append('tank')

func()
print(name_list) # ['kevin', 'jerry', 'tank']

nonlocal
如果你想在内部的局部修改外部的局部：
1. 如果你修改的是不可变的类型，需要nonlocal关键字的声明
2. 如果你修改的是可变类型的，无需使用nonlocal关键字声明
nonlocal的使用：

def outer():

x = 666

def inner():

nonlocal x

x = 999

inner()

print(x) # 此时的x是多少? 666

outer()

def outer():
name_list = ['a', 'b']
def inner():
name_list.append('c')
inner()
print(name_list) # 此时的x是多少? 666

outer()

函数对象（函数名）
函数名可以当成变量赋值
ef index():
print('index')
return 123

print(index())

'''函数名就是函数在内存中得地址'''

print(index) # <function index at 0x0000022FD03AD550>

a = index

print(a) # <function index at 0x0000022D4E03D550>

res=a() # index()
print(res)
函数名可以的当成函数的实参
def index():
print('index')
return None

def func(a):
# a：index
print(a)
res=a() # index()
print(res) # res的结果? None

index:index函数所在的内存地址

函数名可以当成函数的返回值
def index():
print('index')
return 'index2'

def func():
print('func')
# return index() # 'index'
return index # 'index'

res = func() #
print(res)
res1=res() # index()
print(res1)
函数名可以当成容器类型的元素
def index():
print('index')
return Nonell = [11, 22, 33, index]

ll = [11, 22, 33, index()]# print(ll[3])

res=ll3 # index()
print(res)
函数的嵌套调用
嵌套：函数套函数

案例：给你四个数，比较大小，返回最大的

两个数的比较大小，返回大的

def my_max(a, b):
if a >b:
return a
return b

res=my_max(1, 2)

print(res)

def many_max(a, b, c, d, e):
'''四个数的比较大小其实还是要两两比较!'''
res=my_max(a, b) # res得到a和b中得大的那个
# 怎么样比较res和剩余的大小， 只需要拿res和c或者d中得一个进行比较
res1=my_max(res, c) # res1:a,b,c中得最大的那个
res2=my_max(res1, d)
res3=my_max(res2, e)
return res3

res=many_max(11, 12, 3, 24)
print(res)
闭包函数

闭包函数还是函数，它是有函数一点一点演变过来的

什么是闭包函数?
闭：就是函数内部定义函数，至少要有2层函数
包：内部的函数要使用外部函数名称空间中的名字

'''只有同时满足以上两个条件，才能称之为是闭包函数'''

def outer():
x = 666
def inner():
print('hello', x)
return inner

outer()

闭包函数的使用场景：

闭包函数其实是第二种传参方式!

第一种传参方式

def index(username):

print(username)

index('jerry')

第二种传参方式

比较两个数的大小

def my_max(a, b):

if a>b:

return a

return b

my_max(1, 2)

让你用闭包函数实现比较2个数的大小:一次传值，多次使用

def outer(a, b):
# a = 100
# b = 200

def my_max():
    if a > b:
        return a
    return b

return my_max

res = outer(1, 10) # my_max函数的内存地址
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()
print(res()) # my_max()

res1=outer(10, 20) # res1:my_max
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())
print(res1())