Wie sollte der abstrakte Syntaxbaum von Python Ast verwendet werden?

Einführung

Abstrakte Syntaxbäume sind abstrakte Syntaxbäume. Ast ist ein Zwischenprodukt vom Python-Quellcode zum Bytecode. Mit Hilfe des ast-Moduls kann die Quellcodestruktur aus der Perspektive eines Syntaxbaums analysiert werden.

Darüber hinaus können wir nicht nur den Syntaxbaum ändern und ausführen, sondern auch den von Source generierten Syntaxbaum in Python-Quellcode entparsen. Daher lässt ast genügend Raum für die Überprüfung des Python-Quellcodes, die Syntaxanalyse, die Codeänderung und das Code-Debugging.

1. Einführung in AST

Der von Python offiziell bereitgestellte CPython-Interpreter verarbeitet Python-Quellcode wie folgt:

Parse-Quellcode in einen Parse-Baum (Parser/pgen.c)

Transformiere den Parse-Baum in einen abstrakten Syntaxbaum (Python/ast.c)

AST in ein Kontrollflussdiagramm umwandeln (Python/compile.c)

Bytecode basierend auf dem Kontrollflussdiagramm ausgeben (Python/compile.c)

Das heißt, der Verarbeitungsprozess von Der eigentliche Python-Code lautet wie folgt:

Quellcode-Analyse--> Abstrakter Syntaxbaum (AST)--> Kontrollflussdiagramm--> 5. Der Python-Quellcode wird zunächst in einen Syntaxbaum analysiert und dann in einen abstrakten Syntaxbaum umgewandelt. Im abstrakten Syntaxbaum können wir die Syntaxstruktur von Python in der Quellcodedatei sehen.

In den meisten Fällen werden abstrakte Syntaxbäume für die Programmierung möglicherweise nicht benötigt, aber unter bestimmten Bedingungen und Anforderungen bietet AST seine eigenen besonderen Vorteile.

Das Folgende ist ein einfaches Beispiel für abstrakte Syntax.

Module(body=[
    Print(
          dest=None,
          values=[BinOp( left=Num(n=1),op=Add(),right=Num(n=2))],
          nl=True,
 )])

2. AST erstellen

2.1 Kompilierungsfunktion

Lassen Sie uns zunächst kurz die Kompilierungsfunktion verstehen.

compile(source, filename, mode[, flags[, dont_inherit]])

source – String oder AST-Objekt (Abstract Syntax Trees). Im Allgemeinen kann der gesamte Inhalt der PY-Datei an file.read() übergeben werden.
Dateiname – der Name der Codedatei oder ein identifizierbarer Wert, wenn der Code nicht aus einer Datei gelesen wird.
mode – Geben Sie den Typ des kompilierten Codes an. Kann als exec, eval, single angegeben werden.
Flags – Variablenbereich, lokaler Namespace, falls angegeben, kann ein beliebiges Zuordnungsobjekt sein.
flags und dont_inherit sind Flags, die zur Steuerung beim Kompilieren des Quellcodes verwendet werden.

• func_def = \
  """
  def add(x, y):
      return x + y
  print add(3, 5)
  """

Verwenden Sie Compile zum Kompilieren und Ausführen:

