Introduction to Python/fr: Difference between revisions

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

{{Docnav/fr
|[[Scripts/fr|Scripts]]
|[[Python_scripting_tutorial/fr|Tutoriel sur les scripts Python]]
}}

{{TOCright}}

==Introduction==

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
[http://fr.wikipedia.org/wiki/Python_%28programming_language%29 Python], qui est un [http://fr.wikipedia.org/wiki/Programming_language 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.
Python a de nombreuses fonctionnalités qui le différencie des autre langages de programmation, et est facilement accessible à celui qui veut se lancer dans la programmation.
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 spécialement pour être facile à lire par les êtres humains, il est ainsi 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é. C'est-à-dire que contrairement aux langages compilés comme le C, votre programme n'a pas besoin d'être compilé pour être exécuté. Le code que vous écrivez peut être directement exécuté, une ligne après l'autre si vous le souhaitez. Cela permet de l'apprendre et de trouver les erreurs dans votre code facilement, parce que vous avancez lentement, une étape après l'autre.
* 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 langage de script. FreeCAD possède un interpréteur Python intégré, vous pouvez ainsi y écrire du code Python. Cela permet de manipuler des éléments de FreeCAD, par exemple de créer des objets géométriques. Il s'agit d'une fonction extrêmement puissante, parce qu'au lieu de se contenter de cliquer sur un bouton appelé "Créer une sphère", qu'un programmeur aurait placé là pour vous, vous avez la possibilité de créer simplement vos propres outils pour générer exactement les objets géométriques que vous souhaitez.
* 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 Python et étendre ses fonctionnalités. Par exemple, il existe un module qui permet à Python de lire et d'écrire des images jpg, de communiquer avec twitter, de planifier des tâches exécutées pour 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.
Nous vous encourageons vivement à entrer les extraits de code ci-dessous dans un interpréteur Python. Pour beaucoup de nos exemples, le point important est la ligne après l'exécution du code, le résultat.
Et maintenant au travail ! Soyez conscient que ce qui suit est une introduction simplifiée, et en aucun cas un tutoriel complet. Mais nous espérons qu'après cette lecture vous aurez acquis les bases nécessaires pour connaître et exploiter plus profondément les mécanismes de FreeCad.


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


Habituellement, lors de l'écriture d'un programme informatique, il suffit d'ouvrir votre environnement de programmation préféré qui, est dans la plupart des cas, un éditeur de texte avec plusieurs outils autour de lui, écrire votre programme, puis le compiler et l'exécuter. Lorsque vous avez fait des erreurs pendant l'écriture, votre programme ne fonctionnera pas! et vous obtiendrez un message d'erreur vous indiquant ce qu'il s'est passé. Ensuite, vous revenez à votre éditeur de texte, corrigez les erreurs, exécutez à nouveau, et ainsi de suite jusqu'à ce que votre programme fonctionne parfaitement.
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 exécuté de manière transparente dans l'interpréteur Python. L’interpréteur Python est une fenêtre avec une invite de commande, vous pouvez simplement y taper votre code Python. Si vous installez Python sur votre ordinateur ([http://www.python.org/download/ téléchargez] le depuis le site web Python si vous êtes sous Windows ou Mac, installez le à partir des gestionnaire de paquets, si vous êtes sous GNU / Linux), vous aurez l'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, 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 FreeCAD dispose également d'un interpréteur Python intégré, vous n'êtes donc pas obligé de l'installer, cet interpréteur est visible dans la fenêtre inférieure (Si vous ne voyez pas cette fenêtre, cliquez sur '''Affichage->Vues->Console Python'''). Tous ces exemples ont été relu à partir de l'interpréteur disponible dans FreeCad.
Mais comme déjà mentionné, FreeCAD dispose également d'un interpréteur Python intégré : la [[Python_console/fr|console Python]].


[[Image:Screenshot_pythoninterpreter.jpg]]
[[Image:FreeCAD_Python_console.png]]
{{Caption|La console Python FreeCAD}}


(SI vous ne l'avez pas, cliquez sur le menu Affichage --> Panneaux --> Console Python).
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 de Python installée, puis le symbole '''>>>''', qui est l'invite de commande pour entrer votre code Python. L'écriture du code dans l'interpréteur est très simple: une ligne, est une instruction. Lorsque vous appuyez sur {{KEY|ENTREE}}, votre ligne de code est exécuté (après avoir été instantanément compilé et cela de manière transparente pour vous).
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 :


Par exemple, écrivez ce code:
{{Code|code=
{{Code|code=
print "hello"
print("hello")
}}
}}

Ici '''print''' est une commande spéciale de Python qui signifie: affiche ce que je te demande. Lorsque vous pressez {{KEY|ENTREE}}, l'opération s’exécute et le message {{Variable|hello}} s'affiche à l'écran. Si vous effectuez 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=
print hello
print(hello)
}}
}}
Python vous dira qu'il ne sait pas ce qu'est {{Variable|hello}}. Les caractères '''"''' (guillemets) spécifient que le contenu est une chaîne de caractères qui doit être affichée. Sans les '''"''' (guillemets), la commande d'affichage de {{Variable|hello}} n'est pas reconnue comme du texte, mais comme un mot-réservé spécial de Python. L'important est, que vous obtenez immédiatement une notification d'erreur. En appuyant sur la {{KEY|flèche Haut}} (ou, dans l'interpréteur FreeCAD, {{KEY|CTRL + flèche Haut}}), vous pouvez revenir à la dernière commande que vous avez écrite 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é. Essayez :

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

ou, par exemple, imaginons que nous n'avons pas compris ce qui n'allait pas avec notre commande d'affichage "help" ci-dessus, nous allons demander des informations spécifiques sur la commande "print". Tapez :
{{Code|code=
{{Code|code=
help("print")
help("print")
}}
}}
Nous voilà devant une longue description sur la commande "print".


Vous obtiendrez une description longue et complète de tout ce que la commande {{incode|print()}} peut faire.
Maintenant, nous dominons totalement notre interpréteur, et nous pouvons commencer à travailler sérieusement.


Maintenant que vous comprenez l'interpréteur Python, nous pouvons continuer avec des choses plus sérieuses.
{{Top}}
<span id="Variables"></span>
==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 :
Of course, printing "hello" is not very interesting. More interesting is printing stuff you didn't know before, or let Python find for you. That's where the concept of the variable comes in. A variable is simply a value that you store under a name. For example, type this:

{{Code|code=
{{Code|code=
a = "hello"
a = "hello"
print a
print(a)
}}
}}

I guess you understood what happened, we "saved" the string "hello" under the name "a." Now, "a" is not an unknown name any more! We can use it anywhere, for example in the print command. We can use any name we want, just follow some simple rules, like not using spaces or punctuation. For example, we could write:
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=
hello = "my own version of hello"
hello = "my own version of hello"
print hello
print(hello)
}}
}}

See? now hello is not an undefined word any more. What if, by terrible bad luck, we choose a name that already exists in Python? Let's say we want to store our string under the name "print":
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=

print = "hello"
}}
Python is very intelligent and will tell us that this is not possible. It has some "reserved" keywords that cannot be modified. But our variables can be modified any time, that's why they are called variables, the contents can vary. For example:
{{Code|code=
{{Code|code=
myVariable = "hello"
myVariable = "hello"
print myVariable
print(myVariable)
myVariable = "good bye"
myVariable = "good bye"
print myVariable
print(myVariable)
}}
}}

Nous venons de changer la valeur de '''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=
var1 = "hello"
var1 = "hello"
var2 = var1
var2 = var1
print var2
print(var2)
}}
}}
Note that it is important to give meaningful names to your variables. After a while you won't remember what your variable named "a" represents. But if you named it, for example myWelcomeMessage, you'll easily remember its purpose. Plus your code is a step closer to being self-documenting.


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.
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 : NameError: name '' is not defined.


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.
Of course you must know that programming is useful to treat all kinds of data, and especially numbers, not only text strings. One thing is important, Python must know what kind of data it is dealing with. We saw in our print hello example, that the print command recognized our "hello" string. That is because by using the ", we told specifically the print command what follows next is a text string.

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


