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 2.6/2.7提供了json 模块，但Python 2.5以及更早版本没有json模块，不过可以安装一个simplejson模块，这两个模块提供的函数签名和功能都一模一样。

包的概念

将代码分拆放入多个py文件，可以使得同一名字的变量互不影响。

模块的名字就是py文件的文件名。在一个py文件中利用‘import’引用其他模块（py文件）。

为了解决模块名的冲突，将同名模块放入不同的包（文件夹）中。包可以有多级，而且每一层目录都必须有__init__.py 这一文件。

文件夹跟目录应该是同一个概念。包也是本质上也是一个文件夹，但这个文件夹中包含了__init__.py这个文件，就可以被python识别为包。另外，在包中存放了很多我们自己写的.py文件，这些.py文件就是模块

python之导入模块

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

import math

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

导入用到的math模块的某几个函数，而不是所有函数，可以用下面的语句：

from math import pow, sin, log


使用import导入模块名，由于必须通过模块名引用函数名，因此不存在冲突：import math, logging
print math.log(10)   # 调用的是math的log函数
logging.log(10, 'something')   # 调用的是logging的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：

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

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

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

高阶函数指的就是参数包含函数的函数，此时剩余参数即可参与函数参数计算进而产生返回值。

python中完善decorator

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

Python内置的functools可以用来自动化完成这个“复制”的任务

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

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

python中编写带参数decorator

带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')
def test():
    pass
print test()

执行结果：

[DEBUG] test()...
None

对于这种3层嵌套的decorator定义，你可以先把它拆开：

# 标准decorator:def log_decorator(f):
    def wrapper(*args, **kw):
        print '[%s] %s()...' % (prefix, f.__name__)
        return f(*args, **kw)
    return wrapper
return log_decorator# 返回decorator:def log(prefix):
    return log_decorator(f)

拆开以后会发现，调用会失败，因为在3层嵌套的decorator定义中，最内层的wrapper引用了最外层的参数prefix，所以，把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

python中编写无参数decorator

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

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

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

请编写一个@performance，它可以打印出函数调用的时间。

• ?不会了怎么办

• 计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。

  参考代码:

  import time
  def performance(f):
      def fn(*args, **kw):
          t1 = time.time()
          r = f(*args, **kw)
          t2 = time.time()
          print 'call %s() in %fs' % (f.__name__, (t2 - t1))
          return r
      return fn
  
  @performance
  def factorial(n):
      return reduce(lambda x,y: x*y, range(1, n+1))
  print factorial(10)

在实例中不能访问类的私有属性（带下划线__的属性）

高阶函数：把函数作为另一个函数的参数

在Python中，对匿名函数提供了有限支持。还是以map()函数为例，计算 f(x)=x² 时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

>>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

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

def f(x):
    return x * x

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

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

这个要注意了，返回函数时语句中函数后面是没有括号的。

返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。

• ?不会了怎么办

• 考察下面的函数 f:

  def f(j):
      def g():
          return j*j
      return g

  它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。

  在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。

  参考代码:

  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(), f2(), f3()

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。

原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：

>>> f1()
9     # 因为f1现在才计算i*i，但现在i的值已经变为3

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