>>> cm = compile(func_def, &#39;<string>&#39;, &#39;exec&#39;)
>>> exec cm
>>> 8

Die obige func_def wird durch Kompilieren kompiliert, um den Bytecode zu erhalten. cm ist das Codeobjekt.

compile(source, filename, mode, ast.PyCF_ONLY_AST) 209861d5cd2975725c730f519ed6ad71 ast.parse(source, filename='e12ba19319d03b5626da3e95daebf10a', mode='exec')

2.2 ast generieren

Verwenden Sie das obige func_def, um ast zu generieren.

r_node = ast.parse(func_def)
print astunparse.dump(r_node)    # print ast.dump(r_node)

Das Folgende ist die ast-Struktur, die func_def entspricht:

Module(body=[
    FunctionDef(
        name='add',
        args=arguments(
            args=[Name(id='x',ctx=Param()),Name(id='y',ctx=Param())],
            vararg=None,
            kwarg=None,
            defaults=[]),
        body=[Return(value=BinOp(
            left=Name(id='x',ctx=Load()),
            op=Add(),
            right=Name(id='y',ctx=Load())))],
        decorator_list=[]),
    Print(
        dest=None,
        values=[Call(
                func=Name(id='add',ctx=Load()),
                args=[Num(n=3),Num(n=5)],
                keywords=[],
                starargs=None,
                kwargs=None)],
        nl=True)
  ])

Zusätzlich zu ast.dump gibt es viele Bibliotheken von Drittanbietern, die ast ausgeben, z. B. astunparse, codegen und unparse , usw. Diese Bibliotheken von Drittanbietern können nicht nur die AST-Struktur besser anzeigen, sondern AST auch umgekehrt in Python-Quellcode exportieren.

module Python version "$Revision$"
{
  mod = Module(stmt* body)| Expression(expr body)
  stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list)
        | ClassDef(identifier name, expr* bases, stmt* body, expr* decorator_list)
        | Return(expr? value)
        | Print(expr? dest, expr* values, bool nl)| For(expr target, expr iter, stmt* body, stmt* orelse)
  expr = BoolOp(boolop op, expr* values)
       | BinOp(expr left, operator op, expr right)| Lambda(arguments args, expr body)| Dict(expr* keys, expr* values)| Num(object n) -- a number as a PyObject.
       | Str(string s) -- need to specify raw, unicode, etc?| Name(identifier id, expr_context ctx)
       | List(expr* elts, expr_context ctx) 
        -- col_offset is the byte offset in the utf8 string the parser uses
        attributes (int lineno, int col_offset)
  expr_context = Load | Store | Del | AugLoad | AugStore | Param
  boolop = And | Or 
  operator = Add | Sub | Mult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv
  arguments = (expr* args, identifier? vararg, identifier? kwarg, expr* defaults)
}

Das Obige ist ein Auszug aus der abstrakten Grammatik der offiziellen Website. Während des tatsächlichen Durchlaufens des ast-Knotens wird auf seine Eigenschaften je nach Knotentyp zugegriffen.

3. AST durchqueren

Python bietet zwei Möglichkeiten, den gesamten abstrakten Syntaxbaum zu durchqueren.

3.1 ast.NodeTransfer

