Comment vérifier la version des modules python?

Je viens d'installer les modules python: constructet statlibavec setuptoolscomme ça:

# Install setuptools to be able to download the following
sudo apt-get install python-setuptools

# Install statlib for lightweight statistical tools
sudo easy_install statlib

# Install construct for packing/unpacking binary data
sudo easy_install construct

Je veux pouvoir (par programmation) vérifier leurs versions. Existe-t-il un équivalent que python --versionje peux exécuter à partir de la ligne de commande?

Ma version python est 2.7.3.

Je suggère d'utiliser pip à la place de easy_install . Avec pip, vous pouvez lister tous les packages installés et leurs versions avec

pip freeze

Dans la plupart des systèmes Linux, vous pouvez diriger cela vers grep(ou findstrsur Windows) pour trouver la ligne du package particulier qui vous intéresse:

Linux:
$ pip freeze | grep lxml
lxml==2.3

Windows:
c:\> pip freeze | findstr lxml
lxml==2.3

Pour un module individuel, vous pouvez essayer l' __version__attribut , mais il existe des modules sans lui:

$ python -c "import requests; print(requests.__version__)"
2.14.2
$ python -c "import lxml; print(lxml.__version__)"
Traceback (most recent call last):
  File "<string>", line 1, in <module>
AttributeError: 'module' object has no attribute '__version__'

Enfin, comme les commandes de votre question sont préfixées sudo, il semble que vous installez dans l'environnement global python. Il est fortement conseillé de se pencher sur les gestionnaires d' environnement virtuel python , par exemple virtualenvwrapper

Tu peux essayer

>>> import statlib
>>> print statlib.__version__

>>> import construct
>>> print contruct.__version__

Utilisez le pkg_resourcesmodule distribué avec la setuptoolsbibliothèque. Notez que la chaîne que vous passez à la get_distributionméthode doit correspondre à l'entrée PyPI.

>>> import pkg_resources
>>> pkg_resources.get_distribution("construct").version
'2.5.2'

et si vous voulez l'exécuter à partir de la ligne de commande, vous pouvez faire:

python -c "import pkg_resources; print(pkg_resources.get_distribution('construct').version)"

Notez que la chaîne que vous transmettez à la get_distributionméthode doit être le nom du package tel qu'il est enregistré dans PyPI, pas le nom du module que vous essayez d'importer.

Malheureusement, ce ne sont pas toujours les mêmes (par exemple vous le faites pip install memcached, mais import memcache).

Je pense que cela peut aider mais installez d'abord le showpaquet afin de l'exécuter pip showpuis utilisez show pour trouver la version!

sudo pip install show
# in order to get package version execute the below command
sudo pip show YOUR_PACKAGE_NAME | grep Version

La meilleure façon de le faire est:

Pour les détails du package spécifique

pip show <package_name>

Il détaille le nom du package, la version, l'auteur, l'emplacement, etc.

$ pip show numpy
Name: numpy
Version: 1.13.3
Summary: NumPy: array processing for numbers, strings, records, and objects.
Home-page: http://www.numpy.org
Author: NumPy Developers
Author-email: numpy-discussion@python.org
License: BSD
Location: c:\users\prowinjvm\appdata\local\programs\python\python36\lib\site-packages
Requires:

Pour plus de détails: >>> pip help

pip install --upgrade pip

Sous Windows, la commande recommandée est:

python -m pip install --upgrade pip

En python3 avec des crochets autour de l'impression

>>> import celery
>>> print(celery.__version__)
3.1.14

module.__version__ est une bonne première chose à essayer, mais cela ne fonctionne pas toujours.

Si vous ne voulez pas décortiquer et que vous utilisez pip 8 ou 9, vous pouvez toujours utiliser pip.get_installed_distributions()pour obtenir des versions à partir de Python:

mise à jour: la solution fonctionne ici dans les pip 8 et 9, mais dans la pip 10, la fonction a été déplacée de pip.get_installed_distributionsà pip._internal.utils.misc.get_installed_distributionspour indiquer explicitement qu'elle n'est pas destinée à un usage externe. Ce n'est pas une bonne idée de s'y fier si vous utilisez pip 10+.

import pip

pip.get_installed_distributions()  # -> [distribute 0.6.16 (...), ...]

[
    pkg.key + ': ' + pkg.version
    for pkg in pip.get_installed_distributions()
    if pkg.key in ['setuptools', 'statlib', 'construct']
] # -> nicely filtered list of ['setuptools: 3.3', ...]

Les réponses précédentes n'ont pas résolu mon problème, mais ce code a:

import sys 
for name, module in sorted(sys.modules.items()): 
  if hasattr(module, '__version__'): 
    print name, module.__version__ 

Vous pouvez utiliser importlib_metadata bibliothèque pour cela.

Si vous êtes sur python <3.8, installez-le d'abord avec:

pip install importlib_metadata

Depuis python 3.8 il est inclus dans la bibliothèque standard.

Ensuite, pour vérifier la version d'un package (dans cet exemple lxml), exécutez:

>>> from importlib_metadata import version
>>> version('lxml')
'4.3.1'

Gardez à l'esprit que cela ne fonctionne que pour les packages installés à partir de PyPI. En outre, vous devez passer un nom de package en tant qu'argument à la versionméthode, plutôt qu'un nom de module fourni par ce package (bien qu'ils soient généralement les mêmes).

Utilisez dir()pour savoir si le module a un __version__attribut.

>>> import selenium
>>> dir(selenium)
['__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '__path__', '__version__']
>>> selenium.__version__
'3.141.0'
>>> selenium.__path__
['/venv/local/lib/python2.7/site-packages/selenium']

Si les méthodes ci-dessus ne fonctionnent pas, il vaut la peine d'essayer ce qui suit en python:

import modulename

modulename.version
modulename.version_info

Voir Obtenir la version Python Tornado?

Remarque, cela a .versionfonctionné pour moi sur quelques autres en plus de la tornade.

ajoutez d'abord python, pip à vos variables d'environnement. afin que vous puissiez exécuter vos commandes à partir de l'invite de commande. puis donnez simplement la commande python . puis importez le package

->import scrapy

puis imprimez le nom de la version

->print(scrapy.__version__)

Cela fonctionnera certainement

En supposant que nous utilisons Jupyter Notebook (si vous utilisez Terminal, supprimez les points d'exclamation):

1) si le package (par exemple xgboost) a été installé avec pip :

!pip show xgboost
!pip freeze | grep xgboost
!pip list | grep xgboost

2) si le paquet (par exemple caffe) a été installé avec conda :

!conda list caffe

Certains modules n'ont pas d' __version__attribut, donc le moyen le plus simple est de vérifier dans le terminal:pip list

Dans la version Python 3.8, il y a un nouveau metadatamodule dans le importlibpackage, qui peut également le faire.

Voici un exemple de documents:

>>> from importlib.metadata import version
>>> version('requests')
'2.22.0'

Je suggère d'ouvrir un pythonshell dans le terminal (dans la version python qui vous intéresse), d'importer la bibliothèque et d'obtenir son __version__attribut.

>>> import statlib
>>> statlib.__version__

>>> import construct
>>> contruct.__version__

Note 1: Il faut considérer la version python . Si nous avons installé différentes versions de python, nous devons ouvrir le terminal dans la version python qui nous intéresse. Par exemple, ouvrir le terminal avec python3.8peut (sûrement) donner une version différente d'une bibliothèque que l'ouverture avec python3.5ou python2.7.

Remarque 2: Nous évitons d'utiliser la printfonction , car son comportement dépend de python2 ou python3. Nous n'en avons pas besoin, le terminal affichera la valeur de l'expression.

Cela fonctionne aussi dans Jupyter Notebook sous Windows! Tant que Jupyter est lancé à partir d'une ligne de commande compatible bash telle que Git Bash (MingW64), les solutions données dans de nombreuses réponses peuvent être utilisées dans Jupyter Notebook sur les systèmes Windows avec un petit ajustement.

J'utilise Windows 10 Pro avec Python installé via Anaconda, et le code suivant fonctionne lorsque je lance Jupyter via Git Bash (mais pas lorsque je lance à partir de l'invite Anaconda).

Le tweak: ajoutez un point d'exclamation ( !) devant pippour le faire !pip.

>>>!pip show lxml | grep Version
Version: 4.1.0

>>>!pip freeze | grep lxml
lxml==4.1.0

>>>!pip list | grep lxml
lxml                               4.1.0                  

>>>!pip show lxml
Name: lxml
Version: 4.1.0
Summary: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API.
Home-page: http://lxml.de/
Author: lxml dev team
Author-email: lxml-dev@lxml.de
License: BSD
Location: c:\users\karls\anaconda2\lib\site-packages
Requires: 
Required-by: jupyter-contrib-nbextensions

Programme python rapide pour lister tous les paquets (vous pouvez le copier dans requirements.txt )

from pip._internal.utils.misc import get_installed_distributions
print_log = ''
for module in sorted(get_installed_distributions(), key=lambda x: x.key): 
    print_log +=  module.key + '~=' + module.version  + '\n'
print(print_log)

La sortie ressemblerait à:

asn1crypto~=0.24.0
attrs~=18.2.0
automat~=0.7.0
beautifulsoup4~=4.7.1
botocore~=1.12.98

(voir également https://stackoverflow.com/a/56912280/7262247 )

J'ai trouvé assez peu fiable l'utilisation des différents outils disponibles (y compris le meilleur pkg_resourcesmentionné par la réponse de Jakub Kukul ), car la plupart d'entre eux ne couvrent pas tous les cas . Par exemple

• modules intégrés
• modules non installés mais juste ajoutés au chemin python (par votre IDE par exemple)
• deux versions du même module disponibles (une dans le chemin python remplaçant celle installée)

Comme nous avions besoin d'un moyen fiable pour obtenir la version de n'importe quel package, module ou sous-module, j'ai fini par écrire getversion . C'est assez simple à utiliser:

from getversion import get_module_version
import foo
version, details = get_module_version(foo)

Consultez la documentation pour plus de détails.

Pour obtenir une liste des modules non standard (pip) importés dans le module actuel:

[{pkg.key : pkg.version} for pkg in pip.get_installed_distributions() 
   if pkg.key in set(sys.modules) & set(globals())]

Résultat:

>>> import sys, pip, nltk, bs4
>>> [{pkg.key : pkg.version} for pkg in pip.get_installed_distributions() if pkg.key in set(sys.modules) & set(globals())]
[{'pip': '9.0.1'}, {'nltk': '3.2.1'}, {'bs4': '0.0.1'}]

Remarque:

Ce code a été compilé à partir de solutions à la fois sur cette page et de Comment lister les modules importés?

En résumé:

conda list   

(Il fournira toutes les bibliothèques ainsi que les détails de la version).

Et:

pip show tensorflow

(Il donne les détails complets de la bibliothèque).

Vous pouvez essayer ceci:

pip list

Cela affichera tous les packages avec leurs versions. Production

En m'appuyant sur la réponse de Jakub Kukul, j'ai trouvé un moyen plus fiable de résoudre ce problème.

Le principal problème de cette approche est que les packages doivent être installés "de manière conventionnelle" (et cela n'inclut pas l'utilisation pip install --user), ou être dans le système PATH lors de l'initialisation Python.

Pour contourner cela, vous pouvez utiliser pkg_resources.find_distributions(path_to_search). Cela recherche essentiellement les distributions qui seraient importables si elles se trouvaient path_to_searchdans le système PATH.

Nous pouvons parcourir ce générateur comme ceci:

avail_modules = {}
distros = pkg_resources.find_distributions(path_to_search)
for d in distros:
    avail_modules[d.key] = d.version

Cela renverra un dictionnaire ayant des modules comme clés et leur version comme valeur. Cette approche peut être étendue à bien plus que le numéro de version.

Merci à Jakub Kukul d'avoir indiqué la bonne direction

Écrire cette réponse pour les utilisateurs de Windows. Comme suggéré dans toutes les autres réponses, vous pouvez utiliser les déclarations comme:

import [type the module name]
print(module.__version__)      # module + '.' + double underscore + version + double underscore

Mais, certains modules n'impriment pas leur version même après avoir utilisé la méthode ci-dessus. Donc, ce que vous pouvez simplement faire, c'est:

1. Ouvrez l'invite de commande.
2. Accédez au répertoire / adresse de fichier en utilisant cd [ adresse de fichier ] où vous avez conservé votre python et tous les modules de support installés.
3. utilisez la commande " pip install [nom du module] " et appuyez sur Entrée.
4. Cela vous montrera un message comme " Exigence déjà satisfaite: adresse de fichier \ nom de dossier (avec version) ".
5. Voir la capture d'écran ci-dessous pour ex: je devais connaître la version d'un module pré-installé nommé "Selenium-Screenshot". Cela m'a montré correctement comme 1.5.0:

vous pouvez d'abord installer un paquet comme celui-ci, puis vérifier sa version

pip install package
import package
print(package.__version__)

cela devrait vous donner la version du package