Hoe de versie van python-modules controleren?

Ik heb zojuist de python-modules: constructen statlibmet setuptoolsals volgt geïnstalleerd:

# 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

Ik wil hun versies (programmatisch) kunnen controleren. Is er een equivalent van python --versiondat ik vanaf de opdrachtregel kan uitvoeren?

Mijn python-versie is 2.7.3.


Antwoord 1, autoriteit 100%

Ik raad aan om pip te gebruiken in plaats van easy_install. Met pip kun je alle geïnstalleerde pakketten en hun versies weergeven met

pip freeze

In de meeste linux-systemen kun je dit naar grep(of findstrop Windows) sturen om de rij te vinden voor het specifieke pakket waarin je geïnteresseerd bent:

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

Voor een individuele module kun je de __version__proberen attribuut, er zijn echter modules zonder:

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

Ten slotte, aangezien de commando’s in uw vraag worden voorafgegaan door sudo, lijkt het erop dat u in de globale python-omgeving installeert. Raad ten zeerste aan om te kijken naar python virtuele omgeving-managers, bijvoorbeeld virtualenvwrapper


Antwoord 2, autoriteit 49%

Je kunt het proberen

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

Update: dit is de aanpak die wordt aanbevolen door PEP 396. Maar die PEP is nooit geaccepteerd en is uitgesteld. In feite lijkt er steeds meer steun te zijn onder Python-kernontwikkelaars om geenaan te bevelen een __version__-attribuut op te nemen, b.v. in https://gitlab.com/python-devs/importlib_metadata/-/merge_requests/ 125.


Antwoord 3, autoriteit 33%

Python >= 3.8:

Als je python >=3.8gebruikt, kun je daarvoor een module uit de ingebouwde bibliotheek gebruiken. Om de versie van een pakket te controleren (in dit voorbeeld construct) voer je het volgende uit:

>>> from importlib.metadata import version
>>> version('construct')
'4.3.1'

Python < 3.8:

Gebruik pkg_resourcesmodule gedistribueerd met setuptoolsbibliotheek. Houd er rekening mee dat de tekenreeks die u doorgeeft aan de methode get_distributionmoet overeenkomen met de PyPI-invoer.

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

Kanttekeningen:

  1. Houd er rekening mee dat de tekenreeks die u doorgeeft aan de get_distribution-methode, de pakket naam moet zijn zoals geregistreerd in PyPI, niet de modulenaam die u probeert te importeren. Helaas zijn deze niet altijd hetzelfde (u doet bijvoorbeeld pip install memcached, maar import memcache).

  2. Als u deze oplossing vanaf de opdrachtregel wilt toepassen, kunt u zoiets doen als:

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

Antwoord 4, autoriteit 12%

Gebruik pip showom de versie te vinden!

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

Antwoord 5, autoriteit 11%

De betere manier om dat te doen is:


Voor de details van een specifiek pakket

pip show <package_name>

Het geeft details over de pakketnaam, versie, auteur, locatie enz.


$ 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: [email protected]
License: BSD
Location: c:\users\prowinjvm\appdata\local\programs\python\python36\lib\site-packages
Requires:

Voor meer informatie: >>> pip help


pipmoet worden bijgewerkt om dit te doen.

pip install --upgrade pip

op opdracht Raden is:

python -m pip install --upgrade pip


Antwoord 6, Autoriteit 5%

in Python3 met beugels rond afdrukken

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

Antwoord 7, Autoriteit 2%

module.__version__is een goed eerste ding om te proberen, maar het werkt niet altijd.

Als u niet wilt schillen, en u PIP 8 of 9 gebruikt, kunt u nog steeds pip.get_installed_distributions()gebruiken om versies vanuit Python te krijgen:

Update: De oplossing hier werkt in PIP 8 en 9, maar in PIP 10 is de functie verplaatst van pip.get_installed_distributionsnaar pip._internal.utils.misc.get_installed_distributionsOm uitdrukkelijk aan te geven dat het niet voor extern gebruik is. Het is geen goed idee om erop te vertrouwen als u PIP 10 + gebruikt.

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', ...]

Antwoord 8, autoriteit 2%

De vorige antwoorden hebben mijn probleem niet opgelost, maar deze code wel:

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

Antwoord 9

Gebruik dir()om erachter te komen of de module een __version__kenmerk heeft.

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

Antwoord 10

In Python 3.8-versie is er een nieuwe metadatamodule in importlibpakket, die dat ook kan.

Hier is een voorbeeld uit documenten:

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

Antwoord 11

Als de bovenstaande methoden niet werken, is het de moeite waard om het volgende in python te proberen:

import modulename
modulename.version
modulename.version_info

Zie Python Tornado-versie downloaden?

