9h52

la programmation orientée object

le programme est ecrit sous forme de classes qui peuvent également etre reutilisé
dans d'autres projets
l'approche modulaire utilisé dans la programamtion (qui se traduit par un code
hautement maintenable )

*/dans la programmation o o chaque classe a une tache specfique .

si une erreur se produit dans une partie du code vous pouvez la rectifier
localement
sans avoir a affecter d'autres parties de code .

*/l'encapsulation des données (que nous étudierons plus loin dans l'article )
ajoute une couche de securité supplementaire au programme developpé
en utilisant l'approche orientée object.

*//les inconvenients :
une connaissance détaillée du domaine du logiciel en cours de developpement est
nécessaire pour crééer
des objects .
toutes les entités logicielles ne sont pas candidates a l'implementation en tant
qu'object

*/la relation classe de programmation orienté object sert de model pour l'object .
une relation entre une classe et object peut etre comprise en examinant la relation
entre
une voiture et une Audit .

syntaxe :
# Creates class Car
class Car:

# create class attributes

name = "c200"
make = "mercedez"
model = 2008

# create class methods

def start(self):
print ("Engine started")

def stop(self):
print ("Engine switched off")

dans cet exemple ci dessus , nous creons une classe nomée car avec trois attributs
:name ,make
et model .la car classe contient egalement deux methodes : Start() et Stop()

----------------------------------------------
OBJECTs
*/nous devons plutot créer un objet d'une classe avant de pouvoir utiliser ses
methodes et ses
attributs

*/un object est aussi appelé une instance ;

par consequent ,le processus de creation d'un object d'une classe est appelé
instanciation .
En Python pour creer un objet d'une classe , il suffit d'ecrire le nom de la classe
suivi
d'une parenthése ouvrante et fermante .

exemple
#creates car_a object of -->car class
car_a = car()

#create car_b object of -->car class

car_b = car()

on a créer deux objects

----------------
verification apres creation des deux objects car_a et car_b
nous pouvons utiliser la Methode type et lui transmettre le nom de notre
objet .Executez le script suivant
print(type(car_b))

10h52

resume :
une class car
#attributes
name = ""
model ="2008"

"class methodes
def start(self)
print ("engine started")

def stop(self)
print ("engine stop")

#les objects

car_a = car()
car_b = car()

----------------
nous avons créé notre class et les objects correspondants
il est maintenant temps d'acceder au attributs de classe et d'appeler la methode de
classe
a l'aide de l'objet de classe .
pour ce faire il vous suffit d'ecrire le nom de l'object suivie de l'operateur
point et du nom
de l'attribut ou de la methode a laquelle vous souhaitez acceder ou appeler
respectivement

car_b.start()

nous appelons la start() methode via l' car_b object .

La sortie sera la suivante :

ce qui est definit dans la class methodes

def start(self)
print ("engine started")

donc comme resultat de car_b.start()

-->engine started
on peut appelé l'attribut de la class car
par car_b.model

si on ecrit dans la ligne de commande

print(car_b.model)
---> 2008

--------------------------------------------
11h02
les attributs

-****************************-resumé
dans la partie precedente nous avons vu comment declarer une classe
et créé des objects d'une classe et utiliser ces objet pour acceder aux attributs
d'une classe
on utilise l'objet car_b.model pour acceder a l'attribut de la classe car
definit dans la classe comme suit

class car :
#les class attribut
model =""
maker =""

#les classe methodes

def start (self)
print ("engin start")

--------------------------

les attributs en python , chaque objet a des attributs et des methodes par defaut
en plus
des attributs definis par l'utilisateur .
Pour voir tous les attributs et methodes d'un object ,
la dir() fonction intégrée peut etre utilisée .
essayons de voir tous les attributs de l'car_b object que ,nous avons créé dans la
derniere section

excucion de la ligne de commande ou script

dir(car_b)
dans la sortie , vous verrez les attributs suivants :

['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
 '__init_subclass__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'make',*****
'model',****
'name',****
'start',****
'stop']***

---->
avec des *** sont definit par l'utilisateur les autres sont definit par defaut

donc la fonction dir() est utile pour inspecter tous les attributs et les fonction
d'un objet
----------------------------------------------
11h15

