函数的进阶(动态参数,命名空间和作用域,函数的嵌套,gloabal和nonlocal关键字)

2023-01-22 19:53:25

1. 函数参数--动态传参

　　昨天已经解过了传参, 如果需要给一个函数传参,而参数又是不确定的. 或者我们给一个函数传很多参数, 我的形参就要写很多, 写起来就很麻烦, 这时我们可以考虑使用动态参数.形参的第三种:动态参数.

(1) 动态参数分为两种:

　　1) 动态接收位置参数

　　语法: def 函数名(*args): 在形参前加个'*'符号

def chi(*food):  # *表示任意,即可以接收任意位置参数

    print('我要吃',food)  # 动态参数接收到的是tuple类型的数据

chi('大盘鸡','火锅','烤鱼','烤鸭','冰淇淋')#  我要吃 ('大盘鸡', '火锅', '烤鱼', '烤鸭', '冰淇淋')

def food(he,tang,*cai):

    print('我要吃',he,cai,tang)

food('可乐','紫菜蛋花汤','大盘鸡','烧烤')  #实参'可乐','紫菜蛋花汤'传递给了形参'he','tang',实参'大盘鸡','烧烤'传给了形参'cai'

# 我要吃 可乐 ('大盘鸡', '烧烤') 紫菜蛋花汤

# 定义求一组数相加的和的函数

def sun(*a):

    sum = 0

    for c in a:

        sum = sum + c

    return sum  #返回值为sum

print(sun(1,2,3,4,5,6,7,8,9,10))  #

　　2) 动态接收关键字参数

　　语法: def 函数名(**kwargs): 在形参前面加两个'*'符号

def food(**a):   # **表示任意,即任意接收关键字参数

    print('我想吃',a)  # 接收到的是字典

print(food(主食='米饭',菜='大盘鸡',喝的='可乐'))  #我想吃 {'主食': '米饭', '菜': '大盘鸡', '喝的': '可乐'}

　　形参有位置参数,默认值参数,动态位置参数(*args),动态接收关键字参数(**kwsrgs)这四种. 他们写的先后顺序是:

　　位置参数>>动态接收位置参数>>默认值参数>>动态接收关键字参数

def f(*args,a,b):  #动态接收位置参数写在位置参数前会导致传入的所有实参都传递给'*args',而a,b没有值

    print(args,a,b)

f(1,2,3,4,5,6)  #会报错因为a,b没有值 TypeError: f() missing 2 required keyword-only arguments: 'a' and 'b'

def f(a,b,*args):  #改变一下位置,把*args写在位置参数后面

    print(args, a, b)

f(1,2,3,4,5,6)  #(3, 4, 5, 6) 1 2

def f(a,b,c='hello',*args):  #当默认值参数在*args前面,想要传递给*args值,就必须要传递'c'的值.不想给c值,就无法给*args值

    print(a,b,c,args)

f(1,2,3,4,5)  #1 2 3 (4, 5)

f(1,2)  #1 2 hello ()

def f(a,b,*args,c='hello'):  #把默认值参数放后面,在传递完*args的值后,最后可以用关键字参数传给c

    print(a,b,c,args)

f(1,2,3,4,c='world')  #1 2 world (3, 4)

给定义函数的两个形参*args和**kwargs, 那么这个函数可以接收所有的参数

def fuc(*args,**kwargs):

    print(args,kwargs)

fuc('hello','world','hhhh',一 ='one',二 ='two',三 ='three')

#('hello', 'world', 'hhhh') {'一': 'one', '二': 'two', '三': 'three'}

把列表中的每一个元素作为参数, 传递给函数. 一次都传过去

def func(*args, **kwargs):  # *表示聚合,所有的位置参数, 聚合成元组 **聚合成字典

    print(args)

    print(kwargs)

lst = ["one", "two", "three", "four"]

func(*lst)  # 实参, 打散, 迭代产生的

