Définition des fonctions principales en Python – Real Python

De nombreux langages de programmation ont une fonction spéciale qui s'exécute automatiquement lorsqu'un système d'exploitation commence à exécuter un programme. Cette fonction est généralement appelée principale() et doit avoir un type de retour spécifique et des arguments conformes à la norme de langue. D'autre part, l'interpréteur Python exécute les scripts en commençant par le haut du fichier et aucune fonction spécifique n'est automatiquement exécutée par Python.

Néanmoins, avoir un point de départ défini pour l'exécution d'un programme est utile pour comprendre le fonctionnement d'un programme. Les programmeurs Python ont mis au point plusieurs conventions pour définir ce point de départ.

À la fin de cet article, vous comprendrez:

• Quelle est la spéciale __prénom__ variable est et comment le définit Python
• Pourquoi voudriez-vous utiliser un principale() en python
• Quelles sont les conventions pour définir principale() en python
• Quelles sont les meilleures pratiques pour quel code mettre dans votre principale()

Une base Python principale ()

Dans certains scripts Python, vous pouvez voir une définition de fonction et une instruction conditionnelle qui ressemble à l'exemple ci-dessous:

def principale():
    impression("Bonjour le monde!")

si __prénom__ == "__principale__":
    principale()

Dans ce code, il existe une fonction appelée principale() qui imprime la phrase Bonjour le monde! lorsque l'interpréteur Python l'exécute. Il existe également un conditionnel (ou si) déclaration qui vérifie la valeur de __prénom__ et le compare à la chaîne "__principale__". Quand le si déclaration évalue à Vrai, l'interpréteur Python s'exécute principale(). Vous pouvez en savoir plus sur les instructions conditionnelles dans les instructions conditionnelles en Python.

Ce modèle de code est assez courant dans les fichiers Python que vous souhaitez utiliser. exécuté comme un script et importé dans un autre module. Pour aider à comprendre comment ce code s’exécutera, vous devez d’abord comprendre comment l’interpréteur Python définit __prénom__ en fonction de la manière dont le code est exécuté.

Modes d'exécution en Python

Vous pouvez demander à l'interpréteur Python d'exécuter ou d'utiliser du code de deux manières principales:

1. Vous pouvez exécuter le fichier Python en tant que scénario en utilisant la ligne de commande.
2. Vous pouvez importation le code d'un fichier Python dans un autre fichier ou dans l'interpréteur interactif.

Vous pouvez en savoir plus sur ces approches dans Comment exécuter vos scripts Python. Quelle que soit la manière dont vous utilisez votre code, Python définit une variable spéciale appelée __prénom__ qui contient une chaîne dont la valeur dépend de la façon dont le code est utilisé.

Nous allons utiliser cet exemple de fichier, enregistré sous execution_methods.py, pour explorer comment le comportement du code change en fonction du contexte:

impression("Ceci est mon fichier pour tester les méthodes d'exécution de Python.")
impression("La variable __name__ m'indique le contexte dans lequel ce fichier est exécuté.")
impression("La valeur de __name__ est:", repr(__prénom__))

Dans ce fichier, il y a trois appels à impression() défini. Les deux premiers contiennent des phrases d’introduction. Le troisième impression() va d'abord imprimer la phrase La valeur de __name__ est, puis il imprimera la représentation du __prénom__ variable en utilisant Python intégré repr ().

En python, repr () affiche la représentation imprimable d'un objet. Cet exemple utilise repr () souligner que la valeur de __prénom__ est une chaîne. Vous pouvez en savoir plus sur repr () dans la documentation Python.

Vous verrez les mots fichier, module, et scénario utilisé tout au long de cet article. En pratique, il n’ya pas beaucoup de différence entre eux. Cependant, il existe de légères différences de sens qui soulignent le but d'un morceau de code:

1. Fichier: En règle générale, un fichier Python est un fichier contenant du code. La plupart des fichiers Python ont l'extension .py.

2. Scénario: Un script Python est un fichier que vous avez l'intention d'exécuter à partir de la ligne de commande pour accomplir une tâche.

