Come controllare la versione dei moduli Python?

Ho appena installato i moduli Python: constructe statlibcon setuptoolsquesto:

# 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

Voglio poter controllare (programmaticamente) le loro versioni. Esiste un equivalente python --versionche posso eseguire dalla riga di comando?

La mia versione di Python è 2.7.3.

Suggerisco di usare pip al posto di easy_install . Con pip, puoi elencare tutti i pacchetti installati e le loro versioni con

pip freeze

Nella maggior parte dei sistemi Linux, puoi reindirizzare questo grep(o findstrsu Windows) per trovare la riga per il pacchetto specifico che ti interessa:

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

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

Per un singolo modulo, puoi provare l' __version__attributo , tuttavia ci sono moduli senza di esso:

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

Infine, poiché i comandi nella tua domanda hanno il prefisso sudo, sembra che tu stia installando nell'ambiente python globale. Consiglio vivamente di dare un'occhiata ai gestori dell'ambiente virtuale Python , ad esempio virtualenvwrapper

Puoi provare

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

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

Utilizzare il pkg_resourcesmodulo distribuito con la setuptoolslibreria. Si noti che la stringa che si passa al get_distributionmetodo deve corrispondere alla voce PyPI.

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

e se vuoi eseguirlo dalla riga di comando puoi fare:

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

Si noti che la stringa che si passa al get_distributionmetodo dovrebbe essere il nome del pacchetto registrato in PyPI, non il nome del modulo che si sta tentando di importare.

Sfortunatamente questi non sono sempre gli stessi (ad es. pip install memcached, Ma import memcache).

Penso che questo possa aiutare, ma prima installa il showpacchetto per eseguirlo, pip showquindi usa show per trovare la versione!

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

Il modo migliore per farlo è:

Per i dettagli del pacchetto specifico

pip show <package_name>

Descrive in dettaglio nome_pacchetto, versione, autore, posizione ecc.

$ 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:

Per ulteriori dettagli: >>> pip help

pip install --upgrade pip

Su Windows il comando consigliato è:

python -m pip install --upgrade pip

In python3 con parentesi attorno alla stampa

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

module.__version__ è una buona prima cosa da provare, ma non sempre funziona.

Se non vuoi sborsare, e stai usando pip 8 o 9, puoi comunque usare pip.get_installed_distributions()per ottenere le versioni da Python:

aggiornamento: la soluzione qui funziona nel pip 8 e 9, ma nel pip 10 la funzione è stata spostata da pip.get_installed_distributionsa pip._internal.utils.misc.get_installed_distributionsper indicare esplicitamente che non è per uso esterno. Non è una buona idea fare affidamento su di esso se si utilizza 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', ...]

Le risposte precedenti non hanno risolto il mio problema, ma questo codice ha fatto:

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

Puoi usare importlib_metadata libreria per questo.

Se sei su Python <3.8, installalo prima con:

pip install importlib_metadata

Dal momento che pitone 3.8 è incluso nella libreria standard.

Quindi, per verificare la versione di un pacchetto (in questo esempio lxml) eseguire:

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

Tieni presente che questo funziona solo per i pacchetti installati da PyPI. Inoltre, è necessario passare un nome di pacchetto come argomento al versionmetodo, anziché un nome di modulo fornito da questo pacchetto (sebbene di solito siano gli stessi).

Utilizzare dir()per scoprire se il modulo ha un __version__attributo.

>>> 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 i metodi di cui sopra non funzionano, vale la pena provare quanto segue in Python:

import modulename

modulename.version
modulename.version_info

Vedi Ottieni la versione di Python Tornado?

Nota, ha .versionfunzionato per me su alcuni altri oltre al tornado.

prima aggiungi python, pip alle variabili di ambiente. in modo da poter eseguire i comandi dal prompt dei comandi. quindi dai semplicemente pitone comando . quindi importare il pacchetto

->import scrapy

quindi stampare il nome della versione

->print(scrapy.__version__)

Funzionerà sicuramente

Supponendo che stiamo usando Jupyter Notebook (se si utilizza Terminale, rilasciare i punti esclamativi):

1) se il pacchetto (ad es. Xgboost) è stato installato con pip :

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

2) se il pacchetto (ad es. Caffe ) è stato installato con conda :

!conda list caffe

Alcuni moduli non hanno __version__attributi, quindi il modo più semplice è controllare nel terminale:pip list

Nella versione 3.8 di Python c'è un nuovo metadatamodulo nel importlibpacchetto, che può farlo anche.

Ecco un esempio dai documenti:

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

