9.20 函数基础

Posted 2022-11-15 lidandanaa

1.可变长参数：

指的是在调用函数时，传入的参数可以不固定

1.可变长形参之*

形参中的*会将多余的位置实参全部接收，然后以元组的形式存储输出，

注意*后的参数称为args.

def f1(*args):
    print(args)
f1()  #()
f1(1)   #(1,)
f1(1,2)   #(1,2)

2.可变长实参之*

def f2(a,b,c,d,e,f):
    print(a,b,c,d,e,f)
lt=[1,2,3,4,5,6]
f2(*lt) #1 2 3 4 5 6
#lt把列表中的元素打散成位置实参依次传值给位置形参

但凡碰到实参中带*的，它就是位置实参，马上打散成位置实参去看

def func(x,y,z,*args):
   print(x,y,z,args)
func(1,*(2,3),4,5)
运行结果:
 1 2 3 (4,5)

3.可变长形参之**

形参中的**会将多余的关键字实参全部接收，然后存储成字典的形式，

注意**后的参数名约定俗成为kwargs

def func(**kwargs):
    print(kwargs)
func(a=5)
运行结果：
'a':5

4.可变长实参之**

实参中的**会将其后多余的值打散成关键字实参。

def f1(a,b):
    print(a,b)
dic='a':1,'b':2   #a=1,b=2
f1(**dic)   **dic把字典打散成关键字实参然后传值给形参
运行结果：1 2

5.可变长参数的应用：

def index(name,age,sex):
    print(f"name:name,age:age,sex:sex")
def wrapper(*args,**kwargs):
    print(f"args:args")
    print(f"kwargs:kwargs")
    index(*args,**kwargs)
wrapper(name='nick',sex='male',age=19)
运行结果：
args:()
kwargs:'name': 'nick', 'sex': 'male', 'age': 19
name:nick,age:19,sex:male

2.函数对象

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

def func():
    print('from func')
print(func)

函数的四大功能：

1.引用

def func():
    print('from func')
print(func)
f = func
print(f)
运行结果：
<function func at 0x0000000005B0F7B8>
<function func at 0x0000000005B0F7B8>

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

def func():
    print('from func')
def foo(m):
    m()
foo(func)  #from func

3.可以当作函数的返回值

def func():
    print('from func')
def foo(m):
    renturn m
res=foo(func)
print(res)
res()
运行结果：
<function func at 0x0000000005B0F7B8>
from func

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

def func():
    print('from func')

l= [func]
l[0]()  #from func

3.函数的嵌套

函数里边有函数，函数内部定义的函数，外部不能用

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 max_2(x,y):
    if x>y:
        return x
    else:
        return y
def max_4(a,b,c,d):
    res1=max_2(a,b)
    res2=max_2(c,d)
    res=max_2(res1,res2)
    print(res)
    return res
max_4(1,2,3,4)  #4

4.名称空间和作用域：

名称空间，专门存储变量名与值之间绑定关系的

名称空间的执行（生成）顺序：

1.内置名称空间：存储Python解释器内置方法的名称，解释器启动生效，关闭失效

2.全局名称空间：除了内置和局部都叫全局，文件执行时生效，文件结束时失效

x=1
def func():
    pass
l=[1,2]
if 3>2:
    if 4>3:
        z=3   #其中的x，func，l,z就是全局名称空间

3.局部名称空间：用于存放函数调用 期间函数体产生的名字，

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

f1()    #f2是局部名称空间

搜索顺序：先从当前位置寻找，找不到再按照这种顺序找，不会逆着方向寻找

len=10
def f1():
    len=20
    print(len)
f1()   #20

def f1():
    print('from f1')
    def f2():
        print('from f2')
rea=f1()   #from f1

作用域

1.全局作用域：内置名称空间+全局名称空间--》全局作用域

def f1():
    y=2
    print(1,y)
y=10
f1()
print(2,y)
print(y)
运行结果：
1 2
2 10
10

2.局部作用域：

全局作用域的x和局部作用域x没有半毛钱关系

def f1():
    def f2():
        def f3():
            x=1
            print(x)
         x=2
        f3()
     f2()
f1()   #1

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

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

函数对象+作用域的应用

def f1():
    def inner():
        print('from inner')
     return inner
f=f1()
def bar():
    f()
bar()   #from inner

3.global和nonlocal关键字--打破规则

x=1
def f1():
    x=2
    def f2():
        global x  #修改全局
        x=3
    f2()
f1()
print(x)  #没有global打印的是全局变量x=1，有了global打印的是局部变量x=3.

x=1
def f1():
    x=2
    def f2():
        nonlocal x #修改局部
        x=3
    f2()
    print(x)
f1()  #没有nonlocal打印的是局部变量x=2，有了nonlocal打印的是内置变量x=3.

所有可变数据类型均可打破上述一切规则

lt=[10]
def f1():
    lt.append(13)
    lt[0]=11
f1()
print(lt)
运行结果：
[11,13]

lis=[]
def f1():
    lis.append(1)
print(f'调用函数前：lis')
f1()
print(f'调用函数后：lis')
运行结果：
调用函数前：[]
调用函数后：[1]