python 函数嵌套的参数_Python day13:函数参数+函数对象+函数嵌套+名称空间+作用域...

一：可变长参数

可变长指的是参数的个数不固定

站在实参的角度，实参是用来为形参赋值的，如果实参的个数不固定，那么必须要有对应的形参能够接收溢出实参

*与*在形参与实参中的应用

在形参中用*与*

1.1 在形参名前加 *：* 会把溢出的位置实参存成元组，然后赋值其后的形参名

def func(x,*y): # y=(2,3,4)

print(x)

print(y)

func(1,2,3,4)

func(1)

func() # 位置形参x必须被传值

'''示范：'''

def add(*nums):

res = 0

for num in nums:

res += num

return res

res=add(1, 2, 3)

print(res)

1.2 在形参名前加**：**会把溢出的关键字实参存成字典，然后赋值其后的形参名

def func(x, **y): # y=(2,3,4)

print(x)

print(y)

func(1,a=111,b=222,c=333)

func(a=111, b=222, x=1, c=333)

在实参中用\*与\**

def func(x, y, z):

print(x, y, z)

1.3 在实参前加*：*会把其后的值打散成位置实参

nums = [1, 2, 3]

func(*nums) # func(1,2,3)

# 若只有一个形参，则多余出来的值没处放，会出错

def fun(x)

print(x)

1.4 在实参前加 **：**会把其后的值打散关键字实参

dic = {'y': 111, 'z': 222, 'x': 333}

func(**dic) # func(y=111,z=222,x=333)

'''

在形参与实参中混用*与**

'''

'''

同时使用*与**的作用是可以把外部传的值原封不动的传给另一个函数，这在闭包函数，装饰器中有很大作用

'''

def index(x,y,z,a,b,c):

print("index===>",x,y,z,a,b,c)

def wrapper(*args, **kwargs): # args=(1, 2, 3,) kwargs={"a":111,"b":222,"c":333}

index(*args, **kwargs) # index(*(1, 2, 3,),**{"a":111,"b":222,"c":333})

# index(1,2,3,c=333,b=222,a=111)

wrapper(1, 2, 3, a=111, b=222, c=333)

函数参数总结：

# def func(x,y=222,*args,**kwargs):

# pass

# 命名关键字形参(了解即可)

def func(x, y=222, *args, n=777,m, **kwargs): # m,n必须按照关键字实参的格式为其赋值

print(x) # 1

print(y) # 2

print(args) # (3,4,5)

print("m===>", m)

print("n===>", n)

print(kwargs)

func(1, 2, 3, 4, 5, n=88888,m=6666666, a=11, b=22, c=33)

二、函数对象

函数对象指的是函数可以被当成变量去使用

def foo(): # foo = 函数的内存地址

print('from foo')

1 可以被赋值

f = foo

print(f is foo)

f()

2 可以当作参数传给一个函数

def bar(func):

print(func)

func()

bar(foo)

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

def bar(func):

return func

res=bar(foo)

print(res)

4 可以当成容器类型的元素

l = [foo]

print(l)

l[0]()

示例:当我们的主函数是由多个其他函数组成，即我们需要使用许多的if来判断用户输入且调用对应的函数时候，可以使用这种容器的方法，使得代码量减少,同时，在面试时，若被问到如何减少if操作时，可使用字典替换

def login():

print('登录功能......')

def withdraw():

print('提现功能......')

def transfer():

print('转账功能......')

def recharge():

print('充值功能')

func_dic={

"1": [login,"登录"],

"2": [withdraw,"提现"],

"3": [transfer,"转账"],

"4": [recharge,"充值"]

}

func_dic["1"][0]()

while True:

print("0 退出")

for k in func_dic:

print("%s %s" %(k,func_dic[k][1]))

choice = input("请输入你的指令编号: ").strip()

if choice == "0":

break

if choice in func_dic:

func_dic[choice][0]()

else:

print('输入的指令不存在')

三、函数嵌套

1 函数的嵌套调用

def bar():

print('from bar')

def foo():

print('from foo')

bar()

foo()

案例:

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)

print(res3)

max4(1,2,3,4)

2 函数的嵌套定义

def f1():

print('from f1')