Ändern Sie die Additionsoperation in der Add-Funktion in func_def in Subtraktion und fügen Sie ein Aufrufprotokoll für die Funktionsimplementierung hinzu.

  class CodeVisitor(ast.NodeVisitor):
      def visit_BinOp(self, node):
          if isinstance(node.op, ast.Add):
              node.op = ast.Sub()
          self.generic_visit(node)
      def visit_FunctionDef(self, node):
          print 'Function Name:%s'% node.name
          self.generic_visit(node)
          func_log_stmt = ast.Print(
              dest = None,
              values = [ast.Str(s = 'calling func: %s' % node.name, lineno = 0, col_offset = 0)],
              nl = True,
              lineno = 0,
              col_offset = 0,
          )
          node.body.insert(0, func_log_stmt)
  r_node = ast.parse(func_def)
  visitor = CodeVisitor()
  visitor.visit(r_node)
  # print astunparse.dump(r_node)
  print astunparse.unparse(r_node)
  exec compile(r_node, &#39;<string>&#39;, &#39;exec&#39;)

Laufergebnisse:

Function Name:add
def add(x, y):
    print 'calling func: add'
    return (x - y)
print add(3, 5)
calling func: add
-2

3.2 ast.NodeTransformer

Die Verwendung von NodeVisitor ändert hauptsächlich die AST-Struktur durch Ändern der Knoten im Syntaxbaum, und NodeTransformer ersetzt hauptsächlich die Knoten in ast.

Da nun das in func_def definierte Add in eine Subtraktionsfunktion geändert wurde, gehen wir gründlicher vor und ändern den Funktionsnamen, die Parameter und die aufgerufenen Funktionen in ast und machen das Aufrufprotokoll der hinzugefügten Funktion komplizierter. Einige versuchen, es zu ändern bis zur Unkenntlichkeit:-)

  class CodeTransformer(ast.NodeTransformer):
      def visit_BinOp(self, node):
          if isinstance(node.op, ast.Add):
              node.op = ast.Sub()
          self.generic_visit(node)
          return node
      def visit_FunctionDef(self, node):
          self.generic_visit(node)
          if node.name == 'add':
              node.name = 'sub'
          args_num = len(node.args.args)
          args = tuple([arg.id for arg in node.args.args])
          func_log_stmt = ''.join(["print 'calling func: %s', " % node.name, "'args:'", ", %s" * args_num % args])
          node.body.insert(0, ast.parse(func_log_stmt))
          return node
      def visit_Name(self, node):
          replace = {'add': 'sub', 'x': 'a', 'y': 'b'}
          re_id = replace.get(node.id, None)
          node.id = re_id or node.id
          self.generic_visit(node)
          return node
  r_node = ast.parse(func_def)
  transformer = CodeTransformer()
  r_node = transformer.visit(r_node)
  # print astunparse.dump(r_node)
  source = astunparse.unparse(r_node)
  print source
  # exec compile(r_node, &#39;<string>&#39;, &#39;exec&#39;)        # 新加入的node func_log_stmt 缺少lineno和col_offset属性
  exec compile(source, &#39;<string>&#39;, &#39;exec&#39;)
  exec compile(ast.parse(source), &#39;<string>&#39;, &#39;exec&#39;)

Ergebnis:

def sub(a, b):
    print 'calling func: sub', 'args:', a, b
    return (a - b)
print sub(3, 5)
calling func: sub args: 3 5
-2
calling func: sub args: 3 5
-2

Der Unterschied zwischen den beiden ist im Code deutlich zu erkennen. Ich werde hier nicht auf Details eingehen.

4.AST-Anwendung

Das AST-Modul wird in der tatsächlichen Programmierung selten verwendet, ist jedoch als zusätzliche Methode zur Überprüfung der Quellcodes, zur Fehlerbehebung, zur Erkennung spezieller Felder usw. sehr sinnvoll.

Das obige Hinzufügen von Anrufprotokollinformationen zur Funktion ist eine Möglichkeit, den Python-Quellcode zu debuggen, aber in Wirklichkeit durchlaufen und ändern wir den Quellcode, indem wir die gesamte Python-Datei analysieren.

4.1 Erkennung chinesischer Zeichen

Das Folgende ist der Unicode-Kodierungsbereich chinesischer, japanischer und koreanischer Zeichen Sprachen: Chinesisch, Japanisch, Koreanisch, Vietnamesisch

Verwenden Sie den Unicode-Bereich

u4e00 - u9fff

, um chinesische Schriftzeichen zu identifizieren (z. B. u';' == u'uff1b').

Das Folgende ist Eine Möglichkeit, festzustellen, ob eine Zeichenfolge chinesische Zeichen enthält. Eine Klasse von CNCheckHelper:

  class CNCheckHelper(object):
      # 待检测文本可能的编码方式列表
      VALID_ENCODING = ('utf-8', 'gbk')
      def _get_unicode_imp(self, value, idx = 0):
          if idx < len(self.VALID_ENCODING):
              try:
                  return value.decode(self.VALID_ENCODING[idx])
              except:
                  return self._get_unicode_imp(value, idx + 1)
      def _get_unicode(self, from_str):
          if isinstance(from_str, unicode):
              return None
          return self._get_unicode_imp(from_str)
      def is_any_chinese(self, check_str, is_strict = True):
          unicode_str = self._get_unicode(check_str)
          if unicode_str:
              c_func = any if is_strict else all
              return c_func(u&#39;\u4e00&#39; <= char <= u&#39;\u9fff&#39; for char in unicode_str)
          return False

Die Schnittstelle is_any_chinese verfügt über zwei Beurteilungsmodi. Die strikte Erkennung kann überprüft werden, solange sie chinesische Zeichenfolgen enthält, und die nicht strikte Erkennung muss alle chinesischen Zeichen enthalten.

下面我们利用ast来遍历源文件的抽象语法树，并检测其中字符串是否包含中文字符。

  class CodeCheck(ast.NodeVisitor):
      def __init__(self):
          self.cn_checker = CNCheckHelper()
      def visit_Str(self, node):
          self.generic_visit(node)
          # if node.s and any(u&#39;\u4e00&#39; <= char <= u&#39;\u9fff&#39; for char in node.s.decode(&#39;utf-8&#39;)):
          if self.cn_checker.is_any_chinese(node.s, True):
              print &#39;line no: %d, column offset: %d, CN_Str: %s&#39; % (node.lineno, node.col_offset, node.s)
  project_dir = &#39;./your_project/script&#39;
  for root, dirs, files in os.walk(project_dir):
      print root, dirs, files
      py_files = filter(lambda file: file.endswith(&#39;.py&#39;), files)
      checker = CodeCheck()
      for file in py_files:
          file_path = os.path.join(root, file)
          print &#39;Checking: %s&#39; % file_path
          with open(file_path, &#39;r&#39;) as f:
              root_node = ast.parse(f.read())
              checker.visit(root_node)

 上面这个例子比较的简单，但大概就是这个意思。

关于CPython解释器执行源码的过程可以参考官网描述：PEP 339

4.2 Closure 检查

一个函数中定义的函数或者lambda中引用了父函数中的local variable，并且当做返回值返回。特定场景下闭包是非常有用的，但是也很容易被误用。

关于python闭包的概念可以参考我的另一篇文章：理解Python闭包概念

这里简单介绍一下如何借助ast来检测lambda中闭包的引用。代码如下：

  class LambdaCheck(ast.NodeVisitor):
      def __init__(self):
          self.illegal_args_list = []
          self._cur_file = None
          self._cur_lambda_args = []
      def set_cur_file(self, cur_file):
          assert os.path.isfile(cur_file)， cur_file
          self._cur_file = os.path.realpath(cur_file)
      def visit_Lambda(self, node):
          """
          lambda 闭包检查原则：
          只需检测lambda expr body中args是否引用了lambda args list之外的参数
          """
          self._cur_lambda_args =[a.id for a in node.args.args]
          print astunparse.unparse(node)
          # print astunparse.dump(node)
          self.get_lambda_body_args(node.body)
          self.generic_visit(node)
      def record_args(self, name_node):
          if isinstance(name_node, ast.Name) and name_node.id not in self._cur_lambda_args:
              self.illegal_args_list.append((self._cur_file, 'line no:%s' % name_node.lineno, 'var:%s' % name_node.id))
      def _is_args(self, node):
          if isinstance(node, ast.Name):
              self.record_args(node)
              return True
          if isinstance(node, ast.Call):
              map(self.record_args, node.args)
              return True
          return False
      def get_lambda_body_args(self, node):
          if self._is_args(node): return
          # for cnode in ast.walk(node):
          for cnode in ast.iter_child_nodes(node):
              if not self._is_args(cnode):
                  self.get_lambda_body_args(cnode)

 遍历工程文件：

  project_dir = './your project/script'
  for root, dirs, files in os.walk(project_dir):
      py_files = filter(lambda file: file.endswith('.py'), files)
      checker = LambdaCheck()
      for file in py_files:
          file_path = os.path.join(root, file)
          checker.set_cur_file(file_path)
          with open(file_path, 'r') as f:
              root_node = ast.parse(f.read())
              checker.visit(root_node)
      res = '\n'.join([' ## '.join(info) for info in checker.illegal_args_list])
      print res

由于Lambda(arguments args, expr body)中的body expression可能非常复杂，上面的例子中仅仅处理了比较简单的body expr。可根据自己工程特点修改和扩展检查规则。为了更加一般化可以单独写一个visitor类来遍历lambda节点。

Das obige ist der detaillierte Inhalt vonWie sollte der abstrakte Syntaxbaum von Python Ast verwendet werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!