Si vous débutez avec Python, vous n'êtes peut-être pas encore au courant de la meilleure pratique de définition des fonctions. Dans ce guide, je vais vous expliquer comment inclure un La fonction main(), bien que non requise en Python, peut structurer vos programmes de manière logique et garantir que vos fonctions ne sont exécutées que lorsque cela est prévu.
L'écosystème Python est très riche en modules, packages, bibliothèques et frameworks. Il est parfois difficile pour les débutants de comprendre la différence entre ces concepts, mais fondamentalement, ce sont toutes des formes d'organisation du code Python.
Par exemple, un module est un ensemble de code associé enregistré dans un fichier avec l'extension .py. Avec un module personnalisé en Python, vous pouvez définir des variables, des fonctions ou même créer vos propres classes. Vous pouvez inclure du code exécutable dans les modules. Cependant, si un module avec du code exécutable est importé d'un autre module, ce code s'exécutera de lui-même lorsqu'il sera importé.
Dans cet article, je vais expliquer comment éviter cette situation en adhérant à la meilleure pratique de Python consistant à séparer le code qui doit être exécuté uniquement lorsqu'il est exécuté en tant que script (mais pas lorsqu'il est importé).
Après avoir lu ce guide, je vous encourage à commencer à vous entraîner immédiatement avec la piste d'apprentissage interactive Learn Programming with Python. Il comprend des centaines de défis de codage couvrant les bases de ce langage ainsi que des concepts plus avancés pour l'écriture d'applications Python optimisées.
Environnement de code de niveau supérieur Python
Les objets de module en Python sont caractérisés par divers attributs qui sont préfixés et postfixés par un double trait de soulignement ('__'). L'attribut clé de chaque module est son nom - ou plus précisément, __name__ .
Dans tout module que vous importez, son nom sera défini sur le nom du fichier. Par exemple, si vous importez le NumPy module, vous verrez que son attribut __name__ sera égal à numpy :
>>> import numpy >>> print(numpy.__name__)
Sortie :
numpy
La chose importante à retenir est que lorsque Python s'exécute en tant que code exécutable de niveau supérieur (c'est-à-dire lorsqu'il est lu à partir d'une entrée standard, d'un script ou d'une invite interactive), le __name__ l'attribut est défini sur '__main__ '. Ainsi, nous pouvons littéralement dire que, dans l'environnement de script de niveau supérieur, __name__ = '__main__' .
Pourquoi ne pas utiliser ces connaissances pour séparer le code de votre module destiné à être utilisé uniquement par des scripts ? Les bonnes pratiques de codage suggèrent d'utiliser le if suivant bloc de code …
if __name__ == '__main__'
.. et y inclure le code que nous ne voulons exécuter que lorsque le module est exécuté dans l'environnement de niveau supérieur.
Voyons comment cela fonctionne avec quelques exemples.
Bonnes pratiques d'organisation du code lors de la définition d'une fonction
Nous allons commencer par un exemple de base pour montrer comment vous pouvez séparer le code exécutable dans votre module. Ensuite, nous passerons à un exemple plus complexe, où nous définirons un main() fonction.
Exemple 1. Séparation du code exécutable
Disons que nous développons un jeu auquel seules les personnes âgées de 18 ans et plus sont autorisées à jouer. La variable d'âge est déclarée dans l'environnement de niveau supérieur en obtenant l'entrée de l'utilisateur :
# Declare global variable age
age = int(input('Please enter your age in years: '))
Ensuite, nous avons un module appelé age_check.py qui a le code suivant :
# Define a function to check that age is 18+
def age_check(age):
if age >= 18:
print('You are allowed to enter the game.')
else:
print('You are not allowed to enter the game.')
# Execute age_check() function
age_check(age)
Comme vous le voyez, ce module a un morceau de code exécutable après le age_check() fonction est définie. Donc si nous importons age_check.py , son code sera exécuté automatiquement. Pour éviter cela, vous pouvez mettre le code exécutable séparément dans le if __name__ == '__main__' bloc de code :
# Define a function to check that age is 18+
def age_check(age):
if age >= 18:
print('You are allowed to enter the game.')
else:
print('Unfortunately, you are not allowed to enter the game because of the age restriction.')
#Execute age_check() function
if __name__ == '__main__':
age_check(age)
Dans ce cas, vous pouvez importer le age_check() module sans que le code exécutable ne soit exécuté. Tout dans le if __name__ == '__main__' le bloc ne s'exécutera que si le module est exécuté dans l'environnement de niveau supérieur.
Exemple 2. Définition de la fonction principale en Python
Dans notre premier exemple, j'ai démontré le principe clé de la façon dont nous pouvons séparer le code exécutable afin qu'il ne s'exécute que lorsqu'il est exécuté dans l'environnement de niveau supérieur. Cependant, dans la pratique, les modules définissent souvent de nombreuses variables, fonctions et classes différentes. Vous pouvez également avoir plusieurs morceaux de code exécutable sans rapport dans un module. Ainsi, pour améliorer la clarté et l'exactitude du code, il est recommandé de mettre le moins d'instructions possible dans le bloc sous if __name___ == '__main__' . Le plus souvent, une fonction nommée main() encapsule le comportement principal du programme.
Par exemple, disons que nous voulons écrire un module Python qui accueille les nouveaux membres et vérifie leur âge. Tout d'abord, nous avons les variables name et age déclarées dans l'environnement de code de niveau supérieur :
name = str(input('Please enter your name: '))
age = int(input('Please enter your age in years: '))
Alors, on peut avoir le welcome.py suivant module importé :
# Define a function to greet new players
def greeting(name):
print ("Hi {}. Glad to see you here.".format(name))
# Define a function to check that age is 18+
def age_check(age):
if age >= 18:
print('You are allowed to enter the game.')
else:
print('Unfortunately, you are not allowed to enter the game because of the age restrictions.')
# Define main function
def main():
greeting(name)
age_check(age)
# Execute main() function
if __name__ == '__main__':
main()
Comme vous le voyez, nous définissons d'abord deux fonctions distinctes pour accueillir les nouveaux joueurs et vérifier leur âge. Ensuite, nous définissons le main() fonction, qui contient un appel au greeting() et age_check() les fonctions. Enfin, nous ajoutons le if __name__ == '__main__' :bloc de code en fin de fichier.
Puisque nous avons toutes les fonctions que nous aimerions exécuter dans le main() fonction, nous appelons uniquement le main() fonction suivant ce if déclaration. Puisque tout le code exécutable est placé sous le if instruction, elle ne sera pas exécutée lors de l'import du module.
Bien sûr, vous pouvez toujours choisir de NE PAS déclarer un main() fonction et avoir le bloc de code suivant à la place :
if __name__ == '__main__':
greeting(name)
age_check(age)
Cependant, les meilleures pratiques suggèrent d'utiliser le main() fonction. Définir la fonction principale en Python puis l'utiliser dans le if __name__ == '__main__' :vous permet d'organiser votre code logiquement et de le rendre plus lisible et plus facile à suivre. Cela serait particulièrement évident avec des modules complexes qui définissent plusieurs fonctions et/ou classes.
Vous pourriez également être intéressé à rendre votre code plus professionnel et plus propre avec notre guide de l'argparse module.
Il est temps de pratiquer les fonctions principales en Python !
Pour maîtriser toute nouvelle compétence, vous avez besoin de beaucoup de pratique. En ce qui concerne la pratique de Python, je pense que les cours en ligne interactifs sont la meilleure option pour les débutants. Avec un bon cours, vous avez tous les exemples de codage préparés pour vous. Ainsi, vous pouvez vous concentrer sur les nouveaux concepts que vous apprenez, sans avoir besoin de configurer un environnement de codage Python et de rechercher des projets à pratiquer.
Pour les programmeurs Python en herbe, je recommande notre piste d'apprentissage interactive Learn Programming with Python. Il comprend cinq cours couvrant les bases (définir des variables, écrire des instructions et des boucles conditionnelles, etc.), des concepts plus avancés et des conseils sur les meilleures pratiques de codage.
Merci d'avoir lu et bon apprentissage !
Bonus. Voici la liste des packages Python les plus populaires.
