调用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，让代码能运行起来，缺少了pass，代码运行就会有语法错误

def nop():
    pass

总结
如果有必要，可以先对参数的数据类型做检查，可以用内置函数isinstance()实现

def my_abs(x):
    if not isinstance(x, (int,float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
else:
        return -x


my_abs('A')

response

raise TypeError('bad operand type')
TypeError: bad operand type

三、函数的参数

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

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）如何设置默认参数
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数
比如学生注册时不需要提供年龄和城市，只需姓名和年龄
只有与默认参数不符的学生才需要提供额外的信息，当不按顺序提供部分默认参数时，需要把参数名写上

def enroll(name, gender, age=6, city='beijing'):
    print('name:', name)
    print('gender:', gender)
    print("age:", age)
    print('city', city)


enroll('Sarah', 'F')   # 默认值
enroll('lily','M', 18, 'hangzhou')    # 一一对应
enroll('lucy', 'M', city='suzhou')   # 缺少一个参数，所以需要指定city

3）默认参数必须指向不变对象
因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L


print(add_end([1,2,3]))
print(add_end(['x', 'y', 'z']))
print(add_end())
print(add_end())

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

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

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))

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

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})

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

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

extra = {'city': 'beijing', 'job': 'engineer', 'gender': 'male'}
person('mickel', 30, city=extra['city'], gender=extra['gender'], job=extra['job'])
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)

person('mickel', 30, city='beijing', gender='female', job='doctor')
person('jack', 24, 'Beijing','changsha',123456)

输出

TypeError: person() got an unexpected keyword argument 'job'
TypeError: person() takes 2 positional arguments but 5 were given

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

def person(name, age, *args, city, job):
    print(name,age,args,city,job)


person('jack',23,city='ningbo',job='teacher')

输出

jack 23 () ningbo teacher

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=suzhou', kwargs, 'city1=beijing')


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

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

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

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


if __name__ == '__main__':
    print('product(5) =', product(5))
    print('product(5, 6) =', product(5, 6))
    print('product(5, 6, 7) =', product(5, 6, 7))
    print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))

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)

尾递归函数：
在函数返回的时候，调用自身本身，并且，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)


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