day11课堂小结 函数作用域

可变长参数

可变长参数：指的是调用函数时，传入的参数个数可以不固定

*形参（形参名）

*args(约定俗成)，接收多余位置实参，用元组接收

def f1(*a) # 调用函数时，有多少个参数，我就接收多少个参数
    print(a)
    
f1() # () # a是空元组
f1(1)   # (1,)
f1(1,2)
f1(1,2,3,4,5,6,7,6,6,)
f1(b=1) #报错

def f1(*abc,b):
    print(abc,b)

f1(b=1) # () 1

**形参

**kwargs，用字典接收多余的关键字实参

def f1(**kwargs):
    print(kwargs)
    
    
f1() # 空字典
f1(x=1) # {'x':1}

def f1(*args,**kwargs):
    print('args:',args)
    print('kwargs:'kwagrs)
    
    
f1(11,1,12,2,x=1,y=2,z=3) 
# agrgs:(11,1,12,2)
# kwargs:('x':1,'y':2,'z':3)

def f1(a,b,c,*args,**kwargs):
    print('args:',args)
    print('kwargs:'kwagrs)
    
    
f1(11,1,12,2,x=1,y=2,z=3) 
# agrgs:(2,)
# kwargs:('x':1,'y':2,'z':3)

记住是接收多余的值

*实参

def f1(a,b,c,d,e,f,g):
    print(a,b,c,d,e,f,g)

lt = [1,2,3,4,5,6,7]
#f1(lt[0],t[1],t[2],t[3],t[4],t[5],t[6]) 换成 f1(*lt)
f1(*lt) # *lt把列表中的元素打散成位置实参一次传给位置形参

# 1 2 3 4 5 6 7

**实参

def f1(*args,**kwargs):
    print('args',args)
    print('kwargs',kwargs)
    
# def f1(x,y):  报错   

dic = {'a':1,'b':2} # a=1,b=2
f1(**dic)   # **dic把字典打散成关键字实参然后传给函数f1
 # args()
 # kwargs{'a':1,'b':2}

函数对象

python中一切皆对象

s = 's1'
lt = ['skdjf']

函数是第一类对象，即函数可以当作数据处理

def func():
    print()
    
    
print(func)

<function func at 0x10af72f28>

一、函数对象的四大功能

1. 引用

x = 'hello nick'
y = x

f = func
print(f)

<function func at 0x10af72f28>

1. 当作参数传给一个函数

len(x)

def foo(m)
    m()
    
    
foo(func)

from func

1. 有当作函数的返回值

def foo(x):
    return x

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

1. 可以当作容器类型的元素

l = [x]

function_list = [func]
function_list[0]()

from func

函数对象的练习

def pay():
    print('支付1e成功')
    
    
def withdraw():
    print('提现2e成功')
    
    
dic = {
    '1':pay,
    '2':withdraw,
}
while True:
    msg = '''
    '1':支付,
    '2':提现,
    '3':退出,
    '''
    print(msg)
    choice = input('选择功能：').strip()
    if choice == '3':
        break
    elif choice in dic :
        dic[choice]()
    

函数嵌套

函数的嵌套定义

函数内部定义的函数，无法在函数外部使用内部定义的函数。

def f1():
    def f2():
        print('from f2')
    f2()
    
f2() # NameError: name 'f2' is not defined
   

def f1():
    def f2():
        print('from f2')
    f2()
    
    
f1()
        

from f2

函数嵌套的调用

def max2(x,y):
    if x > y:
        return x
    else:
        return y
    
    
def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(c,d)
    res = max2(res1,res2)
    return res

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

4

名称空间和作用域

一、名称空间

​ 名称空间（name spaces）：变量的创建其实就是在内存中开辟了一个新的空间。

而内存中有一块内存存储变量名与变量间的绑定关系的空间，而这个空间称为名称空间。

1. 内置名称空间

内置名称空间：存放Pyhton解释器自带的名字，如int、float、len

生命周期：在解释器启动时生效，在解释器关闭时失效

1. 全局名称空间

全局名称空间：除了内置和局部的名字之外，其余都存放在全局名称空间。

如下面代码中的x、func、l、z

生命周期：在文件执行时生效，在文件执行结束后失效

x = 1


def func():
    pass


l = [1, 2]

if 3 > 2:
    if 4 > 3:
        z = 3

1. 局部名称空间

局部名称空间：用于存放函数调用期间函数体产生的名字，如下面代码的f2

生命周期：在文件执行时函数调用期间时生效，在函数执行结束后失效

def f1():
    def f2():
        print('from f2')
    f2()

f1() 

1. 加载顺序

   内置--》全局--》局部

2. 查找顺序

   当前--》全局--》内置

x = 1
y = 2
len = 100


def func():
    y = 3
    len = 1000
    print(f"y: {y}")
    print(f"len: {len}")
    # print(a)  # NameError: name 'a' is not defined


func()

y: 3
len: 1000

二、作用域

域指的是区域，作用域即作用的区域。

1. 全局作用域

全局作用域：全局有效，全局存活，包含内置名称空间和全局名称空间。

# 全局作用域
x = 1


def bar():
    print(x)


bar()

1. 局部作用域

局部作用域：局部有效，临时存储，只包含局部名称空间。

# 局部作用域
def f1():
    def f2():
        def f3():
            print(x)
        x = 2
        f3()
    f2()


f1()

1. 注意点

需要注意的是：作用域关系在函数定义阶段就固定死了，与函数的调用无关。

# 作用域注意点
x = 1


def f1():  # 定义阶段x=1
    print(x)


def f2():
    x = 2
    f1()


f2()

1

1. global关键字

修改全局作用域中的变量。

x = 1


def f1():
    x = 2

    def f2():
        #         global x  # 修改全局 输出 3
        x = 3
    f2()


f1()
print(x)

1

1. nonlocal关键字

修改局部作用域中的变量。

x = 1


def f1():
    x = 2

    def f2():
        #         nonlocal x 输出 3
        x = 3

    f2()
    print(x)


f1()