├── .gitignore ├── .replit ├── 240310_L01 ├── compito.py └── main.py ├── 240317_L02 ├── compito.py └── main.py ├── 240324_L03 ├── compito.py └── main.py ├── 240330_L04 ├── compito.py └── main.py ├── 240407_L05 ├── compito.py └── main.py ├── 240412_L06 ├── compito.py └── main.py ├── 240421_L07 └── readme.txt ├── 240505_L08 ├── compito.py └── main.py ├── 240512_L09 ├── compito.py └── main.py ├── poetry.lock ├── pyproject.toml └── readme.md /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # poetry 98 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 99 | # This is especially recommended for binary packages to ensure reproducibility, and is more 100 | # commonly ignored for libraries. 101 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 102 | #poetry.lock 103 | 104 | # pdm 105 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 106 | #pdm.lock 107 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 108 | # in version control. 109 | # https://pdm.fming.dev/#use-with-ide 110 | .pdm.toml 111 | 112 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 113 | __pypackages__/ 114 | 115 | # Celery stuff 116 | celerybeat-schedule 117 | celerybeat.pid 118 | 119 | # SageMath parsed files 120 | *.sage.py 121 | 122 | # Environments 123 | .env 124 | .venv 125 | env/ 126 | venv/ 127 | ENV/ 128 | env.bak/ 129 | venv.bak/ 130 | 131 | # Spyder project settings 132 | .spyderproject 133 | .spyproject 134 | 135 | # Rope project settings 136 | .ropeproject 137 | 138 | # mkdocs documentation 139 | /site 140 | 141 | # mypy 142 | .mypy_cache/ 143 | .dmypy.json 144 | dmypy.json 145 | 146 | # Pyre type checker 147 | .pyre/ 148 | 149 | # pytype static type analyzer 150 | .pytype/ 151 | 152 | # Cython debug symbols 153 | cython_debug/ 154 | 155 | # PyCharm 156 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 157 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 158 | # and can be added to the global gitignore or merged into this file. For a more nuclear 159 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 160 | #.idea/ -------------------------------------------------------------------------------- /.replit: -------------------------------------------------------------------------------- 1 | entrypoint = "240512_L09/main.py" 2 | #entrypoint = "240412_L06/compito.py" 3 | modules = ["python-3.10:v18-20230807-322e88b"] 4 | 5 | [nix] 6 | channel = "stable-23_05" 7 | 8 | [unitTest] 9 | language = "python3" 10 | 11 | [gitHubImport] 12 | requiredFiles = [".replit", "replit.nix"] 13 | 14 | [deployment] 15 | run = ["python3", "main.py"] 16 | deploymentTarget = "cloudrun" 17 | -------------------------------------------------------------------------------- /240310_L01/compito.py: -------------------------------------------------------------------------------- 1 | # Date due variabili a e b, invertirne il contenuto 2 | # il codice deve funzionare impostando *qualunque* valore di 3 | # a e b 4 | a = 5 5 | b = 11 6 | 7 | print(a) 8 | print(b) 9 | 10 | # qui la prima soluzione 11 | #a = 11 12 | #b = 5 13 | 14 | # inserire ulteriori soluzioni qui 15 | c = a 16 | a = b 17 | b = c 18 | 19 | print(a) 20 | print(b) -------------------------------------------------------------------------------- /240310_L01/main.py: -------------------------------------------------------------------------------- 1 | # creo una variabile di nome pippo 2 | # e vi assegno il valore 5 3 | pippo = 5 4 | 5 | # stampo il valore di pippo 6 | #print(pippo) 7 | 8 | # assegnato il valore 10 a pippo 9 | pippo = 10 10 | 11 | # richiamo la funzione print con parametro pippo 12 | # print è il nome della funzione 13 | # fra le parentesi c'è il parametro pippo 14 | #print(pippo) 15 | 16 | chat = 5 17 | 18 | enk = chat + chat 19 | 20 | base = 5 21 | altezza = 10 22 | 23 | area = base * altezza 24 | 25 | print(enk) 26 | -------------------------------------------------------------------------------- /240317_L02/compito.py: -------------------------------------------------------------------------------- 1 | # Scrivere un programma chiamato numerator 2 | # Il programma deve: 3 | # - Scrivere un messaggio di benvenuto al lancio, indicando il suo nome 4 | # - Chiedere all'utente quattro numeri 5 | # - Sommare i numeri e stamparli a video 6 | # - Chiedere un quinto numero 7 | # - Sottrarlo dalla somma precedente e stamparlo a video 8 | 9 | # Usare se necessario delle stampe per spiegare i valori che vengono mostrati all'utente 10 | 11 | 12 | # chiedo il nome utente 13 | nome_utente = input("Benvenuto coglioncello! Come ti chiami?\n") 14 | 15 | # chiedo i quattro numeri 16 | num1 = input("Bene, " + nome_utente + ", ora dimmi quattro numeri!\n") 17 | num2 = input() 18 | num3 = input() 19 | num4 = input() 20 | 21 | # casto i numeri a float 22 | num1 = float(num1) 23 | num2 = float(num2) 24 | num3 = float(num3) 25 | num4 = float(num4) 26 | 27 | risultato1 = num1 + num2 + num3 + num4 28 | print("Somma dei tuoi numeri è:", risultato1) 29 | 30 | num5 = input("Bravo stupido, ora dammi un altro numero... \n") 31 | num5 = float(num5) 32 | 33 | risultato2 = risultato1 - num5 34 | 35 | print("Il risultato finale è", risultato2) -------------------------------------------------------------------------------- /240317_L02/main.py: -------------------------------------------------------------------------------- 1 | ######### Tipi di dati (e variabili) ######## 2 | 3 | # le variabili contengono uno e un solo dato 4 | # questo dato ha un tipo (e quindi la variabile ha quel tipo) 5 | a = 10.2 # float (con la virgola) 6 | b = 10 # int (intero) 7 | c = "ciao" # str (stringa, notare le virgolette!) 8 | 9 | # possiamo leggere il tipo di una variabile 10 | # con la funzione type 11 | tipo_di_c = type(c) 12 | 13 | # + è un operatore che si comporta diversamente 14 | # a seconda dei tipi di variabili che ha intorno 15 | # int + int => int 16 | # float + float => float 17 | # int + float => float 18 | # str + str => str 19 | print(c) 20 | print(tipo_di_c) 21 | 22 | # chiedere a un utente un dato 23 | # input ritorna SEMPRE una stringa 24 | # si noti l'uso di \n, un carattere speciale 25 | # per andare a capo 26 | dato_da_utente = input("Metti il nome utente:\n") 27 | 28 | 29 | ######### Casting ######## 30 | 31 | # Il casting permette di convertire le variabili da un tipo 32 | # ad un altro 33 | # data una variabile x 34 | # se voglio castare a str uso str(x) 35 | # se voglio castare a int uso int(x) 36 | # se voglio castere a float uso float(x) 37 | 38 | # Esempio: 39 | a = "10" # questo è una stringa 40 | a = int(a) # questo è un intero che viene castato dalla stringa 41 | # attenzione però! 42 | a = "dieci" 43 | a = int(a) # darà errore! 44 | 45 | 46 | # Un piccolo esempio di uso del casting: 47 | # la spesa deve essere castata 48 | # sperando che l'utente rispetti le richieste 49 | # vedremo nel futuro modi per trattare gli errori generati 50 | # dall'uso improprio dell'utente 51 | bilancio = 230 52 | spesa = input("Inserisci spesa in euro\n") 53 | 54 | spesa = int(spesa) 55 | risultato = bilancio - spesa 56 | 57 | 58 | print("Il tuo bilancio ora è:") 59 | print(risultato) 60 | 61 | ######### Ancora esempi di casting e concatenazioni ######## 62 | 63 | a = "due" 64 | b = 4 65 | 66 | print(a+" "+str(b)) 67 | # si noti che la print può prendere più parametri 68 | # uno è str, l'altro int... così non abbiamo errore 69 | # perché la print tollera più tipi diversi 70 | print(a,b) 71 | 72 | -------------------------------------------------------------------------------- /240324_L03/compito.py: -------------------------------------------------------------------------------- 1 | # Creare una applicazione bancaria che permette di effettuare un prelievo o deposito monetario. 2 | 3 | # 1. Effettuare il login chiedendo separatamente nome utente e password. Ci sono solo due utenti registrati. Se il nome utente o la password sono errati (la coppia non è corretta, oppure il nome utente non esiste), dare un messaggio di errore e terminare il programma. 4 | 5 | # 2. Se il login è corretto, stampare il bilancio del conto e chiedere se l'operazione desiderata è prelievo o deposito. Qualunque altro inserimento risulta nella terminazione del programma con un messaggio di errore. 6 | # op = input("Prelievo o deposito?") 7 | 8 | # 3. Se l'operazione è di deposito, chiedere la cifra (si assuma che l'utente inserisca un intero), aggiornare il totale del conto e stamparlo a video terminando così il programma. 9 | 10 | # 4. Se l'operazione è di prelievo, chiedere la cifra (si assuma che l'utente inserisca un intero) e verificare che il bilancio sia sufficente. Se lo è detrarlo dal totale e stampare il nuovo bilancio a video terminando così il programma. Se non lo è terminare il programma con un messaggio di errore. 11 | 12 | 13 | user1 = "Enrico" 14 | psw1 = "latteria!" 15 | bilancio1 = 2000 16 | 17 | user2 = "Michelle" 18 | psw2 = "coprofagia@" 19 | bilancio2 = 120 20 | 21 | 22 | nome_utente = input("Benvenuto! Effettua login, inserisci nome utente:\n") 23 | password = input("Inserisci password:\n") 24 | 25 | # verifichi che l'utente sia utente1 e la password corrisponda 26 | isuser1 = nome_utente == user1 and password == psw1 27 | isuser2 = nome_utente == user2 and password == psw2 28 | 29 | if isuser1 or isuser2: 30 | print("") 31 | print("Benvenuto/a", nome_utente) 32 | 33 | # scelgo il bilancio basandomi sull'utente 34 | if isuser1: 35 | bilancio = bilancio1 36 | else: 37 | bilancio = bilancio2 38 | 39 | print("Il tuo bilancio è", bilancio) 40 | print("") 41 | print("") 42 | op = input("Prelievo o deposito? (inserire p o d):\n") 43 | 44 | if op == "p": 45 | # codice per il prelievo 46 | soldi = input("Quanti soldi vuoi prelevare?\n") 47 | soldi = float(soldi) 48 | if soldi <= bilancio: 49 | nuovobilancio = bilancio - soldi 50 | print(nuovobilancio) 51 | # aggiorno il bilancio a seconda dell'utente 52 | if isuser1: 53 | bilancio1 = nuovobilancio 54 | else: 55 | bilancio2 = nuovobilancio 56 | else: 57 | print("Sei povero.") 58 | elif op == "d": 59 | # codice deposito 60 | soldi = input("Quanti soldi vuoi depositare?\n") 61 | soldi = float(soldi) 62 | nuovobilancio = bilancio + soldi 63 | print(nuovobilancio) 64 | # aggiorno il bilancio a seconda dell'utente 65 | if isuser1: 66 | bilancio1 = nuovobilancio 67 | else: 68 | bilancio2 = nuovobilancio 69 | else: 70 | print("Operazione inesistente") 71 | 72 | else: 73 | print("Nome utente invalido o inesistente o password sbagliata.") 74 | 75 | print("DATABASE BANCA ALLA FINE:") 76 | print("Enrico: ", bilancio1) 77 | print("Michelle: ", bilancio2) -------------------------------------------------------------------------------- /240324_L03/main.py: -------------------------------------------------------------------------------- 1 | # Abbiamo appreso che i programmi vengono eseguiti in ordine, riga per riga 2 | # esistono però dei modi per modificare quali istruzioni vengono eseguite e quali no (e anche il loro ordine, come vedremo nel futuro) 3 | # Si parla di "Control Flow" 4 | 5 | # Un comportamento tipico dei programmi consiste nel verificare una qualche condizione ed eseguire un blocco di codice anziché un altro. Un esempio tipico è il login: SE la password è giusta, ALLORA mostro il profilo utente, altrimenti segnalo che la password è sbagliata 6 | # Si fa uso della istruzione IF. Ecco un esempio: 7 | 8 | 9 | # SE la password inserita è uguale a quella inserita stampare "benvenuto", altrimenti dire che la password è sbagliata 10 | psw_salvata = 8 11 | psw_inserita = 7 12 | 13 | if psw_salvata == psw_inserita: 14 | # blocco di codice seguito se la condizione è vera 15 | print("Benvenuto") 16 | # altre righe "se vero" 17 | else: 18 | # blocco di codice seguito se la condizione è falsa 19 | print("Password sbagliata") 20 | # altre righe "se vero" 21 | 22 | # Osserviamo alcune cose importanti: 23 | # - "psw_salvata == psw_inserita" è la CONDIZIONE dell'if, è la cosa che viene controllata per stabilire quale parte del codice dell'if deve essere eseguito 24 | # - Usiamo == per esprimere l'uguaglianza, perché il singolo uguale ha già la semantica dell'assegnazione di variabili 25 | # - I blocchi "vero" e "falso" sono indentati, ossia con una tablatura (TAB) 26 | # - if e else sono keyword riservate, speciali 27 | # - attenzione ai due punti! 28 | # terminato l'if, tutto prosegue come sempre 29 | 30 | # -------------------------------------- 31 | 32 | # Le condizioni possono essere varie, ad esempio fra due numeri 33 | num1 = 2 34 | num2 = 3 35 | 36 | if num1 > num2: 37 | print("Il secondo numero è maggiore") 38 | else: 39 | print("Il primo numero è minore o uguale") 40 | 41 | # altre varianti possono essere minore (<) maggiore uguale (>=) o minore uguale (<=) 42 | 43 | # -------------------------------------- 44 | 45 | # Ma cosa è veramente una condizione? Proviamo a vederne il tipo 46 | 47 | psw_salvata = 8 48 | psw_inserita = 7 49 | 50 | x = psw_salvata == psw_inserita 51 | tipo_di_x = type(x) 52 | print(tipo_di_x) 53 | 54 | # Il tipo BOOLEAN (bool)! Nel mondo della programmazione è necessario definire in maniera formale dei VALORI DI VERITA'. Un valore booleano può essere solo True (vero) o False (falso). 55 | # Le condizioni di un if, quindi, vengono valutate e producono un valore booleano e quindi verranno ridotte in 56 | 57 | # if True: 58 | # ... 59 | 60 | # oppure 61 | 62 | # if False: 63 | # ... 64 | 65 | # -------------------------------------- 66 | 67 | # Esattamente come coi numeri o le stringhe, anche le varibili booleane hanno degli operatori che si possono usare per combinare valori booleani. Ce ne sono diversi, vediamo i tre principali 68 | 69 | val1 = True 70 | val2 = False 71 | 72 | val1 and val2 73 | val1 or val2 74 | not val1 75 | # and e or sono binari, not è unario 76 | 77 | 78 | # TABELLE DI VERITA' 79 | 80 | # and => tutte variabili devono essere vere per avere valore vero (quindi ne basta una falsa per avere falso) 81 | True and False # False 82 | False and True # False 83 | True and True # True 84 | False and False # False 85 | 86 | # and => tutte variabili devono essere false per avere valore falso (quindi ne basta una vera per avere vero) 87 | True or False # True 88 | False or True # True 89 | False or False # False 90 | True or True # True 91 | 92 | # il not semplicemente inverte il valore di verità 93 | not True # False 94 | not False # True 95 | 96 | # -------------------------------------- 97 | 98 | # Esempi d'uso 99 | 100 | # Condizione che è vera se e solo se 101 | # password e nome utente corrispondono 102 | # e la posizione è conosciuta 103 | 104 | nome_utente = "x" 105 | password = "y" 106 | nome_utente_inserito = "y" 107 | password_inserita ="x" 108 | posizione_conosciuta = True 109 | 110 | nome_utente == nome_utente_inserito and password == password_inserita and posizione_conosciuta 111 | 112 | 113 | # Condizione che è vera se e solo se 114 | # password e nome utente corrispondono 115 | # e la posizione è conosciuta 116 | 117 | nome_utente = "x" 118 | password = "y" 119 | nome_utente_inserito = "y" 120 | password_inserita ="x" 121 | posizione_sconosciuta = True 122 | 123 | nome_utente == nome_utente_inserito and password == password_inserita and not posizione_sconosciuta 124 | 125 | # Scrivere una condizione che sia vera se e solo se 126 | # x e y sono uguali oppure uno è il doppio dell'altro 127 | x = 5 128 | y = 10 129 | 130 | x == y or (x == y*2 or y == x*2) 131 | 132 | # -------------------------------------- 133 | # È anche possibile inserire if dentro altri if. Si chiamano if ANNIDATI. Si osservi l'uso delle tablature 134 | c1 = True 135 | c2 = True 136 | c3 = False 137 | 138 | if c1: 139 | #vera c1 140 | print("c1 è vera") 141 | if c2: 142 | #vera c1 (ovviamente vera c1) 143 | print("c2 è vera") 144 | if c3: 145 | #vera c3 (ovviamente vera c1 e c2) 146 | print("c3 è vera") 147 | else: 148 | #falsa c3 (ovviamente vera c1 e c2) 149 | print("c3 è falsa") 150 | else: 151 | #falsa c2 (ovviamente vera c1) 152 | print("c2 è falsa") 153 | else: 154 | #falsa c1 155 | print("c1 è falsa") 156 | 157 | # Si osservi che se c1 è falsa, c2 e c3 non verranno mai verificate, se c1 è vera ma c2 è falsa, c3 non verrà mai verificata 158 | 159 | 160 | #aiuto compito 161 | if c1: 162 | #vera c1 163 | if c2: 164 | #vera c2 (ovviamente vera c1) 165 | else: 166 | #falsa c2 (ovviamente vera c1) 167 | else: 168 | #falsa c1 -------------------------------------------------------------------------------- /240330_L04/compito.py: -------------------------------------------------------------------------------- 1 | # Scrivi un programma in Python che chieda all'utente il suo reddito annuo e calcoli l'ammontare delle tasse dovute basandosi su semplici fasce di reddito. 2 | 3 | # Prima di tutto chiedere all'utente il suo nome e cognome in una sola stringa (usando cioè un solo input). Se il suo nome o cognome includono "Fedez" (indipendentemente dalle maiuscole), allora stampare direttamente "Sei nulla tenente." e chiudere il programma. Altrimenti procedere come segue: 4 | 5 | # Redditi fino a 10.000 €: esenti da tasse. 6 | # Redditi superiori a 10.000 € e fino a 20.000 €: tassati al 10%. 7 | # Redditi superiori a 20.000 € e fino a 30.000 €: tassati al 20%. 8 | # Redditi superiori a 30.000 €: tassati al 30%. 9 | # Il programma dovrebbe mostrare l'ammontare delle tasse dovute secondo queste regole. 10 | 11 | nome_utente = input("Benvenuto! DIMMI IL TUO NOME E COGNOME ORA!!!\n") 12 | 13 | if "fedez" in nome_utente.lower(): 14 | print("Chill, sei nullatenente!") 15 | else: 16 | soldi = float(input("Quanti soldi hai guadagnato?\n")) 17 | 18 | if soldi <= 10000: 19 | print("no tasse bro") 20 | elif soldi > 10000 and soldi <= 20000: 21 | tasse = ((soldi*10)/100) 22 | print("Dammi", tasse) 23 | elif soldi > 20000 and soldi <= 30000: 24 | tasse = ((soldi*20)/100) 25 | print("Dammi", tasse) 26 | else: 27 | tasse = ((soldi*30)/100) 28 | print("Dammi", tasse) -------------------------------------------------------------------------------- /240330_L04/main.py: -------------------------------------------------------------------------------- 1 | # ---------------------------------- 2 | # Ignorare questa parte di codice, serve per generare 3 | # cinque numeri casuali (num1, num2, num3, num4, num5) 4 | # E un utente casuale (name, gender, email password) 5 | # Usiamo questi dati per fare esercizi 6 | import requests 7 | 8 | num1, num2, num3, num4, num5 = requests.get("http://www.randomnumberapi.com/api/v1.0/random?min=1&max=1000&count=5").json() 9 | 10 | namejs = requests.get("https://randomuser.me/api/?results=1").json()["results"][0] 11 | gender = namejs["gender"] 12 | name = namejs["name"]["first"] 13 | email = namejs["email"] 14 | password = namejs["login"]["password"] 15 | 16 | # ---------------------------------- 17 | 18 | print("Numeri generati:") 19 | print(num1, num2, num3, num4, num5) 20 | 21 | print("Persona generata:") 22 | print(name, gender, email, password) 23 | 24 | print("") 25 | 26 | # Alcune funzionalità utili per quando si ha a che fare con le stringhe 27 | 28 | # usando le funzioni x.lower() e x.upper() 29 | # posso rendere la stringa x tutta minuscola o tutta maiuscola 30 | tuttominuscolo = name.lower() 31 | tuttomaiuscolo = name.upper() 32 | print(tuttominuscolo) 33 | print(tuttomaiuscolo) 34 | # si noti che per la prima volta una funzione è richiamata con il punto dopo la variabile 35 | # e la variabile non viene data come parametro alla funzione 36 | # cioè, non scriviamo lower(x) ma x.lower() 37 | 38 | # la funzione len() restituisce la lunghezza della stringa 39 | if len(password) > 5: 40 | print("Password lunga 6 o più caratteri") 41 | 42 | # Usando la keyword "in" possiamo verificare se una stringa è dentro un altra 43 | # stringa. Qui combiniamo anche l'uso di lower() 44 | if "r" in name.lower(): 45 | c = name.lower().count("r") # e contiamo quante volte c'è la r 46 | print("Il nome ha dentro una r e ne ha", c) 47 | 48 | # Possiamo, usando x.endswith(y) controllare se la stringa x finisce in y 49 | if name.endswith("ia"): 50 | print("IL nome finisce con ia") 51 | 52 | # Possiamo, usando x.startswith(y) controllare se la stringa x inizia con y 53 | if name.startswith("Ca"): 54 | print("IL nome inizia con Ca") 55 | 56 | 57 | 58 | 59 | 60 | -------------------------------------------------------------------------------- /240407_L05/compito.py: -------------------------------------------------------------------------------- 1 | # Creare un programma che analizzi tre interi forniti dall'utente. 2 | 3 | # PARTE 1 # 4 | # Prima di tutto chiedere il nome dell'utente. Se l'utente non ha scritto il nome con la maiuscola nella prima lettera, sostituirla. PS: x.isupper() controlla se una variabile è maiuscola. 5 | # Stampare un messaggio di benvenuto usando il nome utente eventualmente corretto 6 | 7 | 8 | # PARTE 2 # 9 | # Poi, in un solo input, chiedere due numeri separati da virgola Esempio: 3,2 10 | # In un successivo input, chiedere il terzo intero 11 | 12 | # Ospitare tutti i numeri in una lista, 13 | # - stamparli uno per uno 14 | # - stampare la media 15 | 16 | # Eseguire i controlli (per ogni controllo dare un feedback all'utente tramite una stampa) 17 | # - Verificare se il terzo numero sia maggiore della somma degli altri due 18 | # - Verificare se i tre numeri sono tutti diversi fra loro 19 | # - Verificare se la somma dei tre numeri è maggiore o minore al numero di caratteri nel nome dell'utente 20 | 21 | 22 | # PARTE 1 # 23 | 24 | nome_utente = input("Inserisci nome utente:\n") 25 | print("") 26 | 27 | # Enrico 28 | nome_utente = nome_utente.capitalize() 29 | 30 | print("Benvenuto",nome_utente) 31 | 32 | 33 | # PARTE 2 # 34 | 35 | due_numeri = input("Dammi 2 numeri separati da una virgola, senza spazi\n") 36 | terzo_numero = input("Dammi un terzo numero\n") 37 | 38 | lista = due_numeri.split(",") # "4,5" => ["4", "5"] 39 | lista.append(terzo_numero) # ["4", "5", "9"] 40 | 41 | lista[0] = int(lista[0]) 42 | lista[1] = int(lista[1]) 43 | lista[2] = int(lista[2]) 44 | print("") 45 | 46 | # [4, 5, 9] 47 | 48 | print("Primo numero:", lista[0]) 49 | print("Secondo numero:", lista[1]) 50 | print("Terzo numero:", lista[2]) 51 | 52 | 53 | print("La media dei tre numeri è:", sum(lista) / len(lista)) 54 | 55 | # Verifico se i tre numeri sono diversi fra loro 56 | if lista[0] == lista[1] or lista[0] == lista[2] or lista[1] == lista[2]: 57 | print("No, sono tutti uguali") 58 | elif lista[0] == lista[1]: 59 | print("No, i primi due numeri sono uguali") 60 | elif lista[0] == lista[2]: 61 | print("No, il primo e il terzo numero sono uguali") 62 | elif lista[1] == lista[2]: 63 | print("No, il secondo e il terzo numero sono uguali") 64 | else: 65 | print("Si") 66 | 67 | # Verifico se la somma è maggiore ai caratteri del nome 68 | print("3. La somma dei numeri è maggiore ai caratteri del nome?") 69 | if sum(lista) > len(nome_utente): 70 | print("Si") 71 | else: 72 | print("No") 73 | 74 | > < = 75 | 76 | # - Verificare se il terzo numero sia maggiore della somma degli altri due 77 | 78 | if lista[2] > lista[1] + lista[0]: 79 | print("Il terzo numero è maggiore della somma degli altri due") -------------------------------------------------------------------------------- /240407_L05/main.py: -------------------------------------------------------------------------------- 1 | # *** precisazione importante *** 2 | # funzioni chiamate su variabili e funzioni non chiamate su variabili 3 | testo = "Bellissimo testo" 4 | testo.startswith("x") # chiamata sulla variabile (uso del punto) 5 | len(testo) # chiamata generica 6 | # non c'è una regola precisa per cui è len(x) e non x.len()... 7 | # i motivi esistono, ma sono troppo approfonditi per la nostra conoscenza 8 | # quindi limitiamoci a imparare a memoria quali funzioni si applicano su una variabile e quali no. un indicazione può essere che funzioni "generiche" sono senza variabile 9 | 10 | # --------------------------------------------------------- 11 | # Esempio di software. Detector di parole bannabili, implementato in una chat di Twitch 12 | # Ogni messaggio viene controllato e se contiene una parola bannabile viene scartata 13 | # Chiedere messaggio all'utente e stampare il messaggio se non è bannabile, un messaggio di alert se lo è 14 | 15 | p1 = "pandoro" 16 | p2 = "balocco" 17 | p3 = "fidanzato" 18 | p4 = "pubblicità" 19 | p5 = "adv" 20 | p6 = "onlyfans" 21 | p7 = "piedi" 22 | p8 = "divorzio" 23 | p9 = "separazione" 24 | p10 = "sesso" 25 | 26 | # prendo in input una parola 27 | 28 | messaggio = input("Scrivi messaggio\n") 29 | 30 | # controllo se è bannabile e restituisco il risultato 31 | 32 | if p1 == messaggio.lower() or p2 == messaggio.lower() or p3 == messaggio.lower() or p4 == messaggio.lower() or p5 == messaggio.lower() or p6 == messaggio.lower() or p7 == messaggio.lower() or p8 == messaggio.lower() or p9 == messaggio.lower() or p10 == messaggio.lower(): 33 | print("Sei bannato!") 34 | else: 35 | print(messaggio) 36 | 37 | # Dovendo cambiare questo codice osserviamo come sia necessario cambiare LA LOGICA. Dobbiamo aggiungere una condizione all'if. 38 | 39 | # Ci sarà un modo più comodo di memorizzare un insieme di valori? Sì. LE LISTE 40 | # Dichiarazione di una lista 41 | l = [1, 2, 3] 42 | # è di tipo list, dentro ci possono stare valori di tutti i tipi anche mischiati 43 | # gli elementi hanno un INDICE, che parte da zero. si può accedere ad un elemento indicando l'indice fra quadre 44 | # #NOME_DELLA_LISTA[INDICE] 45 | print(l[1]) # stampa 2 46 | # ed è come una variabile a sé, possiamo cambiare valore 47 | l[1] = 2000 48 | # è possibile usare anche len() per sapere quanti elementi ci sono 49 | len(l) # 3 50 | # possiamo aggiungere o rimuovere elementi 51 | l.append(4) # aggiunge quattro alla lista 52 | l.pop(0) # toglie il primo elemento (indice zero) 53 | 54 | # Osserviamo anche un comportamento interessante. Possiamo accedere alle stringhe come fossero liste! 55 | testo = "ciao" 56 | print(testo[2]) # lettera a 57 | 58 | # Ulteriore aggiunta in merito alle stringhe: 59 | 60 | # - le stringhe possono essere suddivise basandosi su una stringa di divisione. Ad esempio data la frase 61 | t = "ciao come stai" 62 | # posso ottenere le singole parole splittando per spazio 63 | parole = t.split(" ") 64 | print(parole) # lista di tre elementi 65 | 66 | 67 | # -------------------------------- 68 | 69 | # Ora riprendiamo l'esercizio di prima ma usiamo le liste, 70 | bannabili = ["pandoro", "balocco", "fidanzato", "pubblicità", "adv", "onlyfans", "piedi", "divorzio", "separazione", "sesso"] 71 | 72 | messaggio = input("Scrivi messaggio\n") 73 | 74 | # controllo se è bannabile e restituisco il risultato 75 | 76 | if messaggio in bannabili: 77 | print("Sei bannato!") 78 | else: 79 | print(messaggio) 80 | 81 | # È molto meglio! Ora la logica non cambia MAI, basta aggiungere parole alla lista di parole bannabili -------------------------------------------------------------------------------- /240412_L06/compito.py: -------------------------------------------------------------------------------- 1 | # Chiedere una frase all'utente e stampare il numero di parole che contiene (consideriamo lo spazio come separatore di parola) 2 | 3 | frase = input("Ciao, dimmi quello che vuoi.\n") 4 | parole = frase.split(" ") 5 | 6 | print("Hai scritto", len(parole), "parole") 7 | 8 | # Poi chiedere all'utente quale parola vuole cambiare. L'utente fornirà la posizione della parola (verificare che sia una posizione esistente) 9 | 10 | cambio = int(input("Quale parola vuoi cambiare?(ins. pos)\n")) 11 | 12 | if cambio > len(parole): 13 | print("Non posso cambiare") 14 | else: 15 | print(parole) # ["ciao", "come", "stai?"] 16 | print(cambio) # 2 17 | 18 | sostituto = parole[cambio-1] 19 | parole[cambio-1] = parole[0] 20 | parole[0] = sostituto 21 | 22 | print(" ".join(parole)) 23 | 24 | # Scambiare la prima parola della frase con la parola nella posizione fornita dall'utente. 25 | 26 | # Esempio: 'Ciao come stai?' fornendo 2 diventa 'come Ciao stai?' 27 | # Fare dunque attenzione alla distizione fra indici e posizioni. 28 | 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /240412_L06/main.py: -------------------------------------------------------------------------------- 1 | ##################################################### 2 | # Questi esercizi NON sono generici. Non sappiamo ancora trattare le liste con generalità e dinamicità, ma vogliamo allenarci a scrivere codice che coinvolga le liste. 3 | 4 | # Creare una lista che contenga nella posizione i-esima la somma degli elementi i-esimi di l1 e l2 5 | l1 = [1, 2, 3, 4] #lunghezza fissa, valori variabili 6 | l2 = [4, 3, 2, 1] #lunghezza fissa, valori variabili 7 | 8 | l3 = [l1[0] + l2[0], l1[1] + l2[1], l1[2] + l2[2], l1[3] + l2[3]] 9 | 10 | 11 | # Creare una lista che contenga la somma degli elementi i-esimi di l1 e l2 ma solo per gli i contenuti in l3 12 | l1 = [1, 5, 10, 1] #lunghezza fissa, valori variabili 13 | l2 = [1, 5, 10, 1] #lunghezza fissa, valori variabili 14 | l3 = [1, 2] #lunghezza fissa, valori variabili (sempre minori di min(len(l1), len(l2))-1) 15 | 16 | l4 = [ l1[l3[0]] + l2[l3[0]], l1[l3[1]] + l2[l3[1]] ] 17 | 18 | # Creare una lista che contenga nell'indice i-esimo la somma degli elementi della i-esima lista => sum() 19 | l1 = [1, 2, 3, 4] #lunghezza e valori variabili 20 | l2 = [2, 3, 4, 5] #lunghezza e valori variabili 21 | l3 = [3, 5, 2, 8] #lunghezza e valori variabili 22 | l4 = [11, 5, 1] #lunghezza e valori variabili 23 | 24 | l5 = [sum(l1), sum(l2), sum(l3), sum(l4)] 25 | 26 | 27 | # modificare l1 così che ad ogni suo elemento vengano sommati il massimo e il minimo trovati nella lista l2 => max e min 28 | l1 = [100, 300] #lunghezza fissa, valori variabili 29 | l2 = [590, 120, 102, 1] #lunghezza e valori variabili 30 | 31 | # max(x) => il valore massimo in x 32 | # min(x) => il valore minimo in x 33 | 34 | l1 = [l1[0] + max(l2) + min(l2), l1[1] + max(l2) + min(l2)] 35 | 36 | ############################# 37 | 38 | # trovare il valore massimo fra le due liste l1 e l2 => + 39 | l1 = [1, 5, 10, 1] #lunghezza e valori variabili 40 | l2 = [12, 3] #lunghezza e valori variabili 41 | 42 | l3 = l1 + l2 43 | print(max(l3)) 44 | print(max(l3)) 45 | 46 | # creare una lista che contenga nella posizione i-esima il numero di occorrenze di i in l1, sapendo che l1 può avere solo 0, 1 e 2 come valori => count 47 | l1 = [0, 1, 0, 0, 2, 1, 2, 0] #lunghezza variable, valori variabili ma solo nell'intervallo 0-2 48 | 49 | l2 = [l1.count(0), l1.count(1), l1.count(2)] 50 | print(l2) 51 | 52 | # controllare che le due liste siano identiche => reverse tanto per 53 | l1 = [1, 5, 10, 1] #lunghezza fissa, valori variabili 54 | l2 = [1, 5, 10, 2] #lunghezza fissa, valori variabili 55 | 56 | uguali = l1[0] == l2[0] and l1[1] == l2[1] and l1[3] == l2[3] and l1[2] == l2[2] 57 | 58 | print(uguali) 59 | -------------------------------------------------------------------------------- /240421_L07/readme.txt: -------------------------------------------------------------------------------- 1 | In questa lezione abbiamo corretto gli esercizi della sesta lezione. -------------------------------------------------------------------------------- /240505_L08/compito.py: -------------------------------------------------------------------------------- 1 | # La variabile parole contiene una lista di 5 parole 2 | # La variabile lista_maiuscole è una lista di 5 interi che possono essere solo 0 o 1. 3 | import requests 4 | from random import randrange, sample 5 | 6 | parole = requests.get("https://random-word-api.herokuapp.com/word?lang=it&number=5").json() 7 | 8 | print("Parole", parole) 9 | 10 | lista_maiuscole = [0]*3 + [1]*2 11 | random.shuffle(lista_maiuscole) 12 | print("Lista maiuscole", lista_maiuscole) 13 | 14 | # Modificare la lista parole rendendo maiuscolo l'i-esimo elemento se l'i-esimo elemento di lista_maiuscole è 1 15 | 16 | parole = ["ciao", "dome", "st", "bl", "pl"] 17 | lista_maiuscole = [0, 0, 1, 1, 1] 18 | 19 | if lista_maiuscole[0] == 1: 20 | parole[0] = parole[0].upper() 21 | 22 | if lista_maiuscole[1] == 1: 23 | parole[1] = parole[1].upper() 24 | 25 | if lista_maiuscole[2] == 1: 26 | parole[2] = parole[2].upper() 27 | 28 | if lista_maiuscole[3] == 1: 29 | parole[3] = parole[3].upper() 30 | 31 | if lista_maiuscole[4] == 1: 32 | parole[4] = parole[4].upper() 33 | 34 | 35 | -------------------------------------------------------------------------------- /240505_L08/main.py: -------------------------------------------------------------------------------- 1 | ##################################################### 2 | # Questi esercizi NON sono generici. Non sappiamo ancora trattare le liste con generalità e dinamicità, ma vogliamo allenarci a scrivere codice che coinvolga le liste. 3 | 4 | # Modificare l1 in modo che l'i-esimo elemento di l1 risulti sé stesso meno l'i-esimo elemento di l2. 5 | l1 = [2, 3, 4] #lunghezza fissa, valori variabili 6 | l2 = [2, 2, 2, 5] #lunghezza fissa, valori variabili 7 | 8 | l1[0] = l1[0] - l2[0] 9 | l1[1] = l1[1] - l2[1] 10 | l1[2] = l1[2] - l2[2] 11 | 12 | l1 = [l1[0] - l2[0], l1[1] - l2[1], l1[2] - l2[2]] 13 | 14 | # Modificare l1. Raddoppiare l'i-esimo elemento di l1 se e solo se l'i-esimo elemento di l2 è uguale a 1 15 | l1 = [2, 3, 4] #lunghezza fissa, valori variabili 16 | l2 = [1, 0, 0] #lunghezza fissa, valori variabili 17 | 18 | 19 | if l2[0] == 1: 20 | l1[0] = l1[0]*2 21 | if l2[1] == 1: 22 | l1[1] = l1[1]*2 23 | if l2[2] == 1: 24 | l1[2] = l1[2]*2 25 | 26 | # Creare una lista l3 che contenga tutti e soli gli elementi comuni sia a l1 che a l2 27 | l1 = [2, 3, 4] #lunghezza fissa, valori variabili 28 | l2 = [4, 2, 5] #lunghezza fissa, valori variabili 29 | 30 | l3 = [] 31 | 32 | if l1[0] in l2: 33 | l3.append(l1[0]) 34 | 35 | if l1[1] in l2: 36 | l3.append(l1[1]) 37 | 38 | if l1[2] in l2: 39 | l3.append(l1[2]) 40 | 41 | # Costruire la lista l3 che è la somma elemento per elemento delle liste l1 ed l2. Mettere a zero l'i-esimo elemento di l3 se l'i-esimo elemento di l2 è 1. 42 | l1 = [7, 8, 9] 43 | l2 = [0, 1, 0] 44 | 45 | # Soluzione 1 46 | l3 = [0]*3 47 | 48 | l3[0] = l1[0] + l2[0] 49 | l3[1] = l1[1] + l2[1] 50 | l3[2] = l1[2] + l2[2] 51 | 52 | if l2[0] == 1: 53 | l3[0] = 0 54 | 55 | if l2[1] == 1: 56 | l3[1] = 0 57 | 58 | if l2[2] == 1: 59 | l3[2] = 0 60 | 61 | # Soluzione 2 usare append e non puoi usare l'assegnamento 62 | 63 | l3 = [] 64 | 65 | if l2[0] == 1: 66 | l3.append(0) 67 | else: 68 | l3.append(l2[0] + l1[0]) 69 | 70 | if l2[1] == 1: 71 | l3.append(0) 72 | else: 73 | l3.append(l2[1] + l1[1]) 74 | 75 | if l2[2] == 1: 76 | l3.append(0) 77 | else: 78 | l3.append(l2[2] + l1[2]) 79 | 80 | 81 | 82 | # La variable "parola" contiene una lista di tre parole a caso. 83 | # La variabile 'indice' è un valore casuale da 0 a 2. 84 | import requests 85 | from random import randrange 86 | parole = requests.get("https://random-word-api.herokuapp.com/word?lang=it&number=3").json() 87 | indice = randrange(0,3) 88 | 89 | 90 | print("Parole", parole) 91 | print("Indice", indice) 92 | 93 | # Modificare la lista parole di modo che ogni elemento di parole sia quello in posizione indice. 94 | # Esempio: parole = ["ciao", "come", "stai"] e indice = 1 95 | # Risultato: ["come", "come", "come"] 96 | 97 | parole[0] = parole[indice] 98 | parole[1] = parole[indice] 99 | parole[2] = parole[indice] 100 | 101 | 102 | 103 | 104 | -------------------------------------------------------------------------------- /240512_L09/compito.py: -------------------------------------------------------------------------------- 1 | # Date due liste l1 l2 di lunghezza randomica ma uguale e valori randomici 2 | from random import randrange, sample 3 | 4 | r_len = randrange(1,10) 5 | l1 = sample(range(1, 50), r_len) 6 | l2 = sample(range(1, 50), r_len) 7 | 8 | print(f"Lista 1: {l1}") 9 | print(f"Lista 2: {l2}") 10 | print(f"Le due liste hanno lunghezza {r_len}") 11 | 12 | 13 | ### USARE I WHILE ### 14 | 15 | # Costruire una l3 che contenga in posizione i-esima il minimo fra l'i-esimo elemento di l1 e l'i-esimo elemento di l2. 16 | 17 | 18 | # Costruire una l3 che contenga in posizione i-esima il l'i-esimo valore di l1 solo se l'i-esimo valore di l2 è maggiore di 3, 0 altrimenti 19 | 20 | 21 | # Costruire una l3 che contenga tutti e soli i valori comuni fra l1 e l2 -------------------------------------------------------------------------------- /240512_L09/main.py: -------------------------------------------------------------------------------- 1 | # Aggiungere ad ogni elemento di l1 il valore x 2 | # l1 ha lunghezza fissa e valori variabili 3 | x = 10 4 | l1 = [10, 20, 30] 5 | 6 | l1[0] = l1[0] + x 7 | l1[1] = l1[1] + x 8 | l1[2] = l1[2] + x 9 | 10 | # Aggiungere ad ogni elemento di l1 il valore x 11 | # l1 ha lunghezza VARIABILE e valori variabili 12 | 13 | l1 = [10, 20, 30, 40] 14 | # Non si può fare. Abbiamo bisogno di costruire il nostro primo loop! 15 | 16 | x = 10 17 | i = 0 18 | while i < len(l1): 19 | l1[i] = l1[i] + x 20 | i = i + 1 21 | 22 | # costruire una lista l3 che contenga nella posizione i-esima la somma degli i-esimi elementi di l1 e l2. 23 | # l1 e l2 sono di UGUALE lunghezza (variabile) e valori variabili 24 | l1 = [10, 20, 30, 20] 25 | l2 = [3, 2, 1, 1] 26 | 27 | l3 = [1]*len(l1) 28 | i = 0 29 | while i < len(l1): 30 | l3[i] = l1[i] + l2[i] 31 | print(l3[i]) 32 | i = i +1 33 | 34 | -------------------------------------------------------------------------------- /poetry.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Poetry 1.5.4 and should not be changed by hand. 2 | package = [] 3 | 4 | [metadata] 5 | lock-version = "2.0" 6 | python-versions = ">=3.10.0,<3.12" 7 | content-hash = "c72ba1872668238cc9b2c02a1118c7b8f9049473b63bbad4ee2bd46365be7ce2" 8 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "python-template" 3 | version = "0.1.0" 4 | description = "" 5 | authors = ["Your Name "] 6 | 7 | [tool.poetry.dependencies] 8 | python = ">=3.10.0,<3.12" 9 | 10 | [tool.pyright] 11 | # https://github.com/microsoft/pyright/blob/main/docs/configuration.md 12 | useLibraryCodeForTypes = true 13 | exclude = [".cache"] 14 | 15 | [tool.ruff] 16 | # https://beta.ruff.rs/docs/configuration/ 17 | select = ['E', 'W', 'F', 'I', 'B', 'C4', 'ARG', 'SIM'] 18 | ignore = ['W291', 'W292', 'W293'] 19 | 20 | [build-system] 21 | requires = ["poetry-core>=1.0.0"] 22 | build-backend = "poetry.core.masonry.api" -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # Hard Python Readhead 2 | 3 | Hard Python Redhead Edition è la seconda edizione del celebre 'Hard Python'. 4 | 5 | Lo scopo è semplice: accompagnare la studentessa [Michelle Puttini](https://www.instagram.com/michelleputtini/) in un percorso formativo che la trasformi da completa neofita della programmazione a esperta coder. 6 | 7 | ## Obiettivi 8 | 9 | Il corso è pensato per chi -come Michelle- non ha mai programmato né ha grande esperienza con questo mondo. Se da una parte si vuole insegnare a programmare di per sé, il vero obiettivo è quello di sfruttare l'arte del coding per sviluppare abilità di problem solving. 10 | 11 | Completo di compiti settimanali e progetti di varie dimensioni, Hard Python è l'occasione perfetta per imparare a "smanettare" ed acquisire skill trasversali. 12 | 13 | ## Riassunto delle lezioni 14 | 15 | Ogni lezione ha una cartella dedicata, con data e numero di lezione. Ad esempio `240310_L01` è la cartella della lezione 01, tenutasi in data 24/03/10. 16 | 17 | ### Lezione 9 (12/05/24) 18 | Introduzione dei cicli, e in particolare il ciclo while con visualizzazione del tool della memoria. 19 | 20 | ### Lezione 8 (05/05/24) 21 | Ancora esercizi sulle liste, questa volta orientati alla modifica delle liste anziché alla loro creazione da zero. All'inizio si illustra anche come vengono rappresentate in memoria. 22 | 23 | ### Lezione 7 (21/04/24) 24 | Una lezione di esercitazioni in cui abbiamo concluso e corretto gli esercizi della lezione 6 orientati alle liste. 25 | 26 | ### Lezione 6 (12/04/24) 27 | Una lezione "esercitazione" con diversi esercizi relativi alle liste. Abbiamo introdotto alcune funzioni utili su liste quali `max()` e `min()`. 28 | 29 | ### Lezione 5 (07/04/24) 30 | Il concetto di lista è stato introdotto ed è stato visto come creare e modificare liste. Abbiamo poi osservato come le stringhe possano essere trattate come liste e convertite in liste o riconvertite in testo usando `split()` e `join()`. 31 | 32 | ### Lezione 4 (30/03/24) 33 | Abbiamo corretto il compito della lezione 3, mostrando come usare gli `if` in maniera efficace. Abbiamo anche introdotto alcune funzioni utili per trattare con le stringhe (`len`, `in`, `startswith`, ecc). 34 | 35 | ### Lezione 3 (24/03/24) 36 | L'importante concetto di control flow è stato introdotto e con esso il costrutto `if`. Abbiamo visto che gli `if` permettono di eseguire sezioni diversi di codice a seconda di una *condizione*. Le condizioni ci hanno dato occasione di introdurre un nuovo tipo di dati, i `boolean` (booleani) e i loro operatori. 37 | 38 | 39 | ### Lezione 2 (17/03/24) 40 | Abbiamo continuato il discorso sulle variabili introducendo l'importante nozione di tipi (interi `int`, numeri con la virgola `float` e stringhe `str`) e la necessaria funzionalità di casting correlata. Abbiamo introdotto la funzione `input`, che viene usata per chiedere dati ad un utente. Infine, abbiamo imparato che la funzione print può accogliere più parametri. 41 | 42 | ### Lezione 1 (10/03/24) 43 | Dopo una breve introduzione teorica al mondo della programmazione abbiamo introdotto l'importante nozione di variabili. [Qui](https://docs.google.com/presentation/d/1UDXe4_JFKnt1ZC8086X8FvhXSowhE8hgEYBpabudeCI/edit?usp=sharing) le slides introduttive. 44 | 45 | 46 | 47 | 48 | 49 | ## Youtube 50 | Riguarda le [lezioni su Youtube](https://www.youtube.com/playlist?list=PLMP9hIwoX2Du9Mjh_zVQoHngjG0zdxS8F)! 51 | 52 | --------------------------------------------------------------------------------