Six questions sur Python orienté objet

Cet article est écrit pour les amis qui découvrent Python, essayant d'expliquer les questions suivantes :

• Que sont les classes et les objets ?
• Maintenant qu'il existe des fonctions, pourquoi avons-nous besoin de classes ?
• Comment Python définit-il public /attributs protégés/privés/ La méthode private est-elle vraiment privée ? Quel est le but de cette méthode ?
• Comment définir les fonctions de classe, les fonctions membres et les fonctions statiques, et quelles sont leurs fonctions ? comment faire en sorte que les sous-classes soient obligées de les réécrire ? Seules les fonctions de la classe parent peuvent être utilisées, sinon une exception sera levée ?
• Il existe la relation d'héritage suivante : A, B(A), C(A), D( B,C) Ensuite, lorsque D est initialisé, A, B, C Quelle est la séquence d'initialisation ? A sera-t-il initialisé deux fois
• 1 Que sont les classes et les objets

Parlons d'abord des objets. . Ils font référence à des choses qui sont des objectifs lorsque l'on agit ou pense, ou spécifiquement l'amour de l'autre partie. Dans le monde de la programmation, les objets sont la cartographie des personnes, des choses, des objets et d'autres entités qui existent dans le monde objectif en logique informatique.

Lors de la programmation, vous pouvez mapper des objets sur tout ce que vous souhaitez mapper. Cependant, si le mappage est plus conventionnel, le code sera plus facile à utiliser et à comprendre, et il sera plus propice à une itération et une expansion rapides ultérieures. Dans le monde de Python, tout est objet.

Parlons des classes. Les classes sont des classes de classification, qui représentent un ensemble de choses similaires et correspondent à la classe de mots-clés Python.

Un objet est un élément spécifique d'une classe, généré après l'initialisation de la classe. Il est généralement également appelé objet ou entité. Par exemple, une femme est une classe et votre petite amie est un objet.

Attribut : Une certaine caractéristique statique de l'objet, comme la couleur de peau, l'origine ethnique, le groupe sanguin de votre petite amie, etc.

Fonction : Une certaine capacité dynamique de l'objet, comme votre petite amie peut chanter, jouer du piano, etc.

Bien que l'exemple donné ne soit peut-être pas approprié, j'espère qu'il pourra approfondir votre compréhension. En fait, la définition plus précise est la suivante :

Une classe est une collection d'objets avec les mêmes attributs et fonctions.

2. Maintenant qu'il y a des fonctions, pourquoi avons-nous besoin de classes ?

Les fonctions servent à résoudre la réutilisation du code, mais les fonctions sont une réflexion sur les processus si elles sont trop spécifiques, il y aura beaucoup de répétitions dans les choses qui le sont aussi. spécifique, donc nous devons toujours faire abstraction des problèmes, et les classes sont une sorte d'abstraction. Les classes abstraites sont plus réutilisables, plus faciles à affronter avec une logique métier complexe et réduiront également la pression de la mémoire des programmeurs lors de la programmation.

S'il n'y a pas de cours, c'est plus facile pour nous d'écrire une montagne de code de merde, qui affecte tout le corps et de ne pas oser le modifier. Avec les classes, il nous est plus facile d’écrire du code facile à lire, facile à maintenir et extensible.

3. Comment Python définit-il les attributs/méthodes publics/protégés/privés ? Le oui et le non privés sont vraiment privés ?

Python accepte les attributs/méthodes protégés/privés sous la forme suivante :

__ signifie privé

• _ signifie protection
• Sauf pour les deux premiers, c'est public
• La soi-disant convention signifie que lorsque vous voyez une variable ou une méthode commençant par un double trait de soulignement ou un simple trait de soulignement, vous devez ne pas le modifier ou y accéder consciemment en dehors de la classe. En d'autres termes, Python n'empêche pas les programmeurs d'accéder aux propriétés privées ou aux méthodes privées des classes. Python choisit de faire confiance aux programmeurs.

Il n'y a aucune différence entre accéder aux propriétés publiques et accéder aux propriétés protégées. Pour accéder aux propriétés privées, vous devez faire ceci :

object._ClassName__PrivateMember

