8. Python的函数

我就是我 2024-04-17 05:56 51阅读 0赞

### 认识函数 ###

函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内置函数，比如`print()`、`round()`、`help()`。也可以自己创建函数，这被叫做用户自定义函数。

a = 1.2345
    result = round(a, 2)
    print(result)
    
    1.23                #结果

函数的特点：

1.  功能性
2.  隐藏细节
3.  避免编写重复代码

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

### 函数的定义及运行特点 ###

Python中使用函数必须要先定义函数。Python中使用`def`关键字来定义函数，后面跟`()`，`()`中是函数的参数列表，在类中的函数被称为方法。

*  格式：

def funcname(self, parameter_list):
        pass

对于函数，参数列表可以没有，在函数体中可以使用`return`关键字来返回函数的结果。

*  示例：

def add(x, y):
        result = x + y
        return result
    
    a = add(3, 2)
    print(a)

函数中没有`print()`将不会显示运行结果，`return`只是返回函数结果而不显示出来。

如果函数中不使用`return`，Python会默认`return None`。使用`return`的话，函数中`return`后面的代码将不再执行。

一个函数可以返回多个结果，通过使用`return result1, result2, result3...`格式来实现返回多个结果，结果类型是元组类型。

*  示例：

def damage(skill1, skill2):
        damage1 = skill1 * 6
        damage2 = skill2 * 5 + 10
        return damage1, damage2
    
    damages = damage(3, 6)
    print(type(damages))
    
    skill1_damage,skill2_damage = damage(3, 6)
    print(skill1_damage, skill2_damage)
    
    <class 'tuple'>             #结果
    18 40

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

### 序列解包与链式赋值 ###

Python有一种一次给多个变量赋值的方法，称为序列解包。上面的例子中就使用了序列解包。

*  示例：

a,b,c = 1,2,3
    print(a, b, c)
    
    d = 1,2,3
    print(type(d))
    
    a,b,c = d               #序列解包
    print(a, b, c)
    
    1 2 3               #结果
    <class 'tuple'>
    1 2 3

需要注意的是，序列解包时元素个数必须相等。

链式赋值，就是同时对几个变量进行赋值。

*  示例：

# a = 1
    # b = 1
    # c = 1
    
    # a,b,c = 1,1,1
    
    a=b=c=1             #链式赋值
    print(a, b, c)
    
    1 1 1               #结果

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

### 参数类型 ###

#### 形参与实参 ####

函数参数的作用是传递数据给函数使用。在使用的过程中，参数有两种形式：`形式参数`（形参）和`实际参数`（实参）。

形参：定义函数时的参数；实参：调用函数时的参数。

#### 位置参数与关键字参数 ####

实参又分为`位置参数`与`关键字参数`。

位置参数，即调用函数时必须要传的参数，位置参数的顺序与定义的形参一一对应；关键字参数是调用函数时传递给函数的名称—值对，关键字参数无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

#### 默认参数 ####

定义函数时，可给每个形参指定默认值，这就是`默认参数`。在调用函数中给形参提供了实参时，Python将使用指定的实参值；否则，将使用形参的默认值。给形参指定默认值后，可在函数调用中省略相应的实参。使用默认参数可简化函数调用，还可清楚地指出函数的典型用法。

注意，**使用默认参数时，在形参列表中必须先列出没有默认值的形参，再列出有默认参数**。

调用参数时，位置参数的顺序必须与形参列表中没有默认值的形参一一对应。然后对于后面的参数，Python也是按默认参数顺序一一对应的，当然也可以使用关键字参数来忽略默认参数的顺序，但位置参数绝对不能夹杂在关键字参数之间。

注意，**调用函数时，关键字参数必须在位置参数的后面**。

#### 可变参数 ####

`可变参数`，即定义函数时参数列表中的形参数量可变，这样的参数称为可变参数。对于可变参数，既可传入相应的参数，也可以什么都不传。

可变参数分为`可变位置参数`和`可变关键字参数`。

当我们定义了一个如`*param`这样的形参，在调用函数时，从此处开始直到结束的所有位置参数都将被收集并汇集成一个称为`param`的元组（Tuple）。

类似地，当我们定义了一个如`**param`的形参，在调用函数时，从此处开始直到结束的所有关键字参数都将被收集并汇集成一个名为`param`的字典（Dictionary）。

可以看作`*param`这样的形参在定义可变位置参数；也可以看作`**param`这样的形参在定义可变关键字参数。

