动态语言的多态和静态语言c++等多态含义不太一样，c++中的多态就是参数数量和类型不同的方法就是不同方法，而动态语言中的多态其实值的是方法的寻找过程，即向右找到类（或者单件类），在类中找不到的话再找父类，一直在祖先链中找到或者找不到为止，先找到的就被调用：
class MyClass(object):
   def fn(x):
       print "This is the first fn"
   def fn(x,y):
       print "This is the second fn"
obj = MyClass()
obj.fn(1)
结果fn被复写，而没有实现多态

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

使用Python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。

sorted()函数可对list进行排序

空白符（包括'\n', '\r', '\t', ' ')

len(s.strip()) > 0

非空字符串

filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list

一个实例的私有属性就是以__开头的属性，无法被外部访问，那这些属性定义有什么用？

虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：

class Person(object):
   address = 'Earth'
   def __init__(self, name):
       self.name = name
p1 = Person('Apple')
p2 = Person('Bob')
print p1.address
p1.address = 'Ocean'
print p1.address
print Person.address
可见类实例的属性，当对象实例化时，对象可以访问到类属性，但是这个类属性，是和当前对象绑定到一起的，对象对类属性的修改不影响类本身的类属性，只影响对象拷贝的那一份类属性。

python中的__slots__

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

已经定义了一个实例的属性和属性值，如果要修改属性值，就给实例的属性重新赋值

但如果要实现对所赋值的有效性的判断，就需要使用特殊的方法，get和set方法；即使用这两个方法来封装对一个属性的访问（面向对象语言中很常见）；

def log(prefix):  #prefix传的是'DEBUG'
    def log_decorator(f):  #f传的是test()
        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

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

B  

本文实例讲述了Python常用时间操作。分享给大家供大家参考，具体如下：

我们先导入必须用到的一个module

设置一个时间的格式，下面会用到

看一下当前的时间，和其他很多语言相似这是从epoch（1970 年 1 月 1 日 00:00:00）开始到当前的秒数。

上面的看不懂，换个格式来看看

localtime返回tuple格式的时间，有一个和它类似的函数叫gmtime(),2个函数的差别是时区，gmtime()返回的是0时区的值，localtime返回的是当前时区的值。

用上我们的时间格式定义了，使用strftime对时间做一个转换，如果取现在的时间，time.localtime() 可以不用。

上面展示了gmtime和localtime的区别。

查看时区用

上面的值是一个秒值，是当前时区和0时区相差的描述，-28800=-8*3600，即为东八区。

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)