您可能不需要重新生成源代码。当然，这对我来说有点危险，因为您实际上并没有解释为什么您认为需要生成一个充满代码的.py文件;但是:

If you want to generate a .py file that people will actually use, maybe so that they can fill out a form and get a useful .py file to insert into their project, then you don't want to change it into an AST and back because you'll lose all formatting (think of the blank lines that make Python so readable by grouping related sets of lines together) (ast nodes have lineno and col_offset attributes) comments. Instead, you'll probably want to use a templating engine (the Django template language, for example, is designed to make templating even text files easy) to customize the .py file, or else use Rick Copeland's MetaPython extension. If you are trying to make a change during compilation of a module, note that you don't have to go all the way back to text; you can just compile the AST directly instead of turning it back into a .py file. But in almost any and every case, you are probably trying to do something dynamic that a language like Python actually makes very easy, without writing new .py files! If you expand your question to let us know what you actually want to accomplish, new .py files will probably not be involved in the answer at all; I have seen hundreds of Python projects doing hundreds of real-world things, and not a single one of them needed to ever writer a .py file. So, I must admit, I'm a bit of a skeptic that you've found the first good use-case. :-)

更新:既然你已经解释了你要做的事情，我还是想做AST手术。您可能希望通过删除整个语句而不是删除文件中的行(这可能导致半条语句，并简单地使用SyntaxError终止)来进行更改—还有什么地方比在AST中更好地做到这一点呢?

Pythoscope对它自动生成的测试用例执行此操作，就像python 2.6的2to3工具一样(它转换python 2。X源代码转换为python 3。x源)。

这两个工具都使用lib2to3库，它是python解析器/编译器机制的实现，可以在从source -> AST -> source循环绊倒源代码时保留源代码中的注释。

如果您想进行更多的重构(如转换)，rope项目可以满足您的需求。

ast模块是另一个选择，还有一个关于如何将语法树“解解析”回代码的旧示例(使用解析器模块)。但是ast模块在对随后转换为代码对象的代码进行ast转换时更有用。

红男爵计划也可能是个不错的选择(泽维尔·康贝尔)

内置ast模块似乎没有转换回源代码的方法。但是，这里的codegen模块为ast提供了一个漂亮的打印机，使您能够这样做。 如。

import ast
import codegen

expr="""
def foo():
   print("hello world")
"""
p=ast.parse(expr)

p.body[0].body = [ ast.parse("return 42").body[0] ] # Replace function body with "return 42"

print(codegen.to_source(p))

这将打印:

def foo():
    return 42

请注意，您可能会丢失确切的格式和注释，因为这些没有保留。

但是，您可能不需要这样做。如果您所需要的只是执行替换的AST，那么只需在AST上调用compile()并执行结果代码对象即可。

程序转换系统是一种工具，它可以解析源文本，构建ast，允许您使用源到源转换(“如果您看到这个模式，请将其替换为那个模式”)来修改它们。这样的工具非常适合对现有源代码进行突变，即“如果看到此模式，请用模式变体替换”。

当然，您需要一个程序转换引擎，它可以解析您感兴趣的语言，并仍然执行面向模式的转换。我们的DMS软件再造工具包就是一个可以做到这一点的系统，它可以处理Python和各种其他语言。

请参阅这个SO答案，以获得一个用于Python准确捕获注释的dms解析AST示例。DMS可以对AST进行更改，并重新生成有效文本，包括注释。您可以要求它使用自己的格式约定(您可以更改这些约定)对AST进行美化打印，或者进行“保真打印”，即使用原始的行和列信息来最大限度地保留原始布局(插入新代码时不可避免地会对布局进行一些更改)。

要用DMS实现Python的“突变”规则，您可以编写以下代码:

rule mutate_addition(s:sum, p:product):sum->sum =
  " \s + \p " -> " \s - \p"
 if mutate_this_place(s);

该规则以语法正确的方式将“+”替换为“-”;它对AST进行操作，因此不会触及碰巧看起来正确的字符串或注释。“mutate_this_place”上的额外条件是让您控制这种情况发生的频率;你不希望改变程序中的每一个地方。