We can always check the data type of a variable with the special Python keyword type:
{{Code|code=
{{Code|code=
myVar = "hello"
myVar = "hello"
type(myVar)
type(myVar)
}}
}}

It will tell us the contents of myVar is 'str', short for string in Python jargon. We have also other basic types of data, such as integer and float numbers:
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:

{{Code|code=
{{Code|code=
firstNumber = 10
firstNumber = 10
secondNumber = 20
secondNumber = 20
print firstNumber + secondNumber
print(firstNumber + secondNumber)
type(firstNumber)
type(firstNumber)
}}
}}

This is much more interesting, isn't it? Now we have a powerful calculator! Look at how well it worked, Python knows that 10 and 20 are integer numbers. So they are stored as "int", and Python can do with them everything it can do with integers. Look at the results of this:
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 :

{{Code|code=
{{Code|code=
firstNumber = "10"
firstNumber = "10"
secondNumber = "20"
secondNumber = "20"
print firstNumber + secondNumber
print(firstNumber + secondNumber)
}}
}}

See? We forced Python to consider that our two variables are not numbers but mere pieces of text. Python can add two pieces of text together, but it won't try to find out any sum. But we were talking about integer numbers. There are also float numbers. The difference is that integer numbers don't have decimal part, while float numbers can have a decimal part:
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 :

