函数对象、函数的嵌套、名称空间、函数的作用域、闭包

函数对象

def foo():
    print('foo')

函数可以被赋值
f=foo
print(f)   #结果是一个内存地址
f()         #内存地址加（）内运行函数

把函数当成参数传递
def bar(func):
    print(func)
    func()

bar(foo)

把函数当成返回值
def bar(func):
    print(func)
    return func

f=bar(foo)
f()
把函数当做容器类型的元素去用

def add():
    print('=============>function add')
def search():
    print('=============>function search')
def delete():
    print('=============>function delete')
def change():
    print('=============>function change')

cmd_dic={
    'search':search,
    'add':add,
    'delete':delete,
    'change':change,   
}

cmd_dic[“change”]()#调用函数　

函数的嵌套

嵌套定义
def f1():   
    print('------>f1 ',x)
    def f2():       
        print('---->f2 ',x)
        def f3():           
            print('-->f3 ',x)
        f3()
    f2()

f1()

名称空间

内置名称空间
全局名称空间
局部名称空间

print(globals())#查看全局名称空间
print(locals())#查看局部名称空间

函数的作用域

内置名称空间、全局名称空间是全局作用域
局部名称空间是局部作用域

！！！先定义后使用
　　

def foo():
    print('from foo')
    bar()

foo()   #此刻调用foo()会报错，调用时内存中还没有bar（）
def bar():
    print('from bar')

闭包

闭包：首先必须是函数内部嵌套的函数，该函数包含对外部作用域而不是全局作用域名称的引用，返回嵌套函数的内存地址。
def f1(x):
    x=1000
    def f2():
        print(x)
    return f2
f=f1(10) #f1传值也能成闭包
f()
print(f.__closure__)   #闭包对外部作用域引用的数量print(f.__closure__[0].cell_contents)  
#闭包对外部作用域引用的第一个值

参数

#函数的参数介绍
#
# def foo(x,y):
#     print(x)
#     print(y)
# foo(1,2)

#在实参的角度
# 第一种：按照位置传值
# foo(1,2)
# foo(2,1)


# 第二种：按照关键字传值
# foo(x=1,y=2)
# foo(y=2,x=1)

# 第三种：混着用
# foo(1,y=2)
# 问题一：按位置传值必须在按关键字传值的前面
# foo(y=2,1) #报错
# 问题一：对于一个形参只能赋值一次
# foo(1,y=2)


# 从形参的角度来分析
#
# 位置参数：必须传值的参数
# def foo(x,y):
#     print(x)
#     print(y)
#
# foo(1,2)
# foo(y=2,x=1)

#
# 默认参数
# def foo(x,y=1):
#     print(x)
#     print(y)
#
# foo(1)
# foo(1,2)
# foo(y=2,x=2)



# *args  #位置传值后剩下的装入元组
# def foo(x,*args): #args=(2, 3, 4, 5, 6, 6, 'a', 'b')
#     print(x)
#     print(args)
# foo(1,2,3,4,5,6,6,'a','b')


#*args与位置参数和默认参数混用:*args要放到位置参数后面
# def foo(x,*args,y=1):
#     print(x)
#     print(y)
#     print(args)
#
# foo(1,2,3,4,5,6,7,8,9,10,y=10000000)

# 从形参的角度
# def foo(*args):  
#     print(args)
#
# foo(1,2,3)

# 从实参的角度
# def bar(x,y,z):
#     print(x)
#     print(y)
#     print(z)
# bar(*(1,2,3)) 



# **kwargs   #按关键字传值剩下的装入字典
# def foo(x,**kwargs):
#     print(x)
#     print(kwargs)
#
# foo(1,y=1,z=2)

# 混着用的位置问题
# def foo(x,*args,**kwargs):
#     print(x)
#     print(args)
#     print(kwargs)
#
# foo(1,y=1,z=2)
# 结果  1   （）  {"z":2,"y":1}


# def foo(*args,**kwargs):
#     print(args)
#     print(kwargs)
#
# foo(1,1,1,1,1,1,a=1,b=2)


# 从形参的角度
# def foo(**kwargs): #x=1,y=2,z=3
#     print(kwargs)
#
#
# foo(x=1,y=2,z=3)
#
# 从实参的角度
# def foo(x,y,z=1):
#     print(x)
#     print(y)
#     print(z)
#
# foo(**{'x':1,'y':2,'z':3})  #foo(x=1,y=2,z=2)
# foo(**{'x':1,'y':2})  #foo(x=1,y=2)
# foo(**{'a':1,'y':2})  #foo(a=1,y=2)   #报错，没有a参数