Come posso ottenere un elenco di moduli Python installati localmente?


998

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?


77
puoi semplicemente fare >>> help () e poi >>> moduli
Julius Naeumann,

1
C'è un'alternativa? help () si blocca per me.
Paulo Carvalho,

2
Molte di queste risposte presuppongono che tu abbia accesso a una riga di comando. Se stai usando AWS Lambda, devi fare tutto da Python. Vedere stackoverflow.com/a/54939905/117471
Bruno Bronosky

Risposte:


610

Soluzione

Non utilizzare con pip> 10.0!

I miei 50 centesimi per ottenere un pip freezeelenco 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']

Scopo

Questa soluzione si applica all'ambito del sistema o all'ambito di un ambiente virtuale e copre i pacchetti installati da setuptools, pipe (a dio forbid ) easy_install.

Il mio caso d'uso

Ho aggiunto il risultato di questa chiamata al mio server di matraccio, quindi quando lo chiamo http://example.com/exampleServer/environmentottengo l'elenco dei pacchetti installati sul virtualenv del server. Rende il debugging molto più semplice.

Avvertenze

Ho notato uno strano comportamento di questa tecnica: quando l'interprete Python viene invocato nella stessa directory di un setup.pyfile, non elenca il pacchetto installato da setup.py.

Passaggi per riprodurre:

Crea 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) $ 
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.pyin /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

Se eseguiamo la soluzione di cui sopra /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 eseguiamo la soluzione di cui sopra /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.5a1manca dal secondo esempio, perché la directory di lavoro contiene behaveil setup.pyfile di.

Non è stato possibile trovare alcun riferimento a questo problema nella documentazione. Forse aprirò un bug per questo.


5
Grazie per questa risposta! Penso che risponda meglio alla domanda perché chiedo moduli Python installati "localmente". Anche il congelamento del pip non è sempre la strada da percorrere. Funziona meglio, penso.
Léo Léopold Hertz

3
@Masi Ho appena aggiunto una spiegazione dettagliata del avvertimento di questa soluzione. È davvero strano.
Adam Matan,

21
Un'alternativa:import pkg_resources; installed_packages = [(d.project_name, d.version) for d in pkg_resources.working_set]
ebolyen,

14
A partire dal pip 10, questa risposta non funzionerà più. Il commento di @ebolyen mostra comandi alternativi che funzionano. Sono arrivato alla stessa conclusione e ho pubblicato il codice completo rivisto di seguito.
Big_Al_Tx

5
Nelle versioni recenti di pip, questo non funzionerà, producendo un messaggio di errore che dice AttributeError: module 'pip' has no attribute 'get_installed_distributions'.
Ciao addio,


285

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.


4
Immagino che l'idea dietro al nome sia quella di ottenere un'istantanea "congelata" di ciò che è installato in questo momento, che puoi successivamente inviare in pip per ottenere esattamente gli stessi moduli installati in un ambiente diverso.
Ryan C. Thompson,

Arash, puoi installare pip anche in Windows! Prima installa setuptools e poi usa easy_install per installare pip :)
gawbul

Questo è eccellente, ma sembra che manchino alcune delle librerie che ho installato. Ad esempio, non elenca PyQt.
Junuxx,

8
A partire da pip 1.3 c'è il comando list .
Piotr Dobrogost,

Funziona. Che python disordinato è. Perché non riescono a mettere insieme i loro atti e escogitare soluzioni simili a quelle che esistono in Rails? (Gemfile, bundler, rvm)
Dimitris,

106

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.


4
C'è anche pip list --localper distinguere tra virtualenvpacchetti di siti globali e, discussi qui .
Ioannis Filippidis,

1
Di gran lunga il migliore. Recupera anche le versioni.
Aerijman,

pip listè il più semplice e il migliore. Ecco le opzioni e i dettagli.
Levi Baguley,

86
  • In ipythonpuoi digitare " importTab".

  • Nell'interprete Python standard, puoi digitare " help('modules')".

  • Alla riga di comando, puoi usare .pydoc modules

  • In uno script, chiama pkgutil.iter_modules().


5
pkgutil.iter_modules()funziona, la soluzione pip sopra non elenca tutti i pacchetti, solo quelli installati tramite pip.
metaperture del

2
Eccezionale! Penso che abbiano migliorato la documentazione, poiché la domanda è stata posta. lo spam di moduli pydoc cerca lo spam nei documenti dei moduli. L'ultimo punto sembra darti le informazioni sufficienti per usare il modulo. @metaperture Puoi, per favore, fare un esempio di come elenchi tutti i moduli locali installati (non la massiccia lista di stlib tramite help ('moduli')) di pkgutil.iter_modules () .
Léo Léopold Hertz

2
@ LéoLéopoldHertz 준영 Prova questo frammento: 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().
Philip Conrad,

76

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.


