Programmation orientée objet dans Python

De nombreuses fonctionnalités existent dans la programmation orientée objet (OOP) pour développer une application simple à complexe. Il est utilisé pour organiser le code en fonction de l'objet contenant des attributs et des comportements, et chaque objet est une instance d'une classe particulière. Les programmes OOP sont plus efficaces que les programmes fonctionnels et faciles à comprendre. Cette approche de programmation est plus adaptée au développement de projets importants et complexes qui sont divisés en groupes. Python est un langage de programmation très populaire pour soutenir la programmation fonctionnelle et orientée objet. Trois caractéristiques principales de la POO sont l'héritage, l'encapsulation et le polymorphisme. Comment écrire un programme orienté objet dans Python à partir de la base et les utilisations de trois fonctionnalités OOP principales en utilisant le script Python ont décrit dans ce tutoriel.

Contenu:

L'apprentissage de la programmation orientée objet dans Python des bases a été expliquée ici en discutant des sujets suivants avec des exemples.

1. Classe et objet
2. Constructeur
3. Héritage
4. Encapsulation
5. Polymorphisme
6. Getter et Setter
7. Opérateur de surcharge et fonction

Classe et objet:

Dans la programmation orientée objet, classe est utilisé pour déclarer la structure de données définie par l'utilisateur qui contient l'ensemble des attributs. Les attributs peuvent être les variables de classe, les variables d'instance et les méthodes. Les variables accessibles par tous les cas de la classe sont appelées variables de classe. Les fonctions qui sont déclarées à l'intérieur de la classe sont appelées méthodes. Les variables définies dans n'importe quelle méthode de classe et accessibles par l'instance actuelle de la classe sont appelées variables d'instance. Une classe est déclarée dans Python en définissant le mot-clé de classe suivi d'un nom de classe et d'un côlon (:). La syntaxe de la classe est définie ci-dessous.

Syntaxe de la classe:

Class ClassName:
Variables;
Méthodes;

Une instance ou une copie d'une classe est appelée un objet utilisé pour accéder aux variables de classe et aux méthodes de classe. Une classe est inutile sans déclarer un objet parce que le classe Contient la description de l'objet uniquement qui n'alloue aucune mémoire. Le objet est déclaré en mentionnant le nom de classe avec le démarrage et la fin des premiers supports. Si la classe Contient toute méthode de constructeur avec les paramètres, alors vous devez définir la valeur des paramètres au moment de objet déclaration. La syntaxe de l'objet est donnée ci-dessous.

Syntaxe de l'objet:

Object_name = class_name ()

ou

Object_name = class_name (value1, value2,…)

La déclaration d'une classe simple et la déclaration d'objet de cette classe ont montré dans le script suivant. Une classe nommée 'Livre'a été déclaré ici qui contient trois variables de classe (book_name, auteur_name et prix) et une méthode nommée book_discount_price (). La méthode calculera le prix du livre après une remise de 5% et imprimera les détails du livre avec l'original et le prix de réduction. La variable d'objet nommée ObjBook a été définie dans le script pour créer l'instance de la classe et appeler la méthode de classe.

ClassandObject.py

# Définir la classe
livre de classe:
# Définir et initialiser les variables de classe
book_name = "Learn python à la dure"
auteur_name = "Zed Shaw"
prix = 22
# Définir la méthode de la classe pour afficher les détails du livre avec un prix de réduction
def book_discount_price (self):
# Calculez le prix de réduction après une remise de 5%
d_price = self.Prix ​​- soi.Prix ​​* 0.05
# Détails du livre d'impression
print ("Nom du livre: \ NAUTHOR NOM: \ Noriginal Price: $ \ ndiscount Price: $ \ n"
.format (soi.book_name, soi.Auteur_name, soi.prix, d_price))
# Créez un objet de la classe
objBook = book ()
Imprimer ("Informations sur le livre après la remise:")
# Appelez la méthode de classe
objbook.book_discount_price ()

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus.

Constructeur:

