Notes d'étude de base Python 08-classes et objets héritent des attributs de classe polymorphes et des attributs d'instance, des méthodes de classe et des méthodes statiques

1. Classes et objets

1.1 Définition
Syntaxe:
classe nom de classe ():
code

1.2 Créer un objet
Syntaxe:
nom d'objet = nom de classe ()

class Animal():
    def func(self):
        print("animal")

animal = Animal()
animal.func()

1.3 Attributs
Ajouter des attributs d' objet en dehors de la classe:
syntaxe:
nom d'objet. Attribut = valeur

Récupère les propriétés de l'objet en dehors de la classe:
syntaxe:
nom de l'objet. Propriété

class Person():
    def func(self):
        print("person")

p = Person()
p.name = "Tom"
p.age = 18
print(f"姓名{p.name},年龄:{p.age}")

Récupère les attributs d'objet dans la classe:
syntaxe:
self. Attribute name

class Person():
    def func(self):
        print(f"姓名：{self.name},年龄:{self.age}")

p = Person()
p.name = "Tom"
p.age = 18
p.func()

1.4 Méthode magique
1.4.1 _ init _
Fonction: initialiser l'objet

class Person():
    def __init__(self):
        self.name = "Tom"
        self.age = 18
    def func(self):
        print(f"姓名：{self.name},年龄:{self.age}")

Remarque:
_ init _ est appelé par défaut lors de la création d'un objet, pas besoin d'appeler manuellement (équivalent au constructeur C ++)
_ init _ dans le paramètre self, n'a pas besoin d'être passé par le développeur

# 带参数的_init_()
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(f"姓名：{self.name},年龄:{self.age}")

1.4.2 _ str _
Lorsque vous utilisez print pour sortir un objet, l'adresse mémoire de l'objet est imprimée par défaut. Si la méthode _ str _ est définie, les données de retour dans cette méthode seront imprimées. Utilisé pour afficher l'état de l'objet

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "Person"

p = Person("Tom",18)
print(p)	# Person

1.4.3 _ del _
Lors de la suppression d'un objet, appelez la méthode _ del _ ()

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        print(f"姓名：{self.name},年龄:{self.age}")

p = Person("Tom",18)
del p

2. Héritage

2.1
Classe de syntaxe nom de classe parente ():
code
classe nom de sous-classe (nom de classe parente):
code

Héritage multiple:

class Father():
    def __init__(self):
        self.hair = "black"
    def __str__(self):
        return self.hair

class Mother():
    def __init__(self):
        self.hair = "brown"
    def _str_(self):
        return self.hair

class Son(Father,Mother):
    pass

s = Son()
print(s)

Lorsqu'une classe possède plusieurs classes parentes, les propriétés et méthodes du même nom de la première classe parente sont utilisées par défaut. Les
sous-classes peuvent remplacer les méthodes de la classe parente

2.2 La sous-classe appelle les propriétés et les méthodes de la classe parente avec le même nom

class Father():
    def __init__(self):
        self.hair = "black"
    def __str__(self):
        return self.hair

class Mother():
    def __init__(self):
        self.hair = "brown"
    def _str_(self):
        return self.hair

class Son(Father,Mother):
    def __init__(self):
        self.hair = "blond"
        #调用父类的方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def father_hair(self):
        Father.__init__(self)
    def mother_hair(self):
        Mother.__init__(self)
    def son_hair(self):
        # 如果先调用了父类的属性和方法，父类属性会覆盖子类属性故先调用子类的属性初始化
        self.__init__()
    def _str_(self):
        return self.hair

s = Son()
s.father_hair()
print(s)
s.mother_hair()
print(s)
s.son_hair()
print(s)

2.3 super () appelle la méthode de la classe parent
Syntaxe 1:
super (nom de la classe actuelle, self). Function ()
Syntaxe 2:
super (). Function ()

    def parents_hair(self):
        super().__init__()
    def son_hair(self):
        super(Son,self).__init__()

2.4 Autorité privée
Syntaxe:
self .__ nom d'attribut = valeur
self .__ nom de fonction ():

class Father():
    def __init__(self):
        self.__money = 1000		# 私有权限
class Son(Father):
    pass

3. Polymorphisme

Le polymorphisme est une manière d'utiliser des objets. Les sous-classes remplacent les méthodes parentes et appellent les mêmes méthodes parentes d'objets de sous-classes différents, ce qui peut produire des résultats d'exécution différents.

class Father():
    def func(self):
        print("father")

class Son(Father):
    def func(self):
        print("son")

class Daughter(Father):
    def func(self):
        print("daughter")

class Person():
    def person_func(self,p):
        p.func()

s = Son()
d = Daughter()
p = Person()
p.person_func(s)
p.person_func(d)

4. Attributs de classe et attributs d'instance

L'attribut de classe est l'attribut appartenant à l'objet de classe, qui est partagé par tous les objets d'instance de la
classe. L'attribut de classe est accessible à l'aide de l'objet de classe ou de l'objet d'instance
. Syntaxe: nom de classe. Nom d'attribut.
Avantages de la classe attribut:
lorsqu'un certain élément de données enregistré est toujours cohérent, définissez ensuite les attributs de classe.
Les attributs d'instance exigent que chaque objet ouvre un espace mémoire distinct pour l'enregistrement des données, tandis que les attributs de classe sont partagés par toutes les classes, n'occupant qu'une seule mémoire, ce qui économise plus d'espace mémoire

Les attributs de classe ne peuvent être modifiés que via l'objet de classe, et non via l'objet d'instance
. Syntaxe: nom de classe. Nom d'attribut = valeur

5. Méthodes de classe et méthodes statiques

5.1 Méthode de classe Le
décorateur @classmethod doit être utilisé pour l'identifier en tant que méthode de classe. Pour une méthode de classe, le premier paramètre doit être un objet de classe, généralement cls est utilisé comme premier paramètre

# 当方法中需要使用类对象时，定义类方法，类方法一般和类属性配合使用
class Father():
    __money = 100
    @classmethod
    def get_money(cls):
        return cls.__money

5.2 Les méthodes statiques
doivent être décorées avec le décorateur @staticmethod, les méthodes statiques n'ont pas besoin de passer des objets de classe ni des objets d'instance,
les méthodes statiques sont également accessibles via des objets d'instance et des objets de classe

class Person():
    @staticmethod
    def func():
        print("Person")