Scorri per mostrare il menu

In questo capitolo, esplorerai come sfruttare la potenza delle espressioni regolari in scenari avanzati di Python, inclusi l'utilizzo di funzioni annidate, inversione di stringhe e unione di stringhe. Queste tecniche permettono di manipolare e analizzare dati testuali in modo più efficiente e flessibile, aprendo nuove possibilità per l'automazione, la pulizia dei dati e il riconoscimento di pattern complessi.

Imparerai come le espressioni regolari possono:

Potenziare la funzionalità delle funzioni annidate per estrarre o trasformare dati;
Semplificare il processo di inversione delle stringhe in base a pattern specifici;
Consentire l'unione dinamica e personalizzabile di stringhe utilizzando regole basate su pattern.

La padronanza di queste applicazioni ti aiuterà a scrivere codice Python più conciso, leggibile e potente per una vasta gamma di attività reali, dalla gestione di file di log alla costruzione di pipeline di dati.

Utilizzo delle espressioni regolari all'interno di funzioni annidate

Quando utilizzi le espressioni regolari in Python, spesso definisci pattern e logica di ricerca all'interno di funzioni. A volte, potresti aver bisogno di usare espressioni regolari all'interno di funzioni annidate — funzioni definite all'interno di altre funzioni. Comprendere come funzionano scope e accesso alle variabili in questo contesto aiuta a scrivere codice chiaro e riutilizzabile.

Definizione: Funzioni annidate

Una funzione annidata è una funzione definita all'interno di un'altra funzione. La funzione interna può accedere alle variabili della funzione esterna grazie allo scope lessicale di Python (detto anche closure).

Scope ed espressioni regolari

La funzione interna può utilizzare pattern di espressioni regolari e oggetti compilati definiti nella funzione esterna;
È possibile passare corrispondenze o risultati di espressioni regolari dalla funzione esterna a quella interna per ulteriori elaborazioni;
Compilare un pattern regex nella funzione esterna migliora l'efficienza se la funzione interna utilizza lo stesso pattern più volte.

Esempio pratico: Filtrare ed estrarre dati

Supponiamo di voler elaborare una lista di indirizzi email, filtrando quelli validi ed estraendo la parte relativa al nome utente. È possibile utilizzare una funzione annidata per incapsulare la logica di estrazione:

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Punti chiave:

Il pattern viene compilato una sola volta nella funzione esterna e riutilizzato nella funzione annidata extract_username;
La funzione interna accede al pattern regex dallo scope esterno;
Questa struttura mantiene il codice organizzato ed efficiente, soprattutto nella gestione di attività complesse di parsing dei dati.

L'utilizzo delle espressioni regolari all'interno di funzioni annidate è una tecnica potente per costruire codice modulare e manutenibile che elabora dati testuali in modo efficiente.


              123456789101112131415
            
import re

def find_and_replace(text, pattern, replacement):
    def inner_replace():
        # Use re.sub to replace all matches of the pattern in the text
        result = re.sub(pattern, replacement, text)
        return result
    return inner_replace()

sample_text = "The rain in Spain stays mainly in the plain."
pattern = r"ain"
replacement = "###"

result = find_and_replace(sample_text, pattern, replacement)
print(result)

Inversione di stringhe in Python

Invertire una stringa è un'operazione comune che può essere necessaria durante l'elaborazione di dati testuali. Python offre un modo semplice per invertire le stringhe utilizzando lo slicing, e puoi anche combinare questa tecnica con le espressioni regolari per manipolazioni avanzate del testo.

Come invertire una stringa

È possibile invertire qualsiasi stringa in Python utilizzando lo slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Spiegazione:

text[::-1] crea una nuova stringa prendendo tutti i caratteri di text ma in ordine inverso.

Scenari di utilizzo

L'inversione delle stringhe è utile in diverse situazioni:

Verifica se una stringa è un palindromo;
Offuscamento di informazioni sensibili mostrandole al contrario;
Creazione di effetti di testo particolari per interfacce utente.

Combinare regex con l'inversione di stringhe

È possibile utilizzare le espressioni regolari per trovare pattern specifici in una stringa e poi invertire solo quelle parti. Questo è utile quando si desidera invertire solo alcune parole o pattern, e non l'intera stringa.

Esempio: invertire tutte le parole che iniziano con una lettera maiuscola

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Come funziona:

Il pattern regex \b[A-Z][a-zA-Z]*\b individua le parole che iniziano con una lettera maiuscola.
La funzione reverse_match inverte ogni parola trovata.
re.sub sostituisce ogni corrispondenza con la sua versione invertita.

Combinare espressioni regolari e inversione di stringhe permette di eseguire trasformazioni complesse del testo in modo conciso e flessibile.


              123456789101112131415161718
            
import re

# Original string
txt = "Python 3.12 is powerful!"

