Modelul Interpreter în Python

Ce este

Șablonul Interpretor (Interpreter) evaluează propoziții dintr-un limbaj mic, construind un arbore de obiecte-expresie — fiecare nod știe să se interpreteze singur. Numerele se interpretează ca ele însele; un nod de adunare își interpretează cele două părți și le adună.

Se potrivește pentru limbaje mici: filtre, formule, reguli simple. Limbajele reale merită instrumente reale de parsare.

Exemplu: un calculator mic

Intrarea 3 + 4 - 2 devine un arbore de noduri dataclass Number, Add și Subtract. Un singur apel interpret() pe rădăcină evaluează întreaga expresie.

Fiecare nod se interpretează singur

parse construiește arborele de la stânga la dreapta; interpret() îl parcurge. Pentru a suporta * ar fi nevoie de un singur tip nou de nod — cele existente rămân neatinse.

Scrie un program Python cu șablonul Interpretor: noduri dataclass Number, Add și Subtract, fiecare știind să se interpreteze singur, și o funcție parse care transformă un șir precum "3 + 4 - 2" într-un arbore de expresii, de la stânga la dreapta. Interpretează expresia și afișează ecuația cu rezultatul ei.

> Ieșire: program Python complet

Prompt

Scrie un program Python cu șablonul Interpretor: noduri dataclass Number, Add și Subtract, fiecare știind să se interpreteze singur, și o funcție parse care transformă un șir precum "3 + 4 - 2" într-un arbore de expresii, de la stânga la dreapta. Interpretează expresia și afișează ecuația cu rezultatul ei.

Ieșire: program Python complet

from dataclasses import dataclass

# Fiecare nod știe să se interpreteze singur.
@dataclass
class Number:
  value: int

  def interpret(self) -> int:
    return self.value

@dataclass
class Add:
  left: "Expression"
  right: "Expression"

  def interpret(self) -> int:
    return self.left.interpret() + self.right.interpret()

@dataclass
class Subtract:
  left: "Expression"
  right: "Expression"

  def interpret(self) -> int:
    return self.left.interpret() - self.right.interpret()

# O expresie este oricare dintre cele trei tipuri de noduri.
Expression = Number | Add | Subtract

def parse(source: str) -> Expression:
  parts = source.split()
  expr: Expression = Number(int(parts[0]))

  for i in range(1, len(parts), 2):
    number = Number(int(parts[i + 1]))
    if parts[i] == "+":
      expr = Add(expr, number)
    else:
      expr = Subtract(expr, number)
  return expr

source = "3 + 4 - 2"
print(source, "=", parse(source).interpret())

Când să-l folosești

Folosește-l când utilizatorii sau configurațiile exprimă logică într-un limbaj mic conceput de tine: filtre de căutare, formule de preț, reguli de validare.

Evită-l când „limbajul” are trei opțiuni fixe (folosește un simplu if/elif) — sau când este un limbaj real (folosește un generator de parsere sau un motor existent).

Avantaje și dezavantaje

Avantaje: gramatica se mapează unu-la-unu pe tipuri mici; operațiile noi sunt tipuri noi de noduri; arborii de expresii pot fi construiți, verificați și refolosiți.

Dezavantaje: devine dificil pe măsură ce gramatica crește; parsarea în sine tot trebuie scrisă; performanța este modestă comparativ cu logica compilată.