2
# Dopo aver importato sys "import sys as s" è possibile stampare con: print sys.modules.keys ()
Dan Evans,

Non sono sicuro del motivo per cui il mio post è stato modificato, ma grazie per aver utilizzato le informazioni che ho pubblicato per correggere gli errori nei post precedenti. Restituirai errori se usi help () vs help (''). Questo vale anche per dir ('') & sys ('') ecc. Spero che questo aiuti e non venga rimosso.
Dan Evans,

Ignora il mio ultimo post, questo post non è stato modificato. Stavo pensando a un post simile trovato qui: stackoverflow.com/questions/139180/… Ci scusiamo per la confusione.
Dan Evans,

7
Eseguito l'upgrade, perché questo è l'unico metodo che sembra funzionare su sistemi vincolati che non hanno pydocpipinstallato (un NAS nel mio caso).
Thomas,

1
D'accordo con Thomas. Sto usando repl.it, ad esempio, che è anche un tipo di ambiente vincolato. help('modules')si blocca senza risposta per me. Ma questo approccio sysfunziona perfettamente
Sergiy Kolodyazhnyy il

63

Nella shell normale basta usare

pydoc modules

Sembra che quanto sopra funziona solo su piattaforme 'nix. In ogni caso, ho trovato ed eseguito lo script, adattando il comando nel modo seguente: c: \ bin \ pythos_2.7 \ lib \ pydoc.py moduli - tale elenco ha richiesto un'eternità per essere compilato, il formato fa schifo e omette la versione installata numero. Io passo.
David A. Gray,

2
@ DavidA.Gray Ho appena provato questo su un computer Windows con Python 3, e in effetti funziona. Usando il launcher di python windows puoi farlo py -m pydoc modulesin cmd o Powershell.
VKK

pydoc modulesnon ha funzionato per me in Windows 10 con Python 3.6, ma la modifica di @VKK: py -m pydoc modulesfunziona in cmd / Powershell.
Martin,

41

A partire dal pip 10, la risposta accettata non funzionerà più. Il team di sviluppo ha rimosso l'accesso alla get_installed_distributionsroutine. C'è una funzione alternativa setuptoolsper 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.


2
Ho cercato questa soluzione e distrutto il mio cervello cercando di capire pkg_resources. Se potessi votare questo più di una volta, lo farei. Grazie, @Big_Al_Tx! Aggiornamento: Tranne .... quando eseguo un "congelamento pip" nel mio ambiente virtuale e lo confronto con l'output di questo, ci sono pacchetti che mancano. Qualche idea sul perché ciò potrebbe / accadere?
numberwhun

@numberwhun - Sono contento che questo abbia funzionato per te. Mi dispiace, ma non ho una risposta per la discrepanza con 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 setuptoolse l'ho fatta funzionare.
Big_Al_Tx

github.com/pypa/pip/issues/5243 - Le discussioni del team di sviluppo sull'accesso rimosso a get_installed_distributions routine.
bl79,

@ bl79 - Penso che sia il posto esatto per cui ho ottenuto il riferimento setuptools.
Big_Al_Tx

@Big_Al_Tx: Beh, ho in qualche modo aggirato l'opzione setuptools (che era waaaay per offuscare per le mie esigenze) e sono andato con questo: installed_pkgs = subprocess.check_output (['pip', 'freeze']) Fa esattamente quello che ne avevo bisogno per fare .... Yay !!
numero

26

Se dobbiamo elencare i pacchetti installati nella shell Python, possiamo usare il helpcomando come segue

>>help('modules package')

22

Normalmente utilizzo pip listper 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 listopzioni disponibili , con diversi buoni esempi.


13

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]

c'è qualche motivo per usare while invece di un ciclo for? Ho scritto usando for m in iter_modules()e ha funzionato anche.
Joao Ponte,

13

su windows, inserisci questo in cmd

c:\python\libs>python -m pip freeze

Questo ha funzionato per me usando: python3 -m pip freeze - per python 3.5.3.
dpminusa,

Funziona bene e non è necessario trovarsi nella directory libs anche se le variabili sono definite
mcy

12

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.



12

Questo aiuterà

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 dovrebbe essere la risposta accettata! Una riga :)
AlmostPitt

9

Questa soluzione è basata principalmente su moduli importlibe pkgutilfunziona con CPython 3.4 e CPython 3.5, ma non ha supporto per CPython 2.


Spiegazione

  1. sys.builtin_module_names- nomina tutti i moduli integrati (guarda la mia risposta qui )
  2. pkgutil.iter_modules() - restituisce informazioni su tutti i moduli disponibili
  3. importlib.util.find_spec() - restituisce informazioni sull'importazione del modulo, se esiste
  4. BuiltinImporter- un importatore di moduli integrati ( documenti )
  5. SourceFileLoader- un importatore per un modulo Python standard (per impostazione predefinita ha l'estensione * .py) ( docs )
  6. 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*******************************)