Le constructeur est une méthode d'une classe appelée automatiquement à la déclaration d'objet Time de cette classe. Il est principalement utilisé pour initialiser l'objet d'une variable. def Le mot-clé est utilisé pour déclarer toute méthode dans une déclaration de classe Python, et le nom de la méthode du constructeur est __init __ () en python. Deux types de constructeurs peuvent être déclarés à Python. Ce sont le constructeur sans paramètre et le constructeur paramétré. Les utilisations des deux constructeurs ont montré dans cette partie de ce tutoriel.

UN. constructeur sans paramètre

Le constructeur qui ne contient qu'un seul argument nommé soi est appelé constructeur sans paramètre ou par défaut. Aucun paramètre n'est tenu de passer au moment de la déclaration d'objet d'une classe qui contient le constructeur sans paramètre. La façon de déclarer un constructeur sans paramètre a été montrée dans le script suivant. Ici le Client La classe contient le constructeur sans paramètre qui initialisera les quatre variables de classe lorsqu'un objet de classe sera créé. Ensuite, un objet de la classe nommé objcustmer a été déclaré accéder aux variables de la classe.

default_constructor.py

# Définir la classe client
Client de classe:
# Déclarer le constructeur sans paramètre
def __init __ (soi):
# Initialiser les variables de classe
soi.Id = 'd-67455'
soi.name = 'Sakib Hasan'
soi.account_type = 'Saving'
soi.solde = 5000000
# Créer un objet de la classe client
objCustomer = client ()
Imprimer ("Informations de base du client: \ n")
# Imprimer les valeurs des propriétés de l'objet
print ("id: \ nname: \ naccount type: \ nbalance: "
.format (objcustomer.Id, objcustomer.nom, objcustomer.account_type, objcustomer.équilibre))

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus.

B. Constructeur paramétré

Le constructeur qui contient un ou plusieurs arguments avec le 'soi'L'argument est appelé le constructeur paramétré. Vous devez passer les valeurs des paramètres au moment de la création d'objets de la classe. La façon de déclarer le constructeur paramétré a été montrée dans le script suivant. Ici le Client La classe est déclarée avec un constructeur paramétré et deux méthodes. La méthode nommée Balance_After_Deposit () est défini pour ajouter le montant du dépôt avec le solde. La méthode nommée Balance_After_WithDraw () est défini pour déduire le montant du retrait du solde. Ensuite, la variable d'objet est définie pour afficher les détails de base du client, le solde après le dépôt et le solde après le retrait.

paramétré_constructeur.py

# Définir la classe client
Client de classe:
# Déclarer le constructeur avec paramètre
def __init __ (self, cust_id, cust_name, cust_balance):
# Initialiser les variables
soi.Id = cust_id
soi.name = cust_name
soi.Balance = Cust_Balance
# Ajouter le montant avec le solde
DEF Balance_After_Deposit (self, Deposit_amount):
soi.Balance + = dépôt_amount
# Imprimez le solde actuel
print ("dépôt ammount: \ ncurrent Balance: \ n".format (dépôt_amount, soi.équilibre))
# Soustrayez le montant du solde
DEF Balance_After_WithDraw (self, retrait_amount):
soi.solde - = retrait_amount
# Imprimez le solde actuel
print ("retirer ammount: \ ncurrent Balance: \ n".format (retrait_amount, soi.équilibre))
# Créer un objet de la classe client
objCustomer = Client ('M-231234', 'Mir Sabbir', 200000)
# Imprimez les informations de base du client
print ("Détails du client: \ nid: \ nname: \ nopening Balance: \ n"
.format (objcustomer.Id, objcustomer.nom, objcustomer.équilibre))
# Ajouter le montant du dépôt
objcustmer.Balance_After_Deposit (30000)
# Soustrayez le montant du retrait
objcustmer.Balance_After_WithDraw (10000)

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus. Ici, le solde d'ouverture est de 200000. Le solde devient 220000 après avoir ajouté 30000 et déducteur 10000.

Héritage:

