Vorrei ottenere un elenco di moduli Python, presenti nella mia installazione di Python (server UNIX).
Come puoi ottenere un elenco di moduli Python installati sul tuo computer?
Vorrei ottenere un elenco di moduli Python, presenti nella mia installazione di Python (server UNIX).
Come puoi ottenere un elenco di moduli Python installati sul tuo computer?
Risposte:
I miei 50 centesimi per ottenere un pip freeze
elenco simile a 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) un liner:
sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])
Dando:
['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']
Questa soluzione si applica all'ambito del sistema o all'ambito di un ambiente virtuale e copre i pacchetti installati da setuptools
, pip
e (a dio forbid ) easy_install
.
Ho aggiunto il risultato di questa chiamata al mio server di matraccio, quindi quando lo chiamo http://example.com/exampleServer/environment
ottengo l'elenco dei pacchetti installati sul virtualenv del server. Rende il debugging molto più semplice.
Ho notato uno strano comportamento di questa tecnica: quando l'interprete Python viene invocato nella stessa directory di un setup.py
file, non elenca il pacchetto installato da setup.py
.
$ cd /tmp
$ virtualenv test_env
New python executable in test_env/bin/python
Installing setuptools, pip...done.
$ source test_env/bin/activate
(test_env) $
Clonare un repository git con 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.
Ci siamo comportati setup.py
in /tmp/behave
:
(test_env) $ ls /tmp/behave/setup.py
/tmp/behave/setup.py
Installa il pacchetto python dal repository git
(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
/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'
/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
manca dal secondo esempio, perché la directory di lavoro contiene behave
il setup.py
file di.
Non è stato possibile trovare alcun riferimento a questo problema nella documentazione. Forse aprirò un bug per questo.
import pkg_resources; installed_packages = [(d.project_name, d.version) for d in pkg_resources.working_set]
AttributeError: module 'pip' has no attribute 'get_installed_distributions'
.
help('modules')
in una shell / prompt di Python.
pydoc modules
funziona. Dovresti inviarlo come risposta.
python -c 'help("modules")'
Ora, ho provato questi metodi e ho ottenuto esattamente ciò che veniva pubblicizzato: tutti i moduli.
Ahimè, davvero non ti interessa molto dello stdlib, sai cosa ottieni con un'installazione python.
Voglio davvero le cose che ho installato.
Ciò che in realtà, sorprendentemente, ha funzionato bene è stato:
pip freeze
Che ha 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é lo strumento di installazione del pacchetto è il posto esatto in cui ci si aspetterebbe di trovare questa funzionalità, anche se non sotto il nome di "blocco", ma il packaging in python è così strano, che sono sbalordito dal fatto che questo strumento abbia senso. Pip 0.8.2, Python 2.7.
Dalla versione pip 1.3, hai accesso a:
pip list
Che sembra essere lo zucchero sintattico per "congelare il pip". Elencherà tutti i moduli specifici della tua installazione o virtualenv, insieme ai loro numeri di versione. Sfortunatamente non mostra il numero di versione corrente di nessun modulo, né lava i tuoi piatti o lucida le tue scarpe.
pip list
è il più semplice e il migliore. Ecco le opzioni e i dettagli.
In ipython
puoi digitare " import
Tab".
Nell'interprete Python standard, puoi digitare " help('modules')
".
Alla riga di comando, puoi usare .pydoc
modules
In uno script, chiama pkgutil.iter_modules()
.
pkgutil.iter_modules()
funziona, la soluzione pip sopra non elenca tutti i pacchetti, solo quelli installati tramite pip.
python -c 'import pkgutil;print [x[1] for x in list(pkgutil.iter_modules())]'
. Dovrebbe scaricare tutti i nomi dei moduli come un unico grande elenco Python. Il x[1]
bit viene utilizzato per estrarre il nome del modulo dalle tuple generate da pkgutil.iter_modules()
.
Lo uso solo per vedere i moduli attualmente utilizzati:
import sys as s
s.modules.keys()
che mostra tutti i moduli in esecuzione su Python.
Per tutti i moduli integrati utilizzare:
s.modules
Che è un dict contenente tutti i moduli e gli oggetti di importazione.
pydoc
né pip
installato (un NAS nel mio caso).
help('modules')
si blocca senza risposta per me. Ma questo approccio sys
funziona perfettamente
Nella shell normale basta usare
pydoc modules
py -m pydoc modules
in cmd o Powershell.
pydoc modules
non ha funzionato per me in Windows 10 con Python 3.6, ma la modifica di @VKK: py -m pydoc modules
funziona in cmd / Powershell.
A partire dal pip 10, la risposta accettata non funzionerà più. Il team di sviluppo ha rimosso l'accesso alla get_installed_distributions
routine. C'è una funzione alternativa 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 funzionerà o non funzionerà anche nelle versioni precedenti di pip.
pip freeze
; la profondità delle mie conoscenze su questo argomento è piuttosto limitata. Ho cercato in un certo senso la mia strada verso la soluzione quando la risposta accettata non ha funzionato per me e ho provato a combinarla con una risposta correlata setuptools
e l'ho fatta funzionare.
get_installed_distributions routine
.
setuptools
.
Normalmente utilizzo pip list
per ottenere un elenco di pacchetti (con versione).
Questo funziona anche in un ambiente virtuale, ovviamente. Per mostrare ciò che è installato solo nell'ambiente virtuale (non pacchetti globali), utilizzare pip list --local
.
Ecco la documentazione che mostra tutte le pip list
opzioni disponibili , con diversi buoni esempi.
Ricerca molto semplice con 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]
for m in iter_modules()
e ha funzionato anche.
Mi sono imbattuto in un python 2.7 personalizzato installato su OS X. Per X11 era necessario elencare i moduli installati (sia usando help che pydoc).
Per poter elencare tutti i moduli senza installare X11 ho eseguito pydoc come http-server, ovvero:
pydoc -p 12345
Quindi è possibile indirizzare Safari http://localhost:12345/
a vedere tutti i moduli.
Nel terminale o IPython, digitare:
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
Questa soluzione è basata principalmente su moduli importlib
e pkgutil
funziona con CPython 3.4 e CPython 3.5, ma non ha supporto per CPython 2.
Spiegazione
sys.builtin_module_names
- nomina tutti i moduli integrati (guarda la mia risposta qui )pkgutil.iter_modules()
- restituisce informazioni su tutti i moduli disponibiliimportlib.util.find_spec()
- restituisce informazioni sull'importazione del modulo, se esisteBuiltinImporter
- un importatore di moduli integrati ( documenti )SourceFileLoader
- un importatore per un modulo Python standard (per impostazione predefinita ha l'estensione * .py) ( docs )ExtensionFileLoader
- un importatore di moduli come libreria condivisa (scritto in 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()
uso
Per 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 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*******************************)
pip
sistema di gestione dei pacchetti utilizzato per installare e gestire i pacchetti software scritti in Python e di conseguenza pip.get_installed_distributions()
restituisce i moduli installati con il pip. La mia risposta si basa interamente sulla libreria standard di Python e copre tutti i moduli disponibili per l'importazione. Un grosso svantaggio della mia risposta: nessun supporto per il CPython 2.
**truncated**
, in cui un output viene troncato. Forse non stai attento, ma se non lo fa, quindi per inviarmi informazioni sul tuo sistema e sull'implementazione di Python, farò ulteriori ricerche per risolverlo.
Attenzione: Adam Matan scoraggia questo uso in pip> 10.0. Inoltre, leggi il commento di @ sinoroc qui sotto
Questo è stato ispirato dalla risposta di Adam Matan (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 quindi stampa una tabella 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 di discernere facilmente quali pacchetti sono stati installati con e senza sudo
.
Una nota a parte: ho notato che quando installo un pacchetto una volta tramite sudo
e una volta senza, uno ha la precedenza in modo che l'altro non venga elencato (viene mostrata solo una posizione). Credo che sia elencato solo quello nella directory locale. Questo potrebbe essere migliorato.
pip
una volta e poi uscire. Sembra essere più un problema che il comportamento potrebbe cambiare.
_internal
). Tutto sommato, ovviamente funziona ma è una cattiva pratica. Ci sono alternative migliori, alcune sono nelle altre risposte a questa domanda.
Oltre all'utilizzo pip freeze
ho installato tuorlo nei miei ambienti virtuali.
Nel caso in cui sia installata una distribuzione Python anaconda , è possibile utilizzare anche
$conda list
oltre alle soluzioni sopra descritte.
conda install
, dovrebbe funzionare :)
sys.modules
pip
), puoi guardarepip.get_installed_distributions()
Per il secondo scopo, esempio di codice:
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
/usr/bin/python
o quello viene da python.org ? Per il primo, posso usare sys.modules
senza problemi.
system.modules
invece di sys.modules
.
Esegui quanto segue nel tuo editor Python o IPython
import pkg_resources;
installed_packages = {d.project_name: d.version for d in pkg_resources.working_set}
print(installed_packages)
Leggi le altre risposte e metti insieme questa combo, che è più semplice e veloce in Python
pip freeze fa tutto per trovare i pacchetti ma si può semplicemente scrivere il seguente comando per elencare tutti i percorsi in cui si trovano i pacchetti python.
>>> import site; site.getsitepackages()
['/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages']
Ci sono molte idee, inizialmente sto riflettendo su questi due:
seme
contro: non sempre installato
aiuto ( 'moduli')
contro: output su console; con moduli rotti (vedi ubuntu ...) può segfault
Ho bisogno di un approccio semplice, usando librerie di base e compatibile con il vecchio Python 2.x
E vedo la luce: listmodules.py
Nascosto nella directory di origine della documentazione in 2.5 è un piccolo script che elenca tutti i moduli disponibili per un'installazione di Python.
Professionisti:
usa solo imp, sys, os, re, time
progettato per funzionare su Python 1.5.2 e versioni successive
il codice sorgente è davvero compatto, quindi puoi facilmente armeggiare con esso, ad esempio per passare un elenco di eccezioni di moduli difettosi (non provare a importarli)
Avevo bisogno di trovare la versione specifica dei pacchetti disponibili per impostazione predefinita in AWS Lambda. L'ho fatto con un mashup di idee da questa pagina. Lo 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 libreria boto3 fornita era obsoleta e non era colpa mia se il mio codice non andava a buon fine. Avevo solo bisogno di aggiungere boto3 e botocore al mio progetto. Ma senza questo avrei sbattuto la testa pensando che il mio codice fosse cattivo.
{
"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
},
...
Ciò che ho scoperto era anche diverso da quello che pubblicano ufficialmente . Al momento della stesura di 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
- SDK AWS per JavaScript - 2.290.0 \
- SDK per Python (Boto 3) - 3-1.7.74 botocore-1.10.74
Installazione
pip install pkgutil
Codice
import pkgutil
for i in pkgutil.iter_modules(None): # returns a tuple (path, package_name, ispkg_flag)
print(i[1]) #or you can append it to a list
Uscita campione:
multiprocessing
netrc
nntplib
ntpath
nturl2path
numbers
opcode
pickle
pickletools
pipes
pkgutil
Ecco una soluzione in codice Python che restituirà un elenco di moduli installati. Si può facilmente modificare il codice per includere i numeri di versione.
import subprocess
import sys
from pprint import pprint
installed_packages = reqs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).decode('utf-8')
installed_packages = installed_packages.split('\r\n')
installed_packages = [pkg.split('==')[0] for pkg in installed_packages if pkg != '']
pprint(installed_packages)
Per chiunque si chieda come chiamare pip list
da un programma Python è possibile utilizzare quanto segue:
import pip
pip.main(['list]) # this will print all the packages
Dal guscio
ls site-packages
Se questo non è utile, puoi farlo.
import sys
import os
for p in sys.path:
print os.listdir( p )
E guarda cosa produce.