Python Ast -moduuli: Abstraktin syntaksipuun käsittelyn salat auki

Pythonin ast-moduuli tarjoaa tehokkaan tavan olla vuorovaikutuksessa Python-koodin abstraktin syntaksipuun (AST) kanssa. AST on puurakenne, joka esittää lähdekoodin syntaktisen rakenteen, mikä mahdollistaa Python-koodin ohjelmallisen analysoinnin, muokkaamisen ja jopa generoinnin. Tämä avaa oven useille sovelluksille, mukaan lukien koodianalyysityökalut, automatisoitu uudelleenkirjoitus, staattinen analyysi ja jopa mukautetut kielilaajennukset. Tämä artikkeli opastaa sinut ast-moduulin perusteisiin tarjoten käytännön esimerkkejä ja näkemyksiä sen ominaisuuksista.

Mikä on abstrakti syntaksipuu (AST)?

Ennen kuin sukellamme ast-moduuliin, ymmärretään, mikä abstrakti syntaksipuu on. Kun Python-tulkki suorittaa koodiasi, ensimmäinen vaihe on jäsentää koodi AST:ksi. Tämä puurakenne edustaa koodin syntaktisia elementtejä, kuten funktioita, luokkia, silmukoita, lausekkeita ja operaattoreita, sekä niiden välisiä suhteita. AST hylkää epäolennaiset yksityiskohdat, kuten välilyönnit ja kommentit, ja keskittyy olennaiseen rakenteelliseen tietoon. Edustamalla koodia tällä tavalla ohjelmien on mahdollista analysoida ja käsitellä itse koodia, mikä on erittäin hyödyllistä monissa tilanteissa.

Aloittaminen ast-moduulin kanssa

ast-moduuli on osa Pythonin standardikirjastoa, joten sinun ei tarvitse asentaa ylimääräisiä paketteja. Tuo se yksinkertaisesti käyttöön aloittaaksesi sen käytön:

            import ast
            

              
                Copy
              
            
          

ast-moduulin ydinfunktio on ast.parse(), joka ottaa syötteenä Python-koodin merkkijonon ja palauttaa AST-objektin.

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

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

              
                Copy
              
            
          

Tämä tulostaa jotain seuraavaa: <_ast.Module object at 0x...>. Vaikka tämä tuloste ei ole erityisen informatiivinen, se osoittaa, että koodi jäsennettiin onnistuneesti AST:ksi. ast_tree-objekti sisältää nyt koko jäsennellyn koodin rakenteen.

AST:n tutkiminen

AST:n rakenteen ymmärtämiseksi voimme käyttää ast.dump()-funktiota. Tämä funktio käy läpi puun rekursiivisesti ja tulostaa yksityiskohtaisen esityksen jokaisesta solmusta.

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

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

              
                Copy
              
            
          

Tuloste on:

            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
              
            
          

Tämä tuloste näyttää koodin hierarkkisen rakenteen. Pilkotaan se osiin:

• Module: Juurisolmu, joka edustaa koko moduulia.
• body: Luettelo moduulin sisällä olevista lauseista.
• FunctionDef: Edustaa funktion määrittelyä. Sen attribuutteihin kuuluvat:
• name: Funktion nimi ('add').
• args: Funktion argumentit.
• arguments: Sisältää tietoja funktion argumenteista.
• arg: Edustaa yhtä argumenttia (esim. 'x', 'y').
• body: Funktion runko (luettelo lauseista).
• Return: Edustaa palautuslausetta.
• value: Palautettava arvo.
• BinOp: Edustaa binäärioperaatiota (esim. x + y).
• left: Vasen operandi (esim. 'x').
• op: Operaattori (esim. 'Add').
• right: Oikea operandi (esim. 'y').

AST:n läpikäynti

ast-moduuli tarjoaa ast.NodeVisitor-luokan AST:n läpikäyntiin. Aliluokittamalla ast.NodeVisitor ja ohittamalla sen menetelmät voit käsitellä tiettyjä solmutyyppejä, kun niitä kohdataan läpikäynnin aikana. Tämä on hyödyllistä koodin rakenteen analysoinnissa, tiettyjen mallien tunnistamisessa tai tietojen poiminnassa.

            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
              
            
          