3. Module: Un module Python est un fichier que vous souhaitez importer depuis un autre module ou un script, ou depuis l'interpréteur interactif. Vous pouvez en savoir plus sur les modules dans la documentation Python.

Cette distinction est également abordée dans Comment exécuter vos scripts Python.

Exécuter à partir de la ligne de commande

Dans cette approche, vous souhaitez exécuter votre script Python à partir de la ligne de commande.

Lorsque vous exécutez un script, vous ne pourrez pas définir de manière interactive le code que l'interpréteur Python est en train d'exécuter. Les détails de la façon dont vous pouvez exécuter Python à partir de votre ligne de commande ne sont pas très importants pour cet article, mais vous pouvez développer la zone ci-dessous pour en savoir plus sur les différences entre la ligne de commande sous Windows, Linux et macOS.

eleanor @ realpython: ~ / Documents $

C:  Utilisateurs  Eleanor  Documents>

Maintenant, vous devriez exécuter le execution_methods.py script en ligne de commande, comme indiqué ci-dessous:

$ python3 execution_methods.py
Ceci est mon fichier pour tester les méthodes d'exécution de Python.
La variable __name__ m'indique le contexte dans lequel ce fichier est exécuté.
La valeur de __name__ est: '__main__'

Dans cet exemple, vous pouvez voir que __prénom__ a la valeur '__principale__', où les symboles de citation (') vous indique que la valeur a le type de chaîne.

N'oubliez pas qu'en Python, il n'y a pas de différence entre les chaînes définies avec des guillemets simples (') et des guillemets doubles ("). Pour en savoir plus sur la définition de chaînes dans Types de données de base en Python.

Vous trouverez une sortie identique si vous incluez une ligne shebang dans votre script et l'exécutez directement (./execution_methods.py), ou utilisez le %courir magie dans les cahiers IPython ou Jupyter.

Vous pouvez également voir les scripts Python exécutés à partir de packages en ajoutant le -m argument à la commande. Le plus souvent, vous verrez cela recommandé lorsque vous utilisez pépin: python3 -m pip install nom_package.

Ajout du -m argument exécute le code dans le __main__.py module d'un package. Vous pouvez trouver plus d'informations sur le __main__.py fichier dans Comment publier un paquet Python à code source ouvert dans PyPI.

Dans les trois cas, __prénom__ a la même valeur: la chaîne '__principale__'.

Importation dans un module ou un interpréteur interactif

Voyons maintenant la deuxième façon dont l’interprète Python exécutera votre code: imports. Lorsque vous développez un module ou un script, vous souhaiterez probablement tirer parti des modules déjà créés par quelqu'un d'autre, ce que vous pouvez faire à l'aide de la importation mot-clé.

Pendant le processus d'importation, Python exécute les instructions définies dans le module spécifié (mais uniquement premier le temps que vous importez un module). Pour démontrer les résultats de l’importation de votre execution_methods.py fichier, lancez l’interpréteur Python interactif, puis importez votre execution_methods.py fichier:

>>> importation execution_methods
Ceci est mon fichier pour tester les méthodes d'exécution de Python.
La variable __name__ m'indique le contexte dans lequel ce fichier est exécuté.
La valeur de __name__ est: 'execution_methods'

Dans cette sortie de code, vous pouvez voir que l’interpréteur Python exécute les trois appels à impression(). Les deux premières lignes de sortie sont exactement les mêmes que lorsque vous avez exécuté le fichier en tant que script sur la ligne de commande car il n'y a pas de variables dans les deux premières lignes. Cependant, il existe une différence entre le résultat du troisième impression().

Lorsque l'interpréteur Python importe du code, la valeur de __prénom__ est défini pour être identique au nom du module en cours d'importation. Vous pouvez le voir dans la troisième ligne de sortie ci-dessus. __prénom__ a la valeur 'execution_methods', qui est le nom du .py fichier que Python importe.

Notez que si vous importation le module à nouveau sans quitter Python, il n’y aura pas de sortie.

Meilleures pratiques pour les fonctions principales de Python

Maintenant que vous pouvez voir les différences dans la façon dont Python gère ses différents modes d’exécution, il est utile que vous connaissiez les meilleures pratiques à utiliser. Ceux-ci s'appliqueront chaque fois que vous voudrez écrire du code que vous pourrez exécuter en tant que script et importer dans un autre module ou une session interactive.

Vous apprendrez quatre pratiques recommandées pour vous assurer que votre code peut remplir deux fonctions:

1. Mettez le plus de code dans une fonction ou une classe.
2. Utilisation __prénom__ pour contrôler l'exécution de votre code.
3. Créez une fonction appelée principale() pour contenir le code que vous voulez exécuter.
4. Appeler d'autres fonctions de principale().

Mettre le plus de code dans une fonction ou une classe

N'oubliez pas que l'interpréteur Python exécute tout le code d'un module lorsqu'il importe le module. Parfois, le code que vous écrivez aura des effets secondaires que vous souhaitez que l'utilisateur contrôle, tels que:

• Lancer un calcul qui prend beaucoup de temps
• Écrire dans un fichier sur le disque
• Imprimer des informations qui encombreraient le terminal de l'utilisateur

Dans ces cas, vous voulez que l'utilisateur contrôle le déclenchement de l'exécution de ce code plutôt que de laisser l'interpréteur Python exécuter le code lors de l'importation de votre module.

Par conséquent, la meilleure pratique consiste à inclure la plupart du code dans une fonction ou une classe. C’est parce que lorsque l’interprète Python rencontre le def ou classe mots-clés, il ne stocke ces définitions que pour une utilisation ultérieure et ne les exécute pas tant que vous ne l’indiquez pas.

Enregistrez le code ci-dessous dans un fichier appelé best_practices.py pour démontrer cette idée:

    1 de temps importation dormir
    2 
    3 impression("Ceci est mon dossier pour démontrer les meilleures pratiques.")
    4 
    5 def données de processus(Les données):
    6     impression("Début du traitement de données ...")
    7     modified_data = Les données + "qui a été modifié"
    8     dormir(3)
    9     impression("Le traitement des données est terminé.")
dix     revenir modified_data

Dans ce code, vous importez d'abord dormir() du temps module.

dormir() met en pause l'interprète pendant le nombre de secondes que vous donnez comme argument et produira une fonction longue à exécuter pour cet exemple. Ensuite, vous utilisez impression() imprimer une phrase décrivant le but de ce code.

Ensuite, vous définissez une fonction appelée données de processus() cela fait cinq choses:

1. Imprime une sortie pour indiquer à l'utilisateur que le traitement des données commence
2. Modifie les données d'entrée
3. Suspend l'exécution pendant trois secondes à l'aide de dormir()
4. Imprime une sortie pour informer l'utilisateur que le traitement est terminé
5. Renvoie les données modifiées

Exécuter le fichier des meilleures pratiques sur la ligne de commande

Maintenant, qu'arrivera-t-il lorsque vous exécuterez ce fichier en tant que script sur la ligne de commande?

L’interprète Python exécutera le à partir de l'heure d'importation sommeil et impression() lignes qui sont en dehors de la définition de la fonction, alors il va créer la définition de la fonction appelée données de processus(). Ensuite, le script se fermera sans rien faire d’autre, car il n’a pas de code exécutant. données de processus().

Le bloc de code ci-dessous montre le résultat de l'exécution de ce fichier en tant que script:

$ python3 best_practices.py
Ceci est mon dossier pour démontrer les meilleures pratiques.

La sortie que nous pouvons voir ici est le résultat de la première impression(). Notez que l'importation de temps et définissant données de processus() ne produire aucune sortie. Plus précisément, les sorties des appels à impression() qui sont à l'intérieur de la définition de données de processus() ne sont pas imprimés!

Importer le fichier des meilleures pratiques dans un autre module ou dans l'interpréteur interactif

Lorsque vous importez ce fichier dans une session interactive (ou un autre module), l'interpréteur Python exécutera exactement les mêmes étapes que lorsqu'il exécute le fichier en tant que script.

Une fois que l'interpréteur Python a importé le fichier, vous pouvez utiliser toutes les variables, classes ou fonctions définies dans le module que vous avez importé. Pour illustrer cela, nous utiliserons l'interpréteur Python interactif. Démarrez l’interprète interactif, puis tapez importer best_practices:

>>> importation les meilleures pratiques
Ceci est mon dossier pour démontrer les meilleures pratiques.

Le seul résultat de l'importation du best_practices.py le fichier est de la première impression() appel défini à l'extérieur données de processus(). Importer de temps et définissant données de processus() ne produire aucune sortie, comme lorsque vous exécutiez le code à partir de la ligne de commande.

Utilisation __prénom__ contrôler l'exécution de votre code

Et si tu veux données de processus() exécuter lorsque vous exécutez le script à partir de la ligne de commande, mais pas lorsque l'interpréteur Python importe le fichier?

Vous pouvez utilisation __prénom__ pour déterminer le contexte d'exécution et exécuté sous condition données de processus() seulement quand __prénom__ est égal à "__principale__". Ajoutez le code ci-dessous au bas de votre best_practices.py fichier:

11 si __prénom__ == "__principale__":
12     Les données = "Mes données lues sur le Web"
13     impression(Les données)
14     modified_data = données de processus(Les données)
15     impression(modified_data)

Dans ce code, vous avez ajouté une instruction conditionnelle qui vérifie la valeur de __prénom__. Cette condition sera évaluée à Vrai quand __prénom__ est égal à la chaîne "__principale__". Rappelez-vous que la valeur spéciale de "__principale__" pour le __prénom__ variable signifie que l'interpréteur Python exécute votre script et ne l'importe pas.

Dans le bloc conditionnel, vous avez ajouté quatre lignes de code (lignes 12, 13, 14 et 15):

• Lignes 12 et 13: Vous créez une variable Les données qui stocke les données que vous avez acquises sur le Web et les imprime.
• Ligne 14: Vous traitez les données.
• Ligne 15: Vous imprimez les données modifiées.

Maintenant, lancez votre best_practices.py script à partir de la ligne de commande pour voir comment la sortie va changer:

$ python3 best_practices.py
Ceci est mon dossier pour démontrer les meilleures pratiques.
Mes données lues sur le Web
Début du traitement des données ...
Le traitement des données est terminé.
Mes données lues sur le Web qui a été modifié

Tout d’abord, la sortie montre le résultat de la impression() appeler en dehors de données de processus().

Après cela, la valeur de Les données est imprimé. Ceci est dû au fait que la variable __prénom__ a la valeur "__principale__" lorsque l'interpréteur Python exécute le fichier en tant que script, l'instruction conditionnelle évaluée à Vrai.

Ensuite, votre script appelé données de processus() et passé Les données dans pour modification. Quand données de processus() s’exécute, il affiche des messages d’état sur la sortie. Enfin, la valeur de modified_data est imprimé.

Maintenant, vous devriez vérifier ce qui se passe lorsque vous importez le best_practices.py fichier de l'interpréteur interactif (ou d'un autre module). L'exemple ci-dessous illustre cette situation:

