函数¶

定义函数¶

函数function，通常接受输入参数，并有返回值。

它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

In [1]:

  1. def add(x, y):
  2.     """Add two numbers"""
  3.     a = x + y
  4.     return a

函数通常有一下几个特征：

  • 使用 def 关键词来定义一个函数。
  • def 后面是函数的名称，括号中是函数的参数，不同的参数用 , 隔开， def foo(): 的形式是必须要有的，参数可以为空；
  • 使用缩进来划分函数的内容；
  • docstring 用 """ 包含的字符串，用来解释函数的用途，可省略；
  • return 返回特定的值，如果省略，返回 None 。

使用函数¶

使用函数时，只需要将参数换成特定的值传给函数。

Python并没有限定参数的类型，因此可以使用不同的参数类型：

In [2]:

  1. print add(2, 3)
  2. print add('foo', 'bar')
  1. 5
  2. foobar

在这个例子中，如果传入的两个参数不可以相加，那么Python会将报错：

In [3]:

  1. print add(2, "foo")
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. <ipython-input-3-6f8dcf7eb280> in <module>()
  4. ----> 1 print add(2, "foo")
  5.  
  6. <ipython-input-1-e831943cfaf2> in add(x, y)
  7.       1 def add(x, y):
  8.       2     """Add two numbers"""
  9. ----> 3     a = x + y
  10.       4     return a
  11.  
  12. TypeError: unsupported operand type(s) for +: 'int' and 'str'

如果传入的参数数目与实际不符合，也会报错：

In [4]:

  1. print add(1, 2, 3)
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. <ipython-input-4-ed7bae31fc7d> in <module>()
  4. ----> 1 print add(1, 2, 3)
  5.  
  6. TypeError: add() takes exactly 2 arguments (3 given)

In [5]:

  1. print add(1)
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. <ipython-input-5-a954233d3b0d> in <module>()
  4. ----> 1 print add(1)
  5.  
  6. TypeError: add() takes exactly 2 arguments (1 given)

传入参数时，Python提供了两种选项，第一种是上面使用的按照位置传入参数，另一种则是使用关键词模式，显式地指定参数的值：

In [6]:

  1. print add(x=2, y=3)
  2. print add(y="foo", x="bar")
  1. 5
  2. barfoo

可以混合这两种模式：

In [7]:

  1. print add(2, y=3)
  1. 5

设定参数默认值¶

可以在函数定义的时候给参数设定默认值，例如：

In [8]:

  1. def quad(x, a=1, b=0, c=0):
  2.     return a*x**2 + b*x + c

可以省略有默认值的参数：

In [9]:

  1. print quad(2.0)
  1. 4.0

可以修改参数的默认值：

In [10]:

  1. print quad(2.0, b=3)
  1. 10.0

In [11]:

  1. print quad(2.0, 2, c=4)
  1. 12.0

这里混合了位置和指定两种参数传入方式，第二个2是传给 a 的。

注意，在使用混合语法时，要注意不能给同一个值赋值多次，否则会报错，例如：

In [12]:

  1. print quad(2.0, 2, a=2)
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. <ipython-input-12-101d0c090bbb> in <module>()
  4. ----> 1 print quad(2.0, 2, a=2)
  5.  
  6. TypeError: quad() got multiple values for keyword argument 'a'

接收不定参数¶

使用如下方法，可以使函数接受不定数目的参数：

In [13]:

  1. def add(x, *args):
  2.     total = x
  3.     for arg in args:
  4.         total += arg
  5.     return total

这里，*args 表示参数数目不定，可以看成一个元组，把第一个参数后面的参数当作元组中的元素。

In [14]:

  1. print add(1, 2, 3, 4)
  2. print add(1, 2)
  1. 10
  2. 3

这样定义的函数不能使用关键词传入参数，要使用关键词，可以这样：

In [15]:

  1. def add(x, **kwargs):
  2.     total = x
  3.     for arg, value in kwargs.items():
  4.         print "adding ", arg
  5.         total += value
  6.     return total

这里， **kwargs 表示参数数目不定，相当于一个字典，关键词和值对应于键值对。

In [16]:

  1. print add(10, y=11, z=12, w=13)
  1. adding  y
  2. adding  z
  3. adding  w
  4. 46

再看这个例子，可以接收任意数目的位置参数和键值对参数：

In [17]:

  1. def foo(*args, **kwargs):
  2.     print args, kwargs
  3.  
  4. foo(2, 3, x='bar', z=10)
  1. (2, 3) {'x': 'bar', 'z': 10}

不过要按顺序传入参数，先传入位置参数 args ，在传入关键词参数 kwargs 。

返回多个值¶

函数可以返回多个值：

In [18]:

  1. from math import atan2
  2.  
  3. def to_polar(x, y):
  4.     r = (x**2 + y**2) ** 0.5
  5.     theta = atan2(y, x)
  6.     return r, theta
  7.  
  8. r, theta = to_polar(3, 4)
  9. print r, theta
  1. 5.0 0.927295218002

事实上，Python将返回的两个值变成了元组：

In [19]:

  1. print to_polar(3, 4)
  1. (5.0, 0.9272952180016122)

因为这个元组中有两个值，所以可以使用

  1. r, theta = to_polar(3, 4)

给两个值赋值。

列表也有相似的功能：

In [20]:

  1. a, b, c = [1, 2, 3]
  2. print a, b, c
  1. 1 2 3

事实上，不仅仅返回值可以用元组表示，也可以将参数用元组以这种方式传入：

In [21]:

  1. def add(x, y):
  2.     """Add two numbers"""
  3.     a = x + y
  4.     return a
  5.  
  6. z = (2, 3)
  7. print add(*z)
  1. 5

这里的*必不可少。

事实上，还可以通过字典传入参数来执行函数：

In [22]:

  1. def add(x, y):
  2.     """Add two numbers"""
  3.     a = x + y
  4.     return a
  5.  
  6. w = {'x': 2, 'y': 3}
  7. print add(**w)
  1. 5

map 方法生成序列¶

可以通过 map 的方式利用函数来生成序列：

In [23]:

  1. def sqr(x): 
  2.     return x ** 2
  3.  
  4. a = [2,3,4]
  5. print map(sqr, a)
  1. [4, 9, 16]

其用法为：

  1. map(aFun, aSeq)

将函数 aFun 应用到序列 aSeq 上的每一个元素上，返回一个列表，不管这个序列原来是什么类型。

事实上，根据函数参数的多少，map 可以接受多组序列，将其对应的元素作为参数传入函数：

In [24]:

  1. def add(x, y): 
  2.     return x + y
  3.  
  4. a = (2,3,4)
  5. b = [10,5,3]
  6. print map(add,a,b)
  1. [12, 8, 7]

原文: https://nbviewer.jupyter.org/github/lijin-THU/notes-python/blob/master/02-python-essentials/02.17-functions.ipynb