L'une des caractéristiques de base de la programmation orientée objet est l'héritage. La façon de créer une nouvelle classe à partir d'une classe existante est appelée héritage. La classe existante est appelée classe parent ou classe de base, et la nouvelle classe héritée est appelée l'enfant ou la classe dérivée. La classe infantile contiendra les caractéristiques de la classe de base après l'héritage. Comment l'héritage peut être appliqué dans la classe Python s'est montré dans l'exemple suivant. Dans le script, le 'Étudiant"est la classe parent, et le"Studibsetails'est la classe d'enfants. Les deux classes ont les constructeurs paramétrés. La classe parent a une méthode nommée Afficher Basic () Pour imprimer les variables ID, nom et e-mail de la classe parentale. La classe enfant a une méthode nommée DisplayInfo () pour imprimer les valeurs du grouper et les variables semestres de la classe enfant. Le constructeur de la classe parent est appelé le constructeur de classe enfant. Après la déclaration de classe, l'objet de la classe parent a été déclaré avec des valeurs à trois paramètres pour initialiser les variables de classe de la classe parent, et la méthode de la classe parent a été appelée pour afficher ces valeurs. Ensuite, l'objet de classe enfant a été déclaré avec des valeurs à trois paramètres pour initialiser les variables de classe de la classe infantile, et la méthode de la classe enfant a été appelée à afficher ces valeurs.

héritage.py

# Définir la classe parent
Élève de classe:
# Définir le constructeur de la classe parent
Def __init __ (self, id, nom, e-mail):
# Initialiser les variables de classe parent
soi.Id = id
soi.nom = nom
soi.e-mail = e-mail
# Définir la méthode de la classe parent
Def DisplayBasic (self):
# Imprimez les valeurs des variables de classe parent
print ("id: \ nname: \ nemail: ".format (soi.Id, moi.Nom, soi.e-mail))
# Définir la classe infantile
classe StudentDetails (élève):
# Définir le constructeur de classe d'enfants
Def __init __ (self, id, nom, e-mail, département, lot, SEM, CGPA):
# Appelez le constructeur de la classe parent
Étudiant.__init __ (self, id, nom, e-mail)
# Initialiser les variables de classe infantile
soi.département = département
soi.lot = lot
soi.Semestre = SEM
soi.CGPA = CGPA
# Définir la méthode de classe infantile
Def DisplayInfo (self):
Étudiant.DisplayBasic (soi)
# Imprimez les valeurs des variables de classe infantile
print ("Department: \ nbatch: \ nsemerter: "
.format (soi.département, soi.lot, moi.semestre))
# Créez l'objet de la classe parent
Objstudent = Student ('674534', 'Rakib Hasan', 'Rakib @ gmail.com ')
Imprimer ("Informations de base de l'élève: \ n")
# Appelez la méthode de la classe parent
objstudent.DisplayBasic ()
# Créez l'objet de la classe enfant
objstudentDetails = StudentDetails («783412», «Zannatul Ferdous», «zannat @ gmail.com ',' cse ', 48, 10, 3.89)
Imprimer ("\ nstudent des informations détaillées: \ n")
# Appelez la méthode de la classe enfant
objstudentdetails.DisplayInfo ()
# Imprimez une valeur de propriété de la classe enfant
print ("cgpa: ".format (objstudentdetails.cgpa))

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus.

Encapsulation:

Une autre caractéristique de base de la programmation orientée objet est l'encapsulation. La façon de cacher les variables et les méthodes particulières d'une classe est appelée encapsulation. Il est utilisé pour définir la restriction pour accéder aux données particulières. L'objectif principal de cette fonctionnalité est de fournir la sécurité des données par la cachette des données. L'encapsulation peut être mise en œuvre dans Python en déclarant les membres de données privés ou protégés de la classe. Comment l'encapsulation peut être implémentée dans Python s'est montré dans l'exemple suivant. Dans le script, le Ajouter La classe a créé en héritant du Nombre classe. Un membre privé nommé '__résultat'a déclaré dans la classe infantile pour stocker la somme de deux nombres, et cette variable est accessible à l'intérieur de la classe infantile uniquement. Le constructeur de la classe parent initialise deux variables de classe avec les nombres. Selon le script, le constructeur de classe d'enfants appellera le constructeur de la classe parent, calculera la somme des variables de classe et imprimera le résultat de l'addition. Après la déclaration de classe, l'objet de la classe enfant a été déclaré. Ensuite, le membre privé de la classe infantile a utilisé dans la fonction d'impression qui générera une erreur.

espion.py

# Définir la classe parent
numéro de classe:
def __init __ (soi):
# Initialiser les membres publics de la classe Parent
soi.n1 = 10
soi.n2 = 30
# Définir la classe infantile
Class Add (numéro):
def __init __ (soi):
# Appelez le constructeur parent
Nombre.__en soi)
"
Stockez le résultat de l'ajout dans un membre privé
de la classe enfant
"
soi.__Result = soi.N1 + Self.n2
# Imprimez le résultat de l'addition
print ("Le résultat de l'addition = \ n".format (soi.__résultat))
# Créez l'objet de la classe enfant
objadd = add ()
# Imprimer la propriété privée de la classe infantile
imprimer (objadd.__résultat)

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus. Lorsque l'objet a été défini, la méthode du constructeur a été appelée et la somme de 10 et 30 a imprimé. Le message d'erreur est apparu pour essayer d'accéder au membre privé depuis l'extérieur de la classe.