Puoi per favore confrontare il tuo approccio con quello di Adam qui stackoverflow.com/a/23885252/54964
Léo Léopold Hertz

@ Léo Léopold Hertz, perché ne hai bisogno?
PADYMKO

Per capire come il tuo approccio sia migliore / peggiore di quello di Adam.
Léo Léopold Hertz

1
@ Léo Léopold Hertz. Una breve risposta: provalo tu stesso in una produzione e trai le tue conclusioni. Risposta lunga: l'approccio di Adam si basa sulpip 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.
PADYMKO

1
@ Léo Léopold Hertz ti sbagli, lo fa. L'ho provato sul mio computer. La mia risposta contiene un significato speciale **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.
PADYMKO

9

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.


1
No. Questo non è raccomandato, vedi qui: pip.pypa.io/it/stable/user_guide/#using-pip-from-your-program
sinoroc

1
@sinoroc Grazie per averlo segnalato. I punti da 1 a 3 non sembrano essere applicabili a questa soluzione, poiché questo script ha il solo scopo di utilizzare pipuna volta e poi uscire. Sembra essere più un problema che il comportamento potrebbe cambiare.
Daniel F

D'accordo, i motivi per cui non esiste un'API pubblica non si applicano a questo particolare pezzo di codice. Ma poiché pip non è destinato a garantire un'API pubblica, è libero di modificare le sue API interne, la struttura del codice, ecc. In una versione successiva, come già fatto in precedenza. Questo è il motivo per cui questo codice ha un tentativo / tranne, per catturare la precedente riorganizzazione del codice interno che aveva lo scopo di chiarire che le API interne sono API interne e non pubbliche ( _internal). Tutto sommato, ovviamente funziona ma è una cattiva pratica. Ci sono alternative migliori, alcune sono nelle altre risposte a questa domanda.
sinoroc,

1
questo script non funzionerà se il modulo "pip" non è presente.
Alexander Stohr,


6

Nel caso in cui sia installata una distribuzione Python anaconda , è possibile utilizzare anche

$conda list

oltre alle soluzioni sopra descritte.


Dove / come si esegue questa linea?
HuckIt

Se sei sulla tua macchina UNIX / Mac OS X, apri il tuo terminale e digita conda install, dovrebbe funzionare :)
Shreyas

Sono su una macchina Windows 7. L'ho trovato sul mio percorso in realtà, ma conda.exe è in AppData \ Local \ Continuum \ Anaconda \ Scripts.
HuckIt,

6
  1. per ottenere tutti i moduli disponibili, eseguire sys.modules
  2. per ottenere tutti i moduli installati (leggi: installato da 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

Il comando sys.modules non funziona nel più recente Python di OSX. NameError: il nome 'system' non è definito .
Léo Léopold Hertz

@Masi Intendevi /usr/bin/pythono quello viene da python.org ? Per il primo, posso usare sys.modulessenza problemi.
yegle,

Intendo / usr / bin / python .
Léo Léopold Hertz

@Masi Non sono sicuro se sei ancora interessato a questo problema. Apparentemente stai usando system.modulesinvece di sys.modules.
yegle,

Lol. Il mio errore è stato che in origine non avevo importato il pacchetto sys. Quindi eseguendo invece import sys; sys.modules funziona come previsto.
Léo Léopold Hertz

6

Per versioni recenti come Pip 20

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


4

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

4

Esistono molti modi per scuoiare un gatto.

  • Il modo più semplice è usare la pydocfunzione direttamente dalla shell con:
    pydoc modules

  • Ma per ulteriori informazioni usa lo strumento chiamato pip-date che ti dice anche le date di installazione.
    pip install pip-date


inserisci qui la descrizione dell'immagine


3

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)


3

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

1

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

1

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)


-10

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.


quale directory dei pacchetti del sito? Questo potrebbe fare di meglio: ls / usr / {local /,} lib / python $ (python -V 2> & 1 | cut -d "" -f2 | cut -d. -F1-2) / site-pacchetti
vezult

Inoltre, questo non mostrerà i moduli integrati, o i moduli in un PYTHONPATH personalizzato, o quelli installati in "modalità di sviluppo" di setuptools ecc.
dF.

Il mio /usr/local/lib/python2.5/site-packages è vuoto, anche se ho installato dei moduli.
Léo Léopold Hertz

14
Complimenti per non aver eliminato questa risposta declassata. È utile per la comunità essere in grado di capire perché una risposta comune è considerata errata.
Jeremy Stein,

1
@JeremyStein Una strategia migliore (più utile e probabilmente meno rep-dannosa) sarebbe probabilmente quella di modificare la domanda per spiegare perché è sbagliata, una volta che questo è stato spiegato nei commenti ...
Kyle Strand
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.