Il miglior modo per imparare a programmare con Python velocemente è fare tanta pratica.
In questa pagina troverai esercizi svolti di programmazione Python su funzioni, stringhe, liste, calcoli matematici, algoritmi ricorsivi e moduli. Volendo puoi anche cliccare sul tasto "Mostra Soluzione" per vedere una delle possibile soluzioni.
Attenzione! Questi esercizi sono pensati e realizzati con il solo obbiettivo di permetterti di concentrarti sulle basi del linguaggio: queste sono infatti fondamentali per poter poi imparare qualsiasi strumento avanzato, e ti aiuteranno a prendere gran confidenza con i tipi di dato di Python.
Ancora devi imparare a programmare o le basi di Python? Dai uno sguardo ai nostri video corsi!
Buon allenamento, ed Happy Coding!
Esercizio 001: Max tra Due Numeri
Scrivi una funzione che prende due numeri come parametro e manda in print il più grande tra i due. Per quanto Python disponga di una funzione max(), sei invitato a utilizzare le istruzioni If, Elif ed Else per la scrittura dell'algoritmo.
def my_max(a, b):
if a == b:
print("I numeri sono identici")
elif a > b:
print("Il numero più grande tra i due è " + str(a))
else:
print("Il numero più grande tra i due è " + str(b))
Esercizio 002: Max tra Tre Numeri
Scrivi una funzione che prende stavolta tre numeri come parametro e restituisce il più grande tra loro!
def my_max_of_three(a, b, c):
if a >= b and a >= c:
return a
elif b >= a and b >= c:
return b
elif c >= a and c >= b:
return c
Esercizio 003: Il Maggiore tra tutti!
Scrivi un programma che, passata come parametro una lista di interi, fornisce in output il maggiore tra i numeri contenuti nella lista.
def max_in_list(list):
my_max = 0
for num in list:
if num > my_max:
my_max = num
print(f"Il numero più grande della lista passata è {my_max}")
Esercizio 004: Sei una Vocale?
Scrivi una funzione a cui viene passato un carattere come parametro, e che ci dice se il carattere è o meno una vocale.
def cerca_vocali(carattere):
vocali = "aeiou"
if carattere in vocali:
print(f"Il carattere {carattere} è una vocale")
else:
print(f"Il carattere {carattere} non è una vocale")
Esercizio 005: Sommatrice Inarrestabile
Scrivi una funzione "sommatrice" che somma tra loro tutti gli elementi di una lista di numeri.
def sommatrice(lista):
risultato = 0
for numero in lista:
risultato += numero
print("Il risultato della somma è... " + str(risultato))
Esercizio 006: Moltiplicatore Inarrestabile
Scrivi una funzione "moltiplicatrice" che moltiplica tra loro tutti gli elementi di una lista di numeri.
def moltiplicatore(lista):
risultato = 1
for numero in lista:
if numero != 0:
risultato *= numero
print("Il risultato della moltiplicazione tra tutti gli elementi della lista è... " + str(risultato))
Esercizio 007: Reverser
Scrivi una funzione a cui passerai come parametro una stringa, e che manderà in print una versione inversa (al contrario) della stessa stringa (ad esempio "abcd" diventerà "dcba")
# Due possibili soluzioni per questo esercizio
def reverser(stringa):
indice = (len(stringa) -1)
nuova_stringa = ""
while indice >= 0:
nuova_stringa += stringa[indice]
indice -= 1
print(nuova_stringa)
def reverser_pro(stringa):
reverse = stringa[::-1]
print(reverse)
Esercizio 008: Palindromo... o non Palindromo?
Scrivi una funzione a cui viene passata una parola e riconosce se si tratta di un palindromo (parole che si leggono uguali anche al contrario) oppure meno.
def palindrome_check(parola):
indice = (len(parola) -1)
nuova_parola = ""
while indice >= 0:
nuova_parola += parola[indice]
indice -= 1
if nuova_parola == parola:
print(nuova_parola + ": la parola passata è un palindromo!")
else:
print(nuova_parola + ": mi dispiace, la parola inserita non è un palindromo...")
Esercizio 009: Scriviamo la nostra versione di len()
Scrivi una funzione che restituisca la lunghezza di una stringa o lista passata come parametro. In sostanza, seppur presente, provate a scrivere la vostra versione della funzione len()!
def my_len(lst_or_str):
length = 0
for unit in lst_or_str:
length += 1
return length
Esercizio 010: Generatore di Istogrammi
Scrivi una funzione che, data una lista di numeri, fornisce in output un istogramma basato su questi numeri, usando asterischi per disegnarlo.
Data ad esempio la lista [3, 7, 9, 5], la funzione dovrà produrre questa sequenza:
***
*******
*********
*****
def istogramma(lista):
for numero in lista:
print("*" * numero)
Esercizio 011: A ciascuno il suo
Scrivi una funzione che data in ingresso una lista A contenente n parole, restituisca in output una lista B di interi che rappresentano la lunghezza delle parole contenute in A.
# due possibili soluzioni per l'esercizio proposto
def char_counter(lista_a):
lista_b = []
for parola in lista_a:
lista_b.append(len(parola))
return lista_b
def char_counter_pro(lista_a):
return [len(parola) for parola in lista_a]
Esercizio 012: Il Frequenzimetro
Scrivi una funzione a cui passare una stringa come parametro, e che restituisca un dizionario rappresentante la "frequenza di comparsa" di ciscun carattere componente la stringa.
Semplicemente, data una stringa "ababcc", otterremo in risultato {"a": 2, "b": 2, "c": 2}!
def char_freq(str):
mappa = {}
for carattere in str:
if carattere in mappa:
mappa[carattere] += 1
else:
mappa[carattere] = 1
return mappa
Esercizio 013: Solamente per Soci
Scrivi una funzione a cui vengono passati come parametro un elemento e una lista di elementi, e che ti dica in output se l'elemento passato sia presente o meno nella lista.
Qualora l'elemento sia presente nella lista, la funzione dovrà inoltre comunicarci l'indice dell'elemento.
def membro_di(el, lista):
if el in lista:
print(f"Il carattere '{el}' è presente nella lista passata, all'indice {lista.index(el)}!")
else:
print(f"Il carattere '{el}' NON è presente nella lista passata...")
Esercizio 014: Il linguaggio dei furfanti
In Svezia, i bambini giocano spesso utilizzando un linguaggio un po' particolare detto "rövarspråket", che significa "linguaggio dei furfanti": consiste nel raddoppiare ogni consonante di una parola e inserire una "o" nel mezzo. Ad esempio la parola "mangiare" diventa "momanongogiarore".
Scrivi una funzione in grado di tradurre una parola o frase passata tramite input in "rövarspråket".
Dopo aver tradotto una frase, il programma dovrà chiedere all'utente se intende tradurne un'altra, e in caso di risposta positiva, dovrà attendere l'inserimento di una nuova parola da parte dell'utente.
def traduttore():
print("""
Ciao! questo programma traduce un testo passato in "rövarspråket".
Ció significa che raddoppia ogni consonante delle parole e ci mette una "o" in mezzo...
""")
vocali = "aeiou"
# volendo puoi ovviamente aggiungere ulteriori caratteri speciali alla lista...
specials = [" ", ",", ".", "?", "!", '"',"'"]
while True:
testo = input("\nInserisci il testo che desideri tradurre: ")
tradotta = ""
for x in testo:
if x in vocali or x in specials:
tradotta += x
else:
tradotta = tradotta + x + "o" + x
print(f"Ecco a te la traduzione! '{tradotta}'")
if input("\nDesidere tradurre un'altra frase? ") == "no":
break
Esercizio 015: Il Geometra
Scrivi una funzione che, a scelta dell'utente, calcoli l'area di:
un cerchio
un quadrato
un rettangolo
un triangolo
Sentiti libero/a di estendere le potenzialità della funzione quanto meglio credi...
def geometra():
print("""
Benvenuti alla funzione Geometra!
In fase di selezione, a ciascun possibile calcolo corrisponde un valore numerico:
- Area Quadrato: 1
- Area Rettangolo: 2
- Area Triangolo: 3
- Area Cerchio: 4
""")
print('Dunque. Di quale figura geometrica desideri calcolare l\'area?')
scelta = int(input(">>> "))
if scelta == 1:
print("Hai scelto: Area Quadrato")
lato = float(input('Inserisci il valore del lato del quadrato '))
print(f"L'Area del Quadrato, avente lato {lato} è: {lato * lato}")
elif scelta == 2:
print("Hai scelto: Area Rettangolo")
base = float(input('Inserisci il valore della base '))
altezza = float(input('Inserisci il valore dell´altezza '))
print(f"L'Area del Rettangolo, avente base {base} e altezza {altezza} è: {base * altezza}")
elif scelta == 3:
print("Hai scelto: Area Triangolo")
base = float(input('Inserisci il valore della base '))
altezza = float(input('Inserisci il valore dell´altezza '))
print(f"L'Area del Triangolo, avente base {base} e altezza {altezza} è: {(base * altezza) / 2}")
elif scelta == 4:
print("Hai scelto: Area Cerchio")
r = float(input('Inserisci il valore del raggio '))
print(f"L'Area del Cerchio, avente raggio {r} è: {(r * r) * 3.14}")
else:
print ('Nessun calcolo disponibile per la scelta effettuata!')
Esercizio 016: L'Americana
Scrivi una funzione che, dato in ingresso un valore espresso in metri, mandi in print l'equivalente in miglia terrestri, iarde, piedi e pollici.
def americana(metri):
conversions = dict()
conversions["miglia"] = metri / 1609.344
conversions["piedi"] = metri * 3.280840
conversions["pollici"] = metri * 39.37008
conversions["iarde"] = metri * 1.093613
print(f"{metri} metri corrispondono a:")
for key, value in conversions.items():
print(f"{key}: {value}")
Esercizio 017: Il Signore del Tempo
Scrivi una semplice funzione che converta un dato numero di giorni, ore e minuti, passati dall'utente tramite funzione input, in secondi.
def calcola_secondi():
print("Questa funzione converte un dato numero di Giorni, Ore e Minuti in Secondi.")
da_giorni = int(input("Inserisci il numero di giorni: ")) * 24 * 3600
da_ore = int(input("Inserisci il numero di ore: ")) * 3600
da_minuti = int(input("Inserisci il numero di minuti: ")) * 60
totale = da_giorni + da_ore + da_minuti
print(totale)
Esercizio 018: Generatore di Password
Scrivi una funzione generatrice di password.
La funzione deve generare una stringa alfanumerica di 8 caratteri qualora l'utente voglia una password semplice, o di 20 caratteri ascii qualora desideri una password più complicata.
# due possibili soluzioni per l'esercizio esposto
import random
import string
def psw_generator():
print("Il programma permette di scegliere tra due livelli di complessità della password.")
ascii_chars = string.digits + string.ascii_letters + string.punctuation
alphanum_chars = string.digits + string.ascii_letters
if input("Desideri una password Semplice o Complessa? S/C ") == "C":
lunghezza = 20
tipo = ascii_chars
else:
lunghezza = 8
tipo = alphanum_chars
psw = ""
counter = 0
while counter < lunghezza:
char = random.choice(tipo)
psw += char
counter += 1
print(f"La password generata è: {psw}")
###########
import secrets
import string
def psw_generator_pro():
print("Il programma permette di scegliere tra due livelli di complessità della password.")
ascii_chars = string.digits + string.ascii_letters + string.punctuation
alphanum_chars = string.digits + string.ascii_letters
if input("Desideri una password Semplice o Complessa? S/C ") == "C":
lunghezza = 20
tipo = ascii_chars
else:
lunghezza = 8
tipo = alphanum_chars
psw = "".join(secrets.choice(tipo) for _ in range(lunghezza))
print(f"La password generata è: {psw}")
Esercizio 019: Funzione Genera MAC
Un indirizzo MAC (Media Access Control address) è un indirizzo univoco associato dal produttore, a un chipset per comunicazioni wireless (es WiFi o Bluetooth), composto da 6 coppie di cifre esadecimali separate da due punti.
Un esempio di MAC è 02:FF:A5:F2:55:12.
Scrivi una funzione genera_mac che generi degli indirizzi MAC pseudo casuali.
import random
def genera_mac():
char_set = "ABCDEF0123456789"
mac_addr = ""
due_punti = 0
for _ in range(6):
for _ in range(2):
mac_addr += random.choice(char_set)
if due_punti < 5:
mac_addr += ":"
due_punti += 1
return mac_addr
Esercizio 020: Poesia Elettronica
Scrivi una semplice funzione rimario, a cui viene passato un elenco di parole come parametro e che riceva una parola inserita dall'utente tramite la funzione input.
La funzione rimario dovrà confrontare la parola inserita dall'utente con quelle presenti nell'elenco passato, alla ricerca di rime, intese come parole le cui ultime 3 lettere siano uguali alla parola inserita dall'utente.
Le rime dovranno essere quindi mostrate in output dall'utente.
# due possibili soluzioni per l'esercizio proposto
def rimario(elenco):
rime = []
parola = input("Inserisci la parola di cui desideri cercare le rime: ")
for elemento in elenco:
if elemento[-3:] == parola[-3:]:
rime.append(elemento)
if not rime:
print("Non sono state trovate rime corrispondenti alla parola passata!")
else:
output = ", ".join(el for el in rime)
print(f"Le rime corrispondenti alla parola {parola} sono le seguenti: {output}")
def rimario_pro(elenco):
rime = []
parola = input("Inserisci la parola di cui desideri cercare le rime: ")
rime = [el for el in elenco if el[-3:] == parola[-3:]]
if not rime:
print("Non sono state trovate rime corrispondenti alla parola passata!")
else:
output = ", ".join(el for el in rime)
print(f"Le rime corrispondenti alla parola {parola} sono le seguenti: {output}")
Esercizio 021: La Libreria
Scrivi una funzione "vendi_libri" che:
Controlla se il libro richiesto è presente sugli scaffali della libreria
Qualora il libro sia presente, ne decrementa il numero di copie (eventualmente rimuovendo il titolo) e ci segnala che la vendita ha avuto successo
Se il libro non è disponibile, viene messo in un elenco di libri da ordinare e ci viene comunicato che la vendita non ha avuto successo
La funzione restituisce valore Booleano True o False in base all'esito della vendita.
scaffale = {"Così parló Zarathustra": 10, "Elon Musk - Biografia": 7, "End Of Jobs": 5,
"L'Alchimista": 1, "I Fratelli Karamazov": 2, "Delitto e Castigo": 1}
ordini = []
def vendi_libri(scaffale, libro):
vendita = False
if libro in scaffale:
vendita = True
scaffale[libro] -= 1
print(f"Il libro '{libro}' è stato venduto!")
if scaffale[libro] == 0:
del scaffale[libro]
else:
print(f"Mi dispiace, ma il libro richiesto '{libro}' non è presente nello scaffale.")
print("Sto effettuando un ordine!")
ordini.append(libro)
print(f"Da Ordinare: {ordini}")
print("Di seguito un elenco aggiornato dei volumi presenti nel nostro scaffale:")
print(scaffale)
return vendita
Esercizio 022: Crittografia ROT-13
Il ROT-13 è un semplice cifrario monoalfabetico, in cui ogni lettera del messaggio da cifrare viene sostituita con quella posta 13 posizioni più avanti nell'alfabeto.
Scrivi una semplice funzione in grado di criptare una stringa passata, o decriptarla se la stringa è già stata precedentemente codificata.
Scrivi una funzione ricorsiva che calcola il fattoriale di un numero dato.
def fattoriale(n):
if n == 1:
return n
else:
result = n * fattoriale(n-1)
return result
Esercizio 024: La Serie di Fibonacci
Nella serie di Fibonacci, ciascun numero della serie è la somma dei due numeri nella serie che lo precedono, ad esempio:
1, 1, 2, 3, 5, 8, 13 (...)
Scrivi una funzione ricorsiva che restituisce in output i numeri della sequenza di Fibonacci, entro una soglia specifica impostata dall'utente.
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
limite = int(input("Inserisci il numero di valori della serie che desideri vedere: "))
for num in range(1, limite+1):
print(fibonacci(num))
Esercizio 025: Info di Sistema
Scrivi una funzione che fornisca in output il nome del Sistema Operativo utilizzato con eventuali relative informazioni sulla release corrente.
import platform
def sys_info():
print("Il Sistema attualmente in uso è: " + platform.system())
print("Info Release: " + platform.release())
Esercizio 026: Trova ASCII
Scrivi una funzione che, dato un carattere in ingresso, restituisca in output il codice ASCII associato al carattere passato.
def trova_ascii():
carattere = input("Inserisci il carattere che ti interessa convertire: ")
valore = ord(carattere)
output = f"Il valore ASCII associato a '{carattere}' è {valore}"
return output
Esercizio 027: Il peso di una cartella
Scrivi una funzione che calcoli la somma (espressa in MB) delle dimensioni dei file presenti nella cartella di lavoro.
import os
def file_size():
totale = 0
cartella = os.getcwd()
for file in os.listdir(cartella):
totale += os.path.getsize(os.path.join(cartella, file))
print(f"La somma delle dimensioni dei file presenti nella cartella '{cartella}' è: {(totale/1048576):.2f}MB")
Esercizio 028: Il Postino
Scrivi una funzione "postino" che sia in grado di spedire delle eMail tramite Gmail! (aiuto: puoi usare il modulo smtplib)
import smtplib
def postino():
print("""
Questa è la funzione Postino: spedisce eMail utilizzando Gmail!
Server: smtp.gmail.com
Porta: 587
Si richiedono: Username, Password, Destinatario, Oggetto e Messaggio da inviare.
""")
username = input("Inserisci il tuo username: ")
password = input("Inserisci la tua password: ")
destinatario = input("Inserisci l'email del destinatario: ")
oggetto = input("Inserisci l'oggetto della mail: ")
messaggio = input("Ora puoi inserire il messaggio che vuoi inviare: ")
contenuto = f"Subject: {oggetto}\n\n{messaggio}"
print("Sto effettuando la connessione col Server...")
email = smtplib.SMTP("smtp.gmail.com",587)
email.ehlo()
email.starttls()
email.login(username,password)
print("Sto inviando...")
email.sendmail(username, destinatario, contenuto)
email.quit()
print("Messaggio Inviato!")
Esercizio 029: La Cercatrice
Scrivi una funzione "cercatrice" che scansioni un dato percorso di sistema alla ricerca di file di tipo pdf. La funzione dovrà avere le seguenti caratteristiche:
Il percorso fornito dovrà essere anzitutto validato, in quanto deve portare a una cartella esistente
La funzione dovrà fornire un elenco dei file pdf (con/relativo/percorso) man mano che questi vengono trovati
In fine la funzione dovrà fornire in output il totale dei file .pdf che sono stati trovati durante la scansione.
import os
def cercatrice(percorso):
if not os.path.isdir(percorso):
print(f"Il percorso inserito '{percorso}' risulta non essere un percorso idoneo. Verifica e riprova, grazie.\n")
return None
contatore = 0
print(f"Sto effettuando la scansione di '{percorso}' alla ricerca di file .pdf\n")
for cartella, sottocartelle, files in os.walk(percorso):
for file in files:
if file.endswith(".pdf"):
pdf = os.path.join(cartella,file)
print(f"Trovato file pdf: {pdf}\n")
contatore += 1
print(f"\nScansione Ultimata! Ho trovato {contatore} files con estensione pdf.")
Esercizio 030: Il Salvatore
Scrivi una funzione "file_backup" che sia in grado di effettuare copie di backup di determinati tipi di file, con le seguenti caratteristiche:
Percorso da scansionare, di backup e tipologia di file da copiare dovranno essere passati dall'utente tramite input
Il programma dovrà verificare la presenza o meno di una cartella di backup al percorso fornito, e qualora questa non fosse presente dovrà crearla
La funzione dovrà anche gestire l'eventuale scelta da parte dell'utente, di un percorso da scansionare che non esiste
import os
import shutil
def file_backup():
print("Ciao! Questo script effettua copie di backup per file di un'estensione passata come input.\n")
percorso = input("Inserisci il percorso da scansionare: ")
if not os.path.isdir(percorso):
print(f"Il percorso inserito '{percorso}' risulta non essere un percorso idoneo. Verifica e riprova, grazie.\n")
return file_backup()
estensione = input("Che tipologia di file desideri salvare? [esempio: .jpg .pdf .epub]: ")
backup_folder = input("Inserisci la cartella dove desideri salvare i tuoi file: ")
if not os.path.isdir(backup_folder):
os.makedirs(backup_folder)
contatore = 0
print(f"Sto effettuando la scansione di '{percorso}' alla ricerca di file '{estensione}'\n")
for cartella, sottocartelle, files in os.walk(percorso):
for file in files:
if file.endswith(estensione):
match = os.path.join(cartella,file)
print(f"Trovato file {estensione}: {match}")
shutil.copy(match,backup_folder)
contatore += 1
print("Copia Terminata")
print(f"Ho trovato '{contatore}' files con estensione {estensione}, ora disponibili anche in '{backup_folder}'")
Hey tu! Iscriviti alla NewsLetter per ricevere tutti gli aggiornamenti importanti e i link più utili per professionisti e appassionati, curati settimanalmente dalla
nostra redazione. Zero spam, solo qualità!