python学习笔记（七）函数

1. 定义函数

定义函数的格式为：

def 函数名(参数 1，参数 2，...，参数 n)：

    函数体（语句块）

是不是样式很简单呢？

几点说明：

• 函数名的命名规则要符合 Python 中的命名要求。一般用小写字母和单下划线、数字等组合
• def 是定义函数的关键词，这个简写来自英文单词 define
• 函数名后面是圆括号，括号里面，可以有参数列表，也可以没有参数
• 千万不要忘记了括号后面的冒号
• 函数体（语句块），相对于 def 缩进，按照 Python 习惯，缩进四个空格

2. 函数的返回值

使用return 返回。

3.参数收集

既然有很多不确定性，那么函数的参数的个数，也当然有不确定性，函数怎么解决这个问题呢？Python 用这样的方式解决参数个数的不确定性：

def func(x,*arg):
    print x         #输出参数 x 的值
    result = x
    print arg       #输出通过 *arg 方式得到的值
    for i in arg:
        result +=i
    return result

print func(1,2,3,4,5,6,7,8,9)    #赋给函数的参数个数不仅仅是  2个

运行此代码后，得到如下结果：

1                       #这是函数体内的第一个 print，参数x得到的值是 1
(2, 3, 4, 5, 6, 7, 8, 9) #这是函数内的第二个 print，参数 arg 得到的是一个元组
45                      #最后的计算结果

从上面例子可以看出，如果输入的参数个数不确定，其它参数全部通过 *arg，以元组的形式由 arg 收集起来。对照上面的例子不难发现：

• 值 1 传给了参数 x
• 值 2,3,4,5,6.7.8.9 被塞入一个 tuple 里面，传给了 arg

为了能够更明显地看出 args（名称可以不一样，但是 符号必须要有），可以用下面的一个简单函数来演示：

>>> def foo(*args):
...     print args      #打印通过这个参数得到的对象
... 

下面演示分别传入不同的值，通过参数 *args 得到的结果：

>>> foo(1,2,3)
(1, 2, 3)

>>> foo("qiwsir","qiwsir.github.io","python")
('qiwsir', 'qiwsir.github.io', 'python')

>>> foo("qiwsir",307,["qiwsir",2],{"name":"qiwsir","lang":"python"})
('qiwsir', 307, ['qiwsir', 2], {'lang': 'python', 'name': 'qiwsir'})

如果用 **kargs 的形式收集值，会得到 dict 类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以键值对形式出现的。

看官到这里可能想了，不是不确定性吗？我也不知道参数到底会可能用什么样的方式传值呀，这好办，把上面的都综合起来。

>>> def foo(x,y,z,*args,**kargs):
...     print x   
...     print y
...     print z
...     print args
...     print kargs        
... 
>>> foo('qiwsir',2,"python")
qiwsir
2
python
()
{}
>>> foo(1,2,3,4,5)
1
2
3
(4, 5)
{}
>>> foo(1,2,3,4,5,name="qiwsir")
1
2
3
(4, 5)
{'name': 'qiwsir'}

很 good 了，这样就能够足以应付各种各样的参数要求了。

def foo(**args)

这种方式跟上面的区别在于，必须接收类似 arg=val 形式的。

4.lambda

lambda 函数，是一个只用一行就能解决问题的函数，听着是多么诱人呀。看下面的例子：

>>> def add(x):     #定义一个函数，将输入的变量增加 3,然后返回增加之后的值
...     x += 3
...     return x
... 
>>> numbers = range(10)
>>> numbers
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  #有这样一个 list，想让每个数字增加 3,然后输出到一个新的 list 中

>>> new_numbers = []
>>> for i in numbers:
...     new_numbers.append(add(i))  #调用 add() 函数，并 append 到 list 中
... 
>>> new_numbers
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

在这个例子中，add() 只是一个中间操作。当然，上面的例子完全可以用别的方式实现。比如：

>>> new_numbers = [ i+3 for i in numbers ]
>>> new_numbers
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

首先说明，这种列表解析的方式是非常非常好的。

但是，我们偏偏要用 lambda 这个函数替代 add(x)，如果看官和我一样这么偏执，就可以：

>>> lam = lambda x:x+3
>>> n2 = []
>>> for i in numbers:
...     n2.append(lam(i))
... 
>>> n2
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

这里的 lam 就相当于 add(x)，请看官对应一下，这一行 lambda x:x+3 就完成 add(x) 的三行（还是两行？），特别是最后返回值。还可以写这样的例子：

>>> g = lambda x,y:x+y  #x+y,并返回结果
>>> g(3,4)
7
>>> (lambda x:x**2)(4)  #返回 4 的平方
16

通过上面例子，总结一下 lambda 函数的使用方法：

• 在 lambda 后面直接跟变量
• 变量后面是冒号
• 冒号后面是表达式，表达式计算结果就是本函数的返回值