pip est un gestionnaire de packages permettant l’installation de dépendances en Python. Ce n’est pas le seul gestionnaire mais c’est le plus recommandé, il en existe d’autres comme:
- Homebrew (pour macOS),
- conda (connu avec les installateurs Miniconda et Anaconda pour installer un environnement Python complet).
- pipenv permettant de rassembler en un seul gestionnaire plusieurs gestionnaires.
Quel pip utiliser ?
Chemin de pip
Utiliser pip avec un environnement virtuel
Les commandes pip
pip install
Installer à partir d’un fichier
Indiquer où les packages sont installés
Conditions sur les versions
Identifiants des versions
Mode éditable
Installation à partir d’un repository GitHub
Pour effectuer la mise à jour d’un package
pip download
pip uninstall
pip list
pip search
pip show
pip freeze
pip wheel
pip cache
pip config
Configuration par fichier
PIP_CONFIG_FILE
Liste des commandes pour modifier la configuration par fichier
Import de modules
__file__
Avoir des informations sur un package installé
dir()
Package wheel .whl
Construire un package wheel
Quelques détails sur les packages wheel
CPython
Pip signifie “Pip installs Python” ou “PIP installs Packages”. Il a pour but comme tous les gestionnaires de packages de proposer des commandes communes pour installer, désinstaller ou mettre à jour les dépendances d’un projet en prenant en compte les différentes conditions de versions. Par défaut, il permet de télécharger les packages à partir de PyPI mais il est possible de configurer d’autres repositories pour, par exemple, télécharger à l’intérieur d’une infrastructure d’entreprise.
Quel pip utiliser ?
Comme pour Python, pip peut être installé de différentes façons. Comme les différentes méthodes d’installation peuvent placer pip à des chemins différents, il peut subsister plusieurs versions de pip sur le même machine.
Chemin de pip
On peut vérifier les différents emplacements possibles en tapant:
- Windows:
> where pip
- Linux:
- Pour afficher tous les répertoires où pip se trouve:
% whereis pip
- Pour indiquer le chemin actuel utilisé:
% which pip
- Pour afficher tous les répertoires où pip se trouve:
Pour vérifier la version de pip:
% pip --version
Utiliser pip avec un environnement virtuel
On peut utiliser pip:
- Directement: suivant la méthode utilisée pour installer pip (par exemple avec Miniconda ou avec un autre gestionnaire de package). Son emplacement est du type:
- Sur Windows:
C:/Program Files/Miniconda3-Windows-x86_64/Script/pip.exe
- Sur Linux:
/home/<user>/miniconda3/bin/pip3
Cette méthode est déconseillée car la version de pip peut être figée et liée à la façon dont Python est installée. De cette façon, on peut être amené à utiliser une version obsolète de pip. Il est préférable d’utiliser cette méthode comme amorce et privilégier l’utilisation d’un environnement virtuel.
- Sur Windows:
- Exécuter pip en tant que module: cette méthode permet de garantir que la version de pip qui est utilisée est en accord avec la version de Python utilisée, par exemple:
% python -m pip
- Exécuter dans un environnement virtuel: cette méthode permet d’installer une version spécifique pour un projet donné. Elle permet de mettre à jour facilement pip.
Pour créer un environnement virtuel dans un répertoire:
python -m venv <chemin du répertoire>
Par exemple:
% python -m venv venv
Pour activer cet environnement sur l’invite de commandes ou le terminal courant:
- Sur Windows:
<chemin de l'env. virtuel>\Scripts\activate
- Sur Linux:
source <chemin de l'env>/bin/activate
Dans notre cas:
- Sur Windows:
> venv\Scripts\activate.bat
- Sur Linux:
% source venv/bin/activate
L’environnement est ensuite activé, ce qui signifie que python et pip utilisés sont désormais dans le répertoire de l’environnement virtuel. De même, si on installe un package avec pip, il le sera seulement dans l’environnement virtuel.
Si on tape:
where pip
Le résultat indique au moins 2 répertoires dont le premier est celui de l’environnement virtuel:
- Sur Windows:
> where pip <chemin de l'env. virtuel>\Scripts\pip.exe C:\Program Files\Miniconda<version>\Scripts\pip.exe
- Sur Linux:
% whereis pip pip: <chemin de l'env. virtuel>/bin/pip3.9 <chemin de l'env. virtuel>/bin/pip /home/<user>/miniconda<version>/bin/pip
Par exemple, si on installe un package dans l’environnement virtuel:
% pip install numpy
On peut voir qu’il est installé dans l’environnement virtuel:
<chemin de l'env. virtuel>/Lib/site-packages/numpy
Pour désactiver l’environnement virtuel pour l’invite de commande ou du terminal courant, il faut juste taper:
% deactivate
A ce stage, les chemins de python et de pip qui seront utilisés ne seront plus ceux de l’environnement virtuel:
% where pip
- Sur Windows:
> where pip C:\Program Files\Miniconda<version>\Scripts\pip.exe
- Sur Linux:
% where pip pip: /home/<user>/miniconda<version>/bin/pip
Les commandes pip
Les commandes principales sont:
pip install
: pour installer des packages.pip uninstall
: pour désinstaller des packages.pip list
: pour lister les packages installés.pip search
: pour chercher un package dans un index de packages.pip show
: pour indiquer des informations concernant un package.pip freeze
: pour lister les packages installés et permettre de stocker la liste dans un fichierrequirements.txt
pip wheel
: pour construire un package d’un projet et télécharger les dépendances de ce projet.pip cache
: pour manipuler le cache de pip.pip config
: pour configurer pip.
Dans cet article, on ne traitera que ces commandes. On peut voir la liste exhaustive des commandes sur pip.pypa.io/en/stable/cli/.
pip install
Un package peut être installé à partir de 4 sources:
- PyPI (ou un autre repository suivant la configuration): c’est le type d’installation le plus courant. Cette méthode permet de récuperer et d’installer des packages tiers.
- A partir d’un gestionnaire de versions (comme Git): si le repository dans Git possède un fichier
setup.py
, il est possible d’installer un package directement à partir du code source. Cette méthode est plutôt simple d’utilisation et convient bien si le projet ne se trouve pas dans un repository Python comme PyPI. - A partir d’un répertoire: si le projet comprend un fichier
setup.py
, il est possible de l’installer directement à partir d’un répertoire. Cette méthode convient bien pour tester l’installation dans le cadre d’un projet en développement. - A partir d’un fichier
.zip
ou.tar.gz
.
D’une façon générale, pour installer un package ou plusieurs packages, il faut exécuter:
pip install <noms des packages>
Pour séparer les noms des packages, il suffit d’utiliser un espace.
L’installation des packages se fait en 4 étapes, par exemple:
% pip install numpy
Collecting numpy
Downloading numpy-1.23.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (13.9 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 13.9/13.9 MB 16.1 MB/s eta 0:00:00
Installing collected packages: numpy
Successfully installed numpy-1.23.1
Les étapes de l’installation sont:
- Prise en compte des paramètres.
- Résolution des dépendances: les packages sont téléchargés ou récupérer à partir du cache.
- Construction des packages wheels pour toutes les dépendances où c’est possible. Cette étape n’est pas effectuée s’il n’y a pas de packages wheel ou s’ils sont dans le cache. Execution du fichier
setup.py
des packages. - Installation des packages
Installer à partir d’un fichier
On peut installer un package à partir d’un fichier tar.gz
ou un fichier wheel (.whl
):
pip install <emplacement du fichier>
Indiquer où les packages sont installés
Par défaut le répertoire utilisé pour stocker les packages installés est de type:
- Sur Windows:
C:\Program Files\Miniconda<version>\lib\site-packages
- Sur Linux:
/home/<user>/miniconda<version>/lib/site-packages
Dans Le cas où on utilise un environnement virtuel, le chemin sera du type:
<chemin du l'env. virtuel>/lib/site-packages
Pour trouver le chemin du répertoire site-packages
, il faut exécuter:
% python >>> import site >>> site.getsitepackages() ['<chemin du l'env. virtuel>/lib/python3.9/site-packages']
Dans le répertoire site-packages
, on peut trouver tous les packages avec des répertoires correspondant au nom du package et des informations relatives aux packages dans un répertoire de type:
<chemin de site-packages>/<nom package>-<version>.dist-info
Par exemple pour numpy en version 1.19.5, le répertoire contenant des informations sur le package est:
<chemin de site-packages>/numpy-1.19.5.dist-info
Conditions sur les versions
On peut indiquer des conditions de versions sur les packages. Il est possible d’indiquer plusieurs conditions en les séparant par une virgule. Les conditions doivent être indiquées avec la syntaxe <opérateur> <version concernée>
. D’une façon générale, pip essaie d’installer la dernière version d’un package en prenant en compte les différentes conditions.
Les opérateurs sont:
==
pour indiquer une version précise. Si la version ne peut être satisfaite alors l’installation ne pourra aboutir.!=
pour indiquer l’incompatibilité avec une version précise.<=
,<
,>
,>=
pour indiquer que la version du package doit être, respectivement, inférieure ou égale, strictement inférieure, strictement supérieure ou supérieure ou égale à une version donnée.~=
siM
est la version majeure etm
la version mineure, cette condition permet d’indiquer une condition équivalente à>= M.m, == M.*
.Par exemple:
~= 1.3
est équivalent à:
>= 1.3, == 1.*
- L’équivalence peut porter sur des versions comprenant
MAJEURE.MINEURE.PATCH
:
~= 1.1.3
est équivalent à:
>= 1.1.3, == 1.1.*
===
effectue une comparaison des versions sous la forme de chaîne de caractères sans prendre en compte la sémantique dans les numéros de versions.
Par exemple:
% pip install 'numpy>1.0, <=1.5'
On peut indiquer plusieurs conditions de version de cette façon:
% pip install 'numpy>1.0, <=1.5'
Dans le cas où on veut installer plusieurs packages:
% pip install 'numpy>1.0, <=1.5' pandas
Identifiants des versions
En Python, les identifiants de versions respectent quelques règles qui ne sont pas forcément appliquées pour d’autres langages. Ces règles sont détaillées dans les spécifications PEP440.
Les versions finales sont indiquées sous la forme classique <majeure>.<mineure>
ou <majeure>.<mineure>.<patch>
en accord avec le semantic versioning (cf. semver.org). Pour les versions intermédaires (alpha, beta, release candidate, prelease) Python permet d’indiquer plus de précisions dans l’identifiant des versions à condition de respecter les règles suivantes:
- Version pré-release:
a
oualpha
:1.2a1
ou1.2alpha1
(dans ce cas la version finale sera1.2
);1.2.4a1
ou1.2.4alpha1
(dans ce cas la version finale sera1.2.4
).b
oubeta
:3.2b2
ou3.2beta2
(dans ce cas la version finale sera3.2
);3.2.4b1
ou3.2.4beta1
(dans ce cas la version finale sera3.2.4
).c
,rc
,pre
oupreview
:1.5c2
,1.5rc2
,1.5pre2
,1.5preview2
;1.5.6c2
,1.5.6rc2
,1.5.6pre2
,1.5.6preview2
;
D’autres règles s’appliquent:
- Il est possible d’utiliser les caractères de séparation
-
ou_
par exemple1.2.7-a2
ou1.2.7_a2
toutefois la forme courante est1.2.7a2
. - En cas d’omission du numéro,
0
est utilisé. Ainsi1.2.7a
est équivalent à1.2.7a0
.
- Version post-release: avec
.postN
, par exemple1.2.post0
(la version précédente était1.2
);1.2.7.post2
(les versions précédentes étaient1.2.7
et1.2.7.post1
).- Il est possible d’utiliser les caractères de séparation
-
ou_
par exemple1.2.7-post2
ou1.2.7_post2
toutefois la forme courante est1.2.7.post2
. - En cas d’omission du numéro,
0
est utilisé. Ainsi1.2.7.post
est équivalent à1.2.7.post0
.
- Il est possible d’utiliser les caractères de séparation
- Version de développement: avec
.devN
, par exemple3.1.dev2
(la version finale sera3.1
);3.1.5.dev1
(la version finale sera3.1.5
).
Dans le cas où des conditions avec des opérateurs d’inégalité sont appliquées, l’ordre des versions s’applique suivant l’identifiant:
- Les versions de pré-release comme alpha, beta, release candidate précédent les versions finales.
- Les versions de post-release succèdent aux versions stables.
- Les versions de développement précédent les versions finales.
Mode éditable
Ce mode peut être utile en développement car il permet d’installer un package que l’on développe de façon à pouvoir accéder aux sources facilement. Quand on installe un package de cette façon, un lien est créé dans le répertoire site-packages
. Ce lien est de type:
<chemin site-packages>/<nom du package>.egg-link
Ces liens sont des fichiers permettant à l’interpréteur python de faire un lien entre le nom du package et l’emplacement des fichiers sources.
Pour installer un package à partir d’un répertoire avec le mode éditable:
pip install -e <chemin du répertoire>
Par exemple, pour installer à partir du répertoire courant:
% pip install -e .
Pour illustrer l’installation à partir d’un repository GitHub, on considère le repository: github.com/msoft/python_package_example.
Ce repository contient les fichiers suivants:
├── LICENSE
├── PeopleCounter
│ ├── Counter.py
│ ├── __init__.py
│ └── ScientistRepository.py
├── README.md
└── setup.py
Le fichier setup.py
contient le code suivant:
from distutils.core import setup
with open("README.md", "r") as fh:
description = fh.read()
setup(name='PeopleCounter',
version='1.0',
description='Python package example',
author='MM',
author_email='',
packages=['PeopleCounter'],
long_description=description,
long_description_content_type="text/markdown",
url="https://github.com/msoft/python_package_example",
license='MIT',
python_requires='>=3.8',
install_requires=[ 'numpy' ]
)
Si on installe à partir du repository en exécutant la commande suivante:
% pip install git+https://github.com/msoft/python_package_example.git
Les fichiers sont installés de la façon suivante:
- Les fichiers
.py
sont installés dans<chemin env. virtuel>/lib/python3.9/site-packages/PeopleCounter
. - Les fichiers
.pyc
contenant le bytecode CPython correspondant au code Python dans<chemin env. virtuel>/lib/python3.9/site-packages/PeopleCounter/__pycach__
(plus de détails sur CPython plus bas). - Les métadonnées du package sont dans:
<chemin env. virtuel>/lib/python3.9/site-packages/PeopleCounter-1.0.dist-info
.
Si on effectue l’installation en mode éditable en exécutant la commande suivante:
% pip install -e git+https://github.com/msoft/python_package_example.git#egg=PeopleCounter
Il n’existe pas de code CPython, les fichiers sont installés de la façon suivante:
- Les fichiers
.py
sont installés dans<chemin env. virtuel>/src/peoplecounter/
- Un lien
.egg-link
est placé dans le répertoire<chemin env. virtuel>/lib/python3.9/site-packages/PeopleCounter.egg-link
. Ce fichier contient le chemin du répertoire contenant les sources:<chemin env. virtuel>/src/peoplecounter
Ce lien est utilisé par l’interpréteur Python pour faciliter les imports.
Installation à partir d’un repository GitHub
Il faut exécuter une commande du type:
pip install git+<adresse .git du repo>
En mode éditable:
pip install -e git+<adresse .git du repo>#egg=<nom du package>
Par exemple:
% pip install git+https://github.com/msoft/python_package_example.git
En mode éditable:
% pip install -e git+https://github.com/msoft/python_package_example.git#egg=PeopleCounter
Quelques options courantes:
- Installer à partir d’un fichier
requirements.txt
(contenant les dépendances voirpip freeze
):pip install -r <chemin du fichier requirements.txt>
Ou
pip install --requirement <chemin du fichier requirements.txt>
- Permettre d’installer une version en pré-release:
pip install --pre <nom du package>
- Pour ne pas installer de dépendances:
pip install --no-deps <nom du package>
- Pour simuler l’exécution:
pip install --dry-run <nom du package>
- Pour réinstaller des packages déjà installés:
pip install --force-reinstall <nom du package>
- Pour installer à partir d’un répertoire local sans utiliser des index comme PyPI:
pip install --no-index --find-links <chemin répertoire local>
Le répertoire local sera listé pour trouver les dépendances. Si le chemin indiqué est une URL ou un fichier HTML, les liens du fichiers seront utilisés pour trouver les dépendances.
Pour effectuer la mise à jour d’un package
La mise à jour implique que le package sera supprimé puis réinstaller, il faut exécuter:
pip install --upgrade <nom du package>
Ou
pip install -U <nom du package>
Pour mettre à jour pip:
Il est fortement conseillé d’utiliser pip sous la forme d’un module pour mettre à jour pip:
% python -m pip install -U pip
pip download
La commande pip download
effectue le même traitement de résolution des dépendances que pip install
. La différence est que pip download
n’installe pas les packages, mais permet de les télécharger. Par défaut, les packages sont installés dans le répertoire courant. Les dépendances des packages peuvent aussi être téléchargées si elles ne sont pas déjà installées.
Si un package à télécharger existe sous la forme wheel, un fichier .whl
compatible sera téléchargé sinon dans le cas d’un projet contenant des fichiers .py
et un fichier setup.py
, un fichier .zip
sera généré.
Comme pour pip install
, il est possible de télécharger un package à partir de sources différentes:
- Des repositories comme PyPI:
pip download <nom des packages>
Sans indications supplémentaires, le téléchargement sera effectué dans le répertoire courant.
Pour indiquer explicitement le répertoire de destination, il faut utiliser l’option
-d
ou--dest
, par exemple:pip download numpy -d <chemin répertoire>
Ou
pip download numpy --dest <chemin répertoire>
Par défaut, seules les versions stables sont téléchargées. Pour inclure les versions pre-releases, il faut utiliser l’option
--pre
:pip download --pre <nom des packages>
Pour effectuer les téléchargements de packages indiqués dans un fichier
requirement
(obtenu par exemple en utilisantpip freeze
):pip download -r <fichier requirement>
Ou
pip download --requirement <fichier requirement>
- Un VCS comme Git:
pip download git+<adresse .git du repo>
Les dépendances existant sous la forme de fichier wheel
.whl
seront téléchargés et le projet dans le repo Git sera téléchargé sous la forme d’un fichier.zip
. - Directement à partir d’un répertoire:
pip download <chemin du répertoire>
Cette commande permet de télécharger toutes les dépendances.
- A partir d’une archive
.zip
ou.tar.gz
:pip download <chemin de l'archive>
Cette commande permet de télécharger toutes les dépendances et de copier l’archive dans le répertoire de destination.
pip uninstall
Pour désinstaller un package à partir de son nom:
pip uninstall <nom du package>
Pour éviter la question de confirmation:
pip uninstall --yes <nom du package>
Ou
pip uninstall -y <nom du package>
pip list
Permet de lister les packages installés. Par défaut les packages éditables sont affichés et les packages en pré-release ne sont pas affichés:
pip list
Pour lister uniquement les packages éditables:
pip list -e
Ou
pip list --editable
Pour lister les packages obsolètes:
pip list -o
Ou
pip list --outdated
Pour lister aussi les packages en prerelease:
pip list --pre
pip search
Permet de chercher un package dans PyPI par défaut:
pip search <nom du package>
Il faut noter que dans le code de PyPI, cette commande est désactivée pour limiter les accès aux serveurs et ne permet pas de renvoyer des résultats. On obtient systématiquement l’erreur suivante:
ERROR: XMLRPC request failed [code: -32500] RuntimeError: PyPI's XMLRPC API is currently disabled due to unmanageable load and will be deprecated in the near future. See https://status.python.org/ for more information.
Cette commande est à privilégier pour des index privés comme à l’intérieur de l’infrastructure d’une entreprise.
Pour utiliser un autre index:
pip search -i <url> <nom du package>
Ou
pip search --index <url> <nom du package>
pip show
Permet d’indiquer des informations concernant un package installé:
pip show <nom du package>
Pour afficher la liste des fichiers installés:
pip show -f <nom du package>
Ou
pip show -files <nom du package>
pip freeze
Permet d’indiquer les packages installés. Cette commande est particulièrement utile pour figer la version des dépendances d’un projet.
Pour lister les packages installés dans un fichier:
pip freeze > <nom du fichier>
Pour installer les packages listés dans le fichier généré;
pip install -r <nom du fichier>
Par défaut les packages distribute
, pip
, setuptools
, wheel
ne sont pas listés. L’option --all
permet de lister ces packages:
pip freeze --all
Pour exclure le package en mode éditable:
pip freeze --exclude-editable
pip wheel
pip wheel
permet de construire le package wheel .whl
d’un projet et de télécharger les dépendances de ce projet. La commande pip wheel
utilise la bibliothèque wheel pour construire les packages. La bibliothèque wheel utilise ensuite setuptools
.
La recherche des dépendances se fait, par défaut, comme pour l’instruction pip install
. Sans précision, elle se fait à partir des repositories comme PyPI.
Pour construire un package wheel et télécharger les dépendances dans un projet, on peut exécuter directement:
pip wheel <chemin du projet>
Pour que le package wheel soit construit, il faut que le projet comporte un fichier setup.py
(voir package wheel .whl
. Les packages seront placés dans le répertoire dans lequel l’instruction est exécutée.
On peut préciser des options particulières:
- Pour indiquer le répertoire de destination:
pip wheel <chemin du répertoire> -w <répertoire destination .whl>
Ou
pip wheel <chemin du répertoire> --wheel-dir <répertoire destination .whl>
- Pour effectuer la construction du package à partir d’un projet dans un repository Github:
pip wheel git+<adresse .git du repo>
- Pour utiliser un fichier
requirements.txt
:pip wheel -r <chemin fichier requirements.txt>
Dans le cas où un projet éditable est utilisé dans un répertoire différent de:
<répertoire de l'environnement virtuel>/src
ou<répertoire courant>/src
On peut indiquer le chemin du projet avec l’option
--src
:pip wheel --src <chemin du répertoire>
- On peut utiliser
--pre
comme pourpip install
pour indiquer la prise en compte des packages en pré-release ou en développement. - Dans le cas où certains packages ne se trouvent pas le repository indiqué en configuration mais localement, on peut indiquer le chemin du répertoire dans lequel se trouve les packages en utilisant l’option
-f
ou--find-links
:pip wheel <chemin du répertoire du projet> -f <chemin packages>
Ou
pip wheel <chemin du répertoire du projet> --find-links <chemin packages>
Si le chemin des packages est un répertoire, le répertoire sera listé pour trouver les dépendances. Si le chemin des packages est une URL ou un fichier HTML, les liens du fichiers seront utilisés pour trouver les dépendances.
A titre d’exemple d’utilisation de l’instruction pip wheel
, on considère un projet simple possédant 2 dépendances:
peoplecounter
qui est un package construit localement provenant de l’exemple plus haut.peoplecounter
nécessite le packagenumpy
.numpy
qui sera téléchargé dans PyPI qui est une dépendance indirecte carpeoplecounter
nécessite son téléchargement.
Le projet comporte 2 fichiers:
test.py
qui contient le code Python utilisantpeoplecounter
etsetup.py
qui permet de construire le package du projet.
Le fichier test.py
contient le code:
from peoplecounter import ScientistRepository
from peoplecounter import Counter
scientistRepo = ScientistRepository()
scientistRepo.printMembers()
counter = Counter()
counter.countScientists()
Le fichier setup.py
contient:
from distutils.core import setup
setup(name='TestPackage',
version='1.0.0',
description='Python package example',
install_requires=[ 'peoplecounter' ]
)
On peut voir dans ce fichier la dépendance vers peoplecounter
.
Si on exécute l’instruction suivante dans le répertoire où se trouve setup.py
:
/home/user/python/test% pip wheel . -w results
L’option -w results
est rajoutée pour que les packages soient téléchargés dans le répertoire results
.
Le résultat est:
Processing /home/user/python/test Preparing metadata (setup.py) ... done ERROR: Could not find a version that satisfies the requirement peoplecounter (from testpackage) (from versions: none) ERROR: No matching distribution found for peoplecounter
L’instruction échoue car peoplecounter
est un package local et qu’aucun repository ne permet de le retrouver. On rajoute l’option -f <répertoire>
pour indiquer le répertoire ../other_packages
dans lequel se trouve le package .whl peoplecounter
:
/home/user/python/test% pip wheel . -w results -f ../other_packages
Le résultat:
Looking in links: ../other_packages Processing /home/user/python/test Preparing metadata (setup.py) ... done Processing /home/user/python/other_packages/peoplecounter-1.0.0-py3-none-any.whl Collecting numpy Using cached numpy-1.23.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (13.9 MB) Saved ./results/peoplecounter-1.0.0-py3-none-any.whl Saved ./results/numpy-1.23.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl Building wheels for collected packages: TestPackage Building wheel for TestPackage (setup.py) ... done Created wheel for TestPackage: filename=TestPackage-1.0.0-py3-none-any.whl size=1077 sha256=dbe761785e430537171a0017a3df1d235cafd44110797e864ea92b5d03d55b92 Stored in directory: /tmp/pip-ephem-wheel-cache-xr1jlt4g/wheels/06/fa/73/05ae28860a3649aff8701fe92444de7cf3d792fc7434a6b138 Successfully built TestPackage
Dans le répertoire results
, on peut trouver les packages suivants:
/home/user/python/test% ls results
numpy-1.23.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
peoplecounter-1.0.0-py3-none-any.whl
TestPackage-1.0.0-py3-none-any.whl
On peut voir que:
numpy
a été téléchargé. Ce n’est pas une dépendance directe du projetTestPackage
toutefois il a été téléchargé car c’est une dépendance du packagepeoplecounter
.peoplecounter
puisque c’est la seule dépendance directe deTestPackage
.TestPackage
: ce package a été construit conformément au fichiersetup.py
.
pip cache
Pour minimiser le trafic réseau, pip stocke les packages wheel téléchargés dans un cache.
pip stocke les packages dans le cache de 2 façons:
- Les packages téléchargés en utilisant un index comme PyPI et
- Les packages construits, par exemple, à partir d’un repository Github.
Quelques opérations concernant le cache:
- Pour connaître le répertoire du cache, on peut exécuter:
% pip cache dir
- Pour avoir des informations sur ce cache:
% pip cache info Package index page cache location: /home/user/.cache/pip/http Package index page cache size: 88.9 MB Number of HTTP files: 54 Locally built wheels location: /home/user/.cache/pip/wheels Locally built wheels size: 2.5 kB Number of locally built wheels: 1
- Pour supprimer tout le contenu du cache:
% pip cache purge
- Pour supprimer des packages avec un nom particulier:
pip cache remove <pattern de recherche>
- Pour ajouter un package construit localement dans le cache, il faut l’installer, par exemple, à partir d’un tag ou d’un commit Git:
Si on considère le repository github.com/msoft/python_package_example du packagepeoplecounter
, on peut l’installer en exécutant:% pip install peoplecounter@git+https://github.com/msoft/python_package_example.git@f21d733cb72a59aa537ca0b369f46887383451c8
A ce moment le package sera rajouté dans le cache en tant que package construit localement.
- Pour lister les packages construits localement;
pip cache list <pattern de recherche>
Avec cette syntaxe, les packages seront affichés par nom:
Cache contents: - peoplecounter-1.0.0-py3-none-any.whl (2.3 kB)
On peut afficher le chemin de ces packages en exécutant:
% pip cache list --format abspath /home/user/.cache/pip/wheels/28/01/8e/fef2941029595fef189e0aeb739117267d9835751dcbf78a62/peoplecounter-1.0.0-py3-none-any.whl
pip config
La configuration de pip peut être paramétrer de 3 façons du plus prioritaire au moins prioritaire:
- Par des options lorsqu’une commande est exécutée avec
--<indication du paramètre>
.Par exemple, si considère le paramètre
--progress-bar <on ou off>
.La configuration par option surcharge toutes les autres méthodes.
- Avec des variables d’environnement. Le nommage se fait en utilisant des majuscules, avec le préfixe
PIP_
et en remplaçant-
par_
.La configuration par variable d’environnement surcharge la méthode par fichier de configuration.
Par exemple l’équivalent du paramètre
--progress-bar <on ou off>
est:PIP_PROGRESS_BAR
- Avec un fichier de configuration.
Si le paramètre affecte plusieurs commandes, il sera placé dans la catégorie[global]
:[global] progress-bar = on
Dans le cas où le paramètre est spécifique à une commande, il sera placé dans la catégorie correspondant à la commande. Par exemple, si on considère la commande
pip download
et l’option--progress-bar <on ou off>
:[download] progress-bar = on
La configuration par fichier peut être surchargée par toutes les autres méthodes. La valeur d’un paramètre affecté au niveau global peut être surchargée par une valeur affectée pour une commande spécifique.
Configuration par fichier
Il existe 3 niveaux de configuration par fichier pour pip. Pour un niveau donné, si aucune valeur n’est précisée, il hérite de la valeur indiquée dans un niveau supérieur. Si une valeur est précisée, elle surcharge la valeur du niveau supérieur. Par défaut, c’est le niveau utilisateur qui est affecté.
Les 3 niveaux de configurations sont:
- Global: concerne tout le système pour tous les utilisateurs et tous les environnements. Il faut utiliser
--global
pour affecter des paramètres pour ce niveau. - Utilisateur: concerne un utilisateur en particulier et tous les environnements de cet utilisateur. Il faut utiliser
--user
pour affecter des paramètres pour ce niveau. - Site: concerne un environnement en particulier. Il faut utiliser
--site
pour affecter des paramètres pour ce niveau.
Pour voir le détail de la configuration par fichier, on peut exécuter:
pip config list
Ou pour avoir plus de détails:
pip config -v list
On peut voir la liste des fichiers choisis en tapant:
pip config -v debug
Avec cette dernière commande, on peut voir les chemin des fichiers de configuration suivant les niveaux.
Par exemple:
Windows | Niveau global | C:\ProgramData\pip\pip.ini |
Niveau utilisateur | C:\Users\<utilisateur>\pip\pip.ini ouC:\Users\<utilisateur>\AppData\Roaming\pip\pip.ini |
|
Niveau site dans le cas de miniconda | C:\Program Files\miniconda3-windows-x86_64\pip.ini |
|
Linux | Niveau global | /etc/xdg/pip/pip.conf /etc/pip.conf |
Niveau utilisateur | /home/<utilisateur>/.pip/pip.conf /home/<utilisateur>/.config/pip/pip.conf |
Dans le cas d’un environnement virtuel, le niveau site est remplacé par le fichier de l’environnement. Par exemple:
- Sur Windows:
<chemin environnement virtuel>\pip.ini
- Sur Linux:
<chemin environnement virtuel>/pip.conf
Dans les fichiers de configuration, les paramètres sont identifiés suivant:
- le nom de la catégorie:
[global]
si le paramètre concerne plusieurs commandes ou la catégorie correspondant à la commande si le paramètre est spécifique à une commande. Par exemple, si un paramètre concerne la commandepip download
alors la catégorie estdownload
. - le nom du paramètre.
Par exemple, si on considère l’option --index-url http://example.org
devant s’appliquer seulement sur la commande pip download
, le paramétrage dans un fichier sera:
[download]
index-url = http://example.org
PIP_CONFIG_FILE
On peut utiliser une variable d’environnement nommée PIP_CONFIG_FILE
pour indiquer le chemin d’un fichier de configuration. Ce fichier sera utilisé en priorité par rapport aux autres niveaux global, utilisateur ou site.
Liste des commandes pour modifier la configuration par fichier
La liste des commandes de pip config
pour éditer la configuration est:
edit
pour éditer la configuration avec un éditeur. Cette commande renvoie l’erreur suivante si on n’indique pas un éditeur:% pip config edit ERROR: Could not determine editor to user
Pour préciser l’éditeur:
- Sur Windows:
pip config edit --editor notepad.exe .
- Sur Linux:
pip config edit --editor vi
- Sur Windows:
get
pour récupérer la valeur d’un paramètre de configuration. Le paramètre est identifié avec la syntaxe:<catégorie>.<option>
Ainsi pour obtenir la valeur du paramètre:
[download] index-url = http://example.org
Il faut taper:
pip config get download.index-url
set
pour affecter une valeur à un paramètre de configuration. Le paramètre est identifié avec la syntaxe:<catégorie>.<option>
.Ainsi pour affecter une valeur au paramètre:
[download] index-url = ...
Il faut exécuter la commande:
% pip config set download.index-url http://example.org
unset
pour supprimer la valeur d’un paramètre de configuration. Le paramètre est identifié avec la syntaxe:<catégorie>.<option>
.Ainsi pour supprimer la valeur du paramètre:
[download] index-url = http://example.org
Il faut exécuter la commande:
% pip config unset download.index-url
Import de modules
Un module peut être un autre fichier Python .py
ou un fichier C/C++. Un module possède un namespace privé et ce namespace n’est pas directement accessible à l’extérieur du module. Un module peut importer un autre module.
Pour utiliser un module, il faut l’importer. Plusieurs solutions sont possibles:
import <nom du module>
: le module est importé dans le namespace local toutefois tous les noms des objets ne sont pas accessibles à partir du namespace local. Pour accéder aux objets du module, il faut taper<nom du module>.<nom de l'objet>
.Par exemple:
import pandas data = pandas.DataFrame()
import <nom de l'objet> as <nom alias>
: permet d’éviter d’utiliser le nom entier du module pour accéder à ses objets. Avec cette syntaxe, le module est importé dans le namespace local toutefois les objets ne sont accessibles qu’en utilisant l’alias du module:<nom alias>.<nom de l'objet>
.Par exemple:
import pandas as pd data = pd.DataFrame()
from <nom du module> import <nom de l'objet>
: on ne charge qu’un seul objet du module dans le namespace local. Cet objet est accessible en utilisant directement son nom.Par exemple:
from pandas import DataFrame data = DataFrame()
from <nom du module> import *
: tous les noms des objets du module sont importés dans le namespace local. Il n’est pas recommandé d’utiliser cette syntaxe car il peut y avoir des collisions entre des modules qui utiliseraient les mêmes noms d’objet. Avec cette syntaxe, les objets sont accessibles directement par leur nom.Par exemple:
from pandas import * data = DataFrame()
from <nom du module> import <nom de l'objet> alias <alias de l'objet>
: cette syntaxe permet d’importer le nom d’un objet du module et de permettre d’utiliser cet objet en utilisant un alias.Par exemple:
from pandas import DataFrame as PandasDataframe data = PandasDataframe()
__file__
Quand un module est chargé à partir d’un fichier, on peut voir le chemin de ce fichier en utilisant la variable: <module ou alias>.__file__
.
Par exemple:
- Si on importe le module de cette façon:
import numpy
On peut voir le chemin du fichier utlisé pour l’initialisation avec:numpy.__file__
- Si on importe le module en utilisant un alias:
import numpy as npy
Alors:npy.__file__
affichera le chemin du fichier d’initialisation.
Avoir des informations sur un package installé
On peut obtenir des informations concernant un package installés comme son emplacement en utilisant importlib
.
Par exemple, pour rechercher des informations concernant numpy
:
>>> import importlib >>> importlib.util.find_spec('numpy') ModuleSpec(name='numpy', loader=<_frozen_importlib_external.SourceFileLoader object at 0xffffa3cbdb80>, origin='/home/parallels/Documents/PYTHON/PIP_TESTS/VENV/venv/lib/python3.9/site-packages/numpy/__init__.py', submodule_search_locations=['/home/parallels/Documents/PYTHON/PIP_TESTS/VENV/venv/lib/python3.9/site-packages/numpy'])
dir()
La fonction permet de lister les noms d’objets définis dans le namespace local. Cette fonction permet de lister les variables, les fonctions et les modules.
Par exemple:
dir()
: sans argument, ce sont les noms de variables, fonctions et modules qui sont accessibles dans le namespace local qui sont listés.dir(<nom du module>)
: liste les objets accessibles dans le module.
Package wheel .whl
Un package wheel .whl
est un fichier zip
contenant les fichiers .py
ou les bibliothèques nécessaires pour utiliser la dépendance. A l’installation, les répertoires dans le package sont décompressés dans le répertoire Python contenant les dépendances, par exemple dans le cas d’un environnement virtuel ce répertoire est du type:
<chemin du l'env. virtuel>/lib/site-packages
Plus haut, on détaille les répertoires d’installation des packages suivant quelques cas de figure.
Généralement, les packages contiennent:
- Un répertoire avec le nom du package contenant les fichiers Python
.py
- Un répertoire nommé
<nom package>-<version>.dist-info
contenant des informations concernant le package.
D’autres répertoires peuvent exister, en particulier si le package nécessite des dépendances dans des bibliothèques en C/C++.
Construire un package wheel
Il existe 2 méthodes pour construire des packages (cf. Build System Interface): avec un fichier .toml
ou avec un fichier setup.py
. Dans cet article, on explicitera seulement la méthode avec setup.py
.
Pour construire un package wheel, il faut que le projet comporte à minima certains fichiers comme:
setup.py
pour exécuter du code à l’installation et fournir les informations concernant le projet.- éventuellement un fichier
__init__.py
pour que le projet soit importable après installation.
Si on prend le même exemple de projet que celui présenté précédemment. Ce projet comprend les fichiers suivants:
python_package_example
├── LICENSE
├── PeopleCounter
│ ├── Counter.py
│ ├── __init__.py
│ └── ScientistRepository.py
├── README.md
└── setup.py
Pour utiliser le fichier setup.py
, il faut installer le package setuptools
en exécutant:
pip install setuptools
Le fichier setup.py
doit, au minimum, comporter des informations relatives au projet, par exemple:
from setuptools import setup
setup(name='PeopleCounter',
version='1.0',
description='Python package example',
author='MM',
author_email='',
packages=['PeopleCounter'],
url="https://github.com/msoft/python_package_example",
license='MIT',
python_requires='>=3.8',
install_requires=[ 'numpy' ]
)
Les éléments importants sont:
name
: le nom du projetversion
: il faut en particulier utiliser les conventions indiquées précédemmentpackages
: chaînes de caractères indiquant le package qui sera manipulé par setuptools.install_requires
: indiquant les dépendances du package à construire.
Au minimum, il faut que les éléments name
, version
et packages
soient indiqués. On peut trouver une liste plus exhaustive d’éléments qu’il est possible de préciser dans le fichier setup.py
sur la page suivante: setuptools.pypa.io/en/latest/references/keywords.html.
On peut trouver un autre exemple simple de projet sur: github.com/pypa/sampleproject.
La documentation de setuptools
se trouve sur la page suivante: setuptools.pypa.io/en/latest/userguide/index.html.
Dans le fichier setup.py
, on peut rajouter des classificateurs (i.e. classifiers). Ce sont des indications utilisées pour la documentation. Ces indications peuvent servir si le package est uploadé dans un repository comme PyPI. Dans le cas de PyPI, on peut trouver une liste des classificateurs sur la page: pypi.org/pypi?%3Aaction=list_classifiers.
Une fois que le fichier setup.py
est créé, on peut tester son installation/désinstallation en exécutant:
- Installer le projet avec pip en utilisant:
% pip install .
- Désinstaller en exécutant:
% pip uninstall peoplecounter
Les commandes précédentes permettent d’effectuer l’installation et la désinstallation à partir des fichiers source du projet juste dans le cadre d’un test.
Pour construire le package de distribution wheel à proprement parler, il faut exécuter dans le répertoire du projet:
% python setup.py bdist_wheel
On peut trouver une documentation plus complète sur wheel sur wheel.readthedocs.io/en/stable.
Quelques détails sur les packages wheel
bdist_wheel
permet de construire des packages wheel .whl
mais il est possible de générer d’autres types de packages:
- Ancien package
.egg
avecsdist
:python setup.py sdist
- Des packages RPM (RedHat Package Manager) avec
bdist_rpm
:python setup.py bdist_rpm
oupython setup.py bdist --format=rpm
- Des archives
.tar.gz
ou.zip
suivant la plateforme avecbdist_dumb
:
python setup.py bdist_dumb
python setup.py bdist --format=gztar
python setup.py bdist --format=zip
Au lieu de définir des données concernant le package dans le fichier setup.py
, il est possible d’utiliser un fichier de configuration setup.cfg
. Ce fichier doit être placé dans le même répertoire que setup.py
. Il existe des équivalences entre les paramètres indiqués dans le fichier setup.py
et setup.cfg
. Pour trouver une liste exhaustive des paramètres utilisables dans le fichier setup.cfg
, on peut se reporter sur la documentation de setuptools
.
Dans le cas où on utilise bdist_wheel
pour générer un package wheel, il sera généré dans le répertoire:
<répertoire du projet>/dist
Le nom du fichier généré est de type:
<nom package>-<version>-<tag python>-<tag ABI>-<tag platform>.whl
avec:
- Tag python correspondant à:
py
pour la version générique de Pythonpy3
pour Python 3cp
pour CPythonip
pour IronPythonpp
pour PyPy
- Tag ABI:
ABI correspond à Application Binary Interface. A chaque version de Python, l’API C de Python est modifiée. La majorité de ces changements ne modifient pas la compatibilité du code source toutefois ils peuvent casser la compatibilité binaire. L’interface binaire de Python est donc identifiée car elle change pour chaque version. Un package peut être dépendant de cette interface. Si c’est le cas, le tag ABI permet d’indiquer l’interface avec laquelle le package est compatible. S’il n’y a pas de dépendances avec l’ABI, le tag ABI est"none"
.Dans le cas d’une dépendance, la version de CPython est indiquée, par exemple:
cp33
pour CPython 3.3.cp33d
pour la version debug de Python 3.3.
On peut limiter à une ABI particulière un package en utilisant le paramètre
--py-limited-api
à la construction du package. - Tag platform: permet d’indiquer la plate-forme avec laquelle le package est compatible. Sans indication particulière, l’indication est
”any”
. Par exemple, la plate-forme peut être:win32
pour Windows 32-bits.linux_i386
pour un set d’instructions compatible i386.linux_x86_64
pour la version 64 bits du set d’instructions x86.aarch64
pour les instructions ARM 64 bits.
On peut limiter à une plate-forme particulière un package en utilisant le paramètre
--plat-name
à la construction du package:% python setup.py bdist_wheel --plat-name linux_x86_64
Pour installer le package, il suffit d’exécuter:
pip install <chemin du fichier .whl>
CPython
On a coutume de dire que Python est un langage interprété. C’est vrai toutefois il n’est pas interprété au même titre que Javascript par exemple. L’implémentation originale de Python est CPython. CPython est à la fois un interpréteur et un compilateur implémenté en C.
Lors de l’exécution de code Python, CPython effectue les étapes suivantes:
- Initialisation de CPython: cette étape permet d’initialiser les structures de données nécessaire pour exécuter Python, préparer les types de bases du langage, configurer et charger les modules de base.
- Compilation du code source: le code source est transformé en bytecode. Des optimisations peuvent être appliquées sur le bytecode généré.
- Interprétation du bytecode: du fait que le code généré n’est pas du code machine, on considère que CPython interprète le code Python sous forme de bytecode.
Il existe d’autres implémentations de Python fonctionnant différemment comme:
- Jython implémenté en Java et convertissant le code Python en Java bytecode.
- IronPython implémenté en C# et convertissant le code Python en bytecode interprétable par le CLR (MSIL).
- PyPy: autre implémentation de Python permettant d’utiliser un compilateur JIT (Just-In-Time).
L’architecture de CPython faite en couches, les différents niveaux de ces couches pourraient être:
- Runtime: correspond à l’état global du processsus, il inclut le GIL (cf. Global Interpreter Lock et le mécanisme d’allocation de la mémoire. Le GIL est un mutex au niveau du processus autorisant l’exécution d’un seul thread permettant de contrôler l’interpréteur Python.
- L’interpréteur: groupe de threads ainsi que les données qu’ils partagent comme les modules importés.
- Thread: données relatives à un seul thread contenant la pile d’exécution (cf. call stack).
- Frame (cf. execution frame ou structure de la pile): correspond à un élément de la pile d’exécution (cf. call stack). Une frame contient l’objet du code (cf. object code) qui est le résultat de la compilation et elle fournit un état pour exécuter cet objet.
- Boucle d’évaluation: permet d’exécuter les objets d’une frame.
Si on considère le code suivant dans un fichier test.py
:
def print_hello_world():
print('Hello world')
if __name__ == 'main':
print_hello_world()
Si on compile ce code en exécutant:
% python -m py_compile test.py
On obtient un fichier test.cpython-36.pyc
dans le répertoire __pycache__
.
Si on décompile le fichier en exécutant le code suivant:
import platform
import time
import sys
import binascii
import marshal
import dis
import struct
def view_pyc_file(path):
"""Read and display a content of the Python`s bytecode in a pyc-file."""
file = open(path, 'rb')
magic = file.read(4)
timestamp = file.read(4)
size = None
if sys.version_info.major == 3 and sys.version_info.minor >= 3:
size = file.read(4)
size = struct.unpack('I', size)[0]
print(file)
code = marshal.load(file)
magic = binascii.hexlify(magic).decode('utf-8')
timestamp = time.asctime(time.localtime(struct.unpack('I', timestamp)[0]))
dis.disassemble(code)
print('-' * 80)
print('Python version: {}\nMagic code: {}\nTimestamp: {}\nSize: {}'
.format(platform.python_version(), magic, timestamp, size)
)
file.close()
if __name__ == '__main__':
print(sys.argv[1])
view_pyc_file(sys.argv[1])
Source du code: https://stackoverflow.com/questions/11141387/given-a-python-pyc-file-is-there-a-tool-that-let-me-view-the-bytecode
On obtient:
% python view_pyc_file.py __pycache__/test.cpython-39.pyc:
2 0 LOAD_CONST 0 (<code object print_hello_world at 0x000000145877D5030, file "test.py", line 2>)
2 LOAD_CONST. 1 ('print_hello_world)
4 MAKE_FUNCTION 0
6 STORE_NAME 0 (print_hello_world)
5 8 LOAD_NAME 1 (__name__)
10 LOAD_CONST 2 ('__main__')
12 COMPARE_OP 2 (==)
14 POP_JUMP_IF_FALSE 22
16 LOAD_NAME 0 (print_hello_world)
18 CALL_FUnCTION 0
20 POP_TOP
>> 22 LOAD_CONST 3 (None)
24 RETURN_VALUE
L’en-tête du fichier bytecode contient:
- Un nombre sur 4 octets: magic number. Ce nombre est composé de 2 premiers octets qui changent pour chaque changement dans le code marshallé (typiquement ce nombre peut changer d’une version à l’autre de python). Les 2 octets suivant sont des caractères de retour à la ligne (carriage return et line feed). Le but du magic number est d’éviter la corruption du fichier
.pyc
par copie. Si ce fichier est lu comme un fichier texte, le retour à la ligne va corrompre le magic number. - Une indication de date sur 4 octets (timestamp): ce timestamp indique l’heure Unix de génération du fichier.
- Le reste de fichier contient l’objet code marshallé (code objet) correspondant au bytecode généré.
Dans le code affiché:
- Les numéros à gauche 2, 5, 6 correspondent au numéros de ligne dans le code source.
- Les numéros suivant vers la droite 0, 2, 4, 6 correspondent au décalage par rapport au début du fichier source.
- La colonne suivante contient les instructions.
- L’argument des instructions sous la forme d’un entier.
- Le caractère
>>
correspond au point atteint après un saut d’instruction. Par exemple l’instructionPOP_JUMP_IF_FALSE
renvoie à l’instruction 22.
Pour résumer
Installer des packages
pip install <noms des packages>
Par exemple: pip install numpy
- Installation à partir d’un fichier
.zip
ou.tar.gz
:pip install -f <chemin de l'archive>
- Installation avec une condition de version:
pip install <noms des packages>==<version>
Par exemple:
pip install numpy==1.19
- Installation en mode éditable:
pip install -e <chemin du répertoire contenant le setup.py>
- Installation à partir d’un repository GitHub:
pip install git+<url repo. .git>
Par exemple:
pip install git+https://github.com/msoft/python_package_example.git
- Installation à partir d’un fichier
requirements.txt
:pip install -r <chemin du fichier requirements.txt>
- Installation d’une version en pré-release:
pip install --pre <nom du package>
Mettre à jour un package
pip install -U <nom du package>
Pour mettre à jour pip:
python -m pip install -U pip
Télécharger les packages .whl sans les installer
pip download <noms des packages>
Mêmes options que pour pip install
.
Désinstaller des packages
pip uninstall <noms des packages>
Lister les packages installés
pip list
Lister les packages obsolètes:
pip list -o
Chercher un package
pip search <nom du package>
Lister les packages avec leur version
pip freeze
Sauvegarder la liste des packages dans un fichier requirements.txt
:
pip freeze > requirements.txt
Afficher des informations concernant un package
pip show <nom du package>
Afficher le répertoire contenant le cache
pip cache dir
Import de modules
Les imports de module peuvent se faire de ces façons:
Syntaxe import | Objets du module | Exemple |
---|---|---|
import <nom du module> |
<nom du module>.<nom de l'objet> |
import pandas |
import <nom de l'objet> as <nom alias> |
<nom alias>.<nom de l'objet> |
import pandas as pd |
from <nom du module> import <nom de l'objet> |
Directement avec le nom | from pandas import DataFrame |
from <nom du module> import * |
Directement avec le nom | from pandas import * |
from <nom du module> import <nom de l'objet> alias <alias de l'objet> |
Avec l’alias | from pandas import DataFrame as PandasDataframe |
- setuptools keywords: https://setuptools.pypa.io/en/latest/references/keywords.html
- Using Python’s pip to Manage Your Projects’ Dependencies: https://realpython.com/what-is-pip/
- pip uninstall: https://pip.pypa.io/en/stable/cli/pip_uninstall/
- Editable installs: https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs
- Why you should use ‘python -m pip’: https://snarky.ca/why-you-should-use-python-m-pip/
- The hitchhiker’s guide to packaging: https://the-hitchhikers-guide-to-packaging.readthedocs.io/en/latest/pip.html
- Where Does pip Install Packages: https://www.codingem.com/where-does-pip-install-packages/
- When would the -e, –editable option be useful with pip install?: https://stackoverflow.com/questions/35064426/when-would-the-e-editable-option-be-useful-with-pip-install
- what does the __file__ variable mean/do?: https://stackoverflow.com/questions/9271464/what-does-the-file-variable-mean-do
- Requirement Specifiers: https://pip.pypa.io/en/stable/reference/requirement-specifiers/#requirement-specifiers
- How to setup pip to download from mirror repository by default?: https://stackoverflow.com/questions/60814982/how-to-setup-pip-to-download-from-mirror-repository-by-default
- Pip, Virtualenv, Pipenv Cheat Sheet: https://cheatography.com/djackh/cheat-sheets/pip-virtualenv-pipenv/
- Python vs Cpython: https://stackoverflow.com/questions/17130975/python-vs-cpython
- Python behind the scenes #1: how the CPython VM works: https://tenthousandmeters.com/blog/python-behind-the-scenes-1-how-the-cpython-vm-works/
- How to generate byte code file in python ?: https://www.geeksforgeeks.org/generate-byte-code-file-python/
- Command-line use: https://docs.python.org/3/library/compileall.html#command-line-use
- Given a python .pyc file, is there a tool that let me view the bytecode?: https://stackoverflow.com/questions/11141387/given-a-python-pyc-file-is-there-a-tool-that-let-me-view-the-bytecode
- How to read python bytecode?: https://stackoverflow.com/questions/19560057/how-to-read-python-bytecode
- How can I understand a .pyc file content: https://stackoverflow.com/questions/32562163/how-can-i-understand-a-pyc-file-content
- The structure of .pyc files: https://nedbatchelder.com/blog/200804/the_structure_of_pyc_files.html
- Setuptools: https://en.wikipedia.org/wiki/Setuptools#Package_format
- CPython: https://en.wikipedia.org/wiki/CPython
- Code objet: https://fr.wikipedia.org/wiki/Code_objet
- What is an execution frame?: https://stackoverflow.com/questions/2390705/what-is-an-execution-frame
- Pile d’exécution: https://fr.wikipedia.org/wiki/Pile_d%27ex%C3%A9cution
- How does python find packages?: https://leemendelowitz.github.io/blog/how-does-python-find-packages.html
- Modules: https://docs.python.org/fr/3/tutorial/modules.html?highlight=import
- Wheel user guide: https://wheel.readthedocs.io/en/stable/user_guide.html
- Python Modules and Packages – An Introduction: https://realpython.com/python-modules-packages/
- How to Create a Wheel file for your Python package and import it in another project: https://www.realpythonproject.com/how-to-create-a-wheel-file-for-your-python-package-and-import-it-in-another-project/
- Python: Creating a pip installable package: https://betterscientificsoftware.github.io/python-for-hpc/tutorials/python-pypi-packaging/
- Python Packaging User Guide: https://packaging.python.org/
- Packaging and distributing projects: https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/
- Creating Built Distributions: https://docs.python.org/3/distutils/builtdist.html
- How to Build a Python package?: https://www.geeksforgeeks.org/how-to-build-a-python-package/
- Different Types of Wheels: https://realpython.com/python-wheels/#different-types-of-wheels
- Google colab: https://colab.research.google.com/