{{Code|code=
{{Code|code=
var1 = 13
var1 = 13
var2 = 15.65
var2 = 15.65
print "var1 is of type ", type(var1)
print("var1 is of type ", type(var1))
print "var2 is of type ", type(var2)
print("var2 is of type ", type(var2))
}}
}}

Les types '''entier''' et à '''virgule flottante''', '''Int''' et '''Float''' peuvent être mélangés sans problème:
Les entiers et les nombres à virgule flottante peuvent être mélangés sans problème :

{{Code|code=
{{Code|code=
total = var1 + var2
total = var1 + var2
print total
print(total)
print type(total)
print(type(total))
}}
}}

Of course the total has decimals, right? Then Python automatically decided that the result is a float. In several cases such as this one, Python automatically decides what type to use. In other cases it doesn't. For example:
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.
Par exemple :

{{Code|code=
{{Code|code=
varA = "hello 123"
varA = "hello 123"
varB = 456
varB = 456
print varA + varB
print(varA + varB)
}}
}}

This will give us an error, varA is a string and varB is an int, and Python doesn't know what to do. However, we can force Python to convert between types:
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 :

{{Code|code=
{{Code|code=
varA = "hello"
varA = "hello"
varB = 123
varB = 123
print varA + str(varB)
print(varA + str(varB))
}}
}}

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:
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 :

{{Code|code=
{{Code|code=
varB = str(varB)
varB = str(varB)
}}
}}

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

{{Code|code=
{{Code|code=
varA = "123"
varA = "123"
print int(varA)
print(int(varA))
print float(varA)
print(float(varA))
}}
}}
'''Note au sujet des commandes Python'''


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 :
You must have noticed that in this section we used the print command in several ways. We printed variables, sums, several things separated by commas, and even the result of other Python command such as type(). Maybe you also saw that doing those two commands,

{{Code|code=
{{Code|code=
type(varA)
type(varA)
print type(varA)
print(type(varA))
}}
}}

have exactly the same result. That is because we are in the interpreter, and everything is automatically printed. When we write more complex programs that run outside the interpreter, they won't print automatically, so we'll need to use the print command. From now on, let's stop using it here, it'll go faster. So we can simply write:
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 :

{{Code|code=
{{Code|code=
myVar = "hello friends"
myVar = "hello friends"
myVar
myVar
}}
}}
{{Top}}
You must have seen that most of the Python commands (or keywords) type(), int(), str(), etc. have parenthesis to limit the command contents. The only exception is the print command, which in fact is not really an exception, as it also works normally: print("hello"). However, since it is used often, the Python designers allowed a simpler version.
<span id="Lists"></span>

==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|[ ]}} :
Another interesting data type is a list. A list is simply a collection of other data. The same way that we define a text string by using " ", we define a list by using [ ]:

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

You see that it can contain any type of data. Lists are very useful because you can group variables together. You can then do all kinds of things within that group, for example counting them:
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 :

{{Code|code=
{{Code|code=
len(myOtherList)
len(myOtherList)
}}
}}

ou récupérer un objet de cette liste:
Ou récupérez un élément :