Let op, de .versionwerkte voor mij ook op een paar andere behalve tornado.


Antwoord 12

voeg eerst python, pip toe aan je omgevingsvariabelen. zodat u uw opdrachten vanaf de opdrachtprompt kunt uitvoeren. geef dan gewoon het commando python.
importeer dan het pakket

–>import scrapy

druk vervolgens de versienaam af

–>print(scrapy.__version__)

Dit gaat zeker werken


Antwoord 13

Ervan uitgaande dat we Jupyter Notebook gebruiken (laat de uitroeptekens weg als u Terminal gebruikt):

1) als het pakket (bijv. xgboost) is geïnstalleerd met pip:

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

2) als het pakket (bijv. caffe) is geïnstalleerd met conda:

!conda list caffe

Antwoord 14

Sommige modules hebben geen kenmerk __version__, dus de eenvoudigste manier is om in de terminal in te checken: pip list


Antwoord 15

Ik stel voor een python-shell in terminal te openen (in de python-versie waarin je geïnteresseerd bent), de bibliotheek te importeren en het kenmerk __version__te verkrijgen.

>>> import statlib
>>> statlib.__version__
>>> import construct
>>> contruct.__version__

Opmerking 1:we moeten rekening houden met de python-versie. Als we verschillende versies van python hebben geïnstalleerd, moeten we de terminal openen in de python-versie waarin we geïnteresseerd zijn. Bijvoorbeeld, het openen van de terminal met python3.8kan (zeker) een andere versie geven van een bibliotheek dan openen met python3.5of python2.7.

Opmerking 2:We vermijd het gebruik van de functie print, omdat het gedrag ervan afhangt van python2 of python3. We hebben het niet nodig, de terminal toont de waarde van de uitdrukking.


Antwoord 16

Je kunt dit proberen:

pip list

Hiermee worden alle pakketten met hun versies uitgevoerd.
Uitvoer


Antwoord 17

Dit antwoord schrijven voor Windows-gebruikers. Zoals gesuggereerd in alle andere antwoorden, kunt u de uitspraken gebruiken als:

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

Maar er zijn enkele modules die hun versie niet afdrukken, zelfs niet na gebruik van de bovenstaande methode. Wat u dus eenvoudig kunt doen is:

  1. Open de opdrachtprompt.
  2. Navigeer naar het bestandsadres/de map met behulp van cd[bestandsadres] waar je je python en alle ondersteunende modules hebt geïnstalleerd. Als u slechts één python op uw systeem heeft, zijn de PYPI-pakketten normaal gesproken zichtbaar in de directory/map:- Python > lib > site-pakketten.
  3. gebruik het commando “pip install [module name]” en druk op enter.
  4. Hiermee wordt een bericht weergegeven als “Reeds aan vereiste: bestandsadres\mapnaam (met versie)“.
  5. Zie bijvoorbeeld de schermafbeelding hieronder: ik moest de versie kennen van een vooraf geïnstalleerde module met de naam “Selenium-Screenshot”. Het toonde me correct als 1.5.0:


Antwoord 18

Samengevat:

conda list   

(Het geeft alle bibliotheken samen met versiedetails).

En:

pip show tensorflow

(Het geeft volledige bibliotheekdetails).


Antwoord 19

Dit werkt ook in Jupyter Notebook op Windows! Zolang Jupyter wordt gestart vanaf een bash-compatibele opdrachtregel zoals Git Bash (MingW64), kunnen de oplossingen die in veel van de antwoorden worden gegeven, met een kleine aanpassing in Jupyter Notebook op Windows-systemen worden gebruikt.

Ik gebruik Windows 10 Pro met Python geïnstalleerd via Anaconda, en de volgende code werkt wanneer ik Jupyter start via Git Bash (maar niet wanneer ik opstart vanaf de Anaconda-prompt).

De tweak: voeg een uitroepteken (!) toe voor pipom het !pipte maken.

>>>!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: [email protected]
License: BSD
Location: c:\users\karls\anaconda2\lib\site-packages
Requires: 
Required-by: jupyter-contrib-nbextensions

Antwoord 20

Snel python-programma om alle pakketten weer te geven (je kunt het kopiëren naar 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)

De uitvoer zou er als volgt uitzien:

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

Antwoord 21

