正则表达式解析python中的import语句

Question

有人可以帮我写单个正则表达式从python源代码行获取模块吗？

from abc.lmn import pqr
from abc.lmn import pqr as xyz
import abc
import abc as xyz

它有3个子部分

[from(\s)<module>(\s)] --> get module if this part exist
import(\s)<module>     --> get module
[(\s)as(\s)<alias>]    --> ignore if this part exist

这样的事情

:?[from(\s)<module>(\s)]import(\s)<module>:?[(\s)as(\s)<alias>]

Answer 1

使用内置的python库而不是使用正则表达式可能是一种更好的方法. https://docs.python.org/2/library/ast.html 您可以使用它来解析python语法.

import ast

import_string = """from abc.lmn import pqr
from abc.lmn import pqr as xyz
import abc
import abc as xyz"""

modules = []
for node in ast.iter_child_nodes(ast.parse(import_string)):
    if isinstance(node, ast.ImportFrom):
        if not node.names[0].asname:  # excluding the 'as' part of import
            modules.append(node.module)
    elif isinstance(node, ast.Import): # excluding the 'as' part of import
        if not node.names[0].asname:
            modules.append(node.names[0].name)

这将给你['abc.lmn','abc'],如果你想提取其他信息,它很容易调整.

Answer 2

看起来您可以在 忽略as的同时使from可选和import需要。

(?m)^(?:from[ ]+(\S+)[ ]+)?import[ ]+(\S+)[ ]*$

https://regex101.com/r/fmoAuh/1

解释

 (?m)                          # Modifiers: multi-line
 ^                             # Beginning of line
 (?:                           # Optional from
      from [ ]+ 
      ( \S+ )                       # (1), from <module>
      [ ]+ 
 )?

 import [ ]+                   # Required import
 ( \S+ )                       # (2), import <module>
 [ ]* 
 $                             # End of line

或者，如果您想匹配as但不想捕获任何内容，请使用它。

(?m)^(?:from[ ]+(\S+)[ ]+)?import[ ]+(\S+)(?:[ ]+as[ ]+\S+)?[ ]*$

https://regex101.com/r/xFtey5/1

展开

 (?m)                          # Modifiers: multi-line
 ^                             # Beginning of line
 (?:                           # Optional from
      from [ ]+ 
      ( \S+ )                       # (1), from <module>
      [ ]+ 
 )?

 import [ ]+                   # Required import
 ( \S+ )                       # (2), import <module>

 (?:                           # Optional as
      [ ]+ 
      as [ ]+ 
      \S+                          # <alias>
 )?
 [ ]* 
 $