{{Code|code=
{{Code|code=
myName = myOtherList[0]
myName = myOtherList[0]
myFriendsName = myOtherList[1]
myFriendsName = myOtherList[1]
}}
}}
You see that while the len() command returns the total number of items in a list, their "position" in the list begins with 0. The first item in a list is always at position 0, so in our myOtherList, "Bob" will be at position 2. We can do much more with lists, you can read [http://www.diveintopython.net/native_data_types/lists.html here], such as sorting contents, removing or adding elements.


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.
A funny and interesting thing: a text string is very similar to a list of characters! Try doing this:

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

{{Code|code=
{{Code|code=
myvar = "hello"
myvar = "hello"
Line 178: Line 222:
myvar[2]
myvar[2]
}}
}}
Usually, what you can do with lists can also be done with strings. In fact both lists and strings are sequences.


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.
Outside strings, ints, floats and lists, there are more built-in data types, such as [http://www.diveintopython.net/native_data_types/index.html#d0e5174 dictionaries], or you can even create your own data types with [http://www.freenetpages.co.uk/hp/alan.gauld/tutclass.htm classes].

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.
{{Top}}
<span id="Indentation"></span>
==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 :
==L'Indentation==


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:
{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
for dalton in alldaltons:
for dalton in alldaltons:
print dalton + " Dalton"
print(dalton + " Dalton")
}}
}}
We iterated (programming jargon) through our list with the "for ... in ..." command and did something with each of the items. Note the special syntax: the '''for''' command terminates with ''':''' indicating the following will be a block of one of more commands. In the interpreter, immediately after you enter the command line ending with :, the command prompt will change to ... which means Python knows that a colon (:) ended line has happened and more is coming.


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.
How will Python know how many of the next lines will be to be executed inside the for...in operation? For that, Python uses indentation. That is, your next lines won't begin immediately. You will begin them with a blank space, or several blank spaces, or a tab, or several tabs. Other programming languages use other methods, like putting everything inside parenthesis, etc.
As long as you write your next lines with the '''same''' indentation, they will be considered part of the for-in block. If you begin one line with 2 spaces and the next one with 4, there will be an error.
When you finished, just write another line without indentation, or simply press Enter to come back from the for-in block


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}}.
Indentation is cool because it aids in program readability. If you use large indentations (for example use tabs instead of spaces because it's larger), when you write a big program you'll have a clear view of what is executed inside what. We'll see that commands other than for-in, can have indented blocks of code too.

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 {{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()}} :


For-in commands can be used for many things that must be done more than once. It can, for example, be combined with the range() command:
{{Code|code=
{{Code|code=
serie = range(1,11)
serie = range(1, 11)
total = 0
total = 0
print "sum"
print("sum")
for number in serie:
for number in serie:
print number
print(number)
total = total + number
total = total + number
print "----"
print("----")
print total
print(total)
}}
}}
(If you have been running the code examples in an interpreter by Copying and Pasting, you will find the previous block of text will throw an error. Instead, copy to the end of the indented block, i.e. the end of the line ''total = total + number'' and then paste to the interpreter. In the interpreter issue an <enter> until the three dot prompt disappears and the code runs. Then copy the final two lines into the interpreter followed by one or more <enter> The final answer should appear.)


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.
If you would type into the interpreter '''help(range)''' you would see:

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

{{Code|code=
{{Code|code=
range(...)
range(...)
Line 218: Line 266:
range(start, stop[, step]) -> list of integers
range(start, stop[, step]) -> list of integers
}}
}}

Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the range parameters to be an integer using 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=
number = 1000
decimales = 1000 # for 3 decimales
for i in range(0, 180 * number, int(0.5 * number)):
#decimales = 10000 # for 4 decimales ...
print(float(i) / number)
for i in range(int(0 * decimales),int(180 * decimales),int(0.5 * decimales)):
print float(i) / decimales
}}
}}

Ou des choses plus complexes comme ceci:
Un autre exemple {{incode|range()}} :

