Introduction to Python/fr

= Introduction to Python/fr =

Ceci est un petit tutoriel créé pour ceux qui veulent débuter en programmation Python, qui est un 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. 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.
 * Guido van Rossum a spécialement créé Python pour que quiconque puisse l'apprendre, lire et écrire du code très facilement.
 * C'est un langage interprété comme GW-BASIC il peut, pendant son exécution être suivi ligne par ligne pour pouvoir détecter la moindre erreur de programmation c'est, ce qui le rend différent des langages comme le C qui est un langage compilé avant d'être exécuté.
 * Il peut être incorporé dans d'autres langages informatiques sous forme de script. Un interpréteur Python est intégré dans FreeCad, ce qui vous permet d'écrire directement du code et de manipuler ou contrôler des procédures comme les géométries ou tout autres commandes comme par exemple cliquer sur le bouton "créer une sphère" qu'un programmeur a mis à la disposition de tous, vous pouvez librement créer facilement vos propres scripts pour créer vos propres géométries.
 * Il est extensible, vous pouvez facilement ajouter des modules dans Python et étendre ses fonctionnalités. Par exemple, vous avez des modules Python pour lire et écrire des images JPG, ou communiquer avec quelqu’un sur Twitter, pour planifier des tâches a accomplir directement par votre système d'exploitation et plein d'autres choses . ..

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



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, votre ligne de code est exécuté (après avoir été instantanément compilé et cela de manière transparente pour vous). Par exemple, écrivez ce code:

print "bonjour"

Ici print est une commande spéciale de Python qui signifie: affiche ce que je te demande. Lorsque vous pressez, l'opération s’exécute et le message "bonjour" s'affiche à l'écran. Si vous effectuez une erreur, par exemple, écrivez:

print bonjour

Python vous dira qu'il ne sait pas ce qu'est bonjour. 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 bonjour 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 (ou, dans l'interpréteur FreeCAD, ), vous pouvez revenir à la dernière commande que vous avez écrite et la corriger. L'interpréteur Python dispose également d'un système d'aide intégré. Voulez vous taper:

help

ou, par exemple, nous n'avons pas compris ce qui n'allait pas avec notre commande d'affichage "help" ci-dessus, et nous allons demander des informations spécifiques sur la commande "print": tapez

help("print")

Nous voilà devant une longue description sur la commande "print". Maintenant, nous dominons totalement notre interpréteur, et nous pouvons commencer à travailler sérieusement.

Les Variables
Bien sûr, vous vous dites que l'affichage de "bonjour" n'est pas très intéressant. Il peut y avoir alors des choses plus intéressantes comme par exemple, l'affichage de choses que vous ne savez pas, et laisser Python trouver ces choses pour vous. C'est là que le concept de "variable" entre en jeu. Une variable est tout simplement une valeur que vous stockez en mémoire avec un nom identificateur. Par exemple, tapez ceci:

a = "Bonjour" print a

Avez vous compris ce qui s'est passé ? Nous avons «sauvé» en mémoire la chaîne "bonjour" dans la variable qui porte le nom de a. Maintenant, a n'est plus un nom inconnu ! Nous pouvons maintenant l'utiliser n'importe où, comme par exemple dans la commande d'affichage à l'écran print. Nous pouvons dans Python utiliser n'importe quel nom que nous voulons, tout en respectant de simples règles, comme, ne pas utiliser d'espaces ou de signes de ponctuation. Par exemple, nous pouvons écrire:

hello = "ma version de bonjour" print hello

Compris ? maintenant hello n'est plus un mot inconnu. Que faire alors si, par inattention ou par méprise nous choisissons un nom qui existe dans Python? Admettons que nous voulons stocker notre chaîne sous le nom de "print":

print = "hello"

Python se rend compte immédiatement de l'erreur et vous signale qu'il est impossible de donner ce nom à votre variable. Il y a quelques restrictions dans Python, les mots "réservés" ne peuvent pas être modifiés! Mais, nos propres variables peuvent être modifiées à tout moment, c'est exactement pour cela qu'elles sont appelées variables, le contenu de la variable peut varier. Par exemple:

myVariable = "Bonjour" print myVariable myVariable = "Au revoir" print myVariable

Nous venons de changer la valeur de myVariable. Nous pouvons également copier des variables:

var1 = "Bonjour" var2 = var1 print var2

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. Plus de renseignements sur les variables Python

Les Nombres
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). 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:

myVar = "Bonjour" type(myVar)

Dans cet exemple, il s'affiche dans la console Python  dans le langage informatique on dit qu'il est de type "string" (chaîne de caractères alphabétiques). Il y a d'autres types de données, par exemple: les nombres entier (integer), les nombres à virgule flottante (float). . .:

premierNombre = 10 secondNombre = 20 print premierNombre + secondNombre type(premierNombre)

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:

premierNombre = "10" secondNombre = "20" print premierNombre + secondNombre type(premierNombre)

Vu ? 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: var1 = 13 var2 = 15.65 print "var1 est de type ", type(var1) print "var2 est de type ", type(var2)

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

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

Naturellement, la somme comporte des décimales, vrai? 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:

varA = "bonjour 123" varB = 456 print varA + varB

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:

varA = "hello" varB = 123 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:

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 Pour la conversion, il faut faire:

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

Pour cet exemple, la conversion n'est faite que pour l'affichage, pour une conversion permanente, il faut faire:

varA = "123" varA = int(varA) ou varA = float(varA) Note au sujet des commandes Python

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,

type(varA) print type(varA)

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:

myVar = "Salut copain" myVar

Attention, Python est sensible à la casse, myVar est différent de myvar !!! Vous avez remarqué que la plupart des commandes Python (ou mots-réservés) que nous connaissons ont des parenthèses, qui sont utilisées pour dire avec quoi la commande doit travailler: type, int, str. . . etc. La seule exception est la commande print, qui en vérité ne l'est pas car, elle peut fonctionner aussi bien avec ou sans parenthèses. Exemple: print ("bonjour") print "bonjour"

Les Listes (Tableaux)
Un autre type de données intéressant, est le type list. Le type list est simplement une liste 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):

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

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:

len(myOtherList)

ou récupérer un objet de cette liste:

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

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 d'autres renseignements sur List. PS: une chaîne de texte est très semblable à une liste et chaque caractère peut être adressé séparément! Essayez ce code:

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

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. 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 dictionnaires. Vous pouvez même créer vos propres types de données avec des classes.

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. Entrez ce code dans la console:

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

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. Après avoir frappé derrière le " : ", l'invite de commande va changer en " ... " ce qui indique à Python que la suite sera une partie de celui-ci. 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. 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. Créer des indentations permet aussi d'éclaircir la lecture code dans le cas de grands programmes. Nous allons voir que de nombreuses autres commandes indentées peuvent avoir des blocs de code aussi. 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:
 * >>> alldaltons = ["Joe", "William", "Jack", "Averell"]
 * >>> for dalton in alldaltons:
 * ... print dalton + " Dalton"

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

Ou des choses plus complexes comme ceci:

alldaltons = ["Joe", "William", "Jack", "Averell"] for n in range(4): 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. Par exemple:

alldaltons = ["Joe", "William", "Jack", "Averell"] total = len(alldaltons) for n in range(total): 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.

alldaltons = ["Joe", "William", "Jack", "Averell"] if "Joe" in alldaltons: print "OK c'est bien un Dalton !!!"

C'est bien, ce code affiche "OK il c'est bien un Dalton !!!" car la condition est exacte. Mais maintenant essayons cette ligne:

if "Lucky" in alldaltons:

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

alldaltons = ["Joe", "William", "Jack", "Averell"] if "Lucky" in alldaltons: print "OK c'est bien un Dalton !!!" else: print "Désolé ce n'est pas un Dalton !"

Résumé: PS: ne pas oublier le " : " derrière else:.
 * if (si) "Lucky" est dans alldaltons:
 * alors "OK c'est bien un Dalton !!!"
 * else: (si non)
 * alors "Désolé ce n'est pas un Dalton !"

Les Fonctions
Il n'y a pas beaucoup 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:

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