Polymorphisme:

Une autre caractéristique de base de la programmation orientée objet est le polymorphisme. Le sens de poly est «beaucoup», et morphisme est des «formes». La façon de déclarer la même fonction plusieurs fois à des fins différentes est appelée polymorphisme. Le codage devient plus facile pour l'utilisation de cette fonctionnalité de l'OOP. Cette fonctionnalité peut être implémentée à l'aide d'un script Python, comme le polymorphisme dans différentes classes, le polymorphisme dans les classes héréditaires, etc. Comment le polymorphisme peut être mis en œuvre dans différentes classes à l'aide du script Python s'est montré dans l'exemple suivant. Dans le script, deux classes non liées nommées rectangle et cercle ont été déclarées. Les deux classes ont le constructeur paramétré et une méthode nommée zone(). Ici, les deux classes contiennent la même méthode, mais le but de la méthode est différent. Dans la classe rectangulaire, le constructeur initialisera deux variables nommées hauteur et largeur, et le zone() La méthode calculera la zone du rectangle. Dans la classe Circle, le constructeur initialisera une variable nommée rayon, et le zone() La méthode calculera la zone du cercle. Après avoir déclaré la classe, deux valeurs de nombre seront prises de l'utilisateur pour passer la hauteur et les valeurs de largeur au constructeur du Rectangle classe au moment de la déclaration d'objet. Ensuite, le zone() Méthode de la Rectangle La classe sera appelée pour imprimer la zone du rectangle en fonction des valeurs d'entrée. Après cela, une valeur de nombre sera tirée de l'utilisateur pour passer la valeur de rayon au constructeur du Cercle classe au moment de la création d'objets. , le zone() Méthode de la Cercle La classe sera appelée pour imprimer la zone du cercle en fonction de la valeur d'entrée.

polymorphisme.py

# Définir la classe rectangulaire
Rectangle de classe:
# Définir le constructeur
Def __init __ (soi, hauteur, largeur):
# Initialiser les variables de classe
soi.hauteur = hauteur
soi.largeur = largeur
# Définissez la méthode pour calculer la zone rectangulaire
zone def (soi):
zone = soi.Hauteur * Self.largeur
print ("La zone du rectangle est \ n".format (zone))
# Définir la classe Circle
Cercle de classe:
# Définir le constructeur
def __init __ (self, rayon):
# Initialiser la variable de classe
soi.rayon = rayon
# Définir la méthode pour calculer la zone du cercle
zone def (soi):
zone = 3.14 * Self.rayon * soi.rayon
print ("La zone du cercle est \ n".format (zone))
# Prenez les valeurs de hauteur et de largeur de l'utilisateur
hauteur = int (entrée ("Entrez la hauteur du rectangle:"))
largeur = int (entrée ("Entrez la largeur du rectangle:"))
# Créez l'objet de la classe rectangulaire
objrectangle = rectangle (hauteur, largeur)
# Zone d'appel () Méthode pour imprimer la zone du rectangle
objrectangle.zone()
# Prenez la valeur du rayon de l'utilisateur
rayon = int (entrée ("Entrez le rayon du rectangle:"))
# Créez l'objet de la classe Circle
objCircle = cercle (rayon)
# Areat d'appel () Méthode pour imprimer la zone du cercle
ob000000000000000000000000000000000000000000000000000000000000000000JCIRCLE.zone()

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus. Selon la sortie, 5 a pris la valeur de hauteur et 2 a pris la valeur de largeur. Pour ces valeurs, la zone du rectan0gle est de 10 (5 × 2) qui a été imprimée. Ensuite, 2 a pris la valeur du rayon et la zone du cercle est de 12.56 (3.14x2x2) qui a été imprimé.

