python中map()函数

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]

如果希望把list的每个元素都作平方，就可以用map()函数：

因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：

def f(x):     return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

输出结果：

[1, 4, 9, 10, 25, 36, 49, 64, 81]

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

利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。

由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

高阶函数：

不同语言的抽象层次：

1用%1==0，int(math.sqrt(x))相当于强制转换了

import math

def is_sqr(x):

    return math.sqrt(x)%1==0

print filter(is_sqr, range(1, 101))

2判断一个数是否为平方数，现将其开方然后用int取整，再平方，看与原数是否相等

计算平方根可以用函数：

>>> math.sqrt(2)
1.4142...

math.sqrt

import math

def add(x, y, f):

    return f(x) + f(y)

print add(25, 9, math.sqrt)

把函数作为参数

def add(x, y, f):
    return f(x) + f(y)

如果传入abs作为参数f的值：

add(-5, 9, abs)

根据函数的定义，函数执行的代码实际上是：

abs(-5) + abs(9)

实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。定义类属性可以直接在 class 中定义：class Person(object):    address = 'Earth'    def __init__(self, name):        self.name = name因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：print Person.address# => Earth对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性：p1 = Person('Bob')p2 = Person('Alice')print p1.address# => Earthprint p2.address# => Earth由于Python是动态语言，类属性也是可以动态添加和修改的：Person.address = 'China'print p1.address# => 'China'print p2.address# => 'China'因为类属性只有一份，所以，当Person类的address改变时，所有实例访问到的类属性都改变了。

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：class Person(object):
    def __init__(self, name):
        self.name = name
        self._title = 'Mr'
        self.__job = 'Student'
p = Person('Bob')
print p.name
# => Bob
print p._title
# => Mr
print p.__job
# => Error
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute '__job'
可见，只有以双下划线开头的"__job"不能直接被外部访问。但是，如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"__xxx__"定义。

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：class Person(object):    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth
__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。

利用ImportError错误，我们经常在Python中动态导入模块：try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO
上述代码先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。这样，如果cStringIO模块存在，则我们将获得更快的运行速度，如果cStringIO不存在，则顶多代码运行速度会变慢，但不会影响代码的正常执行。try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句。

如果遇到名字冲突怎么办？比如math模块有一个log函数，logging模块也有一个log函数，如果同时使用，如何解决名字冲突？如果使用import导入模块名，由于必须通过模块名引用函数名，因此不存在冲突：import math, loggingprint math.log(10)   # 调用的是math的log函数logging.log(10, 'something')   # 调用的是logging的log函数如果使用 from...import 导入 log 函数，势必引起冲突。这时，可以给函数起个“别名”来避免冲突：from math import logfrom logging import log as logger   # logging的log现在变成了loggerprint log(10)   # 调用的是math的loglogger(10, 'import from logging')   # 调用的是logging的log

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

def gcd (a,b):

    gcd_max = 1

    for s in range(2,min(a,b)+1):

        if a%s == 0 and b%s == 0:

            gcd_max = s

    return gcd_max

class Rational(object):

    def __init__(self, p, q):

        self.p = p

        self.q = q

    def __add__(self, r):

        p = self.p * r.q + self.q * r.p

        q = self.q * r.q

        return Rational(p/gcd(p,q), q/gcd(p,q))

    def __sub__(self, r):

        p = self.p * r.q - self.q * r.p

        q = self.q * r.q

        return Rational(p/gcd(p,q), q/gcd(p,q))

    def __mul__(self, r):

        p = self.p * r.p

        q = self.q * r.q

        return Rational(p/gcd(p,q), q/gcd(p,q))

    def __div__(self, r):

        p = self.p * r.q

        q = self.q * r.p

        return Rational(p/gcd(p,q), q/gcd(p,q))

    def __str__(self):

        return '%s/%s' % (self.p, self.q)

    __repr__ = __str__

r1 = Rational(1, 2)

r2 = Rational(1, 4)

print r1 + r2

print r1 - r2

print r1 * r2

print r1 / r2

class Fib(object):

    def __init__(self, num):

        self.num = num

        self.L = []

        for x in range(1,11):

            self.L.append(self.fibs(x))

    def __str__(self):

        return str(self.L)

    def __len__(self):

        return self.num

    def fibs(self,n):

        if n == 1:

            return 0

        elif n == 2:

            return 1

        else:

            return int(self.fibs(n-1)+self.fibs(n-2))

f = Fib(10)

print f

print len(f)  

@log
def add(x, y):
    return x + y
print add(1, 2)
结果：Traceback (most recent call last):
  File "test.py", line 15, in <module>
    print add(1,2)
TypeError: fn() takes exactly 1 argument (2 given)
因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：def log(f):    def fn(*args, **kw):        print 'call ' + f.__name__ + '()...'        return f(*args, **kw)    return fn现在，对于任意函数，@log 都能正常工作。

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum
注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。