1.继承:

class Father:  
    def eat(self):  
       print('人要吃饭')  
      
    def drink(self, name):  
       self.name = name  
       print('我要喝%s='%self.name)    
      
class Son(Father):   
    pass    
      
father = Father()      
father.drink('水')  
   
son = Son()     
son.eat()     
son.drink('水')        
>>>我要喝水      
>>>人要吃饭  
>>>我要喝水 

子类可以继承父类的方法和属性

2.重写

子类中的方法名相同，但属性和结果变了。

class Father:  
    def eat(self):  
        print(人要吃饭)  
    def drink(self, name):  
        self.name = name  
        print(我要喝%s%self.name)    
class Son(Father):  
    def eat(self):  
        print(我要吃苹果)    
      
son = Son()  
son.eat()    
>>>我要吃苹果  

3.继承与私有方法和属性

在父类中有私有方法时，子类继承父类，无法调用其私有的方法和属性，但可以通过在父类中设置公用的方法来调用私有方法和属性，但在子类中调用父类的私有方法或属性，这是不允许的。当然这并不是继承才有的。

4.多重继承:

class A:  
    def one(self):  
        print(--one---)    
class B:  
    def two(self):  
        print(--two--)    
class C(A,B):  
    def three(self):  
        print(--three--)    
      
c = C()    
c.one()    
c.two()    
c.three()    
print(C.__mro__)    

>>>--one---     
>>>--two--     
>>>--three--    
(<class '__main__.C'>, <class '__main__.A'>,<class '__main__.B'>, <class 'object'>)   

多继承：同时继承多个父类的方法和属性，定义解析顺序的是子类的__mro__属性，内容为一个存储要解析类顺序的元组。
但是，多继承容易导致代码混乱，谨慎使用。

5.面向对象三要素：封装，多态，继承

1.封装：隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。
例如：私有属性，类本身就是一个封装的体现。
2.多态：一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）有了继承，才能有多态。

类属性与实例属性

类属性是在类对象中定义的属性
通常记录与类相关的特征
类属性不会记录与对象有关的特征

class Tool(object):  
    count = 0

    def __init__(self):  
        Tool.count += 1  

t1 = Tool()  
t2 = Tool()  
print(Tool.count)  

获取类属性的值可以使用类名.属性（Tool.count）获取，也可以用实例对象获取（不推荐）
属性获取机制：

t1 = Tool()  
t2 = Tool()  
print(t2.count)  
t2.count += 100  # t2.count = t2.count + 100  
print(t2.count)  
print(Tool.count)

>>>2  
>>>102  
>>>2 

类方法

静态方法

使用场景

__new__方法与单例

单例

class A(object):  
    instance = None

    def __new__(cls, *args, **kwargs):  
        if cls.instance is None:  
            cls.instance = super(A, cls).__new__(cls)  
        return cls.instance  

    def __init__(self):  
        print('__init__')  

a1 = A()  
print(a1)  
a2 = A()  
print(a2)  


>>>__init__  
<__main__.A object at 0x0000021B7F38CDD8>  
>>>__init__  
<__main__.A object at 0x0000021B7F38CDD8>  

class A(object):  
    instance = None  
    init_flag = False  # 标记位（**）

    def __new__(cls, *args, **kwargs):  
        if cls.instance is None:  
            cls.instance = super(A, cls).__new__(cls)  
        return cls.instance  

    def __init__(self):  
        if self.init_flag:  
            return  
        self.init_flag = True  
        print('__init__')  

a1 = A()  
print(a1)  
a2 = A()  
print(a2)  
>>>__init__  
<__main__.A object at 0x000001557930CE10>  
<__main__.A object at 0x000001557930CE10>