继承和单例模式

# 父类车类（品牌，颜色，方法：启动），子类小汽车（座位数）
''' 知识点：1.== 在于测试两个被引用的对象是否有相同的值，is 在于测试两个变量是否引用了同一个对象
            2.__repr__()方法与__str__()方法的区别：repr不用遍历输出，它返回的是列表形式
            3.super().start()#调用父类方法:super().方法名(父类方法里的参数，不包括self)
            super(SmallCar,self).start()#调用父类方法:super(子类名，self).方法名(父类所调用的方法里的参数，不包括self)
             Car.start(self)#调用父类方法:父类名.方法名(self，参数)
           4.初始化父类__init__:
              # first:
              self.brand = brand
              self.color = color
              # second:
              super().__init__(brand,color)
              super(SmallCar,self).__init__(brand,color)
              # third:
              Car.__init__(self,brand,color)
           5.less than -- lt小于 , great than -- gt大于 , isinstance(agre1,agre2)判断两个参数是不是一个类型
           以下：如果名字一样就按age排序，否则按中文名字排序encode（'gbk'）
            if self.name == other.name:
                return self.age > other.age
            else:
                return self.name.encode("gbk") > other.name.encode("gbk")

            '''


# 父类
class Car:
    def __init__(self,brand=None,color=None):
        self.brand = brand
        self.color = color
    def start(self):
        print('汽车可以启动！')

#子类
class SmallCar(Car):
    def __init__(self,brand=None,color=None,seating=None):
        # first:
        # self.brand = brand
        # self.color = color

        # second:
        # super().__init__(brand,color)
        #super(SmallCar,self).__init__(brand,color)

        # third:
        Car.__init__(self,brand,color)
        self.seating = seating
    def start(self):
        print('小汽车也可以启动！')
    def seat(self):
        #super().start()#调用父类方法
        super(SmallCar,self).start()#调用父类方法
        #Car.start(self)#调用父类方法
        print('{0}牌的{1}小汽车有{2}个座位'.format(self.brand,self.color,self.seating))
    def __str__(self):
        return '{0}牌的{1}小汽车有{2}个座位'.format(self.brand,self.color,self.seating)
    def __repr__(self):
        return '{0}牌的{1}小汽车有{2}个座位'.format(self.brand, self.color, self.seating)
    def __lt__(self,other):
        if isinstance(other,SmallCar):
            return self.seating < other.seating
        else:
            return None
        # if self.brand == other.brand:
        #     return self.seating < other.seating
        # else:
        #     return self.brand.encode('gpk')

# 实例化
smallCar = SmallCar('可爱','red',6)
smallCar.seat()
smallCar.start()
list1 = []
list1.append(SmallCar('happy','orangered',4))
list1.append(SmallCar('smart','green',8))
list1.append(SmallCar('little','yellow',2))
for car in list1:
    print(car)

print('-'*40)
list1.sort()
print(list1)



#构造方法和初始化方法：先执行构造方法__new__(cls,)后执行初始化方法__init__(self,)
class Person():
    def __new__(cls,*args,**keywords):#参数写成(cls,name,age)也可以，只要与__init__(self,)里保持一致就可以
        print('---new---')
        return object.__new__(cls)
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('---init---')
p = Person('lucy',18)




#单例模式
class SingleDemo:
    __sd = None
    def __new__(cls):
        if cls.__sd == None:
           cls.__sd = object.__new__(cls)
        return cls.__sd
s = SingleDemo()
d = SingleDemo()
print(s,d)


#课外例子
class Parent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print('Parent')#1
    def bar(self,message):
        print('{0} from Parent'.format(message))#3
class Child(Parent):
    def __init__(self):
        super().__init__()
        print('Child')#2
    def bar(self,message):
        super().bar(message)#3
        print('Child bar fuction')#4
        print(self.parent)#5
child = Child()
child.bar('HelloWorld')

#此例中初始化父类
'''
父类初始化时没有参数，就不需要加参数
super().__init__()            #super().__init__(父类初始化时的参数)
super(Child,self).__init__()  #super(子类名，self).__init__(父类初始化时的参数)
Parent.__init__(self)       #父类.__init__(self,父类初始化时的参数)
'''
#此例中调用父类方法
'''
super().bar(message)
super(Child,self).bar(message)
Parent.bar(self,message)
'''