# f2 = 函数的内存地址

def f2():

print("from f2")

f1()

定义在函数内的函数特点是: 正常情况只能在函数体内调用

from math import pi

def circle(radius,mode=0):

def perimiter(radius):

return 2 * pi * radius

def area(radius):

return pi * (radius ** 2)

if mode == 0:

return perimiter(radius)

elif mode == 1:

return area(radius)

res1=circle(3,0)

res2=circle(3,1)

print(res1)

print(res2)

-------------------------

18.84955592153876

28.274333882308138

def func():

x = 10

print(x)

def f2():

print('from f2')

f2()

func()

print(x)

---------------------------------

Traceback (most recent call last):

File "xxx", line 122, in

print(x)

NameError: name 'x' is not defined

10

from f2

四、名称空间与作用域

'''

名称空间：就是存放名字的地方

名(函数名、变量名等)：存放在内存里

值(变量值等)：存放在内存里

通过划分出各个名字空间，允许在不同的空间内，可以有相同的名字

1、内置名称空间：存放内置的名字(python解释器启动时便定义好的)如 print、input、len

生命周期：解释器启动则产生，解释器关闭则销毁 (python解释器在pyhton程序执行时运行，执行结束时结束)

2、全局名称空间：存放的是顶级的名字

生命周期：python程序运行时则产生，python程序结束则销毁

3、局部名称空间：函数内的名字

只有调用函数时，局部名字才产生,定义函数时，并不会产生，因为代码并未执行

生命周期：调用函数时产生，函数调用结束则销毁

访问 同名名字的优先级：局部>全局>内置

从当前位置往外查找

名字的查找优先级:

从当前位置往外查找,如果当前是在局部:局部名称空间->全局名称空间->内置名称空间

从当前位置往外查找,如果当前是在全局:全局名称空间->内置名称空间

'''

1 内置名称空间: 存放的是内置的名字,如print\input\len

生命周期: 解释器启动则产生,解释器关闭则销毁

2 全局名称空间: 存放的是顶级的名字

生命周期: python程序运行时则产生,python程序结束则销毁

x = 10

def func():

x = 111

print(x)

if 1:

y = 6666

3 局部名称空间:函数内的名字

生命周期: 调用函数时则产生,函数调用结束则销毁

名字的查找优先级:

从当前位置往外查找,如果当前是在局部:局部名称空间->全局名称空间->内置名称空间

从当前位置往外查找,如果当前是在全局:全局名称空间->内置名称空间

示范1:

def func():

len = 222

# print(len)

# len = 111

func()

print(len)

名称空间可以理解为一层套一层的关系,问题是嵌套关系是在函数定义阶段生成的,还是在函数调用阶段生成的?

x = 111

def foo():

print(x)

def bar(f):

x=222

f()

bar(foo)

一个非常重要的结论:名称空间的嵌套关系是函数定义阶段(即扫描语法时)就固定死的,与函数的调用位置无关

x = 111

def func():

print(x)

x=2222

func()

练习

x=0

def f1():

# x=1

def f2():

# x=2

print(x)

f2()

f1()

len = 111

def f1():

len=2222

def f2():

len=3333

f1()

f2()

全局范围/全局作用域:内置名称空间+全局名称空间

特点:全局存活,全局有效

局部范围/局部作用域:局部名称空间

特点:临时存活,局部有效

了解:

global(****) 在局部名称空间中指定某个变量为全局变量

nonlocal(***)

案例1

x = 10

def func(x): # x = 值10的内存地址

# x = 值10的内存地址

x = 20

func(x) # func(值10的内存地址)

print(x)

案例2

x = [11,22,33]

def func(x): # x = 列表[11,22,33]的内存地址

# x = 列表[11,22,33]的内存地址

# x=444444444444

x[0] = 66666

func(x) # func(列表[11,22,33]的内存地址)

print(x)

案例3

x = [11,22,33]

def func():

x[0] = 66666

func()

print(x)

案例4

x = 10

def func():

global x

x=22

func()

print(x)

案例5:nonlocal生命名字是来自于外层函数的(了解)

x = 10

def f1():

x=111

def f2():

nonlocal x

x=222

f2()

print(x)

f1()

print(x)