# Reverse the string
reversed_txt = txt[::-1]
print("Reversed string:", reversed_txt)

# Regex pattern to find all sequences of digits in the reversed string
pattern = r"\\d+"
digits = re.findall(pattern, reversed_txt)
print("Digits found in reversed string:", digits)

# Regex pattern to find all words in the reversed string
word_pattern = r"[A-Za-z]+"
words = re.findall(word_pattern, reversed_txt)
print("Words found in reversed string:", words)

Unire stringhe in Python

Unire stringhe è un'operazione comune quando si lavora con dati testuali. Spesso è necessario combinare più stringhe in una sola, ad esempio unendo parole, righe o risultati di una ricerca tramite espressioni regolari.

Utilizzo di `join()` per combinare una lista di stringhe

Il metodo str.join() è lo standard per concatenare una lista di stringhe in un'unica stringa. Si specifica una stringa separatrice e si richiama join() su di essa con la lista da combinare.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Punti chiave su join():

Il separatore (come uno spazio, una virgola o un carattere di nuova riga) viene posto prima di .join();
L'argomento di join() deve essere un iterabile di stringhe (come una lista o una tupla);
Il risultato è una singola stringa contenente tutti gli elementi, separati dal separatore scelto.

Unire i risultati delle regex in una singola stringa

Quando si utilizza la funzione re.findall(), questa restituisce una lista di tutte le corrispondenze non sovrapposte. È possibile usare join() per combinare queste corrispondenze in un'unica stringa.

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Casi d'uso comuni:

Combinare tutte le corrispondenze delle regex in una stringa separata da virgole;
Unire righe di testo in un unico blocco;
Creare righe CSV da liste di valori.

Unire stringhe in modo efficiente aiuta a elaborare, visualizzare e memorizzare dati testuali in modo leggibile e strutturato.


              12345678910111213141516171819202122
            
import re

# Joining a list of strings with a space
words = ["Python", "Regular", "Expressions"]
joined_words = " ".join(words)
print("Joined list:", joined_words)

# Using regex to extract all words starting with a capital letter
text = "Alice and Bob are learning Regular Expressions in Python."
pattern = r"\\b[A-Z][a-z]+\\b"
capitalized_words = re.findall(pattern, text)
print("Capitalized words:", capitalized_words)

# Joining regex match groups with a hyphen
joined_matches = "-".join(capitalized_words)
print("Hyphen-joined matches:", joined_matches)

# Using regex groups and joining them
match = re.match(r"(\\w+) (\\w+)", "Hello World")
if match:
    groups_joined = ", ".join(match.groups())
    print("Groups joined:", groups_joined)

1. Che cos'è una funzione annidata in Python e come può essere utile quando si lavora con le espressioni regolari

2. Quale metodo Python viene comunemente utilizzato per unire una lista di stringhe in un'unica stringa e come può essere combinato con i risultati delle regex

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 6

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Funzioni Annidate, Inversione e Unione di Stringhe

Imparerai come le espressioni regolari possono:

Potenziare la funzionalità delle funzioni annidate per estrarre o trasformare dati;
Semplificare il processo di inversione delle stringhe in base a pattern specifici;
Consentire l'unione dinamica e personalizzabile di stringhe utilizzando regole basate su pattern.

Utilizzo delle espressioni regolari all'interno di funzioni annidate

Definizione: Funzioni annidate

Scope ed espressioni regolari

La funzione interna può utilizzare pattern di espressioni regolari e oggetti compilati definiti nella funzione esterna;
È possibile passare corrispondenze o risultati di espressioni regolari dalla funzione esterna a quella interna per ulteriori elaborazioni;
Compilare un pattern regex nella funzione esterna migliora l'efficienza se la funzione interna utilizza lo stesso pattern più volte.

Esempio pratico: Filtrare ed estrarre dati

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Punti chiave:

Il pattern viene compilato una sola volta nella funzione esterna e riutilizzato nella funzione annidata extract_username;
La funzione interna accede al pattern regex dallo scope esterno;
Questa struttura mantiene il codice organizzato ed efficiente, soprattutto nella gestione di attività complesse di parsing dei dati.

L'utilizzo delle espressioni regolari all'interno di funzioni annidate è una tecnica potente per costruire codice modulare e manutenibile che elabora dati testuali in modo efficiente.


              123456789101112131415
            
import re

def find_and_replace(text, pattern, replacement):
    def inner_replace():
        # Use re.sub to replace all matches of the pattern in the text
        result = re.sub(pattern, replacement, text)
        return result
    return inner_replace()

sample_text = "The rain in Spain stays mainly in the plain."
pattern = r"ain"
replacement = "###"

result = find_and_replace(sample_text, pattern, replacement)
print(result)

Inversione di stringhe in Python

Come invertire una stringa

