lez18_es00.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 18 - Esercizio 0 - Sesso, droga e C++
# Scrivere un programma in Python che censuri un dato di testo sostituendo
# le parole "sesso", "droga" e "c++" con degli asterischi. È richiesto
# l'utilizzo del metodo join() per ricostruire il testo.

# testo = "nella vita mi piace fare sesso e ogni tanto decido di usare della droga e programmare in C++"

# parole = testo.split(" ")

# for indice, parola in enumerate(parole):
#     if parola == "sesso" or parola == "droga" or parola == "C++":
#         parole[indice] = len(parola) * "*"

# risultato = " ".join(parole)

# print(risultato)

# Soluzione complessa con funzioni e dizionari ecc...
def censura_testo(testo: str) -> str:
    """
    Funzione che censura le parole "sesso", "droga" e "c++" sostituendole con asterischi.

    :param testo: Il testo che deve essere censurato
    :return: La stringa contenente il testo censurato
    """
    parole_da_censurare = {
        "sesso": "*****",
        "droga": "*****",
        "c++": "***"
    }

    parole = testo.split()
    risultato = []

    for parola in parole:
        if parola[-1] == "." or parola[-1] == ",":
            parola = parola[:-1]
        if parola.lower() in parole_da_censurare:
            risultato.append(parole_da_censurare[parola.lower()])
        else:
            risultato.append(parola)
    
    return " ".join(risultato)

def main():
    """
    Programma principale per censurare il testo
    """
    file_con_frase = open("file_con_frase.txt", "r")
    frase = file_con_frase.read()
    file_con_frase.close()

    testo_censurato = censura_testo(frase)
    print("\nTesto censurato:")
    print(testo_censurato)

if __name__ == "__main__":
    main()

lez18_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 18 - Esercizio 3
# Scrivere un programma Python che apre e legge una lista di nomi di studenti
# da un file di testo, dove ogni riga contiene il nome di uno studente. Il programma
# deve dividere la lista di studenti letta dal file in due gruppi: una per la prima
# metà degli studenti e una per la seconda metà degli studenti. Stampare i due gruppi.
import random

def leggi_studenti(file_path: str) -> list[str]:
    """
    Legge i nomi degli studenti da un file di testo.

    :param file_path: percorso del file con la lista di nomi degli studenti
    :return: la lista dei nomi degli studenti
    """
    studenti = []
    with open(file_path, 'r') as file:
        for riga in file:
            studenti.append(riga.strip())
        # studenti = [riga.strip() for riga in file]  # List comprehension
    # Equivalenti a:
    # file = open(file_path, 'r')
    # righe_file = file.readlines()  # ["Giovanni ", " Giampiero", "Franco ", " Giuseppe"]
    # for riga in righe_file:
    #     studenti.append(riga.strip())  # ["Giovanni", "Giampiero", "Franco", "Giuseppe"]
    # file.close()
    
    random.shuffle(studenti)
    return studenti

def dividi_gruppi(studenti: list[str]) -> tuple[list[str], list[str]]:
    """
    Divide la lsita degli studenti in due gruppi (1o gruppo 1a metà, 2o gruppo 2a metà).

    :param studenti: la lista degli studenti
    :return: tupla con i due gruppi
    """
    metà = len(studenti) // 2
    gruppo1 = studenti[:metà]
    gruppo2 = studenti[metà:]
    return gruppo1, gruppo2

def main() -> None:
    """
    Programma principale.
    """
    file_path = "studenti.txt"
    studenti = leggi_studenti(file_path)

    if not studenti:
        print("Il file non contiene studenti")
        return
    
    primo_gruppo, secondo_gruppo = dividi_gruppi(studenti)

    print("Gruppo 1:")
    stampa_lista_in_modo_bello(primo_gruppo)

    print("Gruppo 2:")
    stampa_lista_in_modo_bello(secondo_gruppo)

def stampa_lista_in_modo_bello(lista: list) -> None:
    for elemento in lista:
        print(f" - {elemento}")

if __name__ == "__main__":
    main()

lez18_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 18 - Esercizio 1
# Scrivere un programma Python che legga il file "database_biologico.txt"
# e memorizzi le informazioni in un dizionario in cui la chiave è il nome
# della specie e il valore è il valore della caratteristiche.
# Fornisci un menu all'utente per eseguire le seguenti operazioni:
# - Se l’utente inserisce il numero 1, si visualizzano tutte le specie e
#   le caratteristiche
# - Se l’utente inserisce il numero 2, si ottieni il valore di caratteristiche
#   per una specie (all’utente sarà successivamente chiesto di inserire quale
#   specie valutare la caratteristica).
# Queste operazioni devono essere effettuate fintanto che l’user non richieda
# di uscire e scriva “3”.

def leggi_database(percorso_file: str) -> dict[str, int]:
    """
    Legge il file e memorizza le informazioni in esso contenute in un dizionario.

    :param percorso_file: Il percorso del file da leggere
    :return: Il dizionario con il nome della specie come chiave e caratteristica come valore
    """
    database = {}
    file = open(percorso_file, 'r')
    righe = file.readlines()  # righe = ["Lupo 100", "Orca 800", "Elefante 300"]
    file.close()
    for riga in righe:
        elementi_nella_riga = riga.split(" ")  # elementi_nella_riga = ["Lupo", "100"]
        specie = elementi_nella_riga[0]
        caratteristica = elementi_nella_riga[1]
        # specie, caratteristica = riga.split(" ")  # riga.split(" ") = ["Lupo", "100"]
        database[specie] = int(caratteristica)
    
    return database

def menu(database: dict[str, int]) -> None:
    """
    Fornisce un menu all'utente per interagire con il database biologico.
    """
    while True:
        print("\nMenu:")
        print("1. Visualizza tutte le specie e le caratteristiche")
        print("2. Ottieni il valore di caratteristica per una specie")
        print("3. Esci")

        scelta = input("Inserisci la tua scelta: ")

        if scelta == '1':
            stampa_dizionario_in_modo_bello(database)
        elif scelta == '2':
            specie = input("Inserisci il nome della specie di cui visualizzare il valore di Caratteristica1: ").strip()
            if specie.capitalize() in database:
                print(f"La caratteristica di {specie} è: {database[specie.capitalize()]}")
            else:
                print("Specie non trovata nel database")
        elif scelta == '3':
            print("Ciao ciao")
            break
        else:
            print("Scelta non valida. Riprova")

def stampa_dizionario_in_modo_bello(dizionario: dict) -> None:
    """
    Funzione che stampa un dizionario come una lista puntata

    :param dizionario: il dizionario da stampare
    """
    for chiave, valore in dizionario.items():
        print(f" - {chiave}: {valore}")

def main() -> None:
    """
    Programma principale.
    """
    percorso_database = "database_biologico.txt"
    database = leggi_database(percorso_database)

    if database:
        menu(database)
    else:
        print("C'è stato un errore nella lettura del file, oppure il file è vuoto.")

if __name__ == "__main__":
    main()

lez18_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 18 - Esercizio 2
# Si suppone di avere un'applicazione che consente agli utenti di registrare
# nuove specie biologiche nel nostro database. Ogni specie ha un nome e alcune
# caratteristiche associate. Scrivere un programma Python che permetta agli utenti
# di inserire il nome di una nuova specie e le sue caratteristiche, e salvarli
# in un dizionario. Scrivere ogni specie e valore associato in un file txt.

# Suggerimento: iterare sugli elementi da scrivere e ricordarsi di inserire il
# carattere “\n” per andare a capo!

def leggi_database(percorso_file: str) -> dict[str, int]:
    """
    Legge il file e memorizza le informazioni in esso contenute in un dizionario.

    :param percorso_file: Il percorso del file da leggere
    :return: Il dizionario con il nome della specie come chiave e caratteristica come valore
    """
    database = {}
    file = open(percorso_file, 'r')
    righe = file.readlines()  # righe = ["Lupo 100", "Orca 800", "Elefante 300"]
    file.close()
    for riga in righe:
        elementi_nella_riga = riga.split(" ")  # elementi_nella_riga = ["Lupo", "100"]
        specie = elementi_nella_riga[0]
        caratteristica = elementi_nella_riga[1]
        # specie, caratteristica = riga.split(" ")  # riga.split(" ") = ["Lupo", "100"]
        database[specie] = int(caratteristica)
    
    return database

def aggiungi_specie(specie: str, caratteristica: int, file_path: str) -> dict[str, int]:
    """
    Permette agli utenti di aggiungere una nuova specie e la corrispondente caratteristica al database.

    :param specie: la nuova specie da inserire
    :param caratteristica: la caratteristica della nuova specie
    :param file_path: percorso del file dove salvare la nuova specie
    """
    database = leggi_database(file_path)

    # database = {"Lupo": 100, ...}

    if specie.capitalize() in database:
        print("Specie già presente.")
    else:
        database[specie] = caratteristica
        # database = {"Lupo": 100, ..., "Biero": 1000}
        file = open(file_path, 'w')
        for specie, caratteristica in database.items(): # it. 1 -> specie = "Lupo", caratteristica = 100
                                                        # it. 2 -> specie = "Orca", caratteristica = 800
                                                        # ...
                                                        # it. 4 -> specie = "Biero", caratteristica = 1000
            file.write(f"{specie.capitalize()} {caratteristica}\n")  # it. 1 -> Lupo 100 (scritto in una riga del file)
                                                                     # it. 2 -> Orca 800 (============================)
                                                                     # ...
                                                                     # it. 4 -> Biero 1000 (scritto ....)
        # Con l'append sarebbe stato più semplice:
        # file = open(file_path, 'a')
        # file.write(f"{specie.capitalize()} {caratteristica}\n")
        file.close()
        print("Specie aggiunta con successo")
    
    return database

def menu(database: dict[str, int], file_path: str) -> None:
    """
    Fornisce un menu all'utente per interagire con il database biologico.

    :param database: il database biologico
    :param file_path: il percorso del file dove si trova il database
    """
    while True:
        print("\nMenu:")
        print("1. Visualizza tutte le specie e le caratteristiche")
        print("2. Ottieni il valore di caratteristica per una specie")
        print("3. Aggiungi una nuova specie")
        print("4. Esci")

        scelta = input("Inserisci la tua scelta: ")

        if scelta == '1':
            stampa_dizionario_in_modo_bello(database)
        elif scelta == '2':
            specie = input("Inserisci il nome della specie di cui visualizzare il valore di Caratteristica1: ").strip()
            if specie.capitalize() in database:
                print(f"La caratteristica di {specie} è: {database[specie.capitalize()]}")
            else:
                print("Specie non trovata nel database")
        elif scelta == '3':
            nuova_specie = input("Inserisci il nome della specie da aggiungere: ").strip()
            nuova_caratteristica = int(input("Inserisci la corrispondente nuova caratteristica: "))
            database = aggiungi_specie(nuova_specie, nuova_caratteristica, file_path)
        elif scelta == '4':
            print("Ciao ciao")
            break
        else:
            print("Scelta non valida. Riprova")

def stampa_dizionario_in_modo_bello(dizionario: dict) -> None:
    """
    Funzione che stampa un dizionario come una lista puntata

    :param dizionario: il dizionario da stampare
    """
    for chiave, valore in dizionario.items():
        print(f" - {chiave}: {valore}")

def main() -> None:
    """
    Programma principale.
    """
    percorso_database = "database_biologico.txt"
    database = leggi_database(percorso_database)

    if database:
        menu(database, percorso_database)
    else:
        print("C'è stato un errore nella lettura del file, oppure il file è vuoto.")

if __name__ == "__main__":
    main()

lez17_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 17 - Esercizio 1 - Temperatura
# Scrivi una funzione in Python analizza_temperature che prende in input una lista
# di temperature (numeri float) e restituisce la temperatura media, la temperatura
# massima e la temperatura minima (tuple). Poi, crea un programma che chiede
# all'utente di inserire una serie di temperature (fino a quando non inserisce
# 'stop'), le salva in una lista e utilizza la funzione per analizzare queste
# temperature.

def analizza_temperature(temperature: list[float]) -> tuple[float, float, float]:
    """
    Calcola la temperature media, massima e minima

    :param temperature: lista di numeri float rappresentanti delle temperature da analizzare
    :return: tupla contenente media (float), massima (float) e minima (float) delle temperature
    """
    if not temperature:  # Se la lista è vuota viene considerata False, con il not davanti, il tutto
                         # diventa True. Quindi, se la lista è vuota, "not temperature" è True, quindi
                         # si entra nell'if e si evita di andare in errore con le righe dopo.
        return None, None, None  # Oppure 0.0, 0.0, 0.0

    media = sum(temperature) / len(temperature)
    massima = max(temperature)
    minima = min(temperature)

    return media, massima, minima

def main():
    """
    Programma principale per inserire e analizzare temperature
    """
    temperature = list()

    print("Inserisci una serie di temperature (scrivi 'stop' per terminare l'inserimento):")
    while True:
        temperatura_inserita = input("Insersci una temperatura: ")
        if temperatura_inserita.lower() == 'stop':
            break

        temperatura_convertita = float(temperatura_inserita)
        temperature.append(temperatura_convertita)

    media, massima, minima = analizza_temperature(temperature)

    print("\n\nRisultati dell'analisi delle temperature:")
    print(f"Temperatura media: {media}")
    print(f"Temperatura massima: {massima}")
    print(f"Temperatura minima: {minima}")

if __name__ == "__main__":
    main()

lez17_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 17 - Esercizio 2 - Conteggio
# Crea un programma in Python che chiede all'utente di inserire una frase e conta
# quante volte e dove all'interno della stringa compaiono le vocali. Il programma
# deve stampare il conteggio totale di ogni vocale e la posizione di ogni occorrenza
# nella stringa.

def conta_vocali(frase: str) -> dict[str, dict[str, int|list]]:
    """
    Conta il numero di occorrenze delle vocali e registra le posizioni in cui compaiono.

    :param frase: stringa inserita dall'utente
    :return: dizionario con vocali come chiavi e dizionari (conteggio, posizioni) come valori
    """
    VOCALI = 'aeiouAEIOU'
    risultato = {}

    for vocale in VOCALI:
        risultato[vocale] = {
            'conteggio': 0,
            'posizioni': []
        }
    # Dopo questo for, si crea lo scheletro del dizionario, quindi una cosa del tipo:
    # risultato = {
    #   'a': {
    #       'conteggio': 0,
    #       'posizioni': []
    #   },
    #   'e': {
    #       'conteggio': 0,
    #       'posizioni': []
    #   },
    #
    #   ...
    #
    #   'U': {
    #       'conteggio': 0,
    #       'posizioni': []
    #   },
    # }

    for indice, carattere in enumerate(frase):
        if carattere in VOCALI:
            risultato[carattere]['conteggio'] += 1
            risultato[carattere]['posizioni'].append(indice)
    
    # Esempio di risultato finale:
    # risultato = {
    #   'a': {
    #       'conteggio': 7,
    #       'posizioni': [2, 4, 2, 1, 6, 7, 5]
    #   },
    #   'e': {
    #       'conteggio': 3,
    #       'posizioni': [2, 8, 1]
    #   },
    # }

    return risultato

def main():
    """
    Programma principale per analizzare vocali in una frase.
    """
    frase = input("Inserisci una frase: ")

    analisi = conta_vocali(frase)

    print("\n\nRisultati del conteggio delle vocali:")
    for vocale, informazioni in analisi.items():
        if informazioni['conteggio'] > 0:
            print(f"La vocale '{vocale}' è comparsa {informazioni['conteggio']} volte nelle posizioni: {informazioni['posizioni']}")
        else:
            print(f"La vocale '{vocale}' non è mai comparsa nella frase.")

if __name__ == "__main__":
    main()

teoria.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 17 - Lavorare con i file

# A livello puramente informatico e teorico, un file è una sequenza di byte
# memorizzata su un dispositivo di memorizzazione permanente, come un disco
# rigido. I file possono contenere qualsiasi tipo di informazione, come testo,
# immagini, audio, video, ecc.

# Essendo i file una sequenza di byte, possono essere di due tipi:
# - file di testo: contengono testo in formato ASCII o Unicode.
# - file binari: contengono informazioni non testuali, come immagini, audio,
#   video, ecc.

# I file sono fondamentali per la memorizzazione e il recupero di dati. Ad
# esempio, quando si scrive un programma, è possibile memorizzare i dati in un
# file per poterli recuperare in un secondo momento. Fino a questo momento,
# infatti, i dati che abbiamo utilizzato sono stati memorizzati solo in memoria
# RAM, che è volatile, cioè i dati vengono persi quando il computer viene
# spento o il programma termina. Attraverso i file, invece, è possibile
# memorizzare i dati in modo permanente.

# ---==== Aprire un file ====---

# Per aprire un file in Python, si utilizza la funzione open(). Questa funzione
# restituisce un oggetto file, che è un oggetto che rappresenta il file aperto.
# La sintassi della funzione open() è la seguente:

# open(nome_file, modalità)

# dove:
# - nome_file è il nome del file da aprire.
# - modalità è la modalità di apertura del file. Le modalità possibili sono:
#   - 'r': apre il file in modalità di sola lettura. Il file deve esistere.
#   - 'w': apre il file in modalità di sola scrittura. Se il file esiste, il
#          suo contenuto viene sovrascritto. Se il file non esiste, viene
#          creato.
#   - 'a': apre il file in modalità di scrittura in append. Se il file esiste,
#          il cursore viene posizionato alla fine del file. Se il file non
#          esiste, viene creato.
#   - 'r+': apre il file in modalità di lettura e scrittura. Il file deve
#           esistere.
#   - 'w+': apre il file in modalità di lettura e scrittura. Se il file esiste,
#           il suo contenuto viene sovrascritto. Se il file non esiste, viene
#           creato.
#   - 'a+': apre il file in modalità di lettura e scrittura in append. Se il
#           file esiste, il cursore viene posizionato alla fine del file. Se il
#           file non esiste, viene creato.
#   - 'x': apre il file in modalità di sola scrittura. Se il file esiste, viene
#          sollevata un'eccezione di tipo FileExistsError. Se il file non esiste,
#          viene creato.
#   - 'b': apre il file in modalità binaria. Questa modalità deve essere
#          utilizzata insieme a una delle modalità precedenti e serve per aprire
#          un file binario (ad esempio, un'immagine, un file audio, ecc.).
# Ce ne sono altre, ma queste sono le più comuni.

# ATTENZIONE: il nome_file deve essere una stringa e deve essere il percorso del
# file. Cosa si intende con percorso del file?
# Sostanzialmente, il nome di un file, dietro le quinte, è composto da due parti:
# - il nome vero e proprio del file.
# - il percorso del file, cioè la sequenza di cartelle che, a partire dalla cartella
#   radice del sistema operativo, porta al file.

# N.B.: la struttura del percorso cambia in base al sistema operativo. In generale:
# - su Windows, il percorso è composto da una sequenza di cartelle separate da
#   backslash (\).
# - su Unix e Unix-like (Linux, macOS), il percorso è composto da una sequenza di
#   cartelle separate da slash (/).

# N.B.2: generalmente, i file hanno un'estensione che indica il tipo di file. Ad
# esempio, i file di testo hanno estensione .txt, i file Python hanno estensione
# .py, i file immagine hanno estensione .jpg o .png, i file audio hanno estensione
# .mp3 o .wav, i file Excel hanno estensione .xls o .xlsx, i file Word hanno
# estensione .doc o .docx, i file PDF hanno estensione .pdf, i file PowerPoint
# hanno estensione .ppt o .pptx, i file ZIP hanno estensione .zip, ecc...
# Tuttavia, ci possono essere anche file senza estensione o con estensioni
# personalizzate. L'estensione di un file non è altro che una convenzione per
# indicare il tipo di file, ma non è obbligatoria. Infatti, è possibile creare un
# file di testo con estensione .jpg e un'immagine con estensione .txt, ma questo
# potrebbe creare confusione e non funzionare correttamente con alcuni programmi.

# Per quanto riguarda le estensioni personalizzate, è possibile, per esempio, creare
# un file PDF con estensione .pdf.old, se magari si vuole mantenere una
# vecchia versione di un file PDF. In questo caso, però, il file non sarà riconosciuto
# come un file PDF da un programma che gestisce i file PDF.

# Esempi di percorsi di file:
# Supponiamo di avere un file chiamato lista_spesa.txt, che si trova nella cartella
# Desktop del nostro utente (che chiameremo biero). I percorsi del file sono:
# - su Windows: C:\Users\biero\Desktop\lista_spesa.txt
# - su Unix e Unix-like: /home/biero/Desktop/lista_spesa.txt

# Perché? Perché:
# - su Windows, la cartella radice è C:\, mentre su Unix e Unix-like è /.
# - su Windows, le cartelle sono separate da backslash (\), mentre su Unix e
#   Unix-like sono separate da slash (/).
# - su Windows, il nome dell'utente è preceduto da Users\, mentre su Unix e
#   Unix-like è preceduto da home/.

# Quindi, considerando Windows, il file lista_spesa.txt si trova nella cartella
# Desktop, che a sua volta si trova nella cartella biero, che a sua volta si trova
# nella cartella Users, che a sua volta si trova nella cartella C:\. Quindi, il
# percorso del file è C:\Users\biero\Desktop\lista_spesa.txt.

# Quindi, ricapitolando, il nome del file, per Python, è il suo percorso.

# Inoltre, questo percorso, può anche essere relativo. Cosa si intende con percorso
# relativo? Sostanzialmente, un percorso relativo è un percorso costruito attraverso
# due cartelle speciali:
# - la cartella punto (.) rappresenta la cartella corrente.
# - la cartella punto-punto (..) rappresenta la cartella genitore.

# Ad esempio, supponiamo di avere un file chiamato programma.py, che si trova nella
# cartella pythonata, che a sua volta si trova nella cartella Documenti, che a sua
# volta si trova nella cartella biero, che a sua volta si trova nella cartella
# Utenti, che a sua volta si trova nella cartella C:\. Quindi, il percorso ASSOLUTO
# del file # è C:\Utenti\biero\Documenti\pythonata\programma.py.
# Ma supponiamo che il file programma.py voglia aprire un file chiamato dati.txt,
# che si trova nella stessa cartella di programma.py. In questo caso, il percorso
# RELATIVO del file dati.txt è .\dati.txt. Il punto (.) rappresenta la cartella
# corrente, mentre il backslash (\) separa le cartelle.
# Supponiamo, invece, che il file dati.txt si trovi nella cartella prova, che si
# trova nella cartella pythonata. Allora, il percorso RELATIVO del file dati.txt
# è ..\prova\dati.txt. Il punto-punto (..) rappresenta la cartella genitore.

# Esempi di apertura di un file:
f = open('C:\\Users\\biero\\Desktop\\lista_spesa.txt', 'r')
f = open('/home/biero/Desktop/lista_spesa.txt', 'r')
f = open('lista_spesa.txt', 'r') # Questo è un percorso relativo e apre il file
                                 # nella cartella corrente.

# N.B.: quando si apre un file, è importante chiuderlo quando non serve più. Per
# chiudere un file, si utilizza il metodo close() dell'oggetto file.

# Esempio:
f = open('lista_spesa.txt', 'r')
f.close()

# ---==== Leggere il contenuto di un file ====---

# Per leggere il contenuto di un file, si utilizza il metodo read() dell'oggetto
# file. Questo metodo restituisce una stringa contenente tutto il contenuto del
# file.

# Esempio:
f = open('lista_spesa.txt', 'r')
contenuto = f.read()
print(contenuto)
f.close()

# N.B.: il metodo read() legge tutto il contenuto del file. Se il file è molto
# grande, potrebbe occupare troppa memoria. In questo caso, è possibile leggere
# il file riga per riga, utilizzando il metodo readline() dell'oggetto file.

# Esempio:
f = open('lista_spesa.txt', 'r')
riga = f.readline()
while riga != '': # Quando il metodo readline() raggiunge la fine del file,
                  # restituisce una stringa vuota. Quindi, il ciclo while
                  # continua finché la riga non è vuota, ovvero finché non
                  # raggiunge la fine del file.
    print(riga)
    riga = f.readline()
f.close()

# ---==== Scrivere su un file ====---

# Per scrivere su un file, si utilizza il metodo write() dell'oggetto file. Questo
# metodo scrive una stringa nel file. Se il file è stato aperto in modalità di
# sola scrittura ('w'), il contenuto del file viene sovrascritto. Se il file è
# stato aperto in modalità di scrittura in append ('a'), il contenuto viene
# aggiunto alla fine del file.

# Esempio:
f = open('lista_spesa.txt', 'w')
f.write('Latte\n')
f.write('Pane\n')
f.write('Burro\n')
f.close()

# N.B.: il metodo write() scrive solo stringhe. Se si vuole scrivere un numero
# intero o un numero decimale, è necessario convertirlo in stringa utilizzando
# la funzione str(), ovvero effettuando il type casting.

# Esempio:
f = open('lista_spesa.txt', 'w')
f.write(str(1) + '\n')
f.write(str(2) + '\n')
f.write(str(3) + '\n')
f.close()

# ---==== Dettagli aggiuntivi ====---

# 1
# La cosa comoda dei file è che questi possono sostituire l'input messo da 
# terminale e l'output printato a terminale. Infatti, è possibile leggere da un
# file e scrivere su un file, senza dover utilizzare input() e print().

# 2
# Attenzione: se il file contiene caratteri speciali, come accenti, apostrofi,
# ecc., è necessario specificare l'encoding del file. L'encoding è la codifica
# dei caratteri, ovvero il modo in cui i caratteri sono rappresentati in byte.
# I due encoding più comuni sono:
# - ASCII: codifica a 7 bit che rappresenta 128 caratteri (senza accenti, ecc.).
# - UTF-8 (Unicode Transformation Format 8-bit): codifica a 8 bit che rappresenta
#   tutti i caratteri Unicode (compresi accenti, apostrofi, emoji, ecc.).

# Per specificare l'encoding di un file, si utilizza il parametro encoding della
# funzione open().

# Esempio:
f = open('lista_spesa.txt', 'r', encoding='utf-8')
contenuto = f.read()
print(contenuto)
f.close()

# N.B.: l'encoding di un file deve essere specificato sia in lettura che in
# scrittura. Se si apre un file in lettura con un certo encoding, è necessario
# aprire lo stesso file in scrittura con lo stesso encoding. Altrimenti, si
# potrebbero avere problemi di codifica.

# 3
# La funzione read() può prendere un argomento, che è il numero di caratteri (byte)
# da leggere. Questo può essere utile se si vuole leggere solo una parte del file.
# N.B.: anche l'andare a capo (\n) è considerato un carattere.

# 4
# Così come quando inserivamo gli input del nostro programma da terminale attraverso
# la funzione input(), anche la lettura dai file restituisce solo ed esclusivamente
# stringhe. Se si vuole leggere un numero intero o un numero decimale, è necessario
# convertire la stringa in intero o decimale. Per fare ciò, si usano le stesse funzioni
# viste precedentemente: int() e float().

# Esempio:
f = open('lista_spesa.txt', 'r')
numero = int(f.readline())
print(numero)
f.close()

# 5
# Dettaglio per evitare di avere problemi: è sempre una buona pratica non chiamare
# i file con nomi che possono creare problemi. Ad esempio, non chiamare un file
# con il nome di una funzione built-in di Python, come open, print, ecc.
# Oppure non chiamare un file con il nome di una variabile già definita nel programma.
# Oppure non chiamare un file con uno spazio nel nome. In generale, è sempre meglio
# usare l'underscore (_) al posto dello spazio.
# Per buona pratica è anche spesso consigliato usare solo lettere minuscole, salvo
# casi particolari (ad esempio per nomi di classi).

# 6
# Risolutore di percorsi per script lanciati su piattaforme diverse:
from pathlib import Path

file_relativo = Path('./lista_spesa.txt')

print(file_relativo.resolve())

lez17_es04.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 17 - Esercizio 4 - Regole nascoste
# Data una lista vuota l = [], scrivere un programma che la riempia con ciascuna
# delle sequenze di valori seguenti, dopo aver compreso la regola di generazione
# della sequenza (se esiste).
# I. 1 2 3 4 5 6 7 8 9 10
# II. 0 2 4 6 8 10 12 14 16 18 20
# III. 0 0 0 0 0 0 0 0 0 0
# IV. 0 1 0 1 0 1 0 1 0 1

def genera_sequenze() -> dict[str, list[int]]:
    """
    Genera le asequenze richieste dalla consegna secondo le regole specificate.

    :return: dizionario con le sequenze
    """

    sequenze = {}

    # Sequenza I: numeri incrementali (+1)
    sequenza_i = []
    for i in range(1, 11):
        sequenza_i.append(i)
    
    sequenze['I'] = sequenza_i

    # Sequenza II: numeri pari
    sequenza_ii = []
    for i in range(0, 21, 2):
        sequenza_ii.append(i)
    
    sequenze['II'] = sequenza_ii

    # Sequenza III: tutti zero
    sequenza_iii = []
    for _ in range(10):
        sequenza_iii.append(0)
    
    sequenze['III'] = sequenza_iii

    # Sequenza IV: 0 e 1 alternati
    sequenza_iv = []
    for i in range(10):
        sequenza_iv.append(i % 2)  # 0%2=0, 1%2=1, 2%2=0, 3%2=1, 4%2=0, 5%2=1, 6%2=0, 7%2=1, 8%2=0, 9%2=1

    sequenze['IV'] = sequenza_iv

    return sequenze

def main():
    """
    Programma principale per generare e stampare le sequenze.
    """
    sequenze = genera_sequenze()

    print("Sequenze generate:")
    for codice_sequenza, sequenza in sequenze.items():
        print(f"Sequenza {codice_sequenza}: {sequenza}")

if __name__ == "__main__":
    main()

lez17_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 17 - Esercizio 3 - Password
# Scrivi un programma in Python che chiede all'utente di inserire una password.
# La password è valida se ha almeno 8 caratteri, contiene almeno una lettera
# maiuscola, una lettera minuscola e un numero. Il programma deve stampare un
# messaggio che indica se la password è valida o meno.
import time

def valida_password(password: str) -> bool:
    """
    Verifica se una password è valida secondo i criteri:
     - Deve avere almeno 8 caratteri
     - Deve contenere almeno una lettera maiuscola
     - Deve contenere almeno una lettera minuscola
     - Deve contenere almeno un numero

    :param password: stringa contenente la password
    :return: True se la password è valida, False altrimenti
    """
    if len(password) < 8:
        return False
    
    ha_maiuscola = False
    ha_minuscola = False
    ha_numero = False

    for carattere in password: # 'Ciao1sium'
        print(f"CARATTERE IN ANALISI: {carattere}")
        
        if carattere.isupper():
            print("Il carattere è maiuscolo, imposto ha_maiuscola a True")
            ha_maiuscola = True # è true
        
        if carattere.islower():
            print("Il carattere è minuscolo, imposto ha_minuscola a True")
            ha_minuscola = True # è true
        
        if carattere.isdigit():
            print("Il carattere è un numero, imposto ha_numero a True")
            ha_numero = True # è true

        # Interrompiamo il ciclo appena tutti i criteri sono soddisfatti
        if ha_maiuscola and ha_minuscola and ha_numero:
            print("Tutti e tre i criteri sono stati rispettati, fermo la verifica e ritorno")
            break
        else:
            print(f"Maiuscola: {ha_maiuscola}, Minuscola: {ha_minuscola}, Numero: {ha_numero}")

        time.sleep(1)

    return ha_maiuscola and ha_minuscola and ha_numero

def main():
    """
    Programma principale per la validazione della password.
    """
    password = input("Inserisci una password: ")

    # is_password_valida = valida_password(password)

    if valida_password(password):
        print("La password è valida")
    else:
        print("La password NON è valida")

    # print(f"La funzione aveva restituito: {is_password_valida}")
    