*  示例：

def demo(*param):
        print(param)
        print(type(param))
        
    demo(1,2,3,4,5,6)
    
    (1, 2, 3, 4, 5, 6)              #结果
    <class 'tuple'>

可以看到，所有位置参数形成了名为`param`的元组。

当我们要传入的实参是序列（列表或元组）时，如何保证参数不形成二维元组呢？

*  示例：

def demo(*param):
        print(param)
        print(type(param))
    
    a = [1, 2, 3, 4, 5, 6]
    
    demo(*a)                #类似序列解包
    
    (1, 2, 3, 4, 5, 6)              #结果
    <class 'tuple'>

要想将序列（列表或元组）中的元素当作参数传入函数时，在序列前面加上`*`，类似序列解包，将位置参数依次传入。

可变参数可以与前面介绍的参数结合起来使用。在定义函数时，尽量保证形参的类型更少，这样更有利于函数的调用。

*  示例：

def demo(param1, *param, param2=2):
        print(param1)
        print(param)
        print(param2)
        
    demo('a', 1, 2, 3, param2 = '222')
    
    a               #结果
    (1, 2, 3)
    222

在使用可变参数和默认参数时，对于默认参数，传入的实参应该是关键字参数。

可变关键字参数是通过`**param`这样的形参来定义的。

*  示例：

def city_temp(**param):
        print(param)
        print(type(param))
        
    city_temp(bj='32c', sh='30c', sz='26c')
    
    { 'bj': '32c', 'sh': '30c', 'sz': '26c'}             #结果
    <class 'dict'>

可以看到，所有关键字参数形成了名为`param`的字典。

*  示例：

def city_temp(**param):
        for k,v in param.items():               #字典的遍历
            print(k, ':', v)
    
    city_temp(bj='32c', sh='30c', sz='26c')
    
    bj : 32c                #结果
    sh : 30c
    sz : 26c

def city_temp(**param):
        for k,v in param.items():               #字典的遍历
            print(k, ':', v)
    
    a = { 'bj':'32c', 'sh':'30c', 'sz':'26c'}
    city_temp(**a)
    
    bj : 32c
    sh : 30c
    sz : 26c

与上面类似，要想将字典中的key-value当作参数名称-值对传入函数时，在序列前面加上`**`，类似序列解包，将关键字参数依次传入。

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

### 变量作用域 ###

变量的作用域，即变量的作用范围，一个变量如果超出了它的作用范围则该变量会失效。

*  示例：

c = 10
    
    def add(x,y):
        c = x + y
        print(c)
    
    add(1,2)
    print(c)
    
    3               #结果
    10

由变量的作用域可以将变量分为`全局变量`与`局部变量`。

在全局环境下定义的变量称为全局变量，全局变量的作用域是全局，即可以在全局起作用。

在函数体内部定义的变量称为局部变量，局部变量的作用域只有函数内部，只能在函数内部起作用。

函数内部可以引用全局变量，而在函数外部不能引用函数的局部变量。

局部变量只是一个相对的概念，Python中也没有块级作用域这样一个概念，因此函数体内部的if、for、while这样的代码块是可以引用该函数的局部变量的，该函数局部变量的作用域就是整个函数。

*  示例：

c = 1
    
    def func1():
        c = 2
        def func2():
            c = 3
            print(c)
        func2()
    func1()
    
    3               #结果

*  示例：

c = 1
    
    def func1():
        c = 2
        def func2():
            #c = 3
            print(c)
        func2()
    func1()
    
    2               #结果

*  示例：

c = 1
    
    def func1():
        #c = 2
        def func2():
            #c = 3
            print(c)
        func2()
    func1()
    
    1               #结果

可以看到，Python中的作用域有一个链式的特性，变量会“从内到外”逐层寻找与引用，这称为`作用域链`。变量的引用遵循作用域链。

### global关键字 ###

上面定义的全局变量是定义在模块之内的，但全局变量不仅仅可以作用于模块之内，全局变量可以作用于整个程序，只不过需要导入（import）对应全局变量的模块。另外，全局变量很容易被局部变量覆盖，因为将全局变量更改为局部变量只需要将变量在函数内重新赋值即可。

而要想将函数内的局部变量改为全局变量，则要通过`global`关键字，这样就可以在函数外部来引用该局部变量。

*  示例：

def demo():
        global c                # global c = 2 会报错
        c = 2
    
    demo()              #调用函数，对变量赋值
    print(c)

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