函数参数-动态参数

之前我们说过传参,如果我们在传参数的时候不很清楚有哪些的时候,或者说给一个函数传了很多参数,我们就要写很多,很麻烦怎么办呢,我们可以考虑使用动态参数

形参的第三种:动态参数

动态参数分为两种:

1.动态接受位置参数

首先我们来回顾下位置参数

1
2
3
4
def eat(a,b,c):
    print('我想吃%s%s%s'%(a,b,c))
 
eat('大米饭','中米饭','小米饭')

现在有个问题,你们看我这体型也知道吃的不止这些,但是为了让我能够吃饱我们就需要多来些食物,这时我们就要用到动态参数　　

在参数位置用*表示接受任意参数

1
2
3
4
def eat(*args):
    print('我想吃',args)
 
eat('大米饭','中米饭','小米饭')  # 收到的结果是一个tuple元祖

动态接收参数的时候要注意: 动态参数必须在位置参数后面

1
2
3
4
5
6
7
8
def eat(*args,a,b):
    print('我想吃',args,a,b)
eat('大米饭','中米饭','小米饭')
 
结果:
TypeError: eat() missing 2 required keyword-only arguments: 'a' and 'b'
 
# eat函数在调用的时候发现缺少俩个位置参数没有进行传递

通过上述代码发现一个问题就是,我们明明给了多个参数,为什么还会提示参数未传递呢?

原因就是因为这个*在搞鬼  *把所有的位置参数都给接受了,所有会报错.我们尝试着把a,b放在*的前面试试

1
2
3
4
5
6
def eat(a,b,*args):
    print('我想吃',args,a,b)
eat('大米饭','中米饭','小米饭')
 
结果:
我想吃 ('小米饭',) 大米饭 中米饭

动态接收参数的时候要注意:动态参数必须在位置参数后面

那默认值参数呢?

1
2
3
4
5
6
7
def eat(a,b,c='白菜',*args):
    print('我想吃',a,b,c,args)
 
eat('豆腐','粉条','猪肉','大葱')
 
结果:
我想吃 豆腐 粉条 猪肉 ('大葱',)  # 我们定义好的白菜没有生效,被猪肉给覆盖了

我们发现默认值参数写在动态参数前面,默认值的参数是不会生效的

1
2
3
4
5
6
7
def eat(a,b,*args,c='白菜'):
    print('我想吃',a,b,args,c)
 
eat('猪肉','粉条','豆腐','大葱')
 
结果:
我想吃 猪肉 粉条 ('豆腐', '大葱') 白菜  # 这样默认参数就生效了

这个时候如果你不给出关键字传参,那么你的默认值是永远都生效的　　

注意: 形参的顺序:  位置参数 , 动态参数 , 默认参数

动态接收关键字参数

在python中可以动态的位置参数,但是*这种情况只能接收位置参数无法接收关键字参数,在python中使用**来接收动态关键字参数

1
2
3
4
5
6
7
def func(**kwargs):
    print(kwargs)
     
func(a=1, b=2, c=3)
 
结果:
{'a': 1, 'b': 2, 'c': 3}

动态关键字参数最后获取的是一个dict字典形式　　

顺序的问题, 在函数调用的时候, 如果先给出关键字参数, 则整个参数列表会报错.

1
2
3
4
5
6
7
8
9
10
def func(a,b,c,d):
    print(a,b,c,d)
 
func(1,2,c=3,4)
 
结果:
  File "D:/python_object/path2/test.py", line 806
    func(1,2,c=3,4)
                ^
SyntaxError: positional argument follows keyword argument

关键参数必须要放在位置参数后边,由于实参是这个顺序,所以形参接收的时候也是这个顺序.也就是说位置参数必须在关键字参数前面.动态接收关键字参数也要在后面

最终顺序:

　　位置参数 > *args(动态位置参数)  > 默认值参数 > **kwargs(动态默认参数)

　　这四种参数可以任意的使用

如果想接收所有的参数:

1
2
3
4
def func(*args,**kwargs):
    print(args,kwargs)
 
func(1,23,5,a=1,b=6)

