Hoe Python abstracte syntaxisbomen (AST) in Mathematica samen te stellen?

Ik weet niet zeker wat u precies zoekt. Ik denk dat het antwoord op je vraag:

Ik probeer Python-code programmatisch te genereren in MMA […] en dien het vervolgens ter evaluatie in bij Python. Ik zou Python-codetekenreeksen kunnen samenstellen, maar dan moet ik alle inspringingen afhandelen, wat lastig lijkt.

Is het mogelijk om dit soort Python-objecten aan de Mathematica-kant te maken?

is vrij eenvoudig met ExternalEvaluate en Python “s ” ast ” bibliotheek.

Hier is een voorbeeld:

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

(ik gebruikte eval in plaats van exec, omdat eval een waarde retourneert.)

Opmerkingen

• Bedankt Anton. Ja, ik had duidelijker kunnen zijn. Laat me mijn vraag een beetje bijwerken. In principe wil ik de ” ‘ [i ** 2 voor i in bereik (10)] ‘ ” deel aan je antwoord aan de MMA-kant, maar niet als een Python-string, maar als het ast.Module-object dat kan worden aangesloten op compileren en evalueren en uitvoeren.

Ik denk dat het compileren van Python-code als een string eigenlijk eenvoudiger is dan wat je voorstelt. Maar ik weet ook dat ik gewoon zeg dat het niemand zal overtuigen, dus hier is een voorbeeld.

We definiëren een aantal symbolische hoofden die ons Python-programma in Mathematica vertegenwoordigen, en een functie om uitdrukkingen met die symbolische koppen:

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 ] 

Wat deze functies ons toestaan is om Python-code in Mathematica te schrijven zonder na te denken over de inspringing, het is een beetje zoals Python-code bouwen met de ast-module.

Dit is een voorbeeld van het weergeven van de symbolische uitdrukking als een string:

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

We kunnen hier gemakkelijk op voortbouwen en onze symbolische representatie van het Python-programma beschrijvend maken.

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

Met deze hulpdefinities kunnen we nu het volgende programma in een zeer leesbare stijl schrijven.

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) 

Als je dit nog niet hebt gedaan, zoek dan ” symbolisch C in de Mathematica-documentatie. Het is eigenlijk een manier om een AST te bouwen voor een C-taalprogramma in Mathematica dat vervolgens kan worden omgezet in uitvoerbare C-code. Dat is eigenlijk waar we ook met deze code naartoe gaan, maar als ik van plan was om zon complete implementatie te maken, zou het er niet precies zo uitzien (de ast-module is zeker de moeite waard om te bestuderen als je de route wilt inslaan). / p>

Terug naar het punt: wat ik met dit antwoord wil overbrengen, is dat je niet veel tijd hoeft te besteden aan het bouwen van een klein raamwerk dat min of meer het indentatieprobleem oplost dat je in je vraag noemt .

Reacties

• Ja CE dit lijkt heel erg op wat ik me voorstelde dat marteling zou zijn om te implementeren, en je hebt gelijk, je hebt het gehaald vrij eenvoudig. Ik zal op deze manier door moeten gaan met het uitbreiden van de taal naar beneden richting de bladeren om atomen en operatoren en lijsten en tupels en dergelijke te omvatten, maar dit raamwerk behandelt alle inspringingen, en het zou goed moeten zijn.
• @berniethejet In dit voorbeeld heb ik bijvoorbeeld PyIf gedefinieerd als iets dat in iets anders evalueert. U kunt overwegen om in plaats daarvan de definitie toe te voegen aan ToPythonString, d.w.z. ToPythonString[PyIf[...]] :=. Op die manier kun je je hele programma in symbolische vorm bekijken, zonder dat het geëvalueerd wordt totdat je ToPythonString aanroept.
• Bedankt, dat is goed om te weten. Jouw raamwerk is zeker beter dan alle andere die ik in elkaar zou hebben geplaveid (de hele weg mopperen, zoals ik onvermijdelijk zou zijn, geïrriteerd door Guido ‘ s indentation crusade).