python入门--02 函数

我就是我 2022-10-26 15:26 175阅读 0赞

正文在下面，先打个广告：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZneWlidXBp_size_16_color_FFFFFF_t_70]

## 函数定义`def` ##

def bijiao(param):
         if param > 0:
            return True
         elif param < 0:
            return False
         else:
            return "0"
    
    print(bijiao(0)) #输出结果为0

## 返回多个值（其实是tuple） ##

def move(x, y):
        x = x + 10
        y = y+20
        return x, y
    
    print(move(1,2))  # 结果为 (11, 22)

## 函数的参数 ##

### 位置参数 ###

即上面出现的普通参数

### 默认参数 ###

def param(x, y, m=8, n=9):
        print('x =', x)
        print('y =', y)
        print('m =', m)
        print('n =', n)
    param(1, 2, 4) # 按顺序传参
    print('--')
    param(1, 2, n=4) #如果不按顺序，需要明确指定参数名

结果：

x = 1
    y = 2
    m = 4
    n = 9
    --
    x = 1
    y = 2
    m = 8
    n = 4

注意：

*  必选参数在前，默认参数在后
 *  当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
 *  默认参数一定要是不变对象

例：

def param(x, y = []):
        y.append(45)
        print(y)
    param(1)
    param(1)
    param(1)

结果：

[45]
    [45, 45]
    [45, 45, 45]

可见 调用多次的时候执行结果会不一致。解决办法就是使用**不可变对象**。这里可以使用`def param(x, y = None)`来解决。

def param(x, y = None):
        if(y is None):
            y = []
        y.append(45)
        print(y)

输出

[45]
    [45]
    [45]

### 可变参数（动态传参） ###

> 格式定义： `def param(*number)`

def param(*number):
        print('length =', len(number))
        sum = 0
        for i in number:
            sum += i
        return sum
    
    print(param(1,2,3))
    print(param(*list(range(101))))  #Python允许你在list或tuple前面加一个`*`号，把list或tuple的元素变成可变参数传进去

结果：

length = 3
    6
    length = 101
    5050

### 关键字参数 ###

> 函数定义： `def param(name, **student)`

def param(name, **student):
        print('name = %s , other = %s' % (name, student))
    
    param(1)
    param(1,age=23, score = 456)
    a = { "age":"22", "score":"100"}
    param(1, **a)

结果：

name = 1 , other = { }
    name = 1 , other = { 'age': 23, 'score': 456}
    name = 1 , other = { 'age': '22', 'score': '100'}

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

**`*`不是参数，只是分隔符**,表示后面的是命名关键字参数

def param(name, age, *, city='北京', job):
        print('name = %s , age = %s, city = %s, job = %s' % (name, age, city, job))
    
    param(1, 10, job='coder')
    param(1, 10, city = '杭州',job='coder')

结果：

name = 1 , age = 10, city = 北京, job = coder
    name = 1 , age = 10, city = 杭州, job = coder

### 参数组合 ###

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

def f1(a, b, c=0, *args, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    
    def f2(a, b, c=0, *, d, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
    
    f1(1, 2)
    f1(1, 2 , c = 3)
    f1(1, 2, 3, 'a', 'b' , x=99 , y=9 , z = 90)
    f1(1, 2 , sss = 3)
    print('--------')
    f2(1, 2, 3, d=1111, x=10, y=20, z=30)
    f2(1, 2, d=1111, x=10, y=20, z=30)

结果：

a = 1 b = 2 c = 0 args = () kw = { }
    a = 1 b = 2 c = 3 args = () kw = { }
    a = 1 b = 2 c = 3 args = ('a', 'b') kw = { 'z': 90, 'y': 9, 'x': 99}
    a = 1 b = 2 c = 0 args = () kw = { 'sss': 3}
    --------
    a = 1 b = 2 c = 3 d = 1111 kw = { 'z': 30, 'y': 20, 'x': 10}
    a = 1 b = 2 c = 0 d = 1111 kw = { 'z': 30, 'y': 20, 'x': 10}

> 对于任意函数，都可以通过类似`func(*args,**kw)` ( 通过一个tuple和dict ) 的形式调用它，无论它的参数是如何定义的

def f1(a, b, c=0, *args, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    
    def f2(a, b, c=0, *, d, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
    
    args = (1, 2, 3, 4); kw = { 'd': 99, 'x': '#'}
    f1(*args, **kw)
    args = (1, 2, 3); kw = { 'd': 88, 'x': '#'}
    f2(*args, **kw)

结果：

a = 1 b = 2 c = 3 args = (4,) kw = { 'd': 99, 'x': '#'}
    a = 1 b = 2 c = 3 d = 88 kw = { 'x': '#'}

### 函数参数小结 ###

*  Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
 *  默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
 *  要注意定义可变参数和关键字参数的语法：
 *  `*args`是可变参数，args接收的是一个tuple；
 *  `**kw`是关键字参数，kw接收的是一个dict。
 *  以及调用函数时如何传入可变参数和关键字参数的语法：
 *  可变参数既可以直接传入：`func(1, 2, 3)`，又可以先组装list或tuple，再通过`*args`传入：`func(*(1, 2, 3))`；
 *  关键字参数既可以直接传入：`func(a=1, b=2)`，又可以先组装dict，再通过`**kw`传入：`func(**{'a': 1, 'b': 2})`。
 *  使用`*args`和`**kw`是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
 *  命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。
 *  定义命名的关键字参数不要忘了写分隔符`*`，否则定义的将是位置参数。

## 递归函数 ##

def fact(x):
        if(x == 1):
            return 1
      return x * fact(x - 1)
      
    print(fact(100))

结果：  
`93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000`

注：**递归调用的次数过多，会导致栈溢出**。不信试试`print(fact(1000))`  
解决办法就是使用**尾递归**优化，但是这依赖于编译器优化，可惜大部分都没有进行优化，包括Python解释器  
**尾递归**是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

将上述计算阶乘的程序改成尾递归：

def fact(n):  
return fact\_iter(n, 1)

def fact\_iter(num, product):  
if num == 1:  
return product  
return fact\_iter(num - 1, num \* product)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZneWlidXBp_size_16_color_FFFFFF_t_70]: /images/20221024/fa1de3c9fa804c038059242afdc40eb7.png