web-dev-qa-db-de.com

Wie kann ich eine Liste der lokal installierten Python-Module erhalten?

Ich möchte eine Liste der Python-Module erhalten, die sich in meiner Python-Installation (UNIX-Server) befinden.

Wie können Sie eine Liste der auf Ihrem Computer installierten Python-Module erhalten?

help('modules')

in einer Python-Shell/Eingabeaufforderung.

877
ChristopheD

Nun, diese Methoden habe ich selbst ausprobiert und genau das bekommen, was beworben wurde: Alle Module.

Leider kümmert es dich wirklich nicht besonders um die stdlib, du weißt, was du mit einer Python-Installation bekommst. 

Wirklich, ich möchte das Zeug, dasIinstalliert ist. 

Was eigentlich überraschend gut funktioniert hat, war:

pip freeze

Welche zurückgegeben:

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

Ich sage "überraschend", weil das Paketinstallations-Tool genau der Ort ist, an dem man diese Funktionalität erwarten würde, obwohl es nicht unter dem Namen "Freeze" steht, sondern das Python-Packaging so komisch ist, dass ich fassungslos bin, dass dieses Tool Sinn macht. Pip 0,8,2, Python 2,7. 

241
chiggsy
  • In ipython können Sie "import" eingeben.Tab".

  • Im Standard-Python-Interpreter können Sie "help('modules')" eingeben.

  • In der Befehlszeile können Sie pydocmodules verwenden.

  • Rufen Sie in einem Skript pkgutil.iter_modules() auf.

80
Johnsyweb

Seit Pip Version 1.3 haben Sie Zugriff auf:

pip list

Welches scheint syntaktischer Zucker für "Pip Freeze" zu sein. Es werden alle für Ihre Installation oder Ihre Virtualenv spezifischen Module mit ihren Versionsnummern aufgeführt. Leider zeigt es weder die aktuelle Versionsnummer eines Moduls an, noch spült es Ihr Geschirr oder Ihre Schuhe.

71
Bryce

Ich verwende dies nur, um die aktuell verwendeten Module zu sehen:

import sys as s
s.modules.keys()

dies zeigt alle Module, die auf Ihrem Python laufen.

Für alle eingebauten Module verwenden Sie:

s.modules

Welches Diktat enthält alle Module und Importobjekte.

58
Dan Evans

In normaler Shell einfach verwenden

pydoc modules
58
DrkNess

Ab Pip 10 funktioniert die akzeptierte Antwort nicht mehr. Das Entwicklungsteam hat den Zugriff auf die get_installed_distributions-Routine entfernt. In setuptools gibt es eine alternative Funktion, um dasselbe zu tun. Hier ist eine alternative Version, die mit Pip 10 funktioniert:

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)

Bitte lassen Sie mich wissen, ob es auch in früheren Versionen von pip funktionieren wird oder nicht.

22
Big_Al_Tx

Wenn Sie die installierten Pakete in der Python-Shell auflisten müssen, können Sie den Befehl help wie folgt verwenden

>>help('modules package')
21
Sadheesh

Ich habe einen benutzerdefinierten installierten Python 2.7 unter OS X gefunden. X11 musste die installierten Module auflisten (sowohl mit Hilfe als auch mit pydoc).

Um alle Module auflisten zu können, ohne X11 zu installieren, habe ich pydoc als http-Server ausgeführt, d.h.

pydoc -p 12345

Dann ist es möglich, Safari zu http://localhost:12345/ zu leiten, um alle Module anzuzeigen.

11
Qiau

Sehr einfache Suche mit 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]
10
stuudent

bei Windows geben Sie dies in cmd ein

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

Normalerweise verwende ich pip list, um eine Liste von Paketen (mit Version) zu erhalten.

Dies funktioniert natürlich auch in einer virtuellen Umgebung.

8
James

Abgesehen von pip freeze habe ich yolk in meinen virtuellen Umgebungen installiert.

7
jdsantiagojr

Diese Lösung basiert hauptsächlich auf den Modulen importlib und pkgutil und arbeitet mit CPython 3.4 und CPython 3.5, unterstützt jedoch nicht CPython 2.


Erklärung

  1. sys.builtin_module_names - benennt alle eingebauten Module (siehe meine Antwort hier )
  2. pkgutil.iter_modules() - gibt Informationen zu allen verfügbaren Modulen zurück
  3. importlib.util.find_spec() - gibt Informationen zum Importieren des Moduls zurück, falls vorhanden
  4. BuiltinImporter - ein Importer für eingebaute Module ( docs )
  5. SourceFileLoader - Ein Importer für ein Standard-Python-Modul (standardmäßig mit der Erweiterung * .py) ( docs )
  6. ExtensionFileLoader - ein Importer für Module als gemeinsam genutzte Bibliothek (geschrieben in C oder C++)

