fonctions et Classes
Dans cette partie du cours, nous allons voir comment créer une fonction ainsi que son fonctionnement. nous verrons également les type de fonctions et quelques mots réservés qui peuvent rendre vos fonctions dynamiques. dans une deuxième partie, nous entameront la programmation orientée objet avec les class et l'héritage des class
1.les fonctions
Avant de commencer cette
partie, voyons d’abord le fonctionnement des fonction print(),
input() et dir()
print() :
Cette fonction permet
d’afficher un résultat sur la ligne de commande de python sous forme de chaine
de caractère. L’on peut afficher plusieurs variables à la fois en séparant par
des virgules. Elle possède 2 arguments :
sep : qui permet
d’indiquer le caractère qui sera utilisé pour relier les différentes valeur
séparé par les virgules
end : qui permet
d’indiquer le caractère qui sera affiché en dernier sur la chaine de caractères
exemple :
>>> print('neji','hyuga')
neji hyuga
>>> print('neji','hyuga',
sep='*')
neji*hyuga
>>> print('neji','hyuga'
,end='*')
neji hyuga*
input() :
cette fonction permet à
l’utilisateur d’inserer une valeur par le clavier. Cette valeur est une chaine
de caractère donc, si c’est un nombre, vous devriez le convertir préalablement
au travers des fonctions int() ou float()
>>> name=input('entrez votre
nom : ')
entrez votre nom : neji
>>> age=int(input('entrez votre
age : '))
entrez votre age : 17
>>> print(name,'a',age,'ans')
neji a 17 ans
dir() :
permet de revéler toute les
methodes et fonctions d’une classe
exemple :
>>> import math
>>> dir(math)
['__doc__',
'__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh',
'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor',
'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite',
'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf',
'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan',
'tanh', 'tau', 'trunc']
Les fonctions sont des blocs
d’instructions mis ensemble pour exécuter une même tache.
La déclaration d’une fonction
en python se fait à l’aide du mot clé def, et la syntaxe d’une fonction est
suivante :
def nom_de_la_fonction
( parametre1 , parametre2 , parametre3 ,parametreN ):
Bloc d' instructions
-def : c’est le mot clé permettant
de déclarer la fonction
-nom_de_la_fonction :c’est
le nom que nous voulons donner à la fonction que nous sommes en train de créer.
Ce nom ne doit contenir ni d’espace ni de caractère avec accents
-(parametre1, parametre2,
parametre3, parametreN) : ce sont les différentes variables
appartenant à notre fonction par défaut.
Elles seront toujours là lorsque nous ferons appel à la fonction
ultérieurement. Une fonction peut être créée sans paramètre. Vous pouvez tout
aussi bien remplacer tous ces paramètres par *params qui est une liste
de paramètres indéterminées.
-les : ils annonces la
fin de la déclaration de la fonction et le début du bloc d’instructions que la
fonction doit exécuter
-bloc d’instructions :
c’est l’ensemble des lignes de commandes exécuté par fonction créé.
La fonction créer est appeler
en donnant le nom de la fonction suivit d’une parenthèse contenant les
paramètres ou non de la fonction
Exemple :
Fonction sans argument :
def table_par_7 ():
nb = 7
i = 0
while i
< 10:
print (i +
1, "*", nb , "=", (i + 1) * nb)
i += 1
table_par_7 ()
1 * 7 = 7
2 * 7 = 14
3 * 7 = 21
4 * 7 = 28
5 * 7 = 35
6 * 7 = 42
7 * 7 = 49
8 * 7 = 56
9 * 7 = 63
10 * 7 = 70
Fonction avec argument
def
table (nb):
i = 0
while i
< 10:
print (i +
1, "*", nb , "=", (i + 1) * nb)
i += 1
table(nb=9)
1 * 9 = 9
2 * 9 = 18
3 * 9 = 27
4 * 9 = 36
5 * 9 = 45
6 * 9 = 54
7 * 9 = 63
8 * 9 = 72
9 * 9 = 81
10 * 9 = 90
table(14)
1 * 14 = 14
2 * 14 = 28
3 * 14 = 42
4 * 14 = 56
5 * 14 = 70
6 * 14 = 84
7 * 14 = 98
8 * 14 = 112
9 * 14 = 126
10 * 14 = 140
Ici-là, vous voyez
immédiatement l’utilité des arguments.
1.1 Le mot clé return
L'instruction return permet de renvoyer une valeur par la
fonction, pour pouvoir la récupérer ensuite et la stocker dans une variable par
exemple. Cette instruction arrête le déroulement de la fonction, le code situé
après le return ne s'exécutera pas.
Exemple :
def carre (
valeur ):
return valeur * valeur
variable = carre (5)
print(variable)
25
1.2 Les fonctions lambda
Syntaxe : lambda arg1, arg2,... : instruction de retour
Les fonctions lambda
permettent d’exécuter localement une fonction que l’on peut directement stocker
dans une variable
Exemple :
carré= lambda x : x*x
async et await sont des mots-clés utilisés dans la
programmation asynchrone, qui est un style de programmation permettant de gérer
efficacement les opérations longues sans bloquer l’exécution du programme.
Voici une explication détaillée de leur rôle et de leur utilisation.
async
Le mot-clé async est utilisé pour déclarer une
coroutine, qui est une fonction dont l’exécution peut être suspendue et
reprise. Les coroutines sont au cœur de la programmation asynchrone en Python
et sont définies avec la syntaxe async def. Voici un exemple simple :
import asyncio
async def ma_coroutine():
print('Bonjour')
await asyncio.sleep(1)
print('jean')
Dans cet exemple, ma_coroutine est une coroutine qui
affiche “Bonjour”, attend une seconde (sans bloquer d’autres opérations), puis
affiche “Jean”.
await
Le mot-clé await est utilisé pour suspendre
l’exécution d’une coroutine jusqu’à ce qu’une autre coroutine soit terminée.
Vous ne pouvez utiliser await que dans une fonction définie avec async. Lorsque
vous await une coroutine, le contrôle est rendu à la boucle d’événements, qui
peut exécuter d’autres coroutines en parallèle ou reprendre d’autres coroutines
suspendues.
Exemple d’utilisation
Voici comment vous pourriez utiliser async et await dans
un programme complet :
import asyncio
async def dire_apres(delai, quoi):
await asyncio.sleep(delai)
print(quoi)
async def main():
print('Début')
await dire_apres(1, 'Bonjour')
await dire_apres(2, 'Jean')
print('Fin')
asyncio.run(main())
Dans cet exemple, main est la coroutine principale qui
appelle deux autres coroutines dire_apres. Chaque await suspend main jusqu’à ce
que la coroutine dire après correspondante soit terminée.
Avantages de async et await
Non-blocage : Les
opérations d’entrée/sortie (I/O) ne bloquent pas l’exécution du programme.
Concurrence :
Plusieurs coroutines peuvent être exécutées en parallèle, améliorant
l’utilisation des ressources. Lisibilité : Le code asynchrone ressemble
à du code synchrone séquentiel, ce qui le rend plus facile à comprendre et à
maintenir.
Utilisation dans des projets réels
Dans des applications réelles, async et await sont
souvent utilisés pour des opérations I/O, comme les requêtes réseau, l’accès
aux bases de données, ou la lecture/écriture de fichiers. Cela permet au
programme de continuer à fonctionner pendant que ces opérations, qui peuvent
prendre du temps, sont en cours.
1.4 *args et **kwargs
En Python, *args et **kwargs sont utilisés pour passer
un nombre variable d’arguments à une fonction. Ils permettent de créer des
fonctions plus flexibles et dynamiques. Voici une explication détaillée de leur
rôle et de leur utilisation :
*args
Le terme *args est utilisé pour passer une liste
d’arguments de longueur variable à une fonction. Le préfixe * signifie
“déballer” les arguments, ce qui signifie que la fonction les recevra comme une
tuple d’arguments. Voici comment vous pouvez l’utiliser :
def ma_fonction(*args):
for arg in args:
print(arg)
ma_fonction(1, 2, 3, 4) # Affiche
1, 2, 3, 4 sur des lignes séparées
Dans cet exemple, ma_fonction peut accepter n’importe
quel nombre d’arguments positionnels, et args les contiendra tous sous forme de
tuple.
**kwargs
Le terme **kwargs est utilisé pour passer un
dictionnaire de mots-clés et de valeurs de longueur variable à une fonction. Le
préfixe ** signifie “déballer” les arguments de mots-clés, ce qui signifie que
la fonction les recevra comme un dictionnaire de mots-clés. Voici comment vous
pouvez l’utiliser :
def ma_fonction(**kwargs):
for cle, valeur in kwargs.items():
print(f"{cle}
= {valeur}")
ma_fonction(pomme='rouge', banane='jaune') # Affiche pomme = rouge, banane = jaune sur des lignes séparées
Dans cet exemple, ma_fonction peut accepter n’importe
quel nombre d’arguments de mots-clés, et kwargs contiendra tous les mots-clés
et leurs valeurs correspondantes sous forme de dictionnaire.
Utilisation combinée
*args et **kwargs peuvent être utilisés ensemble dans
les fonctions pour accepter un nombre illimité d’arguments positionnels et de
mots-clés :
def ma_fonction(*args, **kwargs):
for arg in args:
print(arg)
for cle, valeur in kwargs.items():
print(f"{cle}
= {valeur}")
ma_fonction(1, 2, pomme='rouge', banane='jaune')
Cela affichera les arguments positionnels suivis des
mots-clés et de leurs valeurs.
Quand les utiliser ?
Utilisez *args lorsque vous n’êtes pas sûr du nombre
d’arguments positionnels que votre fonction pourrait recevoir.
Utilisez **kwargs lorsque vous voulez que votre
fonction puisse gérer n’importe quel nombre d’arguments de mots-clés.
Ces deux outils sont extrêmement utiles pour créer des
interfaces de programmation flexibles et évolutives en Python. Ils sont souvent
utilisés dans la création de décorateurs, de fonctions d’ordre supérieur et de
bibliothèques qui doivent fonctionner avec un nombre inconnu d’arguments.
2. les classes
En python, la programmation
est essentiellement basée sur le concept de de class qui eux même sont des
générateurs d’objets. Les class sont des objets abstraits à partir desquelles l’on
peut créer les objets reels.
Exemple :
Considérer une class ARBRE,
c’est une class qui est caractérisé par des FEUILLES, des
BRANCHES, des RACINES, un
TRONC SEGMENTEE ou pas, des FRUITS ou pas, des FLEURS ou
pas.
Un objet issu de la class
ARBRE peut etre le BAOBA, le COYAVIER, l’AVOCATIER, le BIBINGA, le
SAPIN. Vous voyez donc que la
class ARBRE cree des objets ARBRE juste en Modifiant les
arguments de la class ARBRE
Exemple :
Considérer une Class
PERSONNAGE caractérisée par la COULEUR DE LA PEAU, la TAILLE, L’AGE, le POIDS,
le NOM et le SEXE
Un objet issu de la Class
PERSONNAGE peut-être un NOIR, de 1.8 m, 21 ans, 67 Kg, s’appelant HERMES
ROLAND, et MALE.
Un autre objet issu de la
Class PERSONNAGE peut-être un NOIR, de 1.72 m, 17 ans, 60 Kg, s’appelant
MALICKA FRANCESKA, et FEMELLE. Vous voyez donc que la class PERSONNAGE crée des
objets PERSONNAGE juste en Modifiant les arguments de la class PERSONNAGE
Il y’a plein d’autres
utilisation des classes que nous verrons dans le cours.
En python la déclaration
d’une Class se fait grâce au mot clé class.
Sa syntaxe est : class NomDeLaClasse ():
Contenue de la class
Comme vous l’aurez
certainement compris, une class possède un certain nombre de variables qui lui
sont propres. C’est à partir de ces variables que nous pouvons définir un objet
de la class différents d’un autre objet, ainsi de suite.
2.1 La méthode constructeur __init__ (self,) :
En python la définition des
variables propres à la class se font grâce à la méthode constructeur (fonction)
de la class. La méthode constructeur est une
fonction qui permet d’initialiser la class, c’est elle qui contient le code
principal que la class devra exécuter.
La méthode
constructeur est la fonction __init__ (self,) :
def __init__ (self,) :
est la méthode constructeur des class en python. C’est la commande qui permet
d’initialiser ou de lancer la class. C’est donc dans la
méthode constructeur que nous mettrons les arguments modifiables de la
class.
Exemple :
def __init__ (self,
nom, age, sexe, pays, taille, poids) :
C’est arguments peuvent donc être modifiée
lors de la création de la Class. L’on peut également donner des valeurs par
défaut à ces arguments comme dans les fonctions. En donnant une valeur par
défaut à un argument, chaque fois que la classe sera créée, cet argument aura
par défaut la valeur qui lui sera assigné si celle-ci n’est pas modifier lors
de la création.
Dans la méthode constructeur,
les arguments n’ayant pas de valeur par défaut sont toujours définis avant ceux
possédant une valeur par défaut.
Exemple :
def __init__ (self, nom, age, sexe, pays,
taille= 1.72, poids=65) :
Cependant, pour acceder aux
arguments de la méthode constructeurs dans la classe elle-même, il faut créer
des variables de la class dans laquelle nous assignerons ces arguments.
L’avantage de créer les arguments de la class est que ces arguments sont
modifiables partout dans la class par les fonctions de la classe. La définition
des arguments de la class sont :
Self.nom_de_la_variable=valuer
Le mot clé self indique que la variable
nom_de_la_variable appartient à la class. Elle est propre à la class. Ainsi, si
nous voulons que nos arguments soit des variables propre à la class, nous les
mettrons dans les variables ce class comme suit :
self.nom = nom
self.age = age
self.sexe = sexe
self.pays = pays
self.taille = taille
self.poids = poids
de meme, la creation de toute
variable appartenant à la class se fera de la meme façon.
Self.listName=["neji","naruto","itachi","sasuke","gaara"]
Self.flag=TRUE
Self.chiffre=25
2.2 Les fonctions de la class
Pour définir les différentes
opérations que notre class éxecutera, nous utiliserons des fonctions suivant
cette syntaxe
def nomDeLaFonction(self) :
bloc d’instruction
exemple :
def adresse_personnage(self) :
if self.sexe==
"male" :
print("Monsieur
{0} est un homme agé de {1} et habibant le pays\
de {2} .". format(self.nom,self.age, self.pays)
else :
print("Madame
{0} est une femme agé de {1} et habibant le pays\
de {2} .". format(self.nom,self.age, self.pays))
def
parametre_corporel(self):
if self.sexe==
"male" :
print("Monsieur
{0} a une masse de {1} Kg et une taille de {2} m.". format(self.nom,self.poids,
self.taille))
else :
print("Madame {0} a une masse de {1} Kg et une taille de {2} m.". format(self.nom,self.poids,
self.taille))
Pour appeler ces deux
fonctions, nous devons le faire dans la méthode constructeur. Ainsi, voici le
code complet de notre classe personnage
class Personnage ():
def
__init__ (self, nom, age, sexe, pays, taille= 1.72, poids=65) :
self.nom = nom
self.age = age
self.sexe = sexe
self.pays = pays
self.taille = taille
self.poids = poids
print("cette
class cree un personnage ")
self.adresse_personnage()
self.parametre_corporel()
def adresse_personnage(self):
if self.sexe== "male" :
print("Monsieur {0} est un
homme agé de {1} et habibant le pays\
de {2} .". format(self.nom,self.age,
self.pays))
else :
print("Madame {0} est une
femme agé de {1} et habibant le pays\
de {2} .".
format(self.nom,self.age, self.pays))
def parametre_corporel(self):
if self.sexe== "male" :
print("Monsieur {0} a une masse de {1} Kg
et une taille de {2} m.". format(self.nom,self.poids, self.taille))
else :
print("Madame {0} a une masse
de {1} Kg et une taille de {2} m.". format(self.nom,self.poids, self.taille))
Pour faire appel à notre
class, nous pouvons procéder des deux façons suivante :
·
simplement appelé une class
personnage
Personnage(nom="HERMES romuald",age=21,sexe="male",
pays="cameroun", taille=1.8, poids=60)
·
mettre la classe personnage
dans une variable qui nous permettra de la modifié exterieurement
personne1=Personnage(nom="HERMES,romuald",age=21,sexe="male",pays="cameroun",
taille=1.8,poids=60)
personne2=
Personnage(nom="MALICKA Franceska",age=17, sexe="femelle",
pays="cameroun", taille=1.72, poids=65)
personne3=
Personnage(nom="NEJI
HYUGA",age=17,sexe="male", pays="konoha", taille=1.75,
poids=65)
Pour modifier les parametres
de l’objet pesonne1, on procède comme suit :
nom_de_l_objet.variable_a_modifier=valeur
Pour appeler une fonction
spécifique de l’objet, l’on procède comme suit :
nom_de_l_objet.fonction()
Exemple :
personne1=Personnage(nom="HERMESromuald",age=21,sexe="male",pays="cameroun",
taille=1.8,poids=60)
personne1.nom="HERMES Deneb"
personne1.adresse_personnage()
personne2= Personnage(nom="MALICKA
Franceska", age=17, sexe="femelle", pays="cameroun",
taille=1.72,poids=65)
personne2.pays="Gilgamesh"
personne2.adresse_personnage()
2.3. l’héritage des classes
Considérer notre class
personnage, à partir d’elles, nous pouvons définir une autre class nommé
qualite_des_personnage qui elle renverrait en plus des paramètres de la classe
personnage, leurs comportement et leurs métiers.
Pour l’heritage la syntaxe est la
suivante :
Class nouvelle_class
(class_parente) :
Bloc d’instruction
Dans ce cas notre nouvelle
classe qualite_des_personnage aura toute le propriètés des deux classes
Exemple :
class qualiteDesPersonnage(Personnage):
def
__init__(self,metier,nom, age, sexe, pays, taille, poids):
Personnage.__init__(self,nom,
age, sexe, pays, taille= 1.72, poids=65)
self.comportement=input("entrer
les comportement de la personne séparé par une virgule : ")
self.metier=metier
self.affiche_comportement()
def affiche_comportement(self):
self.tableComportement=self.comportement.split(",")
self.phrase_affiche=""
self.suite=""
if self.sexe=="male":
self.phrase_affiche="Monsieur
"+self.nom+" "
self.suite="Cependant il
exerce le metier : "
else:
self.phrase_affiche="Madame
"+self.nom+" "
self.suite="Cependant elle
exerce le metier : "
for i in
range(len(self.tableComportement)):
if i==0:
self.phrase_affiche=self.phrase_affiche+" est "+self.tableComportement[i]
elif i!=(len(self.tableComportement)-1)
and i!=0:
self.phrase_affiche=self.phrase_affiche+",
"+self.tableComportement[i]
else:
self.phrase_affiche=self.phrase_affiche+" et "+self.tableComportement[i]+"
."
print(self.phrase_affiche, self.suite,
self.metier)
personne3=qualiteDesPersonnage(metier="pilote
de chasse",nom="HERMES
romuald",age=21,sexe="male",pays="cameroun",
taille=1.8,poids=60)
personne2=
qualiteDesPersonnage(metier="conseillère du roi",nom="MALICKA
Franceska",age=17,sexe="femelle",pays="cameroun",
taille=1.72,poids=65)
.png)
Commentaires
Enregistrer un commentaire