Python基础6——函数

基本上所有的高级语言都支持函数，Python也部例外。Python不但能非常灵活的定义函数，而且本身内置了很多有用的函数，可以直接调用。
（函数是最基本的一种代码抽象的方法）

调用函数

Python内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，只有一个参数。可以直接从Python的官方网站查看文档：点击打开链接
也可以在交互式命令通过help（abs）查看abs函数的帮助信息。>>> help(abs)
Help on built-in function abs in module builtins:

abs(x, /)
Return the absolute value of the argument.
调用abs函数：

>>> abs(1)
1
>>> abs(-1)
1
>>> abs(0)
0
>>> abs(11.11)
11.11
>>> abs(-11.11)
11.11

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abs（）有且仅有1个参数，但给出了两个：

>>> abs(-11.11,11)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)

如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型：

>>> abs('123')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

而max函数max（）可以接受任意多个参数，并返回最大的那个：

>>> max(1,2)
2
>>> max(1,2,-1,4)
4

数据类型转换

Python内置的常用函数还包括数据转换函数，比如int（）函数可以把其他数据转换为整数：>>> int('1234')
1234
>>> type(_)
<class 'int'>
>>> int('abc')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'abc'
>>> float('1234')
1234.0
>>> type(_)
<class 'float'>
>>> str(123)
'123'
>>> type(_)
<class 'str'>
>>> bool(1)
True
>>> type(_)
<class 'bool'>
>>> bool('')
False
>>> type(_)
<class 'bool'>
>>> bool(none)函数名其实就是指一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

>>> a = abs(-1)
>>> a
1

定义函数

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

我们以自定义一个求绝对值的my_abshanshu为例：>>> def my_abs(x):
... if x >= 0:
... return x
... else:
... return -x
...
>>> my_abs(-1)
1

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：>>> def nop():
... pass
...
>>>pass可以用来作为占位符i，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代妈能运行起来。

参数检查

调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError：

返回多个值

函数可以同时返回多个值，但其实就是一个tuple。

函数的参数

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无须了解。
Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

位置参数

我们先写一个计算x^2的函数：>>> def power(x):
... return x*x
...对于power(x)函数，参数x就是一个位置参数。
当我们调用power函数时，必须传入有且仅有的一个参数x：>>> power(2)
4
>>> power(-22)
484
>>> power(-22,1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: power() takes 1 positional argument but 2 were given现在，如果要计算2^3,2^4...怎么办？>>> def power(x,n):
... s = 1
... while n > 0:
... n = n - 1
... s = s * x
... return s

>>> power(5,2)
25修改后的power(x,n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。

默认参数

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

从上面例子可以看出，默认参数可以简化函数的调用。设置默认函数时，有几点要注意：一是必选参数在前，默认参数在后，否则Python解释器会报错；
二是如何是指默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。使用默认参数的好处：降低调用函数的难度。

可变参数

在Python函数中，还可以定义可变参数，顾名思义，可变参数就是传入的参数的个数是可变的，可以是1个、两个到任意个，还可以是0个。
例：给定一组数字a,b,c,.....，请计算a^2+b^2+c^2+.......。
要定义出这个函数，我们必须确认输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c，......作为一个list或tuple传进来，这样，函数可以定义如下：>>> def calc(numbers):
... sum = 0
... for n in numbers:
... sum = sum + n*n
... return sum
...

调用的时候现组装一个list或tuple：

>>> calc([1,2,3])
14

>>> calc((1,2,3,9))
95

>>> calc(1,2,3,9)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: calc() takes 1 positional argument but 4 were given

我们把函数的参数改成可变参数：>>> def calc(*numbers):
... sum = 0
... for n in numbers:
... sum = sum + n*n
... return sum
...
>>> calc(1,2,3,9,11,1112)
1236760定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。>>> calc()
0
>>> calc(1,)
1如果已经有一个list或tuple，要调用一个可变参数怎么办？>>> num = [1,2,3,4,5,]
>>> calc(num[0],num[2])
10
>>> calc(num)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in calc
TypeError: can't multiply sequence by non-int of type 'list'
>>> calc(*num)
55

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个参数名的参数，这些关键字参数，在函数内部自动组装为一个dict。>>> person('jeff',25)
name: jeff age: 25 other: {}
>>> person('jeff',25,city='shuangcheng')
name: jeff age: 25 other: {'city': 'shuangcheng'}
>>> person('jeff',25,city='shuangcheng',school='qida')
name: jeff age: 25 other: {'city': 'shuangcheng', 'school': 'qida'}关键字参数的好处：
可以扩展函数的功能。试想正在做一个用户注册的功能，除了用户名和年龄小时必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
利用可变参数类似，也可以先组装一二个dict，然后，把该dict转换为关键字参数传进去（与可变参数相同）

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。