Python学习笔记（五）函数

本文地址：http://blog.csdn.net/dearsq/article/details/51099347
欢迎转载，转载请保留此行~谢谢！！

自带的函数

Python 函数搜索：
官方文档：https://docs.python.org/3/library/functions.html

数字处理：
abs()参数为数字，且只有一个参数，返回绝对值
max()参数为数字，且参数不限，返回最大的一个
数据类型转换：
int() float() str() bool()

定义函数

语法

使用 def 语句，依次写出函数名 func、括号()、括号中的参数arg和冒号 :，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def func(arg):
    ...
    return ..

比如一个求绝对值的函数 my_abs：

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

空函数

用 pass 语句

def nop():
    pass

函数参数错误检查

数据类型的检查用内置函数 isinstance()实现

def my_abs(x)
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
# 如果参数 x 不是 int 或者 float 的话就提交错误
    if x >= 0:
        return x
    else:
        return -x

返回多个值？

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

这里似乎返回了两个值，但实际上

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

返回值其实为一个 tuple 类型。

函数参数

只需关注参数、功能、返回值，无需了解内部逻辑。
Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

位置参数

比如求 x 的 n 次方 的函数。

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

使用方法为 power(x,n)，其中 x 和 n 即为位置参数。

不可多，不可少。比如 power(2) 就会报错。
所以我们可以设置默认参数。

默认参数

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

当我们使用 power(2) 的时候，即默认求其平方。
另外有两点注意：
1. 默认参数不可为可变参数。
比如

def power(x=[])
    x.append('END')
    return None

就是错误的，不理解的话，可以调用两次 power() power() 试试
2. 采用 None 的方式可以解决上面问题

def power(x = None)
    if x is None:
        x = []
    x.append('END')
    return x

可变参数

比如我们要打印一个列表

def print_list(L):
    for n in numbers:
        print(n)
    return None

print_list([1,3,4,5])

必须要构造参数 [1,3,4,5]才行
如果直接写 1,3,4,5 会报错，参数为4个，大于1个。
所以如何构造可变的参数呢？

def print_list(*L):
    for n in numbers:
        print(n)
    return None

print_list(1,3,4,5)

在参数前加 * 就可以了。

关键字参数

可变参数允许我们传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
关键字参数允许我们传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
比如

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

除了 必选参数 name 和 age，还接受关键字 kw。如下

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

可以传递无限个关键字参数，比如

def person(name,age,**kw):
    if 'city' in kw:
        print("有 city 哟~")
        pass
    print('name:',name,'age:',age,'other:',kw)
    return None

person('SQ',18,city='Wuhan',brother='ff')

命名关键字参数

如果要限制关键字参数的名字，可以用 命名关键字参数。比如只接受 city 和 job 就这样定义

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

命名关键字参数也可以使用缺省值

def person(name,age,*,city='Wuhan',job='programmer')
    print(name, age, city, job)

千万注意 * 只代表分隔符，不代表参数

总结

*args 是可变参数，args 接受的是 tuple
**kw 是关键字参数，kw 接受的是 dict

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

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

最后，命名关键字参数是 * 号为分隔符。

递归函数

比如阶乘 n!= 1 x 2 x 3 x … x n

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

使用递归函数需要注意防止栈溢出。
函数调用是通过 栈 stack来实现的，每进入一个函数调用，都会增加一层栈帧，每次返回都会减少一层栈帧。
而栈大小不是无限的，所以要采取一些策略来解决栈溢出问题。

尾递归优化

尾递归是指，在函数返回的时候，调用自身，并且，return 语句不能包含表达式。这样编译器或者解释器就会进行优化。使递归无论进行多少次，都只占用一个栈帧。
（但是 Python解释器没有做优化）
前面的例子 return n*fact(n-1) 包含表达式，不属于尾递归。我们来进行尾递归优化：（将每一步的乘积传入到递归函数）

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)

汉诺塔实例

def move(n,A,B,C):
    if n == 1:
        print(A,'-->',C)
    else:
        move(n-1,A,C,B)
        print(A,'-->',C)
        move(n-1,B,A,C)
    return None

本文地址：http://blog.csdn.net/dearsq/article/details/51099347
欢迎转载，转载请保留此行~谢谢！！