Cum să asamblați arbori de sintaxă abstractă Python (AST) în Mathematica?

Nu sunt sigur ce căutați exact. Cred că răspunsul la întrebarea ta:

Încerc să generez cod Python programat în MMA […] și apoi trimiteți-l la Python pentru evaluare. Aș putea asambla șiruri de cod Python, dar apoi trebuie să mă ocup de toată indentarea, ceea ce pare a fi o durere.

Este posibil să creăm acest tip de obiect Python pe partea Mathematica?

este destul de simplu folosind ExternalEvaluate și Python „s ” ast ” biblioteca.

Iată un exemplu:

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

(am folosit eval în loc de exec, deoarece eval returnează o valoare.)

Comentarii

• Mulțumesc Anton. Da, aș fi putut fi mai clar. Permiteți-mi să-mi actualizez puțin întrebarea. Practic vreau să generez ” ‘ [i ** 2 pentru i în intervalul (10)] ‘ ” faceți parte din răspunsul dvs. pe partea MMA, dar nu ca un șir Python, ci ca obiect ast.Module care se poate conecta la compilare, eval și exec.

Cred că compilarea codului Python ca șir este de fapt mai simplă decât ceea ce propuneți. Dar știu și că spun doar că nu va convinge pe nimeni, așa că iată un exemplu.

Definim câteva capete simbolice care vor reprezenta programul nostru Python în Mathematica și o funcție de redat expresii cu aceste capete simbolice:

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 ] 

Ceea ce ne permit aceste funcții este să scriem cod Python în Mathematica fără să ne gândim la indentare, este un pic ca construirea codului Python cu modulul ast.

Acesta este un exemplu de redare a expresiei simbolice ca un șir:

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] 

Out:

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

Ne putem baza cu ușurință pe acest lucru și putem face reprezentarea noastră simbolică a programului Python mai descriptivă.

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

Cu aceste definiții de ajutor, putem scrie acum următorul program într-un stil foarte lizibil.

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] 

Out:

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) 

Dacă nu aveți încă, vă rugăm să căutați ” simbolic C în documentația Mathematica. Este practic o modalitate de a construi un AST pentru un program de limbaj C în Mathematica care poate fi apoi convertit în cod C rulabil. De fapt, acolo ne îndreptăm și cu acest cod, deși, dacă aș intenționa să realizez o implementare completă de genul acesta, nu ar arăta exact așa (modulul ast merită cu siguranță să fie studiat dacă se dorește să mergem pe traseu).

Înapoi la subiect: ceea ce vreau să transmit cu acest răspuns este că nu trebuie să petreceți mult timp pentru a construi un cadru mic care rezolvă mai mult sau mai puțin problema de indentare pe care o menționați în întrebarea dvs. .

Comentarii

• Da CE, acest lucru seamănă foarte mult cu ceea ce îmi închipuiam că ar fi tortura de implementat și ai dreptate, ai reușit destul de direct. Va trebui să continui astfel, extinzând limbajul în jos spre frunze pentru a acoperi atomii și operatorii și listele și tuplele și altele, dar acest cadru gestionează toată indentarea și ar trebui să fie realizabil.
• @berniethejet În acest exemplu, am definit de exemplu PyIf la ceva care se evaluează în altceva. Vă recomandăm să adăugați definiția la ToPythonString, adică ToPythonString[PyIf[...]] :=. În acest fel, vă puteți inspecta întregul program într-o formă simbolică, fără ca acesta să fie evaluat până când nu apelați ToPythonString.
• Vă mulțumim, este bine să știți. Cadrul dvs. este cu siguranță mai bun decât oricare altul pe care l-aș fi coborât împreună (mormăind tot drumul, așa cum aș fi inevitabil, supărat de cruciada indentării lui Guido ‘).