Возвратите список импортированных модулей Python, используемых в сценарии?

Это зависит от того, насколько тщательно вы хотите быть. Использованные модули - это полная проблема: некоторые коды Python используют ленивый импорт только для того, чтобы импортировать вещи, которые они фактически используют в конкретном запуске, некоторые генерируют вещи для динамического импорта (например, системы плагинов).

python -v будет отслеживать операторы import - это, пожалуй, самая простая вещь для проверки.

Я искал нечто подобное и нашел драгоценный камень в пакете под названием PyScons . Сканер делает то, что вы хотите (в 7 строк), используя import_hook. Вот сокращенный пример:

import modulefinder, sys

class SingleFileModuleFinder(modulefinder.ModuleFinder):

    def import_hook(self, name, caller, *arg, **kwarg):
        if caller.__file__ == self.name:
            # Only call the parent at the top level.
            return modulefinder.ModuleFinder.import_hook(self, name, caller, *arg, **kwarg)

    def __call__(self, node):

        self.name = str(node)

        self.run_script(self.name)

if __name__ == '__main__':
    # Example entry, run with './script.py filename'
    print 'looking for includes in %s' % sys.argv[1]

    mf = SingleFileModuleFinder()
    mf(sys.argv[1])

    print '\n'.join(mf.modules.keys())

Спасибо Тони Саффолку за проверку, примеры importlib ... Я создал этот крошечный модуль, и вы все можете его использовать, если он вам поможет. Отдай, даааа!

import timeit
import os
import inspect, importlib as implib
import textwrap as twrap

def src_modules(filename):
    assert (len(filename)>1)

    mod = implib.import_module(filename.split(".")[0])
    ml_alias = []
    ml_actual = []
    ml_together = []
    ml_final = []
    for i in inspect.getmembers(mod, inspect.ismodule):
        ml_alias.append(i[0])
        ml_actual.append((str(i[1]).split(" ")[1]))
        ml_together = zip(ml_actual, ml_alias)
    for t in ml_together:
        (a,b) = t
        ml_final.append(a+":="+b)

    return ml_final

def l_to_str(itr):
    assert(len(itr)>0)

    itr.sort()
    r_str = ""
    for i in itr:
        r_str += i+"  "
    return r_str

def src_info(filename, start_time=timeit.default_timer()):
    assert (len(filename)>1)

    filename_in = filename
    filename = filename_in.split(".")[0]

    if __name__ == filename:
        output_module = filename
    else:
        output_module = __name__

    print ("\n" + (80 * "#"))
    print (" runtime ~= {0} ms".format(round(((timeit.default_timer() - start_time)*1000),3)))
    print (" source file --> '{0}'".format(filename_in))
    print (" output via --> '{0}'".format(output_module))
    print (" modules used in '{0}':".format(filename))
    print ("  "+"\n  ".join(twrap.wrap(l_to_str(src_modules(filename)), 75)))
    print (80 * "#")

    return ""


if __name__ == "__main__":
    src_info(os.path.basename(__file__))


## how to use in X file:
#
# import print_src_info
# import os
#
# < ... your code ... >
#
# if __name__ == "__main__":
#     print_src_info.src_info(os.path.basename(__file__))


## example output:
#
# ################################################################################
#  runtime ~= 0.049 ms
#  source file --> 'print_src_info.py'
#  output via --> '__main__'
#  modules used in 'print_src_info':
#   'importlib':=implib  'inspect':=inspect  'os':=os  'textwrap':=twrap
#   'timeit':=timeit
# ################################################################################

Мне недавно были нужны все зависимости для данного сценария Python, и я проявил другой подход, чем другие ответы. Я только заботился о высокоуровневых именах модуля модуля (например, я хотел foo от import foo.bar).

Это - код с помощью ast модуль :

import ast


modules = set()

def visit_Import(node):
    for name in node.names:
        modules.add(name.name.split(".")[0])

def visit_ImportFrom(node):
    # if node.module is missing it's a "from . import ..." statement
    # if level > 0 it's a "from .submodule import ..." statement
    if node.module is not None and node.level == 0:
        modules.add(node.module.split(".")[0])

node_iter = ast.NodeVisitor()
node_iter.visit_Import = visit_Import
node_iter.visit_ImportFrom = visit_ImportFrom

Тестирование с файлом foo.py Python, который содержит:

# foo.py
import sys, os
import foo1
from foo2 import bar
from foo3 import bar as che
import foo4 as boo
import foo5.zoo
from foo6 import *
from . import foo7, foo8
from .foo12 import foo13
from foo9 import foo10, foo11

def do():
    import bar1
    from bar2 import foo
    from bar3 import che as baz

я мог получить все модули в foo.py путем выполнения чего-то вроде этого:

with open("foo.py") as f:
    node_iter.visit(ast.parse(f.read()))
print(modules)

, который дал бы мне этот вывод:

set(['bar1', 'bar3', 'bar2', 'sys', 'foo9', 'foo4', 'foo5', 'foo6', 'os', 'foo1', 'foo2', 'foo3'])

ИМО, лучший способ сделать это - использовать пакет http://furius.ca/snakefood/ . Автор выполнил всю необходимую работу, чтобы получить не только напрямую импортированные модули, но и использовать AST для анализа кода на предмет зависимостей во время выполнения, которые упускаются из виду при более статическом анализе.

Разработал пример команды, чтобы продемонстрировать:

sfood ./example.py | sfood-cluster > example.deps

Это будет генерировать базовый файл зависимостей для каждого уникального модуля. Для более подробного использования:

sfood -r -i ./example.py | sfood-cluster > example.deps

Чтобы пройти по дереву и найти все импортированные данные, вы также можете сделать это в коде: ОБРАТИТЕ ВНИМАНИЕ: фрагменты AST этой процедуры были взяты из источника snakefood, на который есть авторские права. : Copyright (C) 2001-2007 Мартин Блейс. Все права защищены.

 import os
 import compiler
 from compiler.ast import Discard, Const
 from compiler.visitor import ASTVisitor

 def pyfiles(startPath):
     r = []
     d = os.path.abspath(startPath)
     if os.path.exists(d) and os.path.isdir(d):
         for root, dirs, files in os.walk(d):
             for f in files:
                 n, ext = os.path.splitext(f)
                 if ext == '.py':
                     r.append([d, f])
     return r

 class ImportVisitor(object):
     def __init__(self):
         self.modules = []
         self.recent = []
     def visitImport(self, node):
         self.accept_imports()
         self.recent.extend((x[0], None, x[1] or x[0], node.lineno, 0)
                            for x in node.names)
     def visitFrom(self, node):
         self.accept_imports()
         modname = node.modname
         if modname == '__future__':
             return # Ignore these.
         for name, as_ in node.names:
             if name == '*':
                 # We really don't know...
                 mod = (modname, None, None, node.lineno, node.level)
             else:
                 mod = (modname, name, as_ or name, node.lineno, node.level)
             self.recent.append(mod)
     def default(self, node):
         pragma = None
         if self.recent:
             if isinstance(node, Discard):
                 children = node.getChildren()
                 if len(children) == 1 and isinstance(children[0], Const):
                     const_node = children[0]
                     pragma = const_node.value
         self.accept_imports(pragma)
     def accept_imports(self, pragma=None):
         self.modules.extend((m, r, l, n, lvl, pragma)
                             for (m, r, l, n, lvl) in self.recent)
         self.recent = []
     def finalize(self):
         self.accept_imports()
         return self.modules

 class ImportWalker(ASTVisitor):
     def __init__(self, visitor):
         ASTVisitor.__init__(self)
         self._visitor = visitor
     def default(self, node, *args):
         self._visitor.default(node)
         ASTVisitor.default(self, node, *args) 

 def parse_python_source(fn):
     contents = open(fn, 'rU').read()
     ast = compiler.parse(contents)
     vis = ImportVisitor() 

     compiler.walk(ast, vis, ImportWalker(vis))
     return vis.finalize()

 for d, f in pyfiles('/Users/bear/temp/foobar'):
     print d, f
     print parse_python_source(os.path.join(d, f)) 

Что ж, вы всегда можете написать простой сценарий, который будет искать в файле операторы import . Он находит все импортированные модули и файлы, включая импортированные в функции или классы:

def find_imports(toCheck):
    """
    Given a filename, returns a list of modules imported by the program.
    Only modules that can be imported from the current directory
    will be included. This program does not run the code, so import statements
    in if/else or try/except blocks will always be included.
    """
    import imp
    importedItems = []
    with open(toCheck, 'r') as pyFile:
        for line in pyFile:
            # ignore comments
            line = line.strip().partition("#")[0].partition("as")[0].split(' ')
            if line[0] == "import":
                for imported in line[1:]:
                    # remove commas (this doesn't check for commas if
                    # they're supposed to be there!
                    imported = imported.strip(", ")
                    try:
                        # check to see if the module can be imported
                        # (doesn't actually import - just finds it if it exists)
                        imp.find_module(imported)
                        # add to the list of items we imported
                        importedItems.append(imported)
                    except ImportError:
                        # ignore items that can't be imported
                        # (unless that isn't what you want?)
                        pass

    return importedItems

toCheck = raw_input("Which file should be checked: ")
print find_imports(toCheck)

Это ничего не делает для from module import something style import, хотя это можно легко добавить, в зависимости от того, как вы хотите иметь дело с ними. Он также не выполняет никакой проверки синтаксиса, поэтому, если у вас есть забавные дела вроде import sys gtk, os , он будет думать, что вы импортировали все три модуля, даже если строка является ошибкой. Он также не имеет отношения к try / , за исключением операторов типа в отношении импорта - если он может быть импортирован, эта функция выведет его список. Он также не подходит для множественного импорта на строку, если вы используете ключевое слово как . Настоящая проблема здесь в том, что мне пришлось бы написать полный синтаксический анализатор, чтобы действительно сделать это правильно. Данный код работает во многих случаях, если вы понимаете, что есть определенные угловые случаи.

Одна из проблем заключается в том, что относительный импорт завершится ошибкой, если этот сценарий не находится в том же каталоге, что и данный файл. Вы можете добавить каталог данного сценария в sys.path .