Python函数

函数的基础概念：
1，函数是Python 为了代码最大程度地重用和最小化代码冗余而提供的基本程序结构

2，函数是一种设计工具，它能让程序员将复杂的系统分解为可管理的部件

3，函数用于将相关功能打包并参数化

4，用Python 中可以创建4中函数：
1），全局函数：定义在模块中

    2），局部函数：嵌套于其它函数中

    3），lambda函数：表达式（匿名函数）

    4），方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用

5，Python 提供了很多内置函数

语法
1，def functionName(parameters):
suite
2,

一些相关的概念
1，def是一个可执行语句
因此可以出现在任何能够使用语句的地方，甚至可以嵌套于其它语句，例如if或while中

2，def创建了一个对象并将其赋值给一个变量名（即函数名）

3，return用于返回结果对象，其为可选；无return语句的函数自动返回None对象
返回多个值时，彼此间使用逗号分隔，且组合为元组形式返回一个对象

4，def语句运行之后，可以在程序中通过函数后附加括号进行调用

pass 为占位语句。

函数：
名称

Python 函数作用域

1，Python 创建、改变或查找变量名都是在名称空间中进行

2，在代码中变量名被赋值的位置决定了其能被访问到的范围

3，函数定义了本地作用域，而模块定义了全局作用域

   1），每个模块都是一个全局作用域，因此，全局作用域的范围仅限于单个程序文件

   2），每次对函数的调用都会创建一个新的本地作用域，赋值的变量除非声明为全局变量，否则均为本地变量

   3），所有的变量名都可以归纳为本地，全局或内置的（由__builtin__模块提供）

在函数中，可以使用global 来声明（修改）使用全局变量。

变量名引用三个作用域进行：
首先是本地，之后是函数内，接着是全局，最后是内置。如果都没有则返回错误没有。

参数传递形式：
位置参数：从左向右
关键字参数：按关键名称匹配
或者：
比如： def f1(x=n,y=m)

   混用上面两种方式时：先所有位置参数，后所有关键字参数。

参数匹配模型

1，默认情况下，参数通过其位置进行传递，从左至右，这意味着，必须精确地传递和函数头部参数一样多的参数

2，但也可以通过关键字参数，默认参数或参数容器等改变这种机制

   1），位置：从左至右。
   2），关键字参数：使用“name = value”的语法通过参数名称进行匹配。
   3），默认参数：定义函数时使用“name = value”的语法直接给变量一个值，从而传入的值可以少于参数个数。
         def f1(x,y=9)  意思是：默认值为9 。可以赋予y值，也可以不赋予。

   4），可变参数：定义函数时使用*开头的参数，可用于手机任意多基于位置或关键字的参数。
         def f1(*x):
         则可以如下调用：f1(x,)  或者 f1(x,y,z)                   
           关键字参数：def f1(**x)
                           调用如下：
                                      f1(x=1,y=2,z=3)
                                 {'y':2,'x':1,'z':3}
          说明：调用函数时使用可变参数要求：
                 定义函数时使用*：收集位置参数
                 定义函数时使用**：收集关键字参数

   5），可变参数解包：调用函数时，使用*开头的参数，可用于将参数集合打散，从而传递任意多基于位置或关键字的参数。
        
          变量的分解赋值：
           比如：L1 = ['x','z','y']
           然后：A,B,C = L1
           相当于   x赋值给了A ，z赋值给了B，y赋值给了C
          
         函数的分解参数：
          def f1(x,y,z)
              print x,y,z
          f1(*L1)

匿名函数lambda

1，lambda运算符：
lambda args:expression
args:以逗号分隔的参数列表
expression:各参数的表达式
其中print 是语句，而不是表达式
f1 = lambda x,y:x + y
调用：f1(3,4)
输出为： 7
2，lambda 语句定义的代码必须是合法的表达式，不能出现多条件语句（可使用if的三元表达式）和其它非表达式语句，如for和while 等

3，lambda 的首要用途是指定短小的回调函数

4，lambda 将返回一个函数而不是将函数赋值给某变量名

注意：lambda是一个表达式而非语句
lambda是一个单个表达式，而不是一个代码块

5，def 语句创建的函数将赋值给某变量名，而lambda 表达式则直接返回函数

6，lambda也支持使用默认参数

      def testFunc(x,y,z):return  x+y+z
      testFunc(4,5,6)
      15
      
      f = lambda x,y,z:x+y+z
      f(4,5,6)
      15
     
      f1 = (lambda x,y,z=10:x+y+z)
      f1(4,5)
      19
   比如二：
     L3 = [(lambda x:x*2),(lambda y:y*3)]
    for i in L3:
        print  i(4)
得出结果 8  
         12

Python 函数式编程

Pthon 函数式编程
1，也称作泛函编程，是一种编程范型
2，它将电脑运算视为数学上的函数计算，并且避免状态以及可变数据
3，函数式编程语言最重要的基础是lambda演算，
而且lambda演算的函数可以接受函数当做输入和输出。
Python 支持有限的函数式编程功能

