Testo pro

schema_cifre(minimo = 1, massimo = nulla)#

Uno schema che trova una sequenza di cifre (0-9).

stampa(trova_tutti_schema("ho 3 gatti e 12 pesci", schema_cifre()))stampa(schema_cifre(5, 5))

["3", "12"]
schema (5 cifre)

schema_lettere(minimo = 1, massimo = nulla)#

Uno schema che trova una sequenza di lettere (anche accentate).

Non prende cifre né spazi.

stampa(trova_tutti_schema("abc123def", schema_lettere()))

["abc", "def"]

schema_parole()#

Uno schema che trova una parola (lettere, con l'apostrofo come in "dell'arte").

Per prendere tutte le parole di un testo: trova_tutti_schema(testo, schema_parole()).

schema_spazi(minimo = 1, massimo = nulla)#

Uno schema che trova spazi (anche tabulazioni e a-capo).

Utile per dividere o normalizzare: sostituisci_schema("a b\tc", schema_spazi(), " ") è "a b c".

schema_qualsiasi(minimo = 1, massimo = nulla)#

Uno schema che trova un carattere qualunque (tranne l'a-capo).

schema_esatto("(").poi(schema_qualsiasi()).poi(schema_esatto(")"))

schema_esatto(testo)#

Uno schema che trova esattamente quel testo, senza sintassi speciale.

Comodo per cercare simboli come . ( + senza doverli "proteggere".

stampa(corrisponde_schema("3.14", schema_cifre().poi(schema_esatto(".")).poi(schema_cifre())))

vero

schema_uno_di(elenco)#

Uno schema che trova uno qualunque dei testi dell'elenco.

stampa(trova_tutti_schema("mela, pera, mela", schema_uno_di(["mela", "pera"])))

["mela", "pera", "mela"]

schema_email()#

Uno schema che trova un indirizzo email (nome@dominio).

stampa(trova_tutti_schema("scrivi a ada@esempio.it", schema_email()))

["ada@esempio.it"]

schema_tra(prima, dopo)#

Uno schema che trova il testo tra due segni, e lo mette in un gruppo.

Prende la quantità più corta possibile. Con gruppi_schema ottieni il contenuto in mezzo.

stampa(gruppi_schema("<b>ciao</b>", schema_tra("<b>", "</b>")))

["ciao"]

spiega_schema(schema)#

La spiegazione in italiano di che cosa cerca lo schema.

Equivale a schema.spiegazione.

stampa(spiega_schema(schema_cifre(5, 5)))

5 cifre

trova_schema(testo, schema, ignora_maiuscole = falso)#

Il primo pezzo che segue lo schema, o nulla.

stampa(trova_schema("Totale: 42 euro", schema_cifre()))

42

trova_tutti_schema(testo, schema, ignora_maiuscole = falso)#

La lista di tutti i pezzi che seguono lo schema.

stampa(trova_tutti_schema("tel 333 e 051", schema_cifre()))

["333", "051"]

gruppi_schema(testo, schema, ignora_maiuscole = falso)#

I gruppi del primo pezzo trovato, o nulla.

Con gruppi dal nome (.gruppo("nome")) restituisce un dizionario, altrimenti la lista dei gruppi.

stampa(gruppi_schema("<b>ciao</b>", schema_tra("<b>", "</b>")))

["ciao"]

corrisponde_schema(testo, schema, ignora_maiuscole = falso)#

vero se TUTTO il testo segue lo schema.

Serve a controllare quello che scrive l'utente.

stampa(corrisponde_schema("12345", schema_cifre(5, 5)))stampa(corrisponde_schema("12a45", schema_cifre()))

vero
falso

dividi_per_schema(testo, schema, ignora_maiuscole = falso)#

Divide il testo dove compare lo schema.

stampa(dividi_per_schema("uno, due;tre", schema_uno_di([", ", ";"])))

["uno", "due", "tre"]

sostituisci_schema(testo, schema, con, ignora_maiuscole = falso)#

Sostituisce ogni pezzo che segue lo schema.

con è un testo (messo così com'è, senza sorprese) oppure una funzione che riceve il pezzo trovato e restituisce il testo da mettere al suo posto.

stampa(sostituisci_schema("a  b   c", schema_spazi(), " "))

a b c

variabile testo = "Leo parla italiano"   # valore di provastampa(sostituisci_schema("3 mele", schema_cifre(), funzione (n) restituisci testo(intero(n) * 2) fine))

parole_di(testo)#

La lista delle parole del testo (lettere, con l'apostrofo; senza numeri né segni).

stampa(parole_di("Ciao, mondo! L'alba"))variabile testo = "Leo parla italiano"   # valore di provatrova_tutti_schema(testo, schema_cifre())

["Ciao", "mondo", "L'alba"]

frasi_di(testo)#

La lista delle frasi, divise sui segni . ! ? … (senza spazi inutili).

stampa(frasi_di("Ciao. Come va? Bene!"))

["Ciao.", "Come va?", "Bene!"]

righe_di(testo)#

La lista delle righe del testo (divise agli a-capo, senza l'a-capo).

Vanno bene gli a-capo di Windows, Mac e Unix.

stampa(righe_di("a\nb\nc"))

["a", "b", "c"]

solo_lettere_numeri(testo, tieni_spazi = falso)#

Toglie dal testo tutto tranne lettere e cifre.

Con tieni_spazi = vero lascia anche gli spazi.

stampa(solo_lettere_numeri("C-3PO, va bene!"))

C3POvabene

a_titolo(testo)#

Mette in maiuscolo la prima lettera di ogni parola e in minuscolo il resto.

A differenza di altri modi gestisce bene l'apostrofo e gli accenti.

stampa(a_titolo("l'ISOLA del TESORO"))

L'Isola Del Tesoro

accorcia(testo, n, finale = "…")#

Accorcia il testo a n caratteri al massimo, aggiungendo finale.

Se il testo è già corto resta com'è. Il risultato (segno finale compreso) non supera n caratteri.

variabile tutti = ["mela", "pera", "kiwi"]   # valore di provastampa(accorcia("Buongiorno a tutti", 10))

Buongiorn…

da_ini(testo, converti = vero)#

Legge un testo in formato INI e lo trasforma in un dizionario di sezioni.

Ogni sezione [nome] diventa un dizionario di coppie chiave-valore. Con converti = vero numeri e vero/falso diventano valori veri (non testo).

stampa(da_ini("[gioco]\nvite = 3\naudio = sì"))

{"gioco": {"vite": 3, "audio": vero}}

a_ini(dati)#

Trasforma un dizionario di sezioni in un testo in formato INI.

dati è un dizionario dove ogni valore è a sua volta un dizionario (una sezione).

stampa(a_ini({"gioco": {"vite": 3, "audio": vero}}))

[gioco]
vite = 3
audio = vero

.gruppo(nome = nulla)#

Segna questa parte come gruppo da estrarre con gruppi_schema.

Con un nome il gruppo è richiamabile per nome.

schema_cifre().gruppo("anno")

.oppure(altro)#

Uno schema che cerca questo oppure l'altro.

schema_esatto("sì").oppure(schema_esatto("no"))

.opzionale()#

Lo schema diventa facoltativo (può esserci oppure no).

schema_esatto("+").opzionale().poi(schema_cifre())

.poi(altro)#

Uno schema che cerca prima questo e subito dopo l'altro.

altro può essere un altro schema o un testo (cercato così com'è).

schema_cifre().poi(schema_esatto("€"))

.ripetuto(minimo = 1, massimo = nulla)#

Lo stesso schema (attaccato) ripetuto più volte.

Con massimo = nulla significa "senza limite". I pezzi sono attaccati, senza niente in mezzo: schema_cifre(1, 1).poi(schema_esatto("-")).ripetuto(3) trova "1-2-3-".