Python函数:理解形参与实参的区别

注意:本文引用自专业人工智能社区Venus AI

更多AI知识请参考原站 ([www.aideeplearning.cn])

函数基本概念

在Python中,函数是一种将代码封装以进行重复使用的机制。它们允许你定义一段代码,以便在程序的多个位置调用,而不必重写相同的代码。这不仅有助于减少冗余,还使得程序更易于维护和调试。

函数的组成

  • 函数头:定义函数的起始部分,包括def关键字、函数名和括号内的形式参数列表。
  • 形参:在函数头中定义的参数。它们是变量的名称,代表了函数可以接收的数据。
  • 函数体:包含一系列定义函数应如何操作输入参数的语句。可以包括逻辑运算、数据处理等。
  • 返回值:函数可以选择性地返回值。这是函数处理过的数据,可以是任何数据类型。
  • 形式参数(形参)

    形参是在函数定义中声明的变量,它们在函数被调用之前没有具体的值。它们是一种占位符,用于表示函数可以接受的数据类型和数量。当函数被调用时,这些形参将被赋予实际的值(实参)。

    实际参数(实参)

    实参是在调用函数时传递给函数的具体值。它们“填充”了形参定义的占位符。实参可以是硬编码的值、变量或者是其他函数的返回值。当函数被调用时,每个实参都被赋给相应的形参,从而使函数可以使用这些具体的值来执行其任务。

    参数的类型

  • 实参的位置参数
  • 实参的关键字参数
  • 形参的缺省参数
  • 形参的不定长参数
  • 详细的代码示例

    Python中的函数, 在开发程序时,很容易遇到一个情景:某些代码在整个项目中需要被用到很多次,为了提高编写的效率以及代码的重用,所以把具有独立功能的代码块组织为一个小模块,这就是函数的概念和作用。

    函数的定义

    1. 函数的格式

    定义函数的命令如下:

    def 函数名():    
        代码

    代码如下:

    # 定义一个函数,能够完成打印信息的功能    
    def printInfo():    
        print('------------------------------------')     
        print('         人生苦短,我用Python' )    
        print('------------------------------------')
        
    printInfo()
    ------------------------------------
             人生苦短,我用Python
    ------------------------------------
    

    定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它。调用函数很简单,通过“函数名()”即可完成调用。

    2. 函数的参数

    先思考一个问题:现在需要定义一个函数,这个函数能够完成2个数的乘法运算,并且把结果打印出来,以下的代码可以实现吗?这样设计有什么缺陷吗?代码如下:

    def mul2():    
        a = 7    
        b = 9    
        c = a*b    
        print (c)

    以上代码可以完成两个数值的相乘,但只适用于特定的两个数值。如果要使该函数更通用,即能计算任意两个数的乘积,在定义函数的时候可以让函数接收要处理的数据,就解决了这个问题,这就是函数的参数。 定义带有参数的函数代码如下:

    def mul2(a, b):     
        c = a*b    
        print (c)

    调用上面函数的方法是调用函数名字,并且在括号里输入函数要处理的具体数据“(参数)”,代码如下:

    def mul2(a, b):     
        c = a*b    
        print (c)
        
    mul2(8,9) #调用带有参数的函数时,需要在小括号中传递数据  
    72
    

    另外,关于函数参数,有两个具体的概念“形参”和“实参”:

    (1)定义时,小括号中的参数,用来接收参数用的,称为 “形参”。

    (2)调用时,小括号中的参数,用来传递给函数用的,称为 “实参”。

    其中,形参可以分别是缺省参数,不定长参数; 实参可以分为位置参数和关键字参数。

    1)实参的位置参数

    函数调用时,按形参的位置,从左往右,一一匹配传递参数。位置参数必须一一对应,缺一不可,代码如下:

    def mul2(a, b):     
        c = a*b    
        print (c)
        
    mul2(7.,9) #7,9这两个实参的传递方法是位置参数
    63.0
    2)实参的关键字参数

    函数调用时,通过“形参=值”方式为函数形参传值,不用按照位置为函数形参传值,这种方式叫关键字参数,代码如下:

    def mul2(a, b):     
        c = a*b    
        print (c)
    mul2(9, b=7) #7,9这两个实参的传递方法是关键字参数,传入顺序可与形参定义顺序不同
    63

    注意:

    (1)关键字参数必须在位置参数的右边,且对同一个形参不能重复传值。

    (2)如果位置参数和关键字参数同时混合使用,那么顺序上必须先传位置参数,再传关键字参数。

    3)形参的缺省参数

    形参设定默认值,称为缺省参数,也叫默认参数,代码如下:

    def mul2(a, b=1):     
        c = a*b    
        print (c)
    mul2(7) 
    mul2(7,9) #b为缺省参数,此时,调用函数时传入新的b,所以在函数计算时b等于9
    7
    63

    注意:

    (1)调用函数时,如果没有传入默认参数对应的实参,则使用默认值。

    (2)默认参数必须在普通参数的后边。

    4)形参的不定长参数

    元组型不定长参数:形参变量名前面加上一个“*”,这个参数则为元组型不定长参数。元组型可变形参必须在形参列表的最后边,代码如下:

    #hanshu.py
    # *args 不定长参数,可以接收0~多个实参    
    # 把实参的1,2,3, 包装成元组(1, 2, 3)再传递, 等价于args = (1, 2, 3)    
    def func(*args):    
        # 函数内部使用,无需加*    
        print(args, type(args))    
    # 函数调用    
    func(1, 2, 3, 4) 
    (1, 2, 3, 4) <class 'tuple'>
    

    字典型不定长参数:定义参数时需要在形参名前添加“**”,则为字典型不定长参数。字典型可变形参必须在形参列表的最后边,代码如下:

    #hanshu.py
    # 把实参包装成 {'city': 'sz', 'age': 18}给kwargs传递    
    # kwargs = {'city': 'sz', 'age': 18}    
    def func(name, **kwargs):    
        # 同时存在形参name, name不会被包装到字典中    
        print(name)    
        print(kwargs)  # 函数内部使用,无需加*    
    # 实参的写法: 变量=数据,变量=数据    
    func(name='mike', city='sz', age=18)     
    mike
    {'city': 'sz', 'age': 18}
    

    函数参数的关键要点总结:

    (1)缺省参数需要在非缺省参数之后。

    (2)关键字参数需要在位置参数之后。

    (3)所有传递的关键字参数必须有对应参数,并且顺序不重要。

    (4)参数只能赋值一次。

    (5)缺省参数通常是可选的,可以不传递值。

    3. 函数的返回值

    返回值,就是程序中函数完成一件事情后,最后给调用者的结果。想要在函数中把结果返回给调用者,需要在函数中使用return关键字,代码如下:

    def add2num(a, b):    
        return a+b 

    注意,当一个函数返回了一个数据,如果想要用这个数据,那么就需要保存。 保存函数的返回值实例代码如下:

    #hanshu.py
    #定义函数    
    def add2num(a, b):    
        return a+b    
    #调用函数,顺便保存函数的返回值    
    result = add2num(72,17)    
    #因为result已经保存了add2num的返回值,所以在接下来的场景中,就可以使用了    
    print (result) #结果等于89
    89
    

    在Python中,在关键字return后面将多个返回值用逗号隔开即可以返回多个值。

    4. 引用和引用传参

    在Python中,值是靠引用来传递的。可以用id()来判断两个变量是否为同一个值的引用。可以将id值理解为变量在计算机中的内存地址标示,代码如下:

    #hanshu.py
    a=1    
    b=a    
    print(id(a)) 
    print(id(b)) 
    a=2    
    print(id(a))      
    print(id(b)) 
    1657366446320
    1657366446320
    1657366446352
    1657366446320
    

    上述代码的图例解释如1所示。

    图1 图例解释

    可变数据类型列表的引用代码如下:

    #hanshu.py
    a=[1,2]    
    b=a    
    print(id(a))
    print(id(b))    
    a.append(3)    
    print(a) 
    print(id(a)) 
    print(id(b))
    1657473933696
    1657473933696
    [1, 2, 3]
    1657473933696
    1657473933696
    

    上述代码的图例解释如图2所示。

    图2 图例解释

    因此,数据类型可变还是不可变的本质是:在改变数据具体的值时,其内存的地址索引是否改变;改变的话当前数据为不可变数据类型,不变的话则为可变数据类型。

    Python中函数参数是引用传递(注意不是值传递)。因此,可变类型与不可变类型的变量分别作为函数参数时,产生的影响是不同的。具体来说,对于不可变类型,因变量不能修改,所以函数中的运算不会影响到变量自身;而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量,代码如下:

    #hanshu.py
    a = (1,2,3)    
    def add(arr):    
        arr += arr  
        
    add(a)    
    print(a)
    (1, 2, 3)
    

    此代码将输出 [1,2,3,1,2,3],而不是 [1,2,3]。

    当传递一个列表(或其他可变对象)给函数时,实际上是传递了这个对象的引用。因此,函数内部对该对象的任何更改将影响函数外部的该对象。

    在 add 函数内部,使用了“+=”运算符,这是一个就地修改的运算符。这意味着它会修改原始列表,而不是创建一个新的列表。因此,当执行arr += arr时,实际上是将arr列表的内容添加到自身,所以结果是 [1,2,3,1,2,3]。

    作者:极光喵

    物联沃分享整理
    物联沃-IOTWORD物联网 » Python函数:理解形参与实参的区别

    发表回复