4 Comment définir les fonctions de classe, les fonctions membres et les fonctions statiques, et quelles sont leurs fonctions ?

Voir les commentaires :

class Document():

WELCOME_STR = 'Welcome! The context for this book is {}.'

def __init__(self, title, author, context):
print('__init__函数被调用')
self.title = title
self.author = author
self.__context = context

#类函数
@classmethod
def create_empty_book(cls, title, author):
return cls(title=title, author=author, context='nothing')

# 成员函数
def get_context_length(self):
return len(self.__context)

# 静态函数
@staticmethod
def get_welcome(context):
return Document.WELCOME_STR.format(context)
empty_book = Document.create_empty_book('What Every Man Thinks About Apart from Sex', 'Professor Sheridan Simove')
print(empty_book.get_context_length())
print(empty_book.get_welcome('indeed nothing'))

La fonction de classe est décorée avec @classmethod. Le premier paramètre doit être cls, qui représente la classe elle-même, c'est-à-dire qu'on peut appeler le constructeur de classe cls() dans la fonction classmethod. générer une nouvelle instance. À partir de ce point, nous pouvons déduire ses scénarios d'utilisation :

Lorsque nous devons appeler à nouveau le constructeur, c'est-à-dire lors de la création d'un nouvel objet instance

• Nous devons renvoyer une nouvelle instance sans modifier l'instance existante.
• Les fonctions membres sont très courantes, ce sont des méthodes qui peuvent être appelées directement par un objet. Le premier paramètre doit être self.

La fonction statique, décorée de @staticmethod, signifie généralement que le calcul de cette fonction n'implique pas de variables de classe et peut être utilisée sans instanciation de la classe. En d'autres termes, la relation entre la fonction et cette classe n'est pas très étroite. En d’autres termes, les fonctions décorées avec la méthode statique peuvent également être définies en dehors de la classe. J'ai parfois du mal à savoir si je dois utiliser la méthode statique dans une classe ou écrire une fonction distincte dans utils.py.

5. Les classes peuvent être héritées. Comment faire en sorte que les sous-classes doivent réécrire les fonctions de la classe parent avant de pouvoir être utilisées, sinon une exception sera levée

Deux méthodes, la seconde est recommandée.

Premier type :

class A:
def fun(self):
raise Exception("not implement")
class B(A):
pass

b = B()
b.fun()

Deuxième type :

from abc import ABCMeta,abstractmethod
class A(metaclass = ABCMeta):
@abstractmethod
def fun(self):
pass
class B(A):
pass

b = B()
b.fun()

6 Il existe la relation d'héritage suivante : A, B(A), C(A), D(B,C) Puis lorsque D est initialisé, A, Quoi. est l'ordre d'initialisation de B et C ? A sera-t-il initialisé deux fois ?

---> B---
A--->D
---> C---

Quel est l'ordre d'initialisation de A, B et C Vous pourriez aussi bien écrire du code pour voir.

Il existe deux manières. La première manière A sera initialisée deux fois, et la seconde ne le sera pas.

Premier type :

class A:
def __init__(self):
print("A is called")class B(A):
def __init__(self):
print("B is called")
A.__init__(self)class C(A):
def __init__(self):
print("C is called")
A.__init__(self)class D(B,C):
def __init__(self):
print("D is called")
B.__init__(self)
C.__init__(self)

d = D()

Sortie :

D is called
B is called
A is called
C is called
A is called

Deuxième type :

class A:
def __init__(self):
print("enter A")
print("levave A")class B(A):
def __init__(self):
print("enter B")
super().__init__()
print("levave B")class C(A):
def __init__(self):
print("enter C")
super().__init__()
print("levave C")class D(B,C):
def __init__(self):
print("enter D")
super().__init__()
print("levave D")

d = D()

Sortie ;

enter D
enter B
enter C
enter A
levave A
levave C
levave B
levave D

第一种方法非常明确的表明了菱形继承潜在的问题：一个基类的初始化函数可能被调用两次。在一般的工程中，这显然不是我们所希望的。

正确的做法应该是使用 super 来召唤父类的构造函数，而且 python 使用一种叫做方法解析顺序的算法(具体实现算法叫做 C3)，来保证一个类只会被初始化一次。

也就是说，能用 super，就用 super。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!