enumerate

函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

函数定义

def my_abs(x):
    if not isinstance(x, (int, float)):    # 类型判断
        raise TypeError('bad operand type')
    if x>=0:
        return x
    if x<0:
        return -x

#空函数
def nop():
    pass

若是没有return语句，隐式 return none.

返回多个值

函数可以返回多个值，但实际上返回的是一个 元组。
因为在语法上，返回一个元组可以省略括号，且多个变量可以同时接收一个tuple。

参数

位置参数

在函数调用中，一般用到的都是 位置参数。

默认参数

def power(x, n=2):
    s = 1
    s = s ** n
    return s

当调用power(5)时，相当于调用 power(5,2)。但传入两个参数时，则按定义进行计算。
注意：

  1. 必选参数在前，默认参数在后。
  2. 变化大的参数在前面，变化小的参数放后面。
  3. 默认参数必须指向 不可变对象。

可变参数

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

在函数内部，参数numbers接收到的是一个 tuple。
若已经有一个lsit或是tuple，python允许在list 或是 tuple上加一个*号，把list 或 tuple的元素变成可变参数传进去。例：

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

关键字参数 & 命名关键字参数

def person(name, age, **kw):
    if 'city' in kw:
        pass
    if 'job' in kw:
        pass
    print(name, age, kw)

>>>person('xie',12, city = 'qingdao', job = 'engineer')
xie 12 {'city': 'qingdao', 'job': 'engineer'}

kw是含 参数名的参数，函数内部会将其自动组装为dict。
对现有dict的调用

>>>extra = {'city': 'qingdao', 'job': 'engineer'}
person('zhao', 24, **extra)

若使用 命名关键字参数，需要一个 特殊分隔符 *，其后的参数被视为 命令关键字参数，且此时必须输入命名关键字参数的名字。

def person (name, age, *, city, job):
    print(name, age, city, job)
#这种用法时，不会出现dict外面的大括号
>>> person('zhao', 24, city = 'qingdao', job = 'engineer')
zhao 24 qingdao engineer

#命名关键字参数可以有缺省值
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

参数小结
对任意函数，都可以使用类似 func(*args, **kw)的形式调用它。
args是可变的 positional arguments列表， **kwargs是可变的 keyword arguments列表

*args是可变参数，args接收的是一个tuple。
**kw是关键字参数，kw接收的是一个dict。

递归函数

若一个函数在内部调用 自身，它即为 递归函数。

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

在计算机中，函数调用通过栈实现，每进入一个函数调用，栈会多一层，每当函数返回，则会少一层，所以若调用次数过多，会导致栈溢出。