>>> importation les meilleures pratiques
Ceci est mon dossier pour démontrer les meilleures pratiques.

Notez que vous obtenez le même comportement qu'avant l'ajout de l'instruction conditionnelle à la fin du fichier! C'est parce que le __prénom__ variable avait la valeur "les meilleures pratiques", donc Python n’a pas exécuté le code à l’intérieur du bloc, y compris données de processus(), parce que l'instruction conditionnelle évaluée à Faux.

Créez une fonction appelée main () pour contenir le code que vous voulez exécuter

Vous pouvez désormais écrire du code Python pouvant être exécuté à partir de la ligne de commande en tant que script et importé sans effets secondaires indésirables. Ensuite, vous allez apprendre à écrire votre code pour que les autres programmeurs Python puissent facilement comprendre ce que vous voulez dire.

De nombreux langages, tels que C, C ++, Java et plusieurs autres, définissent une fonction spéciale qui doit être appelée principale() que le système d’exploitation appelle automatiquement lorsqu’il exécute le programme compilé. Cette fonction est souvent appelée la point d'accès parce que c'est là que l'exécution entre dans le programme.

En revanche, Python n'a pas de fonction spéciale servant de point d'entrée à un script. Vous pouvez réellement donner à la fonction de point d’entrée dans un script Python le nom de votre choix!