显然，您需要更多这样的规则来检测各种代码结构，并将它们替换为变异的版本。DMS乐于应用一组规则。突变的AST随后被漂亮地打印出来。

我最近创建了相当稳定的(核心是经过良好测试的)和可扩展的代码段，它从ast树生成代码:https://github.com/paluh/code-formatter。

我正在使用我的项目作为一个小vim插件的基础(我每天都在使用)，所以我的目标是生成非常漂亮和可读的python代码。

P.S. I've tried to extend codegen but it's architecture is based on ast.NodeVisitor interface, so formatters (visitor_ methods) are just functions. I've found this structure quite limiting and hard to optimize (in case of long and nested expressions it's easier to keep objects tree and cache some partial results - in other way you can hit exponential complexity if you want to search for best layout). BUT codegen as every piece of mitsuhiko's work (which I've read) is very well written and concise.

另一种回答建议使用密码原，它似乎已被阿斯特取代。PyPI上的astor版本(撰写本文时的版本为0.5)似乎也有点过时，因此您可以按如下方式安装astor的开发版本。

pip install git+https://github.com/berkerpeksag/astor.git#egg=astor

然后你可以使用阿斯特。to_source将Python AST转换为人类可读的Python源代码:

>>> import ast
>>> import astor
>>> print(astor.to_source(ast.parse('def foo(x): return 2 * x')))
def foo(x):
    return 2 * x

我已经在Python 3.5上进行了测试。

在另一个答案中，我建议使用astor包，但我后来发现了一个名为astunparse的最新AST非解析包:

>>> import ast
>>> import astunparse
>>> print(astunparse.unparse(ast.parse('def foo(x): return 2 * x')))


def foo(x):
    return (2 * x)

我已经在Python 3.5上进行了测试。

我们也有类似的需求，这里的其他答案并没有解决这个问题。因此，我们为此创建了一个库ASTTokens，它采用AST或astroid模块生成的AST树，并用原始源代码中的文本范围标记它。

它不直接修改代码，但在上面添加代码并不难，因为它会告诉您需要修改的文本范围。

例如，这将在WRAP(…)中包装一个函数调用，保留注释和其他内容:

example = """
def foo(): # Test
  '''My func'''
  log("hello world")  # Print
"""

import ast, asttokens
atok = asttokens.ASTTokens(example, parse=True)

call = next(n for n in ast.walk(atok.tree) if isinstance(n, ast.Call))
start, end = atok.get_text_range(call)
print(atok.text[:start] + ('WRAP(%s)' % atok.text[start:end])  + atok.text[end:])

生产:

def foo(): # Test
  '''My func'''
  WRAP(log("hello world"))  # Print

希望这能有所帮助!

在ast模块的帮助下，解析和修改代码结构当然是可能的，我将在稍后的示例中展示它。然而，仅使用ast模块是不可能写回修改后的源代码的。还有其他模块可用于这项工作，例如这里的一个。

注意:下面的例子可以作为ast模块使用的入门教程，但是更全面的ast模块使用指南可以在绿树蛇教程和ast模块的官方文档中找到。

ast简介:

>>> import ast
>>> tree = ast.parse("print 'Hello Python!!'")
>>> exec(compile(tree, filename="<ast>", mode="exec"))
Hello Python!!

你可以通过调用API ast.parse()来解析python代码(以字符串表示)。它返回抽象语法树(AST)结构的句柄。有趣的是，您可以编译回这个结构并执行它，如上面所示。

另一个非常有用的API是AST .dump()，它将整个AST以字符串形式转储。它可以用来检查树形结构，在调试中有很大的帮助。例如,

在Python 2.7中:

>>> import ast
>>> tree = ast.parse("print 'Hello Python!!'")
>>> ast.dump(tree)
"Module(body=[Print(dest=None, values=[Str(s='Hello Python!!')], nl=True)])"

在Python 3.5上:

>>> import ast
>>> tree = ast.parse("print ('Hello Python!!')")
>>> ast.dump(tree)
"Module(body=[Expr(value=Call(func=Name(id='print', ctx=Load()), args=[Str(s='Hello Python!!')], keywords=[]))])"