(zie ook https://stackoverflow.com/a/56912280/7262247)

Ik vond het nogal onbetrouwbaar om de verschillende beschikbare tools te gebruiken (inclusief de beste pkg_resourcesgenoemd door Jakub Kukul’ antwoord), aangezien de meeste niet alle gevallen dekken. Bijvoorbeeld

  • ingebouwde modules
  • modules niet geïnstalleerd maar zojuist toegevoegd aan het python-pad (bijvoorbeeld door uw IDE)
  • twee versies van dezelfde module beschikbaar (een in python-pad vervangt de geïnstalleerde)

Omdat we een betrouwbare manier nodig hadden om de versie van elkpakket, module of submodule te krijgen, schreef ik uiteindelijk getversion. Het is vrij eenvoudig te gebruiken:

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

Zie de documentatievoor details.


Antwoord 22

Na het internet te hebben doorzocht om erachter te komen hoe ik ervoor kan zorgen dat de versie van een module wordt uitgevoerd (blijkbaar is python_is_horrible.__version__niet iets in 2?) in de versies van os en python… letterlijk geen van deze antwoorden werkte voor mijn scenario…

Toen dacht ik er even over na en realiseerde me de basis… na ~30 minuten falen…

gaat ervan uit dat de module alis geïnstalleerd en kan worden geïmporteerd


3.7

>>> import sys,sqlite3
>>> sys.modules.get("sqlite3").version
'2.6.0'
>>> ".".join(str(x) for x in sys.version_info[:3])
'3.7.2'

2,7

>>> import sys,sqlite3
>>> sys.modules.get("sqlite3").version
'2.6.0'
>>> ".".join(str(x) for x in sys.version_info[:3])
'2.7.11'

letterlijk dat is het…


Antwoord 23

Om een lijst te krijgen van niet-standaard (pip) modules geïmporteerd in de huidige module:

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

Resultaat:

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

Opmerking:

Deze code is samengesteld uit oplossingen zowel op deze pagina als uit Hoe vermeld ik geïmporteerde modules?


Antwoord 24

En in het geval dat uw prod-systeem onbegrijpelijk gehard is, zodat het noch pipnoch condaheeft, is hier een bash-vervanging voor pip freeze:

ls /usr/local/lib/python3.8/dist-packages | grep info | awk -F "-" '{print $1"=="$2}' | sed 's/.dist//g'

(zorg ervoor dat u uw map dist-packagesbijwerkt naar uw huidige python-versie en negeer inconsistente namen, zoals onderstrepingstekens versus streepjes).

Voorbeeld afdruk:

Flask==1.1.2
Flask_Caching==1.10.1
gunicorn==20.1.0
[..]

Antwoord 25

Voortbouwend op Jakub Kukul’s antwoordheb ik een betrouwbaardere manier gevonden om dit probleem op te lossen.

Het belangrijkste probleem van die aanpak is dat de pakketten “conventioneel” moeten worden geïnstalleerd (en dat omvat niet het gebruik van pip install --user), of zich in het systeem PATH bevinden bij de initialisatie van Python .

Om dat te omzeilen kun je pkg_resources.find_distributions(path_to_search)gebruiken. Dit zoekt in feite naar distributies die importeerbaar zouden zijn als path_to_searchzich in het systeem PATH bevond.

We kunnen deze generator als volgt herhalen:

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

Hiermee wordt een woordenboek geretourneerd met modules als sleutels en hun versie als waarde. Deze aanpak kan worden uitgebreid tot veel meer dan alleen het versienummer.

Dank aan Jakub Kukul voor het wijzen in de goede richting


Antwoord 26

Ik werk zelf in een zeer beperkte serveromgeving en helaas werken geen van de oplossingen hier voor mij. Er is misschien geen handschoenoplossing die bij iedereen past, maar ik heb een snelle oplossing bedacht door de terminaluitvoer van pip freeze in mijn script te lezen en de labels en versies van de modules in een woordenboek op te slaan.

import os
os.system('pip freeze > tmpoutput')
with open('tmpoutput', 'r') as f:
    modules_version = f.read()
module_dict = {item.split("==")[0]:item.split("==")[-1] for item in modules_versions.split("\n")}

Haal de versies van uw module op door de modulelabelsleutel door te geven, bijvoorbeeld:

>>  module_dict["seaborn"]
'0.9.0'

Antwoord 27

U kunt eenvoudig subprocess.getoutput(python3 --version)

gebruiken

import subprocess as sp
print(sp.getoutput(python3 --version))
# or however it suits your needs!
py3_version = sp.getoutput(python3 --version)
def check_version(name, version):...
check_version('python3', py3_version)

Voor meer informatie en manieren om dit te doen zonder afhankelijk te zijn van het __version__attribuut:

Wijs uitvoer van os.system toe aan een variabele en voorkom dat deze op het scherm wordt weergegeven

U kunt ook subprocess.check_output()gebruiken, wat een foutmelding geeft wanneer het subproces iets anders retourneert dan exit-code 0:

https://docs.python.org/3/library /subprocess.html#check_output()


Antwoord 28

je kunt eerst een pakket zoals dit installeren en dan de versie controleren

pip install package
import package
print(package.__version__)

het zou je een pakketversie moeten geven

Other episodes