Introduction to Python/fr: Difference between revisions

From FreeCAD Documentation
No edit summary
No edit summary
 
(119 intermediate revisions by 3 users not shown)
Line 1: Line 1:
<languages/>
<languages/>


{{Docnav/fr
<div class="mw-translate-fuzzy">
|[[Scripts/fr|Scripts]]
{{docnav|Macros|Python scripting tutorial}}
|[[Python_scripting_tutorial/fr|Tutoriel sur les scripts Python]]
</div>
}}


{{TOCright}}
{{TOCright}}
Line 11: Line 12:
Ceci est un petit tutoriel créé pour ceux qui veulent débuter en programmation
Ceci est un petit tutoriel créé pour ceux qui veulent débuter en programmation
[https://fr.wikipedia.org/wiki/Python_(langage) Python]. Python est un [https://fr.wikipedia.org/wiki/Langage_de_programmation langage de programmation] open-source et multiplate-forme.
[https://fr.wikipedia.org/wiki/Python_(langage) Python]. Python est un [https://fr.wikipedia.org/wiki/Langage_de_programmation langage de programmation] open-source et multiplate-forme.
Il a de nombreuses fonctionnalités qui le différencie des autres langages de programmation et est facilement accessible aux nouveaux utilisateurs.
Il a de nombreuses fonctionnalités qui le différencie des autres langages de programmation et est facilement accessible aux nouveaux utilisateurs :


* Il a été conçu pour être lisible par les êtres humains, le faisant relativement facile à apprendre et comprendre.
* Il a été conçu pour être lisible par les êtres humains, le faisant relativement facile à apprendre et comprendre.
* Il est interprété, ce qui signifie que les programmes n'ont pas besoin d'être compilés avant qu'ils puissent être exécutés. Le code Python peut être exécuté immédiatement même ligne par ligne si vous le désirez.
* Il est interprété, ce qui signifie que les programmes n'ont pas besoin d'être compilés avant qu'ils puissent être exécutés. Le code Python peut être exécuté immédiatement même ligne par ligne si vous le désirez.
* Il peut être intégré dans d'autres programmes comme un langage de script. FreeCAD possède un interpréteur Python intégré. Vous pouvez écrire du code Python pour manipuler des éléments de FreeCAD. Cela est très puissant et signifie que vous pouvez construire vos propres outils.
* Il peut être intégré dans d'autres programmes comme un langage de script. FreeCAD possède un interpréteur Python intégré. Vous pouvez écrire du code Python pour manipuler des éléments de FreeCAD. Cela est très puissant et signifie que vous pouvez construire vos propres outils.
* Il est extensible, vous pouvez simplement installer de nouveaux modules dans votre programme Python et étendre ses fonctionnalités. Par exemple, il y a des modules qui permettent à Python de lire et d'écrire des images, pour communiquer avec Twitter, pour planifier des tâches exécutées par votre système d'exploitation, etc...
* Il est extensible, vous pouvez simplement installer de nouveaux modules dans votre programme Python et étendre ses fonctionnalités. Par exemple, il y a des modules qui permettent à Python de lire et d'écrire des images, pour communiquer avec Twitter, pour planifier des tâches exécutées par votre système d'exploitation, etc.


Ce qui suit est une introduction très basique et en aucun cas un tutoriel complet. Mais espérons le, il fournira un bon point de départ pour une exploration plus approfondie dans FreeCAD et ses mécanismes. Nous vous encourageons fortement à saisir les extraits de code ci-dessous dans un interpréteur Python.
Ce qui suit est une introduction très basique et en aucun cas un tutoriel complet. Mais espérons le, il fournira un bon point de départ pour une exploration plus approfondie dans FreeCAD et ses mécanismes. Nous vous encourageons fortement à saisir les extraits de code ci-dessous dans un interpréteur Python.


<span id="The_interpreter"></span>
==L’interpréteur==
==L’interpréteur==


Habituellement, lors de l'écriture d'un programme informatique, vous ouvrez un éditeur de texte ou votre environnement de programmation préféré (qui est essentiellement un éditeur de texte avec quelques outils supplémentaires), vous écrivez votre programme, puis vous le compilez et l'exécutez. Souvent une ou plusieurs erreurs ont été commises lors de la saisie, votre programme ne fonctionnera donc pas. Vous pouvez même recevoir un message d'erreur vous indiquant ce qui n'a pas fonctionné. Ensuite, vous revenez à votre éditeur de texte, corrigez les erreurs, exécutez à nouveau, et ainsi de suite jusqu'à ce que votre programme fonctionne comme prévu.
Habituellement, lors de l'écriture d'un programme informatique, vous ouvrez un éditeur de texte ou votre environnement de programmation préféré (qui est essentiellement un éditeur de texte avec quelques outils supplémentaires), vous écrivez votre programme, puis vous le compilez et l'exécutez. Souvent une ou plusieurs erreurs ont été commises lors de la saisie, votre programme ne fonctionnera donc pas. Vous pouvez même recevoir un message d'erreur vous indiquant ce qui n'a pas fonctionné. Ensuite, vous revenez à votre éditeur de texte, corrigez les erreurs, exécutez à nouveau et ainsi de suite jusqu'à ce que votre programme fonctionne comme prévu.


En Python, tout ce processus peut être effectué de manière transparente dans l'interpréteur Python. L’interpréteur est une fenêtre Python avec une invite de commande, où vous pouvez simplement taper du code Python. Si vous avez installé Python sur votre ordinateur (téléchargez-le depuis le [https://www.python.org/ site Web Python] si vous êtes sous Windows ou Mac, installez le à partir des gestionnaires de paquets, si vous êtes sous GNU/Linux), vous aurez un interpréteur Python dans votre menu de démarrage.
En Python, tout ce processus peut être effectué de manière transparente dans l'interpréteur Python. L’interpréteur est une fenêtre Python avec une invite de commande, où vous pouvez simplement taper du code Python. Si vous avez installé Python sur votre ordinateur (téléchargez-le depuis le [https://www.python.org/ site Web Python] si vous êtes sous Windows ou Mac, installez le à partir des gestionnaires de paquets, si vous êtes sous GNU/Linux), vous aurez un interpréteur Python dans votre menu de démarrage.
Mais comme déjà mentionné, FreeCAD dispose également d'un interpréteur Python intégré: la [[Python_console/fr|console Python]].
Mais comme déjà mentionné, FreeCAD dispose également d'un interpréteur Python intégré : la [[Python_console/fr|console Python]].


[[Image:FreeCAD_Python_console.png]]
[[Image:FreeCAD_Python_console.png]]
Line 32: Line 34:
Si vous ne la voyez pas, cliquez sur le menu Affichage --> Panneaux --> Console Python. La console Python peut être redimensionnée et également non "dockée".
Si vous ne la voyez pas, cliquez sur le menu Affichage --> Panneaux --> Console Python. La console Python peut être redimensionnée et également non "dockée".


L’interpréteur affiche la version Python installée, puis le symbole {{incode|>>>}}, qui est l'invite de commande. L'écriture de code dans l'interpréteur est très simple: une ligne correspond à une instruction. Lorsque vous appuyez sur {{KEY|Entrée}}, votre ligne de code est exécutée (après avoir été compilée instantanément et de manière invisible). Par exemple, écrivez ce code:
L’interpréteur affiche la version Python installée, puis le symbole {{incode|>>>}}, qui est l'invite de commande. L'écriture de code dans l'interpréteur est très simple: une ligne correspond à une instruction. Lorsque vous appuyez sur {{KEY|Entrée}}, votre ligne de code est exécutée (après avoir été compilée instantanément et de manière invisible). Par exemple, écrivez ce code :


{{Code|code=
{{Code|code=
Line 38: Line 40:
}}
}}


{{incode|print()}} est une commande Python qui affiche manifestement quelque chose à l'écran. Lorsque vous appuyez sur {{KEY|Entrée}}, l'opération est exécutée et le message {{incode|"hello"}} apparaît. Si vous faites une erreur, par exemple, écrivez:
{{incode|print()}} est une commande Python qui affiche manifestement quelque chose à l'écran. Lorsque vous appuyez sur {{KEY|Entrée}}, l'opération est exécutée et le message {{incode|"hello"}} apparaît. Si vous faites une erreur, par exemple, écrivez :


{{Code|code=
{{Code|code=
Line 44: Line 46:
}}
}}


Python vous le dira immédiatement. Dans ce cas Python ne sait pas ce qu'est {{incode|hello}}. Les caractères {{incode|" "}} spécifient que le contenu est une chaîne, un jargon de programmation pour un morceau de texte. Sans cela la commande {{incode|print()}} ne reconnaît pas {{incode|hello}}. En appuyant sur la flèche vers le haut, vous pouvez revenir à la dernière ligne de code et la corriger.
Python vous le dira immédiatement. Dans ce cas Python ne sait pas ce qu'est {{incode|hello}}. Les caractères {{incode|" "}} spécifient que le contenu est un '''string''', un jargon de programmation pour une chaîne de caractères. Sans cela la commande {{incode|print()}} ne reconnaît pas {{incode|hello}}. En appuyant sur la flèche vers le haut, vous pouvez revenir à la dernière ligne de code et la corriger.


L'interpréteur Python dispose également d'un système d'aide intégré.
L'interpréteur Python dispose également d'un système d'aide intégré.
Line 56: Line 58:


Maintenant que vous comprenez l'interpréteur Python, nous pouvons continuer avec des choses plus sérieuses.
Maintenant que vous comprenez l'interpréteur Python, nous pouvons continuer avec des choses plus sérieuses.
{{Top}}

<span id="Variables"></span>
[[#top|top]]

==Les Variables==
==Les Variables==


Très souvent dans la programmation vous avez besoin de stocker une valeur sous un nom. C'est là que les variables entrent en jeu. Par exemple, tapez ceci:
Très souvent dans la programmation vous avez besoin de stocker une valeur sous un nom. C'est là que les variables entrent en jeu. Par exemple, tapez ceci :


{{Code|code=
{{Code|code=
Line 68: Line 69:
}}
}}


Vous comprenez probablement ce qui s'est passé ici, nous avons enregistré la chaîne {{incode|"hello"}} sous le nom {{incode|a}}. Maintenant que {{incode|a}} est connu, nous pouvons l'utiliser n'importe où, par exemple dans la commande {{incode|print()}}. Nous pouvons utiliser n'importe quel nom souhaité, nous avons juste besoin de suivre quelques règles simples, telles que ne pas utiliser d'espaces ou de ponctuation et ne pas utiliser de mots-clés Python. Par exemple, nous pouvons écrire:
Vous comprenez probablement ce qui s'est passé ici, nous avons enregistré la chaîne de caractères {{incode|"hello"}} sous le nom {{incode|a}}. Maintenant que {{incode|a}} est connu, nous pouvons l'utiliser n'importe où, par exemple dans la commande {{incode|print()}}. Nous pouvons utiliser n'importe quel nom souhaité, nous avons juste besoin de suivre quelques règles simples, telles que ne pas utiliser d'espaces ou de ponctuation et ne pas utiliser de mots-clés Python. Par exemple, nous pouvons écrire :


{{Code|code=
{{Code|code=
Line 75: Line 76:
}}
}}


Maintenant {{incode|hello}} n'est plus un indéfini. Les variables peuvent être modifiées à tout moment, c'est pourquoi elles sont appelées variables, leur contenu peut varier. Par exemple:
Maintenant {{incode|hello}} n'est plus un indéfini. Les variables peuvent être modifiées à tout moment, c'est pourquoi elles sont appelées variables, leur contenu peut varier. Par exemple :


{{Code|code=
{{Code|code=
Line 84: Line 85:
}}
}}


Nous avons changé la valeur de {{incode|myVariable}}. Nous pouvons également copier des variables:
Nous avons changé la valeur de {{incode|myVariable}}. Nous pouvons également copier des variables :


{{Code|code=
{{Code|code=
Line 92: Line 93:
}}
}}


Il est conseillé de donner des noms significatifs à vos variables. Après un certain temps, vous ne vous souviendrez plus de ce que représente votre variable nommée {{incode|a}}. Mais si vous l'avez nommée, par exemple, {{incode|myWelcomeMessage}} vous vous souviendrez facilement de son objectif. De plus, votre code est un pas supplémentaire vers l'auto-documentation.
<div class="mw-translate-fuzzy">
Notez qu'il est judicieux de donner des noms descriptifs à vos variables, lorsque vous écrivez un long programme, vous ne saurez plus à quoi sert votre variable "'''a'''". Mais, si vous la nommez, par exemple '''MonMessageDeBienvenue''', vous vous souviendrez facilement a quoi vous l'aviez destinée quand vous la verrez.

[http://fr.wikibooks.org/wiki/Programmation_Python/Variable Plus de renseignements sur les variables Python]
</div>

<div class="mw-translate-fuzzy">
La casse est très importante. Par exemple maVariable n'est pas identique à mavariable, la différence se situe dans la lettre majuscule/minuscule "v".
Si vous saisissiez "print mavariable", vous aurez en retour une erreur de type : {{SystemOutput | NameError: name '' is not defined}}.
</div>

[[#top|top]]


La casse est très importante, {{incode|myVariable}} n'est pas la même chose que {{incode|myvariable}}. Si vous deviez entrer {{incode|print(myvariable)}}, il produirait une erreur "not defined" (non défini).
{{Top}}
<span id="Numbers"></span>
==Les Nombres==
==Les Nombres==


Bien sûr les programmes Python peuvent traiter toutes sortes de données, pas seulement les chaînes de caractères. Une chose est importante, Python doit savoir de quel type de données il s'agit. Nous avons vu dans notre exemple print hello que la commande {{incode|print()}} a reconnu notre chaîne de caractères {{incode|"hello"}}. En utilisant les caractères {{incode|" "}}, nous avons spécifié que ce qui suit est une chaîne de caractères.
<div class="mw-translate-fuzzy">
Vous savez qu'un programme informatique est utilisé pour traiter toutes sortes de données, non seulement du texte mais aussi et surtout des nombres.
Une des choses les plus importantes dans Python, est que Python doit savoir quel type de données seront traitées. Nous avons vu dans notre exemple d'affichage "bonjour" que la commande d'affichage '''print''' a reconnu «bonjour» comme une chaîne. C'est grâce au " '''"''' " (guillemets), que la commande d'affichage '''print''' sait qu'il va traiter une chaîne de caractères alphabétiques (du texte).
</div>


Nous pouvons toujours vérifier le type de données d'une variable avec la commande {{incode|type()}}:
<div class="mw-translate-fuzzy">
Le type de donnée contenu dans une variable peut être connu à n'importe quel moment grâce à la commande spéciale de Python '''type()''':
</div>


{{Code|code=
{{Code|code=
Line 121: Line 109:
}}
}}


Il nous dira que le contenu de {{incode|myVar}} est un {{incode|'str'}}, qui est l'abréviation de string (chaîne de caractères). Nous avons également d'autres types de données de base, tels que les nombres entiers et ceux à virgule flottante:
<div class="mw-translate-fuzzy">
Dans cet exemple, il s'affiche dans la console Python {{SystemOutput| '''<type 'str'>'''}} dans le langage informatique on dit qu'il est de type "string" (chaîne de caractères alphabétiques).
Il y a d'[http://fr.wikibooks.org/wiki/Programmation_Python/Type autres types] de données, par exemple: les nombres entier '''(integer)''' , les nombres à virgule flottante '''(float)''' . . .:
</div>


{{Code|code=
{{Code|code=
Line 133: Line 118:
}}
}}


Python sait que 10 et 20 sont des nombres entiers, ils sont donc stockés en tant que {{incode|'int'}} et Python peut faire avec eux tout ce qu'il peut faire avec des entiers. Voyez les résultats suivants :
<div class="mw-translate-fuzzy">
C'est déjà plus intéressant, n'est-ce pas? Maintenant nous avons une puissante calculatrice! Voyons maintenant comment elle fonctionne. Python sait que 10 et 20 sont des nombres entiers. Donc, ils sont stockés en mémoire sous forme '''"int"''' (integer), et Python peut travailler avec eux comme il peut le faire avec des nombres entiers. Regardez les résultats de ce code:
</div>


{{Code|code=
{{Code|code=
Line 143: Line 126:
}}
}}


Ici nous avons forcé Python à considérer que nos deux variables ne sont pas des nombres mais des chaînes de caractères. Python peut ajouter deux morceaux de texte ensemble, bien que dans ce cas, bien sûr, ça ne fonctionnera pas en arithmétique. Mais nous parlions des nombres entiers. Il existe également des nombres à virgule flottante. La différence est que les nombres à virgule flottante peuvent avoir une partie décimale et les nombres entiers n'en ont pas :
<div class="mw-translate-fuzzy">
Nous avons forcé Python à considérer nos deux variables non pas comme de simples nombres, mais comme des parties de texte. Python peut concaténer deux parties de texte, mais il ne cherchera pas à trouver leur somme.
Nous avons parlé de nombres entiers, il y a aussi des nombres à virgule flottante. La différence est, que les nombres entiers n'ont pas de partie décimale, alors que les nombres à virgule flottante peuvent avoir une partie décimale:
</div>


{{Code|code=
{{Code|code=
Line 155: Line 135:
}}
}}


Les entiers et les nombres à virgule flottante peuvent être mélangés sans problème :
<div class="mw-translate-fuzzy">
Les types '''entier''' et à '''virgule flottante''', '''Int''' et '''Float''' peuvent être mélangés sans problème:
</div>


{{Code|code=
{{Code|code=
Line 165: Line 143:
}}
}}


Parce que {{incode|var2}} est un flottant, Python décide automatiquement que le résultat doit également être un flottant. Mais il y a des cas où Python ne sait pas quel type utiliser.
<div class="mw-translate-fuzzy">
Par exemple :
Naturellement, la somme comporte des décimales, n'est-ce pas ? Pendant l'opération, Python automatiquement a décidé que le résultat serait un type '''Float''' (virgule flottante). Dans certains cas comme celui-ci, Python détermine automatiquement quel type doit être choisi pour un résultat. Dans d'autres cas il déclanchera une erreur.
Par exemple:
</div>


{{Code|code=
{{Code|code=
Line 176: Line 152:
}}
}}


Il en résulte une erreur, {{incode|varA}} est une chaîne de caractères et {{incode|varB}} est un entier et Python ne sait pas quoi faire. Cependant, nous pouvons forcer Python à convertir entre les types :
<div class="mw-translate-fuzzy">
Dans cet exemple , varA est une '''chaîne''' et varB est un '''int''', Python ne mélange pas les types différents et nous donnera une erreur. Mais, nous pouvons forcer Python a mélanger des types différents grâce à la conversion:
</div>


{{Code|code=
{{Code|code=
Line 186: Line 160:
}}
}}


Maintenant que les deux variables sont des chaînes de caractères, l'opération fonctionne. Notez que nous avons "stratifié" {{incode|varB}} au moment de l'affichage, mais nous n'avons pas changé {{incode|varB}} elle-même. Si nous voulions transformer {{incode|varB}} de façon permanente en une chaîne de caractères, nous aurions besoin de faire ceci :
<div class="mw-translate-fuzzy">
Maintenant, l'opération fonctionne, pourquoi ! Vous avez noté, que nous avons '''converti''' varB en "string" '''''au moment de l'affichage''''' avec la commande '''str()''', mais nous n'avons pas modifié le type de varB qui reste un '''int'''. Si nous voulons convertir varB de façon permanente en une chaîne de caractères pour les besoins futur du programme, nous aurons besoin de faire:
</div>


{{Code|code=
{{Code|code=
Line 194: Line 166:
}}
}}


Nous pouvons également utiliser {{incode|int()}} et {{incode|float()}} pour convertir en entier et en flottant si nous voulons :
<div class="mw-translate-fuzzy">
Nous pouvons également utiliser les commandes '''int()''' et '''float()''' pour convertir une chaîne de caractères '''str''' en un '''int''' ou '''float'''
Pour la conversion, il faut faire:
</div>


{{Code|code=
{{Code|code=
Line 205: Line 174:
}}
}}


Vous devez avoir remarqué que nous avons utilisé la commande {{incode|print()}} de plusieurs manières. Nous avons affiché des variables, des sommes, plusieurs choses séparées par des virgules et même le résultat d'une autre commande Python. Peut-être avez vous aussi vu que ces deux commandes :
<div class="mw-translate-fuzzy">
Vous avez sûrement remarqué que dans cette partie du tutoriel, nous avons utilisé la commande d'affichage '''print''' de plusieurs manières. Nous avons affiché des variables, des opérations, des chaînes séparées par des virgules et même le résultat de la commande Python '''type()'''. Peut-être avez vous également remarqué qu'en faisant ces deux commandes,
</div>


{{Code|code=
{{Code|code=
Line 214: Line 181:
}}
}}


ont le même résultat. C'est parce que nous sommes dans l'interpréteur et tout est automatiquement affiché. Lorsque nous écrivons des programmes plus complexes qui s'exécutent en dehors de l'interpréteur, ils ne s'affichent pas automatiquement, nous devons donc utiliser la commande {{incode|print()}}. Dans cet esprit arrêtons de l'utiliser ici. Désormais, nous écrirons simplement :
<div class="mw-translate-fuzzy">
nous obtenons le même résultat.

Tout s'affiche automatiquement à l'écran parce que nous sommes dans l'interpréteur. Lorsque nous allons écrire des programmes plus complexes qui s'exécuteront hors de l’interpréteur, ils ne seront pas affichés à l'écran, pour les afficher nous aurons besoin d'utiliser la commande '''print'''. Mais maintenant, nous allons cesser de l'utiliser pour augmenter la vitesse d'exécution.

Donc, nous allons simplement écrire:
</div>


{{Code|code=
{{Code|code=
Line 226: Line 187:
myVar
myVar
}}
}}
{{Top}}

<span id="Lists"></span>
[[#top|top]]

==Les Listes (Tableaux)==
==Les Listes (Tableaux)==


Un autre type de données utile est le type '''list'''. Une liste est une collection d'autres données. Pour définir une liste nous utilisons {{incode|[ ]}} :
<div class="mw-translate-fuzzy">
Un autre type de données intéressant, est le type '''list'''. Le type '''list''' est simplement une collection de données. De la même manière que nous définissons une chaîne de texte en utilisant '''" "''' (guillemets), nous définirons des listes en utilisant '''[ ]''' (crochets):
</div>


{{Code|code=
{{Code|code=
Line 242: Line 200:
}}
}}


Comme vous pouvez le voir, une liste peut contenir tout type de données. Vous pouvez faire beaucoup de choses avec une liste. Par exemple, compter ses articles :
<div class="mw-translate-fuzzy">
Vous voyez qu'une liste peut contenir n'importe quel type de données. Les listes sont très utiles car vous pouvez grouper des variables ou des données ensembles. Vous pouvez alors faire toutes sortes de choses au sein de ces groupes, par exemple, les compter avec '''len()''':
</div>


{{Code|code=
{{Code|code=
Line 250: Line 206:
}}
}}


Ou récupérez un élément :
<div class="mw-translate-fuzzy">
ou récupérer un objet de cette liste:
</div>


{{Code|code=
{{Code|code=
Line 259: Line 213:
}}
}}


Alors que la commande {{incode|len()}} renvoie le nombre total d'éléments dans une liste, le premier élément d'une liste est toujours à la position {{incode|0}}, donc dans notre {{incode|myOtherList}} {{incode|"Bob"}} sera en position {{incode|2}}. Nous pouvons faire beaucoup plus avec des listes tel que le tri, la suppression ou l'ajout d'éléments.
<div class="mw-translate-fuzzy">
Vous voyez que la commande '''len()''' renvoie le nombre d'éléments dans une liste, la «position» d'un objet dans la liste commence à 0. Le premier élément dans une liste est toujours à la position 0, donc dans notre myOtherList, "Bob" est a la deuxième position. Nous pouvons faire beaucoup plus de choses avec les listes tel que le tri du contenu, la suppression ou l'ajout d'éléments vous pouvez les lire [http://www.diveintopython.net/native_data_types/lists.html ici] .
</div>


Fait intéressant, une chaîne de caractères est très similaire à une liste de caractères en Python. Essayez de faire ceci :
<div class="mw-translate-fuzzy">
Une chaîne de texte est très semblable à une liste et chaque caractère peut être adressé séparément! Essayez ce code:
</div>


{{Code|code=
{{Code|code=
Line 273: Line 223:
}}
}}


Habituellement ce que vous pouvez faire avec des listes peut également être fait avec les chaînes de caractères. En fait, les listes et les chaînes de caractères sont des séquences.
<div class="mw-translate-fuzzy">
Pratiquement, ce que vous faites avec les listes peut également être fait avec les chaînes de caractères. En fait, les listes et les chaînes de caractères sont des séquences que Python voit en interne de la même manière.
</div>


Outre les chaînes de caractères, les entiers, les flottants et les listes, il existe davantage de types de données intégrés, tels que les dictionnaires et vous pouvez même créer vos propres types de données avec des classes.
<div class="mw-translate-fuzzy">
{{Top}}
Outre les chaînes de caractères '''"String"''', les entiers '''"Integer"''', les nombres à virgule flottante '''"float"''' et les listes '''"list"''', il y a beaucoup de type de données, plus de renseignements sur les [http://www.diveintopython.net/native_data_types/index.html#odbchelper.dict dictionnaires]. Vous pouvez même créer vos propres types de données avec des [http://www.freenetpages.co.uk/hp/alan.gauld/tutclass.htm classes].
<span id="Indentation"></span>
</div>
==L'indentation==


Une utilisation importante des listes est la possibilité de « les parcourir » et de faire quelque chose avec chaque élément. Par exemple, regardez ceci :
[[#top|top]]

==L'Indentation==

<div class="mw-translate-fuzzy">
Une manière pratique et élégante d'afficher chaque élément de la liste, est de naviguer à l’intérieur de cette liste.<br />
Entrez ce code dans la console:
</div>


{{Code|code=
{{Code|code=
Line 296: Line 238:
}}
}}


Nous avons itéré (jargon de programmation) à travers notre liste avec la commande {{incode|for in}} et avons fait quelque chose avec chacun des éléments. Notez la syntaxe spéciale: la commande {{incode|for}} se termine par {{incode|:}} indiquant que ce qui suit sera un bloc d'une ou plusieurs commandes. Dans l'interpréteur, immédiatement après avoir entré la ligne de commande se terminant par {{incode|:}}, l'invite de commande passera à {{incode|...}}, ce qui signifie que Python sait qu'il y a plus à venir.
<div class="mw-translate-fuzzy">
Nous venons de faire une "itération" (encore un nouveau mot de programmeur!) grâce à notre boucle " '''for ... in ... : ''' " nous avons scruté chaque "champ" de la variable '''alldaltons'''. Notez la syntaxe particulière de la boucle, la commande se termine avec un "''' : '''" ce qui indique à Python que la suite sera un bloc d'une ou plusieurs commandes ou instructions.


Comment Python saura-t-il combien de lignes suivantes devront être exécutées à l'intérieur de l'opération {{incode|for in}} ? Pour cela, Python s'appuie sur l'indentation. Les lignes suivantes doivent commencer par un espace vide, ou plusieurs espaces vides, ou une tabulation, ou plusieurs tabulations. Et tant que l'indentation reste la même, les lignes seront considérées comme faisant partie du bloc {{incode|for in}}. Si vous commencez une ligne avec 2 espaces et la suivante avec 4, il y aura une erreur. Lorsque vous avez terminé, écrivez simplement une autre ligne sans retrait, ou appuyez sur {{KEY|Entrée}} pour revenir du bloc {{incode|for in}}.
Après avoir frappé {{KEY|ENTREE}} derrière le "''' : '''", l'invite de commande va changer en "''' ... '''" ce qui indique à Python que la suite sera une partie de celui-ci.
</div>


L'indentation facilite également la lisibilité du programme. Si vous utilisez de grandes indentations (par exemple des tabulations au lieu d'espaces) lorsque vous écrivez un gros programme, vous aurez une vue claire de ce qui est exécuté en son sein. Nous verrons que d'autres commandes utilisent également des blocs de code indentés.
<div class="mw-translate-fuzzy">
Alors comment savoir, combien de ligne(s) sera ou seront exécutées par Python à l'intérieur de la boucle ?
Pour créer un bloc, Python utilise l'indentation. Les prochaines lignes ne commenceront pas au prompt "''' >>>''' " mais elles commenceront par un ou plusieurs espaces vides, ou, une ou plusieurs tabulations. Les langages de programmation utilisent leurs propres méthodes , comme, la mise entre parenthèses du bloc, entre un BEGIN ... END etc.


La commande {{incode|for in}} peut être utilisée pour de nombreuses choses qui doivent être effectuées plusieurs fois. Elle peut par exemple être combinée avec la commande {{incode|range()}} :
Tant que vous écrirez vos lignes avec la même indentation, elles seront considérées comme faisant partie du bloc. Si vous commencez une ligne avec 2 espaces et la prochaine avec 4 espaces, il y aura une erreur. Lorsque vous avez terminé votre bloc, il suffit d'écrire la suite du programme sans indentation, ou appuyez simplement sur ​​Entrée.
</div>

<div class="mw-translate-fuzzy">
L'indentation permet aussi d'éclaircir la lisibilité du programme. Si vous utilisez de grandes indentations (par exemple, utilisez des tabulations plutôt que des espaces car elles sont plus grandes), lorsque vous écrivez un gros programme, vous aurez une vue claire de ce qui est exécuté à l'intérieur de quoi. Nous verrons que les commandes autres que for-in peuvent aussi avoir des blocs de code en retrait.
</div>

<div class="mw-translate-fuzzy">
La commande " '''for ... in ... : ''' " peut être utilisée pour de nombreuses procédures qui doivent être effectuées plus d'une fois (en boucle). Elle peut aussi par exemple être combinée avec la commande '''range()''':
</div>


{{Code|code=
{{Code|code=
serie = range(1,11)
serie = range(1, 11)
total = 0
total = 0
print("sum")
print("sum")
Line 328: Line 257:
}}
}}


Si vous avez exécuté les exemples de code dans un interpréteur par copier-coller, vous trouverez que le bloc de texte précédent générera une erreur. À la place copiez à la fin du bloc en retrait, c'est-à-dire à la fin de la ligne {{incode|total <nowiki>=</nowiki> total + number}}, puis collez-la dans l'interpréteur. Dans l'interpréteur appuyez sur {{KEY|Entrée}} jusqu'à ce que l'invite à trois points disparaisse et que le code s'exécute. Copiez ensuite les deux dernières lignes suivies d'une autre {{KEY|Enter}}. La réponse finale devrait apparaître.
<div class="mw-translate-fuzzy">
(Si vous avez exécuté les exemples de code dans un interpréteur en copier/coller, vous constaterez que le bloc de texte précédent génère une erreur. Au lieu de cela, copiez à la fin du bloc en retrait, c'est-à-dire la fin de la ligne " = total + nombre " puis collez-le dans l'interpréteur. Dans l'interpréteur, frappez sur la touche {{KEY|Enter}} jusqu'à ce que l'invite à trois points disparaisse et que le code s'exécute. Copiez ensuite les deux dernières lignes dans l'interpréteur suivi d'une ou plusieurs frappes sur la touche {{KEY|Enter}} la réponse finale devrait apparaître.)
</div>


Si vous tapez dans l'interpréteur {{incode|help(range)}}, vous verrez :
<div class="mw-translate-fuzzy">
Si vous tapez dans l'interprèteur '''help(range)''' vous allez voir:
{{Code|code=
range(...)
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
}}
Ici, les crochets indiquent un paramètre facultatif. Cependant, tous sont censés être des entiers. Ci-dessous, nous forcerons les paramètres de la plage à être un entier en utilisant int()
</div>


{{Code|code=
{{Code|code=
Line 348: Line 267:
}}
}}


Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the step parameter to be an integer using {{incode|int()}}:
Ici les crochets indiquent un paramètre facultatif. Cependant tous devraient être des nombres entiers. Ci-dessous nous forcerons le paramètre step à être un entier en utilisant {{incode|int()}} :


{{Code|code=
{{Code|code=
Line 356: Line 275:
}}
}}


Un autre exemple {{incode|range()}} :
<div class="mw-translate-fuzzy">
Ou des choses plus complexes comme ceci:
</div>


{{Code|code=
{{Code|code=
Line 366: Line 283:
}}
}}


La commande {{incode|range()}} a également cette particularité étrange qu'elle commence par {{incode|0}} (si vous ne spécifiez pas le numéro de départ) et que son dernier numéro sera le numéro (n-1) du dernier numéro (n) que vous avez spécifié. Bien sûr, cela fonctionne aussi avec d'autres commandes Python. Par exemple :
<div class="mw-translate-fuzzy">
Vous voyez que la commande '''range()''' a également la particularité de commencer à 0 (si vous ne spécifiez pas un nombre de départ) et que son dernier nombre sera le nombre que vous aurez spécifié '''moins un''' . Bien sûr, cette commande fonctionne parfaitement avec les autres commandes Python.

Par exemple:
</div>


{{Code|code=
{{Code|code=
Line 379: Line 292:
}}
}}


Une autre utilisation intéressante des blocs d'indentation est la commande {{incode|if}}. Cette commande exécute un bloc de code uniquement si une certaine condition est remplie, par exemple :
<div class="mw-translate-fuzzy">
Une autre fonction intéressante utilisée dans un bloc indenté est la commande de condition '''if''' (si). Avec " '''if''' " la suite de la procédure sera exécutée '''uniquement si la condition est remplie'''.
</div>


{{Code|code=
{{Code|code=
Line 389: Line 300:
}}
}}


Bien sûr cela affichera toujours l'expression, mais essayez de remplacer la deuxième ligne par :
<div class="mw-translate-fuzzy">
C'est bien, ce code affiche "OK il c'est bien un Dalton !!!" car la condition est exacte.
Mais maintenant essayons cette ligne:
</div>


{{Code|code=
{{Code|code=
Line 398: Line 306:
}}
}}


Alors rien n'est affiché. Nous pouvons également préciser avec une instruction {{incode|else}} :
<div class="mw-translate-fuzzy">
Il ne c'est rien affiché car la condition n'était pas remplie.
Nous pouvons alors lui demander '''else''' (si la condition n'est pas remplie alors):
</div>


{{Code|code=
{{Code|code=
Line 410: Line 315:
print("Such Dalton doesn't exist!")
print("Such Dalton doesn't exist!")
}}
}}
{{Top}}

<span id="Functions"></span>
[[#top|top]]

==Les Fonctions==
==Les Fonctions==


Il existe très peu de [https://docs.python.org/3/reference/lexical_analysis.html#identifiers commandes Python standard] et nous en connaissons déjà plusieurs. Mais vous pouvez créer vos propres commandes. En fait, la plupart des modules supplémentaires que vous pouvez connecter à votre installation Python le font déjà, ils ajoutent des commandes que vous pouvez utiliser. Une commande personnalisée en Python s'appelle une fonction et se présente comme suit :
<div class="mw-translate-fuzzy">
Il n'y a pas beaucoup [http://docs.python.org/reference/lexical_analysis.html#identifiers mots réservés dans Python], à peine une trentaine, et nous en connaissons maintenant quelques unes. Imaginons que nous voulions construire nous même une commande spéciale! Et bien, il est extrêmement facile de construire sa propre commande dans Python. Vous pouvez ajouter ces commandes dans votre installation Python de manière à en augmenter les capacités et les utiliser comme bon vous semble. Ces nouvelles commandes que vous allez créer dans Python, s'appellent des '''Fonctions'''.
Elles sont faites de cette manière:
</div>


{{Code|code=
{{Code|code=
Line 427: Line 328:
}}
}}


La commande {{incode|def()}} définit une nouvelle fonction, vous lui donnez un nom et à l'intérieur de la parenthèse vous définissez les arguments que la fonction utilisera. Les arguments sont des données qui seront transmises à la fonction. Par exemple, observez la commande {{incode|len()}}. Si vous écrivez simplement {{incode|len()}}, Python vous dira qu'il a besoin d'un argument. Ce qui est évident: vous voulez connaître la longueur de quelque chose. Si vous écrivez {{incode|len(maListe)}} alors {{incode|maListe}} est l'argument que vous passez à la fonction {{incode|len()}}. Et la fonction {{incode|len()}} est définie de telle manière qu'elle sait quoi faire avec cet argument. Nous avons fait la même chose avec notre fonction {{incode|printsqm}}.
<div class="mw-translate-fuzzy">
Extrêmement simple: la commande def() définit une nouvelle fonction. Vous lui donnez un nom, et à l'intérieur de la parenthèse vous définissez les arguments que nous utiliserons dans notre fonction. Les arguments sont des données qui seront transmises à la fonction. Par exemple, regardez la commande len(). Si vous écrivez simplement len(), Python vous dira qu'il a besoin d'un argument. C'est-à-dire que tu veux len() de quelque chose, non ? Ensuite, par exemple, vous écrirez len(myList) et vous aurez la longueur de myList. Eh bien, myList est un argument que vous transmettez à la fonction len(). La fonction len() est définie de manière à savoir quoi faire avec ce qui lui est transmis. Comme nous l'avons fait ici.
</div>


Le nom {{incode|myValue}} peut être n'importe quoi et il ne sera utilisé qu'à l'intérieur de la fonction. C'est juste un nom que vous donnez à l'argument pour que vous puissiez en faire quelque chose. En définissant des arguments, vous indiquez également à la fonction combien en attendre. Par exemple, si vous procédez ainsi :
<div class="mw-translate-fuzzy">
Le nom de la variable "'''myValue'''" peut être n'importe quel nom, et cette variable ne sera utilisée qu'à l'intérieur de la fonction. C'est juste un nom qui représentera l'argument dans la fonction en vue de l'utiliser, mais elle sert aussi a renseigner la fonction de combien d'arguments elle disposera.
Par exemple, faites ceci:
</div>


{{Code|code=
{{Code|code=
printsqm(45,34)
printsqm(45, 34)
}}
}}


Il y aura une erreur. Notre fonction a été programmée pour recevoir un seul argument, mais elle en a reçu deux, {{incode|45}} et {{incode|34}}. Essayons un autre exemple:
<div class="mw-translate-fuzzy">
Cette commande affichera l'erreur "'''TypeError: printsqm() takes exactly 1 argument (2 given)'''" car la fonction "'''def printsqm(myValue):'''" ne demande qu'un seul argument, "'''myValue'''" et, nous lui en avons donné deux, 45 et 34.

Maintenant, écrivez cette fonction:
</div>


{{Code|code=
{{Code|code=
Line 454: Line 346:
}}
}}


Ici nous avons créé une fonction qui reçoit deux arguments, les additionne et renvoie cette valeur. Renvoyer quelque chose est très utile, car nous pouvons faire quelque chose avec le résultat, comme le stocker dans la variable {{incode|myTotal}}.
<div class="mw-translate-fuzzy">
{{Top}}
Nous avons créé une fonction qui demande deux arguments, les exécutes , et nous renvoie le résultat. Le retour du résultat est très utile car nous pouvons l'utiliser pour l'afficher ou le stocker dans une variable '''myTotal''' (pour notre exemple mais n'importe quel nom conviendra) ou les deux.
<span id="Modules"></span>
Comme nous sommes dans l'interpréteur de Python, le résultat s'affiche en faisant:
</div>

[[#top|top]]

==Les Modules==
==Les Modules==


Maintenant que vous avez une bonne idée du fonctionnement de Python, vous aurez besoin de savoir encore une chose: comment travailler avec des fichiers et des modules.
<div class="mw-translate-fuzzy">
Maintenant, vous avez une idée du fonctionnement de Python: mais comment faire pour travailler avec les fichiers et les modules.
</div>


Jusqu'à présent, nous avons écrit les instructions Python ligne par ligne dans l'interpréteur. Cette méthode n'est évidemment pas adaptée aux programmes plus importants. Normalement le code des programmes Python est stocké dans des fichiers avec l'extension {{FileName|.py}}. Ce ne sont que des fichiers de texte brut et n'importe quel éditeur de texte (Linux gedit, emacs, vi ou même le bloc-notes Windows) peut être utilisé pour les créer et les modifier.
<div class="mw-translate-fuzzy">
Jusqu'à présent, nous avons écrit des instructions ligne par ligne pour travailler dans l'interpréteur Python, pas vrai?
Lorsque vous voulez faire des choses plus complexes, il est commode d'écrire les premières lignes de code, puis de les exécuter en une seule fois. Eh bien, c'est très facile à faire, et cela permet aussi de sauver son travail.
Il suffit d'ouvrir un éditeur de texte (par exemple, Le Bloc-notes Windows), et d'écrire toutes les lignes de code de Python, de la même manière qu'elles sont écrites dans l'interpréteur, avec les indentations, etc. Ensuite, enregistrez le fichier sur votre disque, de préférence avec l'extension '''.Py'''.


Il existe plusieurs façons d'exécuter un programme Python. Sous Windows, faites simplement un clic droit sur votre fichier, ouvrez-le avec Python et exécutez-le. Mais vous pouvez également l'exécuter à partir de l'interpréteur Python lui-même. Pour cela, l'interprète doit savoir où se trouve votre programme. Dans FreeCAD, le moyen le plus simple consiste à placer votre programme dans un dossier que l'interpréteur Python de FreeCAD connaît par défaut, tel que le dossier utilisateur {{FileName|Mod}} de FreeCAD :
Voilà, maintenant vous avez un programme Python complet. Bien sûr, il y a de meilleurs éditeurs que le bloc-notes de Windows ou le [http://www.osxfacile.com/terminal.html terminal] d'OS X comme l'excellent [http://notepad-plus-plus.org/fr/ Notepad++] (pour Windows) qui utilise la coloration syntaxique tout comme [https://developer.apple.com/xcode XCode] (pour OS X) et ceci démontre qu'un programme Python n'est qu'un fichier texte.
* Sous Linux, il s'agit généralement de {{FileName|/home/<username>/.local/share/FreeCAD/Mod/}} ({{VersionPlus/fr|0.20}}) ou {{FileName|/home/<username>/.FreeCAD/Mod/}} ({{VersionMinus/fr|0.19}}).
</div>
* Sous Windows, il s'agit de {{FileName|%APPDATA%\FreeCAD\Mod\}}, qui est généralement {{FileName|C:\Utilisateurs\<nom_utilisateur>\Appdata\ Roaming\FreeCAD\Mod\}}.

* Sous macOS, il s'agit généralement de {{FileName|/Users/<username>/Library/Application Support/FreeCAD/Mod/}}.
<div class="mw-translate-fuzzy">
Ajoutons un sous-dossier appelé {{FileName|scripts}} puis écrivons un fichier comme celui-ci :
Pour exécuter un programme Python, il ya des centaines de manières. Dans Windows, cliquez simplement sur le fichier, ouvrez-le avec Python, et exécutez le. Mais vous pouvez également l'exécuter avec l'interpréteur Python. Pour ce faire, l’interpréteur doit savoir où se trouve le programme '''.Py'''. Dans FreeCAD, le plus simple est de placer les fichiers '''.Py''' dans le répertoire par défaut destiné aux programmes Python, cet endroit connu de l'interpréteur inclut dans FreeCAD est '''''C:\Program Files\FreeCAD0.12\''bin''', mais d'autres endroits sont aussi connu de FreeCad '''''C:\Program Files\FreeCAD0.12\''Mod''' (tous les outils de FreeCad) et '''''C:\Travail\Mes documents\. . .\FREECAD\''Macro''' où sont répertoriés tous vos programmes créés dans l’interpréteur de FreeCad '''Macro → Macros'''. Le chemin de destination de vos modules peut être forcé à partir du menu '''''Édition → Préférences → Macro'' Chemin de la macro'''. (Sous Linux, vous avez probablement un répertoire /home/<username>/.FreeCAD/Mod, ajoutons un sous-répertoire à ce qu'on appelle les scripts où nous placerons le fichier texte.)

Supposons que nous écrivions ce fichier programme:
</div>


{{Code|code=
{{Code|code=
Line 488: Line 368:
}}
}}


Enregistrez le fichier sous {{FileName|myTest.py}} dans le dossier {{FileName|scripts}} et dans la fenêtre de l'interpréteur, écrivez :
<div class="mw-translate-fuzzy">
et, nous allons l'enregistrer en "'''test.py'''" dans '''. . ./FreeCAD/bin'''. (ou avec Linux dans /home/<username>/.FreeCAD/Mod/scripts.) Maintenant, allons dans FreeCAD, et dans la fenêtre de l'interpréteur, écrivez:
</div>


{{Code|code=
{{Code|code=
Line 496: Line 374:
}}
}}


sans l'extension {{FileName|.py}}. Cela exécutera le contenu du fichier, ligne par ligne, comme si nous l'avions écrit dans l'interpréteur. La fonction sum (somme) sera créée et le message sera affiché. Les fichiers contenant des fonctions, comme les nôtres, sont appelés modules.
<div class="mw-translate-fuzzy">
'''sans''' l'extension .py.


Lorsque nous écrivons une fonction {{incode|sum()}} dans l'interpréteur, nous l'exécutons comme ceci :
Le contenu du fichier sera tout simplement exécuté, ligne par ligne, comme si nous l'avions écrit dans l'interpréteur. La fonction somme a été créée, et le message "'''''test.py a bien été chargé'''''" sera affiché. Il ya une grande différence: la commande '''import''' est faite non seulement pour exécuter des programmes écrits dans des fichiers comme le nôtre, mais aussi de charger des fonctions dans Python, de sorte qu'elles deviennent disponibles dans l'interpréteur. Les fichiers contenant des fonctions, comme le nôtre, sont appelés '''modules'''.
</div>

<div class="mw-translate-fuzzy">
Normalement, lorsque nous écrivons une fonction sum() dans l'interpréteur, nous l'exécutons simplement comme ceci,
</div>


{{Code|code=
{{Code|code=
sum(14,45)
sum(14, 45)
}}
}}


Mais lorsque nous importons un module contenant une fonction {{incode|sum()}} la syntaxe est un peu différente :
<div class="mw-translate-fuzzy">
comme nous l'avons fait plus haut.

Mais quand nous importons un module contenant une fonction comme '''sum(a,b)''', la syntaxe est un peu différente.
Nous ferons:
</div>


{{Code|code=
{{Code|code=
myTest.sum(14,45)
myTest.sum(14, 45)
}}
}}


Autrement dit, le module est importé en tant que "conteneur" et toutes ses fonctions se trouvent à l'intérieur de ce conteneur. Ceci est très utile, car nous pouvons importer de nombreux modules et garder tout bien organisé. Fondamentalement, lorsque vous voyez {{incode|something.somethingElse}}, avec un point entre les deux, cela signifie que {{incode|somethingElse}} est à l'intérieur {{incode|something}}.
<div class="mw-translate-fuzzy">
Autrement dit, le module est importé comme un «conteneur», et toutes ses fonctions sont à l'intérieur. Cela est extrêmement utile, parce que nous pouvons importer un grand nombre de modules, et de les organiser.<br />
Donc, en bref, quand vous voyez '''quelque_chose.quelque_chose''' (avec un '''point''' entre les deux), signifie que quelque chose est à l'intérieur quelque chose.
</div>


Nous pouvons également importer notre fonction sum() directement dans l'espace principal de l'interpréteur :
<div class="mw-translate-fuzzy">
Nous pouvons aussi, importer et extraire notre fonction sum() contenue dans "test.py" directement dans l’interpréteur, comme ceci:
</div>


{{Code|code=
{{Code|code=
from myTest import *
from myTest import *
sum(12,54)
sum(12, 54)
}}
}}


Presque tous les modules le font: ils définissent des fonctions, de nouveaux types de données et classes que vous pouvez utiliser dans l'interpréteur ou dans vos propres modules Python, car rien ne vous empêche d'importer d'autres modules à l'intérieur de votre module !
<div class="mw-translate-fuzzy">
Théoriquement, tous les modules se comportent de cette manière. Vous importez un module, et vous utilisez ses fonctions de cette manière: '''module.fonction(argument(s))'''. <br />
Les modules travaillent de cette façon: ils définissent les fonctions, les nouveaux types de données et les classes que vous pouvez utiliser dans l'interpréteur Python ou dans vos propres modules, parce que rien ne vous empêche d'importer d'autres modules à l'intérieur de votre module!
</div>


Comment savons-nous quels modules nous avons, quelles fonctions sont à l'intérieur et comment les utiliser (c'est-à-dire, de quel type d'arguments elles ont besoin) ? Nous avons déjà vu que Python possède une fonction {{incode|help()}}. Faites :
<div class="mw-translate-fuzzy">
Encore une chose extrêmement utile. Comment connaître les modules disponibles ? quelles sont les fonctions contenues dans ces modules et comment les utiliser (c'est à dire quels arguments sont demandés par la fonction)? Nous avons vu que Python a une fonction d'aide().

Alors, dans l'interpréteur Python de FreeCad faisons:
</div>


{{Code|code=
{{Code|code=
Line 550: Line 405:
}}
}}


nous donnera une liste de tous les modules disponibles. Nous pouvons importer n'importe lequel d'entre eux et parcourir leur contenu avec la commande {{incode|dir()}} :
<div class="mw-translate-fuzzy">
Will give us a list of all available modules. We can now type q to get out of the interactive help, and import any of them. We can even browse their content with the dir() command
</div>


{{Code|code=
{{Code|code=
Line 559: Line 412:
}}
}}


Nous verrons toutes les fonctions contenues dans le module {{incode|math}}, ainsi que des choses étranges nommées {{incode|__doc__}}, {{incode|__file__}}, {{incode|__name__}}. Chaque fonction d'un module bien construit a un {{incode|__doc__}} qui explique comment l'utiliser. Par exemple, nous voyons qu'il y a une fonction {{incode|sin()}} à l'intérieur du module mathématique. Vous voulez savoir comment l'utiliser ?
<div class="mw-translate-fuzzy">
Nous voyons maintenant toutes les fonctions contenues dans le module math, ainsi que des trucs étranges comme:'' __ doc__, __ FILE__, __ name__ . . . ''.<br />
Le '''__ doc__''' est extrêmement utile, il s'agit d'un texte de documentation. Dans les modules, chaque fonction de fait a une '''__ doc__''' qui explique comment l'utiliser. Par exemple, nous voyons qu'il ya une fonction '''sin''' dans le module math. <br />
Vous voulez savoir comment utiliser cette fonction ? alors:
</div>
{{Code|code=
{{Code|code=
print(math.sin.__doc__)
print(math.sin.__doc__)
}}
}}


Cela peut ne pas être évident, mais de chaque côté de {{incode|doc}} se trouvent deux caractères de soulignement.
<div class="mw-translate-fuzzy">
(Cela peut ne pas être évident, mais de chaque côté de doc sont deux caractères de soulignement.)
</div>


Et enfin une dernière astuce : lorsque vous travaillez sur du code nouveau ou existant, il est préférable de ne pas utiliser l'extension de fichier de macro FreeCAD, {{FileName|.FCMacro}}, mais plutôt d'utiliser l'extension standard {{FileName|.py}}. En effet, Python ne reconnaît pas l'extension {{FileName|.FCMacro}}. Si vous utilisez {{FileName|.py}}, votre code peut être facilement chargé avec {{incode|import}}, comme nous l'avons déjà vu et également rechargé avec {{incode|importlib.reload()}} :
<div class="mw-translate-fuzzy">
Et enfin, une dernier chose: Lorsque l'on travaille sur un nouveau module, nous avons besoin de le tester.

La meilleure chose a faire remplacez l'extension de la macro FreeCAD comme suit : '''myModule.fcmacro''' → '''myModule.py'''.
</div>


{{Code|code=
{{Code|code=
Line 583: Line 426:
}}
}}


Il existe cependant une alternative :
<div class="mw-translate-fuzzy">
Cependant, il y a deux méthodes que vous pouvez utiliser: A l'intérieur d'une macro utilisez les fonctions Python exec ou execfile.
</div>


{{Code|code=
{{Code|code=
exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())
exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())
}}
}}
{{Top}}

<span id="Starting_with_FreeCAD"></span>
[[#top|top]]

==Démarrer avec FreeCAD==
==Démarrer avec FreeCAD==


Espérons que vous avez maintenant une bonne idée du fonctionnement de Python et que vous pouvez commencer à explorer ce que FreeCAD a à offrir. Les fonctions Python de FreeCAD sont toutes bien organisées en différents modules. Certains d'entre eux sont déjà chargés (importés) lorsque vous démarrez FreeCAD. Essayez simplement :
<div class="mw-translate-fuzzy">
Eh bien, je pense que maintenant vous devez avoir une bonne idée de la façon dont Python travaille, et vous pouvez commencer à explorer ce que FreeCAD peut nous offrir. Les fonctions Python de FreeCAD sont toutes bien organisées en différents modules. Certaines d'entre elles sont déjà chargées (importées) au démarrage de FreeCAD.
Donc, il suffit de faire:
</div>


{{Code|code=
{{Code|code=
dir()
dir()
}}
}}
{{Top}}

[[#top|top]]

==Notes==
==Notes==


* FreeCAD was originally designed to work with Python 2. Since Python 2 reached the end of its life in 2020, future development of FreeCAD will be done exclusively with Python 3, and backwards compatibility will not be supported.
* FreeCAD a été initialement conçu pour fonctionner avec Python 2. Puisque Python 2 a atteint la fin de sa vie en 2020, le développement futur de FreeCAD se fera exclusivement avec Python 3 et la compatibilité descendante ne sera pas prise en charge.
* Much more information about Python can be found in the [https://docs.python.org/3/tutorial/index.html official Python tutorial] and the [https://docs.python.org/3/reference/ official Python reference].
* Beaucoup plus d'informations sur Python peuvent être trouvées dans le [https://docs.python.org/3/tutorial/index.html tutoriel Python officiel] et la [https://docs.python.org/3/reference/ référence officielle Python].
{{Top}}


{{Docnav/fr
[[#top|top]]
|[[Scripts/fr|Scripts]]

|[[Python_scripting_tutorial/fr|Tutoriel sur les scripts Python]]
<div class="mw-translate-fuzzy">
}}
{{docnav/fr|[[Macros/fr|Macros]]|[[Python scripting tutorial/fr|Python scripting tutorial]]}}
</div>


{{Powerdocnavi{{#translation:}}}}
{{Powerdocnavi{{#translation:}}}}
[[Category:Python_Code{{#translation:}}]]
[[Category:Developer Documentation{{#translation:}}]]
[[Category:Python Code{{#translation:}}]]
{{clear}}

Latest revision as of 10:35, 18 February 2023

Introduction

Ceci est un petit tutoriel créé pour ceux qui veulent débuter en programmation Python. Python est un langage de programmation open-source et multiplate-forme. Il a de nombreuses fonctionnalités qui le différencie des autres langages de programmation et est facilement accessible aux nouveaux utilisateurs :

  • Il a été conçu pour être lisible par les êtres humains, le faisant relativement facile à apprendre et comprendre.
  • Il est interprété, ce qui signifie que les programmes n'ont pas besoin d'être compilés avant qu'ils puissent être exécutés. Le code Python peut être exécuté immédiatement même ligne par ligne si vous le désirez.
  • Il peut être intégré dans d'autres programmes comme un langage de script. FreeCAD possède un interpréteur Python intégré. Vous pouvez écrire du code Python pour manipuler des éléments de FreeCAD. Cela est très puissant et signifie que vous pouvez construire vos propres outils.
  • Il est extensible, vous pouvez simplement installer de nouveaux modules dans votre programme Python et étendre ses fonctionnalités. Par exemple, il y a des modules qui permettent à Python de lire et d'écrire des images, pour communiquer avec Twitter, pour planifier des tâches exécutées par votre système d'exploitation, etc.

Ce qui suit est une introduction très basique et en aucun cas un tutoriel complet. Mais espérons le, il fournira un bon point de départ pour une exploration plus approfondie dans FreeCAD et ses mécanismes. Nous vous encourageons fortement à saisir les extraits de code ci-dessous dans un interpréteur Python.

L’interpréteur

Habituellement, lors de l'écriture d'un programme informatique, vous ouvrez un éditeur de texte ou votre environnement de programmation préféré (qui est essentiellement un éditeur de texte avec quelques outils supplémentaires), vous écrivez votre programme, puis vous le compilez et l'exécutez. Souvent une ou plusieurs erreurs ont été commises lors de la saisie, votre programme ne fonctionnera donc pas. Vous pouvez même recevoir un message d'erreur vous indiquant ce qui n'a pas fonctionné. Ensuite, vous revenez à votre éditeur de texte, corrigez les erreurs, exécutez à nouveau et ainsi de suite jusqu'à ce que votre programme fonctionne comme prévu.

En Python, tout ce processus peut être effectué de manière transparente dans l'interpréteur Python. L’interpréteur est une fenêtre Python avec une invite de commande, où vous pouvez simplement taper du code Python. Si vous avez installé Python sur votre ordinateur (téléchargez-le depuis le site Web Python si vous êtes sous Windows ou Mac, installez le à partir des gestionnaires de paquets, si vous êtes sous GNU/Linux), vous aurez un interpréteur Python dans votre menu de démarrage. Mais comme déjà mentionné, FreeCAD dispose également d'un interpréteur Python intégré : la console Python.

La console Python FreeCAD

Si vous ne la voyez pas, cliquez sur le menu Affichage --> Panneaux --> Console Python. La console Python peut être redimensionnée et également non "dockée".

L’interpréteur affiche la version Python installée, puis le symbole >>>, qui est l'invite de commande. L'écriture de code dans l'interpréteur est très simple: une ligne correspond à une instruction. Lorsque vous appuyez sur Entrée, votre ligne de code est exécutée (après avoir été compilée instantanément et de manière invisible). Par exemple, écrivez ce code :

print("hello")

print() est une commande Python qui affiche manifestement quelque chose à l'écran. Lorsque vous appuyez sur Entrée, l'opération est exécutée et le message "hello" apparaît. Si vous faites une erreur, par exemple, écrivez :

print(hello)

Python vous le dira immédiatement. Dans ce cas Python ne sait pas ce qu'est hello. Les caractères " " spécifient que le contenu est un string, un jargon de programmation pour une chaîne de caractères. Sans cela la commande print() ne reconnaît pas hello. En appuyant sur la flèche vers le haut, vous pouvez revenir à la dernière ligne de code et la corriger.

L'interpréteur Python dispose également d'un système d'aide intégré. Disons que nous ne comprenons pas ce qui s'est mal passé avec print(hello) et que nous voulons des informations spécifiques sur la commande:

help("print")

Vous obtiendrez une description longue et complète de tout ce que la commande print() peut faire.

Maintenant que vous comprenez l'interpréteur Python, nous pouvons continuer avec des choses plus sérieuses.

En haut

Les Variables

Très souvent dans la programmation vous avez besoin de stocker une valeur sous un nom. C'est là que les variables entrent en jeu. Par exemple, tapez ceci :

a = "hello"
print(a)

Vous comprenez probablement ce qui s'est passé ici, nous avons enregistré la chaîne de caractères "hello" sous le nom a. Maintenant que a est connu, nous pouvons l'utiliser n'importe où, par exemple dans la commande print(). Nous pouvons utiliser n'importe quel nom souhaité, nous avons juste besoin de suivre quelques règles simples, telles que ne pas utiliser d'espaces ou de ponctuation et ne pas utiliser de mots-clés Python. Par exemple, nous pouvons écrire :

hello = "my own version of hello"
print(hello)

Maintenant hello n'est plus un indéfini. Les variables peuvent être modifiées à tout moment, c'est pourquoi elles sont appelées variables, leur contenu peut varier. Par exemple :

myVariable = "hello"
print(myVariable)
myVariable = "good bye"
print(myVariable)

Nous avons changé la valeur de myVariable. Nous pouvons également copier des variables :

var1 = "hello"
var2 = var1
print(var2)

Il est conseillé de donner des noms significatifs à vos variables. Après un certain temps, vous ne vous souviendrez plus de ce que représente votre variable nommée a. Mais si vous l'avez nommée, par exemple, myWelcomeMessage vous vous souviendrez facilement de son objectif. De plus, votre code est un pas supplémentaire vers l'auto-documentation.

La casse est très importante, myVariable n'est pas la même chose que myvariable. Si vous deviez entrer print(myvariable), il produirait une erreur "not defined" (non défini).

En haut

Les Nombres

Bien sûr les programmes Python peuvent traiter toutes sortes de données, pas seulement les chaînes de caractères. Une chose est importante, Python doit savoir de quel type de données il s'agit. Nous avons vu dans notre exemple print hello que la commande print() a reconnu notre chaîne de caractères "hello". En utilisant les caractères " ", nous avons spécifié que ce qui suit est une chaîne de caractères.

Nous pouvons toujours vérifier le type de données d'une variable avec la commande type():

myVar = "hello"
type(myVar)

Il nous dira que le contenu de myVar est un 'str', qui est l'abréviation de string (chaîne de caractères). Nous avons également d'autres types de données de base, tels que les nombres entiers et ceux à virgule flottante:

firstNumber = 10
secondNumber = 20
print(firstNumber + secondNumber)
type(firstNumber)

Python sait que 10 et 20 sont des nombres entiers, ils sont donc stockés en tant que 'int' et Python peut faire avec eux tout ce qu'il peut faire avec des entiers. Voyez les résultats suivants :

firstNumber = "10"
secondNumber = "20"
print(firstNumber + secondNumber)

Ici nous avons forcé Python à considérer que nos deux variables ne sont pas des nombres mais des chaînes de caractères. Python peut ajouter deux morceaux de texte ensemble, bien que dans ce cas, bien sûr, ça ne fonctionnera pas en arithmétique. Mais nous parlions des nombres entiers. Il existe également des nombres à virgule flottante. La différence est que les nombres à virgule flottante peuvent avoir une partie décimale et les nombres entiers n'en ont pas :

var1 = 13
var2 = 15.65
print("var1 is of type ", type(var1))
print("var2 is of type ", type(var2))

Les entiers et les nombres à virgule flottante peuvent être mélangés sans problème :

total = var1 + var2
print(total)
print(type(total))

Parce que var2 est un flottant, Python décide automatiquement que le résultat doit également être un flottant. Mais il y a des cas où Python ne sait pas quel type utiliser. Par exemple :

varA = "hello 123"
varB = 456
print(varA + varB)

Il en résulte une erreur, varA est une chaîne de caractères et varB est un entier et Python ne sait pas quoi faire. Cependant, nous pouvons forcer Python à convertir entre les types :

varA = "hello"
varB = 123
print(varA + str(varB))

Maintenant que les deux variables sont des chaînes de caractères, l'opération fonctionne. Notez que nous avons "stratifié" varB au moment de l'affichage, mais nous n'avons pas changé varB elle-même. Si nous voulions transformer varB de façon permanente en une chaîne de caractères, nous aurions besoin de faire ceci :

varB = str(varB)

Nous pouvons également utiliser int() et float() pour convertir en entier et en flottant si nous voulons :

varA = "123"
print(int(varA))
print(float(varA))

Vous devez avoir remarqué que nous avons utilisé la commande print() de plusieurs manières. Nous avons affiché des variables, des sommes, plusieurs choses séparées par des virgules et même le résultat d'une autre commande Python. Peut-être avez vous aussi vu que ces deux commandes :

type(varA)
print(type(varA))

ont le même résultat. C'est parce que nous sommes dans l'interpréteur et tout est automatiquement affiché. Lorsque nous écrivons des programmes plus complexes qui s'exécutent en dehors de l'interpréteur, ils ne s'affichent pas automatiquement, nous devons donc utiliser la commande print(). Dans cet esprit arrêtons de l'utiliser ici. Désormais, nous écrirons simplement :

myVar = "hello friends"
myVar

En haut

Les Listes (Tableaux)

Un autre type de données utile est le type list. Une liste est une collection d'autres données. Pour définir une liste nous utilisons [ ] :

myList = [1, 2, 3]
type(myList)
myOtherList = ["Bart", "Frank", "Bob"]
myMixedList = ["hello", 345, 34.567]

Comme vous pouvez le voir, une liste peut contenir tout type de données. Vous pouvez faire beaucoup de choses avec une liste. Par exemple, compter ses articles :

len(myOtherList)

Ou récupérez un élément :

myName = myOtherList[0]
myFriendsName = myOtherList[1]

Alors que la commande len() renvoie le nombre total d'éléments dans une liste, le premier élément d'une liste est toujours à la position 0, donc dans notre myOtherList "Bob" sera en position 2. Nous pouvons faire beaucoup plus avec des listes tel que le tri, la suppression ou l'ajout d'éléments.

Fait intéressant, une chaîne de caractères est très similaire à une liste de caractères en Python. Essayez de faire ceci :

myvar = "hello"
len(myvar)
myvar[2]

Habituellement ce que vous pouvez faire avec des listes peut également être fait avec les chaînes de caractères. En fait, les listes et les chaînes de caractères sont des séquences.

Outre les chaînes de caractères, les entiers, les flottants et les listes, il existe davantage de types de données intégrés, tels que les dictionnaires et vous pouvez même créer vos propres types de données avec des classes.

En haut

L'indentation

Une utilisation importante des listes est la possibilité de « les parcourir » et de faire quelque chose avec chaque élément. Par exemple, regardez ceci :

alldaltons = ["Joe", "William", "Jack", "Averell"]
for dalton in alldaltons:
    print(dalton + " Dalton")

Nous avons itéré (jargon de programmation) à travers notre liste avec la commande for in et avons fait quelque chose avec chacun des éléments. Notez la syntaxe spéciale: la commande for se termine par : indiquant que ce qui suit sera un bloc d'une ou plusieurs commandes. Dans l'interpréteur, immédiatement après avoir entré la ligne de commande se terminant par :, l'invite de commande passera à ..., ce qui signifie que Python sait qu'il y a plus à venir.

Comment Python saura-t-il combien de lignes suivantes devront être exécutées à l'intérieur de l'opération for in ? Pour cela, Python s'appuie sur l'indentation. Les lignes suivantes doivent commencer par un espace vide, ou plusieurs espaces vides, ou une tabulation, ou plusieurs tabulations. Et tant que l'indentation reste la même, les lignes seront considérées comme faisant partie du bloc for in. Si vous commencez une ligne avec 2 espaces et la suivante avec 4, il y aura une erreur. Lorsque vous avez terminé, écrivez simplement une autre ligne sans retrait, ou appuyez sur Entrée pour revenir du bloc for in.

L'indentation facilite également la lisibilité du programme. Si vous utilisez de grandes indentations (par exemple des tabulations au lieu d'espaces) lorsque vous écrivez un gros programme, vous aurez une vue claire de ce qui est exécuté en son sein. Nous verrons que d'autres commandes utilisent également des blocs de code indentés.

La commande for in peut être utilisée pour de nombreuses choses qui doivent être effectuées plusieurs fois. Elle peut par exemple être combinée avec la commande range() :

serie = range(1, 11)
total = 0
print("sum")
for number in serie:
    print(number)
    total = total + number
print("----")
print(total)

Si vous avez exécuté les exemples de code dans un interpréteur par copier-coller, vous trouverez que le bloc de texte précédent générera une erreur. À la place copiez à la fin du bloc en retrait, c'est-à-dire à la fin de la ligne total = total + number, puis collez-la dans l'interpréteur. Dans l'interpréteur appuyez sur Entrée jusqu'à ce que l'invite à trois points disparaisse et que le code s'exécute. Copiez ensuite les deux dernières lignes suivies d'une autre Enter. La réponse finale devrait apparaître.

Si vous tapez dans l'interpréteur help(range), vous verrez :

range(...)
    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers

Ici les crochets indiquent un paramètre facultatif. Cependant tous devraient être des nombres entiers. Ci-dessous nous forcerons le paramètre step à être un entier en utilisant int() :

number = 1000
for i in range(0, 180 * number, int(0.5 * number)):
    print(float(i) / number)

Un autre exemple range() :

alldaltons = ["Joe", "William", "Jack", "Averell"]
for n in range(4):
    print(alldaltons[n], " is Dalton number ", n)

La commande range() a également cette particularité étrange qu'elle commence par 0 (si vous ne spécifiez pas le numéro de départ) et que son dernier numéro sera le numéro (n-1) du dernier numéro (n) que vous avez spécifié. Bien sûr, cela fonctionne aussi avec d'autres commandes Python. Par exemple :

alldaltons = ["Joe", "William", "Jack", "Averell"]
total = len(alldaltons)
for n in range(total):
    print(alldaltons[n])

Une autre utilisation intéressante des blocs d'indentation est la commande if. Cette commande exécute un bloc de code uniquement si une certaine condition est remplie, par exemple :

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Joe" in alldaltons:
    print("We found that Dalton!!!")

Bien sûr cela affichera toujours l'expression, mais essayez de remplacer la deuxième ligne par :

if "Lucky" in alldaltons:

Alors rien n'est affiché. Nous pouvons également préciser avec une instruction else :

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Lucky" in alldaltons:
    print("We found that Dalton!!!")
else:
    print("Such Dalton doesn't exist!")

En haut

Les Fonctions

Il existe très peu de commandes Python standard et nous en connaissons déjà plusieurs. Mais vous pouvez créer vos propres commandes. En fait, la plupart des modules supplémentaires que vous pouvez connecter à votre installation Python le font déjà, ils ajoutent des commandes que vous pouvez utiliser. Une commande personnalisée en Python s'appelle une fonction et se présente comme suit :

def printsqm(myValue):
    print(str(myValue) + " square meters")

printsqm(45)

La commande def() définit une nouvelle fonction, vous lui donnez un nom et à l'intérieur de la parenthèse vous définissez les arguments que la fonction utilisera. Les arguments sont des données qui seront transmises à la fonction. Par exemple, observez la commande len(). Si vous écrivez simplement len(), Python vous dira qu'il a besoin d'un argument. Ce qui est évident: vous voulez connaître la longueur de quelque chose. Si vous écrivez len(maListe) alors maListe est l'argument que vous passez à la fonction len(). Et la fonction len() est définie de telle manière qu'elle sait quoi faire avec cet argument. Nous avons fait la même chose avec notre fonction printsqm.

Le nom myValue peut être n'importe quoi et il ne sera utilisé qu'à l'intérieur de la fonction. C'est juste un nom que vous donnez à l'argument pour que vous puissiez en faire quelque chose. En définissant des arguments, vous indiquez également à la fonction combien en attendre. Par exemple, si vous procédez ainsi :

printsqm(45, 34)

Il y aura une erreur. Notre fonction a été programmée pour recevoir un seul argument, mais elle en a reçu deux, 45 et 34. Essayons un autre exemple:

def sum(val1, val2):
    total = val1 + val2
    return total

myTotal = sum(45, 34)

Ici nous avons créé une fonction qui reçoit deux arguments, les additionne et renvoie cette valeur. Renvoyer quelque chose est très utile, car nous pouvons faire quelque chose avec le résultat, comme le stocker dans la variable myTotal.

En haut

Les Modules

Maintenant que vous avez une bonne idée du fonctionnement de Python, vous aurez besoin de savoir encore une chose: comment travailler avec des fichiers et des modules.

Jusqu'à présent, nous avons écrit les instructions Python ligne par ligne dans l'interpréteur. Cette méthode n'est évidemment pas adaptée aux programmes plus importants. Normalement le code des programmes Python est stocké dans des fichiers avec l'extension .py. Ce ne sont que des fichiers de texte brut et n'importe quel éditeur de texte (Linux gedit, emacs, vi ou même le bloc-notes Windows) peut être utilisé pour les créer et les modifier.

Il existe plusieurs façons d'exécuter un programme Python. Sous Windows, faites simplement un clic droit sur votre fichier, ouvrez-le avec Python et exécutez-le. Mais vous pouvez également l'exécuter à partir de l'interpréteur Python lui-même. Pour cela, l'interprète doit savoir où se trouve votre programme. Dans FreeCAD, le moyen le plus simple consiste à placer votre programme dans un dossier que l'interpréteur Python de FreeCAD connaît par défaut, tel que le dossier utilisateur Mod de FreeCAD :

  • Sous Linux, il s'agit généralement de /home/<username>/.local/share/FreeCAD/Mod/ (version 0.20 et suivantes) ou /home/<username>/.FreeCAD/Mod/ (version 0.19 et précédentes).
  • Sous Windows, il s'agit de %APPDATA%\FreeCAD\Mod\, qui est généralement C:\Utilisateurs\<nom_utilisateur>\Appdata\ Roaming\FreeCAD\Mod\.
  • Sous macOS, il s'agit généralement de /Users/<username>/Library/Application Support/FreeCAD/Mod/.

Ajoutons un sous-dossier appelé scripts puis écrivons un fichier comme celui-ci :

def sum(a,b):
    return a + b

print("myTest.py succesfully loaded")

Enregistrez le fichier sous myTest.py dans le dossier scripts et dans la fenêtre de l'interpréteur, écrivez :

import myTest

sans l'extension .py. Cela exécutera le contenu du fichier, ligne par ligne, comme si nous l'avions écrit dans l'interpréteur. La fonction sum (somme) sera créée et le message sera affiché. Les fichiers contenant des fonctions, comme les nôtres, sont appelés modules.

Lorsque nous écrivons une fonction sum() dans l'interpréteur, nous l'exécutons comme ceci :

sum(14, 45)

Mais lorsque nous importons un module contenant une fonction sum() la syntaxe est un peu différente :

myTest.sum(14, 45)

Autrement dit, le module est importé en tant que "conteneur" et toutes ses fonctions se trouvent à l'intérieur de ce conteneur. Ceci est très utile, car nous pouvons importer de nombreux modules et garder tout bien organisé. Fondamentalement, lorsque vous voyez something.somethingElse, avec un point entre les deux, cela signifie que somethingElse est à l'intérieur something.

Nous pouvons également importer notre fonction sum() directement dans l'espace principal de l'interpréteur :

from myTest import *
sum(12, 54)

Presque tous les modules le font: ils définissent des fonctions, de nouveaux types de données et classes que vous pouvez utiliser dans l'interpréteur ou dans vos propres modules Python, car rien ne vous empêche d'importer d'autres modules à l'intérieur de votre module !

Comment savons-nous quels modules nous avons, quelles fonctions sont à l'intérieur et comment les utiliser (c'est-à-dire, de quel type d'arguments elles ont besoin) ? Nous avons déjà vu que Python possède une fonction help(). Faites :

help("modules")

nous donnera une liste de tous les modules disponibles. Nous pouvons importer n'importe lequel d'entre eux et parcourir leur contenu avec la commande dir() :

import math
dir(math)

Nous verrons toutes les fonctions contenues dans le module math, ainsi que des choses étranges nommées __doc__, __file__, __name__. Chaque fonction d'un module bien construit a un __doc__ qui explique comment l'utiliser. Par exemple, nous voyons qu'il y a une fonction sin() à l'intérieur du module mathématique. Vous voulez savoir comment l'utiliser ?

print(math.sin.__doc__)

Cela peut ne pas être évident, mais de chaque côté de doc se trouvent deux caractères de soulignement.

Et enfin une dernière astuce : lorsque vous travaillez sur du code nouveau ou existant, il est préférable de ne pas utiliser l'extension de fichier de macro FreeCAD, .FCMacro, mais plutôt d'utiliser l'extension standard .py. En effet, Python ne reconnaît pas l'extension .FCMacro. Si vous utilisez .py, votre code peut être facilement chargé avec import, comme nous l'avons déjà vu et également rechargé avec importlib.reload() :

import importlib
importlib.reload(myTest)

Il existe cependant une alternative :

exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())

En haut

Démarrer avec FreeCAD

Espérons que vous avez maintenant une bonne idée du fonctionnement de Python et que vous pouvez commencer à explorer ce que FreeCAD a à offrir. Les fonctions Python de FreeCAD sont toutes bien organisées en différents modules. Certains d'entre eux sont déjà chargés (importés) lorsque vous démarrez FreeCAD. Essayez simplement :

dir()

En haut

Notes

  • FreeCAD a été initialement conçu pour fonctionner avec Python 2. Puisque Python 2 a atteint la fin de sa vie en 2020, le développement futur de FreeCAD se fera exclusivement avec Python 3 et la compatibilité descendante ne sera pas prise en charge.
  • Beaucoup plus d'informations sur Python peuvent être trouvées dans le tutoriel Python officiel et la référence officielle Python.

En haut