一、函数的定义与创建
函数是 Python 为了代码最大程度的重用和最小化代码冗余而提供的基本程序结构；它能让程序员将
复杂的系统分解为可管理的部件。在Python中可以创建四种函数：
| 全局函数：定义在模版中 局部函数：嵌套在其他函数中 Lambda函数：又称匿名函数，表达式 方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用 |
定义函数语法
def functionName(parameters): suite return value
def是一个可执行语句，因此可以出现在任何能够使用语句的地方，甚至可以嵌套于其他语句，例如 if 或 while；def 创建了一个对象并将其赋值给一个变量名(即函数名)；return用于返回结果对象，其为可选；无returne语句的函数自动返回none对象；def 语句运行之后，可以在程序中通过函数后附加括号进行调用。
In [2]: def make_a_sound():
...: print('quack')
...:
In [3]: make_a_sound()
quack
In [4]: a=make_a_sound()
quack
In [5]: type(a)
Out[5]: NoneType
上面是一个最简单的无参数函数，对其调用后python会执行函数内部代码。此函数会打印输出一个单词，由于没有设置返回值，因此默认为NoneType。
参数传递形式
当定义的函数有参数时，参数传递有两种形式。
位置参数：从左向右，传入的参数值按顺序一次复制进去 关键字参数：调用参数时按关键名称匹配，无需关心函数定义时参数的位置 |
In [6]: def menu(wine,entree,dessert):
...: return{'wine':wine,'entree':entree,'dessert':dessert}
...:
In [7]: menu('chardonnay','chicken','cake') #依次传递参数，位置参数
Out[7]: {'dessert': 'cake', 'entree': 'chicken', 'wine': 'chardonnay'}
In [8]: menu(entree='beef',dessert='bagel',wine='bordeaux') #按关键字传递参数
Out[8]: {'dessert': 'bagel', 'entree': 'beef', 'wine': 'bordeaux'}
定义函数时可以为参数设置默认的参数值，当调用函数没有指定参数值时就会使用此默认值。定义时无默认值的参数在左边，有默认值的参数在右边。
In [9]: def menu(wine,entree,dessert='pudding'):
...: return{'wine':wine,'entree':entree,'dessert':dessert}
...:
In [10]: menu('chardonnay','chicken')
Out[10]: {'dessert': 'pudding', 'entree': 'chicken', 'wine': 'chardonnay'}
当定义函数无法确定参数的具体个数时，可以使用可变参数来收集参数，动态参数有两种形式：一种是收集位置参数，另一种是收集关键字参数。
| 定义函数时使用*： 收集位置参数 (元组) 定义函数时使用**: 收集关键字参数 (字典) |
In [12]: def print_args(*args): #使用*收集位置参数
...: print('positional argument tuple:',args)
...:
In [13]: print_args()
positional argument tuple: ()
In [14]: print_args(1,2,3,4,5,6,'12131','abcd')
positional argument tuple: (1, 2, 3, 4, 5, 6, '12131', 'abcd')
In [15]: def print_kwargs(**args): #使用**收集关键字参数
...: print('Keyword arguments:',args)
...:
In [16]: print_kwargs(wine='merlot',entree='mutton')
Keyword arguments: {'wine': 'merlot', 'entree': 'mutton'}
函数作用域
Python创建、改变或查找变量名都是在名称空间中进行；在代码中变量名被赋值的位置决定了其能被访问的范围；函数定义了本地作用域，而模块定义了全局作用域。
每个模块都是一个全局作用域，因此，全局作用域的范围仅限于单个程序文件。每次对程序的调用都会创建一个新的本地作用域，赋值的变量除非声明为全局变量，否则均为本地变量。所有的变量名都可以归纳为本地、全局或者内置(由__builtin__模块提供)。
变量名引用分三个作用进行：首先本地变量、接着全局变量、最后内置变量。
In [17]: animal='fruitbat' #定义全局变量
In [18]: def print_global():
...: print('inside print_global:',animal) #调用全局变量
...:
In [20]: print_global()
inside print_global: fruitbat
In [21]: def print_global(): #当函数想改变全局变量时，执行函数会报错
...: print('inside print_global:',animal)
...: animal='wombat'
...: print('after the change:',animal)
...:
In [22]: print_global()
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
<ipython-input-22-e3810348dd19> in <module>()
----> 1 print_global()
<ipython-input-21-906f76821837> in print_global()
1 def print_global():
----> 2 print('inside print_global:',animal)
3 animal='wombat'
4 print('after the change:',animal)
5
UnboundLocalError: local variable 'animal' referenced before assignment
In [27]: def print_global(): #在函数内部声明全局变量，再更改时函数可以执行
...: global animal
...: print('inside print_global:',animal)
...: animal='wombat'
...: print('after the change:',animal)
...:
...:
...:
In [28]: print_global()
inside print_global: wolf
after the change: wombat
lambda()函数
在python中，lambda函数是用一个语句表达式的匿名函数，可以用它代替小的函数。
| 语法：lambda args: expression args: 以逗号分隔的参数列表 expression:用到 args 中各参数的表达式 |
Lambda 语句定义的代码必须是合法的表达式，不能出现多条件语句(可使用if的三元表达式)和其他非
表达式语句，如for和while等；Lambda 的首要用途是指定短小的回调函数；Lambda将返回一个函数而不
是将函数赋值给某个变量。
需要注意的是：Lambda 是一个表达式而不是语句；lambda是单个表达式，而不是代码块Def语句创建
的函数将赋值给某变量名，而lambda 表达式则直接返回函数Lambda也支持使用默认函数。
In [29]: f=lambda x,y,z:x+y+z #使用lambda匿名函数求和 ...: ...: In [30]: f(4,5,6) Out[30]: 15 In [31]: f=lambda x,y,z=10:x+y+z ...: ...: ...: In [32]: f(3,7) Out[32]: 20 In [33]: stairs=['thus','meow','thud','hiss'] In [34]: f=lambda word: word.capitalize() +'!' #创建lambda函数将字符串大写 In [37]: for i in stairs: ...: print(f(i)) ...: ...: Thus! Meow! Thud! Hiss!
函数式编程
也称作泛函编程， 是一种编程范型；他将电脑运算视作为数学上的函数计算，并且避免状态以及可变
数据；函数式编程语言最重要的基础是lamdba 演算，而且 lambda 演算的函数可以接受函数当作输入输
出。python支持有限的函数式编程：
| filter(function or None, iterable) | 调用一个布尔函数function来迭代遍历每个iterable中的元素，返回一个使function返回值为真的元素序列。 |
| map(func, *iterables) | 将函数func作用域给定序列的每一个元素，并用一个列表来提供返回值，如果function为none，func表现为一个身份函数，返回一个含有每个序列中元素集合的n个元组的列表。 |
reduce(func,seq[,init]) （python3中废弃） |
将二元函数作用域seq序列中的元素，每次携带一对（先前的结果以及下一个序列元素），连续地将现有的结果和下一个值作用在获得的随后结果上，最后减少序列为一个单一的返回值；如果出事值给定，第一个比较会是init和第一个序列元素而不是序列的两个头元素。 |
In [42]: li=[x for x in range(10) ] In [43]: li Out[43]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] In [44]: new_list=map(lambda a:a+10,li) #使用map函数对li列表中没个元素加10 In [45]: new_list Out[45]: <map at 0x7fd595189828> In [46]: list(new_list) Out[46]: [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
In [48]: new_list2=filter(lambda arg:arg>5,li) #选出列表li中所有大于5的元素 In [49]: list(new_list2) Out[49]: [6, 7, 8, 9]
函数的设计规范
耦合性：
(1)通过参数接受输入， 以及通过 return 产生输出以保证函数的独立性；
(2)尽量减少使用全局变量进行函数间通信；
(3)不要在函数中修改可变类型的参数；
(4) 避免直接改变定义在另外一个模块中的变量；
聚合性：
每个函数都应该有一个单一的、 统一的目标； 每个函数的功能都应该相对简单。
本文转自 梦想成大牛 51CTO博客，原文链接：http://blog.51cto.com/yinsuifeng/1911497，如需转载请自行联系原作者
