python类类

Posted 2021-01-24

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 "<Employees: name:%s,salary:%s>" %(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