*/*/attributs de class et d'instance

la difference que les attributs de classe sont partagés par tous les objects d'une
classe

tandis que les attributs d'instance (object) sont la propriété exclusive de

l'instance .

N'oubliez pas qu'une instance n'est qu'un autre non pour l'objet .les attributs
d'instance
sont declarés dans n'inmporte quelle methode tandis que les attributs de classe
sont
declarés en dehors de toute méthode .l'exemple suivant clarifie la difference :
--------------->exemple

classe car:

#create class attributes

car_count = 0

#create class methods

def start (self ,name ,make ,model):

print ("engine started ")
[Link] = name
[Link] = make
[Link] = model
car.car_count += 1

dans le script ci-dessus , nous créons une classe car avec un attribut de class
car_count et trois attributs d'instance name, make, et mode.
La classe contient une methode
start()-->

def start(self ,name,make ,model )

qui contient les trois attributs d'instance ( ou d'object ).
Les valeurs des attributs d'instance sont transmises en tant qu'arguments a la
start()
methode .
a l'interieur de la start methode l'car_count attribut est incrementé a 1 "un"

******************************************

tres impotant :
Il est important de mentionner qu'à l'intérieur de la méthode, les attributs
d'instance
sont référencés à l'aide du self mot clé,
tandis que les attributs de classe sont référencés par le nom de la classe.
-----------------------------------
creant un objet de car class et appelons la methode start()

car_a = car() #car_a est un objet ou instance de la class car()

car_a.start ("corrolla","Toyota" , 2015)#la methode start contient trois attribut
d'instance
ou l'object car_a

print(car_a.name )
print(car_a.car_count)

dans le script ci-dessous :

-------------------------------------------------
creation d'une classe car avec un attribut class car_count
trois attribut d'instance name make model

la class contient une methode start() qui contient les trois attributs d'instances

remarque : a l'interieur de la methode ,les attributs d'instance sont referencés a

l'aide du
self mot clé , tandis que les attributs de classe sont referencé par le nom de la
classe
Créons un objet de la car classe et appelons la start() methode .

car_a = car()
car_a.start("corrola" ,"toyota", 2013)
print(car_a.name)
print(car_a.car_count)

15h51

*/*/----------> Dans le script ci-dessus :

Nous imprimons l'attribut instance name et l'attribut class car_count attribut aura
une
valeur de 1, comme indiqué ci-dessous .
--> comme resultat nous aurons
engine started
corrola
1 ************par ce que car_a.car_count est un attribut de class

maintenant créons un autre objet de la car classe et appelons la start() méthode

car_b = car()
car_b.start("city","honda",2013)
print(car_b.name)
print(car_b.car_count)

Maintenant
si vous imprimez la valeur de la car_count attribut , vous verrez 2 dans la sortie
.
cela est du au fait que l'car_count attribut de classe et qu'il est donc partagé
entre les instances .l'car_a objet a incrementé sa valeur a 1 , tandis qu e car_b
l'object l'a incrementée a nouveau,d'ou la valeur finale est devenu a 2

donc par la suite si nous avons car_count = 0 comme attribut de class

comme la cration de la classe est comme la suivante
class car :
car_count=0 #c'est la creation de la classe attribut (le nombre de voitures)

def start (self, name, make, model) #creation d'une methode start qui
contient les trois attributs d'instances ou d'objets .

*/creation d'un objet de la classe car et appelons la methode start

car_a = car()
car_a.start("polo","volswagen",2017)# par appel a la methode start (ayant des
attributs
exclusivement concernant l'instance car_a)

print(car_a.name)
-->polo
print(car_a.car_count)
-->1

de plus
un autre objet de la classe car
creation d'un objet
car_b = car()
car_b = [Link]("corolla", "toyota", 2013 )

-->corolla
--->2
2 par ce que le compteur incremente l'attribut de classe car (il compte le nombre
de voiture en genreale )

car.car_count en dehors de la methode elle est initialisé a zero