Getter et Setter:

La méthode utilisée pour lire la valeur de la propriété est appelée Getter, et la méthode utilisée pour définir la valeur de la propriété est appelée setter. Dans la programmation orientée objet, le Getter est utilisé pour accéder aux attributs privés de la classe, et le secteur est utilisé pour définir les valeurs des attributs privés de la classe. Les principaux objectifs de cette fonctionnalité sont d'assurer l'encapsulation des données et la validation des données. Le Getter et Setter peuvent être implémentés en utilisant la fonction normale ou @property décorateur. Les deux façons d'implémenter le secteur et le getter ont été montrés dans cette partie du tutoriel.

Setter et Getter en utilisant la fonction normale:

Le script suivant montre comment la fonction normale peut être utilisée pour implanter des méthodes Getter et Setter. Dans le script, le Personne La classe contient les méthodes de Getter et de Setter personnalisées pour lire les valeurs des variables de classe privée et définir la valeur de la variable de messagerie qui est un membre privé. La valeur vide est passée pour la variable des e-mails au moment de la création d'objets, et la méthode du secteur personnalisé a été utilisée pour définir la valeur de l'e-mail. La méthode Getter personnalisée renvoie toutes les valeurs de la variable de classe sous forme de liste.

personnalisé_setter_getter.py

