函数对象

Posted 2021-02-03 pdun

函数是第一类对象：指定是函数名指向的值（函数）可以被当做数据取使用

1、可以被引用

先看变量可以怎么玩
age=18
x=age                    把age的内存地址赋值给x
print(age,x)
   >>18 18
******************************
同理，变量可以这么玩
def func():
    print(‘func run‘)
x=func                  注意：加括号代表的是函数体运行后的返回值
x()
print(x)

        func run
        <function func at 0x0000021DFB1D1A60>

****************************************
def func():
    print(‘func run‘)
x=func()
print(x)
   >>func run                 
   >>None              没有返回值      

2、可以当做参数传给另一个函数

age=18
def old_func():
    print("from func")

def func(x):
    print(x)
func(age)
func(old_func)

    18
    <function old_func at 0x0000023AD58F1A60>

3、可以当做一个函数的返回值

age=18
def old_func():
     print("from func")

def func(x):
    return x
res=func(age)
print(res)
res=func(old_func)
print(res)

    18
    <function old_func at 0x000001882ACE1A60>

4、可以当做容器类型的元素

age=18
def old_func():
    print("from china")
l=[age,old_func,old_func()]
print(l)

    from china
    [18, <function old_func at 0x000001FC9BF41A60>, None]

　　　　此功能实际运用

def login():
    print(‘登录...‘)
def register():
    print(‘注册...‘)
def shopping():
    print(‘购物...‘)
def pay():
    print(‘支付...‘)
msg="""
0 退出
1 登录
2 注册
3 购物
4 支付
"""
func_dic={
    ‘4‘:pay,
    ‘3‘:shopping,
    ‘2‘:register,
    ‘1‘:login
}
while True:
    print(msg)
    choice = input(‘请输入您的操作：‘)
    if choice == ‘0‘:
        break
    if choice in func_dic:
        func_dic[choice]()
    else:
        print(‘输入有误‘)

二、函数的嵌套

1、函数的嵌套调用：在调用函数过程中，其内部代码调用了其他函数

def func():
    print(‘from bar‘)
def bar():
    print(‘from func‘)
    func()
bar()

2、函数的嵌套定义

def f1():
    print(‘from f1‘)
    def f2():
        print(‘from f2‘)
        def f3():
            print(‘from f3‘)
        f3()
    f2()
f1()

三、名称空间与作用域

1、什么是名称空间

　　用来存放名字与值内存地址绑定关系的地方（内存空间）

2、名称空间分三大类

　　内置名称空间：存放python解释器自带的名字

 

 

　　全局名称空间：存放的是文件级别的名字

 

　　局部名称空间：在函数内定义的名字

　　　　

　　　　生命周期

　　　　　　　内置名称空间：在python解释器启动时生效，解释器关闭时失效

　　　　　　　全局名称空间：在python解释器解释python文件时生效，文件执行完毕时失效

　　　　　　　局部名称空间：只在调用函数时临时产生改函数的局部名称空间，该函数调用完毕则失效

　　　　加载顺序

　　　　　　　内置->全局->局部

　　　　查找名字的顺序:
　　　　　　可以把名称空间想象成三成，最下边是局部，往上是全局，最上边是内置，基于当前所在位置往上查找

　　　　　　假设当前站在局部,查找顺序:局部->全局->内置

　　　　　　假设当前站在全局,查找顺序:全局->内置

x=000
def f1():
    x=111
    def f2():
        x=222
        def f3():
            def f4():
                # x=444    注释掉
                print(x)
            x=333
            f4()
        f3()
    f2()
f1()


   >>333

　　

 

名字的查找顺序,在函数定义阶段就已经固定死了(即在检测语法时就已经确定了名字的查找顺序),与函数的调用位置无关,也就是说无论在任何地方调用函数,都必须回到
当初定义函数的位置去确定名字的查找关系

案例二

案列二:
x=111
def outer():
    def inner():
        print(‘from inner‘,x) # x访问的时全局名称空间中x
    return inner
f=outer()

x=222
f()


   >>222

案例三

案列三:
x=111
def outer():
    def inner():
        print(‘from inner‘,x) # x访问的时全局名称空间中x
    return inner
f=outer()
def func():
    x=333
    f()
x=444
func()

   >>444

四、作用域

　　全局作用域：包含的是内置名称空间与全局名称空间中的名字
　　　　　　特点：全局有效　全局存货

　　局部作用域：包含的是名称空间中的名字
　　　　　　特点：局部有效　临时存活

 

global与nonlocal

global：在局部声明一个名字是来自全局作用域的，可以用来在局部修改全局的不可变类型

x=11
def func():
    global x
    x=22
    return x
print(func())

    >>22

lonlocal：声明一个名字来自于当前层外一层作用域的，可以用于在局部修改外层的不可变类型

x=11
def func():
    global x
    x=22
    return x
print(func())


如果外一层没有，再往外一层找，直到找到外层，如果没有，就会报错

五、闭包函数

1 什么是闭包函数
　　闭：指的是闭包函数是定义在一个函数内部的函数
　　包：该内部函数包含对外层函数作用域名字的引用

　　需要结合函数对象的概念将闭包函数返回到全局作用域去使用，从而打破函数的层级限制

　　　　 1.定义在另一个函数内的函数
 　　　　2.内部的的函数访问了外部的名称(数据 注意 不包含全局的)

2 为何要用闭包函数
　　闭包函数提供了一种为函数体传值的解决方案

3 如何用闭包函数

　　1、为函数体传值方式一：参数

def func(x,y):
    print(x+y)
func(1,2)

　　2、为函数体传值方式二：闭包

def bar():
    x=1
    y=2
    def func():
        print(x+y)
    return func
f=bar()
f()

f()
  >>3
  >>3