Creare un linguaggio di programmazione con Python

In questo articolo vedrai, come utilizzare la libreria NLTK di Python per creare un linguaggio di programmazione, o un interprete di comandi, che possa eseguire determinate azioni in base alla comprensione di frasi di testo immesse dall’utente. Per lo scopo di questo articolo ti parlerò di due librerie utilissime, tramite le quali, potrai realizzare un vero e proprio interprete dei comandi. Cioè, un linguaggio di programmazione tutto tuo.

Introduzione alla libreria NLTK

Natural Language Toolkit (NLTK) è una libreria Python, open-source, che fornisce delle classi per gestire tutte le funzionalità del linguaggio naturale, come l’analisi del testo, la segmentazione del testo, la classificazione dei testi, l’analisi del sentiment, l’analisi sintattica e la lemmatizzazione.

NLTK è utilizzata in molte applicazioni che lavorano con il linguaggio naturale, come i motori di ricerca, i sistemi di traduzione automatica, i chatbot e gli assistenti vocali.

Requisiti

Per creare il nostro interprete di comandi, avremo bisogno delle seguenti librerie Python:

1- nltk

2- speech_recognition

Per installare queste librerie, apri la finestra del prompt dei comandi, o il terminale, e digita il seguente comando e premi il tasto INVIO:

pip install nltk speech_recognition

Definizione dei comandi

La prima cosa che devi fare è, definire, una lista di comandi che il tuo interprete dovrà riconoscere ed eseguire. In questo esempio, consideriamo solo tre semplici comandi: “apri“, “chiudi” e “cerca“. Quindi, apri il tuo editor di testi preferito e inizia a digitare le seguenti istruzioni:

commands = ["apri", "chiudi", "cerca"]

Tokenizzazione del testo

Per comprendere la frase, comprensiva del comando immesso dall’utente, devi prima eseguire la tokenizzazione del testo. Per tokenizzazione di un testo si intende quel processo che porta ad estrapolare tutte le parole, dal testo immesso, per una loro successiva interpretazione ed esecuzione dell’azione ad esso associata.

Nella libreria NLTK esiste una classe appropriata che utilizzeremo. La classe in questione è “word_tokenize“. Sfruttando questa classe potremo suddividere la frase in parole. Cioè i Token. In questo caso, la funzione tokenize, restituisce un array di parole, o keywords del tuo interprete, contenute nel parametro text passato alla funzione stessa. Adesso, copia e incolla il codice di seguito riportato, subito dopo l’istruzione precedentemente inserita.

import nltk

def tokenize(text):
    return nltk.word_tokenize(text)

Comprensione della frase di comando

Ora, definiamo la funzione, in questo caso understand, che eseguirà la comprensione della frase di comando, immessa dall’utente:

def understand(text):
    words = tokenize(text)
    for command in commands:
        if command in words:
            return words
    return None

Questa funzione prende in input una frase di testo e restituisce il comando corrispondente se presente nella frase di testo dell’utente. Se la frase di testo non contiene un comando supportato, cioè presente nell’array commands, la funzione restituirà “None“. Ora, copia e incolla questo codice, all’interno del tuo script Python dove, mano-mano, il tuo interprete prenderà vita.

---

Leggi anche: Come creare un linguaggio di programmazione con Flex e Bison

---

Esecuzione dell’azione associata al comando

Una volta che compreso, e rilevato il comando dell’utente, dobbiamo eseguire l’azione corrispondente. In questo esempio, eseguiremo l’azione su un file di testo. Per mettere in atto tutto questo è stata definita la funzione execute.

def execute(command):
    if "apri" in command:
        # Apri il file
        pass
    elif "chiudi" in command:
        # Chiudi il file
        pass
    elif "cerca" in command:
        # Cerca nel file
        pass

In questa funzione, controlliamo il comando passato e eseguiamo l’azione corrispondente. In questo esempio, le azioni sono solo delle simulazioni e non vengono eseguite effettivamente operazioni sui file. Per questo motivo è stato utilizzato il comando pass di Python che non esegue alcuna azione. Pertanto la definizione dell’azione, da associare ad ogni comando, è delegata alle necessità dello sviluppatore. Pertanto, solo a scopo di prova, aggiungi anche questo codice al tuo interprete.

Interazione con l’utente

Infine, definirai la funzione principale del tuo interprete di comandi. Questa funzione inizia un ciclo infinito che ascolta i comandi dell’utente e li esegue. Per questo motivo è stata utilizzata la libreria speech_recognition. Questa libreria, attraverso il suo metodo Recognizer, resta in ascolto di un comando vocale impartito dall’utente.

import speech_recognition as sr

def main():
    r = sr.Recognizer()
    with sr.Microphone() as source:
        print("Parla adesso...")
        while True:
            audio = r.listen(source)
            try:
                text = r.recognize_google(audio, language='it-IT')
                command = understand(text)
                if command is not None:
                    execute(command)
                else:
                    print("Comando non supportato.")
            except sr.UnknownValueError:
                print("Non ho capito. Ripeti.")
            except sr.RequestError as e:
                print("Errore nella connessione a Internet.")

Il codice inserito all’interno della funzione main, non lascia dubbi. Infatti, la libreria “speech_recognition” intercetterà l’audio, proveniente dal microfono del computer dell’utente e lo convertirà in testo utilizzando il servizio di riconoscimento vocale di Google. Successivamente, la funzione richiamerà le funzioni “understand” ed “execute” per comprendere e eseguire il comando correttamente.

Conclusioni

In questo articolo, hai visto come creare un interprete di comandi utilizzando la libreria NLTK di Python. Ora, potrai modificare il codice proposto in questa guida, lasciando processare all’interprete, i comandi contenuti all’interno di un file di testo. Quindi, se crei il file “script.commands“, con questo contenuto

le istruzioni della funzione main dovrebbero cambiare come di seguito suggerito:

def main():
    with open("script.commands", "r") as file:
    for text in file:
        try:
            command = understand(text)
            if command is not None:
                execute(command)
            else:
                print("Comando non supportato.")
        except:
            print("Syntax error...!")

Se poi hai la necessità di prelevare il contenuto di un eventuale parametro, ad esempio, un eventuale nome di file da associare al comando apri, puoi trasformare il contenuto della funzione execute, e del file script.commands, in questo modo:

def execute(command):
    if "apri" in command:
        # Apri il file
        _parameter = command[-1]
        pass
    elif "chiudi" in command:
        # Chiudi il file
        _parameter = command[-1]
        pass
    elif "cerca" in command:
        # Cerca nel file
        pass

---

Leggi anche: Navigare anonimamente in Internet con una VPN gratuita

---

Domande frequenti