Python Fonction et méthode principales : Comprendre la fonction Main()

Qu'est-ce que le Python Fonction principale ?

Le Python fonction principale est le point de départ de tout programme. Lorsque le programme est exécuté, le Python L'interpréteur exécute le code séquentiellement. La fonction principale n'est exécutée que lorsqu'elle est lancée en tant que Python Ce programme n'exécutera pas sa fonction principale s'il est importé en tant que module.

Quelle est la fonction def main() dans PythonPour comprendre cela, prenons l'exemple de code suivant, qui fait partie du noyau. Python programmation bases:

def main() Exemple 1

def main():
     print ("Hello World!")
print ("Guru99")

Ici, nous avons deux éléments d'impression : l'un est défini dans la fonction principale, qui est « Hello World ! », et l'autre est indépendant, qui est « Guru99". Lorsque vous exécutez la fonction def main() :

• Seul "Guru99 impressions
• et non le code « Hello World ! »

C'est parce que nous n'avons pas déclaré l'appel fonction "if__name__== "__main__".

Il est important qu'après avoir défini la fonction principale, vous appeliez le code par if__name__== « __main__ », puis exécutez le code, alors seulement vous obtiendrez le résultat « hello world ! dans la console de programmation. Considérez le code suivant

def main() Exemple 2

def main():
    print("Hello World!")

if __name__ == "__main__":
    main()

print("Guru99")

GuruLe chiffre 99 est imprimé dans ce cas.

Voici l'explication,

• Lorsque vous Python l'interpréteur lit un fichier source, il exécutera tout le code qui s'y trouve.
• Lorsque vous Python exécute le « fichier source » en tant que programme principal, il définit la variable spéciale (__name__) pour avoir une valeur (« __main__ »).
• Lorsque vous exécutez la fonction principale en python, elle lira alors l'instruction « if » et vérifiera si __name__ est égal à __main__.
• In Python "if__name__== "__main__" vous permet d'exécuter le Python fichiers soit comme modules réutilisables ou programmes autonomes.

Pourquoi utiliser une fonction main() dans Python?

Python L'utilisation de `def main()` n'oblige pas à écrire une fonction principale, mais les développeurs expérimentés en utilisent une dans presque tous les scripts complexes. Ce modèle structure le code et le rend réutilisable en toute sécurité. Voici les principales raisons de son utilisation :

• Point d'entrée clair : La fonction main() indique précisément au lecteur où le programme commence, ce qui facilite la compréhension de sa logique.
• Modules réutilisables : Code La condition « if __name__ == “__main__” » n'est exécutée que lors d'une exécution directe, ce qui permet à d'autres fichiers d'importer vos fonctions sans effets secondaires.
• Portée locale : Les variables créées à l'intérieur de main() restent locales, ce qui évite les conflits accidentels avec les noms globaux ailleurs dans le module.
• Des tests plus faciles : L'isolation de la logique dans la fonction main() permet à une suite de tests de l'appeler directement et de vérifier le résultat.
• Convention partagée : La fonction main() est un signal largement reconnu du point d'entrée du programme, ce qui améliore la maintenabilité entre les équipes.

En bref, la fonction main() est facultative dans Pythonmais cela permet de conserver des programmes plus volumineux lisibles, testables et sûrs à importer.

La variable __name__ et Python Module

Pour comprendre l'importance de la variable __name__ dans Python méthode de fonction principale, considérez le code suivant :

def main():
    print("hello world!")

if __name__ == "__main__":
    main()

print("Guru99")

print("Value in built variable name is:  ",__name__)

Considérez maintenant que le code est importé en tant que module

import MainFunction

print("done")

Voici l'explication du code : Comme C, Python utilise == pour la comparaison tandis que = pour l'affectation. Python l'interprète utilise la fonction principale de deux manières

exécution directe :

• __nom__=__main__
• if instruction == True, et le script dans _main_sera exécuté

