Python 学习 之 函数

函数

当代码出现有规律的重复的时候，便可以用函数来解决麻烦的事情，基本上所有的高级语言都支持函数，Python也不例外。Python中除了灵活地自定义函数外，本事内置了很多有用的函数，可以直接调用。
函数是最基本的一种代码抽象的方式。

调用函数

数据类型转换

Python 内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数。
Python中内置的常用函数包括数据类型转换函数。

abs(-20)     # 绝对值函数
20
int(“123”)   # 字符串转换为整型
123
int(12.34)   # 浮点型数转换为整型
12
float('12.34')  # 字符串转换为浮点型
12.34
str(1.23)     # 转换为字符串
'1.23'
bool(1)		  # 布尔型
True
bool('')     
False

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

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

定义函数

在 Python 中，定义一个函数要使用 def 语句，依次写出函数名、括号、
括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值
用 return 语句返回。

空函数

定义一个什么事也不做的空函数，可以用pass语句。

def nop():
	pass

pass用来作为占位符，比如现在没想好怎么写函数的代码，可以先放一个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')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 File "<stdin>", line 3, in my_abs
TypeError: bad operand type

返回多个值

Python的返回值是一个tuple！
在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多个值其实就是返回一个tuple，但写起来更方便。

函数参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的函数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。

位置参数

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

如例，power(x, n)函数有两个参数，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。

默认参数

def power(x, n=2):   # 此处将幂的默认值设定为2
	s = 1
	while n > 0:
		n = n - 1
	    s = s * x
	return s

将例子中的参数n默认值设定为2，可以简化函数的调用。

设置默认参数时，有几点要注意：
1.必选参数在前，默认参数在后，否则 Python 的解释器会报错（思
考一下为什么默认参数不能放在必选参数前面）；
2.如何设置默认参数
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。
变化小的参数就可以作为默认参数。

使用默认参数有什么好处？最大的好处是能降低调用函数的难度
有多个默认参数时，调用的时候既可以按顺序提供默认参数，也可以不按顺序。当不按顺序提供部分默认参数时，需要把参数名写上。

默认参数必须指定不变对象！

可变参数

在 Python 函数中，还可以定义可变参数。顾名思义，可变参数就是传
入的参数个数是可变的，可以是 1 个、2 个到任意个，还可以是 0 个。

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

调用的时候需要先组装出一个list或tuple：

  calc([1, 2, 3])
  14
  calc((1, 3, 5, 7))
  84

如果利用可变参数，调用函数的方式可以简化为：

calc(1, 2, 3)
14
calc(1, 3, 5, 7)
84

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

如果已经有一个 list 或者 tuple，要调用一个可变参数怎么办？可以这样
做：

nums = [1, 2, 3]
calc(nums[0], nums[1], nums[2]
14

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple
前面加一个*号，把 list 或 tuple 的元素变成可变参数传进去：

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

关键字参数

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

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

函数 person 除了必选参数 name 和 age 外，还接受关键字参数 kw。
在调用该函数时可以只传入必选参数：

>>> person('Michael', 30)
name: Michael age: 30 other: 

也可以传入任意个数的关键字参数：

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

关键字参数有什么用？
它可以扩展函数的功能。比如，在 person 函数里，我们保证能接收到 name 和 age 这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了
用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个 dict，然后，把该 dict 转换为关
键字参数传进去：

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

当然，上面复杂的调用可以用简化的写法：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

**extra 表示把 extra 这个 dict 的所有 key-value 用关键字参数传入到函
数的**kw 参数，kw 将获得一个 dict，注意 kw 获得的 dict 是 extra 的一份
拷贝，对 kw 的改动不会影响到函数外的 extra。

命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收 city 和 job 作为关键字参数。这种方式定义的函数如下：

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

和关键字参数**kw 不同，命名关键字参数需要一个特殊分隔符 * ，其后的参数被视为命名关键字参
数。
调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

由于调用时缺少参数名 city 和 job，Python 解释器把这 4个参数均视为位置参数，但 person()函数仅接受 2 个位置参数。命名关键字参数可以有缺省值，从而简化调用：

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

由于命名关键字参数city有默认参数，调用时，可不传入city参数。
使用命名关键字参数时，要特别注意，*不是参数，而是特殊分割符。如果缺少 *，Python解释器将无法识别位置参数和命名关键字参数。

参数组合

在 Python 中定义函数，可以用必选参数、默认参数、可变参数、关键 字参数和命名关键字参数，这 5 种参数都可以组合使用，除了可变参数
无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。
对于任意函数，都可以通过类似 func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

args 是可变参数，args 接收的是一个 tuple；
**kw 是关键字参数，kw 接收的是一个 dic。
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装 list 或 tuple，再通过args 传入：func((1, 2, 3))；关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装
dict，再过kw 传入：func({‘a’: 1, ‘b’: 2})。
使用args 和**kw 是 Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名的关键字参数不要忘了写分隔符*，否则定义的将是位置参数。

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
计算阶乘 n! = 1 x 2 x 3 x … x n，用函数 fact(n)表示，可以看出：
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 语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
Python 标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

# 利用递归函数移动汉诺塔:
def move(n, a, b, c):
    if n == 1:
        print('move', a, '-->', c)
    else:
        move(n-1, a, c, b)
        move(1, a, b, c)
        move(n-1, b, a, c)

move(4, 'A', 'B', 'C')