定义函数

基础语法

def my_fun(arg):
    print "run function"
    return arg * arg

如果没有写return语句，函数执行之后会返回None

函数的返回值

可以有多个返回值，但是多个返回值默认是以元组的方式返回，相当于返回了一个元组

>>> def my_fun3(arg1, arg2):
...     x = arg1 + 59
...     y = arg2 + 59
...     return x,y
... 
>>> r = my_fun3(12,78)
>>> type(r)
<type 'tuple'>
>>> print r
(71, 137)
>>> r, t = my_fun3(56, 89)
>>> print r,t
115 148

空函数

def my_fun2():
    pass

调用函数

function_name()是调用函数的基本语法

• function_name 是函数的名字（可以使自定义函数，可以使内置函数，可以使第三方模块中的函数）
• () 括号里放的是该函数的参数，如果没有参数，可以为空

>>> def my_fun4():
...     print "hello"
...     print "world"
... 
>>> my_fun4()
hello
world
# my_fun4函数里面只有两行打印语句，没有定义返回值，所以返回值默认为空（None）
>>> s = my_fun4()
hello
world
>>> print s
None
>>> type(s)
<type 'NoneType'>
>>> 
>>> 
>>> def my_fun5():
...     return "hello world"
... 
# my_fun5函数里面定义了返回值
>>> ss = my_fun5()
>>> print ss
hello world
>>> type(ss)
<type 'str'>

函数的参数

默认参数

拿一个简单的幂运算举例
n=2即为默认参数，在调用该函数时，如果只指定了一个参数，那变量n将默认等于2

>>> def my_fun6(x, n=2):
...     return x ** n
... 
>>> my_fun6(3)
9
>>> my_fun6(3,3)
27

也可以将两个参数都设置有默认变量，这样该函数即使不传参，也能正常工作

>>> my_fun6()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: my_fun6() takes at least 1 argument (0 given)
>>> def my_fun7(x=3,n=2):
...     return x ** n
... 
>>> my_fun7()
9

使用默认参数的注意事项

• 必选参数在前，默认参数在后，否则Python解释器会报错

• 当函数需要多个参数的时候，将变化较大的参数放在前面，变化小的放在后面作为默认参数

• 默认参数必须指向不可变对象（eg: int, string, float）

可变参数

可以折衷地使用列表或元组实现可变长参数
(以下交互终端使用了ipython)

In [1]: def cal(numbers):
   ...:     sum = 0
   ...:     for i in numbers:
   ...:         sum = sum + i
   ...:     return sum

In [2]: cal([1,2,3])
Out[2]: 6

In [3]: cal((1,2,3))
Out[3]: 6

可变参数的关键字为*星号。在设置函数的接收参数时，前面加上一个星号，则函数内部接收到的所有参数会自动转化为一个元组

In [5]: def cal(*numbers):
   ...:     sum = 0
   ...:     for i in numbers:
   ...:         sum = sum + i
   ...:     return sum
   ...: 

In [6]: cal(1,2,3)
Out[6]: 6

In [7]: cal()
Out[7]: 0

In [8]: cal(1,2,3,4,5,6)
Out[8]: 21

In [9]: def cal(*numbers):
   ...:     return type(numbers)
   ...: 

In [10]: cal()
Out[10]: tuple

关键字参数

可变长参数传入到函数内部会自动转换成一个元组；而关键字参数传入到函数内部会自动转换成一个字典
关键字参数的关键字是**两个星号

In [12]: def person(name, age, **otherkeyword):
   ....:     print 'name: ', name, '\n', 'age: ', age, '\n', 'otherInfo: ', otherkeyword
   ....:    
 
In [13]: person('ps',24)
name:  ps
age:  24
otherInfo:  {}
 
In [14]: person('ps',24,city='BJ')
name:  ps
age:  24
otherInfo:  {'city': 'BJ'}
 
In [15]: person('ps',24,city='BJ',job='Engineer')
name:  ps
age:  24
otherInfo:  {'city': 'BJ', 'job': 'Engineer'}
 
In [16]: dict_kw = {'city': 'BJ', 'job': 'Engineer'}
 
In [17]: dict_kw
Out[17]: {'city': 'BJ', 'job': 'Engineer'}
 
In [18]: person('ps',24,**dict_kw)
name:  ps
age:  24
otherInfo:  {'city': 'BJ', 'job': 'Engineer'}

参数组合

上面提到了四种参数（必选参数、默认参数、可变参数、关键字参数），这四种参数可以一起使用。
参数定义的顺序必须是：必须参数、默认参数、可变参数、关键字参数

In [21]: def func(a, b, c=0, *args, **kw):
   ....:     print 'a:', a, '\n', 'b:', b, '\n', 'c:', c, '\n', 'tuple_args:', args, '\n', 'dict_kw:', kw
   ....:     

In [22]: func(1,2)
a: 1 
b: 2 
c: 0 
tuple_args: () 
dict_kw: {}

In [23]: func(1,2,c=3)
a: 1 
b: 2 
c: 3 
tuple_args: () 
dict_kw: {}

In [24]: func(1,2,c=3,4,5)
  File "<ipython-input-24-9272b7482bc9>", line 1
SyntaxError: non-keyword arg after keyword arg

In [25]: func(1,2,3,4,5)
a: 1 
b: 2 
c: 3 
tuple_args: (4, 5) 
dict_kw: {}

In [26]: func(1,2,3,4,5,x=59)
a: 1 
b: 2 
c: 3 
tuple_args: (4, 5) 
dict_kw: {'x': 59}

注意

• *args是可变参数，接收一个tuple

• **kw是关键字参数，接收一个dict

• 在必选参数，默认参数，可变长参数和关键字参数混合使用时，默认参数在复制时不要指定参数名，如上例的c=3 否则会报错

常用内置函数

isinstance

isinstance函数判断对象类型

>>> class obj1:
...     pass
... 
>>> o = obj1()
>>> t = (1,2,3)
>>> l = [1,2,3]
>>> d = {'a':1,'b':2,'c':3}
>>> s = 'string'
>>> i = 6
>>> f = 5.9
>>> 
>>> print isinstance(o, obj1)
True
>>> print isinstance(t, tuple)
True
>>> print isinstance(l, list)
True
>>> print isinstance(d, dict)
True
>>> print isinstance(s, str)
True
>>> print isinstance(i, int)
True
>>> print isinstance(f, float)
True