【python】定义函数、参数、递归（n!）

• 函数###

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

>>> a = abs   # 变量a指向abs函数
>>> a(-1)   # 所以也可以通过a调用abs函数
1

• 定义函数###

1)定义函数使用def,return是return None的简写
在Python交互环境中定义函数时，注意Python会出现...的提示。函数定义结束后需要按两次回车重新回到>>>提示符下

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

2)可以将my_abs()的函数定义保存为abstest.py文件，在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）

Paste_Image.png
注意：如果在.py文件中写的代码有问题（sublime中没有语法报错）则在导入函数时会出现语法错误
3)pass可以作为占位符，放在还没想好的函数过程中
4)数据类型检查isinstance()

    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')

5)Python的函数返回多值其实就是返回一个tuple

• 函数的参数###

1.位置参数：power(x, n)按照位置顺序依次赋给参数x和n
2.默认参数：def power(x, n=2) 这样传入一个参数时，第二个参数默认值为2
3.可变参数：允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

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

若已有一个list或者tuple,在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

4.关键字参数：允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict,kw是关键字参数

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

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

5.命名关键字参数：若要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。

>>>def person(name, age, *, city, job):
...     print(name, age, city, job)
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

1）命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
def person(name, age, *, city, job):
2）若函数定义中已经有了一个可变参数，后面的命名关键字参数就不再需要一个特殊分隔符*了
def person(name, age, *args, city, job):
3）必须传入参数名,可有缺省值
>>>person('Jack', 24, city='Beijing', job='Engineer')
def person(name, age, *, city='Beijing', job):city有默认值，则调用时，可以不传入city值
特别注意:如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

6.参数组合:顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

• 递归函数：调用自己

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

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

递归调用栈溢出的解决方法：通过尾递归优化（在函数返回的时候，调用自身本身，并且，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)

num - 1和num * product在函数调用前就会被计算