gentil

1. Définir une classe

Le format syntaxique de la définition de classe est le suivant :

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Une classe est également composée d'attributs et de méthodes. Parfois, lorsque nous définissons une classe, nous devons définir les attributs de la classe, donc cela nécessite un constructeur

class Le constructeur est le suivant :

def __init__(self,[...):

Si la classe définit la méthode init(), l'opération d'instanciation de la classe appellera automatiquement la méthode init().

Ensuite, si le constructeur correspond au destructeur, bien sûr, lorsqu'une classe est créée, on peut utiliser le constructeur pour définir des propriétés, puis lorsqu'une classe est détruite, le destructeur sera appelé.

La syntaxe du destructeur est la suivante :

def __del__(self,[...):

Les enfants qui observent attentivement découvriront que les méthodes de classe ont une différence particulière par rapport aux fonctions ordinaires. Elles doivent avoir un premier nom de paramètre supplémentaire. Par convention, son nom est self .

Alors, que représente le soi ?

Nous pouvons regarder les exemples et trouver la réponse à travers eux :

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
class Test:
    def prt(self):
        print(self)
        print(self.__class__)
t = Test()
t.prt()

Observez les résultats de sortie :

Il ressort clairement des résultats d'exécution que self représente une instance de la classe et que la sortie est l'objet actuel. adresse, tandis que self.__class__ pointe vers la classe.

Bien sûr, self n'est pas un mot-clé python, ce qui signifie qu'il peut être exécuté normalement si on le remplace par d'autres caractères. C'est juste que nous sommes habitués à utiliser self

2. Problèmes historiques dans la définition des classes Python

Dans l'itération des versions Python, il y a un problème historique sur les classes, qui est le problème des classes de nouveau style et Classes à l'ancienne. Plus précisément, regardez d'abord le code suivant :

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# 旧式类
class OldClass:
    pass
# 新式类
class NewClass(object):
    pass

Vous pouvez voir que différentes manières de définir les classes sont utilisées ici. La plus grande différence est que la classe du nouveau style hérite de la classe d'objet en Python2. Il est préférable de définir des classes. Bien sûr, ce problème n'existe pas en Python3 pour définir des classes de nouveau style, car toutes les classes de Python3 sont des classes de nouveau style.

Alors, quelle est la différence entre les cours nouveau style et les cours ancien style ?

Exécutez le morceau de code suivant :

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# 旧式类
class OldClass:
    def __init__(self, account, name):
        self.account = account;
        self.name = name;
# 新式类
class NewClass(object):
    def __init__(self, account, name):
        self.account = account;
        self.name = name;
if __name__ == '__main__':
    old_class = OldClass(111111, 'OldClass')
    print(old_class)
    print(type(old_class))
    print(dir(old_class))
    print('\n')
    new_class=NewClass(222222,'NewClass')
    print(new_class)
    print(type(new_class))
    print(dir(new_class))

Observez attentivement les résultats de sortie et comparez-les, vous pouvez l'observer. Notez que les résultats de sortie dans Python3 sont exactement les mêmes, car il n'y a pas de problème de classes de nouveau style et. classes à l'ancienne en Python3 .