元类

python中，对象是由元类创建的，类也是一种对象，也就是说元类就是‘类的类’
eg、电脑中的cpu、内存等等。cpu、内存相当是x。
https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820064557c69858840b4c48d2b8411bc2ea9099ba000

内置函数

常用的一些方法实例

class A(object):
   def __init__(self,):
       print( 'create an instance of',self.__class__.__name__)
   @property
   def name(self):
       return self.__name
   @name.setter
   def name(self,__value):
       self.__name = __value

   def show(self):
       print(self.__name )
class B(A):
    pass
b= B()
a= A()
a.name = "limei"
print(a.show())
# 判断是否是子类
print(issubclass(B,A))
# 判断是否是实例或者子类的实例。是返回true，不是返回false。
print(isinstance(b,A))
print(hasattr(B,"name"))

定制类

python中有很多有特殊用途的函数，可用于扩充类。
实现： 1、模拟标准类型 2、重载操作符
**用来定制类的特殊方法 **
(http://blog.csdn.net/fdl19881/article/details/8443893)
以下只是部分，详细看上面链接

新式类的常用法的解释

 __init__    创建完对象后调用，对当前对象的实例的一些初始化
__new__(cls, *args, **kwargs)  创建对象时调用，返回当前对象的一个实例，只有在新式类的情况下才会有的方法

new的作用
1、主要是当你继承一些不可变的class时(比如int, str, tuple)， 提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass
2、因为类每一次实例化后产生的过程都是通过__new__来控制的，所以通过重载__new__方法，我们 可以很简单的实现单例模式。

class Singleton(object):
    def __new__(cls):
        # 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance
obj1 = Singleton()
obj2 = Singleton()
obj1.attr1 = 'value1'
print obj1.attr1, obj2.attr1
print obj1 is obj2

__call__
一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。能不能直接在

class Student(object):
    def __init__(self, name):
        self.name = name
    def __call__(self):
        print('My name is %s.' % self.name)

输出：
>>> s = Student('Michael')
>>> s()
My name is Michael.

__str__（重新定制打印方式）
class A(object):
    @property
    def name(self):
       return self.__name
    @name.setter
    def name(self,__value):
        self.__name = __value
    def __str__(self):
        return "this is student name is {0}".format(self.__name)
a=A()
a.name="test"
print(a)

输出如下：
this is student name is test

__iter__(返回迭代对象，用于 for in方法)
__getslice__、__setslice__、__delslice__(切片方法)

闭包（闭包(closure)是函数式编程的重要的语法结构）

闭包构成是：一个函数与他的环境变量结合，在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。

def line_conf():
    b = 15
    def line(x):
        return 2*x+b
    return line    
my_line = line_conf()
print(my_line(5))       

分析：我们可以看到，line定义的隶属程序块中引用了高层级的变量b，但b信息存在于line的定义之外 (b的定义并不在line的隶属程序块中)。我们称b为line的环境变量。事实上，line作为line_conf的返回值时，line中已经包括b的取值(尽管b并不隶属于line)。

装饰器

python中一切都是对象，函数也是对象，因而可以当成参数传递。
装饰模式就是在调用目标函数之前，对这个函数队形进行装饰。
最简单的装饰模式如下：

def say_english():
    print("hello")
def greet(say):
    print("英语的你好怎么输出")
    say()
    print("了解了吗")
greet(say_english)

greet方法就是把say_English方法修饰。
输入如下：

英语的你好怎么输出
hello
了解了吗

如果把项目上的say_english()，都需要改为这样格式的输出，则需要把项目中的say_english()改为greet(say_english)这个方法，这样子需要大量的工程或者会改漏，为了调用say_english()也能达到greet(say_english)，则修改如下：

def say_english():
    print("hello")
def greet(say):
    def wrapper():
        print("英语的你好怎么输出")
        say()
        print("了解了吗")
    return wrapper
say_english = greet(say_english)
say_english()

python中一切都是对象，那么greet()函数return的是wrapper的对象。

###语法糖@（python2.4之后才会出现）
python中@相当于 say_english = greet(say_english) 这句，修改如下：

def greet(say):
    def wrapper():
        print("英语的你好怎么输出")
        say()
        print("了解了吗")
    return wrapper

@greet
def say_english():
    print("hello")
say_english()