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

init   &   call

高阶函数

1.变量可以指向函数，例如：

f=abs

f(-20)

输出结果为20

2.函数名就是函数的变量，与变量名相同，指向一个对象，例如：

abs=len

此时abs不再是求绝对值，而是求长度

abs（[1,2,3]）

输出结果为3

3.高阶函数就是能够接受函数作为参数的函数

一个函数可以接受另一个函数作为参数

例如：

def add（x,y,f）

        return f(x)+f(y)

add(-5,,9,abs)

输出结果为14

总结：变量名可以指向函数，传给另一个函数，这就是高阶函数

class Fib(object):
    __L = [0, 1]
    def __init__(self):
        super(Fib, self).__init__()
    def __call__(self, num):
        self.__count = num
        for count in range(2, num):
            Fib.__L.append(Fib.__L[count - 2] + Fib.__L[count - 1])
        return Fib.__L
f = Fib()
print f(10)

class Person(object):
    __slots__ = ('name', 'gender')
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
class Student(Person):
    __slots__ = 'score'
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
s = Student('Bob', 'male', 59)
s.name = 'Tim'
s.score = 99
print s.score

Student类的__slots__只需要包含Person类不包含的score属性即可。

两种书写方式:

__slots__ = ('score',)

当只有一个属性的时候可以省略成
 __slots__ = 'score'

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

    @property
    def grade(self):
        if self.__score >= 80:
            return "A"
        elif self.__score >= 60:
            return "B"
        else:
            return "C"


s = Student('Bob', 59)
print s.grade

s.score = 60
print s.grade

s.score = 99
print s.grade

class Fib(object):
    __L = [0, 1]

    def __init__(self, num):
        self.__count = num
        for count in range(2, num):
            Fib.__L.append(Fib.__L[count - 2] + Fib.__L[count - 1])

    def __len__(self):
        return self.__count

    def __str__(self):
        return str(Fib.__L[:self.__count])


f = Fib(10)
print f
print len(f)

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

def is_odd(x):
    return x % 2 == 1

然后，利用filter()过滤掉偶数：

filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

结果：[1, 7, 9, 17]

filter函数接收一个f和list，f对每个list的元素进行判断，返回Ture /False,即filter是过滤作用的函数

reduce（f,list,【初始值】）：f必须接收2个参数，list中的元素反复调用函数f，初始值可设可不设

map(f,list):map函数接收2个参数，list中元素按函数f执行

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

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...

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

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

__future__(前后为英文状态下两个下划线)

实用便捷方便