Hur monterar man Python-abstrakta syntaxträd (AST) i Mathematica?

Jag är inte säker på vad du exakt letar efter. Jag tror att svaret på din fråga:

Jag försöker programmera generera Python-kod i MMA […] och skicka det sedan till Python för utvärdering. Jag kunde sätta ihop Python-kodsträngar, men då måste jag hantera hela indragningen, som verkar som en smärta.

Är det möjligt att skapa den här typen av Python-objekt på Mathematica-sidan?

är ganska enkelt med ExternalEvaluate och Python ”s ” ast ” bibliotek.

Här är ett exempel:

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} *) 

(jag använde eval istället för exec, eftersom eval returnerar ett värde.)

Kommentarer

• Tack Anton. Ja, jag kunde ha varit tydligare. Låt mig uppdatera min fråga lite. I grund och botten vill jag skapa ” ’ [i ** 2 för i inom intervallet (10)] ’ ” del i ditt svar på MMA-sidan, men inte som en Python-sträng, utan som det ast.Module-objekt som kan anslutas till kompilering och eval och exec.

Jag tycker att det är enklare att kompilera Python-kod som en sträng än vad du föreslår. Men jag vet också att jag bara sa att det inte kommer att övertyga någon, så här är ett exempel.

Vi definierar ett par symboliska huvuden som kommer att representera vårt Python-program i Mathematica och en funktion att återge uttryck med dessa symboliska huvuden:

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 ] 

Vad dessa funktioner tillåter oss är att skriva Python-kod i Mathematica utan att tänka på indraget, det är lite som bygga Python-kod med ast-modulen.

Detta är ett exempel på att göra det symboliska uttrycket som en sträng:

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] 

Ut:

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") 

Vi kan enkelt bygga vidare på detta och göra vår symboliska representation av Python-programmet mer beskrivande.

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 ] } 

Med dessa hjälpdefinitioner kan vi nu skriva följande program i en mycket läsbar stil.

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] 

Ut:

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) 

Om du inte har det än, snälla slå upp ” symbolisk C i Mathematica-dokumentationen. Det är i grunden ett sätt att bygga en AST för ett C-språkprogram i Mathematica som sedan kan omvandlas till körbar C-kod. Det är i grunden dit vi också är på väg med den här koden, men om jag tänkte göra en fullständig implementering så skulle den inte se exakt så ut (ast-modulen är verkligen värt att studera om man vill gå längs vägen). / p>

Tillbaka till punkten: vad jag vill förmedla med det här svaret är att du inte behöver spendera mycket tid på att bygga ett litet ramverk som mer eller mindre löser det fördjupningsproblem som du nämner i din fråga .

Kommentarer

• Ja CE detta ser väldigt mycket ut som vad jag föreställde mig skulle vara tortyr att genomföra, och du har rätt, du har gjort det ganska enkelt. Jag måste fortsätta på detta sätt och utvidga språket nedåt mot bladen för att täcka atomer och operatörer och listor och tuplar och sådant, men denna ram hanterar hela fördjupningen, och den borde vara genomförbar.
• @berniethejet I det här exemplet definierade jag till exempel PyIf till något som utvärderas till något annat. Du kan överväga att istället lägga till definitionen till ToPythonString, dvs. ToPythonString[PyIf[...]] :=. På det sättet kan du inspektera hela programmet i symbolisk form utan att det utvärderas förrän du ringer till ToPythonString.
• Tack, det är bra att veta. Ditt ramverk är verkligen bättre än något annat jag skulle ha kullat ihop (klagade hela vägen, som jag oundvikligen skulle bli, irriterad över Guido ’ s indrag korståg).