¿Cómo ensamblar árboles de sintaxis abstracta (AST) de Python en Mathematica?

No estoy seguro de qué es exactamente lo que está buscando. Creo que la respuesta a tu pregunta:

Estoy intentando generar código Python mediante programación en MMA […] y luego envíelo a Python para su evaluación. Podría ensamblar cadenas de código Python, pero luego tengo que manejar toda la sangría, lo que parece una molestia.

¿Es posible crear este tipo de objeto Python en el lado de Mathematica?

es bastante sencillo con ExternalEvaluate y Python «s » ast » biblioteca.

Aquí hay un ejemplo:

code = ""[i**2 for i in range(10)]""; astTemplate = StringTemplate["import ast; eval(compile(ast.parse(`1`, mode="eval"), "", "eval"))"]; astTemplate[code] (* "import ast; eval(compile(ast.parse("[i**2 for i in range(10)]", mode="eval"), "", "eval"))" *) ExternalEvaluate["Python", astTemplate[code]] (* {0, 1, 4, 9, 16, 25, 36, 49, 64, 81} *) 

(usé eval en lugar de exec, porque eval devuelve un valor.)

Comentarios

• Gracias Anton. Sí, podría haber sido más claro. Permítanme actualizar un poco mi pregunta. Básicamente, quiero generar el » ‘ [i ** 2 para i en el rango (10)] ‘ » parte de su respuesta en el lado de MMA, pero no como una cadena de Python, sino como el objeto ast.Module que puede conectarse a compilar y evaluar y ejecutar.

Creo que compilar código Python como una cadena es en realidad más simple de lo que propones. Pero también sé que solo digo que no convencerá a nadie, así que aquí hay un ejemplo.

Definimos un par de cabezas simbólicas que representarán nuestro programa Python en Mathematica, y una función para renderizar expresiones con esas cabezas simbólicas:

ToPythonString[statements_List] := StringRiffle[ToPythonString /@ statements, "\n"] ToPythonString[PyBlock[statement_, children_, indent_ : 0]] := StringJoin[ StringRepeat[" ", indent], statement, ":\n", ToPythonString[PyIndent /@ children] ] ToPythonString[PyStatement[statement_, indent_ : 0]] := StringJoin[ StringRepeat[" ", indent], statement ] PyIndent[PyBlock[statement_, children_, indent_ : 0]] := PyBlock[ statement, PyIndent /@ children, indent + 1 ] PyIndent[PyStatement[statement_, indent_ : 0]] := PyStatement[ statement, indent + 1 ] 

Lo que estas funciones nos permiten hacer es escribir código Python en Mathematica sin pensar en la sangría, es un poco como compilando código Python con el módulo ast.

Este es un ejemplo de cómo representar la expresión simbólica como una cadena:

prog = { PyStatement["a = 1"], PyStatement["b = 2"], PyBlock["If a > b", { PyStatement["Print("a is larger than b")"] }], PyBlock["def f(x)", { PyStatement["Print("executing f")"], PyBlock["if x > 0", { PyStatement["Print("x is larger than 0")"] }] }] }; ToPythonString[prog] 

Fuera:

a = 1 b = 2 If a > b: Print("a is larger than b") def f(x): Print("executing f") if x > 0: Print("x is larger than 0") 

Podemos construir fácilmente sobre esto y hacer que nuestra representación simbólica del programa Python sea más descriptiva.

PyAssign[lhs_, rhs_] := PyStatement[lhs <> " = " <> rhs] PyPrint[text_] := PyStatement["Print(" <> text <> ")"] PyFunction[name_, args_, statements_] := PyBlock[ "def " <> name <> "(" <> StringRiffle[args, ", "] <> ")", statements ] PyIf[cond_, statements_] := PyBlock[ "If " <> cond, statements ] PyIf[cond_, statements_, elseStatements_] := { PyBlock[ "If " <> cond, statements ], PyBlock[ "else", elseStatements ] } 

Con estas definiciones de ayuda, ahora podemos escribir el siguiente programa en un estilo muy legible.

prog = { PyAssign["a", "1"], PyAssign["b", "2"], PyIf[ "a > b", { PyPrint["a is larger than b"] }], PyFunction["f", {"x"}, PyIf[ "x > 0", {PyPrint["x is larger than 0"]}, {PyPrint["x is not larger than 0"]} ] ] }; ToPythonString[prog] 

Fuera:

a = 1 b = 2 If a > b: Print(a is larger than b) def f(x): If x > 0: Print(x is larger than 0) else: Print(x is not larger than 0) 

Si aún no lo ha hecho, busque » simbólico C en la documentación de Mathematica. Básicamente es una forma de construir un AST para un programa en lenguaje C en Mathematica que luego se puede convertir en código C ejecutable. Eso es básicamente hacia donde nos dirigimos con este código también, aunque si tuviera la intención de hacer una implementación completa como esa, no se vería exactamente así (el módulo ast ciertamente vale la pena estudiarlo si uno quiere seguir el camino).

De vuelta al grano: lo que quiero transmitir con esta respuesta es que no tienes que dedicar mucho tiempo a construir un marco pequeño que resuelva más o menos el problema de sangría que mencionas en tu pregunta .

Comentarios

• Sí CE, esto se parece mucho a lo que estaba imaginando que sería una tortura de implementar, y tienes razón, lo has logrado bastante sencillo. Tendré que continuar de esta manera extendiendo el lenguaje hacia abajo hacia las hojas para cubrir átomos y operadores y listas y tuplas y demás, pero este marco maneja toda la sangría, y debería ser factible.
• @berniethejet En este ejemplo, definí, por ejemplo, PyIf como algo que se evalúa en otra cosa. En su lugar, puede considerar agregar la definición a ToPythonString, es decir, ToPythonString[PyIf[...]] :=. De esa manera, puede inspeccionar todo su programa en forma simbólica, sin que sea evaluado hasta que llame a ToPythonString.
• Gracias, es bueno saberlo. Su marco es ciertamente mejor que cualquier otro que hubiera improvisado (refunfuñando todo el camino, como inevitablemente estaría molesto por la cruzada de sangría de Guido ‘).