Come posso ottenere un elenco di installazione locale di moduli Python?
https://stackoverflow.com/questions/739993
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Vorrei ottenere un elenco di moduli Python, che sono nella mia installazione di Python (server UNIX).
Come si può ottenere un elenco di moduli Python installato nel vostro computer?
Soluzione
Soluzione
Non utilizzare con pip> 10.0!
I miei 50 centesimi per ottenere un elenco pip freeze simile da uno script Python:
import pip
installed_packages = pip.get_installed_distributions()
installed_packages_list = sorted(["%s==%s" % (i.key, i.version)
for i in installed_packages])
print(installed_packages_list)
Come (troppo lungo) uno di linea:
sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])
Dare:
['behave==1.2.4', 'enum34==1.0', 'flask==0.10.1', 'itsdangerous==0.24',
'jinja2==2.7.2', 'jsonschema==2.3.0', 'markupsafe==0.23', 'nose==1.3.3',
'parse-type==0.3.4', 'parse==1.6.4', 'prettytable==0.7.2', 'requests==2.3.0',
'six==1.6.1', 'vioozer-metadata==0.1', 'vioozer-users-server==0.1',
'werkzeug==0.9.4']
Ambito
Questa soluzione si applica alla portata di un sistema o ad un ambito ambiente virtuale, e copre pacchetti installati setuptools, pip e ( Dio non voglia ) easy_install.
Il mio caso d'uso
Ho aggiunto il risultato di questa chiamata al mio server pallone, così quando lo chiamo io con http://example.com/exampleServer/environment ho la lista dei pacchetti installati sul virtualenv del server. Si fa il debug di un molto più semplice.
Avvertimenti
Ho notato uno strano comportamento di questa tecnica - quando l'interprete Python viene invocato nella stessa directory come file setup.py, che non elenca il pacchetto installato da setup.py
Procedura per riprodurre:
Creare un ambiente virtuale$ cd /tmp
$ virtualenv test_env
New python executable in test_env/bin/python
Installing setuptools, pip...done.
$ source test_env/bin/activate
(test_env) $
setup.py
(test_env) $ git clone https://github.com/behave/behave.git
Cloning into 'behave'...
remote: Reusing existing pack: 4350, done.
remote: Total 4350 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (4350/4350), 1.85 MiB | 418.00 KiB/s, done.
Resolving deltas: 100% (2388/2388), done.
Checking connectivity... done.
Abbiamo setup.py di comportarsi in /tmp/behave:
(test_env) $ ls /tmp/behave/setup.py
/tmp/behave/setup.py
(test_env) $ cd /tmp/behave && pip install .
running install
...
Installed /private/tmp/test_env/lib/python2.7/site-packages/enum34-1.0-py2.7.egg
Finished processing dependencies for behave==1.2.5a1
Se si corre la soluzione citata da /tmp
>>> import pip
>>> sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])
['behave==1.2.5a1', 'enum34==1.0', 'parse-type==0.3.4', 'parse==1.6.4', 'six==1.6.1']
>>> import os
>>> os.getcwd()
'/private/tmp'
Se si corre la soluzione citata da /tmp/behave
>>> import pip
>>> sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])
['enum34==1.0', 'parse-type==0.3.4', 'parse==1.6.4', 'six==1.6.1']
>>> import os
>>> os.getcwd()
'/private/tmp/behave'
behave==1.2.5a1 non è presente nel secondo esempio, perché la directory di lavoro contiene il file behave di setup.py.
non ho trovato alcun riferimento a questo problema nella documentazione. Forse aprirò un bug per esso.
Altri suggerimenti
help('modules')
in una shell Python / richiesta.
Ora, questi metodi provato io stesso, e ho ottenuto esattamente quello che è stato pubblicizzato: Tutti i moduli
.Ahimè, in realtà non si cura molto della stdlib, si sa quello che si ottiene con un pitone installazione.
In realtà, io voglio la roba che I installata.
Quello che in realtà, a sorpresa, ha lavorato bene era:
pip freeze
Quali restituito:
Fabric==0.9.3
apache-libcloud==0.4.0
bzr==2.3b4
distribute==0.6.14
docutils==0.7
greenlet==0.3.1
ipython==0.10.1
iterpipes==0.4
libxml2-python==2.6.21
Dico "sorprendentemente", perché il pacchetto di strumento di installazione è il luogo esatto che ci si aspetterebbe di trovare questa funzionalità, anche se non sotto il nome di 'congelare', ma di imballaggio Python è così strano, che io sono sbalordito che questo strumento ha un senso. Pip 0.8.2, Python 2.7.
-
In
ipythonè possibile digitare "importTab ". -
Nel interprete Python standard, è possibile digitare "
help('modules')". -
Al-riga di comando, è possibile utilizzare
pydocmodules. -
In uno script, chiamata
pkgutil.iter_modules().
Dal momento che la versione 1.3 pip, hai accesso a:
pip list
che sembra essere zucchero sintattico per "congelare pip". Essa elenca tutti i moduli specifici per l'installazione o virtualenv, insieme con i loro numeri di versione. Purtroppo non visualizza il numero di versione corrente di qualsiasi modulo, né lavare i piatti o brillare le scarpe.
mi basta usare questo per vedere i moduli attualmente in uso:
import sys as s
s.modules.keys()
, che mostra tutti i moduli in esecuzione sul pitone.
Per tutti i moduli built-in uso:
s.modules
Il che è un dict che contiene tutti i moduli e gli oggetti di importazione.
Nel normale shell basta usare
pydoc modules
A partire dal 10 pip, la risposta accettata non funzionerà più. Il team di sviluppo ha rimosso l'accesso alla routine get_installed_distributions. C'è una funzione alternativa nel setuptools per fare la stessa cosa. Ecco una versione alternativa che funziona con pip 10:
import pkg_resources
installed_packages = pkg_resources.working_set
installed_packages_list = sorted(["%s==%s" % (i.key, i.version)
for i in installed_packages])
print(installed_packages_list)
Per favore fatemi sapere se sarà o non funzionerà nelle versioni precedenti di pip, anche.
Se abbiamo bisogno di elencare i pacchetti installati nella shell Python, possiamo usare il comando help come segue
>>help('modules package')
Io di solito uso pip list per ottenere una lista dei pacchetti (con la versione).
Questo funziona in un ambiente virtuale troppo, naturalmente. Per mostrare ciò che è installato in un solo ambiente virtuale (non pacchetti globali), utilizzare pip list --local.
Ecco documentazione che mostra tutte le opzioni disponibili pip list, con diversi buoni esempi .
Molto semplice ricerca utilizzando pkgutil.iter_modules
from pkgutil import iter_modules
a=iter_modules()
while True:
try: x=a.next()
except: break
if 'searchstr' in x[1]: print x[1]
Mi sono imbattuto in un pitone installato su misura 2.7 su OS X. E 'richiesto X11 per elencare i moduli installati (sia utilizzando aiuto e pydoc).
Per essere in grado di elencare tutti i moduli senza installare X11 mi sono imbattuto pydoc come http server, cioè:.
pydoc -p 12345
Allora è possibile dirigere Safari per http://localhost:12345/ per vedere tutti i moduli.
In Windows, immettere il cmd
c:\python\libs>python -m pip freeze
Questo è stato ispirato da rispondere (quella accettata):
import tabulate
try:
from pip import get_installed_distributions
except:
from pip._internal.utils.misc import get_installed_distributions
tabpackages = []
for _, package in sorted([('%s %s' % (i.location, i.key), i) for i in get_installed_distributions()]):
tabpackages.append([package.location, package.key, package.version])
print(tabulate.tabulate(tabpackages))
che poi stampa un tavolo sotto forma di
19:33 pi@rpi-v3 [iot-wifi-2] ~/python$ python installed_packages.py
------------------------------------------- -------------- ------
/home/pi/.local/lib/python2.7/site-packages enum-compat 0.0.2
/home/pi/.local/lib/python2.7/site-packages enum34 1.1.6
/home/pi/.local/lib/python2.7/site-packages pexpect 4.2.1
/home/pi/.local/lib/python2.7/site-packages ptyprocess 0.5.2
/home/pi/.local/lib/python2.7/site-packages pygatt 3.2.0
/home/pi/.local/lib/python2.7/site-packages pyserial 3.4
/usr/local/lib/python2.7/dist-packages bluepy 1.1.1
/usr/local/lib/python2.7/dist-packages click 6.7
/usr/local/lib/python2.7/dist-packages click-datetime 0.2
/usr/local/lib/python2.7/dist-packages construct 2.8.21
/usr/local/lib/python2.7/dist-packages pyaudio 0.2.11
/usr/local/lib/python2.7/dist-packages tabulate 0.8.2
------------------------------------------- -------------- ------
che consente quindi facilmente discernere quali pacchetti è stato installato con e senza sudo.
Una nota a parte: Ho notato che quando si installa un pacchetto di una volta tramite sudo e una volta senza, uno ha la precedenza in modo che l'altro non viene elencata (una sola posizione viene visualizzata). Credo che solo l'uno nella directory locale viene poi elencato. Questo potrebbe essere migliorata.
Oltre a utilizzare pip freeze ho installando tuorlo nei miei ambienti virtuali.
- per ottenere tutti i moduli disponibili, eseguire
sys.modules - per avere tutte installato moduli (leggi:installato da
pip), si può guardarepip.get_installed_distributions()
Per il secondo scopo, codice di esempio:
import pip
for package in pip.get_installed_distributions():
name = package.project_name # SQLAlchemy, Django, Flask-OAuthlib
key = package.key # sqlalchemy, django, flask-oauthlib
module_name = package._get_metadata("top_level.txt") # sqlalchemy, django, flask_oauthlib
location = package.location # virtualenv lib directory etc.
version = package.version # version number
Questa soluzione è primario basato su moduli importlib e pkgutil e lavorare con CPython 3.4 e 3.5 CPython, ma non permette di inserire il CPython 2.
Spiegazione
-
sys.builtin_module_names- i nomi di tutti i moduli built-in (guardare la mia risposta qui ) -
pkgutil.iter_modules()- restituisce un informazioni su tutti i moduli disponibili -
importlib.util.find_spec()- restituisce un modulo di informazioni su importazione, se esiste -
BuiltinImporter- un importatore per i moduli incorporati ( docs ) -
SourceFileLoader- un importatore per un modulo standard di Python (per impostazione predefinita ha estensione * .py) ( docs ) -
ExtensionFileLoader- un importatore per i moduli come libreria condivisa ( scritto sulla C o C ++)
codice completo
import sys
import os
import shutil
import pkgutil
import importlib
import collections
if sys.version_info.major == 2:
raise NotImplementedError('CPython 2 is not supported yet')
def main():
# name this file (module)
this_module_name = os.path.basename(__file__).rsplit('.')[0]
# dict for loaders with their modules
loaders = collections.OrderedDict()
# names`s of build-in modules
for module_name in sys.builtin_module_names:
# find an information about a module by name
module = importlib.util.find_spec(module_name)
# add a key about a loader in the dict, if not exists yet
if module.loader not in loaders:
loaders[module.loader] = []
# add a name and a location about imported module in the dict
loaders[module.loader].append((module.name, module.origin))
# all available non-build-in modules
for module_name in pkgutil.iter_modules():
# ignore this module
if this_module_name == module_name[1]:
continue
# find an information about a module by name
module = importlib.util.find_spec(module_name[1])
# add a key about a loader in the dict, if not exists yet
loader = type(module.loader)
if loader not in loaders:
loaders[loader] = []
# add a name and a location about imported module in the dict
loaders[loader].append((module.name, module.origin))
# pretty print
line = '-' * shutil.get_terminal_size().columns
for loader, modules in loaders.items():
print('{0}\n{1}: {2}\n{0}'.format(line, len(modules), loader))
for module in modules:
print('{0:30} | {1}'.format(module[0], module[1]))
if __name__ == '__main__':
main()
Utilizzo
Per la CPython3.5 (troncato)
$ python3.5 python_modules_info.py
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
30: <class '_frozen_importlib.BuiltinImporter'>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
_ast | built-in
_codecs | built-in
_collections | built-in
_functools | built-in
_imp | None
_io | built-in
_locale | built-in
_operator | built-in
_signal | built-in
_sre | built-in
_stat | built-in
_string | built-in
_symtable | built-in
_thread | built-in
(****************************truncated*******************************)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
227: <class '_frozen_importlib_external.SourceFileLoader'>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
__future__ | /usr/local/lib/python3.5/__future__.py
_bootlocale | /usr/local/lib/python3.5/_bootlocale.py
_collections_abc | /usr/local/lib/python3.5/_collections_abc.py
_compat_pickle | /usr/local/lib/python3.5/_compat_pickle.py
_compression | /usr/local/lib/python3.5/_compression.py
_dummy_thread | /usr/local/lib/python3.5/_dummy_thread.py
_markupbase | /usr/local/lib/python3.5/_markupbase.py
_osx_support | /usr/local/lib/python3.5/_osx_support.py
_pydecimal | /usr/local/lib/python3.5/_pydecimal.py
_pyio | /usr/local/lib/python3.5/_pyio.py
_sitebuiltins | /usr/local/lib/python3.5/_sitebuiltins.py
(****************************truncated*******************************)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
64: <class '_frozen_importlib_external.ExtensionFileLoader'>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
_bisect | /usr/local/lib/python3.5/lib-dynload/_bisect.cpython-35m-x86_64-linux-gnu.so
_bz2 | /usr/local/lib/python3.5/lib-dynload/_bz2.cpython-35m-x86_64-linux-gnu.so
_codecs_cn | /usr/local/lib/python3.5/lib-dynload/_codecs_cn.cpython-35m-x86_64-linux-gnu.so
_codecs_hk | /usr/local/lib/python3.5/lib-dynload/_codecs_hk.cpython-35m-x86_64-linux-gnu.so
_codecs_iso2022 | /usr/local/lib/python3.5/lib-dynload/_codecs_iso2022.cpython-35m-x86_64-linux-gnu.so
(****************************truncated*******************************)
Per la CPython3.4 (troncato)
$ python3.4 python_modules_info.py
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
54: <class '_frozen_importlib.BuiltinImporter'>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
_ast | built-in
_bisect | built-in
_codecs | built-in
_collections | built-in
_datetime | built-in
_elementtree | built-in
_functools | built-in
_heapq | built-in
_imp | None
_io | built-in
_locale | built-in
_md5 | built-in
_operator | built-in
_pickle | built-in
_posixsubprocess | built-in
_random | built-in
(****************************truncated*******************************)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
246: <class '_frozen_importlib.SourceFileLoader'>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
__future__ | /usr/lib/python3.4/__future__.py
_bootlocale | /usr/lib/python3.4/_bootlocale.py
_collections_abc | /usr/lib/python3.4/_collections_abc.py
_compat_pickle | /usr/lib/python3.4/_compat_pickle.py
_dummy_thread | /usr/lib/python3.4/_dummy_thread.py
_markupbase | /usr/lib/python3.4/_markupbase.py
_osx_support | /usr/lib/python3.4/_osx_support.py
_pyio | /usr/lib/python3.4/_pyio.py
(****************************truncated*******************************)
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
44: <class '_frozen_importlib.ExtensionFileLoader'>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
_bz2 | /usr/lib/python3.4/lib-dynload/_bz2.cpython-34m-x86_64-linux-gnu.so
_codecs_cn | /usr/lib/python3.4/lib-dynload/_codecs_cn.cpython-34m-x86_64-linux-gnu.so
_codecs_hk | /usr/lib/python3.4/lib-dynload/_codecs_hk.cpython-34m-x86_64-linux-gnu.so
_codecs_iso2022 | /usr/lib/python3.4/lib-dynload/_codecs_iso2022.cpython-34m-x86_64-linux-gnu.so
_codecs_jp | /usr/lib/python3.4/lib-dynload/_codecs_jp.cpython-34m-x86_64-linux-gnu.so
_codecs_kr | /usr/lib/python3.4/lib-dynload/_codecs_kr.cpython-34m-x86_64-linux-gnu.so
_codecs_tw | /usr/lib/python3.4/lib-dynload/_codecs_tw.cpython-34m-x86_64-linux-gnu.so
_crypt | /usr/lib/python3.4/lib-dynload/_crypt.cpython-34m-x86_64-linux-gnu.so
(****************************truncated*******************************)
Nel caso in cui si dispone di un anaconda pitone distribuzione installato, è possibile utilizzare anche
$conda list
in aggiunta alle soluzioni sopra descritte.
congelamento pip lo fa tutti i pacchetti che trovano tuttavia si può semplicemente scrivere il seguente comando per elencare tutti i percorsi in cui i pacchetti Python sono.
>>> import site; site.getsitepackages()
['/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages']
Ci sono molte idee, inizialmente io sto riflettendo su questi due:
pip
cons: non sempre installato
Guida ( 'moduli')
cons: uscita a consolare; con moduli rotti (vedi ubuntu ...) possono segfault
Ho bisogno di un approccio semplice, utilizzando le librerie di base e compatibile con il vecchio python 2.x
E vedo la luce: listmodules.py
Nascosto nella directory dei sorgenti documentazione 2.5 è un piccolo script che elenca tutti i moduli disponibili per l'installazione di Python.
Pro:
utilizza solo imp, sys, os, re, il tempo
progettato per funzionare su Python 1.5.2 e successivi
il codice sorgente è davvero compatto, in modo da poter facilmente armeggiare con esso, ad esempio, di passare un elenco di eccezioni di moduli buggy (non provare a importare)
Ci sono molti modo per scuoiare un gatto.
-
Il modo più semplice è quello di utilizzare la funzione
pydocdirettamente dalla shell con:
pydoc modules -
Ma per ulteriori informazioni utilizzare lo strumento chiamato pip-date che anche dire si le date di installazione.
pip install pip-date
Prova questi
pip list
o
pip freeze
ho bisogno di trovare la versione specifica di pacchetti disponibili per impostazione predefinita in AWS Lambda. Lo feci con un mashup di idee a questa pagina. Sto condividendo per i posteri.
import pkgutil
__version__ = '0.1.1'
def get_ver(name):
try:
return str(__import__(name).__version__)
except:
return None
def lambda_handler(event, context):
return {
'statusCode': 200,
'body': [{
'path': m.module_finder.path,
'name': m.name,
'version': get_ver(m.name),
} for m in list(pkgutil.iter_modules())
#if m.module_finder.path == "/var/runtime" # Uncomment this if you only care about a certain path
],
}
Quello che ho scoperto è che la biblioteca boto3 fornito era così fuori di data e non era colpa mia se il mio codice stava venendo a mancare. Avevo solo bisogno di aggiungere boto3 e botocore al mio progetto. Ma senza questo sarei stato sbattere la testa pensando il mio codice era male.
{
"statusCode": 200,
"body": [
{
"path": "/var/task",
"name": "lambda_function",
"version": "0.1.1"
},
{
"path": "/var/runtime",
"name": "bootstrap",
"version": null
},
{
"path": "/var/runtime",
"name": "boto3",
"version": "1.9.42"
},
{
"path": "/var/runtime",
"name": "botocore",
"version": "1.12.42"
},
{
"path": "/var/runtime",
"name": "dateutil",
"version": "2.7.5"
},
{
"path": "/var/runtime",
"name": "docutils",
"version": "0.14"
},
{
"path": "/var/runtime",
"name": "jmespath",
"version": "0.9.3"
},
{
"path": "/var/runtime",
"name": "lambda_runtime_client",
"version": null
},
{
"path": "/var/runtime",
"name": "lambda_runtime_exception",
"version": null
},
{
"path": "/var/runtime",
"name": "lambda_runtime_marshaller",
"version": null
},
{
"path": "/var/runtime",
"name": "s3transfer",
"version": "0.1.13"
},
{
"path": "/var/runtime",
"name": "six",
"version": "1.11.0"
},
{
"path": "/var/runtime",
"name": "test_bootstrap",
"version": null
},
{
"path": "/var/runtime",
"name": "test_lambda_runtime_client",
"version": null
},
{
"path": "/var/runtime",
"name": "test_lambda_runtime_marshaller",
"version": null
},
{
"path": "/var/runtime",
"name": "urllib3",
"version": "1.24.1"
},
{
"path": "/var/lang/lib/python3.7",
"name": "__future__",
"version": null
},
...
Quello che ho scoperto è stato anche diverso da quello che ufficialmente pubblicare . Al momento di scrivere questo:
- Sistema operativo - Amazon Linux
- AMI - AMZN-ami-HVM-2017.03.1.20170812-x86_64-GP2
- kernel Linux - 4.14.77-70.59.amzn1.x86_64
- AWS SDK per JavaScript - 2.290.0 \
- SDK per Python (Boto 3) - 3-1.7.74 botocore-1.10.74
Per chiunque chiedendo come chiamare pip list da un programma Python è possibile utilizzare il seguente:
import pip
pip.main(['list]) # this will print all the packages
Questo aiuterà
Nel terminale o IPython, tipo:
help('modules')
poi
In [1]: import #import press-TAB
Display all 631 possibilities? (y or n)
ANSI audiodev markupbase
AptUrl audioop markupsafe
ArgImagePlugin avahi marshal
BaseHTTPServer axi math
Bastion base64 md5
BdfFontFile bdb mhlib
BmpImagePlugin binascii mimetools
BufrStubImagePlugin binhex mimetypes
CDDB bisect mimify
CDROM bonobo mmap
CGIHTTPServer brlapi mmkeys
Canvas bsddb modulefinder
CommandNotFound butterfly multifile
ConfigParser bz2 multiprocessing
ContainerIO cPickle musicbrainz2
Cookie cProfile mutagen
Crypto cStringIO mutex
CurImagePlugin cairo mx
DLFCN calendar netrc
DcxImagePlugin cdrom new
Dialog cgi nis
DiscID cgitb nntplib
DistUpgrade checkbox ntpath
Dalla shell
ls site-packages
Se questo non è disponibile, si può fare questo.
import sys
import os
for p in sys.path:
print os.listdir( p )
e vediamo cosa che produce.