Bien que Python n’attribue aucune signification à une fonction nommée principale(), la meilleure pratique est de nommer la fonction de point d'entrée principale() de toute façon. De cette manière, tout autre programmeur qui lit votre script sait immédiatement que cette fonction est le point de départ du code qui accomplit la tâche principale du script.

En outre, principale() doit contenir le code que vous souhaitez exécuter lorsque l'interpréteur Python exécute le fichier. Cela vaut mieux que de placer le code directement dans le bloc conditionnel, car un utilisateur peut le réutiliser. principale()s'ils importent votre module.

Changer la best_practices.py fichier de sorte qu'il ressemble au code ci-dessous:

    1 de temps importation dormir
    2 
    3 impression("Ceci est mon dossier pour démontrer les meilleures pratiques.")
    4 
    5 def données de processus(Les données):
    6     impression("Début du traitement de données ...")
    7     modified_data = Les données + "qui a été modifié"
    8     dormir(3)
    9     impression("Le traitement des données est terminé.")
dix     revenir modified_data
11 
12 def principale():
13     Les données = "Mes données lues sur le Web"
14     impression(Les données)
15     modified_data = données de processus(Les données)
16     impression(modified_data)
17 
18 si __prénom__ == "__principale__":
19     principale()

Dans cet exemple, vous avez ajouté la définition de principale() cela inclut le code qui était auparavant dans le bloc conditionnel. Ensuite, vous avez modifié le bloc conditionnel pour qu'il s'exécute principale(). Si vous exécutez ce code en tant que script ou si vous l'importez, vous obtiendrez le même résultat que dans la section précédente.

