抛头露面 发表于 2023-9-7 17:23:49

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

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


[*]名称的查询顺序
[*]名称空间的作用域
[*]global和nonlocal关键字的使用
[*]函数对象(函数名)
[*]函数的嵌套调用
[*]函数的嵌套定义
[*]闭包函数
名称空间

定义

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

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 =
# ll = # print(ll)
res=ll() # 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())
来源:https://www.cnblogs.com/zhangfanshixiaobai/p/17685546.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!
页: [1]
查看完整版本: Python名称空间和作用域,闭包函数