en la methode
celui qui fait la difference de l'attribut instance
(instance ce n'est qu'un autre nom de l'objet) et l'attribut class est que
l'attribut class
s'execute pour touts les objet les instance mais pas pour les attribut instance
il sont exclusivement des attribut commaçant par le mot self. le nom de la mehtode
ou bien dans cet exemple start .
et l'attribut class
class.car_count +=1 la class ici c'est la car
donc class.car_count +=1

def start(self, name, make, model):

print ("Engine started")
[Link] = name
[Link] = make
[Link] = model
Car.car_count += 1

------------------------------------------------------------------------
17/03/2022
14h31
suite programmation orienté objet...

methodes
les methodes sont utilisées pour implementer les fonctionnalités d'un objet .
nous avons vu els methodes start() et stop()
des methode pour la classe car
-->cependant , il existe un type de methodes
qui peut etre appelée directement a l'aide du nom de la classe
une telle methode est appelée methode statique

--------------
methode statiques
pour decrire une methode statique , vous devez specifier le @staticmethod..
descripteur avant le nom de la methode comme indiquéé ci - dessous

class car:
@staticmethod # descripteur avant le nom de la methode ...
def get_class_details(): # Le nom de la methode
print("this is a car class") #
car.get_class_details() # appel de la methode en utilisant le nom de la classe .

dans le script ci-dessous nous creons une classe

car avec une methode statique get_class_deails().
Appelons cette methode en utilisant le nom de la classe .

car.get_class_details()

**********vous pouvez voir que nous n'avons pas eu besoin de créer une instance
de la car classe (pas besoin de creer un objet)
pour appeler la get_class_details() methode
nous avons simplement utilisé le nom de la classe.
*********il est important de mentionner que les methodes statiques
ne peuvent accéder qu'aux attributs
de classe en python .
//*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*//
---------------------------
Renvoyer plusieurs valeurs d'une methode
l'une des meilleurs fonctionnalités du language python est la capacité des methodes
de la classe a renvoyer plusieurs valeurs .
jetez un oeil a l'exemple suivant
class square:
@staticmethod
def get_squares(a, b):
return a*a, b*b

print(square.get_squares(3,5))

Dans le script ci-dessus nous avons crée une classe nommée square avec une methode
statique get_squares().
la methode prend deux parametres ;
multiplie chaque parametre par lui meme et renvoie les deux resultats
a l'aide de l'return instruction .
dans la sortie du script ci-dessus vous verrez
le carré de 3 et 5
--------------------------
la methode str
jusqu'a present , nous avons imprimé des attributs a l'aide de print() methode
voyons ce qui se passe si nous imprimons l'objet d'une classe

pour ce faire nous allons créer une car classe simple avec une methode et essayer
d'imprimer l'objet de la classe sur la console .executez le script suivant :

class car:
#create class methods
def start(self) :print("Engine started")
car_a = car()
print(car_a)

dans le script ci-dessus ,nous créons car_a l'objet de la car classe et imprimons
sa
valeur a l'ecran.
Fondamentalement ,
nous traitons ici l'car_a objet comme une chaine .la sortie ressemble a ceci :

<__main__.car object at 0x000002914AD54130>

La sortie montre l'emplacement de la memoire ou notre objet est stocké.

chaque objet python a une _str_ methode par defaut.
lorsque vous utilisez l'objet en tant que chaine ,la_str_ methodes est appelée , ce
qui imprime par defaut l'emplacement memoire de l'objet .
Cependant , vous pouvez également fournir votre propre defintion de la_str_
methode.
par exemple regardez l'exemple suivant :

#create class car

class car:
#create class methods

def__str__(self):
return "car class object"

def start(self):
print("engine started")

car_a = car()
print(car_a)

dans le script ci-dessus , nous remplaçons la __str__ methode en fournissant

notre propre defintion presonnalisée pour la methode .
Maintenant , si vous imprimez l'car_a objet , vous verrez le message
"object de classe de voiture "sur la console .c'est le message que nous avons
imprimé dans
notre __str__ methode personnalisée .

En utilisant cette methode , vous pouvez créer des descptions personnalisée et

plus significatiives pour le moment ou un objet est imprimé .
vous pouvez meme afficher certaines des données au sein de la classe ,
comme le name d'une peron classe.
-----------------------------------------------------------------------------------
-----
Constructeurs
un constructeur est une methode speciale qui est appelé par defaut chaque fois que
vous créez un objet d'une
classe
pour créer un constructeur , vous devez créer une methode avec le mot-clé __int__.
jetez un oeil a l'exemple suivant

class car:
#create class attributes
car_count = 0
#create class methods
def __init__(self):
car.car_count +=1
print(car.car_count)

lien pour la suite

[Link]