Python（8）函数之普通参数、参数默认值、可变参数、关键字参数、命名关键字参数及递归函数

刺骨的言语ヽ痛彻心扉 2022-06-07 06:14 187阅读 0赞

### 17、函数的参数 ###

在一般情况下，

函数在传参的时候，需要和函数声明时要求的参数的数量一致，不能多也不能少，否则直接抛错（这点与js不同，js是在执行过程中发现缺少参数才可能报错）。

# 定义函数
    def test(x, y):
        return x
    
    
    # 执行函数
    bar = test(-1)
    # Traceback (most recent call last):
    # File "D:/study notes/Python/笔记/test.py", line 7, in <module>
    # bar = test(-1)
    # TypeError: test() missing 1 required positional argument: 'y'

### 18、类型检查 ###

python也是一种弱类型语言，但假如我们需要检查某个变量的参数的类型，是否符合我们要求怎么办？

> isinstance(x, (int, str, …))

参数一是被检查的变量，参数二是类型。

1.  int；整数
2.  float：浮点数
3.  str：字符串
4.  list：数组list
5.  tuple：就是tuple咯，不能变的list
6.  dict：就是上面说的dict，类似对象的玩意
7.  set：类型set
8.  其他，比如自定义的class之类，也可以。

示例：

# 定义函数
    def test(x):
        # 类型检查
        if isinstance(x, (set)):
            print('set')
    
    
    # 执行函数
    test(set())  # set

# 定义类
    class Foo(object):
        def __init__(self, a):
            self.a = a
    
        def log(self):
            print(self.a)
    
    
    bar = Foo('a')
    print(isinstance(bar, (Foo)))   # True

这个用在函数里，可以用于检查函数的参数，如果不符合，可以抛出错误。怎么抛错，可以看后面关于抛错和捕捉的章节。

### 19、返回值 ###

返回单个值的时候，直接return返回就行

def getA():
        return 'a'
    
    print(getA())   # a

如果需要返回多个值，有多个办法，但都是同一个思路。

常见的写法是返回一个tuple（固定数组），但可以省略括号。看似返回多个值，实则返回一个值。

def getA():
        return 1, 2    # 这里可以用括号包起来，也可以省略括号不包
    
    
    a = getA()
    print(a)  # (1, 2)
    print(a[0]) # 1
    print(a[1]) # 2

也可以返回list，或者dict等，道理是一样的，唯一缺点是不像tuple这么方便。

### 20、函数参数默认值 ###

假如我面对这样一个场景：

1.  函数只有一个参数；
2.  调用函数时，如果传值了，使用传的值；
3.  如果没传值，使用默认值；

在之前的前提下，解决这个场景是可以，但是很麻烦。

而函数默认值，是专门解决这个场景的办法。

使用方法：

> def 函数名(没有默认值的参数放前面, 参数名=默认值, …):

示例：

def log(a, b=2):
        print(a, b)
    
    
    log(1)    # 1 2
    log(1, 3)    # 1 3

有几点需要注意：

1.  定义函数时，没有默认值的函数参数，要放于有默认值的函数参数的前面（否则抛错）；
2.  会优先取传的参数，如果调用时没有传参，才会取默认值；
3.  函数默认值应该使用不变的对象（就是可以作为dict的key的值）；
4.  如果函数参数默认值需要使用list或可变对象，那么默认值应先设为None，再在函数体内赋值为需要的默认值（原因见[廖雪峰的解释][Link 1]）；
5.  函数参数默认值可以选择性传递，如下面的示例：

def log(a, b=2, c=3):
        print(a, b, c)
    
    
    log(1, c='c')   # 1 2 c

其中b使用默认值，c使用了自定义传的参数。

简单来说，就是如果多个带默认值的函数参数，有部分参数不使用默认值，那么不使用默认值的这些参数，在调用时，通过`参数名 = 传的值`的方式来使其不使用默认值，这样可以忽略原本默认值的参数顺序。

拓展：其他的函数参数也可以这么干（虽然意义不大）

def log(a, b, c=3, d=4):
        print(a, b, c, d)
    
    
    log(b=2, a=1)  # 1 2 3 4

### 21、可变参数 ###

使用js之类语言的人，看到这里为止，对python的函数声明时有多少个参数，使用时就必须有多少个参数这种行为，会感觉很不习惯。

假如我们面对这样一个场景：

1.  获取函数在调用时，所有的参数累加的和；
2.  但我们并不知道有多少个参数，可能0个，可能1个，也可能100个；
3.  可以用list装载，但问题是麻烦。

js的解决办法是利用函数内的arguments，而python也有自己的办法：

> def 函数名(前面定义的参数, \*可变参数名):

即在定义时，某个变量的参数名前面加个星号`*`，那么就表示这个参数是可变参数，后面所有的参数都会被装入到这个里面。

这个可变参数是一个tuple

基本示例代码：

