python语法基础-函数-进阶-长期维护

###############    函数的命名空间和作用域    ##############

"""

# 函数进阶

命名空间和作用域

命名空间
全局命名空间——我们自己写的非函数中的代码
    是在程序从上到下被执行的过程中依次加载进内存的,
    放置了我们设置的所有的变量名和函数名,

局部命名空间,——函数
    就是函数内部定义的名字
    在函数调用的时候才会产生这个命名空间,随着函数调用的结束,这个命名空间就消失了,

内置命名空间,——Python解释器,
    就是Python解释器一启动就可以使用的名字,存储在内置的命名空间中,比如print,input,list等,
    内置的名字,在启动解释器的时候就会加载进去内存中,

在全局我们可以使用内置的明明靠空间,但是不能使用局部的,
在局部我们可以使用全局的,内置的命名空间,
在内置的里面不能使用全局的和局部的,

所以就像是一个套娃一样,最外层是内置的,然后是全局的,然后是局部的,

如果我们定义在全局定义了和内置的函数同名的名字,会使用全局的,

"""

def input():
    print(123)

def func():
    # input=1
    print(input)

func()

"""
作用域

作用域和命名空间是分不开的,

作用域有两种,
1,全局作用域,内置和全局的命名空间,都是全局作用域,
2,局部作用域,我们现在就知道一个局部,就是函数,

对于不可变类型,你可以在局部查看全局的变量,但是不能修改,如果要修改,你就需要使用global进行声明,
自己的代码中应该尽量少使用global,这样会导致代码非常不安全,混乱,
"""

a =1

# def func():
#     global a
#     a += 1
# func()
# print(a)


def func(a):
    a += 1
    return a
# 不使用global,可以使用另一种方法
a = func(a)
print(a)  # 2


"""
globals
locals

"""
a =1
b = 2
def func():
    x = "aaa"
    y = "bbb"
    print(locals())  # 会打印出所有的局部变量的名字和值,  {‘y‘: ‘bbb‘, ‘x‘: ‘aaa‘}
    print(globals())  # 这个还是全局的,

func()
print(globals())  # 会打印出所有全局的名字,和内置的变量的名字,然后是函数名,
print(locals())  # print(globals()),这个打印出的本地和全局是一样的,

###############    函数的嵌套调用,函数的嵌套定义    ##############

# 函数的嵌套调用

# 两个数判断最大值
def max(a,b):
    return a if a>b else b  # 三元运算,a大于b,就是a,否则就是b,

# 三个数判断最大值,先判断两个,然后再判断和第三个,
def the_max(x,y,z):
    c = max(x,y)  # 这就是函数的嵌套调用,
    return max(c,z)


# 函数的嵌套定义,
# nonlocal 找离当前函数最近的一个局部变量,只会影响最近的一层,不能是全局变量,
def outer():
    a = 1
    def innner():
        print(123,)
        def innner2():
            nonlocal a
            a += 1
            print(a)
        innner2()
    innner()  # 一定要有这一句,否则内部定义的函数,不会生效,

outer()


# 函数名就是一个内存地址,
# 1,函数名可以赋值
# 2,函数名可以作为容器类型的元素,
# 3,函数可以作为参数调用,# 函数可以作为参数调用,
def func1():
    print(123)
func2=func1  # 函数名可以赋值

func2()

list1=[func1,func2]  # 函数名可以作为容器类型的元素,

def func3(func1):  # 函数可以作为参数调用,
    func1()
    return func1  # 函数名可以作为函数的返回值,

###############    函数的闭包    ##############

# 闭包

def outer():
    a = 1
    def inner():
        print(a)
    inner()
outer()
outer()
outer()
# 这种写法比较浪费资源,每次都要生成a变量,
# 闭包的定义,就是一个嵌套函数,并且内部函数调用外部函数的变量,如果你调用外部函数的变量,就不是一个闭包,

# 闭包最常用的形式是在函数中返回内部函数,

def outer():
    a = 1
    def inner():
        print(a)
    print(inner.__closure__)  # (<cell at 0x0000000009C68FA8: int object at 0x000000005EA960A0>,),有cell就是一个闭包,
    return inner  # 在外部函数中返回内部函数的名字,这就是一个闭包最常用的方式,

inn = outer()
inn()
inn()
inn()
inn()  # 这种写法我调用这个函数100次,但是里面的a变量就只会生成一次了,不会反复生成了,节省资源,

相关推荐