python--函数嵌套 命名空间

函数的嵌套调用

def func():
    print(123)
def func2():
     func()
  print(345)
func2()
#结果：123 345

函数的嵌套定义

def func():
    print(123)
 def func2():
    print(234)
func()
#结果：123   

无法调用func2而且结果也不会调用func2  外面也无法调用func2因为在func里面
为了保证某些功能特有的函数不被其他人随意调用

def func(a,b,c):
    print(a,b,c)
    def func2(a,b,c):
        print(a,b,c)
    func2(a,b,c)
func(3,2,1)

想要令嵌套的函数可以获取值，需要从主函数里面获取变量值再从子函数里面接收传参
想要传多个参数从主函数到子函数

def func(*args,**kwargs):
    def func2(*args,**kwargs):
        print(args,kwargs)
    func2(*args,**kwargs)
func(1,3,5,5,6,c=1,b=3)

这样可以令里面的子函数获取到主函数接收到的实参

三元计算

c =a if a>b else b:

命名空间

a=1
b=0
def name():
def max():

都是全局命名空间   全局命名空间全局都能用
def name(a,b)：
ab是局部命名空间
局部命名空间的独立的    只在函数里面用
对于局部来说，自己有的时候用自己的，自己没有再用全局的
内置命名空间
启动python就能用的就在内置命名空间里面
如 print def 等
打开代码先加载内置命名空间，再加载全局命名空间---从上到下顺序加载
调用该函数的时候加载局部命名空间
内置命名空间任意地方都可以用

应用例如：

a=1
def demo1():
    a=3
    def demo2():
        a=2
        print(a)
    demo2()
    print(a)
demo1()
print(a)

进来获取了全局的a=1，然后调用了demo1然后进入函数demo1
定义了a=3不过里面又有了函数demo2里面的a找到函数中的值2
打印2
然后打印了a=3，然后打印全局的1
结果  231

globals()全局里面变量在哪值是什么
locals()查函数自己的变量在哪值什么
global a  这样可以改变全局变量
nonlocal a  改变上一层的变量变成本函数变量

函数的名字  可以当做变量使用  是第一类对象的概念
首先是一个函数的内存地址
可以赋值，可以作为其他列表等容器类型的元素
可以作为函数的参数，返回值
例子1：

def func():
    print(123)
def fun2():
    print(456)
def fun3():
    print(789)
li=[]
a = func
b = fun2
c = fun3
li=[a,b,c]
li[1]()

例子2：

def func():
    print(123)
def func2(aaa):
    aaa()
func2(func)
结果是123
例子3：
def func():
     print(123)
def func2():
    return func
ret = func2()
ret()

闭包

内部函数引用了外部函数的变量，那么这个时候内部的函数叫做闭包

def func():
    name = 'egon'
 def inner():
    print(name)
 print(inner._closure_)
func()

inner是闭包，，closure检查是不是闭包
例子：

def func():
    name='egon'
    def inner():
        print(name)
    return inner
inner = func()
inner()

能把嵌套函数里面的函数调用
闭包的应用
装饰器是闭包的一种应用
闭包的作用：
节省内存
如果不用闭包，每次输出都会创建一个变量并销毁，闭包的话变量只创建一次
节省内存并且不会因为全局变量容易改变而害怕改变