def log(*foo):
        print(foo)
        print(isinstance(foo, tuple))
    
    
    log(1, 2)
    # (1, 2)
    # True

可变参数可以和固定参数结合使用，如示例代码，前面传的两个参数分别被a和b使用，剩下的归foo。

注意，可以只传2个参数。可变参数foo获得0个参数也是不会抛错的。

def log(a, b, *foo):
        print(a, b)
        print(foo)
    
    
    log(1, 2, 3)
    # print(a, b)
    # (3,)

### 22、关键字参数 ###

在前面，我们在调用函数的时候，使用过这样的语法`log(b=2, a=1)`，即指定变量名的形式来写。

但这种形式，对于一般的函数调用是没有必要的；而对于关键字参数，正是这样使用。

所谓关键字参数，就是将以上形式，组装成一个dict。

示例代码如下：

def person(**kw):
        print(kw)
        print(isinstance(kw, dict))
    
    
    person(a=1, b=2)
    # {'b': 2, 'a': 1}
    # True

关键字参数需要在参数名前面加两个星号：`**`，然后所有符合要求的都会被组装成dict模式，等号前面是的key，等号后面的是该key的value。

几个需要注意地方：

1.  关键字参数必须放在最后；
2.  关键字参数可以取不到值；

### 23、命名关键字参数 ###

这个应该是最难理解其意义的参数了。

先不解释意义，先说用法：

一般情况下，在普通参数后面的第一个参数位，用星号`*`占位，然后后面跟命名参数。如代码：

def person(a, *, b, c):
        print(a, b, c)
    
    
    person(1, b=2, c=3)
    # 1 2 3

其中，b和c就是命名关键字参数。

他具备以下特点：

1.  必须通过例如`b=2`这样的形式赋值，而不能直接`person(1, 2, 3)`来赋值；
2.  在命名关键字参数和普通参数之间，必须用星号`*`来分隔，除非是遇见情况三；
3.  如果有【可变参数】写在【命名关键字参数】和【普通参数】之间，那么可以用以下形式来写：

def person(a, *foo, b, c):
        print(a, b, c)
        print(foo)
    
    
    person(1, 'a', 'b', b=2, c=3)
    # 1 2 3
    # ('a', 'b')

如以上代码，【命名参数】和【普通参数】之间的若干参数，被【可变参数】foo拿走使用了。

【命名关键字参数】和【关键字参数】相比:

1.  劣势：不能自动组装成对象；
2.  优势：可以避免不想要的属性被使用；
3.  优势：可以使用默认值（【关键字参数】显然不行）；
4.  相同：都可以使用可变参数，如以下示例：

def person(a, *foo, **bar):
        print(a, bar)
        print(foo)
    
    
    person(1, 'a', 'b', b=2, c=3)
    # 1 {'c': 3, 'b': 2}
    # ('a', 'b')

关于【3】带默认值的命名关键字参数：

def person(a, *foo, b=2, c):
        print(a, b, c)
        print(foo)
    
    
    person(1, 'a', 'b', c=3)
    # 1 2 3
    # ('a', 'b')

普通参数和可变参数结合的时候，不能使用默认值（因为没有意义，永远取不到默认值）：

def person(a, b=2, *foo):
        print(a, b)
        print(foo)
    
    
    person(1, 3, 'a', 'b')
    # 1 3
    # ('a', 'b')

### 24、参数组合 ###

> 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。  
> 但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

比如示例：

# 必选参数，默认参数，可变参数，命名关键字参数，关键字参数
    # 默认参数无意义（取不到默认值）
    def person(a, b=2, *c, d, **e):
        print(a)
        print(b)
        print(c)
        print(d)
        print(e)
    
    
    person(1, 'b', 'c', d=3, e=4, f=5)
    # 1
    # b
    # ('c',)
    # 3
    # {'f': 5, 'e': 4}
    
    # 必选参数，默认参数，可变参数，关键字参数
    # 默认参数无意义，省略命名关键字参数
    def person(a, b=2, *foo, **bar):
        print(a, b)
        print(foo)
        print(bar)
    
    
    person(1, 'a', 'b', c=3, d=4)
    # 1 a
    # ('b',)
    # {'c': 3, 'd': 4}
    
    # 必选参数，默认参数，命名关键字参数，关键字参数
    def person(a, b=2, *, c=3, **foo):
        print(a, b, c)
        print(foo)
    
    
    person(1, 'b', c='c', d=4, e=5)
    # 1 b c
    # {'e': 5, 'd': 4}
    
    # 必选参数，可变参数，命名关键字参数（带默认值），关键字参数
    def person(a, *b, c=3, **foo):
        print(a, b, c)
        print(foo)
    
    
    person(1, 'b1', 'b2', c='c', d=4, e=5)
    # 1 ('b1', 'b2') c
    # {'d': 4, 'e': 5}

但有几点需要注意：

