Vous apprenez Python, vous ne connaissez pas encore la fonction principale ?

La fonction principale en Python sert de point d'exécution du programme. La définition de la fonction principale dans la programmation Python est une condition nécessaire pour démarrer l'exécution du programme. Cependant, elle n'est exécutée que lorsque le programme est exécuté directement et ne sera pas exécutée. lorsqu'il est importé en tant que module.

Pour en savoir plus sur la fonction principale de Python, nous apprendrons étape par étape à partir des points suivants :

• Qu'est-ce qu'une fonction Python
• Quelle est la fonction de la fonction principale en Python
• Qu'est-ce qu'une fonction principale de base de Python () Le
• Mode d'exécution Python

Commençons

Qu'est-ce qu'une fonction Python

Je crois que de nombreux amis connaissent les fonctions. Les fonctions sont des blocs de code réutilisables qui constituent les étapes pour effectuer des opérations dans un langage de programmation. Bases, qui sont utilisées pour effectuer des calculs sur les données d'entrée et présenter la sortie à l'utilisateur final.

Nous avons appris qu'une fonction est un morceau de code écrit pour effectuer une tâche spécifique. Les fonctions en Python sont divisées en trois types, à savoir les fonctions intégrées, les fonctions définies par l'utilisateur et les fonctions anonymes. Dans le même temps, nous devons préciser que la fonction principale est la même que n’importe quelle autre fonction en Python, il n’y a aucune différence.

Alors comprenons quelle est la fonction principale de Python.

Quelle est la fonction principale en Python

Dans la plupart des langages de programmation, il existe une fonction spéciale qui est automatiquement exécutée à chaque exécution du programme. Il s'agit de la fonction principale, ou main() comme son essence est habituellement exprimée ci-dessus. est le point de départ de l’exécution du programme.

En Python, il n'est pas nécessaire de définir la fonction principale à chaque fois que vous écrivez un programme, car l'interpréteur Python l'exécutera depuis le haut du fichier à moins qu'une fonction spécifique ne soit définie. Par conséquent, définir un point de départ pour l’exécution d’un programme Python permet de mieux comprendre le fonctionnement du programme.

Un Python main() de base

Dans la plupart des programmes/scripts Python, nous pouvons voir une définition de fonction suivie d'une instruction conditionnelle comme celle-ci :

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


if __name__== "__main__" :
main()

La fonction main est un must pour Python

Il n'est pas obligatoire d'avoir une fonction principale en Python, cependant, dans l'exemple ci-dessus, nous pouvons voir qu'une fonction appelée main() est définie et en dessous se trouve une instruction if conditionnelle qui vérifie la valeur __name__ et la compare avec la chaîne __main__ lorsqu'elle est vraie, main() sera exécuté.

Une fois exécuté, « Hello, World ! » sera imprimé.

Ce modèle de code est très courant lorsqu'il s'agit de fichiers à exécuter en tant que scripts Python ou à importer dans d'autres modules.

Regardons de plus près comment ce code est exécuté. Tout d'abord, il est très nécessaire que nous comprenions que le paramètre __name__ de l'interpréteur Python dépend de la façon dont le code est exécuté. Alors, découvrons les modes d'exécution en Python

Modes d'exécution Python

Il existe deux manières principales de demander à l'interpréteur Python d'exécuter du code :

• La manière la plus courante est d'exécuter le fichier en tant que script Python
• En passant le nécessaire Le code est importé d'un fichier Python à un autre

Peu importe le mode d'exécution que nous choisissons, Python définit une variable spéciale appelée __name__ qui contient une chaîne. Comme nous l'avons vu précédemment, la valeur de cette chaîne dépend de la manière dont le code est exécuté.

Parfois, lorsque nous importons depuis un module, nous voulons savoir si une fonction d'un module particulier est utilisée comme importation, ou si seul le fichier .py (script Python) original de ce module est utilisé.

Pour résoudre ce problème, Python dispose d'une variable intégrée spéciale appelée __name__, à laquelle la chaîne __main__ peut être attribuée en fonction de la manière dont le script est exécuté ou exécuté.

Qu'est-ce que __main__ en Python

La fonction principale de Python est le point d'entrée de tout programme Python. Lorsque nous exécutons le programme, l'interpréteur exécute le code séquentiellement. Si elle est importée en tant que module, la fonction principale ne sera pas exécutée. La fonction principale ne sera exécutée que lorsqu'elle est exécutée en tant que programme Python.