È possibile invertire qualsiasi stringa in Python utilizzando lo slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Spiegazione:

text[::-1] crea una nuova stringa prendendo tutti i caratteri di text ma in ordine inverso.

Scenari di utilizzo

L'inversione delle stringhe è utile in diverse situazioni:

Verifica se una stringa è un palindromo;
Offuscamento di informazioni sensibili mostrandole al contrario;
Creazione di effetti di testo particolari per interfacce utente.

Combinare regex con l'inversione di stringhe

Esempio: invertire tutte le parole che iniziano con una lettera maiuscola

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Come funziona:

Il pattern regex \b[A-Z][a-zA-Z]*\b individua le parole che iniziano con una lettera maiuscola.
La funzione reverse_match inverte ogni parola trovata.
re.sub sostituisce ogni corrispondenza con la sua versione invertita.

Combinare espressioni regolari e inversione di stringhe permette di eseguire trasformazioni complesse del testo in modo conciso e flessibile.


              123456789101112131415161718
            
import re

# Original string
txt = "Python 3.12 is powerful!"

# Reverse the string
reversed_txt = txt[::-1]
print("Reversed string:", reversed_txt)

# Regex pattern to find all sequences of digits in the reversed string
pattern = r"\\d+"
digits = re.findall(pattern, reversed_txt)
print("Digits found in reversed string:", digits)

# Regex pattern to find all words in the reversed string
word_pattern = r"[A-Za-z]+"
words = re.findall(word_pattern, reversed_txt)
print("Words found in reversed string:", words)

Unire stringhe in Python

Utilizzo di `join()` per combinare una lista di stringhe

Il metodo str.join() è lo standard per concatenare una lista di stringhe in un'unica stringa. Si specifica una stringa separatrice e si richiama join() su di essa con la lista da combinare.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Punti chiave su join():

Il separatore (come uno spazio, una virgola o un carattere di nuova riga) viene posto prima di .join();
L'argomento di join() deve essere un iterabile di stringhe (come una lista o una tupla);
Il risultato è una singola stringa contenente tutti gli elementi, separati dal separatore scelto.

Unire i risultati delle regex in una singola stringa

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Casi d'uso comuni:

Combinare tutte le corrispondenze delle regex in una stringa separata da virgole;
Unire righe di testo in un unico blocco;
Creare righe CSV da liste di valori.

Unire stringhe in modo efficiente aiuta a elaborare, visualizzare e memorizzare dati testuali in modo leggibile e strutturato.


              12345678910111213141516171819202122
            
import re

# Joining a list of strings with a space
words = ["Python", "Regular", "Expressions"]
joined_words = " ".join(words)
print("Joined list:", joined_words)

# Using regex to extract all words starting with a capital letter
text = "Alice and Bob are learning Regular Expressions in Python."
pattern = r"\\b[A-Z][a-z]+\\b"
capitalized_words = re.findall(pattern, text)
print("Capitalized words:", capitalized_words)

# Joining regex match groups with a hyphen
joined_matches = "-".join(capitalized_words)
print("Hyphen-joined matches:", joined_matches)

# Using regex groups and joining them
match = re.match(r"(\\w+) (\\w+)", "Hello World")
if match:
    groups_joined = ", ".join(match.groups())
    print("Groups joined:", groups_joined)

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 6

Funzioni Annidate, Inversione e Unione di Stringhe

Utilizzo delle espressioni regolari all'interno di funzioni annidate

Definizione: Funzioni annidate

Scope ed espressioni regolari

Esempio pratico: Filtrare ed estrarre dati

Inversione di stringhe in Python

Come invertire una stringa

Scenari di utilizzo

Combinare regex con l'inversione di stringhe

Esempio: invertire tutte le parole che iniziano con una lettera maiuscola

Unire stringhe in Python

Utilizzo di join() per combinare una lista di stringhe

Unire i risultati delle regex in una singola stringa

1. Che cos'è una funzione annidata in Python e come può essere utile quando si lavora con le espressioni regolari

2. Quale metodo Python viene comunemente utilizzato per unire una lista di stringhe in un'unica stringa e come può essere combinato con i risultati delle regex

Funzioni Annidate, Inversione e Unione di Stringhe

Utilizzo delle espressioni regolari all'interno di funzioni annidate

Definizione: Funzioni annidate

Scope ed espressioni regolari

Esempio pratico: Filtrare ed estrarre dati

Inversione di stringhe in Python

Come invertire una stringa

Scenari di utilizzo

Combinare regex con l'inversione di stringhe

Esempio: invertire tutte le parole che iniziano con una lettera maiuscola

Unire stringhe in Python

Utilizzo di join() per combinare una lista di stringhe

Unire i risultati delle regex in una singola stringa

Utilizzo di `join()` per combinare una lista di stringhe

Utilizzo di `join()` per combinare una lista di stringhe