搜索第三方包的名字

@classmethod

作用：将一个类函数变成类方法，如果不加，就是一个函数，则在实例中需要单个动态添加，才可使用。

添加了@classmethod后，由于方法也是一个属性，则__init__()也可使用。

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

 types.MethodType() 把一个函数变为一个方法

例：

import types
def fn_get_grade(self):
    if self.score >= 80:
        return 'A'
    if self.score >= 60:
        return 'B'
    return 'C'

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade()
结果: A

# coding=utf-8/coding:utf-8

作用：声明python代码的文本格式是utf-8，python按照utf-8的方式来读取程序。针对于代码存在中文情况。

实例属性优先级比类属性高

例子：

class Person(object):
    address = 'Earth'
    def __init__(self, name):
        self.name = name
print Person.address
P=Person('Bob')
p.address='China'
print p.address
print Person.address
结果：
   Earth
   China
   Earth

类属性：

__XXX: 外部无法访问。

__XXX__: 可以被外部访问，但以"__xxx__"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"__xxx__"定义。

原代码：

def __init__(self, name, gender, birth, **kw): 

        self.name = name

        self.gender = gender

        self.birth = birth

        self.__dict__.update(kw)

xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student') 

print xiaoming.name 

print xiaoming.job

优化代码：

def __init__(self,**kw):

          self.__dict__.update(kw)

xiaoming = Person(name='Xiao Ming', gender='Male', birty='1990-1-1', job='Student')

print xiaoming.name

print xiaoming.job

__dict__.update(kw): 专门针对不确定变量属性名称，由后期输入自行更改。

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

isinstance(对象, 判断类型)：判断该对象是否指定类型；是，返回True; 否，返回False。

例句：

try:

     import json

except importError:

    import simplejson as json

print json.dumps({'python':2.7})

作用：先尝试从json导入，如果失败了（比如json没有被安装），再尝试从simplejson导入。这样，如果json模块存在，则运行速度可以变得更快，如果json不存在，则顶多使用simplejson代码运行速度会变慢，但不会影响代码的正常执行。

ython内置的 sorted()函数可对list进行排序：

>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]

但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

如果s is None，那么s会被判断为False。而False不管和什么做and，结果都是False，所以不需要看and后面的表达式，直接返回s（注意不是返回False）。
如果s is not None，那么s会被判断为True，而True不管和什么and都返回后一项。于是就返回了s.strip()。

样式代码：

import time, functools

def performance(unit):

    def perf_decoraper(f):

        @functools.wraps(f)

        def wrapper(*args, **kw):

           ..........................

            return f(*args, **kw)

        return wrapper

    return perf_decoraper

@performance('ms')

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__

作用：使你在使用修饰后和之前的名字基本一致。

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

原本需要以上的操作，但python内置了functools接口，用functools.wraps()函数即可把原函数的属性复制到新函数，如下：

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

def performance(unit):

    def perf_decorator(f):

        def wrapper(*args, **kw):

            .........................

            return f(*args, **kw)

        return wrapper

    return perf_decorator

@performance('XXX')

def factorial(n):

    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

基本格式：

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

@log
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

*args, **kw：作用是使输入值可以任意
注意：f.__name__中'__'必须由两条下划线组成，不然编译错误