Metafor

ULiege - Aerospace & Mechanical Engineering

User Tools

Site Tools


doc:user:tutorials:tuto0

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision
Previous revision
Last revisionBoth sides next revision
doc:user:tutorials:tuto0 [2013/07/12 15:42] – external edit 127.0.0.1doc:user:tutorials:tuto0 [2020/09/08 16:05] boman
Line 1: Line 1:
-====== Premiers pas avec python ======+====== Python in a nutshell ======
  
 +This section shows how to use [[doc:user:general:glossaire#Python]], the interpretor used by [[doc:user:general:glossaire#Metafor]], in a basic way. Ideally, [[http://www.python.org/|Python official website]] should be used.
  
-===== Introduction =====+Python is a powerful scripting language allowing the creation of input files in a very convenient way for the developer, but it might look a bit tedious for a new user.
  
-Cette section montre comment utiliser de manière basique l'interpréteur de [[doc:user:general:glossaire#Metafor]] ([[doc:user:general:glossaire#Python]]). L'idéal étant de se documenter sur le [[http://www.python.org/|site officiel de Python]], je sais, par expérience, que personne ne s'y réfère. Python est un langage extrêmement puissant qui permet de construire un [[doc:user:general:glossaire#jeu de données]] de manière très pratique pour le développeur. Elle paraîtra cependant un peu fastidieuse pour le simple utilisateur du code (mais ne sommes nous pas des ingénieurs?). 
  
 +===== Introduction =====
  
-===== L'interpréteur ===== +When Metafor is starteda window appears:
- +
- +
- +
-==== Introduction ==== +
- +
- +
-Lorsque Metafor est lancéune fenêtre apparaît: +
  
 {{ doc:user:metafor-console.png |L'interface graphique de Metafor}} {{ doc:user:metafor-console.png |L'interface graphique de Metafor}}
  
-On arrive alors dans "l'interpréteur de commandes"Il s'agit d'un [[doc:user:general:glossaire#interpréteur]] Python intégré dans Metafor qui permet de lancer des commandesun peu comme dans [[http://www.mathworks.com/|MATLAB]].+This window displays the command-line interpreterThis is a Python interpreter integrated within Metafor, allowing the user to type commands, in a similar way as in [[http://www.mathworks.com/|MATLAB]].
  
-Au dessuson remarque la liste des restrictions sur l'exécutable (limite en tempsen nombre de noeudsetc - ici, c'est une version full liée à une machine spécifique).+Above the interpretera list of all the restrictions associated with the executable is shown (time limitmaximal number of nodes...). The figure above corresponds to a full version associated to a specific computer.
  
-Après initialisation de Python, Metafor charge automatiquement le module ''toolbox.utilities'' qui contient une série de commandes très utiles (plus précisémentseules certaines fonctions de ''toolbox.utilities'' sont chargées pour éviter d'encombrer l'espace de noms "racine").+Once Python is initialized, Metafor automatically loads the module ''toolbox.utilities'', which contains a set of useful commandsTo be more accurate, only the most useful functions of this module are loaded, to avoid using too much space in the root namespace.
  
-Un [[doc:user:general:glossaire#jeu de données]] Metafor est une suite de commandes Python (on est loin de la convivialité d'une interface graphique de type [[doc:user:general:glossaire#samcef|Samcef Fields]] ou [[doc:user:general:glossaire#abaqus|Abaqus CAE]]). Cette manière de faire permet cependant d'obtenir une puissance extraordinaire pour le développement de modèles numériquesIl est en effet possible d'utiliser toutes les fonctions de Python pour arriver à créer rapidement et paramétrer un problème. Dans ce contexteles fonctionsles objetsles boucles, les structures conditionnelles peuvent être utilisées.+A Metafor [[doc:user:general:glossaire#input file]] is a series of Python commands. An obvious disadvantage of a python script is that it is less user-friendly than graphical interfaces of [[doc:user:general:glossaire#samcef|Samcef]] or [[doc:user:general:glossaire#abaqus|Abaqus CAE]]. However, in this context all Python tools (functionsobjectsloopsconditional structures, ...) can be used to easily create and parametrize a problem, leading to a very efficient way of developing numerical models.
  
-Un autre aspect intéressant de Python est sa possibilité d'interfacer du code compilé ([[doc:user:general:glossaire#C++]]) sans aucune intervention du programmeur (les modules ''wrap'' sont créés automatiquement à partir du source de Metafor). Python est donc l'outil idéal pour le développeur et pour l'utilisateur (averti).+Another interesting aspect of Python is its ability to interface compiled [[doc:user:general:glossaire#C++]] code without the help of the programmer (the modules ''wrap'' are automatically created from the C++ source code). Therefore, Python is ideal for both the developer and the (well-informeduser.
  
-Python est simple d'emploiOn peut par exemple l'utiliser comme calculatrice :+Python is quite simple. For example, it can be used as a calculator in interactive mode:
  
   >>> a=2   >>> a=2
Line 38: Line 31:
   >>>   >>>
  
-(attention: cela ne fonctionne sous cette forme que si vous n'utilisez pas "Metafor GUI" mais simplement "Metafor". Sous "Metafor GUI"la valeur de //c// est obtenue par la commande //print c//)+In a scriptthe correct syntax to get the value of ''c'' requires the command ''print(c)''.
-Ce système permet de paramétrer les jeux de données de Metafor. Il est donc très important de définir (comme dans n'importe quel programme) un ensemble de variables (les paramètres du modèle) et de travailler avec ces entités algébriques.+
  
-Pour voir le contenu de la mémoireutilisez ''dir()''+The definition of variables allows the parametrization of Metafor input files. Thereforeas with every other piece of software, it is important to first define a set of variables and then work with these algebraic variables. 
 + 
 +To display memory contents, use ''dir()''
  
   >>>> dir()   >>>> dir()
Line 48: Line 42:
   >>>   >>>
  
-On y voit les variables qu'on vient de créer et les fonctions de ''toolbox.utilities'' initialement importées (''meta'', ''vizu'', ...). ''__builtins__'' est un module contenant les fonctions de base de Python. Pour voir leur listeon utilise a nouveau ''dir()''+The three variables that were just created can be seen, and so can the ''toolbox.utilities'' functions that were automatically imported (''meta'', ''vizu'', ...). Finally, ''_''''_builtins_''''_'' is a module containing basic Python functionsTo see themthe function ''dir()'' is used again.
  
   >>> dir(__builtins__)   >>> dir(__builtins__)
Line 56: Line 50:
   'IndentationError', 'IndexError ...   'IndentationError', 'IndexError ...
  
-==== Types ==== +===== Types =====
  
-Le type des variables s'imprime par ''type(var)''Chaque variable est typée maiscontrairement aux langages [[doc:user:general:glossaire#Fortran]] ou C, le type peut varier au cours du temps.+The type of a variable is obtained with the command ''type(var)''Every variable has a type (also called a "class"), however in Python the type of a variable can change during the execution of the codeunlike in [[doc:user:general:glossaire#Fortran]] or C.
  
   >>> a=4   >>> a=4
   >>> type(a)   >>> type(a)
-  <type 'int'>+  <class 'int'>
   >>> a='text'   >>> a='text'
   >>> type(a)   >>> type(a)
-  <type 'str'>+  <class 'str'>
   >>>   >>>
  
-Des types peuvent être créés par l'utilisateur par l'intermédiaire des classes. Metafor utilise, en plus de ses propres types, les types de base (flottant, string, entierlistestuples, etc)Des opérateurs de conversion (cast) existentPar exemple ''int(2.3)'' donne 2. L'opérateur ''str(2.3)'' donne la chaîne de caractère "2.3".+Metafor uses the basic python types (float, string, integertuple, ...), but also its own types, which are defined by custom classes
  
 +Finally, variables can be converted from one type to another. For example, ''int(2.3)'' is 2, when ''str(2.3)'' gives the string "2.3".
  
  
-==== Fonctions ==== 
  
 +===== Functions =====
  
-L'interpréteur permet de créer des fonctionsCeci est très utile pour éviter notamment des couper/coller ou simplement pour écrire des algorithmes sous forme de scripts. Par exemple:+Simple functions can be created using the interpreterThis is quite useful to avoid any cut and paste, or simply to write algorithms as scripts. For example
  
   >>> def square(x): return x*x   >>> def square(x): return x*x
Line 84: Line 78:
   >>>   >>>
  
-Les fonctions sont un élément important dans l'élaboration d'un jeu de donnéesElles permettent de définir un ensemble d'opérations complexes et de les appeler plusieurs fois (par le même module ou par des modules différents)Par exemplesi on veut définir un problème possédant plusieurs [[doc:user:general:glossaire#matrice de contact|matrices de contact]] de même formeil sera très utile de paramétrer la création d'une matrice (définition des points, lignesetc) et de l'appeler plusieurs foisLes matériaux peuvent aussi être assignés à l'aide d'une fonctionpar exemple.+Functions are essential in the proper writing of an input fileThis way, complex operations may be defined and called several times, from the same module or even from other onesFor exampleif the numerical model contains several similar [[doc:user:general:glossaire#matrice de contact|contact matrices]], it is worth parametrizing the creation of a matrix (definition of its points, lines, ...)and then calling it several times with different arguments. Materials may also be assigned using functions.
  
-Python permet de définir des valeurs par défaut pour les paramètres d'une fonction:+Default values for the parameters of python functions may be set:
  
 <code python> <code python>
Line 93: Line 87:
 </code> </code>
  
-où ''a'', ''b'' et ''c'' sont des paramètres facultatifsPar exempleon peut appeler la fonction par:+where ''a'', ''b'' and ''c'' are optional parametersFor instancethis function may be called with the command :
  
   y = myfun(3, b=2)   y = myfun(3, b=2)
  
-Dans ce cas, ''x=3'', ''a=1'', ''b=2'' et ''c=0''+Here, ''x=3'', ''a=1'', ''b=2'' and ''c=0''
  
-Une autre manière d'écrire cette fonction utilise les fonctions ''lambda'':+This function may be written in another way, using the ''lambda'' functions :
  
   myfun = lambda x, a=1, b=1, c=0 : a*x*x+b*x+c   myfun = lambda x, a=1, b=1, c=0 : a*x*x+b*x+c
  
 +===== Modules =====
  
 +It is quite useful to gather several functions into a file, to form a [[doc:user:general:glossaire#module]] (one module is defined with one file). In Metafor, every [[doc:user:general:glossaire#test case]] is defined in a [[doc:user:general:glossaire#module]]. For example, the test case named ''cont2'' is located in ''Metafor/apps/qs/cont2.py'' and identified by ''apps.qs.cont2'' under Python.
  
- +By default, Python already contains many modules. For examplethe module called ''math'' defines all basic mathematical functionsTo use a module, the statement ''import'' must be used (for example, ''import math''). Thento use a function of the ''math'' modulethe point is used. For example, ''math.cos'' is the command used to compute a cosine
- +
- +
- +
-==== Modules ==== +
- +
-Il est souvent utile de regrouper une série de fonctions ensemble dans un fichier pour former un [[doc:user:general:glossaire#module]]. Un module est   défini par un fichier. Dans Metaforchaque [[doc:user:general:glossaire#cas-test]] est défini dans un [[doc:user:general:glossaire#module]]. Par exemple, le cas-test nommé ''cont2'' se trouve dans ''Metafor/apps/qs/cont2.py'' et est identifié par ''apps.qs.cont2'' sous Python+
- +
-Python possède d'origine beaucoup de modules prédéfinisPar exemplele module ''math'' définit les fonctions mathématiques de basePour utiliser un module, on utilise ''import'' (par exemple ''import math''). Pour voir le contenu d'un moduleon utilise ''dir(module)''. Pour utiliser une fonction de ''math'', on utilise le point (''math.cos'' par exemple pour calculer un cosinus):+
  
   >> import math   >> import math
   >>> dir(math)   >>> dir(math)
-  ['__doc__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', +  ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh',  
-  'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log' +  'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh',  
-  , 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']+  'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor',  
 +  ... 
 +  'sqrt', 'tan', 'tanh', 'tau', 'trunc']
   >>> math.cos(0.1)   >>> math.cos(0.1)
   0.99500416527802582   0.99500416527802582
   >>>   >>>
  
-Pour voir l'aide en ligne, c'est la commande ''help()'':+The online help is accessed with the command ''help()'':
  
   >>> help(math.cos)   >>> help(math.cos)
Line 134: Line 124:
       Return the cosine of x (measured in radians).       Return the cosine of x (measured in radians).
  
-''help(math)'' liste toutes les fonctions du module ''math''Cette aide en ligne bien précieuse est disponible également pour tous les modules de Metafor.+''help(math)'' enumerates all functions found in the ''math'' moduleThe online help is quite useful and also available for all Metafor modules.
  
-Il est possible d'importer toutes les fonctions de ''math'' dans l'espace de nom courant en effectuant:+It is also possible to import all functions found in ''math'' in the current namespace with the command:
  
   >>> from math import *   >>> from math import *
Line 143: Line 133:
   >>>   >>>
  
-Dans ce casle prefixe ''math'' n'est plus nécessaire (mais des conflits peuvent survenir avec d'autres modules qui définiraient une fonction ''cos'').+With this syntaxthe ''math'' prefix is no longer necessary. However, conflicts could occur with other modules if they also contain a function named ''cos''.
  
-Dans le cas de Metaforpour importer les classes du module Metafor, on utilise ''from wrap import *''On a ainsi accès aux fonctionnalités de Metafor dans Python. On peut aussi imaginer d'importer une liste de matériaux par la commande ''import toolbox.createMaterial''. Dans ce cas, le module ne contient plus des fonctions mais des objets.+To use mathematical functionsthe module ''math'' must be importedIn the same way, the functions which are used to build an input file in Metafor must be imported from the module ''wrap'', using the command ''from wrap import *''
  
 +===== Objects =====
  
- +Python is [[doc:user:general:glossaire#object-oriented]]. This means that classes can be createdTo make it shorta class is a structure containing datato which methods can be associatedFor example, to compute the length of a vector, a function can be defined :
- +
-==== Objets ==== +
- +
-Python est [[doc:user:general:glossaire#orienté objets]]. Cela signifie qu'il est possible de créer des classes. Une classe esten résumé, une structure de données à laquelle on associe des méthodes. Par exempleimaginons qu'on veuille calculer la longueur d'un vecteurOn peut définir une fonction du type:+
  
 <code python> <code python>
-def vectLength(x,y,z):+def vectLength(x, y, z):
     import math     import math
-    return math.sqrt(x*x+y*y+z*z)+    return math.sqrt(x*x + y*y + z*z)
 </code> </code>
  
-Remarquons ici que les blocs d'instructions sont définis par l'indentation en Python (contrairement au qui utilise les acolades)Finir un bloc se fait en diminuant l'indentation. Ceci peut paraître compliqué à première vue mais est très pratique à l'utilisation puisque les utilisateurs de Python sont obligés d'indenter leur code.+<note> 
 +At this point, it should be noted that a block of several instructions is defined with the indentation, in opposition to which uses bracesEnding a block is done by decreasing the indentation. It may sounds complicated at first, however this way Python users are forced to indent their code, making it more readable. 
 +</note>
  
-La fonction ''vectLength'' calcule la longueur du vecteur ''(x,y,z)''Ce n'est pas de l' "orienté objets" (pas d'encapsulation, l'utilisateur manipule directement les composantes du vecteur). Pour transformer ce code en "orienté objets"on peut créer une classe (c-à-d un nouveau "type"qui représentera un vecteur:+The function called ''vectLength'' computes the length of the vector ''(x,y,z)''However, this is not object-oriented, because the encapsulation principle is violated (the user is directly manipulating the components). In order to have an object-oriented code, a class (so a new type) representing this vector is created:
  
 <code python> <code python>
 class vector: class vector:
     def __init__(self,x,y,z):     def __init__(self,x,y,z):
-        self.x=x +        self.x = x 
-        self.y=y +        self.y = y 
-        self.z=z+        self.z = z
     def view(self):     def view(self):
-        print 'x=',self.x, ' y=',self.y, ' z=',self.z     +        print('x=', self.x, ' y=', self.y, ' z=', self.z    
     def length(self):     def length(self):
         import math         import math
-        return math.sqrt(self.x*self.x+self.y*self.y+self.z*self.z)+        return math.sqrt(self.x*self.x + self.y*self.y + self.z*self.z)
 </code> </code>
  
-Nous avons défini 3 [[doc:user#fonctions]] membres: ''__init__'' : le constructeur (voir plus bas)''view()'' qui affiche le vecteur en utilisant la fonction Python ''print'' et ''length'' qui retourne la longueurChaque fonction membre est définie à l'intérieur de la classe (cfr l'indentation).+Three methods (or member functions) have been defined: ''_''''_init_''''_'', the constructor (see below''view()'', displaying the vector using the function ''print'' ; and ''length'', returning the lengthEach method is defined within the class (see the indentation).
  
-Calculer la longueur d'un vecteur revient à créer un vecteur par la commande :+To compute the length of a vector, this vector is first created using the command
  
-  >>> v=vector(1,1,1)+  >>> v = vector(1, 1, 1)
  
-Cette commande appelle le constructeur de la classe ''vector'' (fonction membre ''__init__''). Notez que la fonction est définie avec 4 paramètres dont le premier est ''self'' (équivaut au pointeur ''this'' du C++) et que l'appel se fait avec 3 paramètres (le pointeur ''self'' est passé de manière implicite).+This command calls the constructor (method ''_''''_init_''''_''of the class named ''vector''It should be noted that this function is defined with four parameters, the first one being ''self'' (equivalent to the pointer ''this'' in C++), but called with only three parameters (the ''self'' pointer is passed implicitly).
  
   >>> type(v)   >>> type(v)
-  <type 'instance'>+  <class '__main__.vector'>
   >>> v.view()   >>> v.view()
   x= 1  y= 1  z= 1   x= 1  y= 1  z= 1
Line 193: Line 182:
   >>>   >>>
  
-Dans le cas de Metafor, l'utilisateur manipule des classes définies dans les modules contenus dans le répertoire ''wrap''Il est donc important de connaître la notion d'objet pour utiliser Metafor même si l'utilisateur peut écrire un jeu de données sans avoir recours à la création de ses propres objets.+When creating an input file in Metafor, the user manipulates classes defined in the modules found in the folder ''wrap''Therefore, the user should understand basic object-oriented programming, even if an input file may be written without defining new objects.
  
-==== Boucles - tuples - listes ==== 
  
-Dans un [[doc:user:general:glossaire#jeu de données]] Metaforcertaines opérations peuvent être répétitives. Il est par exemple intéressant de pouvoir mailler les courbes portant les numéros à 10. On utilise alors des boucles pour réduire la taille du fichierUne boucle s'écrit de la manière suivante:+===== Loop - tuples - lists ===== 
 + 
 +In a Metafor [[doc:user:general:glossaire#input file]], the same operation may be used several times in a row (for example, meshing the curves numbered from to 10)In such a case, loops are usedA loop is written as:
  
 <code python> <code python>
-for i in (1,6,8,12): +for i in (1, 6, 8, 12): 
-    print 'i=',i+    print('i=', i)
 </code> </code>
  
-où les valeurs entre parenthèses forment un "tuple"Cet exemple est une boucle où ''i'' vaudra successivement 1, 6, 8 et 12 (4 exécutions de la commande ''print'').+where the values in parentheses constitute a "tuple"In this example, "i" will successfully take the values 1, 6, 8 and 12, leading to four executions of the command ''print''.
  
-Il est possible également d'utiliser des listesDans ce cason utilise des crochets au lieu des parenthèsesA la différence des tuples, les listes sont modifiables.+Instead of tuples, lists may also be usedTo do sobrackets are used instead of parenthesesUnlike tuples, lists may be modified.
  
-Pour créer une listeil est souvent intéressant d'utiliser la fonction ''range(i,j,k)'' qui fonctionne comme ''i:k:j'' de Matlab et ''i j k'' de [[doc:user:general:glossaire#Bacon]] ([[doc:user:general:glossaire#Samcef]]).+To create a listthe function ''range(i, j, k)'' is quite often used. This function works as ''i:k:j'' in Matlab.
  
-  >>> range(1,10,2)+  >>> list(range(1, 10, 2))
   [1, 3, 5, 7, 9]   [1, 3, 5, 7, 9]
  
-Une liste peut être créée par définition:+A list may also be defined as :
  
   [ x for x in range(100) if x%3==0 ]   [ x for x in range(100) if x%3==0 ]
  
-donne tous les nombres divisibles par 3 de à 99.+leading to all numbers from to 99 which can be divided by 3.
  
  
-==== Structure conditionnelle ====+===== Conditional statements =====
  
-Il est parfois intéressant de paramétrer un jeu de données de manière complexe en utilisant des conditionsPar exempleon peut définir par exemple un paramètre booléen ''useLinearMaterial'' qui permet de choisir entre un comportement linéaire ou non du matériauCe paramètre sera facile à modifier (puisque placé au début du fichier de données) et entrainera la création conditionnelle d'un matériau linéaireCe type de structure fait intervenir la commande ''if''. Il s'utilise comme suit:+It may be useful to parametrize an input file in a complex way using conditional statementsFor examplea boolean ''useLinearMaterial'' can be defined, to choose whether the material behaves in an linear wayThis parameter, defined in the beginning of the input file, is easy to modify and leads to a conditional definition of a linear materialSuch a construct requires the command ''if'', which is used as 
  
 <code python> <code python>
 if x>100: if x>100:
-    print "x>100"+    print ("x>100")
 elif x>10: elif x>10:
-    print "x>10"+    print ("x>10")
 else: else:
-    print "x<=10"+    print ("x<=10")
 </code> </code>
    
  
-==== Remarques importantes ====+===== Important notes =====
  
  
-  * Les booléens "vrai" & "faux" se notent ''True'' et ''False'' (avec majuscule).+  * The ''True'' and ''False'' booleans are noted with capital letter.
  
-  * Si on effectue une opération de division entre 2 entiers, Python réagit comme la plupart des langages compilés (C, [[doc:user:general:glossaire#Fortran]]): il effectue une division ENTIERE. Autrement dit 2/3 = :!:, par exemplePour obtenir un nombre flottant en sortieon doit utiliser un flotant dans la division: soit 2.0/3, soit 2/3.0.+  * A number starting with corresponds to a number defined using the octal numeral systemFor example012 corresponds to 10 in decimal.
  
-  * Un nombre commençant par 0 est interprété en base octale: par exemple 012 donne 10 en décimal.+  * The command ''input('message')'' is used to ask the user to enter a value. This is useful to pause the input file, for example to view an intermediate mesh.
  
-  * La commande ''raw_input('message')'' permet de demander une valeur à l'utilisateur (utile pour faire une pause dans un jeu de données - par exemple lors d'une visualisation de maillage intermédiaire).+  * The function ''print(a, b, c)'' prints the objects ''a'', ''b'' et ''c'' on the same line, which can be quite useful for Metafor objects.
  
-  * La fonction ''print a,b,c'' imprime les objets ''a'', ''b'' et ''c'' sur la même ligne. Il est souvent très intéressant d'utiliser cette fonction sur les objets de Metafor.+  * The null command is named ''pass''.
  
-  * La commande nulle s'appelle ''pass''.+  * Several commands may be written on the same line if separated by a semicolon, as in C.
  
-  * Les commandes peuvent être écrites sur la même ligne en étant séparées par un point-virgule (comme en C). +  * Strings are defined with simple ('), double ("or triple quotation marks (""").
- +
-  * Les chaînes sont délimitées soit par des simples ('), doubles ("ou triples guillements (""").+
  
    
 +===== Conclusions =====
  
 +In this page, the basic use of [[doc:user:general:glossaire#Python]] in a Metafor context was shown. However, it is useful to read others sources in order to understand the language better. More complex objects and commands exist (dictionaries, I/O commands, ...) and can be used to improve the efficiency and clarity of an input file. 
  
 +After reading this introduction to Python, this language can be used to define a first input file in Metafor: 
  
-===== Conclusions =====+=> [[doc:user:tutorials:tuto1]]
  
  
-Ce document a montré la base de l'utilisation de [[doc:user:general:glossaire#Python]] dans le cadre de [[doc:user:general:glossaire#Metafor]]. Il est cependant très utile de lire d'autres sources d'informations pour compléter sa compréhension du langage. Des objets et des commandes plus complexes existent (dictionnaires, commandes I/O, commandes systèmes, expressions régulières, interface Tcl/Tk, etc) et peuvent être utilisées dans n'importe quel jeu de données pour améliorer sa lisibilité et son efficacité. N'hésitez pas à [[r_boman@yahoo.fr|me contacter]] si vous êtes intéressé par ces aspects avancés.  +[[test_python]]
- +
-Maintenant, vous en savez assez pour apprendre à utiliser  +
- +
-=> [[doc:user:tutorials:tuto1]]+
doc/user/tutorials/tuto0.txt · Last modified: 2020/09/08 16:26 by boman

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki