Python的类和对象

1. 类和对象的定义

　　类用class关键字声明，类中的变量成为属性，函数成为方法，定义方法的时候，需要带上self参数。

例：
    class Person:　　　　　　　　# 默认继承Object父类，也可以继承Str，Number等父类
        name = 'dog'
        age = 12
        def fav(self):
            print('喜欢跑步。')

    person = Person()          # 实例化类
    person.name                # dog
    person.fav()               # 喜欢跑步

2. 类的继承和重写　

类的继承，类B继承类A，继承父类的所有属性和方法
    class  A：
        x = 22
        def name(self):
            print('我是A'）
    
    class  B(A):           
        pass

    b = B()
    b.x                    # 22
    b.name()               # 我是A

类的多继承，一个类可以继承多个父类，如果父类中存在相同的方法或属性，则从左往右就近继承
    class D:
        x = 333
        y = 33
        def name(self):
            print('我是D')

    class E(A,D):
        pass

    e = E()
    e.x                        # 22
    e.y                        # 33
    e.name()                   # 我是A

类的重写，类C继承类A，如果类C中存在和父类A相同的属性和方法名，则会重写父类的属性和方法的内容
    class C(A):            
        x = 222
        def name(self):
            print('我是C')

    c = C():
    c.x                    # 222
    c.name                 # 我是C

3. 类的组合　

类的组合，即将类作为值赋给另一个类中的属性
    class Dog:
        def say(self):
            print('汪汪汪')
    
    class Cat:
        def say(self):
            print('喵喵喵')

class Animal:
    dog = Dog()
    cat = Cat()

    def say(self):
        self.dog.say()
        self.cat.say()

    Animal().say()                # 汪汪汪   喵喵喵

4. self的作用

slef的作用
    class Self:
        x = 22
        def get_self(self):
            return self

    mySelf = Self()
    # 他们的结果都是一样的，说明这个self指的是对象的本身
    print(mySelf.get_self())        # <__main__.self object at 0x000002CB88A9CA08>
    print(mySelf)                   # <__main__.self object at 0x000002CB88A9CA08>

　　类实例化对象后方法是共享的，属性是私有的
    mySelf.y = 33
    print(mySelf.y)              # 33，mySelf对象的私有属性y
    
    mySelf1 = Self()
    mySelf1.x                    # 22  x是共有属性，是实例化类的
    mySelf1.y                    # AttributeError: 'self' object has no attribute 'y'

    mySelf1.z = 44
    print(mySelf1.z)             # 44，z是mySelf对象的私有属性

    查看对象的内部私有属性
    mySelf.__dict__              # {'y': 33} 
    mySelf1.__dict__             # {'z': 44}

5. 类的私有变量

1.以__下划线命名，表示这是私有变量,外部无法正常去访问
2.但是，他并不是一个真正的私有变量，他还是可以被外部访问到，只是被偷偷修改了名称
  我们可以通过_类名＋变量名来访问并操作值，并不建议
3._单个下划线开头的变量：代表仅供类内部使用的变量，约定俗成

例：
    class private:
        def __init__(self, x):
            self.x = x

        def set_x(self, x):
            self.__x = x
        
        def get_x(self):
            print(self.__x)

    myPrivate = private(100)
    print(myPrivate.__x)        # 无法访问对象的内部私有属性值
    
    通过内省，类内部的__x被改名为_private__x
    myPrivate.__dict__            # {'_privateVariable__x': 100}
    print(myPrivate._private__x)        # 100

    通过内部方法去修改值
    myPrivate.set_x(200)
    通过内部的方法去访问
    myPrivate.get_x()        # 200

    也可以直接通过_类名+私有属性名的方式直接修改值
    myPrivate._private__x = 300
    myPrivate.get_x()        # 300

不能通过动态添加对象属性的方法来增加类的属性
    1. 直接通过添加变量的方式
    myPrivate.y = 666
    2. 通过字典的属性添加对象的属性__dict__[key] = value
    myPrivate.__dict__['z'] = 888
    查看属性，发现属性的命名为发声改变，说明命名重写只发生在类内部产生的时候
    print(myPrivate.__dict__)    # {'_privateVariable__x': 300, 'y': 666, 'z': 888}

    进一步验证，将类实例化另一个对象，并没有发现y和z的属性
    myPrivate1 = private(1)
    print(myPrivate1.__dict__)    # {'_privateVariable__x': 1}

__slots__方法，限制对象可动态添加的属性，避免内存泄漏浪费
    class Slots:
        __slots__ = ['x', 'y']
        
        def __init__(self, x):
            self.x = x

    slots = Slots(100)
    print(slots.__dict__)        # 报错，使用了__slots__方法就不存在__dict__方法了
    print(slots.__slots__)        # ['x', 'y']  通过__slots__获取

    可以添加__slots__中定义的属性名称，不可以随意添加
    slots.y = 200        # 添加y属性
    slots.z = 300        # 报错，因为__slots__不包含z属性

    slots的继承
    class S(Slots):
        pass
    
    s = S(666)
    print(s.x)        # 666    继承了父类的属性
    s.z = 777
    print(s.z)        # 777    可以添加自己的属性
    print(s.__dict__)        # {'z': 777}
    print(s.__slots__)        # ['x', 'y']