Vollständiger Code

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 __== '__main__':
    main()

Verwendungszweck

Für den CPython3.5 (abgeschnitten)

$ 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*******************************)

Für den CPython3.4 (abgeschnitten)

$ 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*******************************)
6
Seti Volkylany
  1. um alle verfügbaren Module zu erhalten, führen Sie sys.modules aus
  2. um alle installierten module zu erhalten (gelesen: von pip installiert), können Sie sich pip.get_installed_distributions() anschauen.

Für den zweiten Zweck, Beispielcode:

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
6
yegle

pip freeze Findet alle Pakete, aber Sie können einfach den folgenden Befehl schreiben, um alle Pfade aufzulisten, in denen sich Python-Pakete befinden.

>>> import site; site.getsitepackages()
['/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages']
4
Pavan Gupta

Probiere diese

pip list

oder

pip freeze
3
Amit Gupta

Dies wurde von Adam Matans answer (der akzeptierten) inspiriert:

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

die dann eine Tabelle in der Form von

19:33 [email protected] [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
-------------------------------------------  --------------  ------

so können Sie leicht erkennen, welche Pakete Sie mit und ohne Sudo installiert haben.


Ein Hinweis zur Seite: Ich habe bemerkt, dass, wenn ich ein Paket einmal über Sudo und einmal ohne installiere, einer Vorrang hat, sodass das andere nicht aufgelistet wird (nur ein Ort wird angezeigt). Ich glaube, dass dann nur der im lokalen Verzeichnis aufgeführt wird. Dies könnte verbessert werden.

3
Daniel F

Falls Sie eine Anaconda Python-Distribution installiert haben, können Sie auch verwenden

$conda list

zusätzlich zu den oben beschriebenen Lösungen.

3
Shreyas

Es gibt viele Ideen, an die ich zunächst nachdenke:

pip

nachteile: nicht immer installiert

help ('modules')

nachteile: Ausgabe an die Konsole; mit defekten modulen (siehe ubuntu ...) kann segfault werden

Ich brauche einen einfachen Ansatz, der grundlegende Bibliotheken verwendet und mit dem alten Python 2.x kompatibel ist

Und ich sehe das Licht: listmodules.py

Versteckt im Dokumentationsquellverzeichnis von 2.5 ist ein kleines Skript, das alle verfügbaren Module für eine Python-Installation auflistet.

Pros:

verwendet nur imp, sys, os, re, time

entwickelt für Python 1.5.2 und neuer

der Quellcode ist sehr kompakt, so dass Sie ihn leicht basteln können, um beispielsweise eine Ausnahmeliste fehlerhafter Module zu übergeben (versuchen Sie nicht, sie zu importieren).

2
Massimo

Es gibt viele Möglichkeiten, eine Katze zu enthäuten.

  • Am einfachsten ist es, die pydoc-Funktion direkt von der Shell aus zu verwenden:
    pydoc modules

  • Weitere Informationen erhalten Sie mit dem Tool pip-date , das Ihnen auch die Installationsdaten angibt.
    pip install pip-date


 enter image description here

1
not2qubit

Ich musste die spezifische Version von Paketen finden, die standardmäßig in AWS Lambda verfügbar ist. Ich habe das mit einem Mix von Ideen von dieser Seite gemacht. Ich teile es für die Nachwelt.

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

Was ich entdeckte, ist, dass die zur Verfügung gestellte boto3-Bibliothek nicht mehr aktuell ist und es nicht meine Schuld war, dass mein Code fehlschlug. Ich musste nur boto3 und botocore zu meinem Projekt hinzufügen. Aber ohne das hätte ich meinen Kopf geschlagen, weil ich dachte, mein Code sei schlecht.

{
  "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
    },
...

Was ich entdeckte, war auch anders als was sie offiziell veröffentlichen . Zum Zeitpunkt des Schreibens dieses:

  • Betriebssystem - Amazon Linux
  • AMI - amzn-AMI-hvm-2017.03.1.20170812-x86_64-gp2
  • Linux-Kernel - 4.14.77-70.59.amzn1.x86_64
  • AWS SDK für JavaScript - 2.290.0 \
  • SDK für Python (Boto 3) - 3-1.7.74 Botocore-1.10.74
0
Bruno Bronosky

Das wird helfen

Geben Sie im Terminal oder in IPython Folgendes ein:

help('modules')

dann

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
0
X Personified

Für alle, die sich fragen, wie man pip list aus einem Python -Programm heraus aufruft, können Sie Folgendes verwenden:

import pip
pip.main(['list])  # this will print all the packages
0
Marcelo Villa