读书笔记-DAY2-函数

一、内置函数

Python内置了很多函数，以下为几个常用函数：
1、abs()，求绝对值
2、max()，可以接收任意多个参数，并返回最大的那个：

>>> max(1, 2)
2
>>> max(2, 3, 1, -5)
3

3、类型转换函数：

>>> int('123')123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

把函数名赋给一个变量：

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

二、自定义函数

以自定义一个求绝对值的my_abs函数为例：

# -*- coding: utf-8 -*-
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
print(my_abs(-99))

1、空函数
如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

pass语句什么都不做，就是为了避免代码运行时报错，后续可以完善相应功能代码，把pass去掉。

2、参数检查
下面示例为对参数类型做检查，只允许整数和浮点数类型的参数：

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

3、返回多个值
比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：

import math
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。
然后，我们就可以同时获得返回值：

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值：

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

原来返回值是一个tuple，但写起来更方便。

三、函数的参数

1、位置参数
简单举例，比如定义一函数：

def fun(a,b):
    pass

那么调用fun函数的时候按照位置顺序传参即可。

2、默认参数
同C++中定义，不再复述

3、可变参数
下面为可变长参数平方和的函数：

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

可以这样传入参数：

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

4、关键字参数
关键字参数在函数内部自动组装为一个dict，可以起到扩展函数的功能：

# -*- coding: utf-8 -*-
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

if __name__ == '__main__':
    person('Michael', 30)
    person('Bob', 35, city='Beijing')
    person('Adam', 45, gender='M', job='Engineer')
    extra = {'city': 'Beijing', 'job': 'Engineer'}
    person('Jack', 24, **extra)

>>> 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

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

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

四、递归函数

举个例子，计算阶乘n! = 1 x 2 x 3 x … x n，用函数fact(n)表示：

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

上面就是一个递归函数，可以试试：

>>> fact(1)
1
>>> fact(5)
120

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

>>> fact(1000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in fact
  ...
  File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison

解决递归调用栈溢出的方法是通过尾递归优化：

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)

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

阅读链接：Python教程