1. 类的命名空间

1> 简单变量和属性名称    1. 简单变量名(无点号)：遵循函数LEGB作用域法则         ==> 赋值(X = value)：// 使变量成为本地变量：除非声明是全局的         ==> 引用(X)：// LEGB搜索变量     2. 属性名称(点号属性名称)：遵循模块和类的规则         ==> 赋值(object.X = value)  // 实例对象命名空间内创建、修改变量         ==> 引用(object.X)：// 基于类的对象：对象内遵循继承搜索；模块：对象中直接读取X(模块中存在类对象，模块没有继承的概念)    2> 命名空间组成：命名空间字典和命名空间链接        属性点号运算实际是内部字典的取值； // x.data = x.__dict__['data']        x.__dict__  // 获取实例的命名空间        x.__class__  // 获取实例的父类        sub.__bases__  //  sub类的父类        命名空间链接：当前命名空间找不到，会按照继承搜索查找        """        父类层次：        B: B --> A        F: F --> D --> B --> A --> C --> A --E         """        class A: pass        class B(A): pass        class C(A): pass        class D(B,C): pass        class E: pass        class F(D,E): pass

2. 继承

*继承原理：实际也是继承树的应用，子类实例总是先去查找自己的命名空间，然后才去查找父类命名空间*    class Manager(Person):   # 7 调用父类的构造函数:我们可以决定哪些参数使用父类,比如此处的Job             def __init__(self,name,pay):                     Person.__init__(self,name,'mgr',pay)             def givePay(self,percent,bouns=.10):       # 调用方法两种方式 1) 实例.方法() 2)类.方法(self) 不管哪种，方法都需要传递一个self调用                     Person.givePay(self,percent + bouns)   # 6.2 继承：扩展子类行为，只能在子类实例对象使用             def doSomething(self):                         return '[%s %s]' %(self.__class__.__name__,"考核")    """        # coding:utf-8        """        类的继承        """        class Employees:            def __init__(self,name,salary=0):                    self.name = name                    self.salary = salary            def givePay(self,percent):                    self.salary = self.salary + (self.salary * percent)            def work(self):                    print(self.name,"does stuff")            def __repr__(self):                    return "
    
     " %(self.name,self.salary)        class Chef(Employees):            def __init__(self,name):                    Employees.__init__(self,name,50000)            def work(self):                    print(self.name,'make foods')        class Server(Employees):            def __init__(self,name):                    Employees.__init__(self,name,40000)            def work(self):                    print(self.name,'interfaces to customer')        class PizzaRobbt(Chef):                def __init__(self,name):                        Chef.__init__(self,name)                def work(self):                        print(self.name,'make pizza')        if __name__ == "__main__":        # 一定要分清楚：object.attr 和 赋值        # 继承是从点号运算开始的，触发实例、类以及超类中属性搜索                bob = PizzaRobbt('bob')                print(bob)                bob.work()                bob.givePay(0.2)                print(bob)            for kclass in Employees,Chef,Server,PizzaRobbt:            # kclass.__name__ 是一个字符串                    obj = kclass(kclass.__name__)                        obj.work()            """            """            """                类的组合：order下单包含Server、Customer、PizzaRobbt一起完成一件事情.            """            from employees import Server,PizzaRobbt            class Customer:                    def __init__(self,name):                            self.name = name                    def order(self,server):                            print(self.name,"order pizza",server)                    def pay(self,server):                            print(self.name,'pay money',server)            class Oven:                    def bake(self):                            print('ovens bakes')            class PizzaShop:                    def __init__(self):                            self.server = Server('Pat')                            self.chef = PizzaRobbt('bob')                            self.oven = Oven()                    def order(self,name):                            customer = Customer(name)                            customer.order(self.server)                            self.chef.work()                            self.oven.bake()                            customer.pay(self.server)                if __name__ == "__main__":                        scene = PizzaShop()                        scene.order('tom')             """
    

3. 抽象超类

*父类中的方法具体在子类中实现;抽象超类是不能被继承的，除非所有抽象方法都在子类实现*    """    class Super:             def method(self):                     print("in Super.method")             def delegate(self):                     self.action()       # 要是子类没有提供action，那么就会抛错：采用assert       # assert False,'action must be method!'     class Provider(Super):             def method(self):                    print('starting Sub.method')                    Super.method(self)  // 扩展父类的方法                    print('ending Sub.method')             def action(self):  // 实现父类的抽象方法                    print('In Provider.action')    """

4. 运算符重载

