Hogyan állítsuk össze a Python absztrakt szintaxis fákat (AST) a Mathematicában?

Nem vagyok biztos benne, hogy pontosan mit keres. Azt hiszem, a kérdésedre adott válasz:

Programozatosan próbálok Python kódot generálni az MMA-ban […], majd nyújtsa be a Pythonnak értékelésre. Össze tudtam állítani a Python kód karaktersorozatait, de akkor az összes behúzást kezelnem kell, ami fájdalomnak tűnik.

Lehetséges ilyen Python objektum létrehozása a Mathematica oldalon?

A

a ExternalEvaluate és a Python “s ” ast ” könyvtár.

Íme egy példa:

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

(eval a exec helyett, mert a eval értéket ad vissza.)

Megjegyzések

• Köszönöm Anton. Igen, tisztább tudtam volna lenni. Hadd frissítsem egy kicsit a kérdésemet. Alapvetően a ” ‘ [i ** 2 i-re a (10) tartományban] ‘ ” rész a válaszodban az MMA-oldalon, de nem Python-karakterláncként, hanem mint ast.Module objektum, amely csatlakoztatható a fordításhoz, az eval és az exec végrehajtásához.

Úgy gondolom, hogy a Python kód karaktersorozatként való összeállítása valójában egyszerűbb, mint amit javasol. De azt is tudom, hogy én csak azt mondtam, hogy ez nem fog meggyőzni senkit, ezért itt van egy példa.

Meghatározunk pár szimbolikus fejet, amelyek a Mathematica Python programját fogják képviselni, és egy funkciót, amellyel kifejezések azokkal a szimbolikus fejekkel:

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 ] 

Amit ezek a funkciók lehetővé tesznek számunkra, az az, hogy Python-kódot írunk a Mathematicába anélkül, hogy gondolkodnánk a behúzáson, ez kicsit olyan, mint Python kód felépítése az ast modullal.

Ez a példa a szimbolikus kifejezés karakterláncként történő megjelenítésére:

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

Erre könnyen építhetünk, és leíróbbá tehetjük a Python program szimbolikus ábrázolását.

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

Ezekkel a segítődefiníciókkal most nagyon olvasható stílusban írhatjuk a következő programot.

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) 

Ha még nincs “”, kérjük, keresse meg ” szimbolikus C a Mathematica dokumentációjában. Ez alapvetően egy AST létrehozásának módja egy C nyelvprogram számára a Mathematicában, amelyet aztán futtatható C kódgá lehet alakítani. Alapvetően itt tartunk ezzel a kóddal is, bár ha egy teljes megvalósítást szándékoznék megvalósítani, akkor ez nem pontosan így nézne ki (az ast modult mindenképpen érdemes tanulmányozni, ha valaki az útvonalon akar menni).

Visszatérve a lényegre: amit ezzel a válasszal szeretnék közölni, az az, hogy nem kell sok időt töltenie egy olyan kis keretrendszer felépítéséhez, amely többé-kevésbé megoldja a kérdésében megemlített behúzási problémát .

Megjegyzések

• Igen, CE ez nagyon úgy néz ki, hogy amit elképzeltem, kínzást jelentene, és igazad van, ezt megcsináltad egészen egyértelmű. Ilyen módon folytatnom kell a nyelv lefelé terjesztését a levelek felé az atomok és operátorok, listák és tömbök és hasonlók lefedésére, de ez a keret kezeli az összes behúzást, és megvalósíthatónak kell lennie.
• @berniethejet Ebben a példában meghatároztam például az PyIf -t valamire, ami mássá értékelhető. Fontolja meg, hogy ehelyett hozzáadja a definíciót a ToPythonString elemhez, azaz ToPythonString[PyIf[...]] :=. Így a teljes programját szimbolikus formában vizsgálhatja meg, anélkül, hogy kiértékelné, amíg meg nem hívja a ToPythonString hívást.
• Köszönöm, ezt jó tudni. A keretrendszere minden bizonnyal jobb, mint bármi más, amit összefogtam volna (morogtam az egész utat, ahogy óhatatlanul is, idegesítem Guido ‘ s behúzási keresztes hadjáratán).