filter 过滤/

filter(func,seq) ：调用一个布尔函数func 来迭代遍历每个seq中的元素；
返回一个使func返回值为true的元素序列

L1 = [1,2,3,21,46,54]
比如：def f1(x):
if x > 20:
return True
else:
return False
filter(f1,L1)

map 映射器
1，map()将函数调用"映射"到每个序列的对应元素上并返回一个含有所有返回值的列表
2，带有单个队列的map()

 比如：L1 = [0,1,2,3,4,5,6]
       L2 = ['Sun','m','w','t','f','s']
   map（None,L1,L2）
  无需做运算则是None/可以是定义的函数，或者运算表达式。
     然后	[(0,'Sun'),(),()....(6,None)]

map(func,seq[,seq2…]) ：将函数func作用于给定序列（s）的每个元素，
并用一个列表来提供返回值，如果func为None，
func 表现为一个身份函数，返回一个含有每个序列中元素集合的n个元组的列表。

reduce 折叠

reduce(func,seq[,init]) :将二元函数作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列元素），
连续地将现有的结果和下一个值作用在获得的随后的结果上，
最后减少我们的序列为一个单一的返回值；如果初始值init给定，
第一个比较会是init和第一个序列元素而不是序列的头两个元素。

     def f1(x,y):
        return x + y
    L1 = [0,1,2,3,4,5,6]
    reduce(f5,L1)
    21
    reduce(f5,L1,10)
    31
        也就是如下运算：（（（（0+1）+2）+3...）+10）= 31

在Python语言中，定义一个函数为:def

闭合函数：
def f1(x):
def f2(y):
return y ** x
return f2
f1(2)
返回函数类型
然后赋值给f3,f3也就成了函数类型
f3 = f1
f3(3)
则返回 9
这个过程称为 闭合函数

Python 闭包：闭包叫lexical closure

生存器对象
yield
比如： def genNum(x):
y = 0
while y <= x:
yield y
y +=1
g1 = genNum(10)

    type(g1)  
       显示为生存器（generator）
    g1.next()
    ......

或者 def genNum(x):
y = 0
while y <= x:
yield y ** 2
y +=1
g1 = genNum(10)

装饰器：
1，装饰器本身是一个函数，用于装饰其它函数；
2，功能“增强被装饰函数的功能；
装饰器一般接受一个函数对象作为参数，以对其进行增强

装饰： def deco(func):
def wrapper(x):
print “Plz say something:”
func()
print “No zuo no die…”

调用： @deco
def show(x):
print “I am from Mars”

调用输出：show(‘hello,mars’)
Plz say something:
I am from Mars.
No zuo no die…

递归： fact

递归需要边界条件，递归前进段和递归返回段：

def fact(n):
if n <= 1:return 1
else:return n*(n-1)

def fact(n):
if n <=1:return 1
else : return n * fact(n - 1)

321 = 6
65432*1 = 720

        fact 递归

函数的设计规范：
耦合性：
（1）通过参数接受输入，以及通过return 产生输出以保证函数的独立性；
（2）尽量减少使用全局变量进行函数间通信；
（3）不要在函数中修改可变类型的参数；
（4）避免直接改变定义在另外一个模块中的变量；
聚合性：
（1）每个函数都应该有一个单一的，统一的目标；
（2）每个函数的功能都应该相对简单；

  展示关键字help("keywords")  

等效的函数调用：
也就是默认值，位置参数，关键字参数都可以用！

让实参变成可选的：
只需要在定义函数的参数时： 给一个空的默认值就好 ，并存放在最末尾。如
def t1(name,last_name,middle_name=’’)

Raise 语句的用法大全

raise语法 描述
raise exclass 触发一个异常，从exclass生成一个实例（不含任何异常参数）
raise exclass() 同上，但现在不是类；通过函数调用操作符（function calloperator:
"()"作用于类名生成一个新的exclass实例，同样也没有异常参数）

raise exclass(),args 同上，但同时提供的异常参数args，可以是一个参数也可以是元组
raise exclass(args) 同上
raise exclass,args,tb 同上，但提供一个跟踪记录（traceback）对象tb共使用
raise exclass ,instance 通过实例触发异常（通常是exclass的实例）；如果实例时exclass的子类实例，那么这个新异常的类型会是子类的类型（而不是exclass）；如果实例既不是exclass的实例也不是exclass子类的实例，那么会是复制此实例为异常参数去生成一个新的exclass实例

raise instance 通过实例触发异常；异常类型是实例的类型；等价于raise instance.class, instance(同上)

raise string （过时的）触发字符串异常

raise string, args 同上，但触发伴随着args

raise string,args,tb 同上，但提供了一个跟踪记录（traceback）对象tb供使用

raise （1.5新增）重新触发前一个异常，如果之前没有异常，触发TypeError