Esimerkki: Kaikkien muuttuja-arvojen löytäminen

            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
              
            
          

AST:n muokkaaminen

ast-moduuli mahdollistaa myös AST:n muokkaamisen. Voit muuttaa olemassa olevia solmuja, lisätä uusia solmuja tai poistaa solmuja kokonaan. AST:n muokkaamiseksi käytät luokkaa ast.NodeTransformer. Samoin kuin ast.NodeVisitor, aliluokitat luokan ast.NodeTransformer ja ohitat sen menetelmät muokataksesi tiettyjä solmutyyppejä. Keskeinen ero on, että ast.NodeTransformer-menetelmien tulisi palauttaa muokattu solmu (tai uusi solmu sen korvaamiseksi). Jos menetelmä palauttaa None, solmu poistetaan AST:stä.

AST:n muokkaamisen jälkeen sinun on käännettävä se takaisin suoritettavaksi Python-koodiksi compile()-funktion avulla.

            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
              
            
          

Funktio compile() ottaa muokatun AST:n, tiedostonimen (<string> tässä tapauksessa, mikä osoittaa, että koodi tulee merkkijonosta) ja suoritustilan ('exec' koodilohkon suorittamiseen). Se palauttaa koodiobjektin, joka voidaan suorittaa exec()-funktion avulla.

Esimerkki: Muuttujan nimen korvaaminen

            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
              
            
          

Koodin luominen AST:stä

Vaikka compile() mahdollistaa koodin suorittamisen AST:stä, se ei tarjoa tapaa saada koodia merkkijonona. Python-koodin luomiseksi AST:stä voit käyttää astunparse-kirjastoa. Tämä kirjasto ei ole osa standardikirjastoa, joten sinun on asennettava se ensin:

            pip install astunparse
            

              
                Copy
              
            
          

Sitten voit käyttää funktiota astunparse.unparse() luodaksesi koodin AST:stä.

            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
              
            
          

Tuloste on:

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

            

              
                Copy
              
            
          

Huomaa: Sulkeet (x + y) ympärillä on lisätty astunparse-ohjelmalla oikean operaattoriprioriteetin varmistamiseksi. Nämä sulkeet eivät välttämättä ole ehdottoman välttämättömiä, mutta ne takaavat koodin oikeellisuuden.

Esimerkki: Yksinkertaisen luokan luominen

            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
              
            
          

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

Tämä osoittaa, kuinka AST rakennetaan tyhjästä ja luodaan sitten koodia siitä. Tämä lähestymistapa on tehokas koodin luontityökaluille ja metaprogrammoinnille.

ast-moduulin käytännön sovellukset

ast-moduulilla on lukuisia käytännön sovelluksia, mukaan lukien:

• Koodianalyysi: Koodin analysointi tyylirikkomusten, tietoturva-aukkojen tai suorituskyvyn pullonkaulojen varalta. Voit esimerkiksi kirjoittaa työkalun, joka valvoo koodausstandardeja suuressa projektissa.
• Automatisoitu uudelleenkirjoitus: Tehtävien automatisointi, kuten muuttujien nimeäminen uudelleen, menetelmien poimiminen tai koodin muuntaminen käyttämään uudempia kieliohjelmia. Työkalut, kuten `rope`, hyödyntävät AST:itä tehokkaita uudelleenkirjoitusominaisuuksia varten.
• Staattinen analyysi: Mahdollisten virheiden tai vikojen tunnistaminen koodissa suorittamatta sitä. Työkalut, kuten `pylint` ja `flake8`, käyttävät AST-analyysiä ongelmien havaitsemiseen.
• Koodin luominen: Koodin automaattinen luominen mallien tai määritysten perusteella. Tämä on hyödyllistä toistuvan koodin luomisessa tai koodin luomisessa eri alustoille.
• Kielilaajennukset: Mukautettujen kielilaajennusten tai toimialakohtaisten kielten (DSL) luominen muuntamalla Python-koodi erilaisiksi esityksiksi.
• Tietoturvatarkastus: Koodin analysointi mahdollisesti haitallisten rakenteiden tai haavoittuvuuksien varalta. Tätä voidaan käyttää epävarmallisten koodauskäytäntöjen tunnistamiseen.