动态参数还可以这样传参:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
lst = [1,4,7]
# 方法一
def func(*args):
    print(args)
 
func(lst[0],lst[1],lst[2])
 
# 方法二
def func(*args):
    print(args)
func(*lst)  
 
# 在实参的位置上用*将lst(可迭代对象)按照顺序打散
# 在形参的位置上用*把收到的参数组合成一个元祖

字典也可以进行打散,不过需要**

1
2
3
4
5
dic = {'a':1,'b':2}
def func(**kwargs):
    print(kwargs)
 
func(**dic)

函数的注释:

1
2
3
4
5
6
7
8
9
10
11
def eat(food,drink):
    '''
    这里描述这个函数是做什么的.例如这函数eat就是吃
    :param food:  food这个参数是什么意思
    :param drink: drink这个参数是什么意思
    :return:  执行完这个函数想要返回给调用者什么东西
    '''
 
    print(food,drink)
 
eat('麻辣烫','肯德基')

名称空间

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

1
2
3
4
5
def fun():   
    a = 10   
    print(a)
fun()
print(a)    # a不存在了已经

我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就 是存储在这片空间中的.

命名空间分类:

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

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

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

　

加载顺序:

　　1. 内置命名空间

　　2. 全局命名空间

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

取值顺序:

1. 局部命名空间

2. 全局命名空间

3. 内置命名空间

1
2
3
4
5
6
a = 10
def func():   
    a = 20   
    print(a)
 
func()  # 20

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

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

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

作⽤域命名空间:

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

　　2. 局部作⽤用域:    局部命名空间

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

1
2
3
4
5
6
7
8
9
10
a = 10
def func():   
    a = 40   
    b = 20   
    def abc():       
        print("哈哈")   
        print(a, b)     # 这⾥里里使⽤用的是局部作⽤用域   
        print(globals())    # 打印全局作用域中的内容   
        print(locals())     # 打印局部作用域中的内容
func()    　　

函数的嵌套

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

2. 函数的执行顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def fun1():   
    print(111)  
 
def fun2():   
    print(222)   
    fun1()
    
fun2()
print(111)
 
# 函数的嵌套
def fun2():   
    print(222)   
    def fun3():       
        print(666)   
    print(444)   
    fun3()   
    print(888)
print(33)
fun2()
print(555)

gloabal、nonlocal

首先我们写这样一个代码, 首先在全局声明一个变量, 然后再局部调用这个变量, 并改变这 个变量的值

1
2
3
4
5
6
7
a = 100
def func():   
    global a    # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a   
    a = 28   
print(a)
func()
print(a)

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

1
2
3
4
5
6
7
lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():   
    lst.append("⻢云")   
    # 对于可变数据类型可以直接进⾏访问. 但是不能改地址. 说⽩了. 不能赋值 在函数中赋值就是在局部空间创建了一个变量   
　　 print(lst)
func()
print(lst)

nonlocal 表示在局部作用域中, 调用父级命名空间中的变量.

如果父级命名空间中没有这个变量名,就继续向上查找.最多找到最外成的函数就结束了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
a = 10
def func1():   
    a = 20   
    def func2():
        nonlocal a       
        a = 30       
        print(a)  
    func2()   
    print(a)
func1()
 
结果:
加了nonlocal
30
30
 
不加nonlocal
30
20   

再看, 如果嵌套了很多层, 会是一种什么效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = 1
def fun_1():   
    a = 2   
    def fun_2():       
        nonlocal a       
        a = 3       
        def fun_3():           
            a = 4           
            print(a)       
        print(a)       
        fun_3()       
        print(a)   
    print(a)   
    fun_2()   
    print(a)
print(a)
fun_1()
print(a)

这样的程序如果能分析明白. 那么作用域, global, nonlocal就没问题了

