Comment puis-je obtenir une liste des modules Python installés localement?

help('modules')

dans un interpréteur de commandes Python/prompt.

maintenant, ces méthodes que j'ai essayées moi-même, et j'ai obtenu exactement ce qui a été annoncé: tous les modules.

hélas, vous ne vous souciez pas beaucoup du stdlib, vous savez ce que vous obtenez avec une installation python.

vraiment, je veux que le truc que i installé.

ce qui, en fait, étonnamment, a très bien fonctionné était:

pip freeze

Qui a retourné:

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

je dis" étonnamment "parce que l'outil d'installation de paquet est l'endroit exact où l'on s'attendrait à trouver cette fonctionnalité, bien que pas sous le nom "freeze" mais l'empaquetage python est si bizarre, que je suis sidéré que cet outil ait du sens. Pip 0.8.2, Python 2.7.

• Dans ipython , vous pouvez taper " import Onglet ".

• dans l'interpréteur Python standard, vous pouvez taper" help('modules') ".

• en ligne de commande, vous pouvez utiliser pydoc modules .

• dans un script, appelez pkgutil.iter_modules() .

depuis la version 1.3 de pip, vous avez accès à:

pip list

qui semble être du sucre syntactique pour "PIP freeze". Il liste tous les modules spécifiques à votre installation ou virtualenv, avec leurs numéros de version. Malheureusement, il n'affiche pas le numéro de version actuel d'un module, il ne lave pas votre vaisselle ou cirer vos chaussures.

Je l'utilise juste pour voir les modules actuellement utilisés:

import sys as s
s.modules.keys()

qui affiche tous les modules tournant sur votre python.

pour tous les modules encastrés utiliser:

s.modules

qui est un dict contenant tous les modules et importer des objets.

dans la coque normale juste utiliser

pydoc modules

si nous devons lister les paquets installés dans le shell Python, nous pouvons utiliser la commande help comme suit

>>help('modules package')

j'ai rencontré un python 2.7 installé sur OS X. Il a fallu X11 pour lister les modules installés (à la fois en utilisant l'AIDE et pydoc).

pour pouvoir lister tous les modules sans installer X11 j'ai lancé pydoc comme serveur http, i.e.:

pydoc -p 12345

il est alors possible de diriger Safari vers http://localhost:12345/ pour voir tous les modules.

recherche très simple utilisant 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]

sur windows, entrez ceci dans cmd

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

à partir du pip 10, la réponse acceptée ne fonctionnera plus. L'équipe de développement a retiré l'accès à la routine get_installed_distributions . Il y a une fonction alternative dans le setuptools pour faire la même chose. Voici une version alternative qui fonctionne avec 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)

s'il vous plaît, faites-moi savoir si cela fonctionnera ou non dans les versions précédentes de pip, aussi.

mis à part l'utilisation de pip freeze j'ai installé yolk dans mes environnements virtuels.

1. pour obtenir tous les modules disponibles, Lancez sys.modules
2. pour obtenir tous les installés modules (lire: installés par pip ), vous pouvez regarder pip.get_installed_distributions()

pour le deuxième usage, exemple de code:

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

cette solution est principalement basée sur les modules importlib et pkgutil et fonctionne avec CPython 3.4 et CPython 3.5, mais n'a pas de support pour le CPython 2.

explication

1. sys.builtin_module_names - nomme tous les modules intégrés (regardez ma réponse ici )
2. pkgutil.iter_modules() - renvoie une information sur tous les modules disponibles
3. importlib.util.find_spec() - retourne des informations sur le module d'importation ,s'il existe
4. BuiltinImporter - un importateur pour les modules intégrés ( docs )
5. SourceFileLoader - un importateur pour un module Python standard (par défaut a extension *.py) ( docs )
6. ExtensionFileLoader - un importateur pour les modules comme bibliothèque partagée (écrit sur le C ou C++)

code complet

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

l'Utilisation de la

pour le CPython3.5 (tronqué)

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

pour le CPython3.4 (tronqué)

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

si vous avez une distribution anaconda python installée, vous pouvez aussi utiliser

$conda list

en plus des solutions décrites ci-dessus.

pip freeze est-ce qu'il trouve tous les paquets? cependant, il suffit d'écrire la commande suivante pour lister tous les chemins où se trouvent les paquets python.

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

j'utilise normalement pip list pour obtenir une liste des paquets (avec la version).

cela fonctionne aussi dans un environnement virtuel, bien sûr.

il y a beaucoup d'idées, au début je réfléchis sur ces deux:

pip

cons: pas toujours installé

aide ('modules')

contre: sortie sur console; avec des modules cassés (voir ubuntu...) peut-erreur de segmentation

j'ai besoin d'une approche facile, à l'aide de bibliothèques de base et compatible avec le vieux python 2.x

et je vois la lumière: listmodules.py

caché dans le répertoire des sources de documentation en 2.5 est un petit script qui liste tous les modules disponibles pour une installation Python.

Pour:

n'utilise que imp, sys, os, re, time

conçu pour fonctionner avec Python 1.5.2 et versions plus récentes

le code source est vraiment compact, donc vous pouvez facilement le bricoler, par exemple pour passer une liste d'exception de modules bogués (n'essayez pas de les importer)

à Partir de l'interpréteur de commandes

ls site-packages

Si ce n'est pas utile, vous pouvez le faire.

import sys
import os
for p in sys.path:
    print os.listdir( p )

Et voir ce que cela produit.