#('one', 'two', 'three', 'four')

# {}

dic = {"name":"alex", "sex":"男"}

func(**dic) # 把字典打散. 以key=value形式进行传参

#()

# {'name': 'alex', 'sex': '男'}

(2) 函数的注释先写'''''',然后在六个单引号中间位置按回车,自动生成注释

def f(a,b):

    '''

    介绍函数的功能,返回的值

    :param a: 介绍变量a

    :param b: 介绍变量b

    :return:  介绍返回值

    '''

    pass

2. 命名空间和作用域

　　在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, ⾄至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此⽽而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.

def f(a):

    a = 10

    return a

print(f(3))  #

print(a)  #a不存在了,NameError: name 'a' is not defined

　　存放名字和值的关系的空间叫命名空间. 变量在存储的时候就是存储在这片空间中的.

　　命名空间分类:

　　1. 全局命名空间--> 直接在py文件中, 函数外声明的变量都属于全局命名空间

　　2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间

　　3. 内置命名空间--> 存放python解释器提供的名字, list, tuple, str, int这些都是内置命名空间

　　加载顺序:

　　1. 内置命名空间

　　2. 全局命名空间

　　3. 局部命名空间(函数被执⾏行行的时候)

　　取值顺序:

　　1. 局部命名空间

　　2. 全局命名空间

　　3. 内置命名空间
　　

a = 10  #全局

def f():  #全局

    a = 20  #局部

    print(a)  #从局部空间取a的值

f()  #

print(a)  #

a = 10

def f():

    print(a)  #找不到局部a的值时,会去全局命名空间找,如果全局也没有,那么就从内置命名空间找.

f()  #

print(a)  #

　　作用域 : 作用域就是作用范围, 按照生效范围来看分为全局作用域和局部作用域

　　全局作用域 : 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循从上到下逐行执行).

　　局部作用域 : 在函数内部可以使用.

　　作用域命名空间 :

　　1. 全局作用域 : 全局命名空间 + 内置命名空间

　　2. 局部作用域 : 局部命名空间我们可以通过globals()函数来查看全局作用域中的内容, 也可以通过locals()来查看局部作用域中的变量和函数信息

a = 10

def func():

    a = 20

    print(a)    # 就近原则

    print(globals())  # globals() 获取到全局作用域(内置,全局)中的所有名字

    print(locals())  # locals() 查看当前作用域中的所有名字

func()

#

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at

#0x0000011BD70A6160>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 
#'D:/pycharm/练习/week02/new10.py', '__cached__': None, 'a': 10, 'func': <function func at 0x0000011BD74697B8>}

# {'a': 20}

3. 函数的嵌套

(1)只要遇见了()就是函数的调用, 如果没有()就不是函数的调用.

(2) 函数的执行顺序

def func1():

    print("赵")

    def func2():

        print("钱")

        def func3():

            print("孙")

        print("李")

    def func4():

        print("哈哈")

        func2()

    print("周")

    func2()

func1()

# 赵

# 周

# 钱

# 李

4. gloabal, nonlocal关键字

(1) global表示不再使用局部作用域中的内容了. 而改用全局作用域中的变量

a = 10  #全局变量

def f():

    global a  #把全局变量的a拿来用了

    a = a + 20  #改变的a是全局变量a

    print(a)

f() #

print(a)  #

def f():

    global a  #建立一个全局变量的a

    a = 20  #给全局变量a赋值

    print(a)

f() #

print(a)  #

(2)nonlocal 表示在局部作用域中, 调用其他层的局部变量(就近原则调用).

a = 10

def f():

    a = 20

    print(a)  320

    def ff():

        nonlocal a  # 找局部作用域中 离他最近的那个变量引入进来,将函数f中的a引入

        a = a + 20  #函数f中的a变成40

        print(a)  #

    ff()

    print(a)  #

f()

#

#

#

print()  #

码农公寓

相关文章