{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
for n in range(4):
for n in range(4):
print alldaltons[n], " is Dalton number ", n
print(alldaltons[n], " is Dalton number ", n)
}}
}}
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.


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 :
Par exemple:

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

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'''.
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 :

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

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

{{Code|code=
{{Code|code=
if "Lucky" in alldaltons:
if "Lucky" in alldaltons:
}}
}}

Il ne c'est rien affiché car la condition n'était pas remplie.
Alors rien n'est affiché. Nous pouvons également préciser avec une instruction {{incode|else}} :
Nous pouvons alors lui demander '''else''' (si la condition n'est pas remplie alors):

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

<span id="Functions"></span>
==Les Fonctions==
==Les Fonctions==


There are few [http://docs.python.org/reference/lexical_analysis.html#identifiers standard Python commands]. In the current version of Python, there are about 30, and we already know several of them. But imagine if we could invent our own commands? Well, we can, and it's extremely easy. In fact, most the additional modules that you can plug into your Python installation do just that, they add commands that you can use. A custom command in Python is called a function and is made like this:
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 :

{{Code|code=
{{Code|code=
def printsqm(myValue):
def printsqm(myValue):
print str(myValue)+" square meters"
print(str(myValue) + " square meters")

printsqm(45)
printsqm(45)
}}
}}
(Another copy and paste error, only copy through the end of the indented section i.e. '''" square meters"''' Paste to the interpreter, and issue <enter> until the three dot prompt goes a way, then copy and paste the final line.)


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}}.
Extremely simple: the def() command defines a new function. You give it a name, and inside the parenthesis you define arguments that we'll use in our function. Arguments are data that will be passed to the function. For example, look at the len() command. If you just write len() alone, Python will tell you it needs an argument. That is, you want len() of something, right? Then, for example, you'll write len(myList) and you'll get the length of myList. Well, myList is an argument that you pass to the len() function. The len() function is defined in such a way that it knows what to do with what is passed to it. Same as we did here.

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 :


The "myValue" name can be anything, and it will be used only inside the function. It is just a name you give to the argument so you can do something with it, but it also serves to tell the function how many arguments to expect. For example, if you do this:
{{Code|code=
{{Code|code=
printsqm(45,34)
printsqm(45, 34)
}}
}}
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.


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:
Maintenant, écrivez cette fonction:
{{Code|code=
def sum(val1,val2):
total = val1 + val2
return total


sum(45,34)
myTotal = sum(45,34)
}}
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.
Comme nous sommes dans l'interpréteur de Python, le résultat s'affiche en faisant:
{{Code|code=
{{Code|code=
sum(45,34)
def sum(val1, val2):
total = val1 + val2
}}
return total
will print the result on the screen, but outside the interpreter, since there is no print command inside the function, nothing would appear on the screen. You would need to:

{{Code|code=
print sum(45,34)
myTotal = sum(45, 34)
}}
}}
Voilà c'est affiché.

Pour plus de renseignements sur [http://www.diveintopython.net/getting_to_know_python/declaring_functions.html les autres possibilités des fonctions].


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}}.
{{Top}}
<span id="Modules"></span>
==Les Modules==
==Les Modules==


Maintenant, vous avez une idée du fonctionnement de Python: mais comment faire pour travailler avec les fichiers et 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 {{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.
Until now, we wrote Python instructions line by line in the interpreter, right? What if we could write several lines together, and have them executed all at once? It would certainly be handier for doing more complex things. And we could save our work too. Well, that too, is extremely easy. Simply open a text editor (such as the windows notepad, Linux gedit, emacs, or vi), and write all your Python lines, the same way as you write them in the interpreter, with indentations, etc. Then, save that file somewhere, preferably with a .py extension. That's it, you have a complete Python program. Of course, there are much better editors than notepad, but it is just to show you that a Python program is nothing else than a text file.

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 :
* 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}}).
* 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/}}.
Ajoutons un sous-dossier appelé {{FileName|scripts}} puis écrivons un fichier comme celui-ci :


To make Python execute that program, there are hundreds of ways. In windows, simply right-click your file, open it with Python, and execute it. But you can also execute it from the Python interpreter itself. For this, the interpreter must know where your .py program is. In FreeCAD, the easiest way is to place your program in a place that FreeCAD's Python interpreter knows by default, such as FreeCAD's bin folder, or any of the Mod folders. (In Linux, you probably have a directory /home/<username>/.FreeCAD/Mod, let's add a subdirectory to that called scripts where we will put the text file.) Suppose we write a file like this:
{{Code|code=
{{Code|code=
def sum(a,b):
def sum(a,b):
return a + b
return a + b


print "myTest.py succesfully loaded"
print("myTest.py succesfully loaded")
}}
}}


Enregistrez le fichier sous {{FileName|myTest.py}} dans le dossier {{FileName|scripts}} et dans la fenêtre de l'interpréteur, écrivez :
and we save it as myTest.py in our FreeCAD/bin directory (or on Linux to /home/<username>/.FreeCAD/Mod/scripts.) Now, let's start FreeCAD, and in the interpreter window, write:

{{Code|code=
{{Code|code=
import myTest
import myTest
}}
}}
'''sans''' l'extension .py.


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'''.
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.

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


Normalement, lorsque nous écrivons une fonction sum() dans l'interpréteur, nous l'exécutons simplement comme ceci,
{{Code|code=
{{Code|code=
sum(14,45)
sum(14, 45)
}}
}}
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.
Mais lorsque nous importons un module contenant une fonction {{incode|sum()}} la syntaxe est un peu différente :

