Installer Python une première fois et ajouter des librairies au fur et à mesure des besoins, en ligne de commande ou depuis son IDE, ne pose en général sans trop de problème.

Les ennuis commencent plus tard, notamment quand on souhaite changer de version de Python. On ne sait plus trop sur quelle version de Python on travaille si on fait un "pip install", d'autant plus que l'on peut installer Python pour tous les utilisateurs du PC (donc en mode admin) ou seulement pour soi... voir le petit dessin xkcd qui expose bien l'enchevêtrement de chemins qui en résulte On va donc ici exposer quelques bases, rappeler comment les chemins d'accès aux ressources sont définis (variable d'environnement PYTHONPATH), comment gérer ses paquets selon la procédure recommandée : les environnements virtuels.

_Mots_clefs _: : installation, pip et conda, versions, à venir

• environnement virtuel, requirements.txt, module poetry
• Lexique : module, bibliothèque (/library), paquet(/package), dépendance

ATTENTION, pages en restructuration

Sommaire

• 1. Première installation de Python et ses bibliothèques : classique ou conda ?
• 2. Upgrader et gérer les versions
• 3. Définir et travailler dans un environnement virtuel
  • Création d'un environnement virtuel
  • Activation d'un environnement virtuel
• 4. Distribuer un code en précisant toutes les dépendances
  • fichier des modules obtenus avec pip freeze
  • module Poetry
• Quelques ressources :
  • point de vocabulaire : script, module, paquets, ajouter environnements virtuels**...
• Faire un bilan de ce qui est installé
• installer des paquets et les mettre à jour
  • avec PIP, Python Package Index
    • installer un paquet présent sur Pypi
    • vérifier les paquets installés
    • mettre à jour
    • Notion d'environnement virtuel avec venv
• Gestion des environnements virtuels et de leurs paquets avec votre IDE (ici, PyCharm)
  • PyCharm : Menu Settings/Project/Python Interpreter
  • .

1. Première installation de Python et ses bibliothèques : classique ou conda ?

Comment installer Python : Il existe pour Windows deux méthodes pour installer Python, incompatibles entre elles sur un même environnement.

• Cas général, installer la dernière version stable depuis le site python.org Pour Windows, choisir **Download for windows", en version 64 bits ne pas cocher "ajouter au PATH" (sinon on n'accède plus qu'à cette version là de Python) vous n'aurez alors que le Python de base, avec les modules standard tels que maths, datetime, tkinter... Il n'y a pas matplotlib par exemple, ni numpy.
• Avec Anaconda ou miniconda : Anaconda est une distribution de Python qui comprend l'essentiel des modules utiles en sciences dans des versions compatibles entre elles : numpy, matplotlib, scipy, Jupyter Notebook... Elle offre en outre des outils spécifiques pour installer et gérer les autres bibliothèques et les environnements virtuels. L'inconvénient est de vous charger avec des tas de modules dont vous n'aurez peut-être jamais besoin ; miniconda peut être une alternative intéressante. Pour commencer, téléchargez la distribution Anaconda correspondant à votre système d’exploitation, en Python version 3 : https://www.anaconda.com/distribution/

un exemple de bibliothèque qu'on ne peut quasiment installer qu'avec conda : GeoPandas. Cette bibliothèque puissante génère des conflits avec d'autres pour des question de version des dépendances (= modules dont elle a besoin).

Comment installer une librairie sous Windows

• Cas général, en ligne de commande : $ pip install ma_librairie
• Avec Anaconda ou miniconda : $ conda install ma_librairie update conda
• Avec un IDE, par exemple PyCharm (voir capture d'écran ci-dessus): dans Files / Settings / Project / Python Interpreter ; cliquez sur le "+" en haut à gauche.

2. Upgrader et gérer les versions

En ligne de commande, l'outil PyLauncher est très utile : py --list : quelles versions de Python sont installées

py --list-paths : versions de Python et leurs chemins (sans espace entre list et -path!)

py -3.9 : lancer python 3.9 dans le terminal le prompt >>> apparaît à la place du prompt shell

py -3.7 toto.py : lancer le scripts toto en python 3.7

Pour vérifier quelles bibliothèques sont installées, et en quelle version, vous pouvez donc consulter la liste depuis votre IDE ou taper en ligne de commande pip freeze. Attention, si vous voulez mettre à jour une librairie existante, il ne suffit pas de refaire la manip d'installation, il faut préciser que vous voulez l'upgrader.

Installer une nouvelle version de Python n'écrase pas l'ancienne : on peut avoir besoin de conserver une version antérieure car on est sûrs que nos codes tournent bien avec.. De même, on peut avoir besoin de mettre à jour nos bibliothèques, en gardant éventuellement aussi une version sous le coude... Bref, on s'y perd vite. La solution :

• savoir ce que l'on fait, et avec quelle version de Python on travaille
• recourir systématiquement aux environnements virtuels, malgré leur nom ce sont des "installations locales"
• travailler avec PyLauncher, alias PY pour se repérer.

Les ennuis commencent en général quand on veut mettre Python à jour (la dernière version est actuellement 3.10, il y a maintenant environ une mise à jour par an), ou que l'on a besoin d'une version particulière de Python et/ou de certaines bibliothèques.

3. Définir et travailler dans un environnement virtuel

C'est une pratique fortement recommandée pour ne pas se perdre dans les versions de python et de ses modules. C'est expliqué dans la doc en français de Python 3.10

Création d'un environnement virtuel

Un environnement virtuel est un techniquement un répertoire, que l'on ne touchera pas "à la main", mais toujours en passant par le module qui va le gérer, ici venv.

on peut spécifier la version de Python

py -m venv /path/to/new/virtual/environment
py -3.10 -m venv /path/to/new/virtual/environment
py -3.10 -m venv nom_venv_dans_repertoire_du_prompt
py -3.10 -m venv nom_venv_dans_repertoire_du_prompt

pour ouvrir une fenêtre invite de commande dans un répertoire, il suffit de taper cmd dans la barre de navigation de l'explorateur

Activation d'un environnement virtuel

Sous Windows Èn ligne de commande, à l'emplacement du venv voulu, ici mon_venv, tapez chemin_courant>mon_venv\Scripts\activate.bat Le prompt change alors en : (mon_venv) chemin_courant >

On peut alors travailler dans l'environnement, et notamment installer des modules :

(mon_venv) chemin_courant >py -m pip install scipy (mon_venv) chemin_courant >py -m pip freeze > requirements.txt

Pour quitter : deactivate.

4. Distribuer un code en précisant toutes les dépendances

fichier des modules obtenus avec pip freeze

pip freeze génère la liste des modules installés, avec leur version. Le signe de redirection > permet d'envoyer cette liste dans un fichier, habituellement appelé "requirements.txt". Le destinataire du fichier n'aura plus qu'à créer un environnement similaire. Attention cependant, le fichier txt contient les noms de modules et leurs dépendances, donc l'utilisateur ne sait pas forcément lesquels doivent être installés et lesquels s'installeront automatiquement en même temps que d'autres.

(mon-env)> pip freeze > requirements.txt

module Poetry

Le module Poetry permet de faciliter le travail du destinataire des scripts, car il se chargera aussi de réinstaller les modules nécessaires.

Intaller Poetry Poetry s'installe comme n'importe quel module, dans l'environnement virtuel activé: NB ; il peut aussi s'occuper de créer et.ou activer l'environnement virtuel : poetry shell

(mon_venv) chemin_courant >py -m pip install poetry (mon_venv) chemin_courant >poetry new nom_projet va créer un fichier pyproject.toml pour un projet à créer

(mon_venv) chemin_courant >poetry init va créer un fichier pyproject.toml pour un projet existant

This command will guide you through creating your pyproject.toml config. Package name [2022-test-anguilles-git]:

[tool.poetry]
name = "2022-test-anguilles-git"
version = "0.1.0"
description = "Code de traitement de chroniques QJ spécifiquement développé pour Migrateurs"
authors = ["C. Poulard, INRAE"]

[tool.poetry.dependencies]
python = "^3.10"

[tool.poetry.dev-dependencies]

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

Poetry distingue une version "développement", avec des modules dont l'utilisateur des scripts n'aura pas besoin (comme black, pour formater le code ): (mon_venv) chemin_courant > poetry add mon_module

(mon_venv) chemin_courant > poetry add -d mon_module_pour_dev

** gérer l'environnement virtuel pour avoir des informations sur l'environnement : poetry env info

Pour changer d'environnement avec poetry env use

** Installer les dépendances Quand l'utilisateur récupère les scripts (comment ? dépôt ?)

poetry install

Quelques ressources :

• tuto du site Pypi qui met à disposition un catalogue de paquets
• une fois de plus, le cours de X. Garrido, section gérer son environnement
• Python Doctor, en français
• OpenClassRoom

point de vocabulaire : script, module, paquets, ajouter environnements virtuels**...

Un script est un programme sauvegardé dans un fichier mon_code.py (par opposition à des instructions tapées dans la console, qui seront perdues...). Quand votre programme va grossir, vous avez intérêt à structurer votre code en plusieurs fichiers, et éventuellement à utiliser du code déjà écrit dans d'autres fichiers *.py. Vous pouvez alors importer les fonctions et/ou les variables de ces codes, considérés comme modules. Il faut que ces fichiers *.py soient dans le même répertoire que votre script, ou dans un répertoire connu par Python dont la liste est le Python PATH, voir ce tuto. Le plus simple est de les gérer avec votre IDE dans un même "projet", et dans le même répertoire, surtout si vous travaillez à plusieurs : si vous oubliez d'envoyer un des fichiers le code sera inutilisable...

Si vous voulez vraiment garder un fichier module commun à plusieurs projets, modifiez le Python PATH, ou ajoutez le chemin vers le fichier dans le code.

import sys
sys.path.insert(0, "/home/olivier/scripts")  # oui, j'ai piqué l'exemple à Python Doctor tel quel

La syntaxe d'import ne fait pas de différence entre des fichiers pythons faits par vous et des packages externes installés (contrairement à d'autres langages qui distinguent include et import)

# j'ai besoin de tout ce qu'il y a dans le fichier, je sais ce qu'il y a dedans, il est fait pour mon script
from mon_fichier_de_fonctions import *  # je peux utiliser la fonction du module via leur nom
import mon_fichier_de_fonctions  # je peux utiliser la fonction du module via l mon_fichier_de_fonctions.nom_de_fonction
# je ne connais pas tout ce qu'il y a dans ce module, tout ne m'intéresse pas
# je n'ai besoin que de quelques fonctions et des variables
from mon_module import ma_fonction_1, ma_fonction_32, ma_classe_71, ma_variable_12, ma_variable2

:warning:vous utiliserez ces autres fichiers *.py pour leurs classes, leurs fonctions et leurs variables, mais peut-être ont-ils aussi un "corps principal", i.e des instructions... Si vous appelez le module avec **import *** elles vont s'exécuter !

Pour éviter cela : 1)construisez des modules qui ne contiennent que des classes, fonctions et variables 2) si vous avez quand même besoin d'écrire des instructions dans leur corps de programme, pour débuguer ou pour une utilisation spécifique, testez si ce fichier est exécuté en tant que script ou bien appelé par un autre code :

if __name__ == __main__:
    # les instructions suivantes sont donc exécutées 
    print("ce fichier est exécuté en tant que script ")
else:
    # ce fichier est importé en tant que module par un autre script
    print("j'ai rarement intérêt à exécuter du code dans un module, peut être quelques initialisations")

Remarque :

• on peut aussi importer des modules dans la console ! Ils seront connus pour tout le reste de la session...
• on peut aussi importer des modules dans la Jupyterlab pour ne pas surcharger le notebook et créer des séquences interminables ! les modules importés dans la console ou dans Jupyter sont importés tels quels et seront connus pour tout le reste de la session... Si vous effectuez des modifications sur le fichier elles ne seront pas prises en compte ! Il faut désinstaller le module ou, avec la console, démarrer une nouvelle session et réimporter.

Un paquet est un ensemble de modules, structurés dans une arborescence. Matplotlib est un paquet, pyplot en est l'un des modules.

Il est fortement déconseillé de tout importer en bloc avec import module * sauf si vous avez vous-même codé ces modules et que vous êtes certains qu'il n'y a pas d'homonyme... car si deux modules contiennent un objet homonyme votre code va faire des choses bizarres...

from matplotlib.pyplot import * : vous avez accès à tous les objets de pyplot sans préfixe mais fortement déconseillé  ! ! 
from matplotlib import * # fortement déconseillé ; attention vous n'avez pas accès aux objets des sous-modules...

il vaut mieux écrire

import module_1 # accès à tous les objets avec module_1 .nom_objet
import module_2 # accès à tous les objets avec module_2 .nom_objet

Il est possible de définir un alias au nom de module. Certains modules, même avec des noms courts, ont des alias que tout le monde utilise par convention, ce qui facilite les échanges de code

import mon_module_avec_un_nom_super_detaille as module # accès à tous les objets avec module .nom_objet

from matplotlib import pyplot as plt  # accès aux objets avec plt.nom_objet
import matplotlib.pyplot as plt  # identique au précédent 

import numpy as np   # accès aux objets avec np.nom_objet
import pandas as pd  # accès aux objets avec pd.nom_objet
import seaborn as sn  # accès aux objets avec sn.nom_objet

Il est également possible d'importer sélectivement certains objets, éventuellement avec des alias

from tkinter import filedialog
from matplotlib.widgets import Slider, CheckButtons
from numpy.random import gumbel
from shapely import Polygon as PolygonShapely

Le code de certains paquets est totalement en Python ; c'est le cas de matplotlib et vous avez accès au code : pour d'autres ce sont des exécutables et/ou du code Python.

Faire un bilan de ce qui est installé

Ouvrir une fenêtre "invite de commande"

python --version

Python 3.6.4

Apparemment, je suis restée au Python 3.6. Pourtant dans mon IDE je travaille avec Python 3.8. En fait, j'ai plusieurs versions installées, ce qui peut être pertinent à condition de savoir ce que l'on fait ! quand je vais installer de nouveaux modules avec pip, ils sont être associés à cette version mentionnée par python --version, donc dans cet exemple Python3.6

Dans un IDE, vous avez aussi quelque part dans "settings" l'information sur la version courante. Eventuellement, on vous demandera de préciser la version de Python à la création d'un projet.

On présente dans la suite comment gérer ses paquets et utiliser les bonnes version hors IDE (pip en invite de commande et venv), ce qui permet de présenter les notions. On mentionne ensuite que l'on peut tout gérer depuis son IDE, ce qui est souvent plus pratique. Si on a plusieurs versions de Python et qu'on installe un module avec PIP, on peut avoir la désagréable surprise de ne pas avoir accès à ce module depuis son IDE... L'IDE permet de mieux visualiser ce que l'on installe pour quelle version de Python.

installer des paquets et les mettre à jour

Pypi est le dépôt tiers officiel du langage de programmation Python. Son objectif est de doter la communauté des développeurs Python d'un catalogue complet recensant tous les paquets Python libres. Voir le site Pypi. Il est donc possible de récupérer facilement des tas de modules développés par d'autres. On peut gérer ses depuis l'invite de commande avec PIP ou depuis votre IDE.

avec PIP, Python Package Index

L'installeur de paquets PIP est fourni avec Python depuis la version 3.4. Il fonctionne en ligne de commande dans l'invite de commande. En windows, c'est la fenêtre sur fond noir qui rappelle l'époque du DOS... On l'ouvre sous windows avec le menu fenêtre, éventuellement en tant qu'administrateur : clic doit puis "exécuter en tant qu'administrateur)

pip --version

pip 20.2.3 from C:\Users\christine.poulard\AppData\Roaming\Python\Python36\site-packages\pip (python 3.6)

installer un paquet présent sur Pypi

Pour installer un paquet (et toutes ses dépendances) :

pip install matplotlib

Dans certains cas, vous aurez besoin d'installer un paquet en spécifiant un chemin ; voir la doc de Pypi. A partir du lien d'un git par exemple :

python3 -m pip install -e git+https://git.repo/some_pkg.git#egg=SomeProject

Le nouveau paquet est disponible maintenant, mais pour l'utiliser dans un de vos codes il faudra d'abord l'importer en précisant en début de script ou dans la console pour une utilisation en console, par exemple :
from matplotlib import pyplot as plt

Suppression d’un paquet :

pip uninstall matplotlib

vérifier les paquets installés

Avoir des infos sur un paquet :

pip show matplotlib

Name: matplotlib Version: 3.3.4 Summary: Python plotting package Home-page: https://matplotlib.org Author: John D. Hunter, Michael Droettboom Author-email: matplotlib-users@python.org License: PSF Location: c:\users\christine.poulard\appdata\local\programs\python\python36-32\lib\site-packages Requires: cycler, numpy, pillow, python-dateutil, kiwisolver, pyparsing Required-by: seaborn

Liste des modules utilisés, avec leur numéro de version

pip freeze

bleach==2.1.3 bokeh==2.2.1 certifi==2018.11.29 chardet==3.0.4 (...)etc.

Je découvre des paquets que je ne me souviens pas avoir installés (sans doute des dépendances d'autres paquets), des paquets que je n'ai pas utilisés depuis longtemps, et peut-être aussi des paquets que j'utilise tout le temps sans savoir qu'il existe des mises à jour qui m'attendent...

mettre à jour

A chaque nouvelle installation PIP vérifiera sa version et vous proposera éventuellement une mise à jour. Il ne s'en charge que pour lui-même ! Pour vérifier si vos paquets sont à jour et comparer votre version avec la dernière sortie :

M:>pip list --outdated

Package Version Latest Type

bleach 2.1.3 3.3.0 wheel bokeh 2.2.1 2.3.2 sdist certifi 2018.11.29 2020.12.5 wheel chardet 3.0.4 4.0.0 wheel (...) cligj 0.4.0 0.7.1 wheel cloudpickle 0.8.0 1.6.0 wheel (...) dask 1.1.1 2021.3.0 wheel datashader 0.6.9 0.12.1 wheel decorator 4.3.2 5.0.7 wheel

Si je cherche à réinstaller datashader, par exemple, PIP va me répondre qu'il est déjà là :

pip install datashader

Requirement already satisfied: datashader in c:\users\christine.poulard\appdata\local\programs\python\python36-32\lib\site-packages (0.6.9) (...)

Pour forcer la mise à jour :

pip install datashader --upgrade

(...) Installing collected packages: datashader Attempting uninstall: datashader Found existing installation: datashader 0.6.9 Uninstalling datashader-0.6.9: Successfully uninstalled datashader-0.6.9 Successfully installed datashader-0.12.1

Sinon, je peux aussi installer un module d'une version précise :

pip install matplotlib==1.5.0

Un de soucis de Python et ses modules est le manque de rétrocompatibilité : rien ne garantit que vos codes continueront à fonctionner tels quels au fur et à mesure des mises à jour. Les plus polis, comme Matplotlib vous préviennent que telle ou telle façon de faire ne sera bientôt plus possible (DeprecationWarning).

D:/2021_AtelierPython/main.py:69: MatplotlibDeprecationWarning: 
The set_window_title function was deprecated in Matplotlib 3.4 and will be removed two minor releases later. Use manager.set_window_title or GUI-specific methods instead.
  fig.canvas.set_window_title("ScE - Hydrologie - Démo probas crue sur N années")

une belle blague avec le module shapefile, utilisé dans l'atelier D (carte) !

pip install pyshp

mais ensuite

import shapefile

Notion d'environnement virtuel avec venv

Pour s'y retrouver dans cette jungle de versions, dont on peut avoir besoin de l'une ou l'autre selon les cas, il existe la notion Environnements virtuel. On déclare les paquets et leurs versions dans un fichier, et on rend le fichier actif avec venv

python3.5 -m venv ~/python.d/my_python_env

Un environnement virtuel permet d’avoir des installations de Python isolées entre elles (une Python 3.6 et une Python 3.10) et de travailler avec différentes versions des modules selon les projets.

Gestion des environnements virtuels et de leurs paquets avec votre IDE (ici, PyCharm)

Vous pouvez aussi gérer tout cela depuis votre IDE. Cette partie présente les manips pour PyCharm, voir la doc selon votre IDE (éventuellement, on complètera ici).

PyCharm : Menu Settings/Project/Python Interpreter

Pour PyCharm, les informations se trouvent dans File/Settings/Project/Python Interpreter. L'interface est pratique dans ce cas car elle affiche la liste des modules, avec pour chacun le numéro de la version installée et celui de la dernière version disponible (voire des "early releases" avec l'icône oeil). Il suffit de cliquer sur le numéro de la version disponible si on a besoin de mettre à jour. Pour ajouter un module, le bouton "+" ouvre une fenêtre avec les packages disponibles, dont on peut consulter une description en cliquant dessus. Attentio, contrairement au "CRAN" de R, le dépôt des modules n'est ni filtré ni vérifié.

.

Vous pouvez depuis l'IDE choisir parmi les environnements déjà connus de PyCharm dans Settings/Project/Python Interpreter.

Vous pouvez créer votre environnement virtuel, et il est d'ailleurs conseillé d'en créer un par projet, ne serait-ce que pour ensuite fournir la liste des modules nécessaires et suffisants pour chaque projet : cliquez sur la petite roue dentée à droite et choisissez "Add". Il faut alors activer le radiobouton "New Environment", et choisir l'emplacement du répertoire venv et la version de Python.

Si l'environnement a été créé par ailleurs mais n'apparaît pas dans la liste, cliquez de même sur la petite roue dentée à droite et choisissez "Add". Il faut alors activer le radiobouton "Existing Environment" et naviguer vers la version visée, à savoir le python.exe dans le répertoire Scripts de votre environnement virtuel.