python 函数

一、定义函数

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回

函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return

def my_abs(x):
    if x >= 0:
        return
    else:
        return -x


if __name__ == '__main__':
    a = my_abs(100)
    print(a)

输出结果：

"G:\Program Files (x86)\Python\python.exe" D:/Python-Test/test.py
None

Process finished with exit code 0

二、空函数：可以用pass语句

pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，可以先放一个pass，让代码能运行起来

三、函数的参数

除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数

1、位置参数

如下代码：x和n，都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n，参数也可以设置默认值，简化函数的调用

def power(x, n=2):
    s = 1
    while n > 0:
        n -= 1
        s = s * x
    return s


if __name__ == '__main__':
    print(power(5, 3))     # 输出125
    print(power(5))    # 输出25

2、默认参数

1）必选参数在前，默认参数在后
有默认值的参数位于无默认值之前，则调用函数时就必须使用key=Value的形式，而不能使用直接送入Value的形式了，同时也容易产生歧义

2）如何设置默认参数
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数
比如学生注册时不需要提供年龄和城市，只需姓名和年龄

3）默认参数必须指向不变对象

3、可变参数(*args)：接收的是一个tuple

1）由于参数个数不确定（0 或 n个），可以作为一个list或tuple传进来
2）在参数前面加了一个*号，*args 实质就是将函数传入的参数，存储在元组类型的变量args当中
代码中 *nums表示把nums这个list的所有元素作为可变参数传进去

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum += n * n
    return sum


if __name__ == '__main__':
    nums = [1, 2, 3, 4]
    a = calc(nums[0], nums[1], nums[2], nums[3])
    print(a)
    b = calc(*nums)  
    print(b)

4、关键字参数（**kwargs）：可以扩展函数的功能

可以传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

比如注册功能，除了用户名和密码是必填项，其他（邮箱、城市等）都是可选项，利用关键字参数来定义这个函数就能满足注册的需求

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

extra = {'city': 'beijing', 'job': 'engineer', 'gender': 'male'}
print(person('mickel', 30, city=extra['city'], gender=extra['gender'], job=extra['job']))
print(person('lily', 25, **extra))

输出结果：

name: mickel age: 30 other: {'gender': 'male', 'job': 'engineer', 'age1': 'beijing'}
name: lily age: 25 other: {'city': 'beijing', 'gender': 'male', 'job': 'engineer'}

5、命名关键字参数：限制关键字参数的名字，需要一个特殊分隔符，后面的参数被视为命名关键字参数

只接收city和gender参数

def person(name, age, *, city, gender):
    print('name:', name, 'age:', age, 'city:', city, 'gender:', gender)

print(person('mickel', 30, city='beijing', gender='female', job='doctor'))

输出

TypeError: person() got an unexpected keyword argument 'job'

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了，但是调用时需要传入参数名

print(person('mickel', 30, city=‘hangzhou’, gender='female'))

6、参数组合

参数定义顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
注：不要同时使用太多的组合，否则函数接口的可理解性很差

def test1(a, b, c=0, *args, **kwargs):
    print('a=', a, 'b=', b, 'c=', c, 'args=', args, 'kwargs=', kwargs)


def test2(a, b, c=0, *, d, **kwargs):
    print('a=', a, 'b=', b, 'c=', c, 'd=', d, 'city=hangzhou', kwargs, 'city1=beijing')


if __name__ == '__main__':
    print(test1(1, 2))   # a= 1 b= 2 c= 0 args= () kwargs= {}
    print(test1(1, 3, c=5))   # a= 1 b= 3 c= 5 args= () kwargs= {}
    print(test1(1, 2, 3, 'a', 'b'))   # a= 1 b= 2 c= 3 args= ('a', 'b') kwargs= {}
    print(test1(1, 2, 3, 'a', 'b', cc=30, dd=50))   # a= 1 b= 2 c= 3 args= ('a', 'b') kwargs= {'dd': 50, 'cc': 30}
    print(test1(1, 2, 3, 'a', 'b', x=99))   # a= 1 b= 2 c= 3 args= ('a', 'b') kwargs= {'x': 99}
    print(test2(1, 2, d=99, extra='hello world'))   # a= 1 b= 2 c= 0 d= 99 city=hangzhou {'extra': 'hello world'} city1=beijing

    # 对于任意函数，都可以通过类似func(*args, **kw)的形式调用它
    args = (1, 2, 3, 4)
    kwargs = {'d': 99, 'x': '@'}
    print(test1(*args, **kwargs))   # a= 1 b= 2 c= 3 args= (4,) kwargs= {'d': 99, 'x': '@'}
    args = (1, 2, 3)
    kwargs = {'d': 99, 'x': '@'}
    print(test2(*args, **kwargs))   # a= 1 b= 2 c= 3 d= 99 city=hangzhou kwargs= {'x': '@'}

练习题：通过可变参数计算n个数的乘积

def product(x, y, *args):
    b = x * y
    for kw in args:
        b *= kw
    return b


if __name__ == '__main__':
    a1 = product(3, 4, *(5, 6, 7))
    a2 = product(3, 4, *(5,))
    print(a1)    # 2520
    print(a2)    # 60

7、递归函数：一个函数在内部调用自身本身

1）需要注意防止栈溢出（一定要有终止的条件，不然程序就会一直运行下去）
2）一定要有返回值return，否则只会计算出最后那个被调用的函数的值，而不会返回给前面依次调用它的函数

def fact(n):    # 阶乘
    if n == 1:
        return 1
    return n * fact(n-1)


if __name__ == '__main__':
    a1 = fact(4)
    print(a1)

尾递归函数：

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)


if __name__ == '__main__':
    a1 = fact(4)
    print(a1)