# Définir la classe
Personne de classe:
DEF __INIT __ (Self, nom, e-mail, téléphone):
# Définir les variables des membres privés
soi.__name = nom
soi.__Email = Email
soi.__phone = téléphone
# Définir le Getter personnalisé
def get_person_data (self):
print ("La méthode de Getter personnalisée est appelée")
Retour [moi.__nom, soi-même.__Email, soi.__téléphone]
# Définir le setter personnalisé
def set_person_data (self, e-mail):
print ("La méthode du setter personnalisé est appelée")
soi.__Email = Email
# Créer un objet de la classe
Objperson = Person ('Rifat bin Hasan', ", '01855435626')
# Définissez la valeur de l'e-mail à l'aide de Setter personnalisé
objonrson.set_person_data ('rifat @ gmail.com ')
# Lisez toutes les valeurs des membres de données à l'aide de Getter personnalisé
personne = objperson.get_person_data ()
# Imprimez les valeurs de retour
print ("name: \ nemail: \ nphone: ".format (personne [0], personne [1], personne [2]))

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus.

Setter et Getter à l'aide de @property décorateur:

Le script suivant montre comment le décorateur @property peut être utilisé pour implanter des méthodes Getter et Setter. Dans le script, le Getter et le Setter ont déclaré en utilisant @property décorateur pour définir la valeur de la variable, un membre de la classe privée. Après avoir déclaré la classe, l'objet de la classe a été défini et la valeur de la variable de nom a été attribuée et récupérée en utilisant le secteur et le getter.

décorateur_setter_getter.py

# Définir la classe
Personne de classe:
def __init __ (self, name = "):
# Définir les variables des membres privés
soi.__name = nom
# Définir le Getter personnalisé
@propriété
Def Name (self):
print ("La méthode Getter est appelée")
se retourner.__nom
# Définir le setter personnalisé
@nom.setter
Def Name (self, nom):
print ("La méthode du setter est appelée")
soi.__name = nom
# Créer un objet de la classe
objPerson = personne ()
# Définissez la valeur de l'e-mail à l'aide de Setter personnalisé
objonrson.name = 'Zanifer Ali'
print ("Le nom de la personne est \ n".format (objperson.nom))

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus.

Opérateur de surcharge et fonction:

Lorsqu'une fonction ou opérateur est utilisé dans un but différent en fonction du paramètre de fonction ou des opérandes au lieu de l'utilisation normale de la fonction ou de l'opérateur, il est appelé surcharge. La fonction de réutilisabilité peut être implémentée dans une programmation orientée objet en utilisant la surcharge de l'opérateur et la surcharge de fonction. C'est une caractéristique utile de la POO, mais l'utilisation excessive de cette fonctionnalité crée des difficultés à gérer le code. L'utilisation simple de la surcharge de l'opérateur et de la surcharge de fonctions dans la classe Python a été affichée dans ce tutoriel.

Surcharge de l'opérateur:

L'opérateur est utilisé sur deux opérandes. Le but de chaque opérateur est différent. Par exemple, il existe de nombreuses utilisations de l'opérateur '+', comme il peut être utilisé pour l'addition, combinant deux chaînes, etc. Mais lorsque l'opérateur «+» est utilisé dans un but différent, il est appelé la surcharge de l'opérateur. Les fonctions spéciales sont utilisées pour différents types de surcharge de l'opérateur. La fonction spéciale est déclarée en utilisant «__» au début et à la fin du nom de la fonction. De nombreuses fonctions spéciales de différents types d'opérateurs existent à Python pour la surcharge des opérateurs. L'opérateur peut être mathématique, comparaison opérateur, opérateur d'assignation, etc. L'utilisation de la fonction spéciale de l'opérateur mathématique a été montrée dans cette partie de ce tutoriel pour comprendre le concept de surcharge de l'opérateur à Python.

Opérateur mathématique:

Les opérateurs utilisés pour les opérations arithmétiques sont appelés opérateurs mathématiques. Ces opérateurs peuvent être utilisés dans un but spécial en utilisant une fonction spéciale. Certaines fonctions spéciales de l'opérateur mathématique sont mentionnées ci-dessous.

Nom de l'opérateur	Symbole	Fonction spéciale
Ajout	+	__add __ (Self, autre)
Soustraction	-	__Sub __ (Self, autre)
Multiplication	*	__mul __ (self, autre)
Division	/ /	__Treediv __ (self, autre)
Module	%	__mod __ (self, autre)
Pouvoir	**	__POW __ (Self, autre)

Utilisation de la fonction spéciale de l'opérateur de puissance (**):

__POW __ () La fonction spéciale est utilisée pour surcharger l'opérateur de puissance. Le but principal de l'opérateur de puissance est de calculer la valeur de puissance d'un nombre particulier. Mais si nous devons calculer les valeurs de puissance en utilisant des valeurs ponctuelles, alors l'opérateur de puissance générale ne fonctionnera pas. Supposons qu'il y ait deux points (3, 2) et (2, 4). Nous avons besoin de la somme de 32 et 24. Dans ce cas, nous devons utiliser la fonction spéciale de l'opérateur de puissance. La fonction __pow __ () peut calculer la somme des pouvoirs en fonction des valeurs ponctuelles indiquées dans le script suivant. La classe Sumofpower contient un constructeur paramétré pour initialiser deux variables de classe, __POW __ () fonction pour calculer la somme de deux pouvoirs en fonction des valeurs ponctuelles, et __str __ () fonction pour imprimer l'objet de la classe. Ensuite, deux objets de la classe ont été déclarés. L'opérateur de puissance a utilisé deux variables d'objet dans l'impression () fonction pour appeler le __POW __ () fonction pour terminer l'opération.

Operator_Overloading.py

# Définir la classe
Class SumofPowers:
# Définir le constructeur de classe
def __init __ (self, n1, n2):
soi.a = n1
soi.b = n2
# Surcharge de l'opérateur électrique
def __pow __ (self, autre):
a = soi.un ** autre.un
b = soi.déranger.b
soi.résultat = a + b
Retour SumofPowers (A, B)
Fonction de chaîne pour imprimer l'objet de la classe
Def __str __ (Self):
Retour Str (Self.a) + '+' + str (self.b)
# Créez le premier objet
POW1 = SUMOFPOWERS (3, 2)
# Créez le deuxième objet
Pow2 = SumofPowers (2, 4)
# Calculez les pouvoirs et imprimez la somme des pouvoirs
print ("La somme de Powers =", pow1 ** pow2, "=", pow1.résultat)

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus. 32 est 9 et 24 est 16. La somme de 9 et 16 est 25 qui s'affiche dans la sortie.

Surcharge de fonction:

Parfois, nous devons écrire plusieurs méthodes qui sont assez similaires mais diffèrent dans certaines parties uniquement. Dans ce cas, une seule méthode peut être définie pour effectuer les mêmes tâches en utilisant la surcharge de fonction. La complexité du code peut être supprimée et le code devient plus clair en utilisant la surcharge de fonction. La sortie de la fonction dépend de l'argument transmis à la fonction. Comment la surcharge de fonction peut être implémentée dans Python s'est montrée dans le script suivant. Le but principal du script est d'effectuer quatre types d'opérations arithmétiques avec la valeur par défaut ou les valeurs passées au moment de la création d'objets. La méthode nommée calculer () a été utilisé ici pour faire les opérations arithmétiques. La méthode a été appelée quatre fois dans le script pour effectuer quatre types de tâches. Lorsque la méthode appelle sans aucun argument, il affichera un message uniquement. Lorsque la méthode appelle avec «+» comme valeur d'argument, il calculera les valeurs par défaut. Lorsque la méthode appelle avec '-' et une valeur numérique en tant que valeurs d'argument, il soustraire la deuxième valeur par défaut de la valeur d'argument. Lorsque la méthode appelle avec '*' et deux valeurs numériques comme valeurs d'argument, il calculera deux valeurs d'argument.

function_overloging.py

# Définir la classe
Arithmétique de classe:
# Définir la variable de classe
résultat = 0
# Définir la méthode de classe
Def calculer (self, opérator = "", numéro1 = 25, nombre2 = 35):
# Calculez la sommation
Si l'opérateur == "+":
soi.result = number1 + nombre2
print ('Le résultat de l'ajout est '.format (soi.résultat))
# Calculez la soustraction
ELIF Opérateur == "-":
soi.result = number1 - numéro2
print ('Le résultat de la soustraction est '.format (soi.résultat))
# Calculez la multiplication
Opérateur ELIF == "*":
soi.result = number1 * numéro2
print ('Le résultat de la multiplication est '.format (soi.résultat))
# Calculez la division
Opérateur ELIF == "/":
soi.result = number1 / numéro2
print ('Le résultat de la division est '.format (soi.résultat))
autre:
imprimer ("aucun opérateur n'est donné")
# Créez l'objet de la classe
objarithmétique = arithmétique ()
# Appelez la méthode sans argument
objarithmétique.calculer()
# Appelez la méthode avec un argument
objarithmétique.calculer ('+')
# Appelez la méthode avec deux arguments
objarithmétique.calculer ('-', 50)
# Appelez la méthode avec trois arguments
objarithmétique.calculer ('*', 2, 3)

Sortir:

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus. 'Aucun opérateur n'est donné'Le message a imprimé pour appeler la méthode sans aucun argument. La somme de 25 et 35 a été imprimée pour appeler la méthode avec un argument. La valeur de soustraction de 50-35 a été imprimée pour appeler la méthode avec deux valeurs d'argument. La valeur de multiplication de 3 et 2 a imprimé pour appeler la méthode avec trois valeurs d'argument. De cette façon, la surcharge de fonction a été implémentée dans le script pour utiliser la même fonction plusieurs fois.

Conclusion:

La programmation de base orientée objet dans Python a été expliquée dans ce tutoriel en utilisant des exemples de python très simples. Les caractéristiques les plus courantes de la POO sont discutées ici pour aider les lecteurs à connaître la façon de la POO à Python et à pouvoir écrire un programme Python en utilisant la classe et l'objet.