Extrêmement simple ! Le mot réservé "def" crée une nouvelle fonction dans Python. Vous lui donnez un nom, dans l'exemple: "printsqm". Dans les parenthèses, la variable qui va transmettre les données à la fonction, dans l'exemple: "myValue". A l'intérieur de la fonction (donc après le " : " et une indentation), vous définissez les formules, les données ou tout ce que vous voulez transformer et que la fonction va vous retourner. Par exemple, regardez la commande (ou mot réservé) len. Si vous écrivez len simplement, Python affichera "TypeError: len takes exactly one argument (0 given)" il vous dit, vous voulez len de quelque chose alors j'ai besoin d'un argument pour l'exécuter ! Puis, par exemple, vous allez écrire len("William") et vous en obtiendrez la longueur. Alors, "William" ou une variable est un argument que vous passez à la len. La fonction len est définie de telle manière qu'elle sait exactement quoi faire avec l'argument qui lui a été transmis. 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:

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. Maintenant, écrivez cette fonction:

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

Puis tapez:

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:

sum(45,34)

Mais une fois le programme terminé et exécuté hors de l'interpréteur il n'y aura pas d'affichage ! Pour afficher le résultat hors de l'interpréteur Python, il faut bien sûr utiliser la commande print. Alors il faudra faire:

print sum(45,34)

Voilà c'est affiché. Pour plus de renseignements sur les autres possibilités des fonctions.

Les Modules
Maintenant, vous avez une idée du fonctionnement de Python: mais comment faire pour travailler avec les fichiers et les modules. 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. 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 terminal d'OS X comme l'excellent Notepad++ (pour Windows) qui utilise la coloration syntaxique tout comme XCode (pour OS X) et ceci démontre qu'un programme Python n'est qu'un fichier texte. 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. Supposons que nous écrivions ce fichier programme:

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

print "test.py a bien été chargé"

et, nous allons l'enregistrer en "test.py" dans '''. . ./FreeCAD/bin'''. Maintenant, allons dans FreeCAD, et dans la fenêtre de l'interpréteur, écrivez:

import test

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. Normalement, lorsque nous écrivons une fonction sum dans l'interpréteur, nous l'exécutons simplement comme ceci,

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. Nous ferons:

test.sum(14,45)

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. 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. Nous pouvons aussi, importer et extraire notre fonction sum contenue dans "test.py" directement dans l’interpréteur, comme ceci:

from test import * sum(12,54)

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)). 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 des 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. Alors, dans l'interpréteur Python de FreeCad faisons:

help

Une fenêtre de dialogue s'ouvre, tapez

modules

Cliquez deux fois de suite sur  et, la liste de tous les modules disponibles s'affiche dans la console Python. ''PS:Les modules hors de "c:\program files\" ne s'affichent pas !! Si vous sauvez vos modules dans un répertoire "privé" autre que "c:\program files\", ils ne seront pas visibles dans la liste.''

Nous allons importer l'un d'eux. Nous pouvons même voir son contenu avec la commande dir

import math dir(math)

Nous voyons maintenant toutes les fonctions contenues dans le module math, ainsi que des trucs étranges comme:'' __ doc__, __ FILE__, __ name__. . . ''. 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. Vous voulez savoir comment utiliser cette fonction ? alors:

print math.sin.__doc__

Et si vous faites

help(math)

C'est tout le fichier math.py qui va s'afficher dans l'interpréteur Python. Et enfin, une dernier chose: Lorsque l'on travaille sur un nouveau module, nous avons besoin de le tester. Donc, une fois que nous avons écrit une partie du code, dans l'interpréteur Python, nous ferons:

import myModule myModule.myTestFunction

Mais que faire, si myTestFunction ne fonctionne pas correctement? Nous retournons à notre éditeur et nous le corrigeons. Puis, au lieu de fermer et de rouvrir l'interpréteur python, nous allons tout simplement mettre à jour le module comme ceci:

reload(myModule)

Démarrer avec FreeCAD
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:

dir

et lire dans l’interpréteur tous les modules chargés dans FreeCad, voir Scripts de base dans FreeCad...

Bien sûr, nous n'avons vu qu'une très petite partie de l'univers Python. Il existe de nombreux concepts importants que nous n'avons pas mentionné ici. Voici deux liens de référence de Python sur le net:

Pensez à en faire des onglets !
 * Le site officiel de Python (en)
 * Plongez dans le Wikibook/ Book de Python (en)
 * Wiki en français
 * Un autre aussi en français