解析Python函数调用来获取参数的位置

Question

我想代码，可以分析一个函数调用是这样的：

whatever(foo, baz(), 'puppet', 24+2, meow=3, *meowargs, **meowargs) 

，并返回各自的每个参数的位置，在这种情况下foo，baz()，'puppet'，24+2 ，meow=3，*meowargs，**meowargs。

我尝试使用_ast模块，它似乎只是工作的事情，但不幸的是有问题。例如，在一个像自己的函数调用baz()这样的参数中，我找不到一个简单的方法来获得它的长度。 （即使我找到了一个，我也不想为每一种不同类型的论证提供一些特殊情况。）

我也查看了tokenize模块，但看不到如何使用它来获取参数。

任何想法如何解决这个问题？

Answer 1

该代码使用的ast组合（找到初始参数偏移）和正则表达式（以确定的参数边界）：

import ast 
import re 

def collect_offsets(call_string): 
    def _abs_offset(lineno, col_offset): 
     current_lineno = 0 
     total = 0 
     for line in call_string.splitlines(): 
      current_lineno += 1 
      if current_lineno == lineno: 
       return col_offset + total 
      total += len(line) 
    # parse call_string with ast 
    call = ast.parse(call_string).body[0].value 
    # collect offsets provided by ast 
    offsets = [] 
    for arg in call.args: 
     a = arg 
     while isinstance(a, ast.BinOp): 
      a = a.left 
     offsets.append(_abs_offset(a.lineno, a.col_offset)) 
    for kw in call.keywords: 
     offsets.append(_abs_offset(kw.value.lineno, kw.value.col_offset)) 
    if call.starargs: 
     offsets.append(_abs_offset(call.starargs.lineno, call.starargs.col_offset)) 
    if call.kwargs: 
     offsets.append(_abs_offset(call.kwargs.lineno, call.kwargs.col_offset)) 
    offsets.append(len(call_string)) 
    return offsets 

def argpos(call_string): 
    def _find_start(prev_end, offset): 
     s = call_string[prev_end:offset] 
     m = re.search('(\(|,)(\s*)(.*?)$', s) 
     return prev_end + m.regs[3][0] 
    def _find_end(start, next_offset): 
     s = call_string[start:next_offset] 
     m = re.search('(\s*)$', s[:max(s.rfind(','), s.rfind(')'))]) 
     return start + m.start() 

    offsets = collect_offsets(call_string) 

    result = [] 
    # previous end 
    end = 0 
    # given offsets = [9, 14, 21, ...], 
    # zip(offsets, offsets[1:]) returns [(9, 14), (14, 21), ...] 
    for offset, next_offset in zip(offsets, offsets[1:]): 
     #print 'I:', offset, next_offset 
     start = _find_start(end, offset) 
     end = _find_end(start, next_offset) 
     #print 'R:', start, end 
     result.append((start, end)) 
    return result 

if __name__ == '__main__': 
    try: 
     while True: 
      call_string = raw_input() 
      positions = argpos(call_string) 
      for p in positions: 
       print ' ' * p[0] + '^' + ((' ' * (p[1] - p[0] - 2) + '^') if p[1] - p[0] > 1 else '') 
      print positions 
    except EOFError, KeyboardInterrupt: 
     pass 

输出：

whatever(foo, baz(), 'puppet', 24+2, meow=3, *meowargs, **meowargs) 
     ^^ 
      ^^
        ^ ^
          ^^ 
            ^^
              ^ ^
                 ^ ^
[(9, 12), (14, 19), (21, 29), (31, 35), (37, 43), (45, 54), (56, 66)] 
f(1, len(document_text) - 1 - position) 
^
    ^       ^
[(2, 3), (5, 38)] 

Answer 2

您可能想要为函数的函数调用获取抽象语法树。

Here is a python recipe to do so，基于ast模块。

Python的ast模块用于解析代码字符串并创建一个ast 节点。然后，它通过生成的ast.AST节点来查找使用NodeVisitor子类的 功能。

功能explain进行解析。这里是你分析你的函数调用，你会得到什么

>>> explain('mymod.nestmod.func("arg1", "arg2", kw1="kword1", kw2="kword2", 
     *args, **kws') 
    [Call( args=['arg1', 'arg2'],keywords={'kw1': 'kword1', 'kw2': 'kword2'}, 
     starargs='args', func='mymod.nestmod.func', kwargs='kws')] 

Answer 3

如果我理解正确的，从你的榜样，你想要的东西，如：

--> arguments("whatever(foo, baz(), 'puppet', 24+2, meow=3, *meowargs, **meowkwds)") 
{ 
    'foo': slice(9, 12), 
    'baz()': slice(14, 19), 
    '24+2': slice(21, 29), 
    'meow=3': slice(32, 38), 
    '*meowargs': slice(41, 50), 
    '**meowkwds': slice(53, 63), 
} 

请注意，我改变了你的最后一个参数的名称，因为你不能有两个同名的参数。

如果这是你想要的，那么你需要有问题的原始字符串（不应该是一个问题，如果你建立一个IDE），并且你需要一个字符串解析器。一个简单的状态机应该这样做。