Les développeurs rencontrent souvent des difficultés à structurer efficacement leur code en python, ce qui peut conduire à des erreurs et à une maintenance complexe.
Sans une bonne organisation, le code devient rapidement illisible et difficile à déboguer, augmentant le risque de bugs coûteux et de retards dans les projets.
Découvrez comment utiliser les procédures et fonctions en Python pour structurer votre code de manière claire et efficace, facilitant ainsi la maintenance et réduisant les erreurs. Cet article vous guide à travers les meilleures pratiques.
Utiliser les Procédures en Python
En Python, une procédure regroupe un ensemble d’instructions sans retourner de valeur. C’est vraiment pratique pour éviter de répéter le même code plusieurs fois et pour rendre votre programme plus clair et plus efficace. Voyons ensemble comment créer une procédure :
Définition des Procédures Python
Afin de définir une procédure en doit utilisez le mot-clé def suivi du nom de la procédure et de parenthèses pour les paramètres d’entrée.
def ma_procedure( ):
# Instructions de la procédure
print("Bonjour j’espère que vous allez bien ")
Utilisation Pratique des Procédures en Python
Pour appeler une procédure en Python, les administrateurs doivent simplement écrire son nom avec les paramètres d’entrée.
# Appel de la procédure
ma_procedure( )
En intégrant des procédures dans votre code, vous simplifiez sa structure, le rendant plus lisible et plus facile à maintenir.
Exploiter les Paramètres de Procédures Python
Paramètres d’Entrée des Procédures en Python
Lorsque vous utilisez des procédures, les arguments, également appeler paramètres d’entrer, sont des données qui vont être manipulées à l’intérieur de la procédure.
def presentation (nom,age):
# Instructions de la procédure
print(f"Bonjour {nom} , Vous avez {age} ")
Noter bien que si vous ne passer pas les paramètres lors de l’appel de la procédure qui nécessite ces derniers, une erreur se produira, comme illustré ci-dessous :
presentation()
Cell In[2], line 5
1 def presentation (nom,age):
2 # Instructions de la procédure
3 print(f"Bonjour {nom} , Vous avez {age} ")
----> 5 presentation()
TypeError: presentation() missing 2 required positional arguments: 'nom' and 'age'
Pour éviter ce problème, vous devez passer toujours les arguments nécessaire au fonctionnement de votre procédure sinon vous pouvez définir des valeurs par défaut pour les arguments. Ces valeurs seront utilisées si aucun argument correspondant n’est passé lors de l’appel, comme il est montré dans l’exemple suivant :
def presentation (nom="Anonyme", age=0):
# Instructions de la procédure
print(f"Bonjour {nom} , Vous avez {age} ")
Maintenant, même si vous appelez la procédure sans spécifier d’arguments, aucun erreur ne sera lever :
presentation ()
# appel sans paramètres d’entrer
Bonjour Anonyme , Vous avez 0
Ordre des Paramètres de Procédures en Python
Il est primordial de respecter l’ordre des paramètres lors de l’appel d’une procédure pour obtenir les résultats souhaités, comme illustré l’exemple suivant :
def presentation (nom,age):
print(f"Bonjour {nom} , Vous avez {age} ")
# output attendue : Bonjour Emilie, Vous avez 30 ans
presentation ("Emilie", 30)
Bonjour Emilie , Vous avez 30
def presentation (nom,age):
print(f"Bonjour {nom} , Vous avez {age} ")
# output attendue : Bonjour 30, Vous avez Emilie ans
presentation (30, ("Emilie"))
Bonjour 30 , Vous avez Emilie
Utiliser les Arguments Arbitraires (*args) en Python
Les *args sont des paramètres spéciaux en python qui permettent à une fonction de recevoir un nombre infini de paramètres. ces derniers seront rassemblés dans un tuple qui va être manipulé ensuite à l’intérieur de la fonction comme une structure de données .
def ma_fonction (*args):
for arg in args:
print(f"Element : {arg} ")
# Exemples d'utilisation avec différent type et taille
ma_fonction (1,2,3,4,5,6,9,8) # Appel avec des nombres
ma_fonction ('a','c','s','v','r') # Appel avec des caractères
ma_fonction () # Appel sans paramètres
Dans l’exemple ci dessous, la fonction ma_fonction utilise *args pour recevoir et afficher tous les paramètres passés, qu’ils soient nombreux ou aucun. Cela démontre comment les arguments arbitraires peuvent simplifier le traitement de données variées au sein d’une même procédure, ce qui facilite l’adaptation et la réutilisation du code dans des contextes différentes.
Manipulation des *args dans les Procédures en Python
L’exemple suivant montre comment manipuler les paramètres de type *args passés en argument à l’intérieur d’une procédure :
def somme(*nbr):
total=0
for n in nbr:
total+=n
return total
Dans cet exemple, *nbr permet à la procédure somme de recevoir n’importe quel nombre de paramètres. Vous pouvez appeler cette procédure avec deux nombres, trois nombres, ou plus, comme illustré ci-dessous :
res=somme (1,2)
print(res) # output : 3
res=somme (1,2,3,4)
print(res) # output : 10
print(somme (1,2,3,4,5)) # output : 15
L’utilisation d’arguments arbitraires rend votre code plus flexible et évite la nécessité de définir une longue liste de paramètres individuellement. En intégrant cette fonctionnalité dans vos procédures, vous pouvez traiter efficacement un nombre variable d’entrées sans sacrifier la lisibilité ni la simplicité de votre code Python.
Formation Python : Les fonctions, la modularité et les environnements virtuels
Maîtrisez la programmation de fonction et de procédure ainsi que la modularité sous Python
Utiliser les Fonctions Python
Définition des Fonctions Python
En Python, une fonction est une procédure qui exécute un ensemble d’instructions et peut renvoyer une valeur à la fin de son exécution. Elle est définie par le mot-clé def suivi du nom de la fonction et de parenthèses contenant éventuellement des paramètres. Une fois définie, la fonction peut être réutilisée simplement en appelant son nom, comme illustré dans la figure ci-dessous :
Affichage des Résultats des Fonctions de Python
Pour afficher la valeur retournée, on peut utiliser la fonction print() ou bien affecter le retour de la fonction à une variable et l’afficher par la suite avec la fonction print(), comme illustré ci-dessous :
def somme(a,b):
total=a+b
return total
res=somme (1,2)
print(res) #Affectation du résultat puis l’appel ; output : 3
print(somme (1,2)) # Appel direct de la fonction; output : 3
Dans cet exemple on a la fonction addition qui prend deux paramètres a et b, calcule leur somme à l’aide de l’opérateur +, puis retourne le résultat avec return. L’utilisation de print() permet d’afficher directement la valeur retournée ou de l’affecter à la variable res puis l’afficher en utilisant la même fonction print( ).
Fonctions à Retours Multiples en Python
Une fonction peut retourner plusieurs valeurs qui seront regroupées dans un tuple. Cela permet de les capturer et de les utiliser séparément, Voici un exemple :
def operations(a,b):
somme =a+b
soustraction=a-b
produit =a*b
division=a/b
return somme ,soustraction, produit ,division
res=operations(4,2)
print(res) # output : (6,2,8,2)
somme ,soustraction, produit ,division=operations(4,2)
print(somme) # output : 6
print (soustraction) # output : 2
print(produit) # output : 8
print(division) # output : 2
Dans cet exemple, la fonction opérations prend deux paramètres a et b, effectue les quatre opérations mathématiques à savoir :l’addition ,la soustraction, le produit et la division, les valeurs retournées sont capturées dans un tuple, ce qui permet d’écrire des fonctions plus expressives et flexibles. Ou bien ils peuvent être attribuées individuellement à des variables pour un traitement ultérieur.
Comportement par Défaut de return dans les Fonctions Python
Si une fonction utilise return sans spécifier explicitement une valeur à retourner, elle retournera automatiquement None, Voici un exemple :
def rien( ):
#Fonction qui ne retourne rien
return
res=rien ( )
print(res)# Output : None
None
Dans cet exemple, la fonction rien utilise return sans suivre avec une valeur. Lorsque cette fonction est appelée, elle retourne implicitement None, qui indique l’absence de valeur de retour explicite.
Utilisation des **kwargs en Python
**kwargs permet de transformer un ensemble d’arguments nommés passés à une fonction en un dictionnaire à l’intérieur de cette fonction. Cela offre une manière pratique de gérer un nombre variable et diversifié d’arguments nommés sans avoir à les spécifier individuellement dans la signature de la fonction.
- Définition de la fonction avec **kwargs :
Lorsque vous utilisez **kwargs dans une définition de fonction, Python rassemble tous les arguments nommés supplémentaires dans un dictionnaire. La syntaxe pour définir une telle fonction est la suivante :
def fct_kwargs(**kwargs):
for k in kwargs:
print(f" {k} : {kwargs[k]} ")
fct_kwargs(n1=1,n2=2,n3=3)
n1 : 1
n2 : 2
n3 : 3
A l’interieur de la fonction ,kwargs est un dictionnaire qui contient des paires clé-valeur, où chaque clé est le nom de l’argument nommé et chaque valeur est la valeur associée à cet argument. A fin de manipuler les paires clé-valeur du dictionnaire sous forme de tuples (clé, valeur) en fait recourt a la méthode .items() qui va vous permet d’itérer de manière efficace sur toutes les paires clé-valeur de kwargs
def personne(nom, age, **kwargs):
description = f"Nom: {nom}, Age: {age}"
for key, value in kwargs.items():
description += f", {key.capitalize()}: {value}"
return description
print(personne("Jean", 30, profession="Ingénieur", ville="Paris"))
print(personne("Emilie", 25, hobby="Lecture", sport="tenis"))
Note : Dans la définition de la fonction, on utilise *args et **kwargs pour indiquer que la fonction peut recevoir un nombre variable d’arguments positionnels et d’arguments nommés, respectivement. Cependant, à l’intérieur de la fonction, on manipule simplement args et kwargs.
Manipuler le Retour d'une Fonction dans une Autre
On a toujours le droit d’appeler ou de manipuler le retour d’une fonction à l’intérieur d’une autre fonction. Voici un exemple pertinent qui illustre cela :
def addition(a, b):
return a + b
def multiplication(a, b):
return a * b
def soustraction(a, b):
return a - b
def division(a, b):
return a / b
return resultat
def calcul(x, y):
menu="1.Addition\n2.Soustration\n3.Multiplication\n4.Division"
print(menu)
choix=int(input("\nVeuillez taper votre choix: "))
if choix==1:
resultat=addition(x,y)
elif choix==2:
resultat=soustraction(x,y)
elif choix==3:
resultat=multiplication(x,y)
elif choix==4:
resultat=division(x,y)
else :
resultat="none"
x=int(input("Entrer le premier nombre: "))
y=int(input("Entrer le deuxieme nombre: "))
resultat = calcul(x, y)
print(f"Le resultat obtenue est :{resultat}")
Fonctions Lambda en Python
Définition des Fonctions Lambda
Lambda est une fonction anonyme qui peut contenir une seule expression. Elle est définie à l’aide du mot clé lambda et elle est particulièrement utile lorsque vous souhaitez effectuer une tâche simple tout en économisant des lignes de code.
Une caractéristique importante des fonctions lambda est qu’elles doivent être affectées directement à une variable, car elles sont anonymes et ne sont pas définies avec le mot clé def. De plus, elles sont conçues pour être des fonctions d’une seule ligne, ce qui les rend idéales pour des opérations simples et rapides.
Paramètres par Défaut des Lambda en Python
Après savoir la définition de la fonction lambda et ça syntaxe de d’utilisation, On va passer maintenant pour vous montrer la possibilité de définir des valeurs par défaut pour les paramètres passés à une fonction lambda. Par exemple, une fonction lambda qui calcule la somme de deux nombres avec un paramètre par défaut pourrait être définie comme ceci
lambda arguments : expression
somme = lambda x, y=0 : x + y
print(somme(5, 3)) # Output : 8
print(somme(5)) # Output : 5 (car il a pris la valeur par défaut de y)
Les fonctions lambda avec des paramètres par défaut offrent une flexibilité supplémentaire pour gérer différents scénarios sans sacrifier la concision et la lisibilité du code.
Utiliser l’Aide dans le Terminal Python
Lors de l’écriture de code Python, il est souvent essentiel de consulter la documentation ou d’obtenir des informations sur une fonction ou un module particulier. Pas de panique, Python propose une fonctionnalité très pratique que vous pouvez utiliser directement depuis le terminal. C’est super simple ! Voici les étapes à suivre pour tirer le meilleur parti de cette fonctionnalité :
- Démarrer l’Interpréteur Python :
Dans le terminal intégré de VS Code(éditeur utiliser), tapez la commande pour démarrer l’interpréteur Python. Selon votre installation, cela pourrait être python, python3, ou py.
- Utiliser la Fonction d’Aide :
Une fois dans l’interpréteur Python, vous pouvez utiliser la fonction help() pour obtenir des informations sur les fonctions, modules, etc.
- Rechercher une Fonction ou un Module :
Pour obtenir de l’aide sur une fonction ou un module spécifique, tapez help('nom_de_la_fonction_ou_du_module') et appuyez sur Entrée. Par exemple, pour obtenir de l’aide sur la fonction print, vous pouvez taper :
- Quitter le Système d’Aide :
Pour quitter le système d’aide interactif, tapez simplement quit() ou exit() et appuyez sur Entrée.
Utilisation de la Fonction map() en Python
La fonction map est vraiment pratique ! Elle vous permet d’appliquer une fonction à chaque élément d’un ou plusieurs itérables, comme des listes ou des tuples, et de renvoyer un objet itérable avec les résultats. C’est une manière simple et efficace de transformer des données. Pour mieux comprendre le principe de la fonction map(), voici le tableau suivant qui le schématise clairement :
Fonction | Description | Exemple |
|---|---|---|
map(function, iterable) | Simple Applique une fonction donnée à chaque élément d’un itérable (comme une liste, un tuple, etc.) et retourne un itérable map object (qui peut être converti en liste, tuple, etc.). | def carré(x):return x * x
nums = [1, 2, 3, 4]
resultat = map(carré, nums)
print(list(resultat))
# Sortie: [1, 4, 9, 16] |
Fonctionnement | La fonction map() prend en entrée une fonction et un ou plusieurs itérables. Elle applique la fonction à chaque élément de l’itérable, renvoyant un objet map contenant les résultats. | |
Utilisation avec lambda | On peut utiliser lambda pour définir des fonctions anonymes à appliquer via map() sans avoir besoin de définir une fonction séparément | nums = [1, 2, 3, 4]resultat = map(lambda x: x * 2, nums)
print(list(resultat))
# Sortie: [2, 4, 6, 8] |
def carre(x):
return x ** 2
# Utiliser map pour appliquer la fonction carre à une liste donner
liste = [1, 2, 3, 4, 5]
resultats = map(carre, liste)
#A fin d'afficher le resultat on va le convertir en liste
resultats= list(resultats)
print(resultats) # Output : [1, 4, 9, 16, 25]
Dans cet exemple :
- Nous définissons une fonction carre qui calcule le carré d’un nombre.
- Nous utilisons map pour appliquer cette fonction à chaque élément de la liste
liste. - Le résultat est un objet map, que nous convertissons en liste
resultatspour l’afficher par la suite.
La fonction map est souvent utilisée avec des fonctions lambda pour des opérations simples et rapides.
La Portée Locale et Globale en Python
Comprendre les Variables Locales en Python
Les variables locales en Python sont définies à l’intérieur d’une fonction et ne sont accessibles que depuis cette fonction. En d’autres termes, elles sont créées quand la fonction est appelée et disparaissent dès que la fonction se termine. Cela permet de garder les données et les opérations liées à cette fonction bien organisées et séparées du reste du programme.
def exemple_fonction():
variable_locale = "local"
print(variable_locale)
exemple_fonction()
print(variable_locale) # Cette ligne provoquerait une erreur car variable_locale Les variables définies à l'intérieur d'une fonction sont considérées comme des variables n'est pas accessible en dehors de la fonction
Local
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In[6], line 6
3 print(variable_locale)
5 exemple_fonction()
----> 6 print(variable_locale) # Cette ligne provoquerait une erreur car variable_locale n'est pas accessible en dehors de la fonction
NameError: name 'variable_locale' is not defined
Comprendre les Variables Globales en Python
Les variables globales sont des variables définies en dehors de toute fonction et peuvent être utilisées à l’intérieur des fonctions grâce au mot clé global. Voici comment vous pouvez manipuler une variable globale à l’intérieur d’une fonction :
variable_globale = "Je suis globale"
def exemple_fonction():
global variable_globale
variable_globale += " et j'ai été modifiée à l'intérieur de la fonction"
print(variable_globale)
exemple_fonction()
print(variable_globale) # Output : "Je suis globale et j'ai été modifiée à l'intérieur de la fonction"
Dans cet exemple, en utilisant global variable_globale à l’intérieur de la fonction, nous indiquons à Python que nous voulons accéder et modifier la variable globale variable_globale. Cela permet une interaction entre les fonctions et les variables globales tout en respectant les principes de portée et de sécurité des données.
Les Fonctions locals() et globals() en Python
locals() et globals() sont des fonctions intégrées qui permettent d’accéder respectivement aux variables locales et globales disponibles dans un contexte donné. Voici ce que chacune de ces fonctions permet de faire :
Utilisation de locals() en Python
La fonction locals() retourne un dictionnaire contenant les variables locales disponibles dans la portée actuelle. Cela inclut toutes les variables définies à l’intérieur de la fonction ou de la méthode où locals() est appelé.
Elle est souvent utilisée pour inspecter les variables locales à des fins de débogage ou de compréhension du contexte d’exécution d’une fonction.
def exemple_fonction():
var_locale = "Je suis locale"
print(locals())
exemple_fonction()
Dans cet exemple, locals() nous a retourner {'var_locale': 'Je suis locale'} pour montrer la variable locale définie dans exemple_fonction.
Utilisation de globals() en Python
La fonction globals() retourne un dictionnaire contenant toutes les variables globales disponibles dans le contexte d’exécution actuel du programme Python. Cela inclut toutes les variables définies au niveau du module ou du script.
Elle est utile pour accéder et modifier des variables globales à partir de fonctions ou de méthodes, bien que cela ne soit généralement pas recommandé en raison des bonnes pratiques de gestion des variables globales.
def exemple_fonction():
print(globals()['variable_globale'])
exemple_fonction()
Dans cet exemple, globals()['variable_globale'] nous retourne « Je suis globale », démontrant l’accès à la variable globale depuis l’intérieur de la fonction.
En résumé, locals() et globals() offrent des mécanismes pour inspecter et accéder aux variables locales et globales respectivement dans Python. Ils sont souvent utilisés dans des contextes de débogage ou lorsqu’il est nécessaire d’interagir avec les variables définies dans différents scopes. Toutefois, il est recommandé de manipuler les variables globales avec prudence pour éviter les effets secondaires indésirables dans le code.
Exercice Pratique : Compter les Voyelles en Python
Après avoir exploré les procédures, les fonctions en Python, ainsi que la manipulation des arguments et la portée locale et globale avec les fonctions local() et global(), nous allons maintenant mettre en pratique ces concepts avec l’exercice suivant :
Énoncé de l’Exercice
Ecrire une fonction pour compter les voyelles dans une chaîne de caractères, en tenant compte ou non de la casse.
Solution de l’Exercice
def nb_voyelles(chaine, sens_casse = True):
voyelles = "aeiouy"
nb = 0
for lettre in chaine:
if sens_casse:
if lettre in voyelles:
nb +=1
else:
if lettre.upper() in voyelles.upper():
nb +=1
return nb
result = nb_voyelles("Le python c'est SUPER.", False)
print(result) #output:6 puisqu'on a 6 voyelle dans la chaine passer en argument
Explication de la Solution
Paramètres d’entrer de la fonction nb_voyelles :
- chaine : La chaîne de caractères à traiter.
- sens_casse : Un booléen pour spécifier si la fonction doit ignorer la casse des caractères (par défaut True).
Logique de la fonction nb_voyelles :
- Initialise voyelles avec les voyelles à rechercher.
nbc’est un compteur initialisé à 0 pour compter les voyelles.- Utilise une boucle pour parcourir chaque caractère de chaine et vérifie si chaque caractère est une voyelle pour incrémenter le compteur nb en fonction de sens_casse.
Retour :
- Retourne le nombre total de voyelles trouvées dans la chaîne.
Exemple d’utilisation :
Pour utiliser la fonction créée, nous allons l’appeler en lui passant comme paramètre d’entrée la phrase « Le python c’est SUPER. » en spécifiant que la casse ne doit pas être prise en charge (sens_casse = False). Ensuite, nous afficherons le résultat avec print, ce qui nous donne 6, représentant le nombre de voyelles présentes dans la phrase.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui. Découvrez des cours variés pour tous les niveaux !
Conclusion
Les fonctions Python, des classiques aux lambdas, offrent une flexibilité pour optimiser et structurer le code. Maîtriser leur utilisation, y compris *args et **kwargs, permet de créer des scripts efficaces et adaptables.