Donc, si nous exécutons le script directement, Python attribuera __main__ à __name__, c'est-à-dire __name__="__main__".

Donc, si l'instruction conditionnelle est évaluée à True, cela signifie que le fichier .py (script Python) est en cours d'exécution ou exécuté directement.

Une chose importante à noter est que si nous exécutons quelque chose directement sur le shell ou le terminal Python, cette instruction conditionnelle s'avère être True par défaut.

En fin de compte, nous écrivions habituellement toutes les définitions de fonctions nécessaires en haut du fichier de code, et finalement écrivions cette instruction à la fin du fichier pour organiser le code.

if __name__ == "__main__" :
Logic Statements

En bref, la variable __name__ peut nous aider à vérifier si le fichier est exécuté directement ou importé.

Lors de l'écriture d'un programme avec une fonction principale, nous devons nous rappeler les choses suivantes

Utilisez les fonctions et les classes autant que possible

长期以来，我们一直在学习面向对象编程的概念及其优势，所以绝对有必要将批量逻辑代码放在紧凑的函数或类中。通过这种方式，我们可以控制代码的执行，而不是让 Python 解释器一导入模块就执行它。

让我们看看下面的一段代码：

def get_got():
print("…Fetching GOT Data… n")
data="Bran Stark wins the Iron Throne. n"
print("…GOT Data has been fetched…n")
return data
 
print("n Demo: Using Functions n")
got=get_got()
print(got)

在上面的示例中，我定义了一个名为 get_got 的函数，它返回存储在变量 data 中的字符串。然后将其存储在名为 got 的变量中，最后打印该变量。

输出如下：

使用 __name__ 来控制代码的执行

现在我们知道了什么是 __name__ 变量，那么该如何以及为什么使用它。让我们看看下面的代码片段：

if __name__ == "__main__":
got = "Game of Thrones is a legendary shown"
print(got)
new_got = str.split(got)
print(new_got)

在上面的示例中，条件 if 语句将比较变量 __name__ 的值与字符串 __main__。当且仅当它的计算结果为 True 时，才会执行下一组逻辑语句。由于我们直接运行程序，我们知道条件语句将是 True。因此语句被执行，我们得到了想要的输出。这样我们就可以使用 __name__ 变量来控制我们代码的执行。

输出如下：

创建一个包含要运行代码的函数 main()。

到目前为止，我们已经了解了 Python 代码的各种执行方式，同时我们还知道为什么以及何时使用 main() 函数，下面就来应用它。看下面这段代码：

print("n Main Function Demo n")
def demo(got):
print("…Beginning Game Of Thrones…n")
new_got = str.split(got)
print("…Game of Thrones has finished…n")
return new_got

def main():
got= "n Bran Stark wins the Iron Throne n"
print(got)
new_got = demo(got)
print(new_got)
if __name__ == "__main__":
main()

在上面的例子中，我们使用了 main() 的定义，它包含了我们要运行的程序逻辑。我们还定义了一个名为 demo 的函数，包含一段代码，可以在必要时复用。此外我们还更改了条件块，使其执行 main()。

这样，我们将要运行的代码放在 main() 中，将编程逻辑放在一个名为 demo 的函数中，并在条件块中调用 main()。

来看一下输出：

可以尝试一下，如果将此代码作为脚本运行或导入它，则输出将是相同的。

从 main() 调用其他函数

当我们编写成熟的 Python 程序时，可能有许多可以调用和使用的函数。通常情况下，一些函数应该在程序开始执行时立即调用。因此，从 main() 本身调用其他函数就是最佳的选择了。

让我们看看下面的代码片段：

print("n Main Function Demo n")
def demo(got):
print("…Beginning Game Of Thrones Demo1…n")
new_got = str.split(got)
print("…Game of Thrones has finished…n")
return new_got
def getgot():
print("…Getting GOT Data…n")
got="Bran Stark wins the Iron Throne n"
print("…GOT Data has been returned…n")
return got
def main():
got= getgot()
print(got)
new_got = demo(got)
print(new_got)
if __name__ == "__main__":
main()

在上面的示例中，我们定义了一个名为 getgot() 的函数来获取数据，这个函数是从 main() 本身调用的。

因此，从 main() 中调用其他函数以将整个任务从可以独立执行的较小子任务中组合起来总是较好的选择。

输出如下：

希望通过这篇文章，对于 Python 中 main() 函数的全部内容以及如何使用它有一个全面而正确的理解。借助 Python 中的 main() 函数，我们可以在需要时执行大量功能，还可以控制执行流程。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!