面向对象

把某个人或者事务看成一个对象。每个对象有自己的属性和方法。

类和对象

对象是由类实例化产生的

#声明一个类
class Animal:
    def speak(self):
        print("i can speak")

#实例化一个对象
dog = Animal()
dog.speak() # i can speak

添加和获取对象属性

class Animal:
    age = 1
    weight = 10

    def speak(self):
        print('I can speak')

dog = Animal()
dog.color = 'black' #添加颜色属性
print(dog.age) #1 #获取狗的年龄
dog.speak() # I can speak

面向对象特性

面向对象的特点：封装、继承、多态性。

继承

class Father:
    _f_money = '100'
    __power = 'take child' #私有属性，不会被继承


class Son(Father): #Son 继承了 Father
    pass

xiaoming = Son()
print(xiaoming._f_money) # 100
print(xiaoming.__power) #会报错，Son无法继承该属性

多继承

当有相同属性时，按从左到右的优先级，优先继承
多继承时，深度优先，遇到object，向右继续遍历

class Father:
    _f_money = '100'
    character = '开朗'

class Mother:
    _feature = 'long hair'
    character = '内向'

lass Son(Father,Mother): #Son 同时继承父亲和母亲
    pass

xiaoming = Son()
print(xiaoming._f_money) # 100
print(xiaoming._feature) # long hair
print(xiaoming.character) # 开朗  #优先继承左边的父亲的

print(Son.__mro__) #查看继承的顺序 # Son Father Mother object

重写

子类重写父类的同名方法和属性

class Father:
    def ability(self):
        print('聪明')

class Son(Father):
    def ability(self): #重写父类的方法
        print('普通人')

    def

xiaoming = Son()
xiaoming.ability() #普通人

调用父类方法 super()

直接使用父类的类名

class Father:
    def ability(self):
        print('聪明')

class Son(Father):
    def hiden_ability(self): #重写父类的方法
        Father.ability(self) #调用父类的方法


xiaoming = Son()
xiaoming.hiden_ability() #聪明

使用super进行调用

class Father:
    def __init__(self,character):
        self.character = character

    def say(self):
        print(f'性格是{self.character}')

class Son(Father):
    def __init__(self,character):
        super.__init__(character)
        #Father.__init__(self,character)

xiaoli = Son('活泼')
xiaoli.say() #性格是活泼

魔法方法

在特定条件下，被动调用，不是主动调用

• _init_ 初始化属性，在实例化对象的时候，会被调用
• _add_ 进行对象加法运算的时候，会被调用
• _str_ 当使用print去输出对象时
• _del_ 当对象被删除时触发

class people:
    def __init__(self):
        self.height = 180
        self.weight = 140

    def __add__(self,other):
        self.height += other
        self.weight += other
        return self

    def __str__(self):
        return f'身高是{self.height},体重是{self.weight}'

    def __del__(self):
        print('我被删除了')

xiaoming = people()
xiaoming + 2 + 3
print(xiaoming) #身高是185,体重是145
del xiaoming # 我被删除了

成员变量 类变量

• 成员变量是在构造方法init()中定义的，通过self参数引用。
  在类的外部，成员变量只能通过对象名访问。
• 类变量在类中方法之外定义的变量。
  在类的外部，既可以通过类名访问，也可以通过对象名访问，被类的所有对象共享

class A:
    count = 0 #类变量
    def __init__(self,name):
        self.name = name #成员变量

a = A('a')
print(a.count) #1
b = A('b')
print(a.name) #a
print(a.count) #2
print(b.count) #2
print(A.count) #2  #类名调用类变量

类方法 静态方法

• 类方法：
  在类中定义，使用@classmethod进行装饰，参数填入cls

• 静态方法
  不适用类中的变量(self)，定义在类里面，使用@staticmethod进行装饰
  逻辑上属于类，但和类本身没有关系。静态方法是个独立的、单纯的函数。

class A:
    def __init__(self,a,b):
        self.a = a
        self.b = b
        self.print_() #调用打印的方法

    def print_(self):
        print(self.a+self.b)

    @classmethod #类方法
    def test(1,2):
        return cls(1,2)

    @staticmethod #静态方法
    def sayAWord()：
        print("我是一个静态方法")
A.test() #3 使用类名调用类方法