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

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

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

计算平方根可以引用：math.sqrt函数解决

print filter(lambda s: s and len(s.strip()) > 0, ['test', None, '', 'str', '  ', 'END'])

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs


f1, f2, f3 = count()

print f1()
print f2()
print f3()

python面向对象编程：

安装第三方模块：

在cmd命令提示符中输入以下命令来导入第三方模块：

1、pip install web.py

2、python

3、import web

任务

在Python 3.x中，字符串统一为unicode，不需要加前缀 u，而以字节存储的str则必须加前缀 b。请利用__future__的unicode_literals在Python 2.7中编写unicode字符串。

• ?不会了怎么办

• 使用from __future__ import unicode_literals将把Python 3.x的unicode规则带入Python 2.7中。

  参考代码:

  from __future__ import unicode_literals
  s = 'am I an unicode?'
  print isinstance(s, unicode)

python之使用__future__

Python的新版本会引入新的功能，但是，实际上这些功能在上一个老版本中就已经存在了。要“试用”某一新的特性，就可以通过导入__future__模块的某些功能来实现。

例如，Python 2.7的整数除法运算结果仍是整数：

>>> 10 / 3 3

但是，Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：

>>> 10 / 3 3.3333333333333335 >>> 10 // 3 3

要在Python 2.7中引入3.x的除法规则，导入__future__的division：

>>> from __future__ import division >>> print 10 / 3 3.3333333333333335

当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，以便旧的代码能在旧版本中测试新特性。

python中动态导入模块

如果导入的模块不存在，Python解释器会报 ImportError 错误：

>>> import something Traceback (most recent call last):   File "<stdin>", line 1, in <module> ImportError: No module named something

有的时候，两个不同的模块提供了相同的功能，比如 StringIO 和 cStringIO 都提供了StringIO这个功能。

这是因为Python是动态语言，解释执行，因此Python代码运行速度慢。

如果要提高Python代码的运行速度，最简单的方法是把某些关键函数用 C 语言重写，这样就能大大提高执行速度。

同样的功能，StringIO 是纯Python代码编写的，而 cStringIO 部分函数是 C 写的，因此 cStringIO 运行速度更快。

利用ImportError错误，我们经常在Python中动态导入模块：

try:     from cStringIO import StringIO except ImportError:     from StringIO import StringIO

上述代码先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。这样，如果cStringIO模块存在，则我们将获得更快的运行速度，如果cStringIO不存在，则顶多代码运行速度会变慢，但不会影响代码的正常执行。

try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句

python之导入模块

要使用一个模块，我们必须首先导入该模块。Python使用import语句导入一个模块。例如，导入系统自带的模块 math：

import math

你可以认为math就是一个指向已导入模块的变量，通过该变量，我们可以访问math模块中所定义的所有公开的函数、变量和类：

>>> math.pow(2, 0.5) # pow是函数 1.4142135623730951 >>> math.pi # pi是变量 3.141592653589793

如果我们只希望导入用到的math模块的某几个函数，而不是所有函数，可以用下面的语句：

from math import pow, sin, log

这样，可以直接引用 pow, sin, log 这3个函数，但math的其他函数没有导入进来：

>>> pow(2, 10) 1024.0 >>> sin(3.14) 0.0015926529164868282

如果遇到名字冲突怎么办？比如math模块有一个log函数，logging模块也有一个log函数，如果同时使用，如何解决名字冲突？

如果使用import导入模块名，由于必须通过模块名引用函数名，因此不存在冲突：

import math, logging print math.log(10)   # 调用的是math的log函数 logging.log(10, 'something')   # 调用的是logging的log函数

如果使用 from...import 导入 log 函数，势必引起冲突。这时，可以给函数起个“别名”来避免冲突：

from math import log from logging import log as logger   # logging的log现在变成了logger print log(10)   # 调用的是math的log logger(10, 'import from logging')   # 调用的是logging的log