1、【默认参数】后面如果直接跟【可变参数】，那么默认参数是没有意义的（如上面的示例，b永远不可能取到他的默认值）；

2、【命名关键字参数】后面可以直接跟【关键字参数】，并且这二者的参数的位置没有影响。如以下代码：

def person(a, *, b, c, **foo):
        print(a)
        print(b, c)
        print(foo)
    
    
    person(1, d=4, b=2, c=3, e=5)    # 正常是b,c然后d,e。这里是先d,然后b,c，再e
    # 1
    # 2 3
    # {'e': 5, 'd': 4}

3、【可变参数】后面可以跟【命名关键字参数】，其参数位置不能混乱，如以下代码：

def person(a, *foo, c, d):
        print(a)
        print(foo)
        print(c, d)
    
    
    person(1, 2, 3, c=3, d=4)
    # 1
    # (2, 3)
    # 3 4

4、**只使用【可变参数】和【关键字参数】即可获取所有参数**：

可变参数获取多个参数，并且可以是0个，返回值是一个tuple；

关键字参数可以自动组装调用时，赋值了的参数成为dict；

如示例代码：

def person(*foo, **bar):
        print(foo)
        print(bar)
    
    
    person(1, 2, 3, c=3, d=4)
    # (1, 2, 3)
    # {'c': 3, 'd': 4}

唯一缺点是，这种方式要求必须把不带赋值的参数放在前面，带赋值的参数放在后面。

但好处是只要分开，哪怕这两种参数之一，甚至二者都不存在，也可以正常调用函数。

def person(*foo, **bar):
        print(foo)
        print(bar)
    
    
    person()
    # ()
    # {}

### 25、递归函数 ###

递归函数就是函数自己调用自己。

不懂递归函数的话，我就比较尴尬了。先给一个简单的示例好了。

比较典型的递归函数是解决阶乘问题，即例如：`1*2*3*4*5 = 120`这样。

如代码：

def factorial(i):
        if (i == 1):
            return 1
        return i * factorial(i - 1)
    
    
    print(factorial(5)) # 120

面向不懂递归函数的同学，解释运作过程：

1.  调用factorial函数，并且初始传参5；
2.  if判断不通过，进入下一层；
3.  返回一个表达式的值，而这个表达式是参数（即5），再乘以调用factorial的返回值；
4.  相当于在factorial函数（称为外层）内调用他自己（称为内层），只不过内层函数的参数的值，比外层函数参数的值小1；
5.  相当于执行到第三步时，又执行了新一轮的第一步到第三步的循环，只不过比上一轮第一步传参的值小1（第一轮是5，新一轮是4）；
6.  然后在新的一轮里，执行到第三步后，又开始更新的一轮第一步到第三步的值（但此轮第一步的参数的值就变成3了）；
7.  依次循环，直到某一轮的第一步传的值变成了1，此时该轮函数的返回值是1。
8.  于是最终执行的是`(5 * (4 * (3 * (2 * (1)))))`，每一层括号代表该轮factorial函数执行的内容，因为有执行了五轮，所以有五层括号。
9.  如果还不懂的话，可以打个断点，自己跟一遍代码是怎么执行的，结合上面的解释，就明白了（还不明白的话，就自己试着画一个思维导图吧）。

**递归函数的优点：**

1.  简化代码；
2.  适合做，层级深，但每层做的事情都差不多的工作；
3.  很帅有逼格；

**递归函数的缺点：**

1.  写起来比较考验功底；
2.  不适合做比较复杂的逻辑；
3.  写不好的话容易调用栈溢出。

前两个缺点靠多写，以及提高自己的技术功底来做到。

而调用栈溢出是需要通过尾递归优化来解决的。

#### 【但是，Python和JavaScript等语言，都不【支持】尾递归优化】 ####

所以这就很尴尬了。如果想要了解尾递归优化，可以看以下代码，但是依然会溢出，所以如果执行不了，不要觉得奇怪。

上面那个不好体现调用栈溢出，我们把阶乘改为递增的加法来显现这个问题。

如代码：

# 递归函数（相加）
    def factorial(i):
        if (i == 1):
            return 1
        return i + factorial(i - 1)    # 这里是加法

调用栈大约在1000层左右的时候，会溢出，然后抛错。

如代码：

factorial(998)    # 498501
    factorial(999)    # 抛错

解决办法是【尾递归】，所谓尾递归，就是函数在return的时候，return调用函数自己，并且没有表达式。

例如：

1.  `return factorial(i-1)` 是尾递归；
2.  `return factorial(i-1) + 1` 不是尾递归；

以上代码的尾递归优化版（但Python不支持，所以**不能执行**！）：

def factorial(i, total=0):
        if i == 0:
            return total
        total = total + i
        num = i - 1
        return factorial(num, total)
    
    
    print(factorial(3, 0))

[Link 1]: https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431752945034eb82ac80a3e64b9bb4929b16eeed1eb9000