Appeler d'autres fonctions depuis main ()

Une autre pratique courante en Python consiste à avoir principale() exécuter d'autres fonctions, plutôt que d’inclure le code qui accomplit la tâche dans principale(). Ceci est particulièrement utile lorsque vous pouvez composer votre tâche globale à partir de plusieurs sous-tâches plus petites pouvant être exécutées indépendamment.

Par exemple, vous pouvez avoir un script qui effectue les tâches suivantes:

1. Lit un fichier de données à partir d'une source qui pourrait être une base de données, un fichier sur le disque ou une API Web
2. Traite les données
3. Écrit les données traitées dans un autre emplacement

Si vous implémentez chacune de ces sous-tâches dans des fonctions distinctes, il est facile pour vous (ou un autre utilisateur) de réutiliser quelques-unes des étapes et d’ignorer celles que vous ne voulez pas. Ensuite, vous pouvez créer un flux de travail par défaut dans principale()et vous pouvez avoir le meilleur des deux mondes.

Que vous appliquiez cette pratique à votre code est une décision de votre part. Diviser le travail en plusieurs fonctions facilite la réutilisation mais augmente la difficulté pour une autre personne qui tente d'interpréter votre code, car elle doit suivre plusieurs sauts dans le déroulement du programme.

Modifier votre best_practices.py fichier de sorte qu'il ressemble au code ci-dessous:

    1 de temps importation dormir
    2 
    3 impression("Ceci est mon dossier pour démontrer les meilleures pratiques.")
    4 
    5 def données de processus(Les données):
    6     impression("Début du traitement de données ...")
    7     modified_data = Les données + "qui a été modifié"
    8     dormir(3)
    9     impression("Le traitement des données est terminé.")
dix     revenir modified_data
11 
12 def read_data_from_web():
13     impression("Lire des données sur le Web")
14     Les données = "Données du web"
15     revenir Les données
16 
17 def write_data_to_database(Les données):
18     impression("Ecrire des données dans une base de données")
19     impression(Les données)
20 
21 def principale():
22     Les données = read_data_from_web()
23     modified_data = données de processus(Les données)
24     write_data_to_database(modified_data)
25 
26 si __prénom__ == "__principale__":
27     principale()