模块和包：

python中偏函数

当一个函数有很多参数时，调用者就需要提供多个参数。如果减少参数个数，就可以简化调用者的负担。

比如，int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

>>> int('12345') 12345

但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换：

>>> int('12345', base=8) 5349 >>> int('12345', 16) 74565

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):     return int(x, base)

这样，我们转换二进制就非常方便了：

>>> int2('1000000') 64 >>> int2('1010101') 85

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

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

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

任务

在第7节中，我们在sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。请用functools.partial把这个复杂调用变成一个简单的函数：

sorted_ignore_case(iterable)

• ?不会了怎么办

• 要固定sorted()的cmp参数，需要传入一个排序函数作为cmp的默认值。

  参考代码:

  import functools sorted_ignore_case = functools.partial(sorted, cmp=lambda s1, s2: cmp(s1.upper(), s2.upper())) print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

python中完善decorator

@decorator可以动态实现函数功能的增加，但是，经过@decorator“改造”后的函数，和原函数相比，除了功能多一点外，有没有其它不同的地方？

在没有decorator的情况下，打印函数名：

def f1(x):     pass print f1.__name__

输出： f1

有decorator的情况下，再打印函数名：

def log(f):     def wrapper(*args, **kw):         print 'call...'         return f(*args, **kw)     return wrapper @log def f2(x):     pass print f2.__name__

输出： wrapper

可见，由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效。decorator还改变了函数的__doc__等其它属性。如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中：

def log(f):     def wrapper(*args, **kw):         print 'call...'         return f(*args, **kw)     wrapper.__name__ = f.__name__     wrapper.__doc__ = f.__doc__     return wrapper

这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，所以Python内置的functools可以用来自动化完成这个“复制”的任务：

import functools def log(f):     @functools.wraps(f)     def wrapper(*args, **kw):         print 'call...'         return f(*args, **kw)     return wrapper

最后需要指出，由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数：

def log(f):     @functools.wraps(f)     def wrapper(x):         print 'call...'         return f(x)     return wrapper

也可能改变原函数的参数名，因为新函数的参数名始终是 'x'，原函数定义的参数名不一定叫 'x'。

任务

请思考带参数的@decorator，@functools.wraps应该放置在哪：

def performance(unit):     def perf_decorator(f):         def wrapper(*args, **kw):             ???         return wrapper     return perf_decorator

• ?不会了怎么办

• 注意@functools.wraps应该作用在返回的新函数上。

  参考代码:

  import time, functools def performance(unit):     def perf_decorator(f):         @functools.wraps(f)         def wrapper(*args, **kw):             t1 = time.time()             r = f(*args, **kw)             t2 = time.time()             t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)             print 'call %s() in %f %s' % (f.__name__, t, unit)             return r         return wrapper     return perf_decorator @performance('ms') def factorial(n):     return reduce(lambda x,y: x*y, range(1, n+1)) print factorial.__name__

def calc_prod(lst):
    def lazy_compute():
        result = 1
        for item in lst:
            result *= item
        return result

    return lazy_compute


fun = calc_prod([1, 2, 3, 4])
print fun()

任务

上一节的@performance只能打印秒，请给 @performace 增加一个参数，允许传入's'或'ms'：

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

• ?不会了怎么办

• 要实现带参数的@performance，就需要实现：

  my_func = performance('ms')(my_func)

  需要3层嵌套的decorator来实现。

  参考代码:

  import time
  def performance(unit):
      def perf_decorator(f):
          def wrapper(*args, **kw):
              t1 = time.time()
              r = f(*args, **kw)
              t2 = time.time()
              t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
              print 'call %s() in %f %s' % (f.__name__, t, unit)
              return r
          return wrapper
      return perf_decorator
  
  @performance('ms')
  def factorial(n):
      return reduce(lambda x,y: x*y, range(1, n+1))
  print factorial(10)