importer en tant que module

• __name__= nom de fichier du module
• if instruction == false, et le script dans __main__ ne sera pas exécuté

Lorsque le code est exécuté, il vérifiera le nom du module avec « if ». Ce mécanisme garantit que la fonction principale est exécutée uniquement en exécution directe et non lorsqu'elle est importée en tant que module.

Les exemples ci-dessus sont Python 3 codes, si vous souhaitez utiliser Python 2, veuillez considérer le code suivant

def main():
  print "Hello World!"
  
if __name__== "__main__":
  main()

print "Guru99"

In Python 3, vous n'avez pas besoin d'utiliser if__name. Le code suivant fonctionne également

def main():
  print("Hello World!")
  
main()
print("Guru99")

À noter: Assurez-vous qu'après avoir défini la fonction principale, vous laissez un retrait et ne déclarez pas le code juste en dessous de la fonction def main():, sinon cela donnera une erreur d'indentation.

Comment transmettre des arguments de ligne de commande à Python Fonction main()

La fonction main() est l'endroit idéal pour traiter les données saisies par l'utilisateur sur la ligne de commande. Python Ces valeurs sont stockées dans la liste sys.argv, fournie par le module sys standard. Le premier élément, sys.argv[0], correspond au nom du script, et chaque valeur suivante est un argument fourni par l'utilisateur.

L'exemple suivant lit et affiche les arguments de la ligne de commande depuis l'intérieur d'une fonction main() :

import sys

def main():
    print("Script name:", sys.argv[0])
    print("Arguments passed:", sys.argv[1:])

if __name__ == "__main__":
    main()

Si vous enregistrez le fichier sous le nom script.py et que vous exécutez script python.py alpha bêtaLe programme affiche le nom du script et la liste ['alpha', 'beta']. Comme les valeurs arrivent dans la fonction main(), la logique reste organisée et facile à tester.

Voici quelques conseils pratiques pour travailler avec des entrées en ligne de commande :

• Extrayez le nom du script : Utilisez sys.argv[1:] pour lire uniquement les arguments saisis par l'utilisateur.
• Utilisez argparse pour les vrais outils : Le module argparse intégré analyse les drapeaux, les options et le texte d'aide de manière beaucoup plus sûre que la lecture manuelle de sys.argv.
• Renvoyer un code de sortie : Encapsulez l'appel sous la forme sys.exit(main()) afin que la valeur de retour de main() devienne le statut de sortie du processus.
• Valider tôt : Vérifiez le nombre et le type des arguments en haut de la fonction main() avant d'exécuter le reste du programme.

Ce modèle transforme un simple script en un outil en ligne de commande fiable tout en conservantping chaque étape à l'intérieur d'une seule fonction main() testable.

Python Fonction main() comparée à d'autres langages de programmation

Développeurs venant du C, C++, Java On s'attend souvent à une fonction main() obligatoire. Python Cela fonctionne différemment car il s'agit d'un langage interprété ; l'interpréteur exécute donc simplement un fichier de la première ligne à la dernière. La fonction main() dans Python Il s'agit donc d'une convention plutôt que d'une règle.

• C, C++, C# et Java: La fonction main() est un point d'entrée obligatoire. Elle est appelée automatiquement par l'environnement d'exécution, et il ne peut y en avoir qu'une seule par programme.
• Python: Aucune fonction main() n'est requise. L'exécution commence à la première ligne du fichier, et la fonction main() n'est appelée que si votre code la lance.
• Le garde : Le bloc if __name__ == “__main__” donne Python un objectif similaire à celui d'une fonction main() compilée, en marquant le code qui ne doit s'exécuter que lorsque le fichier est le programme principal.

Alors que d'autres langages imposent un point d'entrée main(), Python Cela vous laisse le choix, tout en offrant la même clarté grâce à une convention plutôt qu'à une règle du compilateur.

FAQ