if __name__ == "__main__":
    main()

lez17_esempio1.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esempione 1:
# Supponiamo di avere un file chiamato numeri.txt, che contiene una sequenza di numeri
# decimali, memorizzati uno per riga. Si vuole leggere tali numeri e scriverli in un
# nuovo file di output chiamato numeri_allineati.txt, in cui sono scritti in modo ben
# allineato (incolonnando i punti decimali), e seguiti dal loro valore totale e dal
# loro valore medio.

# Ad esempio, il file di input potrebbe contenere:
# 1.23
# 45.678
# 9.0
# 123.456
# 789.012
# 34.567
# 890.123

# Il file di output dovrebbe contenere:
#   1.230
#  45.678
#   9.000
# 123.456
# 789.012
#  34.567
# 890.123
# Totale: 1883.866
# Media: 269.124

# Ecco il codice per risolvere il problema:
f_input = open('numeri.txt', 'r')
numeri = f_input.readlines()
f_input.close()

f_output = open('numeri_allineati.txt', 'w')
totale = 0
for numero in numeri:
    numero = float(numero)
    totale += numero
    f_output.write(f'{numero:10.3f}\n')
f_output.write(f'Totale: {totale:.3f}\n')
f_output.write(f'Media: {totale / len(numeri):.3f}\n')
f_output.close()

lez16_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 16 - Esercizio 1 - Lista di funzioni
# Scrivere una funzione per ciascuna delle seguenti operazioni su liste di numeri
# interi, e fornire un programma per collaudare (testing) ciascuna funzione.
# 
# 1. Scambiare tra loro il primo e l’ultimo elemento della lista.
# 2. Far slittare tutti gli elementi della lista di una posizione, spostando
#    l’ultimo elemento nella prima posizione.
#    Ad esempio, la lista 1 4 9 16 25 deve diventare 25 1 4 9 16.
# 3. Sostituire con 0 tutti gli elementi di valore pari.
# 4. Eliminare l’elemento centrale della lista se questa ha dimensione dispari,
#    altrimenti eliminare i due elementi centrali.
# 5. Restituire il secondo valore maggiore della lista.
# 6. Restituire True se e solo se la lista è ordinata in senso crescente.

import random

def scambia_primo_ultimo(lista: list[int]) -> list[int]:
    lista[0], lista[-1] = lista[-1], lista[0]
    return lista

def scambiatore(lista):
    primo_elemento = lista.pop(0)
    ultimo_elemento = lista.pop()
    lista.append(primo_elemento)
    lista.insert(0, ultimo_elemento)
    return lista

def slitta_elementi(lista: list[int]) -> list[int]:
    if len(lista) == 0:
        return []
    ultimo_elemento = lista.pop()
    lista.insert(0, ultimo_elemento)
    return lista

def sostituzione_con_zero(lista: list[int]) -> list[int]:
    for indice, elemento in enumerate(lista):
        if elemento % 2 == 0:
            lista[indice] = 0
    
    return lista

def sostituzione(lista):
    for numero in lista:
        if numero % 2 == 0:
            numero = 0

# es. lista lunga 15, si ha
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
#               ^
# (len(lista) - 1) / 2
# lista lunga 14, si ha
# 0 1 2 3 4 5 6 7 8 9 10 11 12 13
#             ^ ^                
# len(lista) / 2
# 0 1 2 3 4 5 6 7 8 9 10 11 12
#             ^
# len(lista) / 2

def elimina_centrali(lista: list[int]) -> list[int]:
    if len(lista) == 0:
        return []
    elif len(lista) % 2 == 0:
        lista.pop(int(len(lista) / 2))
        
    lista.pop(int(len(lista) / 2))
    
    return lista

def elimina(lista: list[int]) -> list[int]:  # 15 / 2 = 7.5 ----- 15 // 2 = 7
    if len(lista) == 0:
        return lista
    middle = len(lista) // 2
    if len(lista) % 2 == 0:
        return lista[:middle-1] + lista[middle+1:]
    else:
        return lista[:middle] + lista[middle+1:]
    
def secondo_maggiore(lista: list[int]) -> int:  # [6, 6, 5, 2, 2, 2, 1]
    valore_maggiore = max(lista)  # 6
    numero_di_massimi = lista.count(valore_maggiore)  # 2
    for _ in range(numero_di_massimi):  # lo fa 2 volte
        lista.remove(valore_maggiore)  # [6, 5, 2, 2, 2, 1] - prima it.
                                       # [5, 2, 2, 2, 1] - seconda it.
    return max(lista)

def valore_maggiore_della_lista(lista):  # [6, 6, 5, 2, 2, 2, 1]
    numero_di_massimi = lista.count(max(lista))  # 2
    lista_ordinata = sorted(lista)  # [1, 2, 2, 2, 5, 6, 6]
    #                                  0  1  2  3  4  5  6
    #                                 -7 -6 -5 -4 -3 -2 -1
    secondo_elemento_maggiore = lista_ordinata[-(numero_di_massimi) - 1]  # -2 - 1 = -3
    return secondo_elemento_maggiore

def secondo_maggiore(lista: list[int]) -> int:
    if len(lista) < 2:
        return None
    
    max_val = max(lista)
    lista_senza_max = []
    for x in lista:  # [6, 6, 5, 2, 2, 2, 1]
        if x != max_val:
            lista_senza_max.append(x)  # [5, 2, 2, 2, 1]
    
    if len(lista_senza_max) == 0:
        return None
    
    return max(lista_senza_max)

def verifica_se_crescente(lista: list[int]) -> list[int]:
    if len(lista) == 1:
        return True
    elif len(lista) == 0:
        return False
    
    crescente = True
    for indice, elemento in enumerate(lista):
        if indice > 0:
            if lista[indice - 1] > elemento:  # indice = 0, elemento = 43 ---- lista[indice - 1] -> lista[-1] 
                return False

    return crescente

def verificozza(data):
    for i in range(0, len(data) - 1):  # len(data) = 9 -- range(0, 8) -> [0, 1, 2, 3, 4, 5, 6, 7]
        if data[i] > data[i+1]:
            return False
    return True

def crescente(lista):
    if lista == sorted(lista):
        return True
    return False

listozza = []
for _ in range(50):
    listozza.append(random.randint(0, 100))

print(f"La lista, attualmente, è:\n{listozza}")
print("Scegli l'operazione che vuoi eseguire:")
print(" a. Scambia il primo e l'ultimo elemento della lista.")
print(" b. Slitta tutti gli elementi della lista di 1.")
print(" c. Cambia tutti gli elementi pari con 0.")
print(" d. Elimina elementi centrali.")
print(" e. Trova il secondo elemento maggiore della lista.")
print(" f. Verifica se la lista è ordinata in modo crescente.")

operazione = input("Scegli: ")
if operazione == "a":
    lista_risultante = scambia_primo_ultimo(listozza)
    print(f"Il risultato è:\n{lista_risultante}")
elif operazione == "b":
    lista_risultante = slitta_elementi(listozza)
    print(f"Il risultato è:\n{lista_risultante}")
elif operazione == "c":
    lista_risultante = sostituzione_con_zero(listozza)
    print(f"Il risultato è:\n{lista_risultante}")
elif operazione == "d":
    lista_risultante = elimina(listozza)
    print(f"Il risultato è:\n{lista_risultante}")
elif operazione == "e":
    print(f"Il secondo elemento maggiore è {secondo_maggiore(listozza)}")
elif operazione == "f":
    print(f"La lista è crescente? {verifica_se_crescente(listozza)}")

teoria.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 16 - Le strutture dati (parte 3)

# ---==== TUPLE ====---

# Le tuple sono una struttura dati simile alle liste, ma immutabile. Questo
# significa che, una volta creata, una tupla non può essere modificata. Le
# tuple sono definite tra parentesi tonde e i loro elementi sono separati da
# virgole.

# Esempio:
t = (1, 2, 3, 4, 5)
print(t)

# Output:
# (1, 2, 3, 4, 5)

# Per accedere agli elementi di una tupla, si può utilizzare l'indice dell'elemento
# come per le liste.

# Esempio:
print(t[0])
print(t[2])

# Output:
# 1
# 3

# Le tuple possono contenere elementi di diversi tipi.

# Esempio:
t = (1, 'due', 3.0, [4, 5, 6])

# È possibile creare una tupla con un solo elemento aggiungendo una virgola dopo
# l'elemento.

# Esempio:
t = (1,)

# Per creare una tupla vuota, si possono utilizzare le parentesi tonde senza
# elementi.

# Esempio:
t = ()

# Le tuple possono essere utilizzate per restituire più valori da una funzione.

# Esempio:
def divisione_e_resto(dividendo, divisore):
    quoziente = dividendo // divisore
    resto = dividendo % divisore
    return quoziente, resto

q, r = divisione_e_resto(10, 3)

# Se si assegna il risultato della funzione che restituisce una tupla a una
# sola variabile, questa diventa una tupla.

# Esempio:
risultato = divisione_e_resto(10, 3)
print(risultato)

# Output:
# (3, 1)

print(type(risultato))

# Output:
# 

# In cosa differiscono le tuple dalle liste?
# - Le tuple sono immutabili, mentre le liste sono mutabili. Questo significa
#   che non è possibile modificare gli elementi di una tupla dopo che è stata
#   creata.
# - Le tuple sono definite tra parentesi tonde, mentre le liste sono definite
#   tra parentesi quadre.
# - Le tuple sono più veloci delle liste, perché richiedono meno memoria.

# ---==== SET ====---

# Un set è una collezione non ordinata di elementi unici. I set sono definiti
# tra parentesi graffe e i loro elementi sono separati da virgole.

# Esempio:
s = {1, 2, 3, 4, 5}
print(s)

# Output:
# {1, 2, 3, 4, 5}

# I set non possono contenere elementi duplicati.

# Esempio:
s = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
print(s)

# Output:
# {1, 2, 3, 4, 5}

# Per accedere agli elementi di un set, si può utilizzare un ciclo for.

# Esempio:
for elemento in s:
    print(elemento)

# Output:
# 1
# 2
# ...

# I set possono contenere elementi di diversi tipi.

# Esempio:
s = {1, 'due', 3.0, (4, 5, 6)}

# È possibile creare un set vuoto con la funzione set().

# Esempio:
s = set()

# I set sono utili per rimuovere i duplicati da una lista.

# Esempio:
l = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
s = set(l) # Questo è un type casting (come int(), float(), ecc.)
l = list(s)
print(l)
print(s)

# Output:
# [1, 2, 3, 4, 5]
# {1, 2, 3, 4, 5}

# La differenza tra tuple e set è che i set sono mutabili, mentre le tuple sono
# immutabili. Questo significa che è possibile aggiungere o rimuovere elementi
# da un set dopo che è stato creato.

# La differenza tra set e liste è che i set non sono ordinati, mentre le liste
# sono ordinate. Questo significa che non è possibile accedere agli elementi di
# un set utilizzando l'indice dell'elemento.
# Inoltre, i set non possono contenere elementi duplicati, mentre le liste possono.

# ---==== DIZIONARI ====---

# I dizionari sono effettivamente l'altra importante struttura dati in Python.
# Le tuple e i set, invece, non vengono utilizzati così spesso. I dizionari
# sono simili alle liste, ma invece di avere indici numerici, hanno delle chiavi
# che possono essere di qualsiasi tipo. I dizionari sono definiti tra parentesi
# graffe e le coppie chiave-valore sono separate da due punti.

# Esempio:
dizionario = {'ambrogio': 1,
     'biero': 2,
     'carlone': 3}
print(dizionario)

# Output:
# {'ambrogio': 1, 'biero': 2, 'carlone': 3}

# Per accedere ai valori di un dizionario, si può utilizzare la
# chiave dell'elemento.

# Esempio:
print(dizionario['ambrogio'])
print(dizionario['carlone'])

# Output:
# 1
# 3

# print(dizionario['drugo'])
# Output: ERRORE (KeyError)

# È possibile aggiungere nuove coppie chiave-valore a un dizionario.

# Esempio:
dizionario['drugo'] = ["drugo", "il", "grande", "laureato"]
print(dizionario)

# Output:
# {'ambrogio': 1, 'biero': 2, 'carlone': 3, 'drugo': ["drugo", "il", "grande", "laureato"]}

# È possibile rimuovere una coppia chiave-valore da un dizionario utilizzando
# la parola chiave "del".

# Esempio:
del dizionario['ambrogio']
print(dizionario)

# Output:
# {'biero': 2, 'carlone': 3, 'drugo': ["drugo", "il", "grande", "laureato"]}

# È possibile utilizzare un ciclo for per accedere alle chiavi e ai valori di un
# dizionario.

# Esempio:
for var in dizionario:
    print(var, dizionario[var])

# Output:
# biero 2
# carlone 3
# drugo ["drugo", "il", "grande", "laureato"]

# È possibile utilizzare il metodo "items" per ottenere una lista di tuple che
# contengono le coppie chiave-valore di un dizionario.

# Esempio:
print(dizionario.items())

# Output:
# dict_items([('biero', 2), ('carlone', 3), ('drugo', ["drugo", "il", "grande", "laureato"])])

for chiave, valore in dizionario.items():
    print(chiave, valore)

# È possibile utilizzare il metodo "keys" per ottenere una lista delle chiavi di
# un dizionario.

# Esempio:
print(dizionario.keys())

# Output:
# dict_keys(['biero', 'carlone', 'drugo'])

# È possibile utilizzare il metodo "values" per ottenere una lista dei valori di
# un dizionario.

# Esempio:
print(dizionario.values())

# Output:
# dict_values([2, 3, ["drugo", "il", "grande", "laureato"]])

# I dizionari sono utili per memorizzare informazioni strutturate. Ad esempio,
# si possono utilizzare i dizionari per memorizzare informazioni sugli studenti
# di una scuola.

# Esempio:
studenti = {
    'Filibertozzo': {
        'età': 15,
        'voti': [8, 7, 6, 9]
    },
    'Giangiovanni': {
        'età': 16,
        'voti': [7, 6, 8, 9]
    },
    'T': {
        'età': 15,
        'voti': [9, 9, 9, 9]
    }
}

for studente in studenti:
    print(f"Lo studente {studente} ha {studenti[studente]['età']} anni e "
          f"ha preso i seguenti voti:\n{studenti[studente]['voti']}")

# In questo esempio, il dizionario "studenti" contiene tre coppie chiave-valore,
# dove la chiave è il nome dello studente e il valore è un altro dizionario che
# contiene l'età e i voti dello studente.

# Uso della funzione dict()

# È possibile creare un dizionario utilizzando la funzione dict(). Questa funzione
# accetta una lista di tuple come argomento, dove ogni tupla contiene una coppia
# chiave-valore.

# Esempio:
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)

lista = ["ciao", "drugo", 5, [1, 2, 3]]
# Corrisponde al dizionario:
dizionario = {
    0: "ciao",
    1: "drugo",
    2: 5,
    3: [1, 2, 3]
}

lez16_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 16 - Esercizio 3 - Differenze
# Crea un programma in Python che definisce una lista di numeri. Il programma
# deve trovare e stampare la coppia di numeri adiacenti nella lista con la
# differenza più grande. Ad esempio, nella lista [1, 4, 2, 8], la coppia con la
# maggiore differenza è (2, 8).

lista = [1, 4, 2, 8]
indice_primo_numero_coppia = -1
differenza_maggiore = -10

for i in range(0, len(lista) - 1):
    if abs(lista[i] - lista[i+1]) > differenza_maggiore:
        differenza_maggiore = abs(lista[i] - lista[i+1])
        indice_primo_numero_coppia = i
    