请注意Python 2.7和Python 3.5中print语句的语法差异，以及各自树中AST节点类型的差异。

如何使用ast修改代码:

现在，让我们看一个用ast模块修改python代码的例子。修改AST结构的主要工具是AST . nodetransformer类。每当一个人需要修改AST时，他/她需要从它继承子类并相应地编写节点转换。

对于我们的例子，让我们试着编写一个简单的实用程序，它可以将python2, print语句转换为python3函数调用。

打印语句到Fun调用转换工具:print2to3.py

#!/usr/bin/env python
'''
This utility converts the python (2.7) statements to Python 3 alike function calls before running the code.

USAGE:
     python print2to3.py <filename>
'''
import ast
import sys

class P2to3(ast.NodeTransformer):
    def visit_Print(self, node):
        new_node = ast.Expr(value=ast.Call(func=ast.Name(id='print', ctx=ast.Load()),
            args=node.values,
            keywords=[], starargs=None, kwargs=None))
        ast.copy_location(new_node, node)
        return new_node

def main(filename=None):
    if not filename:
        return

    with open(filename, 'r') as fp:
        data = fp.readlines()
    data = ''.join(data)
    tree = ast.parse(data)

    print "Converting python 2 print statements to Python 3 function calls"
    print "-" * 35
    P2to3().visit(tree)
    ast.fix_missing_locations(tree)
    # print ast.dump(tree)

    exec(compile(tree, filename="p23", mode="exec"))

if __name__ == '__main__':
    if len(sys.argv) <=1:
        print ("\nUSAGE:\n\t print2to3.py <filename>")
        sys.exit(1)
    else:
        main(sys.argv[1])

这个实用程序可以在一个小的示例文件上尝试，比如下面的一个，它应该可以正常工作。

输入文件:py2.py

class A(object):
    def __init__(self):
        pass

def good():
    print "I am good"

main = good

if __name__ == '__main__':
    print "I am in main"
    main()

请注意，上面的转换仅供上一个教程使用，在实际情况下，必须查看所有不同的场景，例如打印“x是%s”%(“Hello Python”)。

我以前使用baron，但现在已经切换到parso，因为它是现代python的最新版本。效果很好。

我还需要这个做变异测试。用parso做一个真的很简单，请访问https://github.com/boxed/mutmut查看我的代码

如果你在2019年看到这个，那么你可以使用这个libcst 包中。它的语法类似ast。这就像一个魅力，并保留了代码结构。这对于你必须保留注释、空格、换行符等的项目是很有帮助的。

如果您不需要关心保留注释、空格和其他内容，那么ast和astor的组合可以很好地工作。

花了一些时间，但是Python 3.9有这个: https://docs.python.org/3.9/whatsnew/3.9.html#ast https://docs.python.org/3.9/library/ast.html#ast.unparse

ast.unparse(ast_obj)

取消解析ast.AST对象并生成一个字符串，如果使用ast.parse()进行解析，该字符串将生成一个等效的ast.AST对象。

不幸的是，上面的答案实际上没有一个同时满足这两个条件

保持周围源代码的语法完整性(例如保留注释，其他类型的代码格式) 实际上使用AST(而不是CST)。

我最近写了一个小工具包来进行纯基于AST的重构，称为重构。例如，如果你想用42替换所有占位符，你可以简单地像这样写一个规则;

class Replace(Rule):
    
    def match(self, node):
        assert isinstance(node, ast.Name)
        assert node.id == 'placeholder'
        
        replacement = ast.Constant(42)
        return ReplacementAction(node, replacement)

它会找到所有可接受的节点，用新节点替换它们并生成最终的表单;

--- test_file.py
+++ test_file.py

@@ -1,11 +1,11 @@

 def main():
-    print(placeholder * 3 + 2)
-    print(2 +               placeholder      + 3)
+    print(42 * 3 + 2)
+    print(2 +               42      + 3)
     # some commments
-    placeholder # maybe other comments
+    42 # maybe other comments
     if something:
         other_thing
-    print(placeholder)
+    print(42)
 
 if __name__ == "__main__":
     main()