python-study-11

上节课复习

上节课复习
    1、函数的参数分为两大类
        形参
            def foo(x,y):
                pass
        实参
            a=1,b=2
            foo(a,b)

    2、细分
        1、位置参数
            位置形参
            位置实参
        2、关键字实参
            foo(1,x=2)
        3、默认形参
            def foo(x,y=1):
                pass

        4、*args，**kwargs
            def index(name,age):
                pass
            def wrapper(*args,**kwargs):
                index(*args,**kwargs) #index(1,x=1,y=2)

            wrapper(1,x=1,y=2)

今日内容：
    1、函数对象
    2、函数嵌套
    3、名称空间与作用域

函数对象

函数是第一类对象的含义是函数可以被当作数据处理

def func():
    print('from func')
print(func)   #func=<function func at 0x0584BA50>  返回内存地址

x='hello'
1、引用
y=x
f=func
print(f)
f()

2、当作参数传给一个函数
len(x)
def foo(m):
    # print(m)
    m()

foo(func)

3、可以当作函数的返回值
def foo(x): #x=func
    return x #return func

res=foo(func)
print(res)
res()

4、可以当作容器类型的元素
l=[x,]
l=[func,]
# print(l)

l[0]()

def pay():
    print('支付。。。')

def withdraw():
    print('取款。。。')

def transfer():
    print('转账。。。')

def check_balance():
    print('查看余额。。。')


def shopping():
    print('购物。。。')

func_dic={
    '1':pay,
    '2':withdraw,
    '3':transfer,
    '4':check_balance,
    '6':shopping
}

while True:
    msg="""
    1 支付
    2 取款
    3 转账
    4 查看余额
    5 退出
    6 购物
    """
    print(msg)
    choice=input('>>: ').strip()
    if choice == '5':break
    if choice not in func_dic:
        print('输入的指令不存在傻叉')
        continue
    func_dic[choice]()

函数嵌套

函数的嵌套定义
def f1():
    def f2():
        print('from f2')
    f2()
f1()

from math import pi

def circle(radius,action='area'): #radius=10
    def area():
        return pi * (radius ** 2)

    def perimeter():
        return 2 * pi * radius

    if action == 'area':
        return area()
    elif action == 'perimeter':
        return perimeter()

print(circle(10))
print(circle(10,action='perimeter'))

函数的嵌套调用
def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max4(a,b,c,d):
    res1=max2(a,b)
    res2=max2(res1,c)
    res3=max2(res2,d)
    return res3

print(max4(1,2,3,4))

名称空间与作用域

1、名称空间namespaces
    存放名字与值绑定关系的地方

2、名称空间分为三大类
    内置名称空间：
        作用：存放python解释器自带的名字
        生命周期：
            在解释器启动时生效，在解释器关闭时失效

    全局名称空间：
        作用：除了内置的与局部的名字外，其余都是全局名字
        生命周期：
            在文件执行时生效，在文件执行完毕时失效

        例如：x，func，y，l，z都是
            x=1
            def func():
                a=1

            y=2
            l=[1,2]

            if 3 > 2:
                if
                    if
                        if
                            z=3
    局部名称空间：
        作用：用于存放函数调用期间函数体产生的名字
        生命周期：
            在文件执行过程
            如果调用了某个函数才会临时生效，在函数执行完毕后失效

    三种名称空间的加载顺序是：
        内置-》全局-》局部

    名称空间就是用来存放名字与值的绑定关系的，所以但凡要查找名字
    一定是从三者之一找到，查找顺序:
        从当前所在的位置倒着查找，如果当前所在的位置是局部名称空间，
        则查找顺序是：
            局部-》全局-》内置

3、作用域：
    域指的是区域、范围，作用域即作用的范围

    全局作用范围，全局作用域（内置名称空间与全局名称空间）
        全局有效，全局存活
    局部作用范围，局部作用域（局部名称空间）
        局部有效，临时存活

作用域关系是在函数定义阶段就固定死了，但凡调用函数都需要跑到定义阶段去找作用域关系

函数对象+作用域：******
def f1():
    x=1
    def inner():
        print('from inner',x)
    return inner
f=f1()

# print(f)

def bar():
    x=111111111111111111111111111111111111111111111
    f()

bar()

x=1
def foo():
    global x
    x=2

foo()
print(x)

x=1
def f1():
    x=33333
    def f2():
        # x=22222222
        def f3():
            nonlocal x
            x=20000000000
        f3()
        # print(x)
    f2()
    print(x)

f1()
# print(x)

legb
在函数内修改g层的变量用global
在函数内修改e层的变量用nonlocal 值修改最近e层的一个值
在局部如果想要修改全局的可变类型，不需要借助任何声明，可以直接修改
在局部如果想要修改全局的不可变类型，需要借助global声明，声明为全局的变量就可以直接修改了

x=[]
def f1():
    x.append(1)
f1()
f1()
print(x)

重点

变量查找逻辑结构：
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间

def f1():
    m = 1
    def f2():
        print(m)
    return f2

x = f1()

def f3():
    m = 3
    x()

f3()