一、函数的定义与创建

  函数是 Python 为了代码最大程度的重用和最小化代码冗余而提供的基本程序结构；它能让程序员将

复杂的系统分解为可管理的部件。在Python中可以创建四种函数：

• 定义函数语法

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 语句定义的代码必须是合法的表达式，不能出现多条件语句(可使用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支持有限的函数式编程：

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) 避免直接改变定义在另外一个模块中的变量；

聚合性：

  每个函数都应该有一个单一的、 统一的目标； 每个函数的功能都应该相对简单。

本文出自 “随风而飘” 博客，请务必保留此出处http://yinsuifeng.blog.51cto.com/10173491/1911497

python函数的定义与使用