Nous ferons:
{{Code|code=
{{Code|code=
myTest.sum(14,45)
myTest.sum(14, 45)
}}
}}
That is, the module is imported as a "container", and all its functions are inside. This is extremely useful, because we can import a lot of modules, and keep everything well organized. So, basically, everywhere you see '''something.somethingElse''', with a dot in between, that means '''somethingElse''' is inside '''something'''.


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}}.
We can also import our sum() function directly into the main interpreter space, like this:

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

{{Code|code=
{{Code|code=
from myTest import *
from myTest import *
sum(12,54)
sum(12, 54)
}}
}}
Basically all modules behave like that. You import a module, then you can use its functions: module.function(argument). Almost all modules do that: they define functions, new data types and classes that you can use in the interpreter or in your own Python modules, because nothing prevents you from importing other modules inside your module!


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 !
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().

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 :


Alors, dans l'interpréteur Python de FreeCad faisons:
{{Code|code=
{{Code|code=
help()
help("modules")
modules
}}
}}

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
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()}} :

{{Code|code=
{{Code|code=
import math
import math
dir(math)
dir(math)
}}
}}
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:
{{Code|code=
print math.sin.__doc__
}}
(It may not be evident, but on either side of doc are two underscore characters.)


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 ?
And finally one last little goodie: When we work on a new or existing module, it's best to replace the file extension with py such as: myModule.FCMacro => myModule.py. We often want to test it so we will load it as above.
{{Code|code=
{{Code|code=
print(math.sin.__doc__)
import myModule
myModule.myTestFunction()
}}
}}
But what if we see that myTestFunction() doesn't work correctly? We go back to our editor and make changes. Then, instead of closing and reopening the python interpreter, we can simply update the module like this:
{{Code|code=
reload(myModule)
}}
This file renaming is because Python doesn't know about the extension FCMacro.


Cela peut ne pas être évident, mais de chaque côté de {{incode|doc}} se trouvent deux caractères de soulignement.
However, there are two alternates: Inside the one macro use Python's exec or execfile functions.

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()}} :

{{Code|code=
{{Code|code=
import importlib
f = open("myModule","r")
importlib.reload(myTest)
d = f.read()
exec d
}}
ou
{{Code|code=
execfile "myModule"
}}
}}


Il existe cependant une alternative :
To share code across macros, you can access the FreeCAD or FreeCADGui module (or any other Python module) and set any attribute to it. This should survive the execution of the macro.

{{Code|code=
{{Code|code=
exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())
import FreeCAD
if hasattr(FreeCAD,"macro2_executed"):
...
else:
FreeCAD.macro2_executed = True # you can assign any value because we only check for the existence of the attribute
... execute macro2
}}
}}
{{Top}}

<span id="Starting_with_FreeCAD"></span>
==Démarrer avec FreeCAD==
==Démarrer avec FreeCAD==


Well, I think you now have a good idea of how Python works, and you can start exploring what FreeCAD has to offer. FreeCAD's Python functions are all well organized in different modules. Some of them are already loaded (imported) when you start FreeCAD. So, just do
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 :

{{Code|code=
{{Code|code=
dir()
dir()
}}
}}
{{Top}}
et lire dans l’interpréteur tous les modules chargés dans FreeCad, voir [[FreeCAD Scripting Basics/fr|Scripts de base dans FreeCad]]...
==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.
Of course, we saw here only a very small part of the Python world. There are many important concepts that we didn't mention. There are three very important Python reference documents on the net:
* the [http://docs.python.org/3/tutorial/index.html official Python tutorial with way more information than this one]
* 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}}
* the [http://docs.python.org/reference/ official Python reference]
* the [http://www.diveintopython.net Dive into Python] wikibook/ book.
Be sure to bookmark them!


{{Docnav/fr
|[[Scripts/fr|Scripts]]
|[[Python_scripting_tutorial/fr|Tutoriel sur les scripts Python]]
}}


{{Powerdocnavi{{#translation:}}}}
{{docnav/fr|[[Macros/fr|Macros]]|[[Python scripting tutorial/fr|Python scripting tutorial]]}}
[[Category:Developer Documentation{{#translation:}}]]

[[Category:Poweruser Documentation/fr]]
[[Category:Python Code{{#translation:}}]]

{{clear}}
<languages/>

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