# coding:utf-8        """            运算符重载        """        import operator        class Number:        # 1. 拦截构造方法                def __init__(self,data):                        self.data = data        # 2. 拦截减法运算                def __sub__(self, other):                        return Number(self.data - other)        class Indexer:                def __init__(self,data):                        self.data = data                # 3.1 拦截索引、切片操作:实例对象拥有索引、切片操作                # 3.1 重载迭代：每次迭代实例对象时都会调用该方法，传入索引值                def __getitem__(self, item):                        print('getitem:',item)                        return self.data[item]                # 3.2 拦截索引赋值、切片赋值操作：实例对象拥有索引赋值、切片赋值操作                def __setitem__(self, key, value):                        self.data[key] = value        class Squeres:        """  iter() 迭代器工厂函数            __iter__() 迭代器协议，可以在自定义类里面形成迭代器 调用方式 1：手动next(i)调用    2：可迭代环境调用     可迭代对象：可以用迭代环境循环的对象    迭代器：支持迭代协议(也就是可以使用next调用);迭代器是可以记住状态的    可迭代对象不一定是迭代器 (for i in 'spam':)    迭代器一定是可迭代对象(支持在迭代环境循环调用)"""                def __init__(self,start,stop):                        self.value = start - 1                        self.stop = stop                # 3.3 在任何迭代环境中,会优先调用__iter__;之后调用__getitem__                # __iter__调用迭代协议;__getitem__调用索引取值，知道抛出索引超范                # __iter__ 根本没有重载索引表达式：X = Squeres(1,5) X[1] 报错                # __iter__ 只循环一次: X = Squeres(1,5) [for i in X] ==> 第二次迭代会为空                def __iter__(self):  # 定义了__iter__的方法,类实例是可迭代对象                        return self  # 此处返回self，每次生成的可迭代对象只能调用一次                def __next__(self):                        if self.value == self.stop:                                raise StopIteration                        self.value += 1                        return self.value            # 调用next方法            class SkipIterator:                    def __init__(self,wrapper):                            self.wrapper = wrapper                            self.offset = 0                    def __next__(self):                            if self.offset >= len(self.wrapper):                                    raise StopIteration                            item = self.wrapper[self.offset]                            self.offset += 2                            return item                # 返回迭代器对象                class SkipObject:                        def __init__(self,wrapper):                                    self.wrapper = wrapper                        def __iter__(self):                                    return SkipIterator(self.wrapper)            class Iter1:            """    1. 成员关系：contains(映射) --> iter --> getitem    2. __iter__和__getitem__ 都可捕获迭代环境      区别：1 __iter__ 使用迭代协议获取值(__next__)，且可以保持状态信息；__getitem__ 使用索引获取值           2 __getitem__ 可以支持索引和切片操作           3 当字段索引行数据时(list、tuple)，两者可替换;为hash类型时(dict、set)，只能用__iter__"""                        def __init__(self,value):                                    self.value = value                        def __getitem__(self, item):                                    print("getitem:",item)                                    return self.value[item]                        def __iter__(self):                                    print("iter=>",end="")                                    self.offset = 0                                    return self                        def __next__(self):                                    print("next:",end="")                                    if self.offset == len(self.value):                                            raise StopIteration                                    item = self.value[self.offset]                                    self.offset += 1                                    return item                    def __contains__(self, item):                                    print("contanins: ",end='')                                    return item in self.value        class Library(object):                    def __init__(self):                                self.books = {'title': 'a', 'title2': 'b', 'title3': 'c', }                    def __getitem__(self, i):                                return self.books[i]                    def __iter__(self):                            # 方法1 使用生成器                            for titles in self.books:                                    yield self.books[titles]        class Empty:            """    拦截属性点号操作；    如果python可以在继承树(self.__dict__)找到该属性,那么__getattr__方法不会被调用    赋值：self.attr = value ==> self.__setattr__(attr,value)        """                    def __init__(self):                            self.data = 0                    def __getattr__(self, item):                            if item == "age":                                    print("__getattr__:",item,end=" ")                                    return 40                            else:                                    raise AttributeError(item)                    def __setattr__(self, key, value):                            if key == "data":                            # 此处一定用self.__dict__[key] = value                            # 因此在__setattr__里面赋值,会再调用__setattr__,造成内存溢出                                        self.__dict__[key] = value                            else:                                        raise AttributeError(key + "not allowed")            class A:            """    1.    __add__ 原处加法(a + b ;a += 1)    __radd__ 右侧加法    2.    a + b ,python会先去a里面找__add__,找不到会去__radd__查找    这个例子： b + a 会报错，因为python会先去B找__add__,然后去A找__radd__,均不满足    3. 每个二元运算符都支持：包括 __sub__(减法)"""                        def __init__(self,val):                                    self.val = val                        def __add__(self, other):                                    return self.val + other            class B:                        def __init__(self,val):                                    self.val = val                        def __radd__(self, other):                                    return self.val + other            class Callee:                """    编写api接口常用：可以将类和实例调用当作函数来使用，并且可以将实例的状态保留到函数内部,自然而然成为了被一个函数记住    ==>并调用另一个函数的实现    __call__ 任何定义了该方法的类和实例 支持与常规函数一致的调用    c = Callee()    c(1,2,3) ==> __call__ (1,2,3) {}"""                def __call__(self, *args, **kwargs):                            print("__call__,",args,kwargs)        class CallBack:                    def __init__(self,color):                            self.color = color                    def __call__(self):                            print('turn',self.color)    class BiJiao:"""比较：__lt__ __gt__ __cmp__(python3.0失效，使用operator替代)"""            pass    class Bool1:"""    拦截布尔操作    __bool__ >> __len__    python 3.0 优先尝试__bool__ python 2.6优先尝试__len__"""                def __bool__(self):                            return True