python 小兵(6)函数进阶的更多相关文章

  1. 【python 3】 函数 进阶

    函数进阶 1.函数命名空间和作用域 命名空间一共分为三种: 全局命名空间 局部命名空间 内置命名空间 *内置命名空间中存放了python解释器为我们提供的名字:input , print , str ...

  2. python语法基础-函数-进阶-长期维护

    ###############    函数的命名空间和作用域    ############## """ # 函数进阶 命名空间和作用域 命名空间 全局命名空间——我们自 ...

  3. (转)Python内置函数进阶之“属性（property（））”详解

    原文:https://blog.csdn.net/GeekLeee/article/details/78519767 版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.c ...

  4. python学习之---函数进阶

    一,递归函数: 做程序应该都知道,在一个函数的内部还可以调用其它函数,这叫函数的调用,但是有一种特殊的情况,在一个函数内部对自身函数的调用,我们成这为函数的递归调用. 在此,使用一个家喻户晓的例子来演 ...

  5. python学习总结(函数进阶)

    -------------------程序运行原理------------------- 1.模块的内建__name__属性,主模块其值为__main__,导入模块其值为模块名     1.创建时间, ...

  6. 周末班：Python基础之函数进阶

    迭代器和生成器 迭代和可迭代 什么是迭代(iteration)? 如果给定一个list或tuple,我们要想访问其中的某个元素,我们可以通过下标来,如果我们想要访问所有的元素,那我们可以用for循环来 ...

  7. Python学习之函数进阶

    函数的命名空间 著名的python之禅 Beautiful is better than ugly. Explicit is better than implicit. Simple is bette ...

  8. Python全栈开发之路 【第五篇】：Python基础之函数进阶(装饰器、生成器&迭代器)

    本节内容 一.名称空间 又名name space,就是存放名字的地方.举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的地方. 名称空间共3种,分别如下 ...

  9. python基础之函数进阶之函数作为返回值/装饰器

    因为装饰器需要用到返回函数的知识,所以在这里将返回函数和装饰器合并讲解. 什么是返回函数? 我们知道,一个函数中return可以返回一个或者多个值,但其实,return不仅可以返回值,还可以返回函数. ...

随机推荐

  1. 教你Python字符串的基本操作：拆分和连接

    摘要:由于字符串数据几乎无处不在,因此掌握有关字符串的交易工具非常重要.幸运的是,Python 使字符串操作变得非常简单,尤其是与其他语言甚至旧版本的 Python 相比时. 本文分享自华为云社区&l ...

  2. Kronecker Products and Stack Operator

    目录 定义 Stack Operator Kronecker Product 性质 Stack Operator Kronecker Product 半线性 Whitcomb L. Notes on ...

  3. Generative Adversarial Nets (GAN)

    目录 目标 框架 理论 数值实验 代码 Generative Adversarial Nets 这篇文章,引领了对抗学习的思想,更加可贵的是其中的理论证明,证明很少却直击要害. 目标 GAN,译名生成 ...

  4. ActiveMQ基础教程（二）：安装与配置（单机与集群）

    因为本文会用到集群介绍,因此准备了三台虚拟机(当然读者也可以使用一个虚拟机,然后使用不同的端口来模拟实现伪集群): 192.168.209.133 test1 192.168.209.134 test ...

  5. 快过年了，如何使用 AutoJS 自动化快速抢微信红包！

    快过年了,群里一般会充斥着各种红包,你抢红包的手速怎么样呢?AutoJS 是一款 Android 端的应用软件,它可以基于无障碍服务主动或基于任务,完成一系列自动化操作 官网:https://pro. ...

  6. CSS基础 盒子相关属性总结 padding+border

    1.border当个属性: 作用 属性名 属性值 边框粗细 border-width 数字+px 边框样式 border-style solid实线.dashed虚线.dotted点线 边框颜色 bo ...

  7. 解构插槽 Prop

    <!DOCTYPE html> <html> <head> <meta charset="utf-8"/> <link rel ...

  8. 初识python： 斐波拉契数（生成器获取）

    使用  生成器(yield) 获取斐波拉契数. 代码如下: def fun(n): a,b,c = 0,0,1 while a < n: yield b # b, c = c, b + c 以下 ...

  9. vue3.0+vite项目搭建

    npm init vite-app <project-name> cd <project-name> 根据控制台的提示执行: npm install / yarn npm ru ...

  10. h5跳转高德地图

    <a href="https://uri.amap.com/marker?position=经度,纬度&name=所在的位置名称">高德地图</a>