Dans cet exemple de code, les 10 premières lignes du fichier ont le même contenu qu'auparavant. La deuxième définition de fonction de la ligne 12 crée et renvoie des données exemple. La troisième définition de fonction de la ligne 17 simule l'écriture des données modifiées dans une base de données.

À la ligne 21, principale() est défini. Dans cet exemple, vous avez modifié principale() de sorte qu’il appelle tour à tour les fonctions de lecture, de traitement et d’écriture des données.

Premièrement le Les données est créé à partir de read_data_from_web (). Ce Les données est passé à données de processus(), qui retourne le modified_data. Finalement, modified_data est passé dans write_data_to_database ().

Les deux dernières lignes du script sont le bloc conditionnel qui vérifie __prénom__ et court principale() si la si déclaration est Vrai.

Maintenant, vous pouvez exécuter tout le pipeline de traitement à partir de la ligne de commande, comme indiqué ci-dessous:

$ python3 best_practices.py
Ceci est mon dossier pour démontrer les meilleures pratiques.
Lecture de données sur le Web
Début du traitement des données ...
Le traitement des données est terminé.
Ecriture des données traitées dans une base de données
Données du web modifiées

Dans la sortie de cette exécution, vous pouvez voir que l'interpréteur Python exécuté principale(), qui a exécuté read_data_from_web (), données de processus(), et write_data_to_database (). Cependant, vous pouvez également importer le best_practices.py déposer et réutiliser données de processus() pour une source de données d'entrée différente, comme indiqué ci-dessous:

>>> importation les meilleures pratiques comme bp
Ceci est mon dossier pour démontrer les meilleures pratiques.
>>> Les données = "Données d'un fichier"
>>> modified_data = bp.données de processus(Les données)
Début du traitement des données ...
Le traitement des données est terminé.
>>> bp.write_data_to_database(modified_data)
Ecriture des données traitées dans une base de données
Données d'un fichier modifié

Dans cet exemple, vous avez importé les meilleures pratiques et raccourci le nom à bp pour ce code.

Le processus d’importation a obligé l’interprète Python à exécuter toutes les lignes de code de la best_practices.py fichier, la sortie affiche la ligne expliquant l’objet du fichier.

Ensuite, vous avez stocké les données d'un fichier dans Les données au lieu de lire les données du Web. Ensuite, vous avez réutilisé données de processus()et write_data_to_database () du best_practices.py fichier. Dans ce cas, vous avez profité de la réutilisation de votre code au lieu de définir toute la logique de principale().

Résumé des meilleures pratiques pour la fonction principale Python

Voici quatre meilleures pratiques clés concernant principale() en Python que vous venez de voir:

1. Mettez du code qui prend beaucoup de temps à exécuter ou a d'autres effets sur l'ordinateur dans une fonction ou une classe, de sorte que vous puissiez contrôler exactement quand ce code est exécuté.

2. Utilisez les différentes valeurs de __prénom__ pour déterminer le contexte et changer le comportement de votre code avec une instruction conditionnelle.

3. Vous devez nommer votre fonction de point d’entrée principale() afin de communiquer l'intention de la fonction, même si Python n'attribue aucune signification particulière à une fonction nommée principale().

4. Si vous souhaitez réutiliser des fonctionnalités de votre code, définissez la logique dans les fonctions externes. principale() et appeler ces fonctions au sein de principale().

Conclusion

Toutes nos félicitations! Vous savez maintenant comment créer Python principale() les fonctions.

Vous avez appris ce qui suit:

• Connaître la valeur du __prénom__ La variable est importante pour écrire du code qui remplit la double fonction de script exécutable et de module importable.

• __prénom__ prend différentes valeurs en fonction de la manière dont vous avez exécuté votre fichier Python. __prénom__ sera égal à:

  • "__principale__" lorsque le fichier est exécuté à partir de la ligne de commande ou avec python -m (pour exécuter un paquet __main__.py fichier)
  • Le nom du module, si le module est en cours d'importation
• Les programmeurs Python ont développé un ensemble de bonnes pratiques à utiliser lorsque vous souhaitez développer du code réutilisable.

Vous êtes maintenant prêt à écrire de superbes fichiers Python. principale() code de fonction!