¿Cómo verificar la versión de los módulos de Python?

Acabo de instalar los módulos de Python: constructy statlibcon setuptoolseste aspecto:

# 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

Quiero poder verificar (mediante programación) sus versiones. ¿Hay un equivalente a python --versionque puedo ejecutar desde la línea de comandos?

Mi versión de Python es 2.7.3.

Sugiero usar pip en lugar de easy_install . Con pip, puede enumerar todos los paquetes instalados y sus versiones con

pip freeze

En la mayoría de los sistemas Linux, puede canalizar esto grep(o findstren Windows) para encontrar la fila del paquete particular que le interesa:

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

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

Para un módulo individual, puede probar el __version__atributo , sin embargo, hay módulos sin él:

$ 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__'

Por último, como los comandos en su pregunta tienen el prefijo sudo, parece que está instalando en el entorno global de Python. Recomendamos encarecidamente que eche un vistazo a los administradores de entornos virtuales de Python , por ejemplo virtualenvwrapper

Puedes probar

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

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

Utilice el pkg_resourcesmódulo distribuido con la setuptoolsbiblioteca. Tenga en cuenta que la cadena que pasa al get_distributionmétodo debe corresponder a la entrada PyPI.

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

y si quieres ejecutarlo desde la línea de comando puedes hacer:

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

Tenga en cuenta que la cadena que pasa al get_distributionmétodo debe ser el nombre del paquete registrado en PyPI, no el nombre del módulo que está intentando importar.

Lamentablemente, estos no son siempre los mismos (p. Ej. pip install memcached, Pero sí import memcache).

¡Creo que esto puede ayudar pero primero instale el showpaquete para ejecutarlo y pip showluego use show para encontrar la versión!

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

La mejor manera de hacerlo es:

Para los detalles del paquete específico

pip show <package_name>

Detalla el nombre del paquete, la versión, el autor, la ubicación, 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:

Para más detalles: >>> pip help

pip install --upgrade pip

En Windows, el comando recomendado es:

python -m pip install --upgrade pip

En python3 con corchetes alrededor de impresión

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

module.__version__ es bueno probarlo primero, pero no siempre funciona.

Si no desea pagar, y está usando pip 8 o 9, aún puede usar pip.get_installed_distributions()para obtener versiones desde Python:

actualización: la solución aquí funciona en los pip 8 y 9, pero en el pip 10 la función se ha movido de pip.get_installed_distributionsa pip._internal.utils.misc.get_installed_distributionspara indicar explícitamente que no es para uso externo. No es una buena idea confiar en él si está utilizando 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', ...]

Las respuestas anteriores no resolvieron mi problema, pero este código sí:

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

Puedes usar la importlib_metadatabiblioteca para esto.

Si estás en Python <3.8, primero instálalo con:

pip install importlib_metadata

Desde python 3.8está incluido en la biblioteca estándar.

Luego, para verificar la versión de un paquete (en este ejemplo lxml) ejecute:

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

Tenga en cuenta que esto solo funciona para paquetes instalados desde PyPI. Además, debe pasar un nombre de paquete como argumento al versionmétodo, en lugar de un nombre de módulo que proporciona este paquete (aunque generalmente son los mismos).

Úselo dir()para averiguar si el módulo tiene algún __version__atributo.

>>> 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 los métodos anteriores no funcionan, vale la pena intentar lo siguiente en python:

import modulename

modulename.version
modulename.version_info

Ver Obtener la versión Python Tornado?

Tenga en cuenta que también .versionfuncionó para mí en algunos otros además del tornado.

primero agregue python, pip a sus variables de entorno. para que pueda ejecutar sus comandos desde el símbolo del sistema. entonces simplemente da el comando python . luego importe el paquete

->import scrapy

luego imprima el nombre de la versión

->print(scrapy.__version__)

Esto definitivamente funcionará

Suponiendo que estamos usando Jupyter Notebook (si usa Terminal, suelte los signos de exclamación):

1) si el paquete (por ejemplo, xgboost) se instaló con pip :

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

2) si el paquete (por ejemplo, caffe) se instaló con conda :

!conda list caffe

Algunos módulos no tienen __version__atributo, por lo que la forma más fácil es verificar en el terminal:pip list

En la versión Python 3.8 hay un nuevo metadatamódulo en el importlibpaquete, que también puede hacer eso.

Aquí hay un ejemplo de documentos:

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

Sugiero abrir un pythonshell en la terminal (en la versión de Python que le interesa), importar la biblioteca y obtener su __version__atributo.

>>> import statlib
>>> statlib.__version__

>>> import construct
>>> contruct.__version__

Nota 1: Debemos considerar la versión de Python . Si hemos instalado diferentes versiones de python, tenemos que abrir el terminal en la versión de python que nos interesa. Por ejemplo, abrir el terminal con python3.8can (seguramente lo hará) dará una versión diferente de una biblioteca que abrir con python3.5o python2.7.

Nota 2: Nos evitamos el uso de la printfunción , debido a que su comportamiento depende de python2 o python3. No lo necesitamos, el terminal mostrará el valor de la expresión.

¡Esto también funciona en Jupyter Notebook en Windows! Siempre que Jupyter se inicie desde una línea de comandos compatible con bash como Git Bash (MingW64), las soluciones dadas en muchas de las respuestas se pueden usar en Jupyter Notebook en sistemas Windows con un pequeño ajuste.

Estoy ejecutando Windows 10 Pro con Python instalado a través de Anaconda, y el siguiente código funciona cuando ejecuto Jupyter a través de Git Bash (pero no cuando inicio desde el indicador de Anaconda).

El ajuste: agregue un signo de exclamación ( !) delante pippara hacerlo !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

Programa de pitón rápida para enumerar todos los packges (se puede copiar a 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 salida se vería así:

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

(ver también https://stackoverflow.com/a/56912280/7262247 )

Me pareció poco confiable usar las diversas herramientas disponibles (incluida la mejor pkg_resourcesmencionada por la respuesta de Jakub Kukul ), ya que la mayoría de ellas no cubren todos los casos . Por ejemplo

• módulos incorporados
• módulos no instalados pero recién agregados a la ruta de Python (por su IDE por ejemplo)
• Dos versiones del mismo módulo disponibles (una en la ruta de Python reemplazando a la instalada)

Como necesitábamos una forma confiable de obtener la versión de cualquier paquete, módulo o submódulo, terminé escribiendo getversion . Es bastante simple de usar:

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

Consulte la documentación para más detalles.

Para obtener una lista de módulos no estándar (pip) importados en el módulo actual:

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

Resultado:

>>> 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'}]

Nota:

Este código se creó a partir de soluciones tanto en esta página como en ¿Cómo enumerar los módulos importados?

En resumen:

conda list   

(Proporcionará todas las bibliotecas junto con los detalles de la versión).

Y:

pip show tensorflow

(Da detalles completos de la biblioteca).

Sobre la base de la respuesta de Jakub Kukul, encontré una forma más confiable de resolver este problema.

El principal problema de ese enfoque es que requiere que los paquetes se instalen "convencionalmente" (y eso no incluye el uso pip install --user), o que estén en la RUTA del sistema en la inicialización de Python.

Para evitar eso, puedes usarlo pkg_resources.find_distributions(path_to_search). Básicamente, esto busca distribuciones que serían importables si path_to_searchestuviera en la RUTA del sistema.

Podemos iterar a través de este generador así:

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

Esto devolverá un diccionario que tenga módulos como claves y su versión como valor. Este enfoque puede extenderse a mucho más que el número de versión.

Gracias a Jakub Kukul por señalar la dirección correcta.

Escribir esta respuesta para usuarios de Windows. Como se sugiere en todas las otras respuestas, puede usar las declaraciones como:

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

Pero, hay algunos módulos que no imprimen su versión incluso después de usar el método anterior. Entonces, lo que simplemente puedes hacer es:

1. Abra el símbolo del sistema.
2. Navegue a la dirección / directorio del archivo utilizando cd [ dirección del archivo ] donde ha mantenido su python y todos los módulos de soporte instalados.
3. use el comando " pip install [nombre del módulo] " y presione enter.
4. Esto le mostrará un mensaje como " Requisito ya satisfecho: dirección del archivo \ nombre de la carpeta (con versión) ".
5. Vea la captura de pantalla a continuación, por ejemplo: tenía que conocer la versión de un módulo preinstalado llamado "Selenium-Screenshot". Me mostró correctamente como 1.5.0:

Puedes probar esto:

pip list

Esto generará todos los paquetes con sus versiones. Salida

primero puede instalar un paquete como este y luego verificar su versión

pip install package
import package
print(package.__version__)

debería darte la versión del paquete