print(f"La coppia di elementi della lista con la differenza maggiore
      ({differenza_maggiore}) è: ({lista[indice_primo_numero_coppia]}, {lista[indice_primo_numero_coppia+1]})")

lez16_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 16 - Esercizio 2 - Al cinema
# Scrivere un programma che gestisca la prevendita di un numero limitato di
# biglietti del cinema. Ogni acquirente può comprare al massimo 4 biglietti
# e non ne possono essere venduti più di 100 in totale. Il programma deve
# chiedere all’utente quanti biglietti intende acquistare, per poi visualizzare
# il numero di biglietti rimasti. L’operazione va ripetuta fino all’esaurimento
# dei biglietti, visualizzando al termine il numero di acquirenti.

biglietti = 100
numero_acquirenti = 0

while biglietti > 0:
    massimo_acquistabile = 4 if biglietti > 4 else biglietti
    biglietti_acquistati = int(input(f"Quanti biglietti vuoi acquistare? (massimo {massimo_acquistabile})"))
    if biglietti_acquistati > massimo_acquistabile:
        continue
    biglietti -= biglietti_acquistati
    numero_acquirenti += 1
    print(f"Biglietti rimasti: {biglietti}")

print(f"Ci sono stati {numero_acquirenti} acquirenti.")

numero_biglietti = 0
acquirenti = 0

print(numero_biglietti)
while numero_biglietti < 100:
    biglietti_acquistati = int(input("?? "))
    if biglietti_acquistati > 4:
        print("NO")
        continue
    numero_biglietti += biglietti_acquistati
    print(numero_biglietti)
    acquirenti += 1

print(acquirenti)

temp.py (clicca per mostrare il codice) Scarica (n. download: 7)

lista = [41, 14, 12, 5, 52, 25, 6]

def stampa_lista_puntata_della_lista(lista):
    print("La lista contiene:")
    for numero in lista:
        print(f" * {numero}")


print("cose varie...")
stampa_lista_puntata_della_lista(lista)

print("altre cose varie...")
stampa_lista_puntata_della_lista(lista)

lez15_es05.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 15 - Esercizio 5 - Out-of-range
# Scrivere un programma che contenga un out-of-range error

lista = [1, 2, 3]
quarto_elemento = lista[3]

lez15_es04.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 15 - Esercizio 4 - Vocali
# Scrivi una funzione elabora_parole che, data una lista di parole, calcola e
# restituisce la lunghezza di ciascuna parola e il numero di vocali in essa contenute.

# ['ciao', 'buonasera']
# [[4, 3], [9, 5]]

VOCALI = 'aeiouAEIOU'

numero_vocali = 0

def elabora_parole(parole: list[str]) -> list[list[int]]:
    risultato = []
    for parola in parole:
        numero_lettere = len(parola)
        numero_vocali = 0
        for lettera in parola:
            if lettera in VOCALI:
                numero_vocali += 1
        risultato.append([numero_lettere, numero_vocali])
    
    return risultato

lista = ['ciao', 'buonasera']
risultato = elabora_parole(lista)
print(risultato)

lez15_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 15 - Esercizio 2 - Somma senza il minimo
# Scrivere la funzione sum_without_smallest(v) che calcoli la somma di tutti i
# valori di una lista v, escludendo il valore minimo.

def sum_without_smallest(v: list[int]) -> int:
    if len(v) <= 1:
        return 0
    valore_minimo = min(v)
    return sum(v) - valore_minimo

print(sum_without_smallest([]))

def sum_without_smallest(v):
    minimo = min(v)
    posizione = v.index(minimo)
    lista_sommata = v[:posizione] + v[posizione + 1:]
    return sum(lista_sommata)

v = [23, 7, 8, 9, 56, 4, 7, 8, 90, 56]

print(sum_without_smallest(v))

def sum_without_smallest(v: list[int]):
    v.remove(min(v))
    return sum(v)

lez15_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 15 - Esercizio 3 - Media
# Scrivi un programma in Python che calcoli la media di tutti i numeri in una lista e
# poi sottragga questa media da ogni elemento della lista. Questo metodo è utile per
# "normalizzare" i dati, rendendoli più confrontabili.

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def normalizza(lista: list[float]) -> list[float]:
    media = sum(lista) / len(lista)
    nuova_lista = []
    for elemento in lista:
        nuova_lista.append(elemento - media)
    return nuova_lista

lista_normalizzata = normalizza(lista)
print(lista_normalizzata)

teoria.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 15 - Le funzioni

# ---==== LE FUNZIONI ====---

# Le funzioni sono blocchi di codice che eseguono un compito specifico. Le funzioni
# sono utili per suddividere il codice in blocchi più piccoli e più facili da gestire.
# Inoltre, le funzioni permettono di riutilizzare il codice, in quanto possono essere
# richiamate più volte.

# Sintassi:
# def nome_funzione(parametro1, parametro2, ..., parametroN):
#     # Blocco di istruzioni

# Per definire una funzione si utilizza la parola chiave def seguita dal nome della
# funzione e tra parentesi tonde i parametri della funzione. I parametri sono variabili
# che vengono passate alla funzione e che possono essere utilizzate all'interno del
# blocco di istruzioni. I parametri sono opzionali, cioè una funzione può non avere
# parametri.

# Esempio:
def saluta():
    print("Ciao!")

# Questa funzione si chiama "saluta" e non ha parametri. Quando viene chiamata, esegue
# il blocco di istruzioni, che in questo caso stampa la stringa "Ciao!".

# Per chiamare una funzione si scrive il nome della funzione seguito da parentesi tonde.
# Esempio:
saluta()

# Output:
# Ciao!

# Per comprendere il funzionamento dei parametri, possiamo considerare le funzioni come
# dei sotto-programmi le cui variabili sono definite nell'elenco dei parametri.
# È importante, però, notare che le variabili definite all'interno di una funzione
# non sono visibili all'esterno della funzione stessa. Questo concetto è chiamato
# "scope" delle variabili.

# Esempio:
def saluta(nome):
    print(f"Ciao, {nome}!")

# Questa funzione si chiama "saluta" e ha un parametro chiamato "nome". Quando viene
# chiamata, si deve passare un argomento che verrà assegnato al parametro "nome". La
# funzione stamperà la stringa "Ciao, " seguita dal valore del parametro "nome".

# Tornando al parallelismo con i sotto-programmi, la funzione saluta(nome) è come un
# un programma scritto come segue:
nome = "Drugo"
print(f"Ciao, {nome}!")

# Già da questo esempio si può notare la comodità delle funzioni per riutilizzare
# codice. Infatti, se volessimo salutare un'altra persona, potremmo chiamare la
# funzione saluta(nome) passando un altro nome, invece di scrivere di nuovo il codice
# e modificare il valore della variabile "nome".

# Esempio:
saluta("Drugo")
saluta("Biero")
saluta("Ambrogio")

# Output:
# Ciao, Drugo!
# Ciao, Biero!
# Ciao, Ambrogio!

# ---==== FUNZIONI CON VALORE DI RITORNO (PAROLA CHIAVE return) ====---

# Le funzioni possono restituire un valore. Per farlo, si utilizza la parola chiave
# return seguita dall'espressione che si vuole restituire.

# Esempio:
def somma(a, b):
    risultato_somma = a + b
    return risultato_somma

# Questa funzione si chiama "somma" e ha due parametri, "a" e "b". Quando viene chiamata,
# la funzione restituisce la somma dei due parametri.

# Per utilizzare il valore restituito da una funzione, si può assegnare il risultato a una
# variabile.

# Esempio:
risultato = somma(10, 20)
print(risultato)

# Output:
# 30

# È possibile restituire più valori da una funzione separandoli con una virgola.

# Esempio:
def divisione_e_resto(dividendo, divisore):
    quoziente = dividendo // divisore  # Questo operatore restituisce la parte intera della divisione
    resto = dividendo % divisore  # Questo operatore restituisce il resto della divisione
    return quoziente, resto

# Questa funzione si chiama "divisione_e_resto" e ha due parametri, "dividendo" e "divisore".
# Quando viene chiamata, la funzione restituisce il quoziente e il resto della divisione tra
# i due parametri.

# Per utilizzare i valori restituiti da una funzione, si possono assegnare a due variabili.

# Esempio:
q, r = divisione_e_resto(10, 3)
print(q)
print(r)

# Output:
# 3
# 1


# ---==== PAROLA CHIAVE yield ====---

# La parola chiave yield è simile a return, ma restituisce un generatore. Un generatore
# è un oggetto iterabile che può essere utilizzato in un ciclo for. I generatori sono
# utili quando si devono generare grandi quantità di dati, perché non richiedono di
# memorizzare tutti i dati in memoria.

# Esempio:
def numeri_pari(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

# Questa funzione si chiama "numeri_pari" e ha un parametro "n". Quando viene chiamata,
# la funzione restituisce un generatore che genera i numeri pari da 0 a n-1.

# Per utilizzare i valori generati da un generatore, si può utilizzare un ciclo for.

# Esempio:
for numero in numeri_pari(10):
    print(numero)

# Output:
# 0
# 2
# 4
# ...

# ---==== TIPAGGIO DELLE FUNZIONI ====---

# Le funzioni in Python sono dinamiche, cioè non richiedono di specificare il tipo dei
# parametri e del valore di ritorno. Questo significa che una funzione può essere chiamata
# con argomenti di qualsiasi tipo e restituire valori di qualsiasi tipo.

# Tuttavia, è possibile specificare il tipo dei parametri e del valore di ritorno utilizzando
# le "type hints". Le type hints sono delle annotazioni che vengono scritte dopo i due punti
# e che specificano il tipo di una variabile o di un valore di ritorno.

# Esempio:
def somma(a: int, b: int) -> int:
    return a + b

# Questa funzione si chiama "somma" e ha due parametri, "a" e "b", di tipo int. Il valore di
# ritorno della funzione è di tipo int.

# Le type hints non influenzano il funzionamento delle funzioni, ma sono utili per rendere
# più chiara la documentazione del codice e per aiutare l'IDE a fornire suggerimenti durante
# la scrittura del codice.

# Abbiamo già visto in passato che le funzioni restituiscono SEMPRE un valore, anche se non
# è presente nessun return statement. In questo caso, la funzione restituisce None (NoneType).

# --= UTILIZZO DELLO STATEMENT return =--

# Lo statement return termina l'esecuzione della funzione e restituisce il valore specificato.
# Se una funzione ha più di uno statement return, solo il primo
# statement return viene eseguito. Gli statement return successivi vengono ignorati.

# Esempio:
def funzione():
    print("Prima del return")
    return 10
    print("Dopo il return")

risultato = funzione()
print(risultato)

# Output:
# Prima del return
# 10

# In questo esempio, la funzione restituisce il valore 10 e termina l'esecuzione. Lo statement
# print("Dopo il return") non viene eseguito.

# Il return, in questo modo, può essere utilizzato per far ritornare dalla funzione valori
# diversi a seconda di condizioni.

# Esempio:
def massimo(a, b):
    if a > b:
        return a
    else:
        return b

risultato = massimo(10, 20)
print(risultato)

# Output:
# 20

# In questo esempio, la funzione restituisce il valore maggiore tra i due parametri.

# ---==== FUNZIONI RICORSIVE ====---

### N.B.: Questo sotto-argomento è particolarmente complesso, quindi probabilmente
###       ci torneremo in futuro per approfondirlo meglio.

# Una funzione può richiamare se stessa. Questo tipo di funzioni sono chiamate "funzioni
# ricorsive". Le funzioni ricorsive sono utili per risolvere problemi che possono essere
# suddivisi in sottoproblemi più piccoli.

# Esempio:
def fattoriale(n):
    if n == 0:
        return 1
    else:
        return n * fattoriale(n - 1)
    
risultato = fattoriale(5)
print(risultato)

# Output:
# 120

# In questo esempio, la funzione "fattoriale" calcola il fattoriale di un numero n. Se n è
# uguale a 0, la funzione restituisce 1. Altrimenti, la funzione restituisce n moltiplicato
# per il fattoriale di n-1.

# Le funzioni ricorsive devono avere una condizione di uscita, cioè un caso base che termina
# la ricorsione. Senza una condizione di uscita, la funzione andrebbe in loop infinito.

# ---==== RIASSUNTO ====---

# - Le funzioni sono blocchi di codice che eseguono un compito specifico.
# - Le funzioni sono utili per suddividere il codice in blocchi più piccoli e più facili
#   da gestire.
# - Le funzioni permettono di riutilizzare il codice, in quanto possono essere richiamate
#   più volte.
# - Per definire una funzione si utilizza la parola chiave def seguita dal nome della
#   funzione e tra parentesi tonde i parametri della funzione.
# - I parametri sono variabili che vengono passate alla funzione e che possono essere
#   utilizzate all'interno del blocco di istruzioni.
# - I parametri sono opzionali, cioè una funzione può non avere parametri.
# - Per chiamare una funzione si scrive il nome della funzione seguito da parentesi tonde.
# - Le funzioni possono restituire un valore. Per farlo, si utilizza la parola chiave
#   return seguita dall'espressione che si vuole restituire.
# - È possibile restituire più valori da una funzione separandoli con una virgola.
# - La parola chiave yield restituisce un generatore, che è un oggetto iterabile che può
#   essere utilizzato in un ciclo for.
# - Le type hints sono delle annotazioni che specificano il tipo dei parametri e del valore
#   di ritorno di una funzione. Le type hints non influenzano il funzionamento delle funzioni,
#   ma sono utili per rendere più chiara la documentazione del codice e per aiutare l'IDE a
#   fornire suggerimenti durante la scrittura del codice.
# - Lo statement return termina l'esecuzione della funzione e restituisce il valore specificato.
# - Se una funzione ha più di uno statement return, solo il primo statement return viene eseguito.
# - Le funzioni ricorsive sono funzioni che richiamano se stesse. Le funzioni ricorsive sono
#   utili per risolvere problemi che possono essere suddivisi in sottoproblemi più piccoli.
# - Le funzioni ricorsive devono avere una condizione di uscita, cioè un caso base che termina
#   la ricorsione.

lez15_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 15 - Esercizio 1 - Lista ordinata
# Scrivere un programma che generi una sequenza di 20 valori interi casuali compresi
# tra 0 e 99, poi visualizzi la sequenza generata, la ordini e la visualizzi di
# nuovo, ordinata. Usate la funzione sorted.

import random

lista = []
for _ in range(20):
    lista.append(random.randint(0, 99))

print(lista)

lista_ordinata = sorted(lista)

print(lista_ordinata)

lez14_es01.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 14 - Esercizio 1 - Il gioco di Nim

# In questo gioco, due giocatori prelevano alternativamente biglie da un mucchietto.
# Ad ogni mossa, un giocatore sceglie quante biglie prendere: almeno una e al
# massimo metà delle biglie disponibili. Il giocatore che prende l’ultima biglia
# perde la partita.

# Scrivere un programma che consenta all’utente di giocare contro il computer.
# Il programma deve:
# - generare un numero intero casuale compreso tra 10 e 100 da usare come dimensione
#   iniziale del mucchietto di biglie;
# - generare un numero intero casuale, o 0 o 1, da usare per decidere se sarà
#   l’utente o il computer a giocare per primo;
# - generare un numero intero casuale, o 0 o 1, da usare per decidere se il computer
#   giocherà in modo intelligente o stupido:
#    * giocando in modo stupido, ad ogni sua mossa il computer semplicemente preleva
#      dal mucchietto un numero di biglie casuale (ma valido, cioè compreso tra 1 e
#      n/2, se nel mucchietto sono rimaste n biglie);
#    * giocando in modalità intelligente, invece, preleva un numero di biglie tale
#      che il numero di quelle che rimangono nel mucchio sia una potenza di due
#      diminuita di un’unità, cioè 3, 7, 15, 31 o 63. Quest’ultima è sempre una mossa
#      valida, tranne quando la dimensione del mucchio è uguale a una potenza di due
#      diminuita di un’unità. In tal caso, il computer fa una mossa scelta a caso
#      (ovviamente tra quelle valide).

# Come potrete verificare sperimentalmente, il computer non può essere battuto quando
# gioca in modalità intelligente e fa la prima mossa, a meno che la dimensione
# iniziale del mucchio non sia 15, 31 o 63. Analogamente, un giocatore umano che faccia
# la prima mossa e conosca la strategia qui descritta è in grado di battere il calcolatore.

import random
import time

mucchietto = random.randint(10, 100)

print("Benveuro nel gioco di Nim!")
print(f"In questo gioco, l'obiettivo è far pescare al tuo avversario l'ultima biglia\npescandone una certa quantità a testa ogni turno, a partire da un\nmucchietto di {mucchietto} biglie.")

modalita_computer = random.randint(0, 1)

DIFFICOLTA = ['STUPIDO', 'INTELLIGENTE']

print(f'\nGiocherai contro il computer in difficoltà: {DIFFICOLTA[modalita_computer]}')

turno = random.randint(0, 1)

if turno == 0:
    print("Inizi tu a giocare!")
else:
    print("Inizia a giocare il computer!")

POTENZE_MENO_UNO = [3, 7, 15, 31, 63]

print("Il gioco inizia tra 3 secondi")
time.sleep(3)

while mucchietto > 1:
    if turno == 0:
        print(f"\n\nTocca a te.\nNel mucchietto ci sono {mucchietto} biglie.")
        mosse_valide = list(range(1, (mucchietto // 2) + (1 if mucchietto % 2 == 0 else 2)))
        mossa_utente = 0
        while mossa_utente not in mosse_valide:
            mossa_utente = int(input(f"Quante biglie vuoi prendere? La scelta è tra le seguenti:\n{mosse_valide}"))
        
        mucchietto -= mossa_utente
        turno = 1
    else:
        print(f"\n\nTocca al computer.\nNel mucchietto ci sono {mucchietto} biglie.")
        print("Il computer sta pensando...")
        time.sleep(1)
        if DIFFICOLTA[modalita_computer] == "STUPIDO":
                mossa_computer = random.randint(1, (mucchietto // 2) + (0 if mucchietto % 2 == 0 else 1))
        else:
            mossa_computer = -1
            for potenza in POTENZE_MENO_UNO[::-1]:
                print(f"Potenza: {potenza}")
                for possibile_scelta in list(range(1, (mucchietto // 2) + (1 if mucchietto % 2 == 0 else 2)))[::-1]:
                    print(f"Possibile scelta: {possibile_scelta}")
                    if mucchietto - possibile_scelta == potenza:
                        mossa_computer = possibile_scelta
                        break
                if mossa_computer != -1:
                    break
            if mossa_computer == -1:
                print("\nLa modalità intelligente non ha trovato alcuna scelta intelligente. Il computer sceglierà casualmente.")
                mossa_computer = random.randint(1, (mucchietto // 2) + (0 if mucchietto % 2 == 0 else 1))
            
        print(f"Il computer prende {mossa_computer} biglie.")
        mucchietto -= mossa_computer
        turno = 0

if turno == 0:
    print("Sei costretto a prendere l'ultima biglia. Hai perso!")
else:
    print("Il computer ha preso l'ultima biglia. Hai vinto!")

    # Nicolò puzza

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 14 - Esercizio 1 - Il gioco di Nim

# In questo gioco, due giocatori prelevano alternativamente biglie da un mucchietto.
# Ad ogni mossa, un giocatore sceglie quante biglie prendere: almeno una e al
# massimo metà delle biglie disponibili. Il giocatore che prende l’ultima biglia
# perde la partita.

# Scrivere un programma che consenta all’utente di giocare contro il computer.
# Il programma deve:
# - generare un numero intero casuale compreso tra 10 e 100 da usare come dimensione
#   iniziale del mucchietto di biglie;
# - generare un numero intero casuale, o 0 o 1, da usare per decidere se sarà
#   l’utente o il computer a giocare per primo;
# - generare un numero intero casuale, o 0 o 1, da usare per decidere se il computer
#   giocherà in modo intelligente o stupido:
#    * giocando in modo stupido, ad ogni sua mossa il computer semplicemente preleva
#      dal mucchietto un numero di biglie casuale (ma valido, cioè compreso tra 1 e
#      n/2, se nel mucchietto sono rimaste n biglie);
#    * giocando in modalità intelligente, invece, preleva un numero di biglie tale
#      che il numero di quelle che rimangono nel mucchio sia una potenza di due
#      diminuita di un’unità, cioè 3, 7, 15, 31 o 63. Quest’ultima è sempre una mossa
#      valida, tranne quando la dimensione del mucchio è uguale a una potenza di due
#      diminuita di un’unità. In tal caso, il computer fa una mossa scelta a caso
#      (ovviamente tra quelle valide).

# Come potrete verificare sperimentalmente, il computer non può essere battuto quando
# gioca in modalità intelligente e fa la prima mossa, a meno che la dimensione
# iniziale del mucchio non sia 15, 31 o 63. Analogamente, un giocatore umano che faccia
# la prima mossa e conosca la strategia qui descritta è in grado di battere il calcolatore.



# import random
# import time

# inizio_utente = False
# computer_int = False
# primo_turno = True
# turno_utente = False
# turno_computer = False

# numero_biglie_tot = random.randint(10, 100)

# primo_turno = random.randint(0, 1)
# if primo_turno == 0:
#     inizio_utente = True
#     turno_utente = True
# else:
#     turno_computer = True

# intelligenza_pc = random.randint(0, 1)
# if intelligenza_pc == 0:
#     computer_int = True

# numero_biglie = numero_biglie_tot

# print("Benvenuto al gioco di Nim! \nIn questo gioco sfiderai il computer e dovrai estrarre delle biglie da un sacchetto. \nPerde chi estrae l'ultima biglia.")
# print("REGOLE DEL GIOCO: \n -Si gioca a turni, una volta tu e una il computer; \n -Puoi pescare massimo la metà delle biglie disponibili.")
# print(f"Il sacchetto presenta {numero_biglie_tot} biglie. \nBuona fortuna!")

# while True:
    
#     if turno_utente:
        
#         if numero_biglie == 1:
#                 print("Hai pescato l'ultima biglia, hai perso!")
#                 break
        
#         if primo_turno:
#             print("Inizierai tu!")
#             primo_turno = False
#         else:
#             print("Tocca a te.")

#         while True:            
#             print(f"Biglie presenti nel sacchetto: {numero_biglie}, puoi prelevare massimo {numero_biglie//2}.")
#             numero_estrarre = int(input(f"Scegli quante biglie vuoi prelevare: "))
            
#             if numero_estrarre < 0:
#                 print("Attenzione! Numero non valido, riprova!")
#                 continue
#             elif numero_estrarre > numero_biglie//2:
#                 print("Attenzione! Stai cercando di estrarre più della metà delle biglie, riprova!")
#                 continue

#             numero_biglie -= numero_estrarre
#             print(f"Hai estratto {numero_estrarre}, ora al sacchetto rimangono {numero_biglie}")

#             turno_utente = False
#             turno_computer = True
#             break
    
#     if turno_computer:
#         if numero_biglie == 1:
#             print("Il computer ha pescato l'ultima biglia, hai vinto!")
#             break
        
#         if primo_turno:
#             print("Inizierà il computer")
#             primo_turno = False
#         else:
#             print("Tocca al computer.")

#         if computer_int:
#             pass
            
#             if numero_biglie in [3, 7, 15, 63]:
#                 numero_estrarre = random.randint(1, numero_biglie//2)
#                 print(f"Il computer estrae {numero_estrarre} biglie.")
#                 numero_biglie -= numero_estrarre
#                 print(f"Nel sacchetto rimangono {numero_biglie} biglie.")
#             else:
#                 pass

#         else:
#             numero_estrarre = random.randint(1, numero_biglie//2)
#             print(f"Il computer estrae {numero_estrarre} biglie.")
#             numero_biglie -= numero_estrarre
#             print(f"Nel sacchetto rimangono {numero_biglie} biglie.")
        
#         turno_computer = False
#         turno_utente = True

#------------------------------------------------------------------------------------------------------------

# Lezione 14 - Esercizio 2 - Lista ordinata
# Scrivere un programma che generi una sequenza di 20 valori interi casuali compresi
# tra 0 e 99, poi visualizzi la sequenza generata, la ordini e la visualizzi di
# nuovo, ordinata. Usate la funzione sorted.

#-------------------------------------------------------------------------------------------------------------

# Lezione 14 - Esercizio 3 - Somma senza il minimo
# Scrivere la funzione sum_without_smallest(v) che calcoli la somma di tutti i
# valori di una lista v, escludendo il valore minimo.

#------------------------------------------------------------------------------------------------------------------

# Lezione 14 - Esercizio 4 - Media
# Scrivi un programma in Python che calcoli la media di tutti i numeri in una lista e
# poi sottragga questa media da ogni elemento della lista. Questo metodo è utile per
# "normalizzare" i dati, rendendoli più confrontabili.

#---------------------------------------------------------------------------------------------------------------------

# Lezione 14 - Esercizio 5 - Vocali
# Scrivi una funzione elabora_parole che, data una lista di parole, calcola e
# restituisce la lunghezza di ciascuna parola e il numero di vocali in essa contenute.

#-------------------------------------------------------------------------------------------------------------------------

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 14 - Esercizio 1 - Il gioco di Nim

# In questo gioco, due giocatori prelevano alternativamente biglie da un mucchietto.
# Ad ogni mossa, un giocatore sceglie quante biglie prendere: almeno una e al
# massimo metà delle biglie disponibili. Il giocatore che prende l’ultima biglia
# perde la partita.

# Scrivere un programma che consenta all’utente di giocare contro il computer.
# Il programma deve:
# - generare un numero intero casuale compreso tra 10 e 100 da usare come dimensione
#   iniziale del mucchietto di biglie;
# - generare un numero intero casuale, o 0 o 1, da usare per decidere se sarà
#   l’utente o il computer a giocare per primo;
# - generare un numero intero casuale, o 0 o 1, da usare per decidere se il computer
#   giocherà in modo intelligente o stupido:
#    * giocando in modo stupido, ad ogni sua mossa il computer semplicemente preleva
#      dal mucchietto un numero di biglie casuale (ma valido, cioè compreso tra 1 e
#      n/2, se nel mucchietto sono rimaste n biglie);
#    * giocando in modalità intelligente, invece, preleva un numero di biglie tale
#      che il numero di quelle che rimangono nel mucchio sia una potenza di due
#      diminuita di un’unità, cioè 3, 7, 15, 31 o 63. Quest’ultima è sempre una mossa
#      valida, tranne quando la dimensione del mucchio è uguale a una potenza di due
#      diminuita di un’unità. In tal caso, il computer fa una mossa scelta a caso
#      (ovviamente tra quelle valide).

# Come potrete verificare sperimentalmente, il computer non può essere battuto quando
# gioca in modalità intelligente e fa la prima mossa, a meno che la dimensione
# iniziale del mucchio non sia 15, 31 o 63. Analogamente, un giocatore umano che faccia
# la prima mossa e conosca la strategia qui descritta è in grado di battere il calcolatore.

import random
numero_iniziale_biglie = int(random.randint(10,100))
print("il mucchietto di biglie iniziale sarà pari ad", numero_iniziale_biglie)

modalità = random.randint(0,1)

if modalità == 1:
    print("il gioco gioca in modalità stupida")
else:
    print("Il gioco gioca in modalità intelligente")

turno = random.randint(0,1)

while numero_iniziale_biglie > 1:
    if turno == 0:
        print(f"Ci sono {numero_iniziale_biglie} biglie. Tocca al computer.")
        biglie = random.randint(0, numero_iniziale_biglie // 2)
        numero_iniziale_biglie = numero_iniziale_biglie - biglie
        turno = 1
    else:
        print("il turno è del giocatore")
        print(f"Ci sono {numero_iniziale_biglie} biglie. Tocca a te.")

        biglie = -1
        while not (0 < biglie <= numero_iniziale_biglie // 2):
            biglie = int(input("quante biglie vuoi prendere considerando che deve essere comprese tra 1 e n/2?"))

        numero_iniziale_biglie -= biglie
        print("ti sono rimaste", numero_iniziale_biglie, "biglie")
        turno = 0

if turno == 1:
    print("Sei costretto a prendere l'ultima biglia. Hai perso!")
else:
    print("Il computer ha preso l'ultima biglia. Hai vinto!")
    






#     biglie_da_prelevare = random.randint(1,50)
#     biglieprelevate = int(biglie_da_prelevare / 2)
#     for biglie_da_prelevare in numero_iniziale_biglie:
#         biglierimaste = numero_iniziale_biglie - biglieprelevate
#         if biglierimaste < biglie_da_prelevare:
#             print("numero di biglie da prelevare impossibile, riprovare")
#         else:
#             print("le biglie da prelevare sono:", biglie_da_prelevare , "e le biglie rimanenti sono", biglierimaste)
# if modalità == 0:



# IL GIOCO VA AVANTI FINCHÈ CI SONO ANCORA BIGLIE DA PESCARE
# SE È IL TUO TURNO
#  - SI CHIEDE ALL'UTENTE QUANTE BIGLIE VUOLE PESCARE
#  - SI VERIFICA SE LA SCELTA DELL'UTENTE È VALIDA IN BASE ALLE REGOLE DEL GIOCO
#  - SI FINALIZZA LA SCELTA MODIFICANDO IL NUMERO DI BIGLIE PRESENTI
#  - SI CAMBIA IL TURNO
# ALTRIMENTI, SE È IL TURNO DEL COMPUTER
#  - SE IL COMPUTER GIOCA IN MODALITA' STUPIDA:
#     * SI IMPOSTA LA SCELTA DI BIGLIE DA PESCARE DEL COMPUTER RANDOMICAMENTE
#     * SI FINALIZZA LA SCELTA MODIFICANDO IL NUMERO DI BIGLIE
#     * SI CAMBIA IL TURNOù
#  - ALTRIMENTI, SE IL COMPUTER GIOCA IN MODALITA' INTELLIGENTE:
#     * DEVO CAPIRLO ANCORA PURE IO

lez13_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 13 - Esercizio 1
# Scrivere un programma che legga una sequenza di numeri interi (la sequenza
# termina quando decidete voi) e che, dopo ogni nuova acquisizione, calcoli
# e visualizzi:
# 1) le somme parziali di tutti i numeri acquisiti:
#    il programma deve visualizzare il risultato dei calcoli dopo ogni
#    nuova acquisizione.
#    (Se, ad esempio, i valori in ingresso sono 1 7 2 9, il programma
#     visualizzerà la somma parziale dei numeri acquisiti dopo ogni acquisizione:
#      - alla prima acquisizione (1), il primo valore acquisito: 1;
#      - alla seconda acquisizione (7), la somma tra la prima e la
#        seconda acquisizione: 1 + 7 = 8;
#      - alla terza acquisizione (2), la somma tra la prima, la seconda
#        e la terza acquisizione: 1 + 7 + 2 = 10;
#      - alla quarta acquisizione (9), la somma tra la prima, la seconda,
#        la terza e la quarta acquisizione: 1 + 7 + 2 + 9 = 19.
# 2) il valore minimo e il valore massimo tra quelli acquisiti;
# 3) il numero di valori pari e il numero di valori dispari tra quelli acquisiti.

lista_di_numeri = []
numeri_pari = 0
numeri_dispari = 0
while True:
    numero = input("Inserisci un numero intero (oppure scrivi 'esci' per terminare l'acquisizione): ")
    if numero == "esci":
        break
    numero = int(numero)
    lista_di_numeri.append(numero)

    print(f"Somma parziale:\n{sum(lista_di_numeri)}")

    print(f"Val. minimo: {min(lista_di_numeri)}")
    print(f"Val. massimo: {max(lista_di_numeri)}")
    
    if numero % 2 == 0:
        numeri_pari += 1
    else:
        numeri_dispari += 1
    
    print(f"Numeri pari: {numeri_pari}")
    print(f"Numeri dispari: {numeri_dispari}")

print("Arrivederci")

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 1
# Creare una lista di numeri da 1 a 10.
# Utilizzare un ciclo for per stampare ogni numero della lista.
# Se il numero è pari, stampare anche "Numero pari" accanto al numero.

# for numero in range(1, 11):

#     if numero % 2 == 0:
#         print(f"{numero} - Numero pari")
#     else:
#         print(numero)


# Lezione 12 - Esercizio 2
# Creare una lista di nomi (ad esempio ['Ambrogio', 'Biero', 'Castrogiovanni', 'Deltoidus']).
# Utilizzare un ciclo for per stampare ogni nome, ma solo se esso contiene la lettera 'a'.
# Se il nome contiene la lettera 'a' più di una volta, stampare anche "Contiene più di una 'a'".

# nomi = ["Yasmine", "Davide", "Nicolò", "Francesca", "Ulderico", "Allora"]

# for nome in nomi:
#     if "a" in nome or "A" in nome:
#         nome_minuscolo = nome.lower()
#         if nome_minuscolo.count("a") > 1:
#             print(f'Il nome {nome}, contiene più di una "a"')
#         else:
#             print(nome)


# Lezione 12 - Esercizio 3
# Scorrere una lista di numeri interi da 1 a 50.
# Utilizzare un ciclo for per stampare solo i numeri pari.
# Se il numero è divisibile anche per 10, stampare un messaggio aggiuntivo, ad esempio "Divisibile per 10: ".
# Se il numero è maggiore di 30, interrompere il ciclo utilizzando break.

# for numero in range(1, 51):
#     if numero > 30:
#         break
    
#     elif numero % 2 == 0:
#         if numero % 10 == 0:
#             print(f"Il numero {numero} è pari e divisibile per 10.")
#         else:
#             print(numero)
    
# Lezione 12 - Esercizio 4
# Chiedere all'utente di inserire una lista di parole, separate da
# virgola (ad esempio: "gatto,cane,pesce") [ATTENZIONE: solo separate
# da virgola e non da spazi]. Utilizzare il metodo split() per dividere
# la stringa in parole e iterare sulle parole con un ciclo for.
# Stampare ogni parola in maiuscolo e, se la parola contiene la lettera
# 'e', stampare anche un messaggio "Contiene la lettera 'e': ".
# Se l'utente inserisce una parola vuota (doppia virgola),
# saltare quella parola utilizzando continue.

# parole = input("Insersci una sequenza di parole, separate SOLAMENTE da una virgola (non da spazi): ")

# lista_parole = parole.split(",")

# for parola in lista_parole:
#     if parola == "":
#         print("Cazzo inserisci le parole vuote! IDIOTA")
#         continue

#     print(parola.upper())
    
#     if "e" in parola.lower():
#         print(f'Contiene la lettera "e": {parola}')



# Lezione 13 - Esercizio 1
# Scrivere un programma che legga una sequenza di numeri interi (la sequenza
# termina quando decidete voi) e che, dopo ogni nuova acquisizione, calcoli
# e visualizzi:

# 1) le somme parziali di tutti i numeri acquisiti:
#    il programma deve visualizzare il risultato dei calcoli dopo ogni
#    nuova acquisizione.
#    (Se, ad esempio, i valori in ingresso sono 1 7 2 9, il programma
#     visualizzerà la somma parziale dei numeri acquisiti dopo ogni acquisizione:
#      - alla prima acquisizione (1), il primo valore acquisito: 1;
#      - alla seconda acquisizione (7), la somma tra la prima e la
#        seconda acquisizione: 1 + 7 = 8;
#      - alla terza acquisizione (2), la somma tra la prima, la seconda
#        e la terza acquisizione: 1 + 7 + 2 = 10;
#      - alla quarta acquisizione (9), la somma tra la prima, la seconda,
#        la terza e la quarta acquisizione: 1 + 7 + 2 + 9 = 19.
# 2) il valore minimo e il valore massimo tra quelli acquisiti;
# 3) il numero di valori pari e il numero di valori dispari tra quelli acquisiti.
somma = 0
min = None
max = None
numeri_pari = 0
numeri_dispari = 0

while True:
    numero = input("Insersisci un numero intero oppure lascia vuoto per terminare.")

    if numero == "":
        break
    
    numero = int(numero)
    somma += numero
    print(f"La somma parziale è {somma}.")

    if max is None:
        max = numero
    elif numero > max:
        max = numero
    
    print(f"Il numero massimo è: {max}.")

    if min is None:
        min = numero
    elif numero < min:
        min = numero
        
    print(f"Il numero minimo è: {min}.")

    if numero % 2 == 0:
        numeri_pari += 1
    else:
        numeri_dispari += 1

    print(f"Sono stati inseriti {numeri_pari} numeri pari.")
    print(f"Sono stati inseriti {numeri_dispari} numeri dispari.")

print("ADDIO!")




    

lez11_es05.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 5
# Chiedere all'utente di inserire una frase con almeno due parole.
# Utilizzare il metodo split() per dividere la frase in parole, quindi concatenare le parole usando il metodo join(),
# separandole con un trattino (-). Se la frase contiene la parola "gianfrancesco" (case insensitive),
# sostituirla con "Giangiovanni" prima di concatenare.
# Stampare la stringa risultante.

frase = input("Inserisci una frase di ALMENO due parole: ")

parole = frase.split(" ")

if len(parole) < 2:
    print("Dovevano essere ALMENO due parole.")
    exit(0)

# parole = ['ciao', 'gianfrancesco', 'buonasera']
# enumerate(parole) = [(0, 'ciao'), (1, 'gianfrancesco'), (2, 'buonasera')]
for indice, parola in enumerate(parole):
    if parola.lower() == "gianfrancesco":
        parole[indice] = "Giangiovanni"

frase_concatenata = "-".join(parole)

print(frase_concatenata)

lez12_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 1
# Creare una lista di numeri da 1 a 10.
# Utilizzare un ciclo for per stampare ogni numero della lista.
# Se il numero è pari, stampare anche "Numero pari" accanto al numero.

for i in range(1, 11):
    stringa_output = str(i)
    if i % 2 == 0:
        stringa_output += " - Numero pari"
    print(stringa_output)

 

lez11_es06.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 6
# Chiedere all'utente di inserire un URL (ad esempio "https://www.example.com/page").
# Utilizzare il metodo split() per dividere l'URL in parti e stampare ogni parte su una nuova riga.
# Successivamente, chiedere all'utente se desidera visualizzare il dominio o il percorso.
# Stampare la parte richiesta (ad esempio "www.example.com" o "/page").

# Chiediamo all'utente di inserire un URL e inseriamolo in una variabile URL
URL = input("Inserisci un URL: ")

# Effettuiamo lo split della stringa URL attraverso il separatore /
pezzi_di_url = URL.split("/")

print(pezzi_di_url)

# Siccome l'URL è formato da un inizio generalmente simile a "https://",
# il metodo split inserirebbe nella lista risultante un elemento che è
# una stringa vuota "" rappresentante lo spazio tra i due slash.
# Visto che non ci interessa e che questo elemento si trova sempre all'indice
# 1, lo possiamo rimuovere
pezzi_di_url.remove("")

# Usiamo un for per stampare tutti gli elementi della lista pezzi_di_url
# uno sotto l'altro
for pezzetto in pezzi_di_url:
    print(pezzetto)

# Chiediamo all'utente cosa vuole visualizzare di preciso
scelta = input("Utentozzo, vuoi visualizzare il dominio o il percorso? (d/p) ").lower().strip()

# In base alla scelta dell'utente visualizziamo la parte desiderata
if scelta == "d":
    # il dominio sarà sempre quello di indice 1 (compreso tra // e il seguente /)
    print(pezzi_di_url[1])
elif scelta == "p":
    # il percorso è tutto quello che c'è dopo, ma riunito (con join) attraverso /
    print("/".join(pezzi_di_url[2:]))
else:
    print("L'opzione non è disponibile")

lez13_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 13 - Esercizio 2
# Scrivere un programma che legga un numero intero n e visualizzi,
# usando asterischi (*), un quadrato, il cui lato abbia lunghezza n.
# Se, ad esempio, l’utente fornisce il numero 4, il programma deve visualizzare:
# ****
# ****
# ****
# ****

n = int(input("Inserisci la lunghezza del lato: "))

for i in range(n):
    print("*" * n)
    


#     # Esercizio 04.1.3
# # Lati

# #  Display a square and a diamond with a side length supplied by the user.
# #

# # Read the side length from the user.
# side_length = int(input("Enter the side length: "))

# # Display the square
# for y in range(0, side_length):
#     print('*' * side_length)
# print()

# Display the diamond.
for y in range(1, n):
    print(" " * (n - y) + "*" * (y * 2 - 1))
for y in range(n, 0, -1):
    print(" " * (n - y) + "*" * (y * 2 - 1))

lez12_es04.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 4
# Chiedere all'utente di inserire una lista di parole, separate da
# virgola (ad esempio: "gatto,cane,pesce") [ATTENZIONE: solo separate
# da virgola e non da spazi]. Utilizzare il metodo split() per dividere
# la stringa in parole e iterare sulle parole con un ciclo for.
# Stampare ogni parola in maiuscolo e, se la parola contiene la lettera
# 'e', stampare anche un messaggio "Contiene la lettera 'e': ".
# Se l'utente inserisce una parola vuota (doppia virgola),
# saltare quella parola utilizzando continue.

parole = input("Inserisci una lista di parole separate da virgole e NON da spazi: ")

lista_di_parole = parole.split(",")

for parola in lista_di_parole:
    if parola == "":
        continue
    print(parola.upper())
    if 'e' in parola.lower():
        print(f"Contiene la lettera 'e': {parola}")

lez12_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 3
# Creare una lista di numeri interi da 1 a 50.
# Utilizzare un ciclo for per stampare solo i numeri pari.
# Se il numero è divisibile anche per 10, stampare un messaggio aggiuntivo, ad esempio "Divisibile per 10: ".
# Se il numero è maggiore di 30, interrompere il ciclo utilizzando break.

for i in range(1, 51):
    if i % 2 == 0:
        print(i)
        if i % 10 == 0:
            print(f"Divisibile per 10: {i}")
    
    if i > 30:
        break

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 5
# Chiedere all'utente di inserire una frase con almeno due parole.
# Utilizzare il metodo split() per dividere la frase in parole, quindi concatenare le parole usando il metodo join(),
# separandole con un trattino (-). Se la frase contiene la parola "gianfrancesco" (case insensitive),
# sostituirla con "Giangiovanni" prima di concatenare.
# Stampare la stringa risultante.

# frase = input("inserisci una frase con almeno due parole")
# parole = frase.split(" ")
# print(parole)
# concatenazione = "-".join(parole)
# print(concatenazione)

# for parola in parole:
#     print(parola)
#     if parola == "gianfrancesco":
#         parola = "Giangiovanni"
# print(frase)

# Lezione 12 - Esercizio 1
# Creare una lista di numeri da 1 a 10.
# Utilizzare un ciclo for per stampare ogni numero della lista.
# Se il numero è pari, stampare anche "Numero pari" accanto al numero.

# lista = []
# for numero in range(1,11):
#     if numero % 2 == 0:
#         print(numero, "è un numero pari")
#     else:
#         print(numero)
    

# Lezione 12 - Esercizio 2
# Creare una lista di nomi (ad esempio ['Ambrogio', 'Biero', 'Castrogiovanni', 'Deltoidus']).
# Utilizzare un ciclo for per stampare ogni nome, ma solo se esso contiene la lettera 'a'.
# Se il nome contiene la lettera 'a' più di una volta, stampare anche "Contiene più di una 'a'".

# lista = ['Ambrogio', 'Biero', 'Castrogiovanni', 'Deltoidus', 'Alessandra']
# for name in lista:
#     if "a" in name.lower():
#         print(name)
#         if name.lower().count("a") > 1:
#             print("il nome", name, "ha piu di una a")
        
# Lezione 12 - Esercizio 3
# Scorrere una lista di numeri interi da 1 a 50.
# Utilizzare un ciclo for per stampare solo i numeri pari.
# Se il numero è divisibile anche per 10, stampare un messaggio aggiuntivo, ad esempio "Divisibile per 10: ".
# Se il numero è maggiore di 30, interrompere il ciclo utilizzando break.

# for numero in range(1,51):
#     if numero % 2 == 0:
#         print(numero)
#         if numero % 10 == 0:
#             print("divisibile per 10:", numero)
    
#     if numero > 30:
#         print("scemo")
#         break

# Lezione 12 - Esercizio 4
# Chiedere all'utente di inserire una lista di parole, separate da
# virgola (ad esempio: "gatto,cane,pesce") [ATTENZIONE: solo separate
# da virgola e non da spazi]. Utilizzare il metodo split() per dividere
# la stringa in parole e iterare sulle parole con un ciclo for.
# Stampare ogni parola in maiuscolo e, se la parola contiene la lettera
# 'e', stampare anche un messaggio "Contiene la lettera 'e': ".
# Se l'utente inserisce una parola vuota (doppia virgola),
# saltare quella parola utilizzando continue.

lista = input("Inserisci una lista inserendo le virgole tra le parole")
parole = lista.split(",")

print(parole)

for parola in parole:
    if parola == "":
        continue
    print(parola.upper())
    if "e" in parola.lower():
        print("contiene la lettera e la parola", parola)
    

# Nicolo puzza ed è stato scritto da davide

lez12_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 2
# Creare una lista di nomi (ad esempio ['Ambrogio', 'Biero', 'Castrogiovanni', 'Deltoidus']).
# Utilizzare un ciclo for per stampare ogni nome, ma solo se esso contiene la lettera 'a'.
# Se il nome contiene la lettera 'a' più di una volta, stampare anche "Contiene più di una 'a'".

lista_di_nomi = ["Ambrogio", "Biero", "Castrogiovanni", "Deltoidus", "IlDrugoDrago12", "Allora"]

for nome in lista_di_nomi:
    if "a" in nome.lower():
        print(nome)
        if nome.count("a") + nome.count("A") > 1:
            print("Contiene più di una 'a'")

lez12_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 1
# Creare una lista di numeri da 1 a 10.
# Utilizzare un ciclo for per stampare ogni numero della lista.
# Se il numero è pari, stampare anche "Numero pari" accanto al numero.

lez12_es04.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 4
# Chiedere all'utente di inserire una lista di parole, separate da
# virgola (ad esempio: "gatto,cane,pesce") [ATTENZIONE: solo separate
# da virgola e non da spazi]. Utilizzare il metodo split() per dividere
# la stringa in parole e iterare sulle parole con un ciclo for.
# Stampare ogni parola in maiuscolo e, se la parola contiene la lettera
# 'e', stampare anche un messaggio "Contiene la lettera 'e': ".
# Se l'utente inserisce una parola vuota (doppia virgola),
# saltare quella parola utilizzando continue.

lez12_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 3
# Creare una lista di numeri interi da 1 a 50.
# Utilizzare un ciclo for per stampare solo i numeri pari.
# Se il numero è divisibile anche per 10, stampare un messaggio aggiuntivo, ad esempio "Divisibile per 10: ".
# Se il numero è maggiore di 30, interrompere il ciclo utilizzando break.

teoria.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Il ciclo for

# ---==== IL CICLO FOR ====---

# Sintassi:
# for elemento in lista:
#    # Blocco di istruzioni

# Il for è un ciclo come il while, ma è più adatto per scorrere gli elementi di una lista.
# La differenza sostanziale tra i due cicli è che il ciclo for è più semplice da utilizzare
# quando si deve scorrere una sequenza di elementi, come ad esempio una lista. Ma, soprattutto,
# il ciclo for non utilizza una condizione booleana per determinare il numero di iterazioni,
# bensì scorre tutti gli elementi della lista.

# Per essere precisi, il ciclo for scorre tutti gli elementi di un oggetto iterabile, non
# necessariamente una lista. Un oggetto iterabile è un oggetto su cui è possibile iterare,
# cioè scorrere tutti gli elementi. Ad esempio, oltre alle liste, anche le stringhe sono
# oggetti iterabili.

# Esempio:
lista = [10, 20, 30, 40, 50]
for elemento in lista:
    print(elemento)

# Output:
# 10
# 20
# 30
# 40
# 50

# Il ciclo for scorre tutti gli elementi della lista e per ognuno di essi esegue il blocco di istruzioni.
# Per fare la stessa cosa con il ciclo while, bisognerebbe utilizzare un contatore e accedere agli elementi
# della lista tramite l'indice.

contatore = 0
while contatore < len(lista):
    print(lista[contatore])
    contatore += 1

# Output: uguale a quello del ciclo for

# Il ciclo for può essere utilizzato anche con le stringhe.
# Esempio:
stringa = "ciao"
for carattere in stringa:
    print(carattere)

# Output:
# c
# i
# a
# o

# Il ciclo for può essere utilizzato anche con lo slicing.
# Esempio:
lista = [10, 20, 30, 40, 50]
for elemento in lista[1:4]:
    print(elemento)

# Output:
# 20
# 30
# 40

# Immagino si veda immediatamente la comodità del ciclo for rispetto al while in questo caso, ma
# anche in molti altri casi. Infatti, d'ora in poi vi capiterà spesso di utilizzare il ciclo for
# al posto del while, soprattutto quando si tratta di scorrere una lista o una stringa.
# A questo punto il ciclo while diventa migliore del for solo quando si deve eseguire un blocco
# sulla base di una condizione booleana oppure quando si deve usare un while True.

# Funzione built-in range():
# La funzione range() permette di generare una SEQUENZA di numeri interi.
# La sintassi è la seguente:
# range(start, stop, step)
# - start: numero di partenza (incluso)
# - stop: numero di fine (escluso)
# - step: passo
# Quindi la sintassi è simile a quella dello slicing.

# Esempio:
numeri = range(1, 6)
print(numeri)  # Output: range(1, 6)

# La funzione range() restituisce un oggetto range, che è un oggetto iterabile. Non è una lista,
# ma può essere utilizzato in un ciclo for come se fosse una lista.
# La differenza principale tra un oggetto range e una lista è che un oggetto range non occupa spazio
# in memoria per memorizzare tutti i numeri della sequenza, ma li genera al momento del bisogno. Tutto qui.

# Esempio:
for numero in range(1, 4):
    print(numero)

# Output:
# 1
# 2
# 3

# Equivalente a:
for numero in [1, 2, 3]:
    print(numero)

# Equivalente a:
contatore = 1
while contatore < 4:
    print(contatore)
    contatore += 1

# Quando è soltanto necessario iterare un numero fisso di volte, la variabile di iterazione
# del ciclo for può essere sostituita con un underscore (_).
# Esempio:
for _ in range(3):
    print("ciao")

lez12_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 12 - Esercizio 2
# Creare una lista di nomi (ad esempio ['Ambrogio', 'Biero', 'Castrogiovanni', 'Deltoidus']).
# Utilizzare un ciclo for per stampare ogni nome, ma solo se esso contiene la lettera 'a'.
# Se il nome contiene la lettera 'a' più di una volta, stampare anche "Contiene più di una 'a'".

teoria.py (clicca per mostrare il codice) Scarica (n. download: 7)

# L11 - Le strutture dati (parte 2)

# ---==== SLICING ====---
# Il concetto di slicing è molto importante per le liste e le stringhe.
# Lo slicing permette di estrarre una porzione di una lista o di una stringa.
# La sintassi per lo slicing è la seguente:
# lista[start:stop:step]

# - start: indice di partenza dell'intervallo da estrarre (incluso)
# - stop: indice di fine dell'intervallo da estrarre (escluso)
# - step: passo dell'intervallo da estrarre

# Esempio:
#               start            stop: 7 escl
#                 |               | 
# indici: 0   1   2   3   4   5   6   7   8   9
lista = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
sottolista = lista[2:7:2]
print(sottolista)  # Output: [30, 50, 70]
# Perché? Perché si parte dall'indice 2 (incluso) e si arriva all'indice 7 (escluso) con passo 2.
#         Ovvero, si parte dall'elemento 3 (indice 2), si arriva all'elemento 7 (indice 6) ma per
#         farlo si salta un elemento ogni volta.

# Capita veramente raramente di dover usare lo step, ma è comunque utile conoscerlo.
# Se non si specifica lo step, viene considerato 1 (ovvero, si prendono tutti gli elementi).

# start e stop invece vengono usati un po' più spesso. Anche questi non sono obbligatori.
# Però c'è da considerare che se non si vogliono mettere, è comunque necessario lasciare i due punti (:)
# perché altrimenti Python non capisce che si sta facendo uno slicing e pensa che si stia cercando
# di accedere a un elemento della lista tramite il suo indice (i.e.: lista[2] invece di lista[2:]).
# Gli unici due punti che si possono omettere sono quelli finali, dopo i quali è solitamente presente lo step.
# Però anche in quel caso, dipende dal contesto: se si vogliono specificare solo lo start e lo step, è necessario
# inserire due due punti: lista[2::2].

# Se si omette lo start, viene considerato 0. Se si omette lo stop, viene considerata la lunghezza della lista.

# Esempio:
lista = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
sottolista = lista[2:7]
print(sottolista)  # Output: [30, 40, 50, 60, 70]

sottolista = lista[:7] # Si può leggere come "dall'inizio fino all'indice 7 escluso"
print(sottolista)  # Output: [10, 20, 30, 40, 50, 60, 70]

sottolista = lista[2:] # Si può leggere come "dall'indice 2 incluso fino alla fine"
print(sottolista)  # Output: [30, 40, 50, 60, 70, 80, 90, 100]

# Ovviamente il tutto funziona anche con indici negativi.
# Esempio:
sottolista = lista[-7:-2] # Si può leggere come "dall'indice -7 incluso (ovvero 40, il sett-ultimo elemento) fino all'indice -2 escluso (ovvero 90 escluso)"
print(sottolista)  # Output: [40, 50, 60, 70, 80]

sottolista = lista[-7:] # Si può leggere come "dall'indice -7 incluso (ovvero 40, il sett-ultimo elemento) fino alla fine"
print(sottolista)  # Output: [40, 50, 60, 70, 80, 90, 100]

sottolista = lista[:-2] # Si può leggere come "dall'inizio fino all'indice -2 escluso (ovvero 90 escluso)"
print(sottolista)  # Output: [10, 20, 30, 40, 50, 60, 70, 80]

# Esempio di utilizzo dello slicing per invertire una lista:
lista = [1, 2, 3, 4, 5]
lista_invertita = lista[::-1]
print(lista_invertita)  # Output: [5, 4, 3, 2, 1]
# Lo step -1 permette di scorrere la lista al contrario.
# Funziona anche con le stringhe.

# ---==== STRINGHE ====---
# Le stringhe possono essere considerate come delle liste di caratteri.
# Ciò significa che si possono utilizzare pressoché gli stessi metodi e le stesse operazioni
# delle liste anche sulle stringhe.

# Esempio la stringa "ciao" può essere considerata, nella codifica di un algoritmo, come
# una lista di caratteri ['c', 'i', 'a', 'o'].

# Accesso con indice:
stringa = "ciao"
print(stringa[0])  # Output: 'c'
print(stringa[1])  # Output: 'i'

# Modifica di un carattere:
# Le stringhe sono immutabili, cioè non possono essere modificate.
# Quindi, non è possibile modificare un singolo carattere di una stringa.
# Questo significa che il seguente codice genera un errore:
stringa[0] = 'C'  # TypeError: 'str' object does not support item assignment

# Ma è possibile creare una nuova stringa con il carattere modificato:
nuova_stringa = "C" + stringa[1:] # La notazione [1:] significa "dal carattere 1 in poi"

# Concatenazione di stringhe:
# Le stringhe possono essere concatenate utilizzando l'operatore +.
stringa1 = "ciao"
stringa2 = " mondo"
stringa3 = stringa1 + stringa2
print(stringa3)  # Output: "ciao mondo"

# Lunghezza di una stringa:
# La funzione len() può essere usata anche sulle stringhe per ottenere la loro lunghezza.
lunghezza = len(stringa)
print(lunghezza)  # Output: 4

# Esistono dei metodi delle stringhe che permettono di svolgere operazioni specifiche
# e che non sono disponibili per le liste. Ad esempio:
# - upper(): converte tutti i caratteri della stringa in maiuscolo
# - lower(): converte tutti i caratteri della stringa in minuscolo
# - capitalize(): converte il primo carattere della stringa in maiuscolo
# - title(): converte il primo carattere di ogni parola in maiuscolo
# - strip(): rimuove gli spazi bianchi all'inizio e alla fine della stringa
# - split(): divide la stringa in una lista di sottostringhe utilizzando un separatore
# - join(): unisce una lista di stringhe in una sola stringa utilizzando un separatore
# Ce ne sono molti altri, non li elenco perché una delle skill più importanti di un programmatore
# è saper cercare e trovare le informazioni di cui ha bisogno su internet.

# Esempio di utilizzo del metodo split():
stringa = "ciao mondo"
sottostringhe = stringa.split(" ")
print(sottostringhe)  # Output: ['ciao', 'mondo']
print(type(sottostringhe))  # Output: 

stringa = " buonasera a tutti, mi chiamo Bierozzo !"
stringa = stringa.strip()
print(stringa)  # Output: "buonasera a tutti, mi chiamo Bierozzo !" (senza spazi all'inizio e alla fine)
print(stringa.split(" "))  # Output: ['buonasera', 'a', 'tutti,', 'mi', 'chiamo', 'Bierozzo', '!']
print(stringa.split(","))  # Output: ['buonasera a tutti', ' mi chiamo Bierozzo !']

url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"  # "You know the rules, and so do I"
pezzi_di_url = url.split("/")
print(pezzi_di_url) # Output: ['https:', '', 'www.youtube.com', 'watch?v=dQw4w9WgXcQ']
# Questo è un esempio pratico di utilizzo di split(). Magari in un programma che, ad esempio,
# deve scaricare un video da YouTube, potrebbe essere utile dividere l'URL in pezzi per estrarre l'ID del video.
# (ovviamente, in un ipotetico programma del genere, si dovrebbe utilizzare una qualche libreria che scarica
# i video tramite ID invece che direttamente dall'URL).
# In questo modo, infatti, potremmo recuperare l'ID (ovvero "dQw4w9WgXcQ") dalla lista pezzi_di_url.
video_id = pezzi_di_url[-1].split("=")[-1]
# Perché? Perché l'ID del video è l'ultimo elemento della lista pezzi_di_url e si trova dopo il carattere "=".
#         Quindi, dividendo l'ultimo elemento della lista pezzi_di_url con split("="), otteniamo l'ID del video
#         che è l'ultimo elemento della lista risultante.

# Esempio di utilizzo del metodo join():
sottostringhe = ['ciao', 'mondo']
stringa = " ".join(sottostringhe)
print(stringa)  # Output: "ciao mondo"
# Quello che abbiamo fatto qui è applicare il metodo join() alla stringa " " (uno spazio) e passare
# come argomento la lista di sottostringhe. Il metodo join() unisce tutte le sottostringhe della lista
# in una sola stringa, separandole con il carattere su cui è stato chiamato il metodo, in questo caso uno spazio.

stringa = "...".join(sottostringhe)
print(stringa)  # Output: "ciao...mondo" 

# N.B.: Ci sono molte operazioni che si possono fare con le liste, ma non con le stringhe.
# E questo dimostra che le stringhe sono diverse dalle liste e le consideriamo simili solo
# per semplificare il processo logico di codifica di un algoritmo.

# Lo slicing funziona anche con le stringhe.
# Esempio:
stringa = "ciao mondo"
sottotringa = stringa[2:7]
print(sottotringa)  # Output: "ao mo"

lez11_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 3
# Creare una lista contenente i numeri da 1 a 30.
# Chiedere all'utente di inserire un valore per lo step da utilizzare per lo slicing.
# Se lo step è negativo, chiedere conferma all'utente se vuole davvero invertire la lista.
# Utilizzare questo valore per creare una sottolista usando uno slicing con step e stampare la sottolista risultante.

lez11_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 2
# Creare una lista di parole, ad esempio ['gatto', 'cane', 'coniglio', 'cavallo', 'leone', 'tigre'].
# Chiedere all'utente di inserire un numero intero n.
# Estrarre e stampare una sottolista che contenga solo gli elementi con indice pari E minore di n.
# Se l'indice inserito è fuori dal range della lista, stampare un messaggio di errore e richiedere un nuovo valore.

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 1
# Creare una lista di numeri interi da 1 a 20.
# Chiedere all'utente di inserire due indici: start e stop.
# Se start è maggiore di stop, scambiare i valori.
# Utilizzare questi indici per fare lo slicing della lista e stampare la sottolista risultante.

contatore = 1
lista = []
while contatore <= 20:
    lista.append(contatore)
    contatore += 1

indicestart = int(input(f"questa è la tua lista {lista} inserisci un indice start per la lista "))
indicestop = int(input(f"questa è la tua lista {lista} inserisci un indice stop per la lista "))
if indicestart > indicestop:
    indicestart, indicestop = indicestop, indicestart
    
listidina = lista[indicestart:indicestop]
print(listidina)

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 1
# Creare una lista di numeri interi da 1 a 20.
# Chiedere all'utente di inserire due indici: start e stop.
# Se start è maggiore di stop, scambiare i valori.
# Utilizzare questi indici per fare lo slicing della lista e stampare la sottolista risultante.

import time

contatore = 1
lista = []
while contatore <= 20:
    lista.append(contatore)
    contatore += 1

i = 0
print("Salve, la tua lista contiene i seguenti numeri:")
while i < len(lista):
    print(" - ", lista[i])
    i += 1
    time.sleep(0.2)

start = int(input("Inserisci l'indice da dove vuoi iniziare a creare la tua sottolista."))
stop = int(input("Inserisci l'indice dove vuoi terminare a creare la tua sottolista."))

if start > stop:
    start, stop = stop, start

slicing = lista[start:stop]

print("Fatto! La tua sottolista contiene i seguenti valori:")
i = 0
while i < len(slicing):
    print(" - ", slicing[i])
    i += 1
    time.sleep(0.2)

# ----------------------------------------------------------------------------------------------------

# Lezione 11 - Esercizio 2
# Creare una lista di parole, ad esempio ['gatto', 'cane', 'coniglio', 'cavallo', 'leone', 'tigre'].
# Chiedere all'utente di inserire un numero intero n.
# Estrarre e stampare una sottolista che contenga solo gli elementi con indice pari E minore di n.
# Se l'indice inserito è fuori dal range della lista, stampare un messaggio di errore e richiedere un nuovo valore.

# lista = ["grano", "mais", "sorgo", "colza", "avena", "triticale", "girasole"]

lez11_es04.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 4
# Chiedere all'utente di inserire una frase.
# Utilizzare il metodo split() per dividere la frase in parole e stampare la lista delle parole.
# Se la frase contiene meno di tre parole, chiedere all'utente di inserirne un'altra e ripetere il processo.

lez11_es06.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 6
# Chiedere all'utente di inserire un URL (ad esempio "https://www.example.com/page").
# Utilizzare il metodo split() per dividere l'URL in parti e stampare ogni parte su una nuova riga.
# Successivamente, chiedere all'utente se desidera estrarre il dominio o il percorso.
# Stampare la parte richiesta (ad esempio "www.example.com" o "/page").

lez11_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 1
# Creare una lista di numeri interi da 1 a 20.
# Chiedere all'utente di inserire due indici: start e stop.
# Se start è maggiore di stop, scambiare i valori.
# Utilizzare questi indici per fare lo slicing della lista e stampare la sottolista risultante.

lez11_es05.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 11 - Esercizio 5
# Chiedere all'utente di inserire una frase con almeno due parole.
# Utilizzare il metodo split() per dividere la frase in parole, quindi concatenare le parole usando il metodo join(),
# separandole con un trattino (-). Se la frase contiene la parola "gianfrancesco" (case insensitive),
# sostituirla con "Giangiovanni" prima di concatenare.
# Stampare la stringa risultante.

lez10_es07_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 7
# Creare una lista di liste con diversi elementi.
# Utilizzare un ciclo while per permettere all'utente di continuare a
# scegliere quale lista e quale elemento visualizzare, finché non decide
# di uscire inserendo un indice speciale, ad esempio 66.

lista_di_liste = [
    [20, 30, 12],
    [34, 150, 777],
    [1, 2, 3],
    [6, 3, 90]
]

print("Rieccoci con l'esercizio 5 ma continuativo. Ebbene sì, farò un copia incolla, perché è la vera natura dei programmatori.")

while True:
    indice_esterno = len(lista_di_liste) * 100
    while not -len(lista_di_liste) <= indice_esterno < len(lista_di_liste):
        indice_esterno = int(input(f"Inserisci l'indice più esterno, quello relativo alla lista di liste (0-{len(lista_di_liste) - 1}): "))
        if indice_esterno == 66:
            print("Dunque hai scelto morte. Ora uscirai dal programma.")
            exit(0)

    indice_interno = len(lista_di_liste[indice_esterno]) * 100
    while not -len(lista_di_liste[indice_esterno]) <= indice_interno < len(lista_di_liste[indice_esterno]):
        indice_interno = int(input(f"Bene, ora inserisci l'indice più interno, quello relativo alla lista interna che hai scelto (0-2): "))
        if indice_interno == 66:
            print("Dunque hai scelto morte. Ora uscirai dal programma.")
            exit(0)

    print(f"L'elemento che hai scelto è {lista_di_liste[indice_esterno][indice_interno]}")

lez10_es06_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 6
# Creare una LISTA DI LISTE DI LISTE, dove ogni lista più interna contiene tre elementi.
# Chiedere all'utente di inserire tre indici: uno per la lista di liste, uno per la lista interna,
# e uno per l'elemento dentro la lista più interna.
# Stampare l'elemento corrispondente.

giga_lista = [[
    [3, 7, 13],
    [6, 8, 32],
    [41, 62, 77]
],
[
    ["ciao", "buonasera", "salve"],
    ["ao", "pupazzo", "buffone"],
    [True, False, not True and False]
],
[
    [12 * 45, 33 * 2, 44 * 45],
    [12e3, 44e2, 55e90],
    [f"Siummeroni {2*2} " * 2, 0b1101011, 0x16AE]
]]

print("\nBuonasera, questo è l'esercizio precedente ma su steroidi.\n")

indice_esterno = len(giga_lista) * 100
while not -len(giga_lista) <= indice_esterno < len(giga_lista):
    indice_esterno = int(input(f"Inserisci l'indice più esterno, quello relativo alla lista di liste (0-{len(giga_lista) - 1}): "))

indice_centrale = len(giga_lista[indice_esterno]) * 100
while not -len(giga_lista[indice_esterno]) <= indice_centrale < len(giga_lista[indice_esterno]):
    indice_centrale = int(input(f"Bene, ora inserisci l'indice centrale, quello relativo alla lista che conterrà la lista più interna (0-{len(giga_lista[indice_esterno]) - 1}): "))

indice_interno = len(giga_lista[indice_esterno][indice_centrale])
while not -len(giga_lista[indice_esterno][indice_centrale]) <= indice_interno < len(giga_lista[indice_esterno][indice_centrale]):
    indice_interno = int(input(f"Infine, inserisci l'indice più interno, quello relativo alla lista interna che hai scelto (0-2):"))

print(f"L'elemento che hai scelto è {giga_lista[indice_esterno][indice_centrale][indice_interno]}")

lez10_es06.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 6
# Creare una LISTA DI LISTE DI LISTE, dove ogni lista più interna contiene tre elementi.
# Chiedere all'utente di inserire tre indici: uno per la lista di liste, uno per la lista interna,
# e uno per l'elemento dentro la lista più interna.
# Stampare l'elemento corrispondente.

lez10_es02_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 2
# Creare una lista con alcuni numeri e chiedere all'utente di modificare
# un elemento della lista fornendo l'indice e il nuovo valore.
# Dopo la modifica, stampare la nuova lista.

lista = [3, 5, 7, 8, 50, 25, 102, 30]

print(f"Questo programma permette di modificare un elemento della lista {lista} specificando l'indice dell'elemento da modificare e il nuovo valore.")

indice = int(input("Inserisci l'indice dell'elemento da modificare: "))
nuovo_valore = int(input("Inserisci il nuovo valore: "))

# Controlliamo se l'indice inserito è valido per la lista.
# -len(lista) <= indice < len(lista) è l'intervallo degli indici validi per la lista.
# -len(lista) è l'indice del primo elemento della lista, acceduto con lista[-len(lista)] (i.e.: lista[-8]).
# Andando oltre (in negativo) si andrebbe in errore perché lista[-9] non esiste.
# Discorso analogo per l'indice massimo, len(lista) - 1, che è l'indice dell'ultimo elemento della lista.
if -len(lista) <= indice < len(lista):
    lista[indice] = nuovo_valore
    print(f"La nuova lista è {lista}.")
else:
    print(f"L'indice {indice} inserito non è valido per la lista {lista}. Il range degli indici validi è da {-len(lista)} a {len(lista) - 1}.")

lez10_es05.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 5
# Creare una LISTA DI LISTE, dove ogni lista interna contiene tre elementi.
# Chiedere all'utente di inserire due indici: uno per la lista interna
# e uno per l'elemento dentro quella lista.
# Stampare l'elemento interno corrispondente.

lez10_es07.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 7
# Creare una lista di liste con diversi elementi.
# Utilizzare un ciclo while per permettere all'utente di continuare a
# scegliere quale lista e quale elemento visualizzare, finché non decide
# di uscire inserendo un indice speciale, ad esempio 66.

lez10_es02.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 2
# Creare una lista con alcuni numeri e chiedere all'utente di modificare
# un elemento della lista fornendo l'indice e il nuovo valore.
# Dopo la modifica, stampare la nuova lista.

lez10_es04.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 10 - Esercizio 4
# Creare una lista con alcuni nomi. Chiedere all'utente di inserire il nome da rimuovere.
# Rimuovere il nome dalla lista e stampare la lista aggiornata.

lez10_es03_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 3
# Creare una lista vuota e chiedere all'utente quanti elementi vuole aggiungere
# alla lista. Dopo di che, chiedere all'utente l'elemento da aggiungere volta per
# volta, fino a riempire la lista del numero di elementi specificato inizialmente.
# Stampare la lista ottenuta.

print("Questo programma consente di creare una lista chiedendo quanti e quali elementi si vogliono inserire.")

lista = []

numero_elementi = int(input("Quanti elementi vuoi inserire nella lista? "))

while len(lista) < numero_elementi:
    elemento = input("Quale elemento vuoi inserire? ")
    lista.append(elemento)
    print(f"Elemento {elemento} inserito. La lista ora è:\n{lista}")

print(f"Sono stati inseriti correttamente {numero_elementi} elementi.")

lez10_es04_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 4
# Creare una lista con alcuni nomi. Chiedere all'utente di inserire il nome da rimuovere.
# Rimuovere il nome dalla lista e stampare la lista aggiornata.

lista = ["Franco", "Biero", "Giovanni", "Giannina", "Sanbenedettodeltronto", "Ambrogio"]

print(f"Buondì, la lista dei nomi contiene, attualmente, i seguenti nomi:")

i = 0
while i < len(lista):
    print(f" - {lista[i]}")
    i += 1

nome_da_rimuovere = input("\nScegli uno di tali nomi da rimuovere: ")

if nome_da_rimuovere in lista:
    lista.remove(nome_da_rimuovere)
    print(f"Il nome è stato rimosso correttamente. Ora la lista contiene i seguenti nomi:")
    i = 0
    while i < len(lista):
        print(f" - {lista[i]}")
        i += 1
else:
    print("Il nome scelto non è presente all'interno della lista.")


































# SOLUZIONE ALTERNATIVA CHE UTILIZZA UNA FUNZIONE DEFINITA DA NOI PER EVITARE LA RIPETIZIONE DEL CODICE

def stampa_elenco_da_lista(listozza):
    i = 0
    while i < len(listozza):
        print(f" - {listozza[i]}")
        i += 1


lista = ["Franco", "Biero", "Giovanni", "Giannina", "Sanbenedettodeltronto", "Ambrogio"]

print(f"\nBuondì, la lista dei nomi contiene, attualmente, i seguenti nomi:")

stampa_elenco_da_lista(lista)

nome_da_rimuovere = input("\nScegli uno di tali nomi da rimuovere: ")

if nome_da_rimuovere in lista:
    lista.remove(nome_da_rimuovere)
    print(f"Il nome è stato rimosso correttamente. Ora la lista contiene i seguenti nomi:")
    stampa_elenco_da_lista(lista)
else:
    print("Il nome scelto non è presente all'interno della lista.")

lez10_es01_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 1
# Creare una lista di numeri.
# Chiedere all'utente di inserire un numero e controllare se tale numero
# è presente nella lista. Stampare un messaggio appropriato.

lista = [3, 5, 10, 42, 66, 12, 5003]

print("Questo programma permette di verificare la presenza di un numero in una lista.")
numero = int(input("Inserisci un numero: "))

if numero in lista:
    print(f"Il numero {numero} è presente nella lista.")
else:
    print(f"Il numero {numero} non è presente nella lista.")

lez10_es03.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 3
# Creare una lista vuota e chiedere all'utente quanti elementi vuole aggiungere
# alla lista. Dopo di che, chiedere all'utente l'elemento da aggiungere volta per
# volta, fino a riempire la lista del numero di elementi specificato inizialmente.
# Stampare la lista ottenuta.

lez10_es01.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 1
# Creare una lista di numeri.
# Chiedere all'utente di inserire un numero e controllare se tale numero
# è presente nella lista. Stampare un messaggio appropriato.

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 1
# Creare una lista di numeri.
# Chiedere all'utente di inserire un numero e controllare se tale numero
# è presente nella lista. Stampare un messaggio appropriato.

# lista = ["1", "3", "5", "6", "10"]
# numero = input("inserisci un numero ")
# if numero in lista:
#     print(f"{numero} è nella lista ")
# else:
#     print(f"{numero} non fa parte della lista")

# Lezione 10 - Esercizio 2
# Creare una lista con alcuni numeri e chiedere all'utente di modificare
# un elemento della lista fornendo l'indice e il nuovo valore.
# Dopo la modifica, stampare la nuova lista.

# lista = [1, 4, 5, 6, 7, 8, 9, 12, 23, 45]
# modificaindice = int(input("modifica un elemento della lista fornendo un indice ì"))
# modificavalore = int(input("inserisci il nuovo valore "))
# lista.pop(modificaindice)
# lista.insert(modificaindice, modificavalore)
# print(lista)


# lista = [1, 4, 5, 6, 7, 8, 9, 12, 23, 45]
# modificaindice = int(input("modifica un elemento della lista fornendo un indice ì"))
# modificavalore = int(input("inserisci il nuovo valore "))
# lista[modificaindice] = modificavalore
# print(lista)

# Lezione 10 - Esercizio 3
# Creare una lista vuota e chiedere all'utente quanti elementi vuole aggiungere
# alla lista. Dopo di che, chiedere all'utente l'elemento da aggiungere volta per
# volta, fino a riempire la lista del numero di elementi specificato inizialmente.
# Stampare la lista ottenuta.

lista = []
numero_elementi = int(input("quanti elementi vuoi aggiungere alla lista "))
 
while len(lista) != numero_elementi:
    elemento = input("inserisci un elemento")
    lista.append(elemento)

print(lista)

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 1
# Creare una lista di numeri.
# Chiedere all'utente di inserire un numero e controllare se tale numero
# è presente nella lista. Stampare un messaggio appropriato.

# lista = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# numero = int(input("Inserisci un numero e ti dirò se appartiene alla lista: "))

# if numero in lista:
#     print(f"Il numero {numero} si trova nella lista {lista}.")
# else:
#     print(f"Il numero {numero} non si trova nella lista {lista}.")

#  OPPURE

# if numero in [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]:
#     print(f"Il numero {numero} si trova nella lista.")
# else:
#     print(f"Il numero {numero} non si trova nella lista.")

#  ---------------------------------------------------------------------------------------------------------------
# Lezione 10 - Esercizio 2
# Creare una lista con alcuni numeri e chiedere all'utente di modificare
# un elemento della lista fornendo l'indice e il nuovo valore.
# Dopo la modifica, stampare la nuova lista.

# lista = [10, 20, 30, 40, 50, 60]

# print(f"La lista corrente è {lista}, modifica un valore a tuo piacimento fornendo l'indice ed il nuovo valore.")

# indice = int(input("Inserisci l'indice dell'elemento da modificare: "))
# nuovo_valore = int(input("Inserisci il nuovo valore: "))

# if indice < len(lista):
#     lista[indice] = nuovo_valore
#     print(f"Fatto! La nuova lista è {lista}.")
# else:
#     print(f"Attenzione, l'indice inserito {indice} supera il massimo degli elementi della lista.")


# Lezione 10 - Esercizio 3
# Creare una lista vuota e chiedere all'utente quanti elementi vuole aggiungere
# alla lista. Dopo di che, chiedere all'utente l'elemento da aggiungere volta per
# volta, fino a riempire la lista del numero di elementi specificato inizialmente.
# Stampare la lista ottenuta.

lista = []

n_elementi = int(input("Quanti elementi vuoi aggiungere alla lista? "))
contatore = 0

while contatore < n_elementi:
    elemento = input("Inserici un elemento alla lista: ")
    lista.append(elemento)
    contatore += 1
    elementi_rimasti = n_elementi - contatore
    print(f"Al momento la tua lista contiene: {lista}.")
    if elementi_rimasti > 0:
        print(f"Ti mancano {elementi_rimasti} elementi.")

print(f"Fatto! La tua lista è {lista}.")

main.py (clicca per mostrare il codice) Scarica (n. download: 7)

# L10 - Le strutture dati (parte 1)
# Liste, Tuple, Set, Dizionari
# Le tuple sono simili alle liste, ma sono IMMUTABILI.
# Questo significa che una volta creata, una tupla non può essere modificata.
# I set sono insiemi, quindi non contengono elementi duplicati e non sono ordinati.
# I dizionari sono collezioni di coppie chiave-valore.

dizionario_di_esempio = {
    "nome": "Mario",
    "cognome": "Rossi",
    "età": 30,
    "numeri_di_telefono": ["123456789", "987654321"],
    "indirizzo": {
        "via": "Via Roma",
        "numero": 10
    }
}

# LE LISTE

# Le liste sono una delle strutture dati più utilizzate in Python.
# Sono sequenze ordinate di elementi, che possono essere di qualsiasi tipo.

# Creazione di una lista
# Per creare una lista, si utilizzano le parentesi quadre [].
# Gli elementi della lista sono separati da virgole.
lista = [1, 2, 3, 4, 5]
print(lista)  # Output: [1, 2, 3, 4, 5]

# Le liste possono contenere elementi di diversi tipi.
lista = [1, "due", 3.0, True]
print(lista)  # Output: [1, 'due', 3.0, True]

# Le liste possono anche contenere altre liste.
lista = [[1, 2], [3, 4], [5, 6]]
print(lista)  # Output: [[1, 2], [3, 4], [5, 6]]

# Creazione di una lista vuota
# Per creare una lista vuota, si utilizzano le parentesi quadre senza elementi.
lista_vuota = []
print(lista_vuota)  # Output: []

# Accesso agli elementi di una lista
# Si può accedere agli elementi di una lista utilizzando l'INDICE.
# L'indice di un elemento è la sua posizione all'interno della lista.
# Gli indici delle liste in Python partono da 0.
lista = [10, 20, 30, 40, 50]
print(lista[0])  # Output: 10
print(lista[1])  # Output: 20

# Gli indici negativi permettono di accedere agli elementi partendo dalla fine della lista.
# L'indice -1 corrisponde all'ultimo elemento della lista.
print(lista[-1])  # Output: 50
print(lista[-2])  # Output: 40

indice = 2
print(lista[indice]) # Output: 30

# È come se dentro la lista ci fossero delle variabili ottenute tramite l'indice
# lista = [lista[0] = 10, lista[1] = 20, lista[2] = 30, lista[3] = 40, lista[4] = 50]

# Modifica degli elementi di una lista
# Gli elementi di una lista possono essere modificati assegnando un nuovo valore all'elemento.
lista = [10, 20, 30, 40, 50]
lista[0] = 100
print(lista)  # Output: [100, 20, 30, 40, 50]
lista[indice] = 300

# Aggiunta di elementi a una lista
# Per aggiungere un elemento alla fine di una lista, si utilizza il metodo append().
lista = [10, 20, 30]
lista.append(40)
print(lista)  # Output: [10, 20, 30, 40]

# Per aggiungere più elementi alla fine di una lista, si utilizza il metodo extend().
lista = [10, 20, 30]
lista.extend([40, 50])
print(lista)  # Output: [10, 20, 30, 40, 50]

# Per aggiungere un elemento in una posizione specifica di una lista, si utilizza il metodo insert().
lista = [10, 20, 30]
lista.insert(1, 15)
print(lista)  # Output: [10, 15, 20, 30]

# Rimozione di elementi da una lista
# Per rimuovere un elemento da una lista, si utilizza il metodo remove().
lista = [10, 20, 30, 30, 50]
lista.remove(30)
print(lista)  # Output: [10, 20, 30, 50]

# Per rimuovere un elemento in una posizione specifica di una lista, si utilizza il metodo pop().
lista = [10, 20, 30, 40, 50]
elemento_rimosso = lista.pop(2)
print(lista)  # Output: [10, 20, 40, 50]
print(elemento_rimosso)  # Output: 30

lista.pop()  # Rimuove l'ultimo elemento della lista
# Equivalente a lista.pop(-1)

# Per rimuovere tutti gli elementi da una lista, si utilizza il metodo clear().
lista = [10, 20, 30, 40, 50]
lista.clear()
print(lista)  # Output: []

# Altri metodi delle liste
# Altri metodi utili delle liste sono:
# - index(): restituisce l'indice di un elemento specifico.
# - count(): restituisce il numero di occorrenze di un elemento.
# - reverse(): inverte l'ordine degli elementi della lista.
# - copy(): crea una copia della lista.
lista = [10, 20, 30, 20, 40, 50]
print(lista.index(20))  # Output: 1
print(lista.count(20))  # Output: 2
lista.reverse()
print(lista)  # Output: [50, 40, 20, 30, 20, 10]
copia_lista = lista.copy()
print(copia_lista)  # Output: [50, 40, 20, 30, 20, 10]

# Funzione built-in len()
# La funzione len() restituisce la lunghezza di una lista, cioè il numero di elementi che contiene.
lista = [10, 20, 30, 40, 50]
lunghezza = len(lista)
print(lunghezza)  # Output: 5
ultimo_indice = len(lista) - 1

lez10_es05_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 10 - Esercizio 5
# Creare una LISTA DI LISTE, dove ogni lista interna contiene tre elementi.
# Chiedere all'utente di inserire due indici: uno per la lista interna
# e uno per l'elemento dentro quella lista.
# Stampare l'elemento interno corrispondente.

lista_di_liste = [
    [20, 30, 12],
    [34, 150, 777],
    [1, 2, 3],
    [6, 3, 90]
]

print("Buonasera, in questo programma scoprirai quale elemento si nasconde in corrispondenza di un doppio indice, in una lista di liste.")

indice_esterno = len(lista_di_liste) * 100
while not -len(lista_di_liste) <= indice_esterno < len(lista_di_liste):
    indice_esterno = int(input(f"Inserisci l'indice più esterno, quello relativo alla lista di liste (0-{len(lista_di_liste) - 1}): "))

indice_interno = len(lista_di_liste[indice_esterno]) * 100
while not -len(lista_di_liste[indice_esterno]) <= indice_interno < len(lista_di_liste[indice_esterno]):
    indice_interno = int(input(f"Bene, ora inserisci l'indice più interno, quello relativo alla lista interna che hai scelto (0-2): "))

print(f"L'elemento che hai scelto è {lista_di_liste[indice_esterno][indice_interno]}")

lez09_esercizione_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

print("Benvenuto alla calcolatrice avanzata!")
print("Scegli un'operazione inserendo la lettera corrispondente:")
print('"a" per addizione')
print('"s" per sottrazione')
print('"m" per moltiplicazione')
print('"d" per divisione')
print('"r" per resto')
print('"p" per potenza')
print('"n" per numero primo')
print('"t" per tabellina')
print('"c" per somma consecutiva')
print('"e" per pari o dispari')
print('"q" per uscire')

OPERAZIONI_MAT = ['a', 's', 'm', 'd', 'r', 'p']

while True:
    scelta = input("Inserisci la tua scelta: ").lower()
    if scelta == "q":
        print("Grazie per aver utilizzato la calcolatrice avanzata!")
        break
    
    num1 = float(input("Inserisci un numero: "))
    
    if scelta in OPERAZIONI_MAT:
        num2 = float(input("Inserisci il secondo numero: "))
    
    if scelta == 'a':
        print(f"Risultato: {num1 + num2}")
    elif scelta == 's':
        print(f"Risultato: {num1 - num2}")
    elif scelta == 'm':
        print(f"Risultato: {num1 * num2}")
    elif scelta == 'd':
        if num2 != 0:
            print(f"Risultato: {num1 / num2}")
        else:
            print("Errore: Non è possibile dividere per zero.")
    elif scelta == 'r':
        print(f"Risultato: {num1 % num2}")
    elif scelta == 'p':
        print(f"Risultato: {num1 ** num2}")
    elif scelta == 'n':
        if num1 > 1:
            is_prime = True
            i = 2
            while i <= num1 / 2:
                if num1 % i == 0: # 9: 9 % 2 = 1, OK; 9 % 3 = 0, non OK
                    is_prime = False
                    break
                i += 1

            if is_prime:
                print(f"{int(num1)} è un numero primo.")
            else:
                print(f"{int(num1)} non è un numero primo. Il suo primo divisore trovato è {i}.")
        else:
            print("I numeri primi sono maggiori di 1.")
    elif scelta == 't':
        i = 1
        while i <= 10:
            print(f"{int(num1)} * {i} = {int(num1) * i}")
            i += 1
    elif scelta == 'c':
        somma = 0
        i = 1
        while i <= num1:
            somma += i  # 0 + 1 + 2 + 3 + 4 + 5 + ... + num1
            i += 1
        print(f"La somma dei numeri da 1 a {int(num1)} è {somma}.")
    elif scelta == 'e':
        if num1 % 2 == 0: # Se il resto della divisione per due del num1 è 0 allora il numero è divisibile per 2, quindi è pari
            print(f"{int(num1)} è pari.")
        else:
            print(f"{int(num1)} è dispari.")
    else:
        print("Scelta non valida. Riprova.")

print("ciao ciao")

lez09_es4_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 4
# Creare un sistema di login che richiede all'utente di tentare di inserire la sua password al massimo tre volte per
# convalidare l'accesso.
#
# 1. FATTO
# 2. FATTO
# 3. Se la password è corretta in almeno uno dei tre tentativi, stampare "Accesso consentito" e terminare.
# 4. Se tutti e tre i tentativi sono errati, stampare "Accesso negato".
#
# Note e consigli:
# - Utilizzare un ciclo while con un contatore per limitare il numero di tentativi a tre.

# Soluzione qui sotto:
PASSWORD_CORRETTA = "salve"
tentativi = 0

while tentativi < 3:
    password = input("Inserisci la password: ")
    if password != PASSWORD_CORRETTA:
        tentativi += 1
    else:
        print("Accesso consentito")
        break

if tentativi == 3:
    print("Accesso negato")

lez09_es3_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

budget = 500 

while budget > 0:
    print(f"Hai {budget:.2f}€ a disposizione.")
    spesa = float(input("Quanto vuoi spendere? "))

    if spesa < 0:
        print(f"AO, ma che stai a fa, vuoi spende {spesa:.2f}€. Magari si potesse fare così che ti ricaricano il conto quando spendi... Scrivi un valore realistico, pezzente.")
        continue
    
    budget -= spesa
    
print(f"Ti sei finito i soldi. Il conto è letteralmente in negativo, infatti hai {budget:.2f}€. \nPezzente.")

lez09_es3.py (clicca per mostrare il codice) Scarica (n. download: 9)

# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

lez09_es2.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 9 - Esercizio 2
# Creare un programma che accetta una serie di età (come input dell'utente) e calcola l'età media.
# Il ciclo termina quando l'utente inserisce "fine".
#
# 1. Chiedere all'utente di inserire un'età alla volta.
# 2. Verificare che l'input sia un numero intero positivo; ignorare gli input non validi con 'continue'.
# 3. Terminare l'input con la parola chiave "fine".
# 4. Calcolare e stampare l'età media al termine dell'inserimento.
#
# Note e consigli:
# - Utilizzare 'continue' per ignorare gli input non validi.
# - Calcolare l'età media solo dopo il completamento di tutti gli inserimenti validi.
# - Utilizzare una variabile per tenere traccia della somma totale delle età e del numero di input validi.

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:
 #chiedere all'utente un numero intero positivo 
 #verifica se il numero è maggiore di zero
 #finche il numero non raggiunge lo zero printare il numero e decrescere di un'unità e poi aspettare un secondo 

# numero = int(input("dimmi un numero intero positivo per favore? "))
# if numero > 0: 
#     print("numero valido")
# else: 
#     print("numero non valido")
#     exit(0)

# while numero >= 0:  # Finché il numero è maggiore o uguale a 0
#     time.sleep(1)  # Aspettare 1 secondo
#     print(numero)  # Stampare il numero
#     numero -= 1  # Decrementare il numero di 1

# ================================================================================================
# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Traduzione in linguaggio naturale schematico:
# 1. L'utente inserisce una password
# 2. Finché la password inserita dall'utente è DIVERSA dalla password corretta:
# 2.1. Stampare "Accesso negato"
# 2.2. Chiedere nuovamente la password all'utente
# 3. Quando succederà che la password sarà UGUALE a quella corretta, la condizione del while 
#    diventerà False, e quindi si uscirà dal while e si andrà oltre, dove stamperemo "Accesso
#      consentito". A quel punto il programma è completo.

# Scrivere qui sotto la soluzione:
# verifica_password = input("mi dici la password per accedere? ")  # Recuperiamo la password dall'input
# if verifica_password != password_corretta:  # Finché la password inserita è diversa da quella corretta
#     print("accesso negato")  # Stampiamo accesso negato
#     verifica_password = input("inserire nuovamente la password ")  # E chiediamo di nuovo la password

# print("accesso consentito")  # Se arriviamo qui, significa che per forza di cose la condizione del while
#                              # è risultata False, e quindi per forza di cose la password è corretta


# ================================================================================================
# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualora l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e/o break e/o la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# 1. Continua, all'infinito, a fare le seguenti operazioni:
# 1.1. Chiedere all'utetne qual è il risultato del controllo qualità (passato/fallito/esci)
# 1.2. Se il risultato è "passato", allora continuare il processo e chiedere il prossimo risultato
# 1.3. Se il risultato è "fallito", interrompere il chiedimento e stampare "prodotto difettoso..."
# 1.4. Se il risultato è "esci", interrompere il programma senza stampare nulla.
# 1.5. Se c'è qualsiasi altro risultato, allora continuare il processo e chiedere il prossimo risultato,
#      stampando, però, che il risultato inserito non è valido.

# Scrivere qui sotto la soluzione:
## risultato_qualità = input("qual è il risultato del controllo della qualità? ")
## while risultato_qualità != "fallito":

# while True:
#     risultato_controllo = input("qual è il risultato del controllo qualita? (passato/fallito/esci) ")
#     if risultato_controllo == "passato":
#         print("Ok, passiamo al prodotto successivo")
#         continue
#     elif risultato_controllo == "fallito":
#         print("prodotto difettoso")
#         break
#     elif risultato_controllo == "esci":
#         exit(0)  # Se fuori dal while (dalla riga 102 in poi) non c'è altro codice da eseguire, questo può essere break
#     else:
#         print("il risultato non è valido")



# ================================================================================================
# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Continua, all'infinito, ad eseguire le seguenti operazioni:
# 1. Chiedere un numero intero
# 1.2. Se il numero è positivo, allora stampare il suo quadrato
# 1.2. Altrimenti, se il numero è negativo, allora non fare nulla e chiedere il prossimo numero
# 1.3. Altrimenti, se il numero è esattamente 0, allora terminare il programma

# Scrivere qui sotto la soluzione:
# while True:
#     numero_inserito = int(input("Puoi inserire un numero intero? "))
#     if numero_inserito > 0:
#         print(f"Il quadrato di {numero_inserito} è: {numero_inserito ** 2}.")
#     elif numero_inserito < 0:
#         print("Il numero deve essere positivo.")
#     else:
#         print("Hai inserito 0, il programma ora si chiuderà.")
#         exit(0)


# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

# Scrivere qui sotto la soluzione:


# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

# Descrizione in linguaggio naturale schematizzato:
# 1. Vediamo il budget come una variabile che possiamo modificare che rappresenta i soldi che abbiamo a dispozione
#    Quindi, questo budget si ridurrà in base alle spese che facciamo, partendo da 500€
# 2. Finché abbiamo soldi (-> il budget è positivo)
#    a) chiediamo la nuova pesa che l'utente vuole effettuare
#    b) se questa spesa è un numero negativo, informiamo l'utente di ciò, non modifichiamo nulla e continuiamo all'iterazione successiva.
#    c) nel caso in cui la spesa fosse stata un numero positivo, possiamo, senza verificare nulla, decrementare il nostro budget della spesa effettuata.
#    d) se, a questo punto, il budget è diventato negativo, significa che l'utente ha finito i soldi. Quindi possiamo informarlo di ciò.
#    e) infine, mostriamo all'utente il suo budget rimanente.

budget = 500 

while budget > 0:
    print(f"Hai {budget:.2f}€ a disposizione.")
    spesa = float(input("Quanto vuoi spendere? "))

    if spesa < 0:
        print(f"AO, ma che stai a fa, vuoi spende {spesa:.2f}€. Magari si potesse fare così che ti ricaricano il conto quando spendi... Scrivi un valore realistico, pezzente.")
        continue
    
    budget -= spesa
    
print(f"Ti sei finito i soldi. Il conto è letteralmente in negativo, infatti hai {budget:.2f}€. \nPezzente.")

lez09_es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 4
# Creare un sistema di login che richiede all'utente di tentare di inserire la sua password tre volte per
# convalidare l'accesso.
#
# 1. Definire una password corretta in una variabile costante.
# 2. Chiedere all'utente di inserire la password fino a tre volte.
# 3. Se la password è corretta in almeno una delle tre prove, stampare "Accesso consentito" e termina.
# 4. Se tutte e tre i tentativi sono errati, stampa "Accesso negato".
#
# Note e consigli:
# - Utilizzare un ciclo while con un contatore per limitare il numero di tentativi a tre.
# - Utilizzare 'break' per uscire dal ciclo se la password è corretta.

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:  # NICOLO' PUZZA

# numero = int(input("Salve, inserisci un numero intero positivo: "))

# if numero > 0: 
#     print(f"Il conto alla roverscia partirà da {numero}.")
# else:
#     print("Errore! Il numero che hai inserito non è positivo.")
#     exit(0)

# while numero > 0:
#     print(numero)
#     numero -= 1
#     time.sleep(1)

# print(0)


# ================================================================================================
# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Scrivere qui sotto la soluzione:

# psw = input("Inserire la password: ")

# while psw != password_corretta
#     print("Password errata!")
#     psw = input("Si prega di inserire la password corretta: ")

# print("Password corretta, accesso consentito.")





# ================================================================================================
# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualore l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e break e la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# Scrivere qui sotto la soluzione:

# prodotto = "biero"
# numero = 1

# while prodotto != "fallito":
#     prodotto = input(f"Controllo qualità del prodotto numero {numero}, esito (passato/fallito): ")
#     if prodotto == "passato":
#         numero += 1
#         print("Controllo superato, passaggio a prodotto successivo.")
#     elif prodotto == "esci":
#         break
#     elif prodotto == "fallito":
#         print("Prodotto difettoso trovato, linea di produzione fermata.")
#         break  # Se non scrivi nulla fuori dal while, questo può essere un break
#     else:
#         print("Risultato non valido. Riprovare.")
#         continue



# ================================================================================================
# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Scrivere qui sotto la soluzione:

# while True:
#     numero = int(input("Inserisci un numero positivo: "))
#     if numero > 0:
#         n_2 = numero ** 2
#         print(f"Il quadrato di {numero} è {n_2}.")
#     elif numero < 0:
#         print("Il numero deve essere positivo.")
#         continue
#     else:
#         print("Numero 0 inserito, terminazione programma.")
#         break



# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

# while True:
#     numero = int(input("Inserisci un numero intero positivo: "))
#     # minimo = min(numero)  # Questo non è corretto, min() è una funzione che restituisce il minimo tra i numeri passati come argomento
#     if minimo > numero:
#         minimo = numero

#     if numero < 0:
#         print("Errore, numero negativo!")
#     elif numero > 0:
#         minimo = min(numero)
#         print(f"Il numero minimo tra quelli inseriti è {minimo}.")
#     else:
#         print("Numero 0 inserito, terminazione programma.")
#         break


# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

budget = 500

print("Questo programma ti aiuterà a tenere traccia delle tue spese e del tuo budget.")

while budget >= 0:
    spesa = float(input(f"Il tuo budget è di {budget}€. Inserisci una spesa: "))
    
    if spesa < 0:
        print("Errore, hai inserito una spesa negativa.")
        continue
    
    budget -= spesa

print(f"Attenzione! La tua spesa di {spesa}€ supera il tuo budget di {budget}€. \n Il programma terminerà.")





PSW_CORRETTA = "bierocondor123"
tentativi = 3

while tentativi != 0:
    psw = input("Benvenuto, inserisci la password per accedere: ")

    if psw == PSW_CORRETTA:
        print("Password corretta! Accesso consentito.")
        exit(0)
    else:
        tentativi -= 1
        if tentativi > 1:
            print(f"Password non valida, ti rimangono {tentativi} tentativi.")
        else:
            print(f"Password non valida, ti rimane {tentativi} tentativo.")
        
print("Hai inserito la password errata per 3 volte, il programma terminerà.")

lez09_es1.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

lez09_esercizione.py (clicca per mostrare il codice) Scarica (n. download: 9)

# Lezione 9 - ESERCIZIONE
# Creare un programma che funzioni come una calcolatrice avanzata, permettendo all'utente
# di scegliere tra diverse operazioni matematiche e funzioni speciali.
#
# Funzionalità richieste:
# 1. Le operazioni matematiche da includere sono: addizione, sottrazione, moltiplicazione,
#    divisione, calcolo del resto ed elevazione a potenza.
# 2. Le funzioni speciali da includere sono: verifica se un numero è primo, stampa la
#    tabellina di un numero fino a x10, calcolo della somma dei numeri da 1 a un numero N,
#    e verifica se un numero è pari o dispari.
#
# Interfaccia utente:
# - All'avvio, il programma deve mostrare un menu con le seguenti opzioni, ciascuna associata
#   a una lettera:
#   "a" per addizione, "s" per sottrazione, "m" per moltiplicazione, "d" per divisione,
#   "r" per calcolo del resto, "p" per elevazione a potenza, "n" per numero primo,
#   "t" per tabellina, "c" per somma dei numeri, "e" per pari o dispari, "q" per uscire.
# - L'utente deve inserire la lettera corrispondente all'operazione desiderata.
# - A seconda dell'operazione scelta, il programma deve chiedere all'utente di inserire uno
#   o due numeri.
# - Il programma deve eseguire l'operazione e mostrare il risultato.
# - Dopo aver mostrato il risultato, il programma deve tornare al menu principale fino a
#   quando l'utente non decide di uscire inserendo "q".
#
# Note e consigli:
# - È obbligatorio commentare adeguatamente il codice spiegando cosa fa ogni parte del codice.
# - È obbligatorio rendere il programma esplicativo per l'utente, stampando stringhe che
#   spiegano chiaramente cosa sta succedendo (spazi alla fine degli input e testi con la maiuscola).
# - Notare che, così come è possibile inserire if dentro altri if, è anche possibile
#   inserire while dentro altri while (non l'abbiamo mai visto a lezione).
# - È fondamentale eseguire costantemente il codice per verificare la correttezza di ciò
#   che si sta scrivendo.
# - In caso di divisione, gestire il caso in cui il divisore sia zero stampando un messaggio
#   di errore appropriato e non permettendo il crash del programma.
# - Per la verifica di un numero primo, considerare che un numero deve avere esattamente due
#   divisori distinti (1 e se stesso) per essere primo.

lez09_es1_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni. W biero

print("Inserisci numeri interi positivi per trovare, ogni volta, il minimo. Inserisci il numero 0 per terminare il programma.")
minimo = None  # positive_infinity = float('inf') negative_infinity = float('-inf')

while True:
    numero = int(input("Inserisci un numero intero positivo: "))

    if numero < 0:
        print("Il numero deve essere positivo.")
        continue
    elif numero == 0:
        print("Hai inserito il numero 0. Il programma terminerà.")
        break

    if minimo is None or numero < minimo:
        minimo = numero
    print(f"Il numero minimo attuale è il numero {minimo}.")

print(f"Il numero minimo finale è {minimo}.")

lez09_es2_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 2
# Creare un programma che accetta una serie di voti (come input dell'utente) e calcola il voto medio.
# Il ciclo termina quando l'utente inserisce "fine".
#
# 1. Chiedere all'utente di inserire un voto alla volta.
# 2. Verificare che l'input sia un numero intero positivo; ignorare gli input non validi con 'continue'.
# 3. Terminare l'input con la parola chiave "fine".
# 4. Calcolare e stampare il voto medio al termine dell'inserimento.
#
# Note e consigli:
# - Utilizzare 'continue' per ignorare gli input non validi.
# - Calcolare il voto medio solo dopo il completamento di tutti gli inserimenti validi.
# - Utilizzare una variabile per tenere traccia della somma totale dei voti e del numero di input validi.

somma_voti = 0  # Questa variabile contiene il TOTALE dei voti inseriti dall'utente
conteggio_voti = 0  # Questa variabile contiene il NUMERO di voti inseriti dall'utente

while True:
    voto = input('Inserisci un voto (numero intero positivo) oppure scrivi "fine" per calcolare la media: ')
    if voto == "fine":
        break
    
    voto = int(voto)  # Qui possiamo effettuare il casting a intero perché supponiamo che l'utente, se non inserisce
                      # la stringa "fine", allora ha per forza inserito un numero intero, non qualche altra cosa.
    
    if voto < 0:  # Se il voto è negativo:
        print("Il voto che hai inserito non è conteggiato nella media perché è negativo")  # Spieghiamo all'utente che non verrà conteggiato
        continue  # Stoppiamo l'iterazione corrente del ciclo while e proseguiamo con la successiva, senza eseguirne la parte restante
    
    somma_voti += voto  # Aggiungiamo il voto alla variabile che tiene conto del TOTALE dei voti
    conteggio_voti += 1  # Aggiungiamo 1 alla variabile che tiene conto del numero dei voti

if conteggio_voti < 1:  # Se il numero di voti inseriti è 0 (o meno), allora informiamo l'utente che non è possibile calcolarne la media
    print("Ma che fai, mettine almeno uno. Pupazzo.")
else:  # Altrimenti, possiamo calcolare la media e printarla all'utente.
    media = somma_voti / conteggio_voti
    print(f"Il voto medio è {media:.2f}.")

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:
 #chiedere all'utente un numero intero positivo 
 #verifica se il numero è maggiore di zero
 #finche il numero non raggiunge lo zero printare il numero e decrescere di un'unità e poi aspettare un secondo 

# numero = int(input("dimmi un numero intero positivo per favore? "))
# if numero > 0: 
#     print("numero valido")
# else: 
#     print("numero non valido")
#     exit(0)

# while numero >= 0:  # Finché il numero è maggiore o uguale a 0
#     time.sleep(1)  # Aspettare 1 secondo
#     print(numero)  # Stampare il numero
#     numero -= 1  # Decrementare il numero di 1

# ================================================================================================
# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Traduzione in linguaggio naturale schematico:
# 1. L'utente inserisce una password
# 2. Finché la password inserita dall'utente è DIVERSA dalla password corretta:
# 2.1. Stampare "Accesso negato"
# 2.2. Chiedere nuovamente la password all'utente
# 3. Quando succederà che la password sarà UGUALE a quella corretta, la condizione del while 
#    diventerà False, e quindi si uscirà dal while e si andrà oltre, dove stamperemo "Accesso
#      consentito". A quel punto il programma è completo.

# Scrivere qui sotto la soluzione:
# verifica_password = input("mi dici la password per accedere? ")  # Recuperiamo la password dall'input
# if verifica_password != password_corretta:  # Finché la password inserita è diversa da quella corretta
#     print("accesso negato")  # Stampiamo accesso negato
#     verifica_password = input("inserire nuovamente la password ")  # E chiediamo di nuovo la password

# print("accesso consentito")  # Se arriviamo qui, significa che per forza di cose la condizione del while
#                              # è risultata False, e quindi per forza di cose la password è corretta


# ================================================================================================
# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualora l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e/o break e/o la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# 1. Continua, all'infinito, a fare le seguenti operazioni:
# 1.1. Chiedere all'utetne qual è il risultato del controllo qualità (passato/fallito/esci)
# 1.2. Se il risultato è "passato", allora continuare il processo e chiedere il prossimo risultato
# 1.3. Se il risultato è "fallito", interrompere il chiedimento e stampare "prodotto difettoso..."
# 1.4. Se il risultato è "esci", interrompere il programma senza stampare nulla.
# 1.5. Se c'è qualsiasi altro risultato, allora continuare il processo e chiedere il prossimo risultato,
#      stampando, però, che il risultato inserito non è valido.

# Scrivere qui sotto la soluzione:
## risultato_qualità = input("qual è il risultato del controllo della qualità? ")
## while risultato_qualità != "fallito":

# while True:
#     risultato_controllo = input("qual è il risultato del controllo qualita? (passato/fallito/esci) ")
#     if risultato_controllo == "passato":
#         print("Ok, passiamo al prodotto successivo")
#         continue
#     elif risultato_controllo == "fallito":
#         print("prodotto difettoso")
#         break
#     elif risultato_controllo == "esci":
#         exit(0)  # Se fuori dal while (dalla riga 102 in poi) non c'è altro codice da eseguire, questo può essere break
#     else:
#         print("il risultato non è valido")



# ================================================================================================
# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Continua, all'infinito, ad eseguire le seguenti operazioni:
# 1. Chiedere un numero intero
# 1.2. Se il numero è positivo, allora stampare il suo quadrato
# 1.2. Altrimenti, se il numero è negativo, allora non fare nulla e chiedere il prossimo numero
# 1.3. Altrimenti, se il numero è esattamente 0, allora terminare il programma

# Scrivere qui sotto la soluzione:
# while True:
#     numero_inserito = int(input("Puoi inserire un numero intero? "))
#     if numero_inserito > 0:
#         print(f"Il quadrato di {numero_inserito} è: {numero_inserito ** 2}.")
#     elif numero_inserito < 0:
#         print("Il numero deve essere positivo.")
#     else:
#         print("Hai inserito 0, il programma ora si chiuderà.")
#         exit(0)


# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

# Scrivere qui sotto la soluzione:


# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

# Descrizione in linguaggio naturale schematizzato:
# 1. Vediamo il budget come una variabile che possiamo modificare che rappresenta i soldi che abbiamo a dispozione
#    Quindi, questo budget si ridurrà in base alle spese che facciamo, partendo da 500€
# 2. Finché abbiamo soldi (-> il budget è positivo)
#    a) chiediamo la nuova pesa che l'utente vuole effettuare
#    b) se questa spesa è un numero negativo, informiamo l'utente di ciò, non modifichiamo nulla e continuiamo all'iterazione successiva.
#    c) nel caso in cui la spesa fosse stata un numero positivo, possiamo, senza verificare nulla, decrementare il nostro budget della spesa effettuata.
#    d) se, a questo punto, il budget è diventato negativo, significa che l'utente ha finito i soldi. Quindi possiamo informarlo di ciò.
#    e) infine, mostriamo all'utente il suo budget rimanente.

budget = 500 

while budget > 0:
    print(f"Hai {budget:.2f}€ a disposizione.")
    spesa = float(input("Quanto vuoi spendere? "))

    if spesa < 0:
        print(f"AO, ma che stai a fa, vuoi spende {spesa:.2f}€. Magari si potesse fare così che ti ricaricano il conto quando spendi... Scrivi un valore realistico, pezzente.")
        continue
    
    budget -= spesa
    
print(f"Ti sei finito i soldi. Il conto è letteralmente in negativo, infatti hai {budget:.2f}€. \nPezzente.")

lez09_es1.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

davide.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:  # NICOLO' PUZZA

# numero = int(input("Salve, inserisci un numero intero positivo: "))

# if numero > 0: 
#     print(f"Il conto alla roverscia partirà da {numero}.")
# else:
#     print("Errore! Il numero che hai inserito non è positivo.")
#     exit(0)

# while numero > 0:
#     print(numero)
#     numero -= 1
#     time.sleep(1)

# print(0)


# ================================================================================================
# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Scrivere qui sotto la soluzione:

# psw = input("Inserire la password: ")

# while psw != password_corretta
#     print("Password errata!")
#     psw = input("Si prega di inserire la password corretta: ")

# print("Password corretta, accesso consentito.")





# ================================================================================================
# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualore l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e break e la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# Scrivere qui sotto la soluzione:

# prodotto = "biero"
# numero = 1

# while prodotto != "fallito":
#     prodotto = input(f"Controllo qualità del prodotto numero {numero}, esito (passato/fallito): ")
#     if prodotto == "passato":
#         numero += 1
#         print("Controllo superato, passaggio a prodotto successivo.")
#     elif prodotto == "esci":
#         break
#     elif prodotto == "fallito":
#         print("Prodotto difettoso trovato, linea di produzione fermata.")
#         break  # Se non scrivi nulla fuori dal while, questo può essere un break
#     else:
#         print("Risultato non valido. Riprovare.")
#         continue



# ================================================================================================
# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Scrivere qui sotto la soluzione:

# while True:
#     numero = int(input("Inserisci un numero positivo: "))
#     if numero > 0:
#         n_2 = numero ** 2
#         print(f"Il quadrato di {numero} è {n_2}.")
#     elif numero < 0:
#         print("Il numero deve essere positivo.")
#         continue
#     else:
#         print("Numero 0 inserito, terminazione programma.")
#         break



# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

# while True:
#     numero = int(input("Inserisci un numero intero positivo: "))
#     # minimo = min(numero)  # Questo non è corretto, min() è una funzione che restituisce il minimo tra i numeri passati come argomento
#     if minimo > numero:
#         minimo = numero

#     if numero < 0:
#         print("Errore, numero negativo!")
#     elif numero > 0:
#         minimo = min(numero)
#         print(f"Il numero minimo tra quelli inseriti è {minimo}.")
#     else:
#         print("Numero 0 inserito, terminazione programma.")
#         break


# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

budget = 500

print("Questo programma ti aiuterà a tenere traccia delle tue spese e del tuo budget.")

while budget >= 0:
    spesa = float(input(f"Il tuo budget è di {budget}€. Inserisci una spesa: "))
    
    if spesa < 0:
        print("Errore, hai inserito una spesa negativa.")
        continue
    
    budget -= spesa

print(f"Attenzione! La tua spesa di {spesa}€ supera il tuo budget di {budget}€. \n Il programma terminerà.")





PSW_CORRETTA = "bierocondor123"
tentativi = 3

while tentativi != 0:
    psw = input("Benvenuto, inserisci la password per accedere: ")

    if psw == PSW_CORRETTA:
        print("Password corretta! Accesso consentito.")
        exit(0)
    else:
        tentativi -= 1
        if tentativi > 1:
            print(f"Password non valida, ti rimangono {tentativi} tentativi.")
        else:
            print(f"Password non valida, ti rimane {tentativi} tentativo.")
        
print("Hai inserito la password errata per 3 volte, il programma terminerà.")

lez09_es3.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

lez09_es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 4
# Creare un sistema di login che richiede all'utente di tentare di inserire la sua password tre volte per
# convalidare l'accesso.
#
# 1. Definire una password corretta in una variabile costante.
# 2. Chiedere all'utente di inserire la password fino a tre volte.
# 3. Se la password è corretta in almeno una delle tre prove, stampare "Accesso consentito" e termina.
# 4. Se tutte e tre i tentativi sono errati, stampa "Accesso negato".
#
# Note e consigli:
# - Utilizzare un ciclo while con un contatore per limitare il numero di tentativi a tre.
# - Utilizzare 'break' per uscire dal ciclo se la password è corretta.

lez09_es2.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 9 - Esercizio 2
# Creare un programma che accetta una serie di età (come input dell'utente) e calcola l'età media.
# Il ciclo termina quando l'utente inserisce "fine".
#
# 1. Chiedere all'utente di inserire un'età alla volta.
# 2. Verificare che l'input sia un numero intero positivo; ignorare gli input non validi con 'continue'.
# 3. Terminare l'input con la parola chiave "fine".
# 4. Calcolare e stampare l'età media al termine dell'inserimento.
#
# Note e consigli:
# - Utilizzare 'continue' per ignorare gli input non validi.
# - Calcolare l'età media solo dopo il completamento di tutti gli inserimenti validi.
# - Utilizzare una variabile per tenere traccia della somma totale delle età e del numero di input validi.

lez08_es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Scrivere qui sotto la soluzione:

lez08_es1.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:
 #chiedere all'utente un numero intero positivo 
 #verifica se il numero è maggiore di zero
 #finche il numero non raggiunge lo zero printare il numero e decrescere di un'unità e poi aspettare un secondo 

# numero = int(input("dimmi un numero intero positivo per favore? "))
# if numero > 0: 
#     print("numero valido")
# else: 
#     print("numero non valido")
#     exit(0)

# while numero >= 0:  # Finché il numero è maggiore o uguale a 0
#     time.sleep(1)  # Aspettare 1 secondo
#     print(numero)  # Stampare il numero
#     numero -= 1  # Decrementare il numero di 1

# ================================================================================================
# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Traduzione in linguaggio naturale schematico:
# 1. L'utente inserisce una password
# 2. Finché la password inserita dall'utente è DIVERSA dalla password corretta:
# 2.1. Stampare "Accesso negato"
# 2.2. Chiedere nuovamente la password all'utente
# 3. Quando succederà che la password sarà UGUALE a quella corretta, la condizione del while 
#    diventerà False, e quindi si uscirà dal while e si andrà oltre, dove stamperemo "Accesso
#      consentito". A quel punto il programma è completo.

# Scrivere qui sotto la soluzione:
# verifica_password = input("mi dici la password per accedere? ")  # Recuperiamo la password dall'input
# if verifica_password != password_corretta:  # Finché la password inserita è diversa da quella corretta
#     print("accesso negato")  # Stampiamo accesso negato
#     verifica_password = input("inserire nuovamente la password ")  # E chiediamo di nuovo la password

# print("accesso consentito")  # Se arriviamo qui, significa che per forza di cose la condizione del while
#                              # è risultata False, e quindi per forza di cose la password è corretta


# ================================================================================================
# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualora l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e/o break e/o la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# 1. Continua, all'infinito, a fare le seguenti operazioni:
# 1.1. Chiedere all'utetne qual è il risultato del controllo qualità (passato/fallito/esci)
# 1.2. Se il risultato è "passato", allora continuare il processo e chiedere il prossimo risultato
# 1.3. Se il risultato è "fallito", interrompere il chiedimento e stampare "prodotto difettoso..."
# 1.4. Se il risultato è "esci", interrompere il programma senza stampare nulla.
# 1.5. Se c'è qualsiasi altro risultato, allora continuare il processo e chiedere il prossimo risultato,
#      stampando, però, che il risultato inserito non è valido.

# Scrivere qui sotto la soluzione:
## risultato_qualità = input("qual è il risultato del controllo della qualità? ")
## while risultato_qualità != "fallito":

# while True:
#     risultato_controllo = input("qual è il risultato del controllo qualita? (passato/fallito/esci) ")
#     if risultato_controllo == "passato":
#         print("Ok, passiamo al prodotto successivo")
#         continue
#     elif risultato_controllo == "fallito":
#         print("prodotto difettoso")
#         break
#     elif risultato_controllo == "esci":
#         exit(0)  # Se fuori dal while (dalla riga 102 in poi) non c'è altro codice da eseguire, questo può essere break
#     else:
#         print("il risultato non è valido")



# ================================================================================================
# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Continua, all'infinito, ad eseguire le seguenti operazioni:
# 1. Chiedere un numero intero
# 1.2. Se il numero è positivo, allora stampare il suo quadrato
# 1.2. Altrimenti, se il numero è negativo, allora non fare nulla e chiedere il prossimo numero
# 1.3. Altrimenti, se il numero è esattamente 0, allora terminare il programma

# Scrivere qui sotto la soluzione:
# while True:
#     numero_inserito = int(input("Puoi inserire un numero intero? "))
#     if numero_inserito > 0:
#         print(f"Il quadrato di {numero_inserito} è: {numero_inserito ** 2}.")
#     elif numero_inserito < 0:
#         print("Il numero deve essere positivo.")
#     else:
#         print("Hai inserito 0, il programma ora si chiuderà.")
#         exit(0)


# Lezione 9 - Esercizio 1
# Scrivere un programma che chiede all'utente di inserire numeri interi positivi.
# Il programma deve determinare il numero minimo inserito dall'utente.
# Il ciclo termina quando l'utente inserisce "0".
#
# 1. Chiedere all'utente di inserire numeri interi positivi uno alla volta.
# 2. Ignorare tutti i numeri negativi utilizzando 'continue'.
# 3. Aggiornare e stampare il numero minimo ogni volta che viene inserito un nuovo numero valido.
# 4. Terminare il ciclo quando viene inserito "0".
#
# Note e consigli:
# - Utilizzare 'continue' per gestire eventuali numeri negativi.
# - Assicurarsi di resettare il minimo in modo appropriato.
# - Commentare il codice per spiegare il funzionamento del ciclo e delle condizioni.

# Scrivere qui sotto la soluzione:


# Lezione 9 - Esercizio 3
# Scrivere un programma che aiuta a tenere traccia delle spese. L'utente inserisce le spese finché
# il totale non supera il budget di 500€.
#
# 1. Chiedere all'utente di inserire una spesa alla volta.
# 2. Sommare le spese e termina il ciclo se il totale supera 500€.
# 3. Se l'utente inserisce un valore negativo, usare 'continue' per ignorarlo.
# 4. Alla fine, se il budget è stato superato, stampare un avviso.
#
# Note e consigli:
# - Utilizzare 'continue' per gestire le spese negative.
# - Tenere traccia del totale delle spese e confrontarlo con il budget.
# - Fornire feedback all'utente sullo stato del budget.

# Descrizione in linguaggio naturale schematizzato:
# 1. Vediamo il budget come una variabile che possiamo modificare che rappresenta i soldi che abbiamo a dispozione
#    Quindi, questo budget si ridurrà in base alle spese che facciamo, partendo da 500€
# 2. Finché abbiamo soldi (-> il budget è positivo)
#    a) chiediamo la nuova pesa che l'utente vuole effettuare
#    b) se questa spesa è un numero negativo, informiamo l'utente di ciò, non modifichiamo nulla e continuiamo all'iterazione successiva.
#    c) nel caso in cui la spesa fosse stata un numero positivo, possiamo, senza verificare nulla, decrementare il nostro budget della spesa effettuata.
#    d) se, a questo punto, il budget è diventato negativo, significa che l'utente ha finito i soldi. Quindi possiamo informarlo di ciò.
#    e) infine, mostriamo all'utente il suo budget rimanente.

budget = 500 

while budget > 0:
    print(f"Hai {budget:.2f}€ a disposizione.")
    spesa = float(input("Quanto vuoi spendere? "))

    if spesa < 0:
        print(f"AO, ma che stai a fa, vuoi spende {spesa:.2f}€. Magari si potesse fare così che ti ricaricano il conto quando spendi... Scrivi un valore realistico, pezzente.")
        continue
    
    budget -= spesa
    
print(f"Ti sei finito i soldi. Il conto è letteralmente in negativo, infatti hai {budget:.2f}€. \nPezzente.")

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:  # NICOLO' PUZZA

# numero = int(input("Salve, inserisci un numero intero positivo: "))

# if numero > 0: 
#     print(f"Il conto alla roverscia partirà da {numero}.")
# else:
#     print("Errore! Il numero che hai inserito non è positivo.")
#     exit(0)

# while numero > 0:
#     print(numero)
#     numero -= 1
#     time.sleep(1)

# print(0)


# ================================================================================================
# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Scrivere qui sotto la soluzione:

# psw = input("Inserire la password: ")

# while psw != password_corretta
#     print("Password errata!")
#     psw = input("Si prega di inserire la password corretta: ")

# print("Password corretta, accesso consentito.")

lez08_es2.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", altrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Scrivere qui sotto la soluzione:

lez08_es3.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualore l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e break e la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# Scrivere qui sotto la soluzione:

lez08_es1.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:

lez08_es3_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualore l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e break e la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# Scrivere qui sotto la soluzione:
while True:
    risultato_controllo = input("Qual è il risultato del controllo qualità? ")
    if risultato_controllo == "passato":
        continue
    elif risultato_controllo == "fallito":
        break
    elif risultato_controllo == "esci":
        exit(0)

print("Prodotto difettoso trovato, linea di produzione fermata.")

main.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Istruzione break - esempi base nei cicli while

# Esempio 1: Utilizzo di break per interrompere un ciclo while
# In questo esempio, utilizziamo un ciclo while per contare da 1 a 10.
# Se il contatore raggiunge il valore 5, interrompiamo il ciclo utilizzando l'istruzione break.
# Il programma stamperà solo i numeri da 1 a 5.
print("Esempio 1:")
contatore = 1
while contatore <= 10:
    print(contatore)
    if contatore == 5:
        break
    contatore += 1


# Esempio 2: Utilizzo di break per interrompere un ciclo while basato su un'input
# In questo esempio, chiediamo all'utente di inserire un numero.
# Utilizziamo un ciclo while per contare da 1 fino al numero inserito.
# Se il contatore raggiunge il valore 5, interrompiamo il ciclo utilizzando l'istruzione break.
# Il programma stamperà solo i numeri da 1 al numero inserito, fino a 5.
print("\nEsempio 2:")
numero = int(input("Inserisci un numero: "))
contatore = 1
while contatore <= numero:
    print(contatore)
    if contatore == 5:
        break
    contatore += 1

# Esempio 3: Utilizzo di break per interrompere un ciclo while basato su una condizione
# In questo esempio, utilizziamo un ciclo while per generare numeri casuali fino a quando non viene generato un numero pari.
# Utilizziamo l'istruzione break per interrompere il ciclo quando viene generato un numero pari.
# Il programma stamperà i numeri generati fino al numero pari.
import random
print("\nEsempio 3:")
while True:
    numero_casuale = random.randint(1, 100)
    print(numero_casuale)
    if numero_casuale % 2 == 0:
        break

# Esempio 4: Utilizzo di break per interrompere un ciclo while basato su una condizione complessa
# In questo esempio, utilizziamo un ciclo while per contare da 1 a 100.
# Utilizziamo l'istruzione break per interrompere il ciclo quando il contatore è multiplo di 3 e 5 contemporaneamente.
# Il programma stamperà i numeri da 1 a 15, escludendo i multipli di 3 e 5.
print("\nEsempio 4:")
contatore = 1
while contatore <= 100:
    if contatore % 3 == 0 and contatore % 5 == 0:
        break
    print(contatore)
    contatore += 1

# Istruzione continue - esempi base nei cicli while

# Esempio 1: Utilizzo di continue per saltare un'iterazione in un ciclo while
# In questo esempio, utilizziamo un ciclo while per contare da 1 a 10.
# Utilizziamo l'istruzione continue per saltare l'iterazione quando il contatore è pari.
# Il programma stamperà solo i numeri dispari da 1 a 10.
print("\nEsempio 1:")
contatore = 1
while contatore <= 10:
    if contatore % 2 == 0:
        print(contatore)
        contatore += 1
        continue
    print(contatore)
    print("DISPARI!")
    contatore += 1
    

lez08_es3.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 3
#
# Scrivere un programma che simula un processo di controllo qualità in una linea di produzione
# industriale. Il programma deve chiedere all'utente di inserire il risultato di un controllo
# qualità, che può essere "passato" o "fallito". Il programma continua a chiedere i risultati finché
# non viene inserito "fallito". Quando un controllo fallisce, stampare "Prodotto difettoso trovato,
# linea di produzione fermata." e terminare il programma. Qualore l'utente dovesse inserire la
# stringa "esci", invece, terminare immediatamente il programma senza ulteriori messaggi.
# 
# Note e consigli:
# - E' possibile utilizzare le istruzioni continue e break e la funzione exit(0), tuttavia non è
#   obbligatorio. Questo esercizio è il tipico esempio di esercizio risolvibile in innumerevoli modi
#   molto differenti tra loro.

# Scrivere qui sotto la soluzione:

esercizione_lezione7.py (clicca per mostrare il codice) Scarica (n. download: 10)

# Lezione 7 - Esercizione
# Creare un sistema per gestire le prenotazioni aeree per una compagnia aerea.
#
# 1. Il programma inizia chiedendo all'utente se vuole effettuare una nuova prenotazione o
#    modificare/cancellare una prenotazione esistente.
#    Risposte ammesse: "nuova", "modifica", "cancella". Risposte diverse causano la terminazione del
#    programma con un messaggio di errore.
#
# 2. Se l'utente sceglie "nuova":
#    - Chiedere la destinazione (es: "Roma", "Milano", "New York").
#    - Chiedere la classe di viaggio ("economica", "business", "prima classe").
#    - Chiedere se desidera aggiungere extra come "bagaglio extra" o "pasto speciale". Rispondere
#      con "sì" o "no".
#    - Calcolare il prezzo base del biglietto: 200€ per economica, 500€ per business, 1000€ per
#      prima classe.
#    - Aggiungere costi aggiuntivi se necessario: 50€ per bagaglio extra, 30€ per pasto speciale.
#    - Stampare il costo totale del biglietto.
#
# 3. Se l'utente sceglie "modifica":
#    - Chiedere il numero di prenotazione.
#    - Verificare che il numero di prenotazione esista (le prenotazioni esistenti sono indicate nel
#      database sottostante). Se non esiste, stampare un messaggio di errore e terminare.
#    - Chiedere quale aspetto della prenotazione desidera modificare ("destinazione", "classe",
#      "extra").
#    - Permettere all'utente di inserire il nuovo valore per l'opzione scelta e stampare un 
#      messaggio di conferma della modifica.
#
# 4. Se l'utente sceglie "cancella":
#    - Chiedere il numero di prenotazione.
#    - Verificare che il numero di prenotazione esista (vedi database sottostante).
#    - Se esiste, confermare la cancellazione e terminare il programma. Se non esiste, stampare un
#      messaggio di errore.
#    - Nota: ovviamente in questo esercizio non è possibile cancellare le prenotazioni, dal momento
#      che i dati sono fissi nel database. Quindi è sufficiente verificare che la prenotazione
#      esista e stampare un messaggio di conferma di cancellazione.
#
# Note e consigli:
# - Risolvere l'esercizio in modo generale, senza utilizzare i dati specifici delle prenotazioni, che
#   sono forniti solo a titolo di esempio.
# - Assicurarsi che tutti gli input siano validati adeguatamente.
# - Utilizzare if-elif-else annidati per gestire le varie opzioni e sotto-opzioni.
# - Commentare il codice per chiarire la logica e le decisioni di progettazione.
# - Mantenere una struttura chiara e leggibile, nonostante la complessità delle operazioni richieste.

# DATABASE:
# - Prenotazione 1:
numero_prenotazione_1 = 1001
destinazione_1 = "New York"
classe_1 = "economica"
extra_bagaglio_1 = "sì"
extra_pasto_1 = "no"

# - Prenotazione 2:
numero_prenotazione_2 = 1002
destinazione_2 = "Tokyo"
classe_2 = "prima classe"
extra_bagaglio_2 = "no"
extra_pasto_2 = "sì"

# Soluzione:
operazione = input("Vuoi effettuare una nuova prenotazione, modificarne una esistente o cancellarne una? (nuova/modifica/cancella): ")

# Opzioni ammesse: operazione == "nuova", operazione == "modifica" e operazione == "cancella". Tutto
# il resto non va bene.
if operazione == "nuova":
    destinazione = input("Inserisci la destinazione del volo: ")
    classe = input("Inserisci la classe di viaggio (economica/business/prima classe): ")
    extra_bagaglio = input("Desideri aggiungere un bagaglio extra? (sì/no): ")
    extra_pasto = input("Desideri aggiungere un pasto speciale? (sì/no): ")

    PREZZO_CLASSE_ECONOMICA = 200
    PREZZO_CLASSE_BUSINESS = 500
    PREZZO_PRIMA_CLASSE = 1000
    PREZZO_EXTRA_BAGAGLIO = 50
    PREZZO_EXTRA_PASTO = 30

    # Opzioni NON ammesse: tutto ciò che non è economica/business/prima classe
    # Se classe != "economica" e classe != "business" e classe != "prima classe" -> errore
    # In tutti gli altri casi, la classe va bene e possiamo fare i nostri calcoli
    if classe != "economica" and classe != "business" and classe != "prima classe":
        print("Classe di viaggio non valida.")
        # exit(0) - Non serve perché a prescindere, il codice dopo non viene eseguito.
    else:
        costo = 0

        # Calcolo del prezzo base del biglietto in base alla classe di viaggio scelta
        if classe == "economica":
            costo = PREZZO_CLASSE_ECONOMICA
        elif classe == "business":
            costo = PREZZO_CLASSE_BUSINESS
        else:  # Non serve scrivere elif classe == "business", perché se arriviamo a questo else,
               # allora classe è PER FORZA uguale a "prima classe", grazie alla condizione che
               # abbiamo scritto prima nell'if (sopra)
            costo = PREZZO_PRIMA_CLASSE
        
        # Calcolo del nuovo prezzo del biglietto in base alla scelta dell'extra bagaglio dell'utente
        if extra_bagaglio == "sì":
            costo += PREZZO_EXTRA_BAGAGLIO  # Equivalente a: costo = costo + PREZZO_EXTRA_BAGAGLIO
        elif extra_bagaglio == "no":
            print("Il bagaglio extra non è stato aggiunto, come richiesto.")
        else:
            print("Il bagaglio extra non è stato aggiunto perché la risposta non è valida.")

        # Calcolo del nuovo prezzo del biglietto in base alla scelta del pasto speciale dell'utente
        if extra_pasto == "sì":
            costo += PREZZO_EXTRA_PASTO
        elif extra_pasto == "no":
            print("Il pasto speciale non è stato aggiunto, come richiesto.")
        else:
            print("Il pasto speciale non è stato aggiunto perché la risposta non è valida.")

        print(f"Il prezzo totale del biglietto per {destinazione} in classe {classe} è di {costo}€.")
elif operazione == "modifica":
    numero_prenotazione = int(input("Inserisci il numero di prenotazione del volo che vuoi modificare: "))

    # Verifichiamo se il numero di prenotazione scelto dall'utente è un numero di prenotazione che esiste
    if numero_prenotazione == numero_prenotazione_1:
        aspetto_da_modificare = input("Cosa desideri modificare? (destinazione/classe/extra): ")

        # Verifichiamo che l'aspetto da modificare scelto dall'utente sia un aspetto da modificare consentito
        if aspetto_da_modificare == "destinazione":
            # Se l'utente vuole modificare la destinazione, chiediamo la nuova destinazione e la inseriamo nella variabile apposita
            destinazione_1 = input("Inserisci la nuova destinazione: ")
            print(f"La destinazione è stata modificata in: {destinazione_1}")
        elif aspetto_da_modificare == "classe":
            # Se l'utente vuole modificare la classe, chiediamo la nuova classe, verifichiamo che sia consentita e, se lo è, la modifichiamo
            classe_modificata = input("Inserisci la nuova classe di viaggio (economica/business/prima classe): ")

            if classe_modificata != "economica" and classe_modificata != "business" and classe_modificata != "prima classe":
                print("La classe scelta da modificare non è valida.")
            else:
                classe_1 = classe_modificata  # Assegnare una variabile (classe_modificata) a un'altra variabile (classe_1),
                                              # significa inserire in classe_1 il valore che contiene classe_modificata.
                print(f"La classe di viaggio è stata modificata in: {classe_1}")
        elif aspetto_da_modificare == "extra":
            # Se l'utente vuole modificare gli extra, gli chiediamo se vuole modificare la preferenza
            # per ognuno di essi, e in base alla sua risposta, modifichiamo le variabili apposite.
            modifica_extra_bagaglio = input(f"Qual è la tua nuova preferenza (attualmente: {extra_bagaglio_1}) per il bagaglio extra? (sì/no): ")

            if modifica_extra_bagaglio == "sì" or modifica_extra_bagaglio == "no":
                extra_bagaglio_1 = modifica_extra_bagaglio
            else:
                print(f"La risposta scelta non va bene. La preferenza per l'extra bagaglio non è stata modificata ed è rimasta: {extra_bagaglio_1}.")

            modifica_extra_pasto = input(f"Qual è la tua nuova preferenza (attualmente: {extra_pasto_1}) per il pasto extra? (sì/no): ")

            if modifica_extra_pasto == "sì" or modifica_extra_pasto == "no":
                extra_pasto_1 = modifica_extra_pasto
            else:
                print(f"La risposta scelta non va bene. La preferenza per l'extra pasto non è stata modificata ed è rimasta: {extra_pasto_1}.")

            print(f"Gli extra sono stati modificati. Ora sono:\nBagaglio extra: {extra_bagaglio_1}\nPasto speciale: {extra_pasto_1}")
        else:
            print("L'aspetto da modificare scelto non è valido. Nessuna modifica effettuata.")
    elif numero_prenotazione == numero_prenotazione_2:
        aspetto_da_modificare = input("Cosa desideri modificare? (destinazione/classe/extra): ")

        # Verifichiamo che l'aspetto da modificare scelto dall'utente sia un aspetto da modificare consentito
        if aspetto_da_modificare == "destinazione":
            # Se l'utente vuole modificare la destinazione, chiediamo la nuova destinazione e la inseriamo nella variabile apposita
            destinazione_2 = input("Inserisci la nuova destinazione: ")
            print(f"La destinazione è stata modificata in: {destinazione_2}")
        elif aspetto_da_modificare == "classe":
            # Se l'utente vuole modificare la classe, chiediamo la nuova classe, verifichiamo che sia consentita e, se lo è, la modifichiamo
            classe_modificata = input("Inserisci la nuova classe di viaggio (economica/business/prima classe): ")

            if classe_modificata != "economica" and classe_modificata != "business" and classe_modificata != "prima classe":
                print("La classe scelta da modificare non è valida.")
            else:
                classe_2 = classe_modificata  # Assegnare una variabile (classe_modificata) a un'altra variabile (classe_2),
                                              # significa inserire in classe_2 il valore che contiene classe_modificata.
                print(f"La classe di viaggio è stata modificata in: {classe_2}")
        elif aspetto_da_modificare == "extra":
            # Se l'utente vuole modificare gli extra, gli chiediamo se vuole modificare la preferenza
            # per ognuno di essi, e in base alla sua risposta, modifichiamo le variabili apposite.
            modifica_extra_bagaglio = input(f"Qual è la tua nuova preferenza (attualmente: {extra_bagaglio_2}) per il bagaglio extra? (sì/no): ")

            if modifica_extra_bagaglio == "sì" or modifica_extra_bagaglio == "no":
                extra_bagaglio_2 = modifica_extra_bagaglio
            else:
                print(f"La risposta scelta non va bene. La preferenza per l'extra bagaglio non è stata modificata ed è rimasta: {extra_bagaglio_2}.")

            modifica_extra_pasto = input(f"Qual è la tua nuova preferenza (attualmente: {extra_pasto_2}) per il pasto extra? (sì/no): ")

            if modifica_extra_pasto == "sì" or modifica_extra_pasto == "no":
                extra_pasto_2 = modifica_extra_pasto
            else:
                print(f"La risposta scelta non va bene. La preferenza per l'extra pasto non è stata modificata ed è rimasta: {extra_pasto_2}.")

            print(f"Gli extra sono stati modificati. Ora sono:\nBagaglio extra: {extra_bagaglio_2}\nPasto speciale: {extra_pasto_2}")
        else:
            print("L'aspetto da modificare scelto non è valido. Nessuna modifica effettuata.")
    else:
        print("Errore: Il numero di prenotazione inserito non è tra le prenotazioni esistenti.")
elif operazione == "cancella":
    numero_prenotazione = int(input("Inserisci il numero di prenotazione da eliminare: "))

    if numero_prenotazione == numero_prenotazione_1:
        print(f"Prenotazione {numero_prenotazione_1} cancellata.")
    elif numero_prenotazione == numero_prenotazione_2:
        print(f"Prenotazione {numero_prenotazione_2} cancellata.")
    else:
        print("Numero di prenotazione non valido.")
else:
    print("L'operazione scelta non è valida.")

lez08_es2_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", atrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Scrivere qui sotto la soluzione:
password = input("Inserisci la password: ")

while password != password_corretta:
    print("Password errata.")
    password = input("Inserisci la password: ")

print("Accesso consentito")

lez08_es1_sol_nick.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Lezione 8 - Esercizio 1
#
# Scrivere un programma che esegue un conto alla rovescia partendo da un numero intero positivo
# fornito in input dall'utente e arrivando fino a 0.
# 
# Note e consigli:
# - Verificare che il numero inserito dall'utente sia positivo
# - Utilizzare la funzione time.sleep(1) per aspettare 1 secondo

# Il codice qui sotto serve per la soluzione
import time

# Scrivere qui sotto la soluzione:
numero = int(input("Scrivi un numero intero positivo: "))

if numero < 0:
    print("Il numero deve essere positivo")
    exit(0)

while numero > 0:
    print(numero)
    numero -= 1
    time.sleep(1)

print("Fine del conto alla rovescia")

lez08_es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 4
#
# Scrivere un programma che continua a chiedere all'utente di inserire numeri interi. Il programma
# deve ignorare (NON elaborare) i numeri negativi inseriti, mentre deve stampare il quadrato (** 2)
# di tutti i numeri positivi inseriti. In altre parole, se il numero inserito è negativo, il
# programma non deve fare nulla e chiedere il prossimo numero. Se, invece, è positivo, il programma
# deve stampare il suo quadrato. Se l'utente inserisce, invece, il numero 0, il programma deve
# terminare.
# 
# Note e consigli:
# - Per l'elevazione a quadrato esiste l'operatore ** in Python (es.: 2 ** 3 -> 8)

# Scrivere qui sotto la soluzione:

lez08_es2.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Lezione 8 - Esercizio 2
#
# Scrivere un sistema di verifica della password. Il programma deve chiedere all'utente una password
# e, se la password è corretta, il programma deve stampare "Accesso consentito", atrimenti, la
# password deve essere inserita e verificata nuovamente e così via fino all'inserimento corretto.
# 
# Note e consigli:
# - La funzione input() può essere utilizzata anche per riassegnare una stessa variabile in un
#   secondo momento.

# Il codice qui sotto serve per la soluzione e non deve essere modificato
password_corretta = "Pythonata2024"

# Scrivere qui sotto la soluzione:

es2.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 2
# Analizza il seguente codice e determina quale sarà il valore stampato alla fine.
# Il programma calcola il punteggio finale basato su una serie di operazioni condizionali.

# Descrizione:
# Il programma inizia con un punteggio di base e modifica questo punteggio
# attraverso una serie di condizioni.

# Codice da analizzare:
punteggio = 50  # Punteggio iniziale

# Serie di condizioni per modificare il punteggio
if punteggio % 4 == 0:
    punteggio += 10
else:
    punteggio -= 5

if punteggio < 60:
    punteggio += 15
else:
    punteggio -= 15

if punteggio % 3 == 0:
    punteggio *= 2
elif punteggio % 5 == 0:
    punteggio -= 10
else:
    punteggio += 20

print("Il punteggio finale è:", punteggio)

# Domande:
# Senza eseguire il codice, quale pensi sarà il punteggio finale stampato?
# Quale sarebbe il punteggio finale se il programma venisse eseguito con punteggio = 100?

es2_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 2
# Analizza il seguente codice e determina quale sarà il valore stampato alla fine.
# Il programma calcola il punteggio finale basato su una serie di operazioni condizionali.

# Descrizione:
# Il programma inizia con un punteggio di base e modifica questo punteggio
# attraverso una serie di condizioni.

# Codice da analizzare:
punteggio = 50  # Punteggio iniziale

# Serie di condizioni per modificare il punteggio
if punteggio % 4 == 0:
    punteggio += 10
else:
    punteggio -= 5

if punteggio < 60:
    punteggio += 15
else:
    punteggio -= 15

if punteggio % 3 == 0:
    punteggio *= 2
elif punteggio % 5 == 0:
    punteggio -= 10
else:
    punteggio += 20

print("Il punteggio finale è:", punteggio)

# Domande:
# Senza eseguire il codice, quale pensi sarà il punteggio finale stampato? Il punteggio finale è: 120
# Quale sarebbe il punteggio finale se il programma venisse eseguito con punteggio = 100? Il punteggio finale è: 85

es4_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 4
# Creare un sistema di valutazione per gli studenti basato sui punteggi degli esami.
#
# 1. Il programma deve chiedere all'utente di inserire il punteggio ottenuto nello
#    esame. I punteggi validi sono compresi tra 0 e 30.
#
# 2. Se il punteggio è inferiore a 18, stampare "Esame fallito" e terminare il programma.
#
# 3. Se il punteggio è tra 18 e 20, stampare "Sufficiente".
#    Se il punteggio è tra 21 e 24, stampare "Buono".
#    Se il punteggio è tra 25 e 30, stampare "Ottimo".
#    In tutti questi casi, terminare poi il programma.
#
# Note e consigli:
# - Assicurarsi che l'input sia un numero intero valido entro il range specificato.
# - Commentare il codice per spiegare le decisioni di progettazione.

# Soluzione:
# Chiediamo all'utente di inserire il punteggio ottenuto
voto = int(input("Ciao bro, quanto hai preso all'esame? "))

if 0 <= voto < 18:
    print("Esame fallito.")
elif 18 <= voto <= 20:
    print("Sufficiente.")
elif 21 <= voto <= 24:
    print("Buono.")
elif 25 <= voto <= 30:
    print("Ottimo.")
else:
    print("Il punteggio inserito non è valido.")

es5.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 5
# Creare un'applicazione per la gestione delle prenotazioni in un hotel.
#
# 1. Il programma deve iniziare chiedendo all'utente il tipo di stanza desiderata.
#    Le opzioni sono: "singola", "doppia", "suite".
#
# 2. Chiedere all'utente il numero di notti di permanenza.
#
# 3. Calcolare il costo basato sul tipo di stanza e sul numero di notti:
#    - Singola: 70€ a notte
#    - Doppia: 120€ a notte
#    - Suite: 200€ a notte
#
# 4. Se la permanenza è superiore a 7 notti, applicare uno sconto del 10% sul totale.
#
# 5. Stampare il costo totale della prenotazione.
#
# Note e consigli:
# - Assicurarsi che il tipo di stanza inserito sia valido.
# - Il numero di notti dovrebbe essere un intero positivo.
# - Commentare il codice per spiegare il flusso e le scelte implementative.

# Soluzione:

es1_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 1
# Esamina il seguente codice e determina quale sarà il valore stampato alla fine.
# Assumi che l'input dell'utente sia sempre un intero valido.
#
# Descrizione:
# Il programma chiede all'utente di inserire un numero.
# In base al valore inserito, la variabile 'risultato' viene aggiornata.
# Il programma stampa il valore finale di 'risultato'.

# Codice da analizzare:
print("Inserisci un numero:")
numero = int(input())

risultato = 10  # Valore iniziale di 'risultato'

if numero > 50:
    risultato += 20
elif numero > 30:
    risultato += 10
elif numero > 20:
    risultato /=  2
else:
    risultato -= 5

if numero % 5 == 0:
    risultato *= 2

print("Il valore finale è:", risultato)

# Domande:
# 1. Cosa stampa il programma se l'input è 15? Il risultato finale è: 10
# 2. Cosa stampa il programma se l'input è 35? Il risultato finale è: 40
# 3. Cosa stampa il programma se l'input è 55? Il risultato finale è: 60
# 4. Cosa stampa il programma se l'input è 64? Il risultato finale è: 30
# 5. Cosa stampa il programma se l'input è 23? Il risultato finale è: 5.0

es1.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 1
# Esamina il seguente codice e determina quale sarà il valore stampato alla fine.
# Assumi che l'input dell'utente sia sempre un intero valido.
#
# Descrizione:
# Il programma chiede all'utente di inserire un numero.
# In base al valore inserito, la variabile 'risultato' viene aggiornata.
# Il programma stampa il valore finale di 'risultato'.

# Codice da analizzare:
print("Inserisci un numero:")
numero = int(input())

risultato = 10  # Valore iniziale di 'risultato'

if numero > 50:
    risultato += 20
elif numero > 30:
    risultato += 10
elif numero > 20:
    risultato /=  2
else:
    risultato -= 5

if numero % 5 == 0:
    risultato *= 2

print("Il valore finale è:", risultato)

# Domande:
# 1. Cosa stampa il programma se l'input è 15?
# 2. Cosa stampa il programma se l'input è 35?
# 3. Cosa stampa il programma se l'input è 55?
# 4. Cosa stampa il programma se l'input è 64?
# 5. Cosa stampa il programma se l'input è 23?

es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 4
# Creare un sistema di valutazione per gli studenti basato sui punteggi degli esami.
#
# 1. Il programma deve chiedere all'utente di inserire il punteggio ottenuto nell' esame. I punteggi
#    validi sono compresi tra 0 e 30.
#
# 2. Se il punteggio è inferiore a 18, stampare "Esame fallito" e terminare il programma.
#
# 3. Se il punteggio è tra 18 e 20, stampare "Sufficiente".
#    Se il punteggio è tra 21 e 24, stampare "Buono".
#    Se il punteggio è tra 25 e 30, stampare "Ottimo".
#    In tutti questi casi, terminare poi il programma.
#
# Note e consigli:
# - Assicurarsi che l'input sia un numero intero valido entro il range specificato.
# - Commentare il codice per spiegare le decisioni di progettazione.

# Soluzione:

lezione6_es5_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio
# Esamina il seguente codice e determina quale sarà l'output senza eseguirlo.
# Assumi che l'input dell'utente sia sempre un intero valido.
#
# Descrizione:
# Il programma chiede all'utente di inserire un numero.
# A seconda del numero inserito, il programma seguirà diverse diramazioni logiche
# e produrrà un output specifico.

# Codice da analizzare:
numero = int(input("Inserisci un numero: "))

if numero < 20:
    if numero % 2 == 0:
        if numero % 3 == 0:
            print("Il numero è divisibile per 6.")
        else:
            print("Il numero è pari ma non divisibile per 3.")
    elif numero % 3 == 0:
        print("Il numero è dispari e divisibile per 3.")
    else:
        print("Il numero è dispari e non divisibile per 6.")
elif numero < 40:
    if numero % 4 == 0:
        print("Il numero è divisibile per 4 ma minore di 40.")
    elif numero % 5 == 0:
        print("Il numero è divisibile per 5 ma minore di 40.")
    else:
        print("Il numero è maggiore o uguale a 20 ma minore di 40 e non divisibile né per 4 né per 5.")
else:
    if numero % 6 == 0:
        print("Il numero è divisibile per 6 e maggiore o uguale a 40.")
    else:
        print("Il numero è maggiore o uguale a 40 e non divisibile per 6.")

# Domande:
# 1. Cosa stampa il programma se l'input è 12? Il numero è divisibile per 6.
# 2. Cosa stampa il programma se l'input è 25? Il numero è divisibile per 5 ma minore di 40.
# 3. Cosa stampa il programma se l'input è 45? Il numero è maggiore o uguale a 40 e non divisibile per 6.

es3_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 3
# Creare un'applicazione che gestisce l'accesso a un evento.
#
# 1. Il programma deve chiedere all'utente di inserire la propria età.
#    Se l'età è inferiore a 18 anni, stampare un messaggio di errore e terminare
#    il programma.
#
# 2. Se l'età è 18 anni o più, chiedere all'utente se possiede un biglietto.
#    L'utente deve rispondere "sì" o "no". Qualsiasi altra risposta termina
#    il programma con un errore.
#
# 3. Se l'utente risponde "sì", stampare "Accesso consentito" e terminare il programma.
#    Se l'utente risponde "no", stampare "Accesso negato" e terminare il programma.
#
# Note e consigli:
# - Verificare sempre i dati inseriti dagli utenti prima di procedere.
# - Commentare il codice per spiegare le scelte implementative.

# Soluzione:
# Il programma dà il benvenuto
print("Buongiorno, benvenuto nell'applicazione di gestione eventi.")

# Chiediamo all'utente la sua età e la salviamo in una variabile apposita
età = int(input("Inserisci la tua età: "))

# Verifichiamo l'età dell'utente (deve essere maggiorenne)
if età < 18:
    print("Mi dispiace, l'accesso è consentito solo ai maggiorenni.")
    exit(0)

# Se l'utente è maggiorenne, chiediamo se possiede un biglietto
biglietto = input("Hai un biglietto? (sì/no): ")

# Verifichiamo la risposta dell'utente
if biglietto == "sì":
    print("Accesso consentito.")
elif biglietto == "no":
    print("Accesso negato.")
else:
    print("Risposta non valida.")

esercizione_lezione7.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizione
# Creare un sistema per gestire le prenotazioni aeree per una compagnia aerea.
#
# 1. Il programma inizia chiedendo all'utente se vuole effettuare una nuova prenotazione o
#    modificare/cancellare una prenotazione esistente.
#    Risposte ammesse: "nuova", "modifica", "cancella". Risposte diverse causano la terminazione del
#    programma con un messaggio di errore.
#
# 2. Se l'utente sceglie "nuova":
#    - Chiedere la destinazione (es: "Roma", "Milano", "New York").
#    - Chiedere la classe di viaggio ("economica", "business", "prima classe").
#    - In base alla classe, chiedere se desidera aggiungere extra come "bagaglio extra" o "pasto 
#      speciale". Rispondere con "sì" o "no".
#    - Calcolare il prezzo base del biglietto: 200€ per economica, 500€ per business, 1000€ per
#      prima classe.
#    - Aggiungere costi aggiuntivi se necessario: 50€ per bagaglio extra, 30€ per pasto speciale.
#    - Stampare il costo totale del biglietto.
#
# 3. Se l'utente sceglie "modifica":
#    - Chiedere il numero di prenotazione.
#    - Verificare che il numero di prenotazione esista (simula con un numero fisso, es: "12345"). Se
#      non esiste, stampare un messaggio di errore e terminare.
#    - Chiedere quale aspetto della prenotazione desidera modificare ("destinazione", "classe",
#      "extra").
#    - Permettere all'utente di inserire il nuovo valore per l'opzione scelta e stampare un 
#      messaggio di conferma della modifica.
#
# 4. Se l'utente sceglie "cancella":
#    - Chiedere il numero di prenotazione.
#    - Verificare che il numero di prenotazione esista (utilizza lo stesso numero di "modifica" per 
#      semplicità).
#    - Se esiste, confermare la cancellazione e terminare il programma. Se non esiste, stampare un
#      messaggio di errore.
#
# Note e consigli:
# - Assicurarsi che tutti gli input siano validati adeguatamente.
# - Utilizzare if-elif-else annidati per gestire le varie opzioni e sotto-opzioni.
# - Commentare il codice per chiarire la logica e le decisioni di progettazione.
# - Mantenere una struttura chiara e leggibile, nonostante la complessità delle operazioni richieste.

# DATABASE:
# - Prenotazione 1:
numero_prenotazione_1 = 1001
destinazione_1 = "New York"
classe_1 = "economica"
extra_bagaglio_1 = "sì"
extra_pasto_1 = "no"

# - Prenotazione 2:
numero_prenotazione_2 = 1002
destinazione_2 = "Tokyo"
classe_2 = "prima classe"
extra_bagaglio_2 = "no"
extra_pasto_2 = "sì"

# Soluzione:

l6_esercizione.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizione
# Creare un'applicazione bancaria che permette di effettuare
# un prelievo o un deposito monetario.
#
# 1. Il programma deve permettere di effettuare il login chiedendo,
#    separatamente, il nome utente e la password. Ci sono solo tre
#    utenti registrati (vedi sotto). Se il nome utente o la password
#    sono errati (ovvero, la coppia non è corretta oppure il nome
#    utente non esiste), printare un messaggio di errore e terminare
#    il programma.
#
# 2. Se il login è corretto, stampare il bilancio attuale del conto
#    e chiedere se l'operazione desiderata è "prelievo" oppure
#    "deposito". Qualunque altro inserimento risulta nella
#    terminazione del programma con un print di errore.
#    Aiuto: op = input("Prelievo (p) o deposito (d)? ")  # L'utente
#           quindi deve inserire la stringa "p" o "d", tutto il
#           resto non è valido
#   
# 3. Se l'operazione è di deposito, chiedere la cifra (si assume che
#    l'utente non faccia lo stupido e inserisca sempre un numero
#    intero), aggiornare il totale del conto e stamparlo a video,
#    terminando, poi, il programma.
#
# 4. Se l'operazione è di prelievo, invece, chiedere la cifra (anche
#    qui si assume che l'utente inserisca sempre un numero intero) e
#    verificare che il bilancio sia sufficiente. Se lo è, detrarlo
#    dal totale e stampare il nuovo bilancio a video, terminando,
#    poi, il programma. Se non lo è terminare il programma con un
#    messaggio di errore.
#
#
# Note e consigli:
# - Si chiede di commentare adeguatamente e abbondantemente il codice.
# - Si consiglia di eseguire molto spesso il codice per verificare
#   il risultato di ciò che si sta scrivendo.
# - Si ricorda di ragionare in modo generico, e non tenendo in
#   considerazione uno specifico utente. Anche perché quelli presenti
#   nel database qui sotto potrebbero essere modificati, o potrebbero
#   essere molti di più. Sono solo un esempio per poter fare i test.
# - Potrebbe essere necessario chiamare la funzione exit(0) che termina
#   il programma nel punto in cui viene chiamata
#
# -----===== DATABASE =====-----

# Utente 1
user1 = "nick"
psw1 = "ildrugodrago12"
bilancio1 = 200

# Utente 2
user2 = "biero"
psw2 = "FerrariPurosangue"
bilancio2 = 3000

# Utente 3
user3 = "ElonioMuschio"
psw3 = "mars_emperor"
bilancio3 = 10000

# -----===== SOLUZIONE =====-----
is_user1 = False
is_user2 = False
is_user3 = False

nome_utente = input("Inserisci il nome utente: ")
password = input("Inserisci la password: ")

if nome_utente != user1 and nome_utente != user2 and nome_utente != user3:
    print("Utente non esistente")
else:
    if nome_utente == user1 and password == psw1:
        is_user1 = True
        print(f"Il bilancio attuale è di {bilancio1} euro")
    elif nome_utente == user2 and password == psw2:
        is_user2 = True
        print(f"Il bilancio attuale è di {bilancio2} euro")
    elif nome_utente == user3 and password == psw3:
        is_user3 = True
        print(f"Il bilancio attuale è di {bilancio3} euro")
    else:
        print("Password errata")

    if is_user1 or is_user2 or is_user3:
        operazione = input("Prelievo (p) o deposito (d)? ")

        if operazione == "d":
            cifra = int(input("Inserisci la cifra da depositare: "))
            if is_user1:
                bilancio1 += cifra
                print(f"Il nuovo bilancio è di {bilancio1} euro")
            elif is_user2:
                bilancio2 += cifra
                print(f"Il nuovo bilancio è di {bilancio2} euro")
            elif is_user3:
                bilancio3 += cifra
                print(f"Il nuovo bilancio è di {bilancio3} euro")
        elif operazione == "p":
            cifra = int(input("Inserisci la cifra da prelevare: "))
            if is_user1:
                if bilancio1 < cifra:
                    print("Bilancio insufficiente")
                else:
                    bilancio1 -= cifra
                    print(f"Il nuovo bilancio è di {bilancio1} euro")
            elif is_user2:
                if bilancio2 < cifra:
                    print("Bilancio insufficiente")
                else:
                    bilancio2 -= cifra
                    print(f"Il nuovo bilancio è di {bilancio2} euro")
            elif is_user3:
                if bilancio3 < cifra:
                    print("Bilancio insufficiente")
                else:
                    bilancio3 -= cifra
                    print(f"Il nuovo bilancio è di {bilancio3} euro")
        else:
            print("Operazione non valida")

# -----===== FINE SOLUZIONE =====-----
print("Stato database:")
print(f"Utente 1: {bilancio1} euro")
print(f"Utente 2: {bilancio2} euro")
print(f"Utente 3: {bilancio3} euro")

es5_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 5
# Creare un'applicazione per la gestione delle prenotazioni in un hotel.
#
# 1. Il programma deve iniziare chiedendo all'utente il tipo di stanza desiderata.
#    Le opzioni sono: "singola", "doppia", "suite".
#
# 2. Chiedere all'utente il numero di notti di permanenza.
#
# 3. Calcolare il costo basato sul tipo di stanza e sul numero di notti:
#    - Singola: 70€ a notte
#    - Doppia: 120€ a notte
#    - Suite: 200€ a notte
#
# 4. Se la permanenza è superiore a 7 notti, applicare uno sconto del 10% sul totale.
#
# 5. Stampare il costo totale della prenotazione.
#
# Note e consigli:
# - Assicurarsi che il tipo di stanza inserito sia valido.
# - Il numero di notti dovrebbe essere un intero positivo.
# - Commentare il codice per spiegare il flusso e le scelte implementative.
# - Ricordarsi della possibilità di inserire costrutti if[-elif-else] all'interno di
#   altri costrutti if[-elif-else]

# Soluzione:
# Diamo il benvenuto all'utente
print("Benvenuto all'applicazione di prenotazione dell'hotel.")

# Chiediamo all'utente il tipo di stanza desiderata
tipo_stanza = input("Che tipo di stanza desideri? (singola/doppia/suite): ")

# Verifichiamo il tipo di stanza inserito
if tipo_stanza != "singola" and tipo_stanza != "doppia" and tipo_stanza != "suite":
    print("Tipo di stanza non valido.")
    exit(0)

# Chiediamo all'utente il numero di notti di permanenza
notti = int(input(f"Hai scelto una stanza {tipo_stanza}. Quante notti vuoi rimanere? "))

# Verifichiamo il numero di notti inserito
if notti <= 0:
    print("Il numero di notti deve essere un intero positivo.")
    exit(0)

# Definiamo i costi delle stanze in delle variabili per facilitare la modifica
costo_singola = 70
costo_doppia = 120
costo_suite = 200

# Calcoliamo il costo totale della prenotazione
if tipo_stanza == "singola":
    costo = costo_singola * notti
elif tipo_stanza == "doppia":
    costo = costo_doppia * notti
else:
    costo = costo_suite * notti

# Applichiamo lo sconto del 10% se la permanenza è superiore a 7 notti
if notti > 7:
    costo *= 0.9

# Stampiamo il costo totale della prenotazione
print(f"Il costo totale della prenotazione della stanza {tipo_stanza} per {notti} notti è di {costo}€.")

l6_es5.py (clicca per mostrare il codice) Scarica (n. download: 8)

# Esercizio
# Esamina il seguente codice e determina quale sarà l'output senza eseguirlo.
# Assumi che l'input dell'utente sia sempre un intero valido.
#
# Descrizione:
# Il programma chiede all'utente di inserire un numero.
# A seconda del numero inserito, il programma seguirà diverse diramazioni logiche
# e produrrà un output specifico.

# Codice da analizzare:
numero = int(input("Inserisci un numero: "))

if numero < 20:
    if numero % 2 == 0:
        if numero % 3 == 0:
            print("Il numero è divisibile per 6.")
        else:
            print("Il numero è pari ma non divisibile per 3.")
    elif numero % 3 == 0:
        print("Il numero è dispari e divisibile per 3.")
    else:
        print("Il numero è dispari e non divisibile per 6.")
elif numero < 40:
    if numero % 4 == 0:
        print("Il numero è divisibile per 4 ma minore di 40.")
    elif numero % 5 == 0:
        print("Il numero è divisibile per 5 ma minore di 40.")
    else:
        print("Il numero è maggiore o uguale a 20 ma minore di 40 e non divisibile né per 4 né per 5.")
else:
    if numero % 6 == 0:
        print("Il numero è divisibile per 6 e maggiore o uguale a 40.")
    else:
        print("Il numero è maggiore o uguale a 40 e non divisibile per 6.")

# Domande:
# 1. Cosa stampa il programma se l'input è 12?
# 2. Cosa stampa il programma se l'input è 25?
# 3. Cosa stampa il programma se l'input è 45?

es3.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 3
# Creare un'applicazione che gestisce l'accesso a un evento.
#
# 1. Il programma deve chiedere all'utente di inserire la propria età.
#    Se l'età è inferiore a 18 anni, stampare un messaggio di errore e terminare
#    il programma.
#
# 2. Se l'età è 18 anni o più, chiedere all'utente se possiede un biglietto.
#    L'utente deve rispondere "sì" o "no". Qualsiasi altra risposta termina
#    il programma con un errore.
#
# 3. Se l'utente risponde "sì", stampare "Accesso consentito" e terminare il programma.
#    Se l'utente risponde "no", stampare "Accesso negato" e terminare il programma.
#
# Note e consigli:
# - Verificare sempre i dati inseriti dagli utenti prima di procedere.
# - Commentare il codice per spiegare le scelte implementative.

# Soluzione:

esercizione_lezione7_soluzione_nick.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizione
# Creare un sistema per gestire le prenotazioni aeree per una compagnia aerea.
#
# 1. Il programma inizia chiedendo all'utente se vuole effettuare una nuova prenotazione o
#    modificare/cancellare una prenotazione esistente.
#    Risposte ammesse: "nuova", "modifica", "cancella". Risposte diverse causano la terminazione del
#    programma con un messaggio di errore.
#
# 2. Se l'utente sceglie "nuova":
#    - Chiedere la destinazione (es: "Roma", "Milano", "New York").
#    - Chiedere la classe di viaggio ("economica", "business", "prima classe").
#    - Chiedere se desidera aggiungere extra come "bagaglio extra" o "pasto speciale". Rispondere
#      con "sì" o "no".
#    - Calcolare il prezzo base del biglietto: 200€ per economica, 500€ per business, 1000€ per
#      prima classe.
#    - Aggiungere costi aggiuntivi se necessario: 50€ per bagaglio extra, 30€ per pasto speciale.
#    - Stampare il costo totale del biglietto.
#
# 3. Se l'utente sceglie "modifica":
#    - Chiedere il numero di prenotazione.
#    - Verificare che il numero di prenotazione esista (le prenotazioni esistenti sono indicate nel
#      database sottostante). Se non esiste, stampare un messaggio di errore e terminare.
#    - Chiedere quale aspetto della prenotazione desidera modificare ("destinazione", "classe",
#      "extra").
#    - Permettere all'utente di inserire il nuovo valore per l'opzione scelta e stampare un 
#      messaggio di conferma della modifica. Le opzioni modificabili sono le stesse della creazione.
#
# 4. Se l'utente sceglie "cancella":
#    - Chiedere il numero di prenotazione.
#    - Verificare che il numero di prenotazione esista (vedi database sottostante).
#    - Se esiste, confermare la cancellazione e terminare il programma. Se non esiste, stampare un
#      messaggio di errore.
#    - Nota: ovviamente in questo esercizio non è possibile cancellare le prenotazioni, dal momento
#      che i dati sono fissi nel database. Quindi è sufficiente verificare che la prenotazione
#      esista e stampare un messaggio di conferma di cancellazione.
#
# Note e consigli:
# - Risolvere l'esercizio in modo generale, senza utilizzare i dati specifici delle prenotazioni, che
#   sono forniti solo a titolo di esempio.
# - Assicurarsi che tutti gli input siano validati adeguatamente.
# - Utilizzare if-elif-else annidati per gestire le varie opzioni e sotto-opzioni.
# - Commentare il codice per chiarire la logica e le decisioni di progettazione.
# - Mantenere una struttura chiara e leggibile, nonostante la complessità delle operazioni richieste.

# DATABASE:
# - Prenotazione 1:
numero_prenotazione_1 = 1001
destinazione_1 = "New York"
classe_1 = "economica"
extra_bagaglio_1 = "sì"
extra_pasto_1 = "no"

# - Prenotazione 2:
numero_prenotazione_2 = 1002
destinazione_2 = "Tokyo"
classe_2 = "prima classe"
extra_bagaglio_2 = "no"
extra_pasto_2 = "sì"

# Soluzione:
operazione = input("Vuoi effettuare una nuova prenotazione, modificarne una esistente o cancellarne una? (nuova/modifica/cancella): ")

if operazione == "nuova":
    destinazione = input("Inserisci la destinazione del volo: ")
    classe = input("Inserisci la classe di viaggio (economica/business/prima classe): ")
    extra_bagaglio = input("Desideri aggiungere un bagaglio extra? (sì/no): ")
    extra_pasto = input("Desideri aggiungere un pasto speciale? (sì/no): ")

    prezzo_eco = 200
    prezzo_bus = 500
    prezzo_prima = 1000
    costo_extra_bagaglio = 50
    costo_extra_pasto = 30

    if classe != "economica" and classe != "business" and classe != "prima classe":
        print("Classe di viaggio non valida.")
    else:
        costo = 0
        if classe == "economica":
            costo = prezzo_eco
        elif classe == "business":
            costo = prezzo_bus
        else:
            costo = prezzo_prima

        if extra_bagaglio == "sì":
            costo += costo_extra_bagaglio
        elif extra_bagaglio == "no":
            print("Bagaglio extra non aggiunto.")
        else:    
            print("Risposta non valida. Il bagaglio extra non è stato aggiunto.")

        if extra_pasto == "sì":
            costo += costo_extra_pasto
        elif extra_pasto == "no":
            print("Pasto speciale non aggiunto.")
        else:
            print("Risposta non valida. Il pasto speciale non è stato aggiunto.")

        print(f"Il costo totale del biglietto per {destinazione} in classe {classe} è di {costo}€.")

elif operazione == "modifica":
    numero_prenotazione = int(input("Inserisci il numero di prenotazione: "))

    if numero_prenotazione == numero_prenotazione_1:
        aspetto = input("Cosa desideri modificare? (destinazione/classe/extra): ")

        if aspetto == "destinazione":
            destinazione_1 = input("Inserisci la nuova destinazione: ")
            print(f"La destinazione è stata modificata in: {destinazione_1}")
        elif aspetto == "classe":
            classe = input("Inserisci la nuova classe di viaggio (economica/business/prima classe): ")

            if classe != "economica" and classe != "business" and classe != "prima classe":
                print("Classe di viaggio non valida.")
            else:
                classe_1 = classe
                print(f"La classe di viaggio è stata modificata in: {classe_1}")
        elif aspetto == "extra":
            nuovo_extra_bagaglio = input("Desideri aggiungere un bagaglio extra? (sì/no): ")

            if nuovo_extra_bagaglio == "sì":
                extra_bagaglio_1 = "sì"
            elif nuovo_extra_bagaglio == "no":
                extra_bagaglio_1 = "no"
            else:
                print("Aspetto non valido. L'extra bagaglio non è stato modificato.")

            nuovo_extra_pasto = input("Desideri aggiungere un pasto speciale? (sì/no): ")

            if nuovo_extra_pasto == "sì":
                extra_pasto_1 = "sì"
            elif nuovo_extra_pasto == "no":
                extra_pasto_1 = "no"
            else:
                print("Aspetto non valido. L'extra pasto non è stato modificato.")

            print(f"Gli extra sono stati modificati. Ora sono:\nBagaglio extra: {extra_bagaglio_1}\nPasto speciale: {extra_pasto_1}")
        else:
            print("Aspetto non valido. Nessuna modifica effettuata.")
    elif numero_prenotazione == numero_prenotazione_2:
        aspetto = input("Cosa desideri modificare? (destinazione/classe/extra): ")

        if aspetto == "destinazione":
            destinazione_2 = input("Inserisci la nuova destinazione: ")
            print(f"La destinazione è stata modificata in: {destinazione_2}")
        elif aspetto == "classe":
            classe = input("Inserisci la nuova classe di viaggio (economica/business/prima classe): ")

            if classe != "economica" and classe != "business" and classe != "prima classe":
                print("Classe di viaggio non valida.")
            else:
                classe_2 = classe
                print(f"La classe di viaggio è stata modificata in: {classe_2}")
        elif aspetto == "extra":
            nuovo_extra_bagaglio = input("Desideri aggiungere un bagaglio extra? (sì/no): ")

            if nuovo_extra_bagaglio == "sì":
                extra_bagaglio_2 = "sì"
            elif nuovo_extra_bagaglio == "no":
                extra_bagaglio_2 = "no"
            else:
                print("Aspetto non valido. L'extra bagaglio non è stato modificato.")

            nuovo_extra_pasto = input("Desideri aggiungere un pasto speciale? (sì/no): ")

            if nuovo_extra_pasto == "sì":
                extra_pasto_2 = "sì"
            elif nuovo_extra_pasto == "no":
                extra_pasto_2 = "no"
            else:
                print("Aspetto non valido. L'extra pasto non è stato modificato.")

            print(f"Gli extra sono stati modificati. Ora sono:\nBagaglio extra: {extra_bagaglio_2}\nPasto speciale: {extra_pasto_2}")
        else:
            print("Aspetto non valido. Nessuna modifica effettuata.")
    else:
        print("Numero di prenotazione non valido.")

elif operazione == "cancella":
    numero_prenotazione = int(input("Inserisci il numero di prenotazione: "))

    if numero_prenotazione == numero_prenotazione_1:
        print("La prenotazione è stata cancellata.")
    elif numero_prenotazione == numero_prenotazione_2:
        print("La prenotazione è stata cancellata.")
    else:
        print("Numero di prenotazione non valido.")
else:
    print("Operazione non valida.")

es2b.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 2b
# Scrivere un programma che, a partire da tre numeri interi
# inseriti dall'utente, dica qual è il numero maggiore tra
# i tre, oppure se sono tutti e tre uguali.

# 1. Chiedere un primo numero intero all'utente
# 2. Chiedere un secondo numero intero all'utente
# 3. Chiedere un terzo numero intero all'utente
# 4. Verificare SE il primo è MAGGIORE del secondo E MAGGIORE del terzo
# 4.1 Se lo è, scriverlo
# 5. ALTRIMENTI, verificare SE il secondo è MAGGIORE del primo E MAGGIORE del terzo
# 5.1 Se lo è, scriverlo
# 6. ALTRIMENTI, verificare SE il terzo è MAGGIORE del primo E MAGGIORE del secondo
# 6.1 Se lo è, scriverlo
# 7. ALTRIMENTI, sono tutti e tre uguali, quindi, scriverlo

# Soluzione:
numero1= int(input("scrivi un primo numero: "))  # Step 1 OK
numero2= int(input("scrivi un secondo numero intero: ")) # Step 2 OK
numero3= int(input("scrivi un terzo numero intero: ")) # Step 3 OK

if (numero1 > numero2 and numero1 > numero3): # Step 4 OK
    print(f"il numero {numero1} è maggiore del numero {numero2} e maggiore del numero {numero3}") # Step 4.1 OK
elif (numero2 > numero1 and numero2 > numero3): # Step 5 OK
    print(f"il numero {numero2} è maggiore del numero {numero1} e del numero {numero3}") # Step 5.1 OK
elif (numero3 > numero1 and numero3 > numero2): # Step 6 OK
    print(f"il numero{numero3} è maggiore del numero {numero2} e del numero {numero3}")
else:
    print(f"i numeri {numero1, numero2,numero3} sono tutti e tre uguali" )

print(f"Il maggiore tra i tre numeri è {max(numero1, numero2, numero3)}")


# Una possibile soluzione è utilizzando la funzione built-in max()
# print("Il numero maggiore è", str(max(num1, num2, num3)))

# Tuttavia, si richiede di risolvere l'esercizio utilizzando
# le strutture condizionali

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 1
# Scrivere un programma che, a partire da un numero intero
# inserito dall'utente, dica se tale numero è pari o dispari
numero_scelto = int(input("Benvenuto utente, insersci un numero intero e ti dirò se è pari o dispari"))

if (numero_scelto % 2) == 0:
    print("Il numero che hai scelto è pari.")
else:
    print("Il numero che hai scelto è dispari")

# ----------------------------------------------------

# Esercizio 2
# Scrivere un programma che, a partire da due numeri interi
# inseriti dall'utente, dica qual è il numero maggiore tra i
# due oppure se sono uguali.

# print("Salve, dammi due numeri interi e ti dirò qual è il più grande o se sono uguali.")

# numero1 = int(input("Numero 1: "))
# numero2 = int(input("Numero 2: "))

# if numero1 == numero2:
#     print("I numero che hai scelto sono uguali.")
# else:
#     numero_max = max(numero1, numero2)
#     print("Il numero maggiore è:", numero_max)

# Esercizio 2b
# Scrivere un programma che, a partire da tre numeri interi
# inseriti dall'utente, dica qual è il numero maggiore tra
# i tre, oppure se sono tutti e tre uguali.

# print("Salve, dammi tre numeri interi e ti dirò qual è il più grande o se sono uguali.")

# numero1 = int(input("Numero 1: "))
# numero2 = int(input("Numero 2: "))
# numero3 = int(input("Numero 3: "))

# if numero1 == numero2 and numero1 == numero3 and numero2 == numero3:
#     print("I numero che hai scelto sono uguali.")
# elif numero1 > numero2 and numero1 > numero3:
#     print(f"Il numero, {numero1}, è quello maggiore tra i tre.")
# elif numero2 > numero3 and numero2 > numero1:
#     print("Il numero", numero2, "è quello maggiore tra i tre.")
# else:
#      print("Il numero", numero3, "è quello maggiore tra i tre.")

"""if numero1 == numero2 and numero1 == numero3 and numero2 == numero3:
    print("I numero che hai scelto sono uguali.")
else:
    print("Il numero maggiore è:", str(max(numero1, numero2, numero3)))"""

# ------------------------------------------------------------

# Esercizio 3
# Scrivere un programma che chieda all'utente una stringa
# composta da un solo carattere. Se la stringa fornita
# dall'utente è più lunga di un carattere, allora printare
# un messaggio di errore e terminare il programma. Altrimenti
# printare se la stringa è una vocale oppure no.
#
# Per la verifica della lunghezza della stringa si utilizzi la
# seguente funzione built-in: 
#       len(str) -> int

# lettera = input("Benvenuto, inserisci una lettera minuscola e ti dirò se è una vocale oppure una consonante: \n")

# if len(lettera) > 1:
#     print("Errore! Hai inserito più di una lettera.")
# else: 
#     if lettera == "a" or lettera == "e" or lettera == "i" or lettera == "o" or lettera == "u":
#         print(f"La lettera {lettera} è una vocale.")
#     else:
#         print(f"La lettera {lettera} è una consonante")

# ---------------------------------------------------------------

# Esercizio 4
# Scrivere un programma che chieda all'utente il suo
# reddito annuo e calcoli l'ammontare delle tasse
# dovute basandosi su semplici fasce di reddito:
# - Redditi fino a 10.000€: esenti da tasse
# - Redditi compresi tra 10.000€ e 20.000€: tassati al 10%
# - Redditi compresi tra 20.000€ e 30.000€: tassati al 20%
# - Redditi superiori a 30.000€: tassati al 30%
#
# Il programma deve mostrare l'ammontare delle tasse
# dovute secondo le suddette regole

reddito = float(input("Benvenuto, inserisci il tuo reddito annuo e posso calcolare le tasse che graveranno sul tuo reddito: \n"))

if reddito <= 10000:
    print(f"Il tuo reddito è esente da tasse.")
elif reddito <= 20000:
    tasse = reddito / 100 * 10
    print(f"Il tuo reddito di {reddito} € viene tassato al 10%, che corrisponde a {tasse} €.")
    reddito = reddito - tasse
    print(f" Il tuo nuovo reddito è di: {reddito} €.")
elif reddito <= 30000:
    tasse = reddito / 100 * 20
    print(f"Il tuo reddito di {reddito} € viene tassato al 20%, che corrisponde a {tasse} €.")
    reddito = reddito - tasse
    print(f" Il tuo nuovo reddito è di: {reddito} €.")
else:
    tasse = reddito / 100 * 30
    print(f"Il tuo reddito di {reddito} € viene tassato al 30%, che corrisponde a {tasse} €.")
    reddito = reddito - tasse
    print(f" Il tuo nuovo reddito è di: {reddito} €.")

es1.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 1
# Scrivere un programma che, a partire da un numero intero
# inserito dall'utente, dica se tale numero è pari o dispari

# 1. L'utente deve dare un numero OK
# 2. Verificare se il numero è pari o dispari OK
# 2.1. Se è pari si scrive che è pari OK
# 2.2. Se è dispari si scrive che è dispari

# Soluzione esercizio 1:
numero = int(input("inserisci numero: "))

# L'operatore % restituisce il resto della divisione (es.: 8 % 2 == 0)

if (numero % 2) == 0:
    print("il numero è pari")
else:
    print("il numero è dispari")

es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 4
# Scrivere un programma che chieda all'utente il suo
# reddito annuo e calcoli l'ammontare delle tasse
# dovute basandosi su semplici fasce di reddito:
# - Redditi fino a 10.000€: esenti da tasse
# - Redditi compresi tra 10.000€ e 20.000€: tassati al 10%
# - Redditi compresi tra 20.000€ e 30.000€: tassati al 20%
# - Redditi superiori a 30.000€: tassati al 30%
#
# Il programma deve mostrare l'ammontare delle tasse
# dovute secondo le suddette regole

#1 chiedi all'utente il suo reddito annuale
#2 SE il reddito è MINORE di 10.000 ALLORA le tasse sono pari a ZERO
#3 ALTRIMENTI per reddito tra 10.000 e 20.000 tasse sono pari al 10%
#4 ALTRIMENTI per reddito tra 20.000 e 30.000 le tasse sono pari al 20%
#5 ALTRIMENTI per reddito superiore al 30.000 le tasse sono pari al 30%


# Soluzione:
reddito_annuale = float(input("Quant'è il tuo reddito annuale? "))  # Step 1 OK

percentuale_primo_scaglione = 10
percentuale_secondo_scaglione = 20
percentuale_terzo_scaglione = 30

if reddito_annuale <= 10000:
    print("le tasse non sono presenti")
elif reddito_annuale > 10000 and reddito_annuale <= 20000:
    print(f"Devi pagare {(reddito_annuale * percentuale_primo_scaglione) / 100}€ di tasse")
elif reddito_annuale > 20000 and reddito_annuale <= 30000:
    print(f"devi pagare {reddito_annuale * percentuale_secondo_scaglione / 100}€ di tasse")
else:
    print(f"devi pagare {reddito_annuale * percentuale_terzo_scaglione / 100}€ di tasse")

es2.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 2
# Scrivere un programma che, a partire da due numeri interi
# inseriti dall'utente, dica qual è il numero maggiore tra i
# due oppure se sono uguali.

# 1. Chiedere all'utente di inserire un numero intero
# 2. Chiedere all'utente di inserire un altro numero intero
# 3. Verificare se il primo numero è maggiore del secondo
# 3.1. Se il primo numero è maggiore del secondo, allora scriverlo
# 3.2. Se il primo numero NON è maggiore del secondo, allora
#      verificare se sono uguali
# 3.2.1. Se sono uguali, scriverlo
# 3.2.2. Altrimenti, il primo è minore del secondo, quindi scriverlo

# Soluzione:
numero1=int(input("srivi un numero intero: "))  # Step 1 OK
numero2=int(input("srivi un altro numero intero: "))  # Step 2 OK

if numero1 > numero2: # Step 3.0 OK
    print(f"Il numero {numero1} è maggiore del numero {numero2}")  # Step 3.1 OK
    # Il numero 5 è maggiore del numero 2
elif numero1 == numero2:  # Step 3.2 OK
    print(f"il numero {numero1} è uguale al numero {numero2}")  # Step 3.2.1 OK
else:
    print(f"il numero {numero1} è minore del numero {numero2}") # Step 3.2.2 OK

es5.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio
# Esamina il seguente codice e determina quale sarà l'output senza eseguirlo.
# Assumi che l'input dell'utente sia sempre un intero valido.
#
# Descrizione:
# Il programma chiede all'utente di inserire un numero.
# A seconda del numero inserito, il programma seguirà diverse diramazioni logiche
# e produrrà un output specifico.

# Codice da analizzare:
numero = int(input("Inserisci un numero: "))

if numero < 20:
    if numero % 2 == 0:
        if numero % 3 == 0:
            print("Il numero è divisibile per 6.")
        else:
            print("Il numero è pari ma non divisibile per 3.")
    elif numero % 3 == 0:
        print("Il numero è dispari e divisibile per 3.")
    else:
        print("Il numero è dispari e non divisibile per 6.")
elif numero < 40:
    if numero % 4 == 0:
        print("Il numero è divisibile per 4 ma minore di 40.")
    elif numero % 5 == 0:
        print("Il numero è divisibile per 5 ma minore di 40.")
    else:
        print("Il numero è maggiore o uguale a 20 ma minore di 40 e non divisibile né per 4 né per 5.")
else:
    if numero % 6 == 0:
        print("Il numero è divisibile per 6 e maggiore o uguale a 40.")
    else:
        print("Il numero è maggiore o uguale a 40 e non divisibile per 6.")

# Domande:
# 1. Cosa stampa il programma se l'input è 12?
# 2. Cosa stampa il programma se l'input è 25?
# 3. Cosa stampa il programma se l'input è 45?

esercizione_lezione6.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizione
# Creare un'applicazione bancaria che permette di effettuare
# un prelievo o un deposito monetario.
#
# 1. Il programma deve permettere di effettuare il login chiedendo,
#    separatamente, il nome utente e la password. Ci sono solo tre
#    utenti registrati (vedi sotto). Se il nome utente o la password
#    sono errati (ovvero, la coppia non è corretta oppure il nome
#    utente non esiste), printare un messaggio di errore e terminare
#    il programma.
#
# 2. Se il login è corretto, stampare il bilancio attuale del conto
#    e chiedere se l'operazione desiderata è "prelievo" oppure
#    "deposito". Qualunque altro inserimento risulta nella
#    terminazione del programma con un print di errore.
#    Aiuto: op = input("Prelievo (p) o deposito (d)? ")  # L'utente
#           quindi deve inserire la stringa "p" o "d", tutto il
#           resto non è valido
#   
# 3. Se l'operazione è di deposito, chiedere la cifra (si assume che
#    l'utente non faccia lo stupido e inserisca sempre un numero
#    intero), aggiornare il totale del conto e stamparlo a video,
#    terminando, poi, il programma.
#
# 4. Se l'operazione è di prelievo, invece, chiedere la cifra (anche
#    qui si assume che l'utente inserisca sempre un numero intero) e
#    verificare che il bilancio sia sufficiente. Se lo è, detrarlo
#    dal totale e stampare il nuovo bilancio a video, terminando,
#    poi, il programma. Se non lo è terminare il programma con un
#    messaggio di errore.
#
#
# Note e consigli:
# - Si chiede di commentare adeguatamente e abbondantemente il codice.
# - Si consiglia di eseguire molto spesso il codice per verificare
#   il risultato di ciò che si sta scrivendo.
# - Si ricorda di ragionare in modo generico, e non tenendo in
#   considerazione uno specifico utente. Anche perché quelli presenti
#   nel database qui sotto potrebbero essere modificati, o potrebbero
#   essere molti di più. Sono solo un esempio per poter fare i test.
# - Potrebbe essere necessario chiamare la funzione exit(0) che termina
#   il programma nel punto in cui viene chiamata
#
# -----===== DATABASE =====-----

# Utente 1
user1 = "nick"
psw1 = "ildrugodrago12"
bilancio1 = 200

# Utente 2
user2 = "biero"
psw2 = "FerrariPurosangue"
bilancio2 = 3000

# Utente 3
user3 = "ElonioMuschio"
psw3 = "mars_emperor"
bilancio3 = 10000

# -----===== SOLUZIONE =====-----

es3.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 3
# Scrivere un programma che chieda all'utente una stringa
# composta da un solo carattere. Se la stringa fornita
# dall'utente è più lunga di un carattere, allora printare
# un messaggio di errore e terminare il programma. Altrimenti
# printare se la stringa è una vocale oppure no.

# 1. Chiedere all'utente una stringa
# 2. Verificare SE la stringa è PIU' LUNGA di 1
# 2.1 Se lo è, printare un messaggio di errore
# 3. ALTRIMENTI, verificare SE la stringa è una vocale
#    Verificare SE il carattere è a OPPURE e OPPURE i...
# 3.1 SE lo è, scriverlo
# 3.2 ALTRIMENTI, scrivere che non lo è

# Per la verifica della lunghezza della stringa si utilizzi la
# seguente funzione built-in: 
#       len(str) -> int

# Soluzione:
stringa = input("Puoi darmi una stringa? ")  # Step 1 OK

if len(stringa) > 1:  # Step 2 OK
    print("ERRORE MERDA")  # Step 2.1 OK
# elif (stringa == "A" or
#       stringa == "E" or
#       stringa == "I" or
#       stringa == "O" or
#       stringa == "U" or
#       stringa == "a" or
#       stringa == "e" or
#       stringa == "i" or
#       stringa == "o" or
#       stringa == "u"):  # Step 3 OK
else:
    stringa = stringa.lower()

    print(f"Stringa prima: {stringa}\nStringa dopo: {stringa}")

    if stringa in "aeiou":
        print("Vocale")
    else:
        print("NON vocale")

esercizione.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizione
# Creare un'applicazione bancaria che permette di effettuare
# un prelievo o un deposito monetario.
#
# 1. Il programma deve permettere di effettuare il login chiedendo,
#    separatamente, il nome utente e la password. Ci sono solo tre
#    utenti registrati (vedi sotto). Se il nome utente o la password
#    sono errati (ovvero, la coppia non è corretta oppure il nome
#    utente non esiste), printare un messaggio di errore e terminare
#    il programma.
#
# 2. Se il login è corretto, stampare il bilancio attuale del conto
#    e chiedere se l'operazione desiderata è "prelievo" oppure
#    "deposito". Qualunque altro inserimento risulta nella
#    terminazione del programma con un print di errore.
#    Aiuto: op = input("Prelievo (p) o deposito (d)? ")  # L'utente
#           quindi deve inserire la stringa "p" o "d", tutto il
#           resto non è valido
#   
# 3. Se l'operazione è di deposito, chiedere la cifra (si assume che
#    l'utente non faccia lo stupido e inserisca sempre un numero
#    intero), aggiornare il totale del conto e stamparlo a video,
#    terminando, poi, il programma.
#
# 4. Se l'operazione è di prelievo, invece, chiedere la cifra (anche
#    qui si assume che l'utente inserisca sempre un numero intero) e
#    verificare che il bilancio sia sufficiente. Se lo è, detrarlo
#    dal totale e stampare il nuovo bilancio a video, terminando,
#    poi, il programma. Se non lo è terminare il programma con un
#    messaggio di errore.
#
#
# Note e consigli:
# - Si chiede di commentare adeguatamente e abbondantemente il codice.
# - Si consiglia di eseguire molto spesso il codice per verificare
#   il risultato di ciò che si sta scrivendo.
# - Si ricorda di ragionare in modo generico, e non tenendo in
#   considerazione uno specifico utente. Anche perché quelli presenti
#   nel database qui sotto potrebbero essere modificati, o potrebbero
#   essere molti di più. Sono solo un esempio per poter fare i test.
#
# -----===== DATABASE =====-----

# Utente 1
user1 = "nick"
psw1 = "ildrugodrago12"
bilancio1 = 200

# Utente 2
user2 = "biero"
psw2 = "FerrariPurosangue"
bilancio2 = 3000

# Utente 3
user3 = "ElonioMuschio"
psw3 = "mars_emperor"
bilancio3 = 10000

# -----===== SOLUZIONE =====-----

es1.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 1
# Scrivere un programma che, a partire da un numero intero
# inserito dall'utente, dica se tale numero è pari o dispari

# Soluzione esercizio 1:
numero = input("Inserisci un numero intero: ")

numero = int(numero)

if numero % 2 == 0:
    print("Il numero è pari")
else:
    print("Il numero è dispari")

simone.py (clicca per mostrare il codice) Scarica (n. download: 7)

nome_utente_inserito = "ciao"
nome_utente_corretto = "ciao1"

password_inserita = "1234"
password_corretta = "12345"

posizione_conosciuta = True

print(nome_utente_inserito == nome_utente_corretto and password_inserita == password_corretta and posizione_conosciuta)

# Scrivere una condizione che verifichi che il nome utente e la password inseriti siano corretti

# -----------------------------------------------------

x = int()
y = int()

# Scrivere una condizione che è vera
# se x e y sono uguali oppure se uno
# è il doppio dell'altro

# La condizione dentro il print:
print(x == y or (x == 2(y) or y == 2(x)))

es2.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 2
# Scrivere un programma che, a partire da due numeri interi
# inseriti dall'utente, dica qual è il numero maggiore tra i
# due oppure se sono uguali.

# Soluzione:
num1 = int(input("Inserisci il primo numero: "))
num2 = int(input("Inserisci il secondo numero: "))

if num1 > num2:
    print(str(num1), "è maggiore di", str(num2))
elif num1 == num2:
    print("I due numeri sono uguali")
else:
    print(str(num2), "è maggiore di", str(num1))

es2b.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 2b
# Scrivere un programma che, a partire da tre numeri interi
# inseriti dall'utente, dica qual è il numero maggiore tra
# i tre, oppure se sono tutti e tre uguali.

# Soluzione:
num1 = int(input("Inserisci il primo numero: "))
num2 = int(input("Inserisci il secondo numero: "))
num3 = int(input("Inserisci il terzo numero: "))

# Una possibile soluzione è utilizzando la funzione built-in max()
print("Il numero maggiore è", str(max(num1, num2, num3)))

# Tuttavia, si richiede di risolvere l'esercizio utilizzando
# le strutture condizionali

es3.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 3
# Scrivere un programma che chieda all'utente una stringa
# composta da un solo carattere. Se la strica fornita
# dall'utente è più lunga di un carattere, allora printare
# un messaggio di errore e terminare il programma. Altrimenti
# printare se la stringa è una vocale oppure no.
#
# Per la verifica della lunghezza della stringa si utilizzi la
# seguente funzione built-in: 
#       len(str) -> int

# Soluzione:

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

nome_utente_inserito = ""
nome_utente_corretto = ""

password_inserita = ""
password_corretta = ""

# Sopra sono str

# Questo è un bool
posizione_conosciuta = True | False

# Scrivere una condizione che verifichi che il nome utente
# e la password inseriti siano corretti e che la posizione
# sia conosciuta
# ==, !=, >, <, >=, <=, or, and, not
print(nome_utente_inserito==nome_utente_corretto and password_inserita==password_corretta and posizione_conosciuta)

# -----------------------------------------------------

x = int()
y = int()

# Scrivere una condizione che è vera
# se x e y sono uguali oppure se uno
# è il doppio dell'altro

# La condizione dentro il print:
print(x == y or (x == 2*y or y == 2*x)) 

davide.py (clicca per mostrare il codice) Scarica (n. download: 8)

# nome_utente_inserito = ""
# nome_utente_corretto = ""

# password_inserita = ""
# password_corretta = ""

# posizione_conosciuta = True

# # Scrivere una condizione che verifichi che il nome utente e la password inseriti siano corretti e che la posizione sia conosciuta

# nome_utente_inserito == nome_utente_corretto and password_inserita == password_corretta and posizione_conosciuta

# -----------------------------------------------------------------------------------------------------------------------

# x = int()
# y = int()

# # Scrivere una condizione che è vera
# # se x e y sono uguali oppure se uno
# # è il doppio dell'altro

# # La condizione dentro il print:
# print(x == y or (x == 2*y or y == 2*x))

# -------------------------------------------------------------------------------------

es4.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Esercizio 4
# Scrivere un programma che chieda all'utente il suo
# reddito annuo e calcoli l'ammontare delle tasse
# dovute basandosi su semplici fasce di reddito:
# - Redditi fino a 10.000€: esenti da tasse
# - Redditi compresi tra 10.000€ e 20.000€: tassati al 10%
# - Redditi compresi tra 20.000€ e 30.000€: tassati al 20%
# - Redditi superiori a 30.000€: tassati al 30%
#
# Il programma deve mostrare l'ammontare delle tasse
# dovute secondo le suddette regole

# Soluzione:

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

# mimi_ti_amo = input("Scrivi una parola: ")
# print(mimi_ti_amo)

# Scrivere un programma che, a partire da un saldo iniziale
# lo mostra a schermo, poi chiede all'utente una spesa da
# effettuare e, infine, mostra a schermo il saldo rimanente
# dopo la spesa inserita dall'utente
"""
saldo = 200
print("saldo disponibile", saldo)
spesa = input("spesa da effettuare: ")
spesa = float(spesa)
saldo_rimanente = saldo - spesa
# ALTRIMENTI
# saldo -= spesa (EQUIVALENTE A saldo = saldo - spesa)
print("saldo rimanente", saldo_rimanente)
"""

# ESERCIZIO 2
# Scrivere un programma che effettua semplici calcoli
# Il programma deve:
# 1. Scrivere un messaggio di benvenuto all'esecuzione,
#    chiedendo il nome dell'utente e salutandolo.
# 2. Chiedere all'utente tre numeri qualsiasi
# 3. Sommare i tre numeri e mostrare il risultato all'utente
# 4. Chiedere un quarto numero all'utente
# 5. Sottrarlo alla somma fatta prima e stampare il risultato
#    della sottrazione finale
# 6. Salutare l'utente
# 
# Note aggiuntive:
# - Commentare il codice per spiegare tutti i passaggi che fate
# - Utilizzare i print per mostrare, eventualmente e se lo
#   ritenete necessario, i valori mano a mano (facoltativo)

# INIZIO STEP 1
x = input("ciao benvenuto, come ti chiami? ")  # chiede al bro come si chiama e lo saluta
print("ciao", x)  # io saluto il bro 
# FINE STEP 1

# INIZIO STEP 2
# chiedo al bro di dirmi tre numeri casuali e poi li converto in float
numero1 = input("dimmi 1 numero ") 
numero2 = input("dimmi un altro numero ")
numero3 = input("dimmi l'ultimo ")
numero1 = float(numero1)
numero2 = float(numero2)
numero3 = float(numero3)
# FINE STEP 2

# INIZIO STEP 3: Sommare i tre numeri e mostrare il risultato all'utente
somma = numero1 + numero2 + numero3
print(somma)
# FINE STEP 3

# INIZIO STEP 4: Chiedere un quarto numero all'utente

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

# numero = input("Scrivi un numero: ")
# print(numero)

#print(input("Scrivi un numero: "))

# Scrivere un programma che, a partire da un saldo iniziale
# lo mostra a schermo, poi chiede all'utente una spesa da
# effettuare e, infine, mostra a schermo il saldo rimanente
# dopo la spesa inserita dall'utente

"""saldo = 200
print("Il tuo saldo iniziale è", saldo, "€")
spesa = input("Quanti soldi vuoi spendere?\n")
# spesa = int(spesa)
spesa = float(spesa)
saldo2 = saldo - spesa
print("Il tuo saldo rimanente è:", saldo2, "€")"""
"""povertà = 100
povertà = int(povertà)
if saldo2 < povertà"""

# ESERCIZIO 2
# Scrivere un programma che effettua calcoli
# Il programma deve:
# 1. Scrivere un messaggio di benvenuto all'esecuzione,
#    salutando l'utente e chiedendo il suo nome.
# 2. Chiedere all'utente tre numeri qualsiasi
# 3. Sommare i tre numeri e mostrare il risultato all'utente
# 4. Chiedere un quarto numero all'utente
# 5. Sottrarlo alla somma fatta prima e stampare il risultato
#    della sottrazione finale
# 6. Salutare l'utente
# 
# Note aggiuntive:
# - Commentare il codice per spiegare tutti i passaggi che fate
# - Utilizzare i print per mostrare, eventualmente e se lo
#   ritenete necessario, i valori mano a mano (facoltativo)

nome_utente = input("Salve caro utente, io sono Biero, lei come si chiama?")  # Il programma chiede il nome all'utente e lo saluta
print("Salve", nome_utente, "le va di fare un gioco? La prego, scriva tre numeri interi")  # Il programma chiederà ora 3 numeri all'utente in sequenza

primo_numero = input("Primo numero: ")  # Il programma chiede il primo numero all'utente
secondo_numero = input("Secondo numero: ")  # Il programma chiede il secondo numero all'utente
terzo_numero = input("Terzo numero: ")  # Il programma chiede il terzo numero all'utente
primo_numero = int(primo_numero)  # Il programma trasforma i numeri inseriti dall'utente in "int"
secondo_numero = int(secondo_numero)
terzo_numero = int(terzo_numero)

print("Adesso sommerò questi tre numeri")
somma = primo_numero + secondo_numero + terzo_numero  # Il programma ora somma i tre numeri forniti dall'utente
print("La somma dei tre nummeri che mi ha fornito è:", somma)  # Il programma mostra il risultato della somma all'utente

quarto_numero = input(nome_utente + "mi fornisca un altro numero intero, prego: ")  # Il programma chiede il quarto numero all'utente
quarto_numero = int(quarto_numero)  # Il programma converte il numero in "int"

print("Adesso sottrarrò quel numero alla somma dei tre numeri precedenti")
sottrazione = somma - quarto_numero  # Il programma sottrae il 4° numero alla somma dei tre
print("Il risultato finale di queste operazioni è:", sottrazione)  # Il programma mostra il risultato finale delle operazioni

input("Sei soddisfatto del risultato?\n")
print("Non me ne frega un cazzo,", nome_utente, "sei uno stronzo")  # Il programma sfancula l'utente
print("Addio")

main.py (clicca per mostrare il codice) Scarica (n. download: 7)

# LEZIONE 4 - 07/09/2024

# Funzione built-in input()

qualcosa = input("Scrivi qualcosa: ")
print(qualcosa)

# ESERCIZIO 2
# Scrivere un programma che effettua semplici calcoli
# Il programma deve:
# 1. Scrivere un messaggio di benvenuto all'esecuzione,
#    chiedendo il nome dell'utente e salutandolo.
# 2. Chiedere all'utente tre numeri qualsiasi
# 3. Sommare i tre numeri e mostrare il risultato all'utente
# 4. Chiedere un quarto numero all'utente
# 5. Sottrarlo alla somma fatta prima e stampare il risultato
#    della sottrazione finale
# 6. Salutare l'utente
# 
# Note aggiuntive:
# - Commentare il codice per spiegare tutti i passaggi che fate
# - Utilizzare i print per mostrare, eventualmente e se lo
#   ritenete necessario, i valori mano a mano (facoltativo)

# INIZIO STEP 1
x = input("ciao benvenuto, come ti chiami? ")  # chiede al bro come si chiama e lo saluta
print("ciao", x)  # io saluto il bro 
# FINE STEP 1

# INIZIO STEP 2
# chiedo al bro di dirmi tre numeri casuali e poi li converto in float
numero1 = input("dimmi 1 numero ") 
numero2 = input("dimmi un altro numero ")
numero3 = input("dimmi l'ultimo ")
numero1 = float(numero1)
numero2 = float(numero2)
numero3 = float(numero3)
# FINE STEP 2

# INIZIO STEP 3: Sommare i tre numeri e mostrare il risultato all'utente
somma = numero1 + numero2 + numero3
print(somma)
# FINE STEP 3

# INIZIO STEP 4: Chiedere un quarto numero all'utente
numero4 = input("dimmi un quarto numero")
numero4 = float(numero4)
# FINE STEP 4

# INIZIO STEP 5: Sottrarlo alla somma fatta prima e stampare il risultato della sottrazione finale
sottrazione= somma - numero4
print(sottrazione)
# FINE STEP 5

# INIZIO STEP 6: Salutare l'utente
print("ciao", x)
# FINE STEP 6

yasmine.py (clicca per mostrare il codice) Scarica (n. download: 7)

def somma_moltiplica_e_somma(a, b):
    x = a + b
    y = a * b 
    z = x + y
    return z

a = 5
b = 10
# Invertite il contenuto delle variabili

# QUI SOTTO LA VOSTRA
c = a 
a = b 
b = c


# RISULTATO
print("a: ", a)
print("b: ", b)
# Deve uscire fuori: a: 10
#                    b: 5

alessia.py (clicca per mostrare il codice) Scarica (n. download: 7)

def somma_moltiplicazione_somma(a, b):
    x = a+b
    y = a*b
    return x+y

a = 5
b = 10
# Invertite il contenuto delle variabili

# QUI SOTTO LA VOSTRA ESECUZIONE
c = a
a = b
b = c 

# RISULTATO
print("a: ", a)
print("b: ", b)
# Deve uscire fuori: a: 10
#                    b: 5

simone.py (clicca per mostrare il codice) Scarica (n. download: 7)

def somma(a, b):
    c=a+b
    d=a*b
    e=c+d
    return e

a = 5
b = 10


c = a
a = b
b = c
 
print("a: ", a)
print("b: ", b)

funzioni.py (clicca per mostrare il codice) Scarica (n. download: 7)

from alessia import somma_moltiplicazione_somma as f_alessia
from simone import somma as f_simone
from davide import somma_moltiplica_e_somma as f_davide
from yasmine import somma_moltiplica_e_somma as f_yasmine

def somma_moltiplica_e_somma(a, b=3):
    somma = a + b
    moltiplicazione = a * b
    risultato_finale = somma + moltiplicazione
    return risultato_finale

var1 = 5
var2 = 3

# Risultati
risultato_nick = somma_moltiplica_e_somma(var1, var2)  # Commento post-istruzione
print("Risultato nick: ", risultato_nick)
risultato_ale = f_alessia(var1, var2)
print("Risultato alessia: ", risultato_ale)
risultato_simone = f_simone(var1, var2)
print("Risultato simone: ", risultato_simone)
risultato_davide = f_davide(var1, var2)
print("Risultato davide: ", risultato_davide)
risultato_yasmine = f_yasmine(var1, var2)
print("Risultato yasmine: ", risultato_yasmine)

davide.py (clicca per mostrare il codice) Scarica (n. download: 7)

def somma_moltiplica_e_somma(a, b):
    # print("Se n'i mondo esistesse un po' di bene e ognun si 'onsiderasse suo fratello, ci sarebbero men pensieri e meno pene, ed il mondo ne sarebbe assai più bello")
    x = a + b
    y = a * b
    return x + y

a = 5
b = 10
# Invertite il contenuto delle variabili

# QUI SOTTO LA VOSTRA ESECUZIONE
x = a
a = b
b = x

# RISULTATO
print("a: ", a)
print("b: ", b)
# Deve uscire fuori: a: 10
#                    b: 5

main.py (clicca per mostrare il codice) Scarica (n. download: 7)

# Commento a linea singola
print("ciao")

""" daiwdnwida
ciadoafnadjoanfojafdnjasjdsa
print("ciao")

dnkalwfdnjawdk
"""
print("ciao")

print("Ciao1\nCiao2")

# Numeri
# Numeri interi (int)
4
-12
473892048782934
# Numeri decimali, numeri floating point (float)
4.0
-12.4
3.14531441831494130

print(0b1101)
print(0o777)
print(0x0AC2B3)

# Stringhe (str)
"Ciao"
'Ciao'

"L'albero"

# Booleani (bool)
True
False

# None (NoneType)
None

tipo_di_print = type(print)

print(tipo_di_print)

def funzione():
    return 5

print(type(funzione()))

var1 = 4
var2 = funzione()

print(var1 == var2)

# ===============================================
# OPERATORI
-5
print(-(-5))

# Operatori matematici 
3.0 + 3 # addizione (risultato 6)
4 - 3 # sottrazione (ris 1)
2 * 4 # moltiplicazione (ris 8)
3 / 2 # divisione (ris 1.5)
3 ** 4 # potenza (ris 81)
4 % 3 # modulo (ris 1)
3 // 2 # divisione intera (ris 1) [TOGLIE LA PARTE DECIMALE]

# print("ciao" / 2)

# Operatori di assegnamento
# =
x = 7

x += 6
# è uguale a fare:
x = x + 6

# *=
x = x * 6
# /=
x = x / 6
# -=
x = x - 6

# Operatori di confrontong
print("ciao" == 'ciao')
print(5 != 5)
print(5 > 5)
print(5 < 5)
print(5 >= 5)
print(5 <= 5)

print("CIAO" > "Ciao")

print("SEPARATORE")

# Operatori logici
# and or not
print(5 == 5 and 4 == 4)
print(5 == 5 and 5 == 4)

print(5 == 5 or 4 == 4)
print(5 == 5 or 4 == 3)
print(4 == 3 or 7 == 123)

print(not (5 == 5))

# VARIABILI

x = 6
x = 0.1

a = 5
b = 10

a, b = b, a
print("a: ", a)
print("b: ", b)
# AIUTO NON SO COSSA STO FACENDO