Suggerisco di aprire una pythonshell nel terminale (nella versione di Python che ti interessa), importare la libreria e ottenere il suo __version__attributo.

>>> import statlib
>>> statlib.__version__

>>> import construct
>>> contruct.__version__

Nota 1: dobbiamo considerare la versione di Python . Se abbiamo installato diverse versioni di Python, dobbiamo aprire il terminale nella versione Python a cui siamo interessati. Ad esempio, aprendo il terminale conpython3.8 può (sicuramente lo farà) dare una versione diversa di una libreria rispetto all'apertura con python3.5opython2.7 .

Nota 2: Abbiamo evitare di utilizzare la printfunzione di , perché il suo comportamento dipende python2 o python3. Non ne abbiamo bisogno, il terminale mostrerà il valore dell'espressione.

Funziona anche con Jupyter Notebook su Windows! Finché Jupyter viene lanciato da una riga di comando conforme a bash come Git Bash (MingW64), le soluzioni fornite in molte delle risposte possono essere utilizzate in Notebook Jupyter su sistemi Windows con una piccola modifica.

Sto eseguendo Windows 10 Pro con Python installato tramite Anaconda e il seguente codice funziona quando avvio Jupyter tramite Git Bash (ma non quando avvio dal prompt di Anaconda).

Il tweak: aggiungi un punto esclamativo ( !) davanti a pipper farlo !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

Programma Quick Python per elencare tutti i pacchetti (è possibile copiarlo in Requisito.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)

L'output sarebbe simile a:

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

(vedi anche https://stackoverflow.com/a/56912280/7262247 )

Ho trovato abbastanza inaffidabile utilizzare i vari strumenti disponibili (incluso il migliore pkg_resourcesmenzionato dalla risposta di Jakub Kukul ), poiché la maggior parte di essi non copre tutti i casi . Per esempio

• moduli integrati
• moduli non installati ma appena aggiunti al percorso python (ad esempio dall'IDE)
• sono disponibili due versioni dello stesso modulo (una nel percorso Python che sostituisce quella installata)

Dato che avevamo bisogno di un modo affidabile per ottenere la versione di qualsiasi pacchetto, modulo o sottomodulo, ho finito per scrivere getversion . È abbastanza semplice da usare:

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

Vedere la documentazione per i dettagli.

Per ottenere un elenco di moduli (standard) non standard importati nel modulo corrente:

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

Risultato:

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

Questo codice è stato messo insieme dalle soluzioni sia in questa pagina che da Come elencare i moduli importati?

In sintesi:

conda list   

(Fornirà tutte le librerie insieme ai dettagli della versione).

E:

pip show tensorflow

(Fornisce dettagli completi sulla libreria).

Puoi provare questo:

pip list

Questo produrrà tutti i pacchetti con le loro versioni. Produzione

Basandosi sulla risposta di Jakub Kukul ho trovato un modo più affidabile per risolvere questo problema.

Il problema principale di questo approccio è che richiede che i pacchetti siano installati "convenzionalmente" (e che non includano l'utilizzo pip install --user), o che si trovino nel sistema PATH all'inizializzazione di Python.

Per aggirare ciò che puoi usare pkg_resources.find_distributions(path_to_search). Questo in pratica cerca le distribuzioni che sarebbero impraticabili se si trovasse path_to_searchnel PERCORSO di sistema.

Possiamo iterare attraverso questo generatore in questo modo:

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

Ciò restituirà un dizionario con moduli come chiavi e la loro versione come valore. Questo approccio può essere esteso a molto più del numero di versione.

Grazie a Jakub Kukul per aver indicato la giusta direzione

Scrivi questa risposta per gli utenti di Windows. Come suggerito in tutte le altre risposte, puoi usare le dichiarazioni come:

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

Ma ci sono alcuni moduli che non stampano la loro versione anche dopo aver usato il metodo sopra. Quindi, ciò che puoi semplicemente fare è:

1. Apri il prompt dei comandi.
2. Passa all'indirizzo / directory del file utilizzando cd [ indirizzo file ] in cui hai installato Python e tutti i moduli di supporto installati.
3. usa il comando " pip install [nome modulo] " e premi invio.
4. Questo mostrerà un messaggio come " Requisito già soddisfatto: indirizzo file \ nome cartella (con versione) ".
5. Vedi lo screenshot qui sotto per esempio: dovevo conoscere la versione di un modulo preinstallato chiamato "Selenium-Screenshot". Mi ha mostrato correttamente come 1.5.0:

puoi prima installare un pacchetto come questo e poi controllarne la versione

pip install package
import package
print(package.__version__)

dovrebbe darti la versione del pacchetto