Question

我想要能够分析函数调用的代码：

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

并返回每个参数的位置，在本例中为foo，baz()，'puppet'，24+2，meow=3，{{1} }，*meowargs。

我尝试使用**meowargs模块，这似乎只是工作的事情，但不幸的是有问题。例如，在像_ast这样的函数调用本身的参数中，我找不到一种简单的方法来获取它的长度。（即使我找到了一个，我也不希望每种不同的论点都有一堆特殊情况。）

我还查看了baz()模块，但看不到如何使用它来获取参数。

知道如何解决这个问题吗？

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，则不应该是一个问题），并且您需要一个字符串解析器。一个简单的状态机应该可以解决问题。

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

3 个答案: