python面向对象（二）

元类

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

内置函数

内置函数	描述
issubclass(sub, sup)	如果类 sub 是类 sup 的子类，则返回 True，反之，为 False
isinstance(obj1, obj2)	如果实例obj1是类obj2或者obj2子类的一个实例；或者如果obj1 是 obj2 的类型，则返回 True；反之，为 False。
hasattr(obj, attr)	如果 obj 有属性 attr（用字符串给出），返回 True，反之，返回
getattr(obj, attr[, default])	获取 obj 的 attr 属性；与返回 obj.attr 类似；如果 attr 不是 obj 的属性，如果提供了默认值，则返回默认值；不然， 就会引发一个 AttributeError 异
setattr(obj, attr, val)	设置obj的attr属性值为val，替换任何已存在的属性值； 不然，就创建属性；类似于 obj.attr=val
delattr(obj, attr)	从 obj 中删除属性 attr（以字符串给出）；类似于 del obj.attr
dir(obj=None)	返回 obj 的属性的一个列表；如果没有给定 obj，dir()则显示局部名字空间空间中的属性，也就是 locals().keys()
super(type, obj=None)	返回一个表示父类类型的代理对象；如果没有传入 obj， 则返 回的 super 对象是非绑定的；反之，如果 obj 是一个 type ， issubclass(obj,type) 必 为 True ； 否 则 ， isinstance(obj,type)就必为 True
vars(obj=None)	返回 obj 的属性及其值的一个字典；如果没有给出 obj， vars()显示局部名字空间字典（属性及其值），也就是 locals()。

常用的一些方法实例

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	构造器
del	构造器
str	可打印的字符输出；内建 str()及 print 语句
repr	运行时的字符串输出(用于调试)
unicode	Unicode 字符串输出
call	表示可调用的实例
nonzero	为object 定义 False 值 ；内置bool()
len	“长度”（可用于类）；内建 len()
cmp	对象比较；内建 cmp()
lt	小于/小于或等于；对应<及<=操作符
gt	大于/大于或等于；对应>及>=操作符
eq	等于/不等于；对应==,!=及<>操作符
C.*add(self, obj)	加；+操作符
C.*sub(self, obj)	减；-操作符
C.*mul(self, obj)	乘；*操作符
C.*div(self, obj)	除；/操作符

新式类的常用法的解释

 __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()