函数式编程 functional

1.特点:把计算视为函数而非指令 

       不需要变量 

       支持高阶函数 

       支持闭包 匿名函数

2.高阶函数：能接收函数作为参数的函数

  变量可以指向函数,函数名其实就是指向函数的变量

3.python中闭包 

  这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

   闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引 用的局部变量在函数返回后不能变

  返回函数不要引用任何循环变量，或者后续会发生变化的变量

4.decorator

  decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

  使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码

  要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参 数总是能正常调用：

    def log(f):

        def fn(*args, **kw):

            print 'call ' + f.__name__ + '()...'

            return f(*args, **kw)

        return fn

5.偏函数

functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值

eg:int2 = functools.partial(int,base=2) 将数据转为二进制

6.python自带的一些高阶函数

  ①map()

    它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的        list 并返回。

    注意：map()函数不改变原有的 list，而是返回一个新的 list

  ②reduce()

   reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同reduce()     传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值     reduce()还可以接收第3个可选参数，作为计算的初始值

  ③filter()

   filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或     False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list

  ④sorted()

   sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是传 入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

7.一些函数与表达式

比较字符串 cmp(s1.lower(),s2.lower())

python判断是否为整数 sqrtR%1 ==0 为true则为整数

lambda只是一个表达式，函数体比def简单很多

lambda x,y: x * y 

通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：

def f(x):
    return x * x

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：

使用python3.6运行需要import functools来使用reduce函数

#多用lambda表达式

def count():
   fs = []
   for i in range(1, 4):
       fs.append(lambda x=i: x*x)
   return fs

f1, f2, f3 = count()
print f1(), f2(), f3()

  print 'call %s() in %f %s'% (f.__name__,t,unit)   打印的参数，%表示下一个参数的类型  空格间距即可

装饰器加参数 就再在外面套一层 带参函数 内函数去调用函数即可

A      f.__name__    可以获取函数的名字   且name前后是两个下划线

B       print 'call %s()  in %fs '%(f.__name__,(t2-t1))  %s是获取的第一个参数 f.__name__  ;  %fs 获取的是第二个参数 （t2-t1）  

C       获取时间戳 参数赋值：   t=time.time()

D      装饰器：可以给原本的函数加装饰，使得它符合我们的各种要求。

         装饰器是函数套函数，内函数返回主函数参数的内函数参数调用，外函数返回内函数。

E      使用装饰函数  只需要在调用的函数前方写上@function（函数名）  即可

可见，只有以双下划线开头的"__job"不能直接被外部访问。

但是，如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"__xxx__"定义。

以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。

在Python中，函数其实是一个对象：

>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123

由于 f 可以被调用，所以，f 被称为可调用对象。

所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print 'My name is %s...' % self.name
        print 'My friend is %s...' % friend

现在可以对 Person 实例直接调用：

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。

如果要限制添加的属性，例如，Student类只允许添加 name、gender和score 这3个属性，就可以利用Python的一个特殊的__slots__来实现。

顾名思义，__slots__是指一个类允许的属性列表：

class Student(object):
    __slots__ = ('name', 'gender', 'score')
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score

现在，对实例进行操作：

>>> s = Student('Bob', 'male', 59)
>>> s.name = 'Tim' # OK
>>> s.score = 99 # OK
>>> s.grade = 'A'
Traceback (most recent call last):
  ...
AttributeError: 'Student' object has no attribute 'grade'

__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存。

因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用：

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    @property
    def score(self):
        return self.__score
    @score.setter
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

注意: 第一个score(self)是get方法，用@property装饰，第二个score(self, score)是set方法，用@score.setter装饰，@score.setter是前一个@property装饰后的副产品。

现在，就可以像使用属性一样设置score了：

>>> s = Student('Bob', 59)
>>> s.score = 60
>>> print s.score
60
>>> s.score = 1000
Traceback (most recent call last):
  ...
ValueError: invalid score

说明对 score 赋值实际调用的是 set方法。

要想清楚先干嘛  然后干嘛

Rational类实现了有理数运算，但是，如果要把结果转为 int 或 float 怎么办？

考察整数和浮点数的转换：

>>> int(12.34)
12
>>> float(12)
12.0

如果要把 Rational 转为 int，应该使用：

r = Rational(12, 5)
n = int(r)

要让int()函数正常工作，只需要实现特殊方法__int__():

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __int__(self):
        return self.p // self.q

结果如下：

>>> print int(Rational(7, 2))
3
>>> print int(Rational(1, 3))
0

同理，要让float()函数正常工作，只需要实现特殊方法__float__()