python 类的各类设计、子类扩展、变化及继承学习笔记

python 类的各类设计、子类扩展、变化及继承，边学边练，边练边记录。

print("=============类的设计=======================")
class Employee:
    def __init__(self,name,salary=0):
        self.name = name
        self.salary =salary
    def giveRaise(self,percent):
        self.salary = self.salary + (self.salary*percent)
    def work(self):
        print(self.name,"does stuff")
    def __repr__(self):
        return "<Employee:name=%s,salary=%s>"%(self.name,self.salary)

class Chef(Employee):
    def __init__(self,name):
        Employee.__init__(self,name,50000)
    def work(self):
        print(self.name,"makes food")

class Server(Employee):
    def __init__(self,name):
        Employee.__init__(self,name,40000)
    def work(self):
        print(self.name,"interfaces with customer")

class PizzaRobot(Chef):
    def __init__(self,name):
        Chef.__init__(self,name)
    def work(self):
        print(self.name,"makes pizza")

if __name__ == '__main__':
    bob = PizzaRobot('bob')
    print(bob)
    bob.work()
    bob.giveRaise(0.20)
    print(bob);print()

    for klass in Employee,Chef,Server,PizzaRobot:
        obj = klass(klass.__name__)
        obj.work()

class Customer:
    def __init__(self,name):
        self.name=name
    def order(self,server):
        print(self.name,"orders from",server)
    def pay(self,server):
        print(self.name,"pays for item to",server)

class Oven:
    def bake(self):
        print("oven bakes")

class PizzaShop:
    def __init__(self):
        self.server = Server('Pat')
        self.chef =PizzaRobot('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('Homer')
    print('...')
    scene.order('Shaggy')

print("=============重返流处理器=======================")
# def processor(reader,converter,writer):
#     while 1:
#         data = reader.read()
#         if not data: break
#         data = converter(data)
#         writer.write(data)
#
# class Processor:
#     def __init__(self,reader,writer):
#         self.reader = reader
#         self.wrtier = writer
#     def process(self):
#         while 1:
#             data = self.reader.readline()
#             if not data: break
#             data =self.converter(data)
#             self.wrtier.write(data)
#     def converter(self,data):
#         assert False,'converter must be defined'
#
# class Uppercase(Processor):
#     def converter(self,data):
#         return data.upper()
# if __name__ == '__main__':
#     import sys
#     obj = Uppercase(open('spam.txt'),sys.stdout)
#     obj.process()

print("============类的高级主题===================")
class Set:
    def __init__(self,value=[]):
        self.data = []
        self.contat(value)

    def intersect(self,other):
        res = []
        for x in other:
            res.append(x)
        return Set(res)

    def union(self,other):
        res = self.data[:]
        for x in other:
            if not  x in res:
                res.append(x)
        return Set(res)

    def contat(self,value):
        for x in value:
            if not x in self.data:
                self.data.append(x)

    def __len__(self):         return len(self.data)
    def __getitem__(self, key): return self.data[key]
    def __and__(self, other):  return self.intersect(other)
    def __or__(self, other):  return self.union(other)
    def __repr__(self):    return 'Set:' + repr(self.data)

x=Set([1,3,5,7])
print(x.union(Set([1,4,7])))
print(x | Set([1,4,6]))

print("============通过子类扩展类型===================")
# class Mylist(list):
#     def __getitem__(self, offset):
#         print('(indexing %s at %s)' % (self,offset))
#         return list.__getitem__(self,offset - 1)
#
#     if __name__ == '__main__':
#         print(list('abc'))
#         x=Mylist('abc')
#         print(x)
#
#         print(x[1])
#         print(x[3])
#
#         x.append('spam');print(x)
#         x.reverse();print(x)

print("============新式类变化===================")
"""
1、类和类型合并
类现在就是类型,并且类型现在就是类。实际上,这二者基本上是同义词。type(I)内置函数返回一个实例所创建自的类,而不是一个通用的实例类型,并
且,通常是和I. class相同的。此外,类是type类的实例,type可能子类化为定制类创建,并且所有的类(以及由此所有的类型)继承自object
2、继承搜索顺序
多继承的钻石模式有一种略微不同的搜索顺序,总体而言,它们可能先横向搜索再纵向搜索,并且先宽度优先搜索,再深度优先搜索。
3、针对内置函数的属性获取
getattr_和_getattribute_方法不再针对内置运算的隐式属性获取而运行。这意味着,它们不再针对运算符重载方法名而调用,这样的名称搜索从类开
始,而不是从实例开始。
4、新的高级工具
新式类有一组新的类工具,包括slot、特性、描述符和 getattribute方法。这
些工具中的大多数都有非常特定的工具构建目的。
"""
# class C:pass
# I=C()
# type(I)
# I.__class__
# type([1,2,3])
# type(list)
# list.__class__

print("============所有对象派生自object===================")
class C:pass
X=C()
type(X)
type(C)

isinstance(X,object)
isinstance(C,object)

type('spam')
type(str)

isinstance('spam',object)
isinstance(str,object)

type(type)
type(object)

isinstance(type,object)
isinstance(object,type)


print("============钻石继承变动===================")
class A:
    attr = 1
class B(A):
    pass
class C(A):
    attr = 2
class D(B,C):
    pass
x=D()
print(x.attr)

class A(object):
    attr = 1
class B(A):
    pass
class C(A):
    attr = 2
class D(B,C):
    pass
x=D()
print(x.attr)

print("============下阶段学：异常与工具===================")