Pythonov ast modul: Demistificirana manipulacija apstraktnim sintaksnim stablom

Pythonov ast modul pruža moćan način za interakciju s apstraktnim sintaksnim stablom (AST) Python koda. AST je stablo koje predstavlja sintaktičku strukturu izvornog koda, što omogućuje programsku analizu, izmjenu, pa čak i generiranje Python koda. To otvara vrata raznim primjenama, uključujući alate za analizu koda, automatizirano refaktoriranje, statičku analizu, pa čak i prilagođena jezična proširenja. Ovaj članak će vas voditi kroz osnove ast modula, pružajući praktične primjere i uvide u njegove mogućnosti.

Što je apstraktno sintaksno stablo (AST)?

Prije nego što zaronimo u ast modul, shvatimo što je apstraktno sintaksno stablo. Kada Python interpreter izvršava vaš kod, prvi korak je parsiranje koda u AST. Ova struktura stabla predstavlja sintaktičke elemente koda, kao što su funkcije, klase, petlje, izrazi i operatori, zajedno s njihovim odnosima. AST odbacuje nebitne detalje poput razmaka i komentara, fokusirajući se na ključne strukturne informacije. Predstavljanjem koda na ovaj način, programi mogu analizirati i manipulirati samim kodom, što je izuzetno korisno u mnogim situacijama.

Početak rada s ast modulom

Modul ast dio je Pythonove standardne biblioteke, tako da ne trebate instalirati nikakve dodatne pakete. Jednostavno ga uvezite kako biste ga počeli koristiti:

            import ast
            

              
                Copy
              
            
          

Ključna funkcija ast modula je ast.parse(), koja kao ulaz prima string Python koda i vraća AST objekt.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)
            

              
                Copy
              
            
          

Ovo će ispisati nešto poput: <_ast.Module object at 0x...>. Iako ovaj ispis nije posebno informativan, on ukazuje da je kod uspješno parsiran u AST. Objekt ast_tree sada sadrži cijelu strukturu parsiranog koda.

Istraživanje AST-a

Kako bismo razumjeli strukturu AST-a, možemo koristiti funkciju ast.dump(). Ova funkcija rekurzivno prolazi stablom i ispisuje detaljan prikaz svakog čvora.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))
            

              
                Copy
              
            
          

Ispis će biti:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)
            

              
                Copy
              
            
          

Ovaj ispis prikazuje hijerarhijsku strukturu koda. Analizirajmo ga:

• Module: Korijenski čvor koji predstavlja cijeli modul.
• body: Lista naredbi unutar modula.
• FunctionDef: Predstavlja definiciju funkcije. Njegovi atributi uključuju:
• name: Ime funkcije ('add').
• args: Argumenti funkcije.
• arguments: Sadrži informacije o argumentima funkcije.
• arg: Predstavlja jedan argument (npr. 'x', 'y').
• body: Tijelo funkcije (lista naredbi).
• Return: Predstavlja naredbu return.
• value: Vrijednost koja se vraća.
• BinOp: Predstavlja binarnu operaciju (npr. x + y).
• left: Lijevi operand (npr. 'x').
• op: Operator (npr. 'Add').
• right: Desni operand (npr. 'y').

Prolazak kroz AST

Modul ast pruža klasu ast.NodeVisitor za prolazak kroz AST. Nasljeđivanjem klase ast.NodeVisitor i nadjačavanjem njezinih metoda, možete obraditi specifične tipove čvorova prilikom prolaska. To je korisno za analizu strukture koda, identificiranje specifičnih uzoraka ili izdvajanje informacija.

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Output: ['add', 'subtract']
            

              
                Copy
              
            
          

U ovom primjeru, FunctionNameExtractor nasljeđuje ast.NodeVisitor i nadjačava metodu visit_FunctionDef. Ova metoda se poziva za svaki čvor definicije funkcije u AST-u. Metoda dodaje ime funkcije na listu function_names. Metoda visit() pokreće prolazak kroz AST.

Primjer: Pronalaženje svih dodjela vrijednosti varijablama

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = "hello"
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Output: ['x', 'y', 'message']
            

              
                Copy
              
            
          

Ovaj primjer pronalazi sve dodjele vrijednosti varijablama u kodu. Metoda visit_Assign poziva se za svaku naredbu dodjele. Iterira kroz ciljeve dodjele i, ako je cilj jednostavno ime (ast.Name), dodaje ime na listu assignments.

Modificiranje AST-a

Modul ast također vam omogućuje modificiranje AST-a. Možete mijenjati postojeće čvorove, dodavati nove čvorove ili ih potpuno ukloniti. Za modificiranje AST-a koristite klasu ast.NodeTransformer. Slično kao i kod ast.NodeVisitor, nasljeđujete ast.NodeTransformer i nadjačavate njegove metode za modificiranje specifičnih tipova čvorova. Ključna razlika je u tome što metode ast.NodeTransformer-a trebaju vratiti modificirani čvor (ili novi čvor koji će ga zamijeniti). Ako metoda vrati None, čvor se uklanja iz AST-a.

Nakon modificiranja AST-a, trebate ga prevesti natrag u izvršni Python kod pomoću funkcije compile().

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

print(x)  # Output: 11
print(y)  # Output: 21
            

              
                Copy
              
            
          

U ovom primjeru, AddOneTransformer nasljeđuje ast.NodeTransformer i nadjačava metodu visit_Num. Ova metoda se poziva za svaki čvor numeričkog literala (ast.Num). Metoda stvara novi ast.Num čvor s vrijednošću uvećanom za 1. Metoda visit() vraća modificirani AST.

Funkcija compile() prima modificirani AST, naziv datoteke (<string> u ovom slučaju, što označava da kod dolazi iz stringa) i način izvršavanja ('exec' za izvršavanje bloka koda). Vraća objekt koda koji se može izvršiti pomoću funkcije exec().

Primjer: Zamjena imena varijable

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

            

              
                Copy
              
            
          

Ovaj primjer zamjenjuje sva pojavljivanja imena varijable 'number' s 'num'. Klasa VariableNameReplacer prima staro i novo ime kao argumente. Metoda visit_Name poziva se za svaki čvor imena. Ako identifikator čvora odgovara starom imenu, stvara novi ast.Name čvor s novim imenom i istim kontekstom (node.ctx). Kontekst označava kako se ime koristi (npr. učitavanje, pohranjivanje).

Generiranje koda iz AST-a

Iako compile() omogućuje izvršavanje koda iz AST-a, ne pruža način za dobivanje koda kao stringa. Za generiranje Python koda iz AST-a, možete koristiti biblioteku astunparse. Ova biblioteka nije dio standardne biblioteke, pa je prvo morate instalirati:

            pip install astunparse
            

              
                Copy
              
            
          

Zatim možete koristiti funkciju astunparse.unparse() za generiranje koda iz AST-a.

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)
            

              
                Copy
              
            
          

Ispis će biti:

            def add(x, y):
    return (x + y)

            

              
                Copy
              
            
          

Napomena: Zagrade oko (x + y) dodaje astunparse kako bi osigurao ispravan prioritet operatora. Ove zagrade možda nisu strogo potrebne, ali jamče ispravnost koda.

Primjer: Generiranje jednostavne klase

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Create the class definition node
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Create the module node containing the class definition
module = ast.Module(body=[class_def], type_ignores=[])

# Generate the code
code = astunparse.unparse(module)

print(code)
            

              
                Copy
              
            
          

Ovaj primjer generira sljedeći Python kod:

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

Ovo demonstrira kako izgraditi AST od nule, a zatim iz njega generirati kod. Ovaj pristup je moćan za alate za generiranje koda i metaprogramiranje.

Praktične primjene ast modula

Modul ast ima brojne praktične primjene, uključujući:

• Analiza koda: Analiza koda radi kršenja stila, sigurnosnih propusta ili uskih grla u performansama. Na primjer, mogli biste napisati alat za provođenje standarda kodiranja u velikom projektu.
• Automatizirano refaktoriranje: Automatizacija zadataka poput preimenovanja varijabli, izdvajanja metoda ili pretvaranja koda za korištenje novijih jezičnih značajki. Alati poput `rope` koriste AST za moćne mogućnosti refaktoriranja.
• Statička analiza: Identificiranje potencijalnih pogrešaka ili bugova u kodu bez njegovog pokretanja. Alati poput `pylint` i `flake8` koriste AST analizu za otkrivanje problema.
• Generiranje koda: Automatsko generiranje koda na temelju predložaka ili specifikacija. Ovo je korisno za stvaranje ponavljajućeg koda ili generiranje koda za različite platforme.
• Jezična proširenja: Stvaranje prilagođenih jezičnih proširenja ili jezika specifičnih za domenu (DSL) transformacijom Python koda u različite prikaze.
• Sigurnosna revizija: Analiza koda radi potencijalno štetnih konstrukcija ili ranjivosti. To se može koristiti za identifikaciju nesigurnih praksi kodiranja.

Primjer: Provođenje stila kodiranja

Recimo da želite osigurati da sva imena funkcija u vašem projektu slijede snake_case konvenciju (npr. my_function umjesto myFunction). Možete koristiti ast modul za provjeru kršenja.

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Function name '{node.name}' does not follow snake_case convention")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Example usage
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("No style violations found")
            

              
                Copy
              
            
          

Ovaj kod definira klasu SnakeCaseChecker koja nasljeđuje ast.NodeVisitor. Metoda visit_FunctionDef provjerava odgovara li ime funkcije regularnom izrazu za snake_case. Ako ne, dodaje poruku o pogrešci na listu errors. Metoda check_code parsira kod, prolazi kroz AST i vraća listu pogrešaka.

Najbolje prakse pri radu s ast modulom

• Razumijevanje strukture AST-a: Prije pokušaja manipulacije AST-om, odvojite vrijeme da razumijete njegovu strukturu pomoću ast.dump(). To će vam pomoći da identificirate čvorove s kojima trebate raditi.
• Korištenje ast.NodeVisitor i ast.NodeTransformer: Ove klase pružaju praktičan način za prolazak i modificiranje AST-a bez potrebe za ručnim kretanjem po stablu.
• Temeljito testiranje: Prilikom modificiranja AST-a, temeljito testirajte svoj kod kako biste osigurali da su promjene ispravne i da ne uvode nikakve pogreške.
• Razmatranje astunparse za generiranje koda: Iako je compile() koristan za izvršavanje modificiranog koda, astunparse pruža način za generiranje čitljivog Python koda iz AST-a.
• Korištenje napomena o tipovima (Type Hints): Napomene o tipovima mogu značajno poboljšati čitljivost i održivost vašeg koda, posebno pri radu sa složenim AST strukturama.
• Dokumentiranje koda: Prilikom stvaranja prilagođenih AST visitora ili transformera, jasno dokumentirajte svoj kod kako biste objasnili svrhu svake metode i promjene koje ona čini na AST-u.

Izazovi i razmatranja

• Složenost: Rad s AST-ovima može biti složen, posebno za veće baze koda. Razumijevanje različitih tipova čvorova i njihovih odnosa može biti izazovno.
• Održavanje: Strukture AST-a mogu se mijenjati između verzija Pythona. Obavezno testirajte svoj kod s različitim verzijama Pythona kako biste osigurali kompatibilnost.
• Performanse: Prolazak i modificiranje velikih AST-ova može biti sporo. Razmislite o optimizaciji koda kako biste poboljšali performanse. Spremanje često pristupanih čvorova u predmemoriju ili korištenje učinkovitijih algoritama može pomoći.
• Rukovanje pogreškama: Elegantno rukujte pogreškama prilikom parsiranja ili manipulacije AST-om. Pružite korisniku informativne poruke o pogreškama.
• Sigurnost: Budite oprezni pri izvršavanju koda generiranog iz AST-a, posebno ako se AST temelji na korisničkom unosu. Sanirajte unos kako biste spriječili napade ubacivanjem koda (code injection).

Zaključak

Pythonov ast modul pruža moćan i fleksibilan način za interakciju s apstraktnim sintaksnim stablom Python koda. Razumijevanjem strukture AST-a i korištenjem klasa ast.NodeVisitor i ast.NodeTransformer, možete programski analizirati, mijenjati i generirati Python kod. To otvara vrata širokom rasponu primjena, od alata za analizu koda do automatiziranog refaktoriranja, pa čak i prilagođenih jezičnih proširenja. Iako rad s AST-ovima može biti složen, prednosti mogućnosti programske manipulacije kodom su značajne. Iskoristite snagu ast modula kako biste otključali nove mogućnosti u svojim Python projektima.