Python

Version

La version 3.11 est la version de référence actuellement.

Toute version supérieure ne devrait pas être choisie sans une excellente raison.

Installation

Il est possible d’installer une version via le Windows Store ou choisir la distribution Anaconda ou bien encore de l’installer en même temps que Visual Studio, ce qui revient à choisir la version officielle du Python.

Il utile de vérifier que la distribution de Python est appelable depuis une ligne de commande “cmd.exe” ou Powershell. Pour cela il faut souvent modifier le PATH Windows en y ajoutant une ou plusieurs clés. Les clés PYTHONPATH (vers le sous-répertoire “lib”) et PYTHONHOME (vers le répertoire d’installation général) sont utiles pour modifier la PATH de Windows car Python va les ajouter au moment de l’exécution.

Une autre voie est l’utilisation d’environnements virtuels

ou encore la modification temporaire du PATH avant d’utiliser Python avec une commande “set”

set PATH=%PATH%;C:\your\path\here\

(“setx” modifie le PATH de façon permanente - !!! droits d’administrateur requis au moment de l’exécution de cmd.exe !!!)

Exemple :

setPYTHONHOME=c:\Python39 setPYTHONPATH=c:\Python39\Lib setPATH=%PYTHONHOME%;%PATH%

La manière de modifier le PATH est parfois spécifique à une version de Windows.

PYTHONPATH et PYTHONHOME

PYTHONHOME Change the location of the standard Python libraries. By default, the libraries are searched in prefix/lib/pythonversion and exec_prefix/lib/pythonversion, where prefix and exec_prefix are installation-dependent directories, both defaulting to /usr/local.

When PYTHONHOME is set to a single directory, its value replaces both prefix and exec_prefix. To specify different values for these, set PYTHONHOME to prefix:exec_prefix.

PYTHONPATH Augment the default search path for module files. The format is the same as the shell’s PATH: one or more directory pathnames separated by os.pathsep (e.g. colons on Unix or semicolons on Windows). Non-existent directories are silently ignored.

In addition to normal directories, individual PYTHONPATH entries may refer to zipfiles containing pure Python modules (in either source or compiled form). Extension modules cannot be imported from zipfiles.

The default search path is installation dependent, but generally begins with prefix/lib/pythonversion (see PYTHONHOME above). It is always appended to PYTHONPATH.

An additional directory will be inserted in the search path in front of PYTHONPATH as described above under Interface options. The search path can be manipulated from within a Python program as the variable sys.path.

IDE

L’interface de développement de la version Intel est Visual Studio (choisir la version Community). Il est également possible d’utiliser VS Code qui est plus “léger” et, à l’utilisation, plus robuste. VisualStudio peut en effet parfois poser des problèmes (utilisation de mémoire en augmentation, plantage…)

La distribution anaconda propose Spyder comme outil par défaut mais peut poser des problèmes d’installation de paquets.

A côté des outils de programmation comme Visual Studio, VS Code ou Spyder, il est possible de programmer du script via un navigateur web au travers de Jupyter Notebook. Les notebooks permettent d’exécuter du code par bloc, de disposer de blocs de texte pour commentaires et de visualiser les graphiques dans l’ordre d’écriture.

En fonction des versions, il est parfois nécessaire d’installer les extensions Notebook via “conda install notebook” ou “pip install notebook”.

Savoir quelle version de Python est en cours d’utilisation

Vous pouvez exécuter “which python” dans une fenêtre de commande ou dans un powershell.

Vous pouvez également exécuter “python –version”

Aide du Python sur le Web

Attention que beaucoup de sites fournissent de l’aide pour la version 2 de Python.

La version actuelle est la version 3 qui est la seule supportée.

Certaines commandes ont changé !! Il faut donc vérifier avant de s’énerver. :-)

Environnements virtuels

Comme plusieurs versions du Python peuvent coexister sur une même machine, il peut être intéressant de se créer un environnement virtuel isolé.

Plus d’infos ici :

Dans une fenêtre de commande ou un powershell, il faut se placer dans le répertoire souhaité et lancer :

python -m venv env

avec “env” qui est le nom de l’environnement (à adapter en fonction de ses souhaits).

Il faut bien entendu que la commande “python” utilise la version souhaitée (si plusieurs coexistent).

Une fois que l’environnement est créé, il faut l’activer avec le script “env/Scripts/activate” (dans PowerShell) ou “”env/Scripts/activate.bat” (dans cmd).

On peut aussi le désactiver avec le script “env/Scripts/dectivate” (dans PowerShell) ou “”env/Scripts/deactivate.bat” (dans cmd).

Installation de paquets

En fonction de la version de Python utilisée, l’installation de paquets se fait avec “conda install xxx” ou “pip install xxx”.

La version Python d’Intel est normalement sous “Conda”.

Paquets utiles

voir les “requirements”

Mais les paquets suivants sont souvent utiles :

Pandas : gestion des fichiers type tableur Excel
Numpy : bibliothèque numérique
Matplotlib : créer des graphiques aussi beau qu’en Matlab :-)
Scipy : bibliothèque plus générale que Numpy (contient Numpy) avec notamment du calcul symbolique (Simpy)
Notebook : gestion du codage via navigateur web (fichier .ipynb)
Wxpython : intarfaçage graphique avec les WxWidgets
Pyopengl : possibilité de tracer des graphiques avec OpenGL
Json : mode de stockage de données sur disque très proche des dictionnaires Python

Parmi les modules “standards” de Python :

math (fonctions ceil(), floor(), fmod(), fsum(), exp(), log(), les cyclométriques sin,cos,tan…)
statistics (fonctions mean(), median(), quantiles(), variance(), stdev()…)
os (chdir(), mkdir(), listdir()…)
collections (OrderedDict …)

Dans un paquet/module, il est possible d’importer tout ou seulement une partie :

import module_name : lecture et exécution du fichier du module
import module_name as mn : mn devient un alias de module_name (ex : import numpy as np)
from module_name import myfunc : seule la fonction myfunc est accessible
from module_name import myclass : seule la classe myclass est accessible
from module_name import myvar : seule la variable myvar est accessible (ex. : from math import pi)
from module_name import * : toutes les méthodes et constantes sont importées. Il n’y a pas besoin de spécifier le nom du module pour les utiliser dans la suite du script)

Informations utiles

Documentation officielle : https://docs.python.org/fr/3.9/
Python est langage orienté objet
en Python, tout est “objet”.
Python est un langage indenté (4 espaces par niveau d’indentation). Par exemple, il n’y a pas de fin de test (if: else:), le seul fait de reculer dans l’indentation indique la fin du segment de code. La plupart des IDE gère très bien les indentations automatiques dès le saut de ligne après la commande.
Comme les objets sont omniprésents, Python privilégie les pointeurs plutôt qu’une copie. Cela peut être assez déroutant en venant d’autres langages de programmation plus “stricts” (Fortran/C/Matlab). Il faut donc bien faire attention à gérer des instances distinctes d’objets pour éviter des effets de bord non souhaités.
Les parenthèses () servent principalement pour les appels de fonctions/routines mais aussi pour définir un “tuple” (collection ordonnée et non modifiable)
Les crochets [] servent pour les vecteurs/matrices ou encore les listes (collection ordonnée et modifiable)
Les accolades {} permettent de définir des dictionnaires (permettant de stocker facilement des infos sous la forme d’une paire key:value, à clé unique) (collection ordonnée depuis version 3.7 et modifiable)
Dans les chemins d’accès sous Windows, il est nécessaire d’utiliser un double backslash (d:\\mydir\\myfile au lieu de d:\mydir\myfile). Si ce n’est pas le cas, la chaîne ‘\t’ serait interprétée comme une tabulation, ‘\n’ comme une nouvelle ligne… :-) Il est possible de se passer de ce double backslash si on transmet une chaîne “raw” avec l’opérateur “r” (exemple print(r’\t’) donnera \t comme résultat).
Python démarre sa numérotation à 0 et non à 1

Exemple : lecture/écriture d’un fichier texte

Pour lire un fichier texte en Python :

with open('myfile.txt') as f:
   mycontent = f.readlines()
   f.close()
   print(mycontent)

Cette commande va lire le contenu du fichier et créer une liste avec autant de valeurs que lignes. Chaque valeur se terminera par le caractère ‘\n’ indiquant que c’est bien une fin de ligne.

Si ce caractère ‘\n’ n’est pas souhaitable (et c’est souvent le cas) on peut utiliser la fonction strip() pour l’éliminer.

A la lecture, il est également possible d’utiliser une commande f.read().splitlines() qui va lire en une ligne l’entièreté du fichier dans une variable et ensuite scinder la variable sur base de ce caractère ‘\n’. Dès lors, plus besoin de nettoyer la chaîne lors de l’utilisation.

Il est aussi possible de lire le fichier ligne par ligne :

for line in open('myfile.txt'):
   print(line)
   print(line.strip())

A l’écriture, il ne faut pas oublier d’ajouter ‘\n’ si on souhaite changer de ligne.

file.write(your_string +'\\n')

ou par formattage :

lines = ['hello','world']
with open('filename.txt', "w") as fhandle:
   for line in lines:
      fhandle.write(f'{line}\n')

Commentaires dans un script Python

Une ligne peut être commentée avec le caractère #.

Il est également possible d’ajouter un commentaire en fin de ligne avec le même #.

Des commentaires multilignes sont également possibles en encadrant les lignes avec des triples “ ou ‘.

'''
   linecomment1

   linecomment2
'''

ou

"""
   linecomment1

   linecomment2
"""

Aide sur une fonction

Il est possible d’avoir de l’aide sur un module/fonction/méthode via help().

Dans les scripts personnels, une documentation est automatiquement générée sur base des commentaires utilisant les triples “ ou ‘. Elle est accessible via la fonction .__doc__ (attention au double underscore avant et après doc).

Typage des variables et Conversion de types

Même si les variables ne sont pas fortement typées, un type est attribué dynamiquement à l’exécution.

Exemple :

a=1 donnera le type int à a

a=1. fonnera le type float à a

La conversion entre type est possible et même recommandée pour éviter de laisser la main à l’ordinateur.

float() transforme l’argument en virgule flottante
int() transforme l’argument en entier
str() transforme l’argument en texte

Dans la manipulation de chaînes de caractères, il est utile de connaître la fonction f-string qui permet de concaténer des variables.

exemples :

print(f'{5*5}')

qui donnera 25

a=20
print(f'My var {str(a+5)}')

qui donnera : My var 25

Utilisation du Fortran avec Python

Il est bien entendu possible de compiler du code Fortran pour l’utiliser sous Python.

Pour Wolf, la voie actuelle est de créer des librairies dynamiques (.dll sous Windows, .so sous Linux) et de les appeler via le module ctypes de Python.

Ce travail peut sembler fastidieux mais il est possible d’utiliser adéquatement des outils comme Copilot ou ChatGPT pour générer le code de base.

Comment accélérer un code Python

Faut-il rappeler que Python est un langage script non compilé?

L’utilisation de Numpy, SciPy… permet d’obtenir de bonnes performances car les routines de calcul sont compilées dans un langage efficient (C ou Fortran la plupart du temps).

Il est admis que l’utilisation du Fortran permet de diviser le temps de calcul d’environ un facteur 30.

Il existe cependant des alternatives telles que Cython qui permet d’obtenir des performances assez similaires tout en gardant une syntaxe très proche du Python.

D’autres approches existent et se basent sur des librairies. Une intéressante est Numba qui permet notamment d’invoquer le GPU assez facilement. MAIS il est intéressant de noter “Special care should be taken when the function which is written under the jit attempts to call any other function then that function should also be optimized with jit else the jit may produce even more slower codes.” :-)

Convention de programmation

Il est important de suivre les conventions de programmation pour faciliter la lecture du code par d’autres personnes (et par soi-même dans quelques mois).

Les conventions générales de programmation sont décrites dans le PEP 8 https://www.python.org/dev/peps/pep-0008/.

Les conventions de nommage sont les suivantes : - les noms de variables sont en minuscules et séparés par des underscores (ex. : my_variable) - les noms de classes sont en CamelCase (ex. : MyClass) - les noms de fonctions sont en minuscules et séparés par des underscores (ex. : my_function) - les constantes sont en majuscules et séparées par des underscores (ex. : MY_CONSTANT) - les noms de modules sont en minuscules et séparés par des underscores (ex. : my_module) - les noms de paquets sont en minuscules et sans underscores (ex. : mypackage)

Pour des raisons historiques, il est fort probable que les codes existants prennent des libertés avec ces conventions. Il est cependant recommandé de respecter ces conventions pour les nouveaux codes.

Les commentaires doivent être idéalement en anglais, mais le français est toléré, surtout pour les commentaires de code existant. Il est cependant recommandé de traduire les commentaires en anglais pour les nouveaux codes afin de faciliter la compréhension par les personnes qui ne parlent pas français.

Les commentaires doivent être clairs et concis. Ils doivent expliquer le pourquoi du code et non le comment. Le code doit être suffisamment clair pour que le comment ne soit pas nécessaire.

Message vers l’utilisateur

Afin de permettre une traduction facile des messages vers l’utilisateur, il est recommandé d’utiliser le module gettext pour gérer les traductions. Dans Wolf, cela se fait via le module wolfhece.Pytranslate en important la routine _.

Exemple :

``` from wolfhece.Pytranslate import _

print(_(“Hello World”)) ```

Cela permet de marquer les chaînes de caractères à traduire et de les traduire facilement dans les fichiers de traduction (.po) générés par pygettext ou xgettext.

Documentation

La documentation de l’API de Wolf est générée automatiquement à partir des commentaires dans le code source. Il est donc important de bien commenter le code pour que la documentation soit complète et compréhensible.

Le format de documentation utilisé est le reStructuredText (reST) qui est un format de documentation léger et facile à lire. Il est recommandé de suivre les conventions de documentation décrites dans le PEP 257 https://www.python.org/dev/peps/pep-0257/.

Le format des docstrings est celui de Sphinx :

``` def my_function(param1, param2):

“”” Description de la fonction.

param param1:

Description du premier paramètre.

param param2:

Description du deuxième paramètre.

return:

Description de la valeur de retour.

“”” pass

```