|
|
|
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](https://xkcd.com/1987/)
|
|
|
|
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
|
|
|
|
|
|
|
|
:construction_worker: :construction: ATTENTION, pages en restructuration
|
|
|
|
|
|
|
|
**Sommaire**
|
|
|
|
|
|
|
|
[TOC]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## 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](https://www.anaconda.com/distribution/) : 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
|
|
|
|
<details><summary>py --list</summary>
|
|
|
|
M:\>py --list
|
|
|
|
Installed Pythons found by py Launcher for Windows
|
|
|
|
-3.9-64 *
|
|
|
|
-3.8-32
|
|
|
|
-3.6-32
|
|
|
|
</details>
|
|
|
|
|
|
|
|
**py --list-paths** : versions de Python et leurs chemins
|
|
|
|
(sans espace entre list et -path!)
|
|
|
|
<details><summary>py --list-paths</summary>
|
|
|
|
|
|
|
|
Installed Pythons found by py Launcher for Windows
|
|
|
|
-3.9-64 C:\Users\christine.poulard\AppData\Local\Programs\Python\Python39\python.exe *
|
|
|
|
-3.8-32 C:\Program Files (x86)\Python38-32\python.exe
|
|
|
|
-3.6-32 C:\Users\christine.poulard\AppData\Local\Programs\Python\Python36-32\python.exe
|
|
|
|
</details>
|
|
|
|
|
|
|
|
**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.
|
|
|
|
|
|
|
|
| commande| résultat|
|
|
|
|
| ------ | ------ |
|
|
|
|
|$ pip list | avoir des infos sur tous les packages installés |
|
|
|
|
|$ pip list **| grep** mon_package | avoir des infos sur un package en particulier|
|
|
|
|
| $ pip list --outdated | liste des packages "dépassés" ("obsolète" est peut-être un terme un peu fort...)|
|
|
|
|
| $ pip install --user --upgrade mon_package | forcer la mise à jour à la dernière version (installation utilisateur en cours seulement)|
|
|
|
|
| $ pip install --upgrade mon_package | forcer la mise à jour à la dernière version (installation admin, tous utilisateurs)|
|
|
|
|
| $ pip install --user mon_package==2.2| forcer la mise à jour à une version donnée (ici, installation pour l'utilisateur courant)|
|
|
|
|
|
|
|
|
<details>
|
|
|
|
<summary>rappels, comment upgrader une librairie</summary>
|
|
|
|
Cas général, en ligne de commande : $ pip install --upgrade ma_librairie Avec Anaconda ou miniconda : $ conda update ma_librairie Avec un IDE, par exemple PyCharm : aller dans Files /.../ Python Interpreter, vous avez la liste des modules avec "Version" et "Latest Version"; cliquez sur le numéro de la dernière version
|
|
|
|
</details>
|
|
|
|
|
|
|
|
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](https://docs.python.org/fr/3/library/venv.html)
|
|
|
|
|
|
|
|
|
|
|
|
### 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
|
|
|
|
``` shell
|
|
|
|
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
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
:bulb: 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](https://python-poetry.org/) 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](https://packaging.python.org/tutorials/installing-packages/) qui met à disposition un catalogue de paquets
|
|
|
|
- une fois de plus, le cours de [X. Garrido, section gérer son environnement](https://xgarrido.github.io/licence_python_teaching/pdf/01_slide_environnement.pdf)
|
|
|
|
- [Python Doctor, en français](https://python.doctor)
|
|
|
|
- [OpenClassRoom](https://openclassrooms.com/fr/courses/6951236-mettez-en-place-votre-environnement-python/7013349-decouvrez-les-paquets-python)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
### 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](https://python.doctor/page-python-path-pythonpath). 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.
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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)
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
# 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 :
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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 ! :warning: 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...
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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 ! :warning: 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](https://pypi.org/). 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](mailto: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).
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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")
|
|
|
|
```
|
|
|
|
|
|
|
|
:warning: une belle blague avec le module shapefile, utilisé dans l'atelier D (carte) !
|
|
|
|
|
|
|
|
> pip install pyshp
|
|
|
|
|
|
|
|
mais ensuite
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
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é.
|
|
|
|
|
|
|
|
</details>
|
|
|
|
|
|
|
|
### .
|
|
|
|
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.
|
|
|
|
|
|
|
|
 |
|
|
|
\ No newline at end of file |
