Como verificar a versão dos módulos python?

Acabei de instalar os módulos python: constructe statlibcom o setuptoolsseguinte:

# 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

Quero poder (programaticamente) verificar suas versões. Existe um equivalente ao que python --versioneu possa executar na linha de comando?

Minha versão do python é 2.7.3.

Sugiro usar pip no lugar de easy_install . Com o pip, você pode listar todos os pacotes instalados e suas versões com

pip freeze

Na maioria dos sistemas Linux, você pode canalizar isso para grep(ou findstrno Windows) para encontrar a linha do pacote específico em que está interessado:

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

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

Para um módulo individual, você pode tentar o __version__atributo , no entanto, existem módulos sem ele:

$ 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 fim, como os comandos em sua pergunta são prefixados sudo, parece que você está instalando no ambiente global de python. Recomendamos vivamente que olhe para os gerenciadores de ambiente virtual python , por exemplo virtualenvwrapper

Podes tentar

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

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

Use o pkg_resourcesmódulo distribuído com a setuptoolsbiblioteca. Observe que a string que você passa para o get_distributionmétodo deve corresponder à entrada PyPI.

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

e se você quiser executá-lo na linha de comando, você pode:

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

Observe que a string que você passa para o get_distributionmétodo deve ser o nome do pacote, conforme registrado no PyPI, não o nome do módulo que você está tentando importar.

Infelizmente, estes nem sempre são os mesmos (por exemplo, você faz pip install memcached, mas import memcache).

Eu acho que isso pode ajudar, mas primeiro instale o showpacote para executar pip showe use show para encontrar a versão!

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

A melhor maneira de fazer isso é:

Para os detalhes de pacote específico

pip show <package_name>

Ele detalha o nome do pacote, versão, autor, local 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 mais detalhes: >>> pip help

pip install --upgrade pip

No Windows, o comando recomendado é:

python -m pip install --upgrade pip

Em python3 com colchetes ao redor da impressão

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

module.__version__ é uma boa primeira coisa a tentar, mas nem sempre funciona.

Se você não deseja desembolsar e está usando o pip 8 ou 9, ainda pode usar pip.get_installed_distributions()para obter versões no Python:

update: a solução aqui funciona no pip 8 e 9, mas no pip 10 a função foi movida de pip.get_installed_distributionspara pip._internal.utils.misc.get_installed_distributionspara indicar explicitamente que não é para uso externo. Não é uma boa ideia confiar nisso se você estiver usando o 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', ...]

As respostas anteriores não resolveram meu problema, mas esse código:

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

Você pode usar importlib_metadata biblioteca para isso.

Se você estiver em python <3.8, primeiro instale-o com:

pip install importlib_metadata

Desde python 3.8 ele está incluído na biblioteca padrão.

Em seguida, para verificar a versão de um pacote (neste exemplo lxml), execute:

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

Lembre-se de que isso funciona apenas para pacotes instalados a partir do PyPI. Além disso, você deve passar um nome de pacote como argumento para o versionmétodo, em vez de um nome de módulo que esse pacote fornece (embora eles geralmente sejam os mesmos).

Use dir()para descobrir se o módulo possui algum __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']

Se os métodos acima não funcionarem, vale a pena tentar o seguinte em python:

import modulename

modulename.version
modulename.version_info

Consulte Obter versão do Tornado Python?

Note, o .versiontrabalhou para mim em alguns outros além do furacão também.

primeiro adicione python, pip às suas variáveis ​​de ambiente. para que você possa executar seus comandos no prompt de comando. então simplesmente dê python comando . depois importe o pacote

->import scrapy

depois imprima o nome da versão

->print(scrapy.__version__)

Isso definitivamente funcionará

Supondo que estamos usando o Jupyter Notebook (se estiver usando o Terminal, solte os pontos de exclamação):

1) se o pacote (por exemplo, xgboost) foi instalado com o pip :

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

2) se o pacote (por exemplo, caffe) foi instalado com o conda :

!conda list caffe

Alguns módulos não têm __version__atributo, portanto, a maneira mais fácil é verificar o terminal:pip list

Na versão Python 3.8, há um novo metadatamódulo no importlibpacote, que também pode fazer isso.

Aqui está um exemplo dos documentos:

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

Sugiro abrir um pythonshell no terminal (na versão python que você está interessado), importar a biblioteca e obter seu __version__atributo.

>>> import statlib
>>> statlib.__version__

>>> import construct
>>> contruct.__version__

Nota 1: Devemos considerar a versão python . Se instalamos versões diferentes do python, temos que abrir o terminal na versão python em que estamos interessados. Por exemplo, abrir o terminal com python3.8can (certamente fornecerá) fornecer uma versão diferente de uma biblioteca do que abrir com python3.5ou python2.7.

Nota 2: Nós evitar o uso da printfunção , porque o seu comportamento depende python2 ou python3. Não precisamos dele, o terminal mostrará o valor da expressão.

Isso também funciona no Jupyter Notebook no Windows! Desde que o Jupyter seja iniciado a partir de uma linha de comando compatível com o bash, como Git Bash (MingW64), as soluções fornecidas em muitas das respostas podem ser usadas no Jupyter Notebook nos sistemas Windows com um pequeno ajuste.

Estou executando o Windows 10 Pro com o Python instalado via Anaconda, e o código a seguir funciona quando inicio o Jupyter via Git Bash (mas não quando inicio no prompt do Anaconda).

O ajuste: adicione um ponto de exclamação ( !) na frente pippara torná-lo !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 python rápido para listar todos os pacotes (você pode copiá-lo para 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)

A saída seria semelhante a:

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

(consulte também https://stackoverflow.com/a/56912280/7262247 )

Achei bastante confiável usar as várias ferramentas disponíveis (incluindo a melhor pkg_resourcesmencionada pela resposta de Jakub Kukul ), pois a maioria delas não cobre todos os casos . Por exemplo

• módulos embutidos
• módulos não instalados, mas adicionados ao caminho do python (por seu IDE, por exemplo)
• duas versões do mesmo módulo disponíveis (uma no caminho python substituindo a outra instalada)

Como precisávamos de uma maneira confiável de obter a versão de qualquer pacote, módulo ou submódulo, acabei escrevendo o getversion . É bastante simples de usar:

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

Veja a documentação para detalhes.

Para obter uma lista de módulos não padrão (pip) importados no módulo atual:

[{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:

Esse código foi criado a partir de soluções nesta página e em Como listar módulos importados?

Em suma:

conda list   

(Ele fornecerá todas as bibliotecas junto com os detalhes da versão).

E:

pip show tensorflow

(Ele fornece detalhes completos da biblioteca).

Com base na resposta de Jakub Kukul encontrei uma maneira mais confiável de resolver esse problema.

O principal problema dessa abordagem é que requer que os pacotes sejam instalados "convencionalmente" (e isso não inclui o uso de pip install --user ) ou estejam no PATH do sistema na inicialização do Python.

Para contornar isso, você pode usar pkg_resources.find_distributions(path_to_search). Isso basicamente procura por distribuições que seriam importáveis ​​se path_to_searchestivessem no sistema PATH.

Podemos iterar através deste gerador como este:

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

Isso retornará um dicionário com módulos como chaves e sua versão como valor. Essa abordagem pode ser estendida para muito mais que o número da versão.

Obrigado a Jakub Kukul por apontar para a direção certa

Escrevendo esta resposta para usuários do Windows. Conforme sugerido em todas as outras respostas, você pode usar as instruções como:

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

Porém, existem alguns módulos que não imprimem sua versão mesmo após o uso do método acima. Então, o que você pode simplesmente fazer é:

1. Abra o prompt de comando.
2. Navegue até o endereço / diretório do arquivo usando cd [ endereço do arquivo ] onde você manteve seu python e todos os módulos de suporte instalados.
3. use o comando " pip install [module name] " e pressione enter.
4. Isso exibirá uma mensagem como " Requisito já satisfeito: endereço do arquivo \ nome da pasta (com versão) ".
5. Veja a captura de tela abaixo para ex: eu precisava conhecer a versão de um módulo pré-instalado chamado "Selenium-Screenshot". Ele me mostrou corretamente como 1.5.0:

Você pode tentar isso:

pip list

Isso produzirá todos os pacotes com suas versões. Resultado

você pode instalar primeiro um pacote como este e depois verificar sua versão

pip install package
import package
print(package.__version__)

deve fornecer a versão do pacote