Esimerkki: Koodausstandardien valvonta

Oletetaan, että haluat varmistaa, että kaikki projektisi funktion nimet noudattavat snake_case-käytäntöä (esim. my_function myFunction sijaan). Voit käyttää ast-moduulia rikkomusten tarkistamiseen.

            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
              
            
          

Parhaat käytännöt ast-moduulin kanssa työskennellessä

• Ymmärrä AST:n rakenne: Ennen kuin yrität käsitellä AST:tä, ota aikaa sen rakenteen ymmärtämiseen ast.dump()-ohjelmalla. Tämä auttaa sinua tunnistamaan solmut, joiden kanssa sinun on työskenneltävä.
• Käytä ast.NodeVisitor ja ast.NodeTransformer: Nämä luokat tarjoavat kätevän tavan käydä läpi ja muokata AST:tä ilman, että sinun tarvitsee navigoida puussa manuaalisesti.
• Testaa perusteellisesti: Kun muokkaat AST:tä, testaa koodisi perusteellisesti varmistaaksesi, että muutokset ovat oikein eivätkä aiheuta virheitä.
• Harkitse astunparse-ohjelmaa koodin luomiseen: Vaikka compile() on hyödyllinen muokatun koodin suorittamiseen, astunparse tarjoaa tavan luoda luettavaa Python-koodia AST:stä.
• Käytä tyyppivihjeitä: Tyyppivihjeet voivat parantaa huomattavasti koodin luettavuutta ja ylläpidettävyyttä, etenkin kun työskennellään monimutkaisten AST-rakenteiden kanssa.
• Dokumentoi koodisi: Kun luot mukautettuja AST-vierailijoita tai muuntajia, dokumentoi koodisi selkeästi selittääksesi kunkin menetelmän tarkoituksen ja AST:hen tekemät muutokset.

Haasteet ja huomioitavat asiat

• Monimutkaisuus: AST:iden kanssa työskentely voi olla monimutkaista, erityisesti suuremmissa koodipohjissa. Eri solmutyyppien ja niiden välisten suhteiden ymmärtäminen voi olla haastavaa.
• Ylläpito: AST-rakenteet voivat muuttua Python-versioiden välillä. Varmista, että testaat koodisi eri Python-versioilla yhteensopivuuden varmistamiseksi.
• Suorituskyky: Suurten AST:iden läpikäynti ja muokkaaminen voi olla hidasta. Harkitse koodisi optimointia suorituskyvyn parantamiseksi. Usein käytettyjen solmujen välimuistaminen tai tehokkaampien algoritmien käyttäminen voi auttaa.
• Virheiden käsittely: Käsittele virheet sulavasti, kun jäsennetään tai käsitellään AST:tä. Anna käyttäjälle informatiivisia virheilmoituksia.
• Tietoturva: Ole varovainen, kun suoritat AST:stä luotua koodia, varsinkin jos AST perustuu käyttäjän syötteeseen. Puhdista syöte koodin injektiohyökkäysten estämiseksi.

Johtopäätös

Pythonin ast-moduuli tarjoaa tehokkaan ja joustavan tavan olla vuorovaikutuksessa Python-koodin abstraktin syntaksipuun kanssa. Ymmärtämällä AST-rakenteen ja käyttämällä luokkia ast.NodeVisitor ja ast.NodeTransformer voit analysoida, muokata ja luoda Python-koodia ohjelmallisesti. Tämä avaa oven monille sovelluksille, koodianalyysityökaluista automatisoituun uudelleenkirjoitukseen ja jopa mukautettuihin kielilaajennuksiin. Vaikka AST:iden kanssa työskentely voi olla monimutkaista, koodin ohjelmallisen käsittelyn edut ovat merkittävät. Hyödynnä ast-moduulin tehoa avataksesi uusia mahdollisuuksia Python-projekteissasi.