├── .DS_Store ├── .ipynb_checkpoints └── python_in_100_minuti-checkpoint.ipynb ├── README.md ├── final_project.ipynb ├── geometry.py ├── python_in_100_minuti.ipynb ├── res └── _ └── script.py /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ProfAI/Python-in-100-minuti/88e145abb08990bff8c111563535feee140b9cc3/.DS_Store -------------------------------------------------------------------------------- /.ipynb_checkpoints/python_in_100_minuti-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "wFpQNKebb0VZ" 8 | }, 9 | "source": [ 10 | "# Da zero a Python in 100 minuti" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": { 16 | "colab_type": "text", 17 | "id": "7dSkI1WMZWEJ" 18 | }, 19 | "source": [ 20 | "## Indice\n", 21 | " * [Introduzione](#intro)\n", 22 | " * [Input e output](#io)\n", 23 | " * [Le variabili](#var)\n", 24 | " * [Tipi di dati](#types)\n", 25 | " * [Liste, tuple e set](#list)\n", 26 | " * [Dizionari](#dict)\n", 27 | " * [I cicli](#loop)\n", 28 | " * [Istruzioni condizionali](#if)\n", 29 | " * [Le funzioni](#func)\n", 30 | " * [Le classi](#oop)\n", 31 | " * [I moduli](#module)" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "\n", 39 | "## Introduzione\n", 40 | "Python è uno dei linguaggi di programmazione più utilizzati al mondo, grazie alla sua semplicità e versalità viene sfruttato per moltissimi scopi diversi come lo sviluppo di applicazioni desktop, web e networking ma da del suo meglio proprio nel calcolo scientifico e nel **machine learning**.\n", 41 | "

\n", 42 | "Python è un **linguaggio interpretato**, questo vuol dire che, a differenza di un lingaggio compilato, il codice non viene direttamente compilato in un file eseguibile (ad esempio i file .exe di Windows), ma viene interpretato da un altro software, chiamato proprio *interprete*, che poi lo esegue. Questo vuol dire che lo stesso codice Python può essere eseguito su qualsiasi sistema operativo sulla quale sia disponibile l'interprete, come Windows, Unix/Linux, Macintosh e sistemi mobili come Android e iOS.\n", 43 | "

\n", 44 | "In realtà, prima di essere eseguito tramite l'interprete, un programma Python viene pre-compilato in un formato chiamato *bytecode*, il ché lo rende più performante di diversi linguaggi interpretati, anche se non al livello di linguaggi compilati a basso livello come C/C++ (Python è realizzato proprio in linguaggio C)." 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": { 50 | "colab_type": "text", 51 | "id": "2F9KErpJd1lN" 52 | }, 53 | "source": [ 54 | "\n", 55 | "## Input e Output\n", 56 | "Le funzioni fondamentali di un qualsiasi linguaggio di programmazione sono quelle che ci permettono di prendere delle informazioni in ingresso e mostrarle in uscita.\n", 57 | "
\n", 58 | "Con Python possiamo stampare dei dati su schermo utilizzando la funzione *print*." 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 1, 64 | "metadata": { 65 | "colab": { 66 | "base_uri": "https://localhost:8080/", 67 | "height": 34 68 | }, 69 | "colab_type": "code", 70 | "id": "fXvxjAOneNd6", 71 | "outputId": "8fcbf867-665a-4f59-99fc-6d8eed954998" 72 | }, 73 | "outputs": [ 74 | { 75 | "name": "stdout", 76 | "output_type": "stream", 77 | "text": [ 78 | "Ciao mondo\n" 79 | ] 80 | } 81 | ], 82 | "source": [ 83 | "print(\"Ciao mondo\")" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": { 89 | "colab_type": "text", 90 | "id": "dN_DpIrqeeH5" 91 | }, 92 | "source": [ 93 | "In questo caso il dato che abbiamo stampato è una stringa, cioè del testo, che viene racchiusa tra doppi apici. \n", 94 | "
\n", 95 | "Utilizzando questa stessa funzione avremmo potuto anche stampare dei numeri." 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 2, 101 | "metadata": { 102 | "colab": { 103 | "base_uri": "https://localhost:8080/", 104 | "height": 34 105 | }, 106 | "colab_type": "code", 107 | "id": "7Vr-DdaUe1gJ", 108 | "outputId": "ef7ef5f9-9bc8-4bc3-93ed-12b49624f418" 109 | }, 110 | "outputs": [ 111 | { 112 | "name": "stdout", 113 | "output_type": "stream", 114 | "text": [ 115 | "5\n" 116 | ] 117 | } 118 | ], 119 | "source": [ 120 | "print(5)" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": { 126 | "colab_type": "text", 127 | "id": "k08A3VkoeR_b" 128 | }, 129 | "source": [ 130 | "Con Python possiamo eseguire le varie **operazioni matematiche** utilizzando l'operatore corretto" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 3, 136 | "metadata": { 137 | "colab": { 138 | "base_uri": "https://localhost:8080/", 139 | "height": 103 140 | }, 141 | "colab_type": "code", 142 | "id": "KGIGfXx6fB-X", 143 | "outputId": "7c1a8358-95ee-4c75-fe22-fdd127cf6379" 144 | }, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "8\n", 151 | "3\n", 152 | "6\n", 153 | "2.0\n", 154 | "1\n", 155 | "52\n" 156 | ] 157 | } 158 | ], 159 | "source": [ 160 | "# somma\n", 161 | "print(5+3)\n", 162 | "\n", 163 | "# sottrazione\n", 164 | "print(4-1)\n", 165 | "\n", 166 | "# prodotto\n", 167 | "print(3*2)\n", 168 | "\n", 169 | "# divisione\n", 170 | "print(4/2)\n", 171 | "\n", 172 | "# resto\n", 173 | "print(5%2)\n", 174 | "\n", 175 | "# unire due stringhe\n", 176 | "print(\"5\"+\"2\")" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": { 182 | "colab_type": "text", 183 | "id": "bMW03EGEc_2r" 184 | }, 185 | "source": [ 186 | "Come vedi dall'ultimo print, l'utilizzo dell'operatore somma (+) su due stringhe ha l'effetto di unirle.\n", 187 | "
\n", 188 | "Il testo inserito dopo il carattere # è un **commento**, il suo scopo è quello di permetterci di inserire annotazioni nel codice, che poi verranno scartate dall'interprete e quindi non utilizzate in alcun modo dal programma.\n", 189 | "

\n", 190 | "E' possibile anche stampare più dati, anche di tipo differente, semplicemente separandoli con una virgola, se si tratta solo di stringhe possiamo anche utilizzare l'operatore somma (+)." 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": 4, 196 | "metadata": {}, 197 | "outputs": [ 198 | { 199 | "name": "stdout", 200 | "output_type": "stream", 201 | "text": [ 202 | "5 + 3 = 8\n", 203 | "5 + 3 = 8\n", 204 | "5 + 3 = 8\n" 205 | ] 206 | } 207 | ], 208 | "source": [ 209 | "print(\"5 + 3 = \"+\"8\")\n", 210 | "print(\"5 + 3 =\",8)\n", 211 | "print(\"5 + 3 =\",5+3)" 212 | ] 213 | }, 214 | { 215 | "cell_type": "markdown", 216 | "metadata": {}, 217 | "source": [ 218 | "Per acquisire dei dati possiamo invece utilizzare la funzione input." 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 5, 224 | "metadata": { 225 | "colab": { 226 | "base_uri": "https://localhost:8080/", 227 | "height": 51 228 | }, 229 | "colab_type": "code", 230 | "id": "NQ7RzV5ggLda", 231 | "outputId": "9a101ecf-5b48-4f2e-9724-2a99d03570f3" 232 | }, 233 | "outputs": [ 234 | { 235 | "name": "stdout", 236 | "output_type": "stream", 237 | "text": [ 238 | "Come ti chiami ? Giuseppe\n", 239 | "Felice di conoscerti Giuseppe\n" 240 | ] 241 | } 242 | ], 243 | "source": [ 244 | "name = input(\"Come ti chiami ? \")\n", 245 | "print(\"Felice di conoscerti\",name)" 246 | ] 247 | }, 248 | { 249 | "cell_type": "markdown", 250 | "metadata": { 251 | "colab_type": "text", 252 | "id": "iaKMAdIjgPQL" 253 | }, 254 | "source": [ 255 | "In questo caso abbiamo immagazzianto l'input inserito da tastiera all'interno di una **variabile** che poi abbiamo stampato su schermo.\n", 256 | "
" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": { 262 | "colab_type": "text", 263 | "id": "pdaVW7WLb23-" 264 | }, 265 | "source": [ 266 | "\n", 267 | "## Le variabili\n", 268 | "Una variabile serve per immagazzinare dati, possiamo assegnare un dato a una variabile usando l'operatore di assegnazione (=)." 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 7, 274 | "metadata": { 275 | "colab": {}, 276 | "colab_type": "code", 277 | "id": "cmSc3Sy4hP7H" 278 | }, 279 | "outputs": [ 280 | { 281 | "name": "stdout", 282 | "output_type": "stream", 283 | "text": [ 284 | "5\n", 285 | "ciao\n" 286 | ] 287 | } 288 | ], 289 | "source": [ 290 | "num = 5\n", 291 | "print(num)\n", 292 | "\n", 293 | "word = \"ciao\"\n", 294 | "print(word)" 295 | ] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "Il nome della variabile viene definito da noi, è buona norma utilizzare un nome che rappresenta il contenuto della variabile, in modo da facilitare la lettura del codice." 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": 9, 307 | "metadata": {}, 308 | "outputs": [ 309 | { 310 | "name": "stdout", 311 | "output_type": "stream", 312 | "text": [ 313 | "Inserisci un nome per il tuo nuovo gatto: Fluffi\n", 314 | "Fluffi è il tuo nuovo padrone\n" 315 | ] 316 | } 317 | ], 318 | "source": [ 319 | "cat = input(\"Inserisci un nome per il tuo nuovo gatto: \")\n", 320 | "print(cat+\" è il tuo nuovo padrone\")" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "metadata": { 326 | "colab_type": "text", 327 | "id": "dIqoBPy4kNSU" 328 | }, 329 | "source": [ 330 | "\n", 331 | "## Tipi di dati\n", 332 | "Python è un linguaggio **non tipizzato** questo vuol dire che il tipo di dato che una variabile può contenere non va dichiarato espressamente. Per conoscere il tipo di dato che una variabile contiene possiamo usare la funzione type." 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": 10, 338 | "metadata": { 339 | "colab": { 340 | "base_uri": "https://localhost:8080/", 341 | "height": 34 342 | }, 343 | "colab_type": "code", 344 | "id": "sXh6P8aZgnDe", 345 | "outputId": "49de4027-6218-4099-f57c-1dbd6c41e47b" 346 | }, 347 | "outputs": [ 348 | { 349 | "data": { 350 | "text/plain": [ 351 | "str" 352 | ] 353 | }, 354 | "execution_count": 10, 355 | "metadata": {}, 356 | "output_type": "execute_result" 357 | } 358 | ], 359 | "source": [ 360 | "var = \"ciao\"\n", 361 | "type(var)" 362 | ] 363 | }, 364 | { 365 | "cell_type": "markdown", 366 | "metadata": {}, 367 | "source": [ 368 | "**NOTA BENE** Jupyter Notebook e l'interprete interattivo di Python stampano l'output dell'ultima istruzione anche senza utilizzare esplicitamente la funzione *print*." 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "metadata": { 374 | "colab_type": "text", 375 | "id": "C4JNDK2gmOpV" 376 | }, 377 | "source": [ 378 | "I tipi di dati principali che Python ci mette a disposizine sono i seguenti:\n", 379 | " * **Interi**: numeri interi (es: 5, 10, 123)\n", 380 | " * **Float**: numeri in virgola mobile (es: 4.34, 5.31, 0.17)\n", 381 | " * **Stringhe**: del testo (es: \"ciao\", \"abc\", \"Yo, come butta fratello ?\")\n", 382 | " * **Booleani**: possono avere solo due valori vero/falso (True/False)" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": 11, 388 | "metadata": { 389 | "colab": { 390 | "base_uri": "https://localhost:8080/", 391 | "height": 34 392 | }, 393 | "colab_type": "code", 394 | "id": "qf2cRHTwn1CF", 395 | "outputId": "4f2f5605-c633-4180-a3a0-5853ae0a5cf6" 396 | }, 397 | "outputs": [ 398 | { 399 | "data": { 400 | "text/plain": [ 401 | "bool" 402 | ] 403 | }, 404 | "execution_count": 11, 405 | "metadata": {}, 406 | "output_type": "execute_result" 407 | } 408 | ], 409 | "source": [ 410 | "# Intero\n", 411 | "var = 5\n", 412 | "\n", 413 | "# Float\n", 414 | "var = 4.15\n", 415 | "\n", 416 | "# Stringa\n", 417 | "var = \"ciao ciao\"\n", 418 | "\n", 419 | "# Boolean\n", 420 | "var = True\n", 421 | "\n", 422 | "type(var)" 423 | ] 424 | }, 425 | { 426 | "cell_type": "markdown", 427 | "metadata": { 428 | "colab_type": "text", 429 | "id": "aHjXd8iqoEg7" 430 | }, 431 | "source": [ 432 | "Con python possiamo convertire un tipo di dato in un altro con un'operazione chiamata casting" 433 | ] 434 | }, 435 | { 436 | "cell_type": "markdown", 437 | "metadata": { 438 | "colab_type": "text", 439 | "id": "BgP1lT_ro6k2" 440 | }, 441 | "source": [ 442 | "#### ES. 1: Casting da intero a stringa" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": 12, 448 | "metadata": { 449 | "colab": { 450 | "base_uri": "https://localhost:8080/", 451 | "height": 51 452 | }, 453 | "colab_type": "code", 454 | "id": "8WjdSh1loCWw", 455 | "outputId": "a456e4fc-44fd-4cd5-841c-59d9e5909453" 456 | }, 457 | "outputs": [ 458 | { 459 | "name": "stdout", 460 | "output_type": "stream", 461 | "text": [ 462 | "5\n", 463 | "\n" 464 | ] 465 | } 466 | ], 467 | "source": [ 468 | "# Creiamo una variabile che contiene un'intero\n", 469 | "var = 5\n", 470 | "\n", 471 | "# Convertiamo la variabile da intero a stringa\n", 472 | "var = str(var)\n", 473 | "\n", 474 | "print(var)\n", 475 | "print(type(var))" 476 | ] 477 | }, 478 | { 479 | "cell_type": "markdown", 480 | "metadata": { 481 | "colab_type": "text", 482 | "id": "5WI__YUspQdp" 483 | }, 484 | "source": [ 485 | "#### ES. 2: Casting da intero a float" 486 | ] 487 | }, 488 | { 489 | "cell_type": "code", 490 | "execution_count": 13, 491 | "metadata": { 492 | "colab": { 493 | "base_uri": "https://localhost:8080/", 494 | "height": 51 495 | }, 496 | "colab_type": "code", 497 | "id": "n06E8AbNpCB5", 498 | "outputId": "fd9236b3-16a5-47cb-8c26-64c5aea47b94" 499 | }, 500 | "outputs": [ 501 | { 502 | "name": "stdout", 503 | "output_type": "stream", 504 | "text": [ 505 | "1.0\n", 506 | "\n" 507 | ] 508 | } 509 | ], 510 | "source": [ 511 | "# Creiamo una variabile che contiene un intero\n", 512 | "var = 1\n", 513 | "\n", 514 | "# Convertiamo la variabile da intero a float\n", 515 | "var = float(var)\n", 516 | "\n", 517 | "print(var)\n", 518 | "print(type(var))" 519 | ] 520 | }, 521 | { 522 | "cell_type": "markdown", 523 | "metadata": { 524 | "colab_type": "text", 525 | "id": "TB6rS6oGpZGf" 526 | }, 527 | "source": [ 528 | "#### ES. 3: Casting da stringa a intero\n", 529 | "\n" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": 14, 535 | "metadata": { 536 | "colab": { 537 | "base_uri": "https://localhost:8080/", 538 | "height": 51 539 | }, 540 | "colab_type": "code", 541 | "id": "sxwMFLWSpD_v", 542 | "outputId": "7c5bd9d0-a5e9-447d-8f3f-08f667c2237a" 543 | }, 544 | "outputs": [ 545 | { 546 | "name": "stdout", 547 | "output_type": "stream", 548 | "text": [ 549 | "10\n", 550 | "\n" 551 | ] 552 | } 553 | ], 554 | "source": [ 555 | "# Creiamo una variabile che contiene una stringa\n", 556 | "var = \"10\"\n", 557 | "\n", 558 | "# Convertiamo la variabile da stringa a intero\n", 559 | "var = int(var)\n", 560 | "\n", 561 | "print(var)\n", 562 | "print(type(var))" 563 | ] 564 | }, 565 | { 566 | "cell_type": "markdown", 567 | "metadata": { 568 | "colab_type": "text", 569 | "id": "ORxBFiNTpuBl" 570 | }, 571 | "source": [ 572 | "Ovviamente il casting da stringa ad intero non si può fare se la stringa non è un numero.\n", 573 | "#### ES. 3: Casting da stringa a intero (sbagliato)" 574 | ] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": 15, 579 | "metadata": { 580 | "colab": { 581 | "base_uri": "https://localhost:8080/", 582 | "height": 233 583 | }, 584 | "colab_type": "code", 585 | "id": "RS9qkW0cproH", 586 | "outputId": "d2de8784-4129-4173-a328-0a1a2a6e15ca" 587 | }, 588 | "outputs": [ 589 | { 590 | "ename": "ValueError", 591 | "evalue": "could not convert string to float: 'boh'", 592 | "output_type": "error", 593 | "traceback": [ 594 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 595 | "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", 596 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# Convertiamo la variabile da intero a float\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mvar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 597 | "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'boh'" 598 | ] 599 | } 600 | ], 601 | "source": [ 602 | "# Creiamo una variabile che contiene un intero\n", 603 | "var = \"boh\"\n", 604 | "\n", 605 | "# Convertiamo la variabile da intero a float\n", 606 | "var = float(var)\n", 607 | "\n", 608 | "print(var)\n", 609 | "print(type(var))" 610 | ] 611 | }, 612 | { 613 | "cell_type": "markdown", 614 | "metadata": { 615 | "colab_type": "text", 616 | "id": "Lsej6DAzqEU7" 617 | }, 618 | "source": [ 619 | "Come vedi il tentativo di convertire una parola in numero ha causato un'errore, che in Python vengono chiamate **eccezioni**.
\n", 620 | "Ogni volta che si verifica un'eccezione Python ci mostra:\n", 621 | " * la riga esatta in cui si è verificato (La freccia verde)\n", 622 | " * il tipo di eccezone (ValueError)\n", 623 | " * una breve descrizione (*could not convert string to float: 'boh' / Impossibile convertire la stringa 'boh' in float*)\n", 624 | " \n", 625 | " \n", 626 | " **APPROFONDIMENTO**\n", 627 | " Possiamo gestire le eccezioni con dei try-except, non tratteremo l'argomento in questo tutorial, ma puoi trovare informazioni in merito [qui](https://docs.python.it/html/tut/node10.html)\n", 628 | " \n", 629 | " Quando si tratta di unire stringhe e numeri, possiamo usare il casting" 630 | ] 631 | }, 632 | { 633 | "cell_type": "code", 634 | "execution_count": 16, 635 | "metadata": {}, 636 | "outputs": [ 637 | { 638 | "name": "stdout", 639 | "output_type": "stream", 640 | "text": [ 641 | "I gatti hanno 7 vite\n" 642 | ] 643 | } 644 | ], 645 | "source": [ 646 | "cat_lives = 7\n", 647 | "print(\"I gatti hanno \"+str(cat_lives)+\" vite\")" 648 | ] 649 | }, 650 | { 651 | "cell_type": "markdown", 652 | "metadata": {}, 653 | "source": [ 654 | "### Formattazione" 655 | ] 656 | }, 657 | { 658 | "cell_type": "markdown", 659 | "metadata": {}, 660 | "source": [ 661 | "Un'altra soluzione consiste nell'utilizzare l'operatore di formattazione (%)" 662 | ] 663 | }, 664 | { 665 | "cell_type": "code", 666 | "execution_count": 17, 667 | "metadata": {}, 668 | "outputs": [ 669 | { 670 | "name": "stdout", 671 | "output_type": "stream", 672 | "text": [ 673 | "I gatti hanno 7 vite\n" 674 | ] 675 | } 676 | ], 677 | "source": [ 678 | "cat_lives = 7\n", 679 | "print(\"I gatti hanno %d vite\" % cat_lives)" 680 | ] 681 | }, 682 | { 683 | "cell_type": "markdown", 684 | "metadata": {}, 685 | "source": [ 686 | "Il carattere dopo l'operatore di formattazione indica il tipo di variabile, i principali sono:\n", 687 | "* **%d**: numero intero\n", 688 | "* **%f**: numero in virgola mobile\n", 689 | "* **%s**: stringa\n", 690 | "\n", 691 | "Per la lista completa, dai uno sguardo [qui](https://docs.python.org/3/library/stdtypes.html#old-string-formatting).\n", 692 | "
\n", 693 | "Possiamo anche utilizzare più operatori di formattazione all'interno di una stringa." 694 | ] 695 | }, 696 | { 697 | "cell_type": "code", 698 | "execution_count": 18, 699 | "metadata": {}, 700 | "outputs": [ 701 | { 702 | "name": "stdout", 703 | "output_type": "stream", 704 | "text": [ 705 | "Come si chiama il tuo gatto ? Elon\n", 706 | "Quante vite ha perso ? 1\n", 707 | "Il tuo gatto Elon ha ancora 6 vite\n" 708 | ] 709 | } 710 | ], 711 | "source": [ 712 | "cat_lives = 7\n", 713 | "\n", 714 | "cat = input(\"Come si chiama il tuo gatto ? \")\n", 715 | "my_cat_lives = input(\"Quante vite ha perso ? \")\n", 716 | "\n", 717 | "my_cat_lives = int(my_cat_lives)\n", 718 | "\n", 719 | "my_cat_lives = cat_lives-my_cat_lives\n", 720 | "\n", 721 | "print(\"Il tuo gatto %s ha ancora %d vite\" % (cat, my_cat_lives))" 722 | ] 723 | }, 724 | { 725 | "cell_type": "markdown", 726 | "metadata": {}, 727 | "source": [ 728 | "**NOTA BENE** la funzione input ritorna una stringa, quindi abbiamo dovuto usare il casting per convertirla in un'intero" 729 | ] 730 | }, 731 | { 732 | "cell_type": "markdown", 733 | "metadata": {}, 734 | "source": [ 735 | "Un'altra soluzione ancora, quella consigliata per Python 3, consiste nell'utilizzare il metodo lo *format*" 736 | ] 737 | }, 738 | { 739 | "cell_type": "code", 740 | "execution_count": 19, 741 | "metadata": {}, 742 | "outputs": [ 743 | { 744 | "name": "stdout", 745 | "output_type": "stream", 746 | "text": [ 747 | "Come si chiama il tuo gatto ? Elon\n", 748 | "Quante vite ha perso ? 6\n", 749 | "Il tuo gatto Elon ha ancora 1 vite\n" 750 | ] 751 | } 752 | ], 753 | "source": [ 754 | "cat_lives = 7\n", 755 | "\n", 756 | "cat = input(\"Come si chiama il tuo gatto ? \")\n", 757 | "my_cat_lives = int(input(\"Quante vite ha perso ? \"))\n", 758 | "my_cat_lives = cat_lives-my_cat_lives\n", 759 | "\n", 760 | "print(\"Il tuo gatto {name} ha ancora {lives} vite\".format(name=cat, lives=my_cat_lives))" 761 | ] 762 | }, 763 | { 764 | "cell_type": "markdown", 765 | "metadata": {}, 766 | "source": [ 767 | "Se usiamo una versione di Python superiore alla 3.6 abbiamo anche un'altro modo per formattare le stringhe, chiamato **f-strings**" 768 | ] 769 | }, 770 | { 771 | "cell_type": "code", 772 | "execution_count": 20, 773 | "metadata": {}, 774 | "outputs": [ 775 | { 776 | "name": "stdout", 777 | "output_type": "stream", 778 | "text": [ 779 | "Come si chiama il tuo gatto ? Elon\n", 780 | "Quante vite ha perso ? 2\n", 781 | "Il tuo gatto Elon ha ancora 5 vite\n" 782 | ] 783 | } 784 | ], 785 | "source": [ 786 | "cat_lives = 7\n", 787 | "\n", 788 | "cat = input(\"Come si chiama il tuo gatto ? \")\n", 789 | "my_cat_lives = int(input(\"Quante vite ha perso ? \"))\n", 790 | "my_cat_lives = cat_lives-my_cat_lives\n", 791 | "\n", 792 | "# inseriamo una f prima della stringa per indicare la formattazione\n", 793 | "print(f\"Il tuo gatto {cat} ha ancora {my_cat_lives} vite\")" 794 | ] 795 | }, 796 | { 797 | "cell_type": "markdown", 798 | "metadata": { 799 | "colab_type": "text", 800 | "id": "Nr-zPSGkrgUZ" 801 | }, 802 | "source": [ 803 | "\n", 804 | "## Liste, Tuple e Set\n", 805 | "Ogni linguaggio di programmazione ci da la possibilità di creare sequenze di dati, Python lo fa con tre tipi, le liste e le tuple e i set\n", 806 | "
\n", 807 | "Possiamo creare una lista di dati semplicemente racchiudendoli tra parentesti quadre e separandoli con una virgola" 808 | ] 809 | }, 810 | { 811 | "cell_type": "code", 812 | "execution_count": 4, 813 | "metadata": { 814 | "colab": { 815 | "base_uri": "https://localhost:8080/", 816 | "height": 51 817 | }, 818 | "colab_type": "code", 819 | "id": "BvccptLFp7pz", 820 | "outputId": "5ee6094f-e704-4259-b2c5-8529cbdd95d3" 821 | }, 822 | "outputs": [ 823 | { 824 | "name": "stdout", 825 | "output_type": "stream", 826 | "text": [ 827 | "[1, 2, 3, 5, 8, 13, 21]\n", 828 | "\n" 829 | ] 830 | } 831 | ], 832 | "source": [ 833 | "l = [1, 2 ,3 ,5 ,8 ,13 ,21]\n", 834 | "print(l)\n", 835 | "print(type(l))" 836 | ] 837 | }, 838 | { 839 | "cell_type": "markdown", 840 | "metadata": { 841 | "colab_type": "text", 842 | "id": "gkF9MiT_sT1f" 843 | }, 844 | "source": [ 845 | "In questo caso abbiamo creato una lista che contiene i primi 7 valori della successione di Fibonacci. \n", 846 | "
\n", 847 | "Possiamo conoscere la lunghezza di una lista utilizzando la funzione len." 848 | ] 849 | }, 850 | { 851 | "cell_type": "code", 852 | "execution_count": 5, 853 | "metadata": { 854 | "colab": { 855 | "base_uri": "https://localhost:8080/", 856 | "height": 34 857 | }, 858 | "colab_type": "code", 859 | "id": "G8f7BB03sN8D", 860 | "outputId": "9b703c2b-c816-4d69-fab4-2e3ec5e8e9c7" 861 | }, 862 | "outputs": [ 863 | { 864 | "data": { 865 | "text/plain": [ 866 | "7" 867 | ] 868 | }, 869 | "execution_count": 5, 870 | "metadata": {}, 871 | "output_type": "execute_result" 872 | } 873 | ], 874 | "source": [ 875 | "len(l)" 876 | ] 877 | }, 878 | { 879 | "cell_type": "markdown", 880 | "metadata": {}, 881 | "source": [ 882 | "### Indexing" 883 | ] 884 | }, 885 | { 886 | "cell_type": "markdown", 887 | "metadata": { 888 | "colab_type": "text", 889 | "id": "EPYEIEPgsoqf" 890 | }, 891 | "source": [ 892 | "Per accedere ad un elemento della lista dobbiamo inserire il suo **indice** tra parentesi quadre, questa opeazione è chiamata *indexing*.\n", 893 | "
\n", 894 | "**NOTA BENISSIMO** In Python e in quasi tutti i linguaggi di programmazione gli indici partono da 0." 895 | ] 896 | }, 897 | { 898 | "cell_type": "code", 899 | "execution_count": 6, 900 | "metadata": { 901 | "colab": { 902 | "base_uri": "https://localhost:8080/", 903 | "height": 51 904 | }, 905 | "colab_type": "code", 906 | "id": "5muXSlokshvy", 907 | "outputId": "39f3617e-5d92-4641-c449-f2391c126ec3" 908 | }, 909 | "outputs": [ 910 | { 911 | "name": "stdout", 912 | "output_type": "stream", 913 | "text": [ 914 | "1\n", 915 | "2\n" 916 | ] 917 | } 918 | ], 919 | "source": [ 920 | "# stampiamo il primo elemento della lista\n", 921 | "print(l[0])\n", 922 | "\n", 923 | "#stampiamo il secondo elemento della lista\n", 924 | "print(l[1])" 925 | ] 926 | }, 927 | { 928 | "cell_type": "markdown", 929 | "metadata": { 930 | "colab_type": "text", 931 | "id": "e7rGwjFOtP_8" 932 | }, 933 | "source": [ 934 | "L'utilizzo del - davanti all'indice ci permette di accedere alla lista dall'ultimo elemento verso il primo, in questo caso l'indice parte da 1 e non da zero, quindi con -1 accederemo all'ultimo elemento della lista." 935 | ] 936 | }, 937 | { 938 | "cell_type": "code", 939 | "execution_count": 7, 940 | "metadata": { 941 | "colab": { 942 | "base_uri": "https://localhost:8080/", 943 | "height": 51 944 | }, 945 | "colab_type": "code", 946 | "id": "0lhjx5XVtC35", 947 | "outputId": "dfad5ccc-893f-464e-b291-b21f697e5206" 948 | }, 949 | "outputs": [ 950 | { 951 | "name": "stdout", 952 | "output_type": "stream", 953 | "text": [ 954 | "21\n", 955 | "8\n" 956 | ] 957 | } 958 | ], 959 | "source": [ 960 | "# stampiamo l'ultimo elemento della lista\n", 961 | "print(l[-1])\n", 962 | "\n", 963 | "# stampiamo il terzultimo elemento della lista\n", 964 | "print(l[-3])" 965 | ] 966 | }, 967 | { 968 | "cell_type": "markdown", 969 | "metadata": {}, 970 | "source": [ 971 | "### Slicing\n", 972 | "Possiamo estrarre solo una parte della lista inserendo gli indici di inizio (incluso) e fine (escluso) separati da (:)" 973 | ] 974 | }, 975 | { 976 | "cell_type": "code", 977 | "execution_count": 8, 978 | "metadata": {}, 979 | "outputs": [ 980 | { 981 | "name": "stdout", 982 | "output_type": "stream", 983 | "text": [ 984 | "[1, 2, 3]\n", 985 | "[8, 13]\n", 986 | "[13, 21]\n", 987 | "[1, 2, 3, 5, 8]\n" 988 | ] 989 | } 990 | ], 991 | "source": [ 992 | "# primi 3 elementi della lista\n", 993 | "print(l[:3])\n", 994 | "\n", 995 | "# quarto e quinto elemento \n", 996 | "print(l[4:6])\n", 997 | "\n", 998 | "# ultimi due elementi\n", 999 | "print(l[-2:])\n", 1000 | "\n", 1001 | "# fino ali ultimi 2 elementi\n", 1002 | "print(l[:-2])" 1003 | ] 1004 | }, 1005 | { 1006 | "cell_type": "markdown", 1007 | "metadata": {}, 1008 | "source": [ 1009 | "Possiamo anche utilizzare un terzo valore, che indicherà il verso della selezione, valore 1: da sinistra a destra (valore di default) valore -1 da destra a sinistra (per ribaltare la lista)." 1010 | ] 1011 | }, 1012 | { 1013 | "cell_type": "code", 1014 | "execution_count": 9, 1015 | "metadata": {}, 1016 | "outputs": [ 1017 | { 1018 | "data": { 1019 | "text/plain": [ 1020 | "[21, 13, 8, 5, 3, 2, 1]" 1021 | ] 1022 | }, 1023 | "execution_count": 9, 1024 | "metadata": {}, 1025 | "output_type": "execute_result" 1026 | } 1027 | ], 1028 | "source": [ 1029 | "# dall'ultimo al primo\n", 1030 | "l[::-1]" 1031 | ] 1032 | }, 1033 | { 1034 | "cell_type": "markdown", 1035 | "metadata": {}, 1036 | "source": [ 1037 | "### Verifica\n", 1038 | "Possiamo verificare se un elemento è contenuto nella lista con lo statement *in*, questo ritorna True se l'elemento è contenuto nella lista, altrimenti ritorna False (*in* è molto utile utilizzato per creare istruzioni condizionali, di cui parleremo più sotto)." 1039 | ] 1040 | }, 1041 | { 1042 | "cell_type": "code", 1043 | "execution_count": 10, 1044 | "metadata": {}, 1045 | "outputs": [ 1046 | { 1047 | "name": "stdout", 1048 | "output_type": "stream", 1049 | "text": [ 1050 | "False\n", 1051 | "True\n" 1052 | ] 1053 | } 1054 | ], 1055 | "source": [ 1056 | "l = [1, 2 ,3 ,5 ,8 ,13 ,21]\n", 1057 | "print(7 in l)\n", 1058 | "\n", 1059 | "l = [\"casa\", \"pozzo\", \"albero\"]\n", 1060 | "print(\"albero\" in l)" 1061 | ] 1062 | }, 1063 | { 1064 | "cell_type": "markdown", 1065 | "metadata": {}, 1066 | "source": [ 1067 | "### Modifica" 1068 | ] 1069 | }, 1070 | { 1071 | "cell_type": "markdown", 1072 | "metadata": { 1073 | "colab_type": "text", 1074 | "id": "ITIPxUB7txTI" 1075 | }, 1076 | "source": [ 1077 | "Possiamo modificare il valore di un elemento della lista semplicemente accedendo ad esso e eseguendo un'assegnazione." 1078 | ] 1079 | }, 1080 | { 1081 | "cell_type": "code", 1082 | "execution_count": 30, 1083 | "metadata": { 1084 | "colab": { 1085 | "base_uri": "https://localhost:8080/", 1086 | "height": 51 1087 | }, 1088 | "colab_type": "code", 1089 | "id": "n2OlFHX6tv8E", 1090 | "outputId": "e7122935-ec3c-4a20-9bb9-7fdebf5ec8b7" 1091 | }, 1092 | "outputs": [ 1093 | { 1094 | "name": "stdout", 1095 | "output_type": "stream", 1096 | "text": [ 1097 | "Vecchio valore in posizione 5: 8\n", 1098 | "Nuovo valore in posizione 5: 10\n" 1099 | ] 1100 | } 1101 | ], 1102 | "source": [ 1103 | "l = [1, 2 ,3 ,5 ,8 ,13 ,21]\n", 1104 | "\n", 1105 | "print(\"Vecchio valore in posizione 5: %d\" % l[4])\n", 1106 | "\n", 1107 | "# sostituiamo il valore alla posizione 3 con un 10\n", 1108 | "l[4]=10\n", 1109 | "\n", 1110 | "#stampiamo l'ultimo elemento della lista\n", 1111 | "print(\"Nuovo valore in posizione 5: %d\" % l[4])" 1112 | ] 1113 | }, 1114 | { 1115 | "cell_type": "markdown", 1116 | "metadata": { 1117 | "colab_type": "text", 1118 | "id": "LA69JeRiutNa" 1119 | }, 1120 | "source": [ 1121 | "Per modificare il contenuto di una lista possiamo sfruttare i seguenti metodi:\n", 1122 | "* **append(e)** aggiunge un elemento e in fondo alla lista\n", 1123 | "* **insert(i,e)** aggiunge l'elemento e all'indice i della lista\n", 1124 | "* **remove(e)** rimuove l'elemento e dalla lista\n", 1125 | "* **pop(i)** rimuove l'elemento all'indice i\n" 1126 | ] 1127 | }, 1128 | { 1129 | "cell_type": "code", 1130 | "execution_count": 32, 1131 | "metadata": { 1132 | "colab": { 1133 | "base_uri": "https://localhost:8080/", 1134 | "height": 86 1135 | }, 1136 | "colab_type": "code", 1137 | "id": "FRm5vukJuU9q", 1138 | "outputId": "0b702cf7-0b8b-407b-8cc2-3e2b8b5c58ed" 1139 | }, 1140 | "outputs": [ 1141 | { 1142 | "name": "stdout", 1143 | "output_type": "stream", 1144 | "text": [ 1145 | "['topo', 'gatto', 'cane']\n", 1146 | "['topo', 'cane']\n", 1147 | "['topo', 'bestia demoniaca', 'cane']\n", 1148 | "['topo', \"dominatore della terra, dell'universo e di tutto il creato\", 'cane']\n" 1149 | ] 1150 | } 1151 | ], 1152 | "source": [ 1153 | "# creiamo una lista contenente solo due elementi\n", 1154 | "animals = [\"topo\", \"gatto\"]\n", 1155 | "\n", 1156 | "# aggiungiamo la parola \"cane\" alla lista\n", 1157 | "animals.append(\"cane\")\n", 1158 | "print(animals)\n", 1159 | "\n", 1160 | "# rimuoviamo la parola \"gatto\" dalla lista\n", 1161 | "animals.remove(\"gatto\")\n", 1162 | "print(animals)\n", 1163 | "\n", 1164 | "# aggiungiamo un sinonimo di gatto alla posizione 1\n", 1165 | "animals.insert(1,\"bestia demoniaca\")\n", 1166 | "print(animals)\n", 1167 | "\n", 1168 | "# rimuoviamo l'elemento alla posizione 1\n", 1169 | "animals.pop(1)\n", 1170 | "\n", 1171 | "# aggiungiamo un sinonimo più realistico di gatto alla posizione 1\n", 1172 | "animals.insert(1,\"dominatore della terra, dell'universo e di tutto il creato\")\n", 1173 | "print(animals)" 1174 | ] 1175 | }, 1176 | { 1177 | "cell_type": "markdown", 1178 | "metadata": { 1179 | "colab_type": "text", 1180 | "id": "J0V5t-4mx_xA" 1181 | }, 1182 | "source": [ 1183 | "Passiamo alle tuple, possiamo creare una tupla inserendo gli elementi tra parentesi tonde e separandoli con una virgola" 1184 | ] 1185 | }, 1186 | { 1187 | "cell_type": "code", 1188 | "execution_count": null, 1189 | "metadata": { 1190 | "colab": { 1191 | "base_uri": "https://localhost:8080/", 1192 | "height": 34 1193 | }, 1194 | "colab_type": "code", 1195 | "id": "aQzIoiJBvuqo", 1196 | "outputId": "25309e59-ccb6-4069-d151-9819c4240462" 1197 | }, 1198 | "outputs": [], 1199 | "source": [ 1200 | "t = (1, 2 ,3 ,5 ,8 ,13 ,21)\n", 1201 | "print(t)\n", 1202 | "print(type(t))" 1203 | ] 1204 | }, 1205 | { 1206 | "cell_type": "markdown", 1207 | "metadata": { 1208 | "colab_type": "text", 1209 | "id": "MX1e_j3_yXYu" 1210 | }, 1211 | "source": [ 1212 | "Per l'accesso agli elementi vale la stessa regola delle liste, quindi indexing e slicing." 1213 | ] 1214 | }, 1215 | { 1216 | "cell_type": "code", 1217 | "execution_count": 34, 1218 | "metadata": { 1219 | "colab": { 1220 | "base_uri": "https://localhost:8080/", 1221 | "height": 51 1222 | }, 1223 | "colab_type": "code", 1224 | "id": "D75mqwx9yWk2", 1225 | "outputId": "d88f3238-62aa-4e9f-bd7c-fa9f581cbf9d" 1226 | }, 1227 | "outputs": [ 1228 | { 1229 | "name": "stdout", 1230 | "output_type": "stream", 1231 | "text": [ 1232 | "1\n", 1233 | "21\n" 1234 | ] 1235 | } 1236 | ], 1237 | "source": [ 1238 | "# Stampiamo il primo elemento della tupla\n", 1239 | "print(t[0])\n", 1240 | "\n", 1241 | "# Stampiamo l'ultimo elemento della tupla\n", 1242 | "print(t[-1])" 1243 | ] 1244 | }, 1245 | { 1246 | "cell_type": "markdown", 1247 | "metadata": { 1248 | "colab_type": "text", 1249 | "id": "mjQ1Ftvqyx6S" 1250 | }, 1251 | "source": [ 1252 | "Che differenza c'è tra una lista e una tupla ? La differenza consiste nel fatto che, una volta creata, una tupla non può essere modificata." 1253 | ] 1254 | }, 1255 | { 1256 | "cell_type": "code", 1257 | "execution_count": 35, 1258 | "metadata": { 1259 | "colab": { 1260 | "base_uri": "https://localhost:8080/", 1261 | "height": 164 1262 | }, 1263 | "colab_type": "code", 1264 | "id": "RTb8O4l2yxGA", 1265 | "outputId": "9a886f3d-bdde-48d0-8b93-16453a33ecf6" 1266 | }, 1267 | "outputs": [ 1268 | { 1269 | "ename": "TypeError", 1270 | "evalue": "'tuple' object does not support item assignment", 1271 | "output_type": "error", 1272 | "traceback": [ 1273 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 1274 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", 1275 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 1276 | "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" 1277 | ] 1278 | } 1279 | ], 1280 | "source": [ 1281 | "t[0] = 5" 1282 | ] 1283 | }, 1284 | { 1285 | "cell_type": "markdown", 1286 | "metadata": { 1287 | "colab_type": "text", 1288 | "id": "RKDMwMHxy2xN" 1289 | }, 1290 | "source": [ 1291 | "Come vedi il tentativo di modificare un'elemento della lista scatena un'eccezione di tipo TypeError, che ci informa proprio del fatto che gli elementi di una tupla non possono essere modificati." 1292 | ] 1293 | }, 1294 | { 1295 | "cell_type": "markdown", 1296 | "metadata": {}, 1297 | "source": [ 1298 | "Le stringe in Python possono essere considerate come tuple di caratteri, questo vuol dire che possiamo usare le operazioni di indexing e slicing anche su di esse." 1299 | ] 1300 | }, 1301 | { 1302 | "cell_type": "code", 1303 | "execution_count": 11, 1304 | "metadata": {}, 1305 | "outputs": [ 1306 | { 1307 | "name": "stdout", 1308 | "output_type": "stream", 1309 | "text": [ 1310 | "Hello\n", 1311 | "dlrow olleH\n" 1312 | ] 1313 | }, 1314 | { 1315 | "ename": "TypeError", 1316 | "evalue": "'str' object does not support item assignment", 1317 | "output_type": "error", 1318 | "traceback": [ 1319 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 1320 | "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", 1321 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"s\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 1322 | "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" 1323 | ] 1324 | } 1325 | ], 1326 | "source": [ 1327 | "s = \"Hello world\"\n", 1328 | "\n", 1329 | "print(s[:5])\n", 1330 | "print(s[::-1])\n", 1331 | "\n", 1332 | "s[4]=\"s\"" 1333 | ] 1334 | }, 1335 | { 1336 | "cell_type": "markdown", 1337 | "metadata": {}, 1338 | "source": [ 1339 | "Anche in questo caso il tentativo di modificare un elemento ha scatenato la stessa eccezione." 1340 | ] 1341 | }, 1342 | { 1343 | "cell_type": "markdown", 1344 | "metadata": {}, 1345 | "source": [ 1346 | "### Altre funzioni utili per liste e tuple" 1347 | ] 1348 | }, 1349 | { 1350 | "cell_type": "code", 1351 | "execution_count": 37, 1352 | "metadata": {}, 1353 | "outputs": [ 1354 | { 1355 | "name": "stdout", 1356 | "output_type": "stream", 1357 | "text": [ 1358 | "3\n", 1359 | "3\n", 1360 | "2\n", 1361 | "2\n" 1362 | ] 1363 | } 1364 | ], 1365 | "source": [ 1366 | "hello_list = [\"Ciao\",\"Hello\",\"Hola\",\"Salut\",\"Hallo\",\"Ciao\"]\n", 1367 | "hello_tuple = (\"Ciao\",\"Hello\",\"Hola\",\"Salut\",\"Hallo\",\"Ciao\")\n", 1368 | "\n", 1369 | "# ottieni l'indice dell'elemento\n", 1370 | "print(hello_list.index('Salut'))\n", 1371 | "print(hello_tuple.index('Salut'))\n", 1372 | "\n", 1373 | "# conta quante volte è presente un'elemento\n", 1374 | "print(hello_list.count('Ciao'))\n", 1375 | "print(hello_tuple.count('Ciao'))" 1376 | ] 1377 | }, 1378 | { 1379 | "cell_type": "markdown", 1380 | "metadata": {}, 1381 | "source": [ 1382 | "Veniamo ai set, i set sono insiemi di elementi unici non ordinati, questo vuol dire che un set non può contenere due volte lo stesso elemento e che non tiene conto della disposizione degli elementi al suo interno.\n", 1383 | "
\n", 1384 | "Possiamo creare un set inserendo gli elementi tra parentesi graffe e separandoli con una virgola." 1385 | ] 1386 | }, 1387 | { 1388 | "cell_type": "code", 1389 | "execution_count": 13, 1390 | "metadata": {}, 1391 | "outputs": [ 1392 | { 1393 | "name": "stdout", 1394 | "output_type": "stream", 1395 | "text": [ 1396 | "{1, 2, 3, 4, 5}\n", 1397 | "\n" 1398 | ] 1399 | } 1400 | ], 1401 | "source": [ 1402 | "my_set = {1,2,2,3,4,5,5}\n", 1403 | "print(my_set)\n", 1404 | "print(type(my_set))" 1405 | ] 1406 | }, 1407 | { 1408 | "cell_type": "markdown", 1409 | "metadata": {}, 1410 | "source": [ 1411 | "Come vedi gli elementi duplicati sono stati rimossi. Vediamo alcune funzioni utili per lavorare con i set." 1412 | ] 1413 | }, 1414 | { 1415 | "cell_type": "code", 1416 | "execution_count": 23, 1417 | "metadata": {}, 1418 | "outputs": [ 1419 | { 1420 | "name": "stdout", 1421 | "output_type": "stream", 1422 | "text": [ 1423 | "{'Federico', 'Giuseppe', 'Matteo', 'Antonio'}\n", 1424 | "{'Giuseppe', 'Matteo', 'Federico', 'Lorenzo', 'Antonio'}\n", 1425 | "{'Giuseppe', 'Matteo', 'Federico', 'Lorenzo', 'Antonio'}\n", 1426 | "{'Giuseppe', 'Matteo', 'Federico', 'Lorenzo'}\n", 1427 | "{'Giuseppe', 'Matteo', 'Federico', 'Lorenzo'}\n", 1428 | "Giuseppe\n", 1429 | "{'Matteo', 'Federico', 'Lorenzo'}\n", 1430 | "set()\n" 1431 | ] 1432 | } 1433 | ], 1434 | "source": [ 1435 | "# creiamo un set di nomi di persona\n", 1436 | "names = {\"Giuseppe\",\"Federico\",\"Antonio\",\"Matteo\"}\n", 1437 | "print(names)\n", 1438 | "\n", 1439 | "# aggiungiamo un elemento al set\n", 1440 | "names.add(\"Lorenzo\")\n", 1441 | "print(names)\n", 1442 | "\n", 1443 | "# se il nome è già presente, non verrà aggiunto\n", 1444 | "names.add(\"Federico\")\n", 1445 | "print(names)\n", 1446 | "\n", 1447 | "# rimuoviamo un nome\n", 1448 | "names.remove(\"Antonio\")\n", 1449 | "print(names)\n", 1450 | "\n", 1451 | "# se il nome non è presente otterremo un'eccezione KeyError\n", 1452 | "# in tal caso possiamo piuttosto usare discard\n", 1453 | "names.discard(\"Paolo\")\n", 1454 | "print(names)\n", 1455 | "\n", 1456 | "# estraiamo un elemento dal set\n", 1457 | "name = names.pop()\n", 1458 | "print(name)\n", 1459 | "print(names)\n", 1460 | "\n", 1461 | "# svuoitamo il set\n", 1462 | "names.clear()\n", 1463 | "print(names)" 1464 | ] 1465 | }, 1466 | { 1467 | "cell_type": "markdown", 1468 | "metadata": {}, 1469 | "source": [ 1470 | "Possiamo convertire una lista in un set e vice versa utilizzando il casting.\n", 1471 | "
\n", 1472 | "**NOTA BENE** convertendo una lista in un set, gli elementi al suo interno verrano mischiati e i duplicati verranno rimossi." 1473 | ] 1474 | }, 1475 | { 1476 | "cell_type": "code", 1477 | "execution_count": 30, 1478 | "metadata": {}, 1479 | "outputs": [ 1480 | { 1481 | "name": "stdout", 1482 | "output_type": "stream", 1483 | "text": [ 1484 | "['Giuseppe', 'Federico', 'Giuseppe', 'Antonio', 'Matteo', 'Matteo']\n", 1485 | "\n", 1486 | "{'Federico', 'Giuseppe', 'Matteo', 'Antonio'}\n", 1487 | "\n", 1488 | "['Federico', 'Giuseppe', 'Matteo', 'Antonio']\n", 1489 | "\n" 1490 | ] 1491 | } 1492 | ], 1493 | "source": [ 1494 | "my_list = [\"Giuseppe\",\"Federico\",\"Giuseppe\",\"Antonio\",\"Matteo\",\"Matteo\"]\n", 1495 | "print(my_list)\n", 1496 | "print(type(my_list))\n", 1497 | "\n", 1498 | "my_set = set(my_list)\n", 1499 | "print(my_set)\n", 1500 | "print(type(my_set))\n", 1501 | "\n", 1502 | "my_list = list(my_set)\n", 1503 | "print(my_list)\n", 1504 | "print(type(my_list))" 1505 | ] 1506 | }, 1507 | { 1508 | "cell_type": "markdown", 1509 | "metadata": {}, 1510 | "source": [ 1511 | "Possiamo anche creare un set immutabile utilizzando **frozenset**, in questo caso una volta creato non potremo più aggiungere o rimuovere elementi dal set." 1512 | ] 1513 | }, 1514 | { 1515 | "cell_type": "code", 1516 | "execution_count": 27, 1517 | "metadata": {}, 1518 | "outputs": [ 1519 | { 1520 | "name": "stdout", 1521 | "output_type": "stream", 1522 | "text": [ 1523 | "frozenset({'Federico', 'Giuseppe', 'Matteo', 'Antonio'})\n" 1524 | ] 1525 | } 1526 | ], 1527 | "source": [ 1528 | "names = frozenset({\"Giuseppe\",\"Federico\",\"Antonio\",\"Matteo\"})\n", 1529 | "print(names)" 1530 | ] 1531 | }, 1532 | { 1533 | "cell_type": "markdown", 1534 | "metadata": { 1535 | "colab_type": "text", 1536 | "id": "vhgo2EnpzGAF" 1537 | }, 1538 | "source": [ 1539 | "\n", 1540 | "## Dizionari\n", 1541 | "Un dizionario è un tipo Python che ci permette di salvare dei dati in un formato chiave valore, in maniera tale da poter utilizzare la chiave per accedere al valore. Possiamo creare un dizionario con Python racchiudendolo tra parentesi graffe e separando chiavi e valori con (:)" 1542 | ] 1543 | }, 1544 | { 1545 | "cell_type": "code", 1546 | "execution_count": 38, 1547 | "metadata": { 1548 | "colab": {}, 1549 | "colab_type": "code", 1550 | "id": "G4oig6SPy0tU" 1551 | }, 1552 | "outputs": [ 1553 | { 1554 | "data": { 1555 | "text/plain": [ 1556 | "dict" 1557 | ] 1558 | }, 1559 | "execution_count": 38, 1560 | "metadata": {}, 1561 | "output_type": "execute_result" 1562 | } 1563 | ], 1564 | "source": [ 1565 | "# Creiamo un dizionario con una lista della spesa\n", 1566 | "# specificando cosa comprare come chiave e la quantità come valore\n", 1567 | "items = {\"latte\":3,\"riso\": 2, \"tofu\":5}\n", 1568 | "type(items)" 1569 | ] 1570 | }, 1571 | { 1572 | "cell_type": "markdown", 1573 | "metadata": { 1574 | "colab_type": "text", 1575 | "id": "0FKKz8Ku0IjY" 1576 | }, 1577 | "source": [ 1578 | "Possiamo accedere ad un elemento del dizionario inserendo la chiave tra parentesi quadre" 1579 | ] 1580 | }, 1581 | { 1582 | "cell_type": "code", 1583 | "execution_count": 39, 1584 | "metadata": { 1585 | "colab": { 1586 | "base_uri": "https://localhost:8080/", 1587 | "height": 34 1588 | }, 1589 | "colab_type": "code", 1590 | "id": "CUUxEO9P0EPn", 1591 | "outputId": "bab50da0-3937-4682-d686-7c4143c99bb7" 1592 | }, 1593 | "outputs": [ 1594 | { 1595 | "data": { 1596 | "text/plain": [ 1597 | "5" 1598 | ] 1599 | }, 1600 | "execution_count": 39, 1601 | "metadata": {}, 1602 | "output_type": "execute_result" 1603 | } 1604 | ], 1605 | "source": [ 1606 | "items[\"tofu\"]" 1607 | ] 1608 | }, 1609 | { 1610 | "cell_type": "markdown", 1611 | "metadata": {}, 1612 | "source": [ 1613 | "Se la chiave è inesistente otterremo un'eccezione di tipo KeyError." 1614 | ] 1615 | }, 1616 | { 1617 | "cell_type": "code", 1618 | "execution_count": 40, 1619 | "metadata": {}, 1620 | "outputs": [ 1621 | { 1622 | "ename": "KeyError", 1623 | "evalue": "'cereali'", 1624 | "output_type": "error", 1625 | "traceback": [ 1626 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 1627 | "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", 1628 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mitems\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"cereali\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 1629 | "\u001b[0;31mKeyError\u001b[0m: 'cereali'" 1630 | ] 1631 | } 1632 | ], 1633 | "source": [ 1634 | "items[\"cereali\"]" 1635 | ] 1636 | }, 1637 | { 1638 | "cell_type": "markdown", 1639 | "metadata": { 1640 | "colab_type": "text", 1641 | "id": "XvTgJl9y0TY6" 1642 | }, 1643 | "source": [ 1644 | "Possiamo aggiungere un'altro elemento al dizionario semplicemente inserendo la chiave tra parentesi quadre ed eseguendo un'assegnazione" 1645 | ] 1646 | }, 1647 | { 1648 | "cell_type": "code", 1649 | "execution_count": 41, 1650 | "metadata": { 1651 | "colab": { 1652 | "base_uri": "https://localhost:8080/", 1653 | "height": 34 1654 | }, 1655 | "colab_type": "code", 1656 | "id": "acIQ4ff50QIw", 1657 | "outputId": "e3f6b64d-4da9-43d0-ea41-9bb41d3b779b" 1658 | }, 1659 | "outputs": [ 1660 | { 1661 | "name": "stdout", 1662 | "output_type": "stream", 1663 | "text": [ 1664 | "{'latte': 3, 'riso': 2, 'tofu': 5, 'cereali': 1}\n" 1665 | ] 1666 | } 1667 | ], 1668 | "source": [ 1669 | "items[\"cereali\"]=1\n", 1670 | "print(items)" 1671 | ] 1672 | }, 1673 | { 1674 | "cell_type": "markdown", 1675 | "metadata": { 1676 | "colab_type": "text", 1677 | "id": "-S_SU4dp0zYu" 1678 | }, 1679 | "source": [ 1680 | "E' possibile inserire all'interno di un elemento del dizionario un'altro dizionario." 1681 | ] 1682 | }, 1683 | { 1684 | "cell_type": "code", 1685 | "execution_count": 42, 1686 | "metadata": { 1687 | "colab": { 1688 | "base_uri": "https://localhost:8080/", 1689 | "height": 34 1690 | }, 1691 | "colab_type": "code", 1692 | "id": "Z_hB1zu20q2D", 1693 | "outputId": "9457cfe0-2705-4e20-cda0-c55aa5686d2d" 1694 | }, 1695 | "outputs": [ 1696 | { 1697 | "name": "stdout", 1698 | "output_type": "stream", 1699 | "text": [ 1700 | "{'latte': 3, 'riso': 2, 'tofu': 5, 'cereali': 1, 'yogurt': {'fragola': 2, 'bianco': 3}}\n" 1701 | ] 1702 | } 1703 | ], 1704 | "source": [ 1705 | "items[\"yogurt\"] = {\"fragola\":2, \"bianco\":3}\n", 1706 | "print(items)" 1707 | ] 1708 | }, 1709 | { 1710 | "cell_type": "markdown", 1711 | "metadata": { 1712 | "colab_type": "text", 1713 | "id": "vebmXA89261x" 1714 | }, 1715 | "source": [ 1716 | "\n", 1717 | "## I cicli\n", 1718 | "I cicli ci permettono di eseguire una serie di istruzioni in maniera ciclica.\n", 1719 | "
\n", 1720 | "Un'esempio classico di ciclo è il **ciclo for**, utilizzato da molti linguaggi di programmazione, Python incluso.\n", 1721 | "
\n", 1722 | "Utilizziamolo per stampare una serie di numeri" 1723 | ] 1724 | }, 1725 | { 1726 | "cell_type": "code", 1727 | "execution_count": 43, 1728 | "metadata": { 1729 | "colab": { 1730 | "base_uri": "https://localhost:8080/", 1731 | "height": 120 1732 | }, 1733 | "colab_type": "code", 1734 | "id": "few_O2NBzC1s", 1735 | "outputId": "6c651797-c02c-479e-c904-c2e8461434f2" 1736 | }, 1737 | "outputs": [ 1738 | { 1739 | "name": "stdout", 1740 | "output_type": "stream", 1741 | "text": [ 1742 | "Fino a che numero vuoi stampare ? 10\n", 1743 | "0\n", 1744 | "1\n", 1745 | "2\n", 1746 | "3\n", 1747 | "4\n", 1748 | "5\n", 1749 | "6\n", 1750 | "7\n", 1751 | "8\n", 1752 | "9\n" 1753 | ] 1754 | } 1755 | ], 1756 | "source": [ 1757 | "n = input(\"Fino a che numero vuoi stampare ? \")\n", 1758 | "n = int(n)\n", 1759 | "\n", 1760 | "for i in range(0,n):\n", 1761 | " print(i)" 1762 | ] 1763 | }, 1764 | { 1765 | "cell_type": "markdown", 1766 | "metadata": { 1767 | "colab_type": "text", 1768 | "id": "3pfs_91n4K2_" 1769 | }, 1770 | "source": [ 1771 | "La funzione range ritorna una sequenza di numeri, in questo caso che va da 0 a n, dove n è la variabile definita da noi con la fuzione input e ad ogni iterazione del ciclo la variabile i verrà incrementata di uno e otterrà il valore dell'i-esimo numero della sequenza, fino al valore n.\n", 1772 | "
\n", 1773 | "Passando un'unico valore come input della funzione range, questa farà partire la sequenza dal valore di default zero.\n", 1774 | "

\n", 1775 | "**NOTA BENISSIMO** Abbiamo lasciato 4 spazi prima dell'istruzione all'interno del ciclo for, questi spazi sono conosciuti l'**indentazione** e permettono all'interprete Python di comprendere il contesto delle istruzioni (ad esempio nel nostro codice permettono di comprendere quali istruzioni devono essere eseguite all'interno del ciclo for). Diversi linguaggi di programmazione, come C/C++, Java e Javascript, utilizzano le parentesi graffe per identifcare il contesto delle istruzioni, Python piuttosto forza ad usare l'indentazione per migliorare la leggibilità del codice (e lo fa benissimo !). I 4 caratteri per l'indentazione sono uno standard proposto nel [PEP 8](https://www.python.org/dev/peps/pep-0008/), in realtà è anche possibile utilizzare un numero differente di spazi (purché sia consistente in tutto il codice) oppure lo shift. Un blocco di codice indentanto viene sempre introdotto da (:) alla fine della riga precedente.\n", 1776 | "
\n", 1777 | "Se non indentiamo l'istruzione sotto il ciclo for otterremo un'eccezione di tipo *IndentationError*." 1778 | ] 1779 | }, 1780 | { 1781 | "cell_type": "code", 1782 | "execution_count": 44, 1783 | "metadata": {}, 1784 | "outputs": [ 1785 | { 1786 | "ename": "IndentationError", 1787 | "evalue": "expected an indented block (, line 2)", 1788 | "output_type": "error", 1789 | "traceback": [ 1790 | "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m print(i)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n" 1791 | ] 1792 | } 1793 | ], 1794 | "source": [ 1795 | "for i in range(0,10):\n", 1796 | "print(i)" 1797 | ] 1798 | }, 1799 | { 1800 | "cell_type": "markdown", 1801 | "metadata": {}, 1802 | "source": [ 1803 | "Implementiamo un ciclo for per il calcolo della successione di Fibonacci fino ad un indice definito da noi. Se non conosci la successione di Fibonacci, ogni elemento della sequenza è la somma dei due valori precedenti, per approfondire dai uno sguardo a [Wikipedia](https://it.wikipedia.org/wiki/Successione_di_Fibonacci)" 1804 | ] 1805 | }, 1806 | { 1807 | "cell_type": "code", 1808 | "execution_count": 47, 1809 | "metadata": { 1810 | "colab": { 1811 | "base_uri": "https://localhost:8080/", 1812 | "height": 206 1813 | }, 1814 | "colab_type": "code", 1815 | "id": "zHBS8qHf1FrP", 1816 | "outputId": "b23d509e-1595-40fb-c626-3f1e6bdea7cc" 1817 | }, 1818 | "outputs": [ 1819 | { 1820 | "name": "stdout", 1821 | "output_type": "stream", 1822 | "text": [ 1823 | "Quanti numeri di Fibonacci vuoi stampare? 10\n", 1824 | "1° numero di Fibonacci = 1\n", 1825 | "2° numero di Fibonacci = 1\n", 1826 | "3° numero di Fibonacci = 2\n", 1827 | "4° numero di Fibonacci = 3\n", 1828 | "5° numero di Fibonacci = 5\n", 1829 | "6° numero di Fibonacci = 8\n", 1830 | "7° numero di Fibonacci = 13\n", 1831 | "8° numero di Fibonacci = 21\n", 1832 | "9° numero di Fibonacci = 34\n", 1833 | "10° numero di Fibonacci = 55\n" 1834 | ] 1835 | } 1836 | ], 1837 | "source": [ 1838 | "#n = input(\"Quanti numeri di Fibonacci vuoi stampare? \")\n", 1839 | "#n = int(n)\n", 1840 | "\n", 1841 | "#Possiamo sintetizzare le due istruzioni sopra in un unico comando\n", 1842 | "n = int(input(\"Quanti numeri di Fibonacci vuoi stampare? \"))\n", 1843 | "\n", 1844 | "fib_num = 0\n", 1845 | "next_fib_num = 1\n", 1846 | "\n", 1847 | "for i in range(n):\n", 1848 | " #Salviamo il valore successivo in una variabile temporanea\n", 1849 | " tmp = next_fib_num\n", 1850 | " #Otteniamo il nuovo valore successivo sommando quello corrente\n", 1851 | " next_fib_num+=fib_num\n", 1852 | " #Assegnamo il valore successivo della successione a quello corrente\n", 1853 | " fib_num = tmp\n", 1854 | " \n", 1855 | " print(\"%d° numero di Fibonacci = %d\" % (i+1, fib_num))\n" 1856 | ] 1857 | }, 1858 | { 1859 | "cell_type": "markdown", 1860 | "metadata": { 1861 | "colab_type": "text", 1862 | "id": "mptV75aw5-qk" 1863 | }, 1864 | "source": [ 1865 | "Come vedi ci siamo ritrovati a dover immagazzinare il valore del numero successivo in una variabile temporanea, questa è necessaria ogni volta che c'è da invertire il valore di due variabili (questa procedura è chiamata **swapping**)" 1866 | ] 1867 | }, 1868 | { 1869 | "cell_type": "code", 1870 | "execution_count": 48, 1871 | "metadata": { 1872 | "colab": { 1873 | "base_uri": "https://localhost:8080/", 1874 | "height": 51 1875 | }, 1876 | "colab_type": "code", 1877 | "id": "rD17saHH5-DR", 1878 | "outputId": "62901af0-e6f6-4750-e08e-e074b41b80cc" 1879 | }, 1880 | "outputs": [ 1881 | { 1882 | "name": "stdout", 1883 | "output_type": "stream", 1884 | "text": [ 1885 | "a=cane b=gatto\n", 1886 | "a=gatto b=cane\n" 1887 | ] 1888 | } 1889 | ], 1890 | "source": [ 1891 | "a = \"cane\"\n", 1892 | "b = \"gatto\"\n", 1893 | "\n", 1894 | "print(\"a=%s b=%s\" % (a,b))\n", 1895 | "\n", 1896 | "tmp = a\n", 1897 | "a = b\n", 1898 | "b = tmp\n", 1899 | "\n", 1900 | "print(\"a=%s b=%s\" % (a,b))" 1901 | ] 1902 | }, 1903 | { 1904 | "cell_type": "markdown", 1905 | "metadata": { 1906 | "colab_type": "text", 1907 | "id": "VfN1hq1062Bq" 1908 | }, 1909 | "source": [ 1910 | "Python ci mette a disposizione una tecnica per eseguire lo **swapping** senza dover utilizzare una terza variabile, ma semplicemente eseguendo l'assegnazione in simultanea separando i valori con una virgola." 1911 | ] 1912 | }, 1913 | { 1914 | "cell_type": "code", 1915 | "execution_count": 49, 1916 | "metadata": { 1917 | "colab": { 1918 | "base_uri": "https://localhost:8080/", 1919 | "height": 51 1920 | }, 1921 | "colab_type": "code", 1922 | "id": "6e5L6is063PD", 1923 | "outputId": "6700c8e4-da8a-41fc-cf78-6f69ab850f9a" 1924 | }, 1925 | "outputs": [ 1926 | { 1927 | "name": "stdout", 1928 | "output_type": "stream", 1929 | "text": [ 1930 | "a=cane b=gatto\n", 1931 | "a=gatto b=cane\n" 1932 | ] 1933 | } 1934 | ], 1935 | "source": [ 1936 | "a = \"cane\"\n", 1937 | "b = \"gatto\"\n", 1938 | "\n", 1939 | "print(\"a=%s b=%s\" % (a,b))\n", 1940 | "\n", 1941 | "a,b = b,a\n", 1942 | "\n", 1943 | "print(\"a=%s b=%s\" % (a,b))" 1944 | ] 1945 | }, 1946 | { 1947 | "cell_type": "markdown", 1948 | "metadata": { 1949 | "colab_type": "text", 1950 | "id": "8RmjVtOl7I4Y" 1951 | }, 1952 | "source": [ 1953 | "Alla luce di ciò, modifichiamo il nostro algoritmo per il calcolo della successione di Fibonacci." 1954 | ] 1955 | }, 1956 | { 1957 | "cell_type": "code", 1958 | "execution_count": 52, 1959 | "metadata": { 1960 | "colab": { 1961 | "base_uri": "https://localhost:8080/", 1962 | "height": 206 1963 | }, 1964 | "colab_type": "code", 1965 | "id": "nXYPqjv7wDCA", 1966 | "outputId": "23add5e3-6c1e-4797-c236-a4a9d47a700c" 1967 | }, 1968 | "outputs": [ 1969 | { 1970 | "name": "stdout", 1971 | "output_type": "stream", 1972 | "text": [ 1973 | "Quanti numeri di Fibonacci vuoi stampare? 10\n", 1974 | "1° numero di Fibonacci = 1\n", 1975 | "2° numero di Fibonacci = 1\n", 1976 | "3° numero di Fibonacci = 2\n", 1977 | "4° numero di Fibonacci = 3\n", 1978 | "5° numero di Fibonacci = 5\n", 1979 | "6° numero di Fibonacci = 8\n", 1980 | "7° numero di Fibonacci = 13\n", 1981 | "8° numero di Fibonacci = 21\n", 1982 | "9° numero di Fibonacci = 34\n", 1983 | "10° numero di Fibonacci = 55\n" 1984 | ] 1985 | } 1986 | ], 1987 | "source": [ 1988 | "n = int(input(\"Quanti numeri di Fibonacci vuoi stampare? \"))\n", 1989 | "\n", 1990 | "fib_num = 0\n", 1991 | "next_fib_num = 1\n", 1992 | "\n", 1993 | "for i in range(n):\n", 1994 | " fib_num, next_fib_num = next_fib_num, next_fib_num+fib_num\n", 1995 | " print(\"%d° numero di Fibonacci = %d\" % (i+1, fib_num))" 1996 | ] 1997 | }, 1998 | { 1999 | "cell_type": "markdown", 2000 | "metadata": { 2001 | "colab_type": "text", 2002 | "id": "8rACxU0X7Rtk" 2003 | }, 2004 | "source": [ 2005 | "Decisamente meglio ! Possiamo utilizzare un ciclo for per iterare sugli elementi di una lista, potresti pensare che il modo per farlo possa essere questo:" 2006 | ] 2007 | }, 2008 | { 2009 | "cell_type": "code", 2010 | "execution_count": 53, 2011 | "metadata": { 2012 | "colab": { 2013 | "base_uri": "https://localhost:8080/", 2014 | "height": 103 2015 | }, 2016 | "colab_type": "code", 2017 | "id": "ki-kVgMc1_Ib", 2018 | "outputId": "0fc99b67-0566-4a00-f683-fb1f5f5649b9" 2019 | }, 2020 | "outputs": [ 2021 | { 2022 | "name": "stdout", 2023 | "output_type": "stream", 2024 | "text": [ 2025 | "La mia lista della spesa:\n", 2026 | "1) tofu\n", 2027 | "2) latte di soia\n", 2028 | "3) riso basmati\n", 2029 | "4) yogurt greco\n" 2030 | ] 2031 | } 2032 | ], 2033 | "source": [ 2034 | "shopping_list = [\"tofu\", \"latte di soia\", \"riso basmati\",\"yogurt greco\"]\n", 2035 | "\n", 2036 | "print(\"La mia lista della spesa:\")\n", 2037 | "\n", 2038 | "for i in range(len(shopping_list)):\n", 2039 | " print(\"%d) %s\" % (i+1,shopping_list[i]))" 2040 | ] 2041 | }, 2042 | { 2043 | "cell_type": "markdown", 2044 | "metadata": { 2045 | "colab_type": "text", 2046 | "id": "C8WUmrAK7nxr" 2047 | }, 2048 | "source": [ 2049 | "e funziona, ma in realtà esiste un metodo migliore per stampare la nostra lista della spesa, possiamo iterare direttamente sugli elementi della lista." 2050 | ] 2051 | }, 2052 | { 2053 | "cell_type": "code", 2054 | "execution_count": 54, 2055 | "metadata": { 2056 | "colab": { 2057 | "base_uri": "https://localhost:8080/", 2058 | "height": 103 2059 | }, 2060 | "colab_type": "code", 2061 | "id": "jfibk4zr1lV5", 2062 | "outputId": "465a5444-7679-469f-ec5f-1ffd8f7e7b97" 2063 | }, 2064 | "outputs": [ 2065 | { 2066 | "name": "stdout", 2067 | "output_type": "stream", 2068 | "text": [ 2069 | "La mia lista della spesa:\n", 2070 | "-tofu\n", 2071 | "-latte di soia\n", 2072 | "-riso basmati\n", 2073 | "-yogurt greco\n" 2074 | ] 2075 | } 2076 | ], 2077 | "source": [ 2078 | "shopping_list = [\"tofu\", \"latte di soia\", \"riso basmati\",\"yogurt greco\"]\n", 2079 | "\n", 2080 | "print(\"La mia lista della spesa:\")\n", 2081 | "\n", 2082 | "for entry in shopping_list:\n", 2083 | " print(\"-\"+entry)" 2084 | ] 2085 | }, 2086 | { 2087 | "cell_type": "markdown", 2088 | "metadata": { 2089 | "colab_type": "text", 2090 | "id": "ZPV_CnaM8GCA" 2091 | }, 2092 | "source": [ 2093 | "**NOTA BENE** entry è sempre una variabile il cui nome viene definito da noi, che conterrà ad ogni iterazione il successivo elemento della lista.\n", 2094 | "

\n", 2095 | "Come vedi adesso abbiamo stampato gli elementi della nostra lista della spesa in maniera decisamente più intuitiva, ma non abbiamo più l'indice i. Qualora ci servisse sia l'elemento che l'indice, possiamo utilizzare la funzione *enumerate*, che ci permette di iterare su entrambi." 2096 | ] 2097 | }, 2098 | { 2099 | "cell_type": "code", 2100 | "execution_count": 55, 2101 | "metadata": { 2102 | "colab": { 2103 | "base_uri": "https://localhost:8080/", 2104 | "height": 103 2105 | }, 2106 | "colab_type": "code", 2107 | "id": "SVctoXdX2NAH", 2108 | "outputId": "533fb391-2e68-47e4-ccce-a34815e54f86" 2109 | }, 2110 | "outputs": [ 2111 | { 2112 | "name": "stdout", 2113 | "output_type": "stream", 2114 | "text": [ 2115 | "La mia lista della spesa:\n", 2116 | "1) tofu\n", 2117 | "2) latte di soia\n", 2118 | "3) riso basmati\n", 2119 | "4) yogurt greco\n" 2120 | ] 2121 | } 2122 | ], 2123 | "source": [ 2124 | "shopping_list = [\"tofu\", \"latte di soia\", \"riso basmati\",\"yogurt greco\"]\n", 2125 | "\n", 2126 | "print(\"La mia lista della spesa:\")\n", 2127 | "\n", 2128 | "for i,entry in enumerate(shopping_list):\n", 2129 | " print(\"%d) %s\" % (i+1, entry))" 2130 | ] 2131 | }, 2132 | { 2133 | "cell_type": "markdown", 2134 | "metadata": { 2135 | "colab_type": "text", 2136 | "id": "lQ8FuRga8eyo" 2137 | }, 2138 | "source": [ 2139 | "Un'altra tiplogia di ciclo utilizzata da Python e da molti altri linguaggi di programmazione è il **ciclo while**, per creare un ciclo while dobbiamo definire un'**espressione booleana**, che ci permettono di eseguire confronti tra i dati, le espressioni booleane disponibili in python sono:\n", 2140 | "\n", 2141 | "* **==**: ritorna True se le due espressioni sono uguali, altrimenti ritorna False\n", 2142 | "* **!=**: ritorna True se le due espressioni sono diverse, altrimenti ritorna False\n", 2143 | "* **>**: ritorna True se la prima espressione è maggiore della seconda (solo numeri)\n", 2144 | "* **>=**: ritorna True se la prima espressione è maggiore o uguale alla seconda (solo numeri)\n", 2145 | "* **<**: ritorna True se la prima espressione è minore della seconda (solo numeri)\n", 2146 | "* **<=**: ritorna True se la prima espressione è minore o uguale alla seconda (solo numeri)" 2147 | ] 2148 | }, 2149 | { 2150 | "cell_type": "code", 2151 | "execution_count": 56, 2152 | "metadata": {}, 2153 | "outputs": [ 2154 | { 2155 | "name": "stdout", 2156 | "output_type": "stream", 2157 | "text": [ 2158 | "True\n", 2159 | "True\n", 2160 | "False\n", 2161 | "\n", 2162 | "\n", 2163 | "False\n", 2164 | "False\n", 2165 | "True\n", 2166 | "\n", 2167 | "\n", 2168 | "True\n", 2169 | "False\n", 2170 | "True\n" 2171 | ] 2172 | } 2173 | ], 2174 | "source": [ 2175 | "print(1==1)\n", 2176 | "print(3+2==6-1)\n", 2177 | "print(1!=1)\n", 2178 | "\n", 2179 | "print(\"\\n\")\n", 2180 | "\n", 2181 | "print(5>6)\n", 2182 | "print(5<5)\n", 2183 | "print(5<=5)\n", 2184 | "\n", 2185 | "print(\"\\n\")\n", 2186 | "\n", 2187 | "print(\"gatto\"==\"gatto\")\n", 2188 | "print(\"gatto\"==\"cane\")\n", 2189 | "print(\"cane\"!=\"gatto\")\n" 2190 | ] 2191 | }, 2192 | { 2193 | "cell_type": "markdown", 2194 | "metadata": {}, 2195 | "source": [ 2196 | "Adesso creiamo un ciclo while che verrò eseguito fino a quando la variabile i è minore del numero che abbiamo inserito." 2197 | ] 2198 | }, 2199 | { 2200 | "cell_type": "code", 2201 | "execution_count": 57, 2202 | "metadata": { 2203 | "colab": { 2204 | "base_uri": "https://localhost:8080/", 2205 | "height": 206 2206 | }, 2207 | "colab_type": "code", 2208 | "id": "uOHl8-Bz2VRl", 2209 | "outputId": "ec557453-8d90-4c4e-d4fe-cb46a32ee2be" 2210 | }, 2211 | "outputs": [ 2212 | { 2213 | "name": "stdout", 2214 | "output_type": "stream", 2215 | "text": [ 2216 | "Fino a che numero vuoi stampare ? 10\n", 2217 | "0\n", 2218 | "1\n", 2219 | "2\n", 2220 | "3\n", 2221 | "4\n", 2222 | "5\n", 2223 | "6\n", 2224 | "7\n", 2225 | "8\n", 2226 | "9\n" 2227 | ] 2228 | } 2229 | ], 2230 | "source": [ 2231 | "n = int(input(\"Fino a che numero vuoi stampare ? \"))\n", 2232 | "\n", 2233 | "i = 0\n", 2234 | "\n", 2235 | "while i\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Fino a che numero dispari vuoi stampare ? \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 2278 | "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'a'" 2279 | ] 2280 | } 2281 | ], 2282 | "source": [ 2283 | "n = int(input(\"Fino a che numero dispari vuoi stampare ? \"))\n", 2284 | "\n", 2285 | "i = 1\n", 2286 | "\n", 2287 | "while i\n", 2307 | "## Istruzioni condizionali\n", 2308 | "Le istruzioni condizionali ci permettono di eseguire del codice solo se una determinata condizione è soddisfatta, la condizione va definita sempre tramite le espressioni booleane. Conoscendo l'espressioni booleane, possiamo definire un'istruzione condizionale inserendo un'espressione dentro un **if**, il codice indentato sotto l'if verrà eseguito solo se la condizione sopra è soddisfatta, cioè se il suo risultato è *True*." 2309 | ] 2310 | }, 2311 | { 2312 | "cell_type": "markdown", 2313 | "metadata": {}, 2314 | "source": [ 2315 | "Conoscendo l'espressioni booleane, possiamo definire un'istruzione condizionale inserendo un'espressione dentro un **if**, il codice indentato sotto l'if verrà eseguito solo se la condizione sopra è soddisfatta, cioè se il suo risultato è *True*." 2316 | ] 2317 | }, 2318 | { 2319 | "cell_type": "code", 2320 | "execution_count": null, 2321 | "metadata": {}, 2322 | "outputs": [], 2323 | "source": [ 2324 | "n = input(\"Inserisci un numero: \")\n", 2325 | "n = int(n)\n", 2326 | "\n", 2327 | "if(n%2==0):\n", 2328 | " print(\"%d è un numero pari\" % n)" 2329 | ] 2330 | }, 2331 | { 2332 | "cell_type": "markdown", 2333 | "metadata": {}, 2334 | "source": [ 2335 | "Se il resto della divisione del numero per due è zero, allora si tratta di un numero pari e lo stampiamo. Se invece è un numero dispari ? Per gestire il caso in cui la condizione definita nell'if non è soddisfatta possiamo usare un **else**" 2336 | ] 2337 | }, 2338 | { 2339 | "cell_type": "code", 2340 | "execution_count": null, 2341 | "metadata": {}, 2342 | "outputs": [], 2343 | "source": [ 2344 | "n = input(\"Inserisci un numero: \")\n", 2345 | "n = int(n)\n", 2346 | "\n", 2347 | "if(n%2==0):\n", 2348 | " print(\"%d è un numero pari\" % n)\n", 2349 | "else:\n", 2350 | " print(\"%d è un numero dispari\" % n)" 2351 | ] 2352 | }, 2353 | { 2354 | "cell_type": "markdown", 2355 | "metadata": {}, 2356 | "source": [ 2357 | "Possiamo anche gestire più casi utilizzando degli **elif**." 2358 | ] 2359 | }, 2360 | { 2361 | "cell_type": "code", 2362 | "execution_count": null, 2363 | "metadata": {}, 2364 | "outputs": [], 2365 | "source": [ 2366 | "n = int(input(\"Da quanti anni programmi ? \"))\n", 2367 | "\n", 2368 | "if(n<0):\n", 2369 | " print(\"Hai inventato il viaggio nel tempo ?\")\n", 2370 | "elif(n>=0 and n<=1):\n", 2371 | " print(\"Sei un novellino !\")\n", 2372 | "elif(n>1 and n<=3):\n", 2373 | " print(\"Stai imparando !\")\n", 2374 | "elif(n>3 and n<=5):\n", 2375 | " print(\"Sarai già bravo !\")\n", 2376 | "elif(n>5 and n<=10):\n", 2377 | " print(\"Sarai molto bravo !\")\n", 2378 | "else:\n", 2379 | " print(\"Sarai un fenomeno !\")" 2380 | ] 2381 | }, 2382 | { 2383 | "cell_type": "markdown", 2384 | "metadata": { 2385 | "colab": {}, 2386 | "colab_type": "code", 2387 | "id": "8rr4jpid-EjA" 2388 | }, 2389 | "source": [ 2390 | "All'interno degli *elif* abbiamo inserito due condizioni unendole con un *and*, questo è un'**operatore logico**." 2391 | ] 2392 | }, 2393 | { 2394 | "cell_type": "markdown", 2395 | "metadata": {}, 2396 | "source": [ 2397 | "### Operatori logici\n", 2398 | "in Python abbiamo i seguenti operatori logici:\n", 2399 | " * **and**: ritorna True se entrambe le due condizioni sono True, altrimenti ritorna False\n", 2400 | " * **or**: ritorna True se almeno una delle due condizioni è True, altrimenti ritorna False\n", 2401 | " * **not**: esegue una negazione, se la condizione è True ritornerà False, se è False ritornerà True" 2402 | ] 2403 | }, 2404 | { 2405 | "cell_type": "code", 2406 | "execution_count": null, 2407 | "metadata": {}, 2408 | "outputs": [], 2409 | "source": [ 2410 | "# entrambe le condizioni sono soddisfatte\n", 2411 | "print(1==1 and \"casa\"!=\"albergo\")\n", 2412 | "\n", 2413 | "# la prima condizione non è soddisfatta\n", 2414 | "print(1==2 and \"casa\"!=\"albergo\")\n", 2415 | "\n", 2416 | "# la prima condizione non è soddisfatta\n", 2417 | "print(1==2 or \"casa\"!=\"albergo\")\n", 2418 | "\n", 2419 | "# Nessuna condizione è soddisfatta\n", 2420 | "print(1==2 or \"casa\"==\"albergo\")\n", 2421 | "\n", 2422 | "# Nessuna condizione è soddisfatta\n", 2423 | "print(not(1==2 or \"casa\"==\"albergo\"))\n", 2424 | "\n", 2425 | "# Tutte le condizioni sono soddisfatte\n", 2426 | "print(not(1==1 or \"casa\"!=\"albergo\"))\n" 2427 | ] 2428 | }, 2429 | { 2430 | "cell_type": "markdown", 2431 | "metadata": {}, 2432 | "source": [ 2433 | "Riprendendo l'esempio della successione di Fibonacci, possiamo verificare che l'input sia effettivamente un numero in questo modo" 2434 | ] 2435 | }, 2436 | { 2437 | "cell_type": "code", 2438 | "execution_count": 4, 2439 | "metadata": {}, 2440 | "outputs": [ 2441 | { 2442 | "name": "stdout", 2443 | "output_type": "stream", 2444 | "text": [ 2445 | "Quanti numeri di Fibonacci vuoi stampare? dieci\n", 2446 | "Numero non valido !\n" 2447 | ] 2448 | } 2449 | ], 2450 | "source": [ 2451 | "n = input(\"Quanti numeri di Fibonacci vuoi stampare? \")\n", 2452 | "\n", 2453 | "if(not n.isdigit()):\n", 2454 | " print(\"Numero non valido !\")\n", 2455 | "else:\n", 2456 | " n = int(n)\n", 2457 | " fib_num = 0\n", 2458 | " next_fib_num = 1\n", 2459 | "\n", 2460 | " for i in range(n):\n", 2461 | " fib_num, next_fib_num = next_fib_num, next_fib_num+fib_num\n", 2462 | " print(\"%d° numero di Fibonacci = %d\" % (i+1, fib_num))" 2463 | ] 2464 | }, 2465 | { 2466 | "cell_type": "markdown", 2467 | "metadata": {}, 2468 | "source": [ 2469 | "**NOTA BENE**\n", 2470 | "* *isdigit* è un metodo della classe string (ne parleremo sotto), questo ritorna True se la stringa contiene un numero, altrimenti ritorna False\n", 2471 | "* nota la doppia indentazione nel ciclo for, necessaria per indicare che le istruzini fanno parte del ciclo for, che a sua volta fa parte del blocco else." 2472 | ] 2473 | }, 2474 | { 2475 | "cell_type": "markdown", 2476 | "metadata": { 2477 | "colab_type": "text", 2478 | "id": "VJ5GKLTMCSbS" 2479 | }, 2480 | "source": [ 2481 | "\n", 2482 | "## Le funzioni\n", 2483 | "Le funzioni ci permettono di riutilizzare blocchi di codice prendendo eventualmente dei dati in ingresso, chiamati **argomenti** o **parametri** e ritornando un'output. \n", 2484 | "
\n", 2485 | "Ad esempio, scriviamo una funzione per il calcolo dell'aria di un triangolo." 2486 | ] 2487 | }, 2488 | { 2489 | "cell_type": "code", 2490 | "execution_count": null, 2491 | "metadata": { 2492 | "colab": { 2493 | "base_uri": "https://localhost:8080/", 2494 | "height": 34 2495 | }, 2496 | "colab_type": "code", 2497 | "id": "DtHVVJnOCWHU", 2498 | "outputId": "3c1eb718-89f1-4ef2-b09a-2951714daca3" 2499 | }, 2500 | "outputs": [], 2501 | "source": [ 2502 | "def compute_area(b,h):\n", 2503 | " area = b*h/2\n", 2504 | " return area\n", 2505 | "\n", 2506 | "b = 5\n", 2507 | "h = 3\n", 2508 | "area = compute_area(b, h)\n", 2509 | "\n", 2510 | "print(\"L'area del triangolo con base %.2f e altezza %.2f è %.2f\" %(b,h,area))" 2511 | ] 2512 | }, 2513 | { 2514 | "cell_type": "markdown", 2515 | "metadata": { 2516 | "colab_type": "text", 2517 | "id": "qJLgm1K9DIBJ" 2518 | }, 2519 | "source": [ 2520 | "La funzione viene definita con un *def* seguito dal nome della funzione e tra parentesi il nome dei suoi parametri, il valore che la funzione ritornerà sarà quello inserito dopo *return*.\n", 2521 | "
\n", 2522 | "Avremmo potuto scrivere la funzione in maniera più compatta inserendo il calcolo direttamente all'interno del return.\n" 2523 | ] 2524 | }, 2525 | { 2526 | "cell_type": "code", 2527 | "execution_count": null, 2528 | "metadata": { 2529 | "colab": {}, 2530 | "colab_type": "code", 2531 | "id": "KFKsSCZFDFtc" 2532 | }, 2533 | "outputs": [], 2534 | "source": [ 2535 | "def compute_area(b,h):\n", 2536 | " return b*h/2" 2537 | ] 2538 | }, 2539 | { 2540 | "cell_type": "markdown", 2541 | "metadata": { 2542 | "colab_type": "text", 2543 | "id": "H_N0pc1kDfQA" 2544 | }, 2545 | "source": [ 2546 | "Una funzione non deve per forza ritornare un valore, ad esempio può essere utilizzata per stampare un'ouput." 2547 | ] 2548 | }, 2549 | { 2550 | "cell_type": "code", 2551 | "execution_count": null, 2552 | "metadata": { 2553 | "colab": { 2554 | "base_uri": "https://localhost:8080/", 2555 | "height": 103 2556 | }, 2557 | "colab_type": "code", 2558 | "id": "riIeWJ_oCovp", 2559 | "outputId": "475605a7-4fcf-4d85-c436-1aa27abcb336" 2560 | }, 2561 | "outputs": [], 2562 | "source": [ 2563 | "def print_shopping_list(shopping_list):\n", 2564 | " \n", 2565 | " print(\"La tua lista della spesa:\")\n", 2566 | " \n", 2567 | " for i, entry in enumerate(shopping_list):\n", 2568 | " print(\"%d) %s\" % (i+1, entry))\n", 2569 | " \n", 2570 | " \n", 2571 | "shopping_list = [\"tofu\", \"latte di soia\", \"riso basmati\",\"yogurt greco\"]\n", 2572 | "print_shopping_list(shopping_list)" 2573 | ] 2574 | }, 2575 | { 2576 | "cell_type": "markdown", 2577 | "metadata": { 2578 | "colab_type": "text", 2579 | "id": "B8K6s21sd81w" 2580 | }, 2581 | "source": [ 2582 | "I Parametri di una funzione possono contenere dei valori di default che verranno utilizzati nel caso in cui non specifichiamo tali parametri quando chiamiamo la funzione." 2583 | ] 2584 | }, 2585 | { 2586 | "cell_type": "code", 2587 | "execution_count": null, 2588 | "metadata": { 2589 | "colab": { 2590 | "base_uri": "https://localhost:8080/", 2591 | "height": 130 2592 | }, 2593 | "colab_type": "code", 2594 | "id": "IWjsD5y9D-0D", 2595 | "outputId": "89fb10b7-51fa-4332-d388-a28f93eed1e2" 2596 | }, 2597 | "outputs": [], 2598 | "source": [ 2599 | "def print_shopping_list(shopping_list, owner=\"Giuseppe\"):\n", 2600 | " \n", 2601 | " print(\"La lista della spesa di %s:\" % owner)\n", 2602 | " \n", 2603 | " for i, entry in enumerate(shopping_list):\n", 2604 | " print(\"%d) %s\" % (i+1, entry))\n", 2605 | " \n", 2606 | " \n", 2607 | "shopping_list = [\"tofu\", \"latte di soia\", \"riso basmati\",\"yogurt greco\"]\n", 2608 | "print_shopping_list(shopping_list)\n", 2609 | "\n", 2610 | "# Stampiamo una linea vuota per separare le due liste\n", 2611 | "print(\"\\n\")\n", 2612 | "\n", 2613 | "shopping_list = [\"croccantini \", \"latte\", \"scatolette di tonno\",\"plutonio\"]\n", 2614 | "print_shopping_list(shopping_list, owner=\"Elon\") # Elon è il nome del mio gatto :)" 2615 | ] 2616 | }, 2617 | { 2618 | "cell_type": "markdown", 2619 | "metadata": {}, 2620 | "source": [ 2621 | "**NOTA BENE** I parametri senza valore di default vanno sempre inseriti **prima** dei parametri con valore di defualt, altrimenti python genererà un'eccezione del tipo *SintaxError*, se vuoi sperimentarlo inserisci il parametro *owner* prima del parametro *shopping_list* nella definizione della funzione qui sotto." 2622 | ] 2623 | }, 2624 | { 2625 | "cell_type": "markdown", 2626 | "metadata": { 2627 | "colab_type": "text", 2628 | "id": "A8RJOinYGsUa" 2629 | }, 2630 | "source": [ 2631 | "\n", 2632 | "## Basi di programmazione ad oggetti\n", 2633 | "Python supporta molti **paradigmi di programamazione**, che caratterizzano lo stile del codice. Il paradigma basato sulle funzioni è conosciuto come **Programmazione Procedurale (Procedural Programming)** (le funzioni vengono anche chiamate procedure). Un'altro paradigma di programmazione molto utilizzato è la **Programmazione Orientata agli Oggetti (Object Oriented Programming - OOP)**. \n", 2634 | "
\n", 2635 | "L'elemento centrale della programmazione ad oggetti sono (sorpresa sorpresa) **gli oggetti**, che ci permettono di racchiudere funzioni e variabili all'interno di un'unica entità e rendono il codice maggiormente riutilizzabile e più semplice da mantenere.\n", 2636 | "

\n", 2637 | "Per creare un oggetto dobbiamo definire una classe che lo rappresenterà, le funzioni definite all'interno della classe sono chiamati **metodi** della classe.\n", 2638 | "
\n", 2639 | "Ad esempio, creiamo una classe che rappresentà un triangolo, i cui metodi ci permettono di calcolarne area e perimetro." 2640 | ] 2641 | }, 2642 | { 2643 | "cell_type": "code", 2644 | "execution_count": null, 2645 | "metadata": { 2646 | "colab": { 2647 | "base_uri": "https://localhost:8080/", 2648 | "height": 51 2649 | }, 2650 | "colab_type": "code", 2651 | "id": "8r40_XHSGqHB", 2652 | "outputId": "c00d4651-046c-46f3-f57f-2e829bd6f09e" 2653 | }, 2654 | "outputs": [], 2655 | "source": [ 2656 | "class Triangle:\n", 2657 | " \n", 2658 | " def area(self, b, h):\n", 2659 | " return b*h/2.\n", 2660 | " \n", 2661 | " def perimeter(self, a, b, c):\n", 2662 | " return a+b+c\n", 2663 | " \n", 2664 | "# istanziamo la classe (creiamo l'oggetto)\n", 2665 | "triangle = Triangle()\n", 2666 | "\n", 2667 | "print(\"Area del triangolo: %2.f\" % triangle.area(3.,4.))\n", 2668 | "print(\"Perimetro del triangolo: %2.f\" % triangle.perimeter(5.,3.,5.))" 2669 | ] 2670 | }, 2671 | { 2672 | "cell_type": "markdown", 2673 | "metadata": {}, 2674 | "source": [ 2675 | "Come puoi vedere ogni metodo della classe ha come primo parametro *self*, questo ci permette di identificare attributi e metodi all'interno della classe stessa.\n", 2676 | "Alla riga 10 creiamo l'oggetto, che a livello concettuale è un'**istanza** della classe triangolo. Per calcolare area e perimetro dobbiamo passare di volta in volta le informazioni sulle misure di base, altezze e lati del triangolo, che funziona ma è concettualmente sbagliato, un'oggetto deve contenere le proprie informazioni al suo interno, in apposite variabili chiamate **attributi**.\n", 2677 | "
\n", 2678 | "Possiamo definire gli attributi della classe all'interno di un **metodo costruttore** che in Python è l'*init*" 2679 | ] 2680 | }, 2681 | { 2682 | "cell_type": "code", 2683 | "execution_count": null, 2684 | "metadata": { 2685 | "colab": { 2686 | "base_uri": "https://localhost:8080/", 2687 | "height": 51 2688 | }, 2689 | "colab_type": "code", 2690 | "id": "-XBKcwYrIImt", 2691 | "outputId": "5ec0f5dc-8007-4d81-a3d4-ef19702cc4f6" 2692 | }, 2693 | "outputs": [], 2694 | "source": [ 2695 | "class Triangle:\n", 2696 | " \n", 2697 | " \n", 2698 | " def __init__(self, a, b, c, h):\n", 2699 | " \n", 2700 | " # Questa istruzione è equivalente a quella sotto\n", 2701 | " #self.a, self.b, self.c, self.h = a, b, c ,h\n", 2702 | "\n", 2703 | " self.a = a\n", 2704 | " self.b = b\n", 2705 | " self.c = c\n", 2706 | " self.h = h\n", 2707 | "\n", 2708 | " \n", 2709 | " def area(self):\n", 2710 | " return self.b*self.h/2\n", 2711 | " \n", 2712 | " \n", 2713 | " def perimeter(self):\n", 2714 | " return self.a+self.b+self.c\n", 2715 | " \n", 2716 | "triangle = Triangle(5.,3.,5.,4.)\n", 2717 | "print(\"Area del triangolo: %2.f\" % triangle.area())\n", 2718 | "print(\"Perimetro del triangolo: %2.f\" % triangle.perimeter())" 2719 | ] 2720 | }, 2721 | { 2722 | "cell_type": "markdown", 2723 | "metadata": {}, 2724 | "source": [ 2725 | "Ogni metodo può accedere agli attributi della classe utilizzando *self*, lo stesso discorso vale per l'utilizzo di metodi all'interno di altri metodi." 2726 | ] 2727 | }, 2728 | { 2729 | "cell_type": "code", 2730 | "execution_count": null, 2731 | "metadata": { 2732 | "colab": { 2733 | "base_uri": "https://localhost:8080/", 2734 | "height": 51 2735 | }, 2736 | "colab_type": "code", 2737 | "id": "YdQPq1_KI_kW", 2738 | "outputId": "63b2f958-8a41-4c09-82d6-a4b37edef2f8" 2739 | }, 2740 | "outputs": [], 2741 | "source": [ 2742 | "class Triangle:\n", 2743 | " \n", 2744 | " \n", 2745 | " def __init__(self, a, b, c, h):\n", 2746 | " self.a, self.b, self.c, self.h = a, b, c ,h\n", 2747 | "\n", 2748 | " \n", 2749 | " def area(self):\n", 2750 | " return float(self.b)*float(self.h)/2.\n", 2751 | " \n", 2752 | " \n", 2753 | " def perimeter(self):\n", 2754 | " return self.a+self.b+self.c\n", 2755 | " \n", 2756 | " \n", 2757 | " def print_info(self):\n", 2758 | " print(\"Area del triangolo: %2.f\" % self.area())\n", 2759 | " print(\"Perimetro del triangolo: %2.f\" % self.perimeter())\n", 2760 | "\n", 2761 | "\n", 2762 | "triangle = Triangle(5.,3.,5.,4.)\n", 2763 | "triangle.print_info()" 2764 | ] 2765 | }, 2766 | { 2767 | "cell_type": "markdown", 2768 | "metadata": {}, 2769 | "source": [ 2770 | "Le classi possono essere organizzate in moduli, cioè file python esterni a quello sulla quale stiamo lavorando (parlemeno di questo argomento sotto), in ogni caso possiamo vedere metodi e attributi di una classe usando la funzione help." 2771 | ] 2772 | }, 2773 | { 2774 | "cell_type": "code", 2775 | "execution_count": null, 2776 | "metadata": {}, 2777 | "outputs": [], 2778 | "source": [ 2779 | "class Triangle:\n", 2780 | " \n", 2781 | " \n", 2782 | " def __init__(self, a, b, c, h):\n", 2783 | " self.a, self.b, self.c, self.h = a, b, c ,h\n", 2784 | "\n", 2785 | " \n", 2786 | " def area(self):\n", 2787 | " return float(self.b)*float(self.h)/2.\n", 2788 | " \n", 2789 | " \n", 2790 | " def perimeter(self):\n", 2791 | " return self.a+self.b+self.c\n", 2792 | " \n", 2793 | " \n", 2794 | " def print_info(self):\n", 2795 | " print(\"Area del triangolo: %2.f\" % self.area())\n", 2796 | " print(\"Perimetro del triangolo: %2.f\" % self.perimeter())\n", 2797 | "\n", 2798 | "\n", 2799 | "triangle = Triangle(5.,3.,5.,4.)\n", 2800 | "help(triangle)" 2801 | ] 2802 | }, 2803 | { 2804 | "cell_type": "markdown", 2805 | "metadata": {}, 2806 | "source": [ 2807 | "Una classe può contenere molti metodi differenti, possiamo utilizzare le **Docstrings** per documentare a cosa serve una classe e cosa fanno ognuno dei suoi metodi" 2808 | ] 2809 | }, 2810 | { 2811 | "cell_type": "code", 2812 | "execution_count": null, 2813 | "metadata": {}, 2814 | "outputs": [], 2815 | "source": [ 2816 | "class Triangle:\n", 2817 | " \n", 2818 | " \n", 2819 | " \"\"\"\n", 2820 | " Questa classe rappresenta un triangolo\n", 2821 | " \"\"\"\n", 2822 | " \n", 2823 | " def __init__(self, a, b, c, h):\n", 2824 | " self.a, self.b, self.c, self.h = a, b, c ,h\n", 2825 | "\n", 2826 | " \n", 2827 | " def area(self):\n", 2828 | " \n", 2829 | " \"\"\"\n", 2830 | " Calcolo dell'area del triangolo\n", 2831 | " \"\"\"\n", 2832 | " \n", 2833 | " return float(self.b)*float(self.h)/2.\n", 2834 | " \n", 2835 | " \n", 2836 | " def perimeter(self):\n", 2837 | " \n", 2838 | " \"\"\"\n", 2839 | " Calcolo del perimetro del triangolo\n", 2840 | " \"\"\"\n", 2841 | " \n", 2842 | " return self.a+self.b+self.c\n", 2843 | " \n", 2844 | " \n", 2845 | " def print_info(self):\n", 2846 | " \n", 2847 | " \"\"\"\n", 2848 | " Stampiamo area e perimetro del triangolo\n", 2849 | " \"\"\"\n", 2850 | " \n", 2851 | " print(\"Area del triangolo: %2.f\" % self.area())\n", 2852 | " print(\"Perimetro del triangolo: %2.f\" % self.perimeter())\n", 2853 | "\n", 2854 | "\n", 2855 | "triangle = Triangle(5.,3.,5.,4.)\n", 2856 | "help(triangle)" 2857 | ] 2858 | }, 2859 | { 2860 | "cell_type": "markdown", 2861 | "metadata": {}, 2862 | "source": [ 2863 | "Questa piccola guida aveva lo scopo di introdurti agli oggetti, ma la programmazione orientata agli oggetti è un'argomento molto più vasto, se vuoi approfondirlo ti consiglio di dare uno sguardo al [Corso di Programmazione in Python di NinjaCloud](https://www.udemy.com/python-corso-pratico-di-programmazione/?couponCode=PROFAI)" 2864 | ] 2865 | }, 2866 | { 2867 | "cell_type": "markdown", 2868 | "metadata": { 2869 | "colab_type": "text", 2870 | "id": "GSzLjGxzME6R" 2871 | }, 2872 | "source": [ 2873 | "\n", 2874 | "## I moduli\n", 2875 | "I moduli ci permettono di organizzare il codice dei nostri programmi in più file, separandone le parti e garantendo una riutilizzabilità ottimale del codice. \n", 2876 | "
\n", 2877 | "Nella pratica, un modulo non è altro che uno script python (.py), con dentro definite delle classi o delle funzioni, possiamo utilizzare tali classi o tali funzioni all'interno di un'altro script python utilizzando *import*\n", 2878 | "

\n", 2879 | "**NOTA BENE** i due script devono trovarsi all'interno della stessa directory" 2880 | ] 2881 | }, 2882 | { 2883 | "cell_type": "code", 2884 | "execution_count": null, 2885 | "metadata": { 2886 | "colab": {}, 2887 | "colab_type": "code", 2888 | "id": "HES1sTjCMFsS" 2889 | }, 2890 | "outputs": [], 2891 | "source": [ 2892 | "import script\n", 2893 | "\n", 2894 | "print(type(script))\n", 2895 | "\n", 2896 | "script.hello_world()" 2897 | ] 2898 | }, 2899 | { 2900 | "cell_type": "markdown", 2901 | "metadata": {}, 2902 | "source": [ 2903 | "Come vedi possiamo eseguire una funzione contenuta in un modulo possiamo usare una sintassi del tipo *nome_modulo.nome_funzione()*\n", 2904 | "
\n", 2905 | "Il discorso è uguale per le classi" 2906 | ] 2907 | }, 2908 | { 2909 | "cell_type": "code", 2910 | "execution_count": null, 2911 | "metadata": { 2912 | "colab": { 2913 | "base_uri": "https://localhost:8080/", 2914 | "height": 428 2915 | }, 2916 | "colab_type": "code", 2917 | "id": "qW9cM76_NnK4", 2918 | "outputId": "ba671275-51cd-42f2-fb4f-f28cdc7172d0" 2919 | }, 2920 | "outputs": [], 2921 | "source": [ 2922 | "import geometry\n", 2923 | "\n", 2924 | "triangle = geometry.Triangle(3., 5., 4., 6.)\n", 2925 | "print(\"L'area del triangolo è %.2f\" % triangle.area())\n", 2926 | "\n", 2927 | "square = geometry.Square(5.)\n", 2928 | "print(\"L'area del quadrato è %.2f\" % square.area())\n", 2929 | "\n", 2930 | "rectangle = geometry.Rectangle(5.,4.)\n", 2931 | "print(\"L'area del rettangolo è %.2f\" % rectangle.area())" 2932 | ] 2933 | }, 2934 | { 2935 | "cell_type": "markdown", 2936 | "metadata": {}, 2937 | "source": [ 2938 | "Possiamo anche decidere di importare solo le funzioni o classi che ci servono utilizziando una sintessi del tipo *from modulo import function* se vogliamo importare più classi o funzioni basta separarle da una virgola." 2939 | ] 2940 | }, 2941 | { 2942 | "cell_type": "code", 2943 | "execution_count": null, 2944 | "metadata": { 2945 | "colab": { 2946 | "base_uri": "https://localhost:8080/", 2947 | "height": 34 2948 | }, 2949 | "colab_type": "code", 2950 | "id": "t3DbWyO3NqsR", 2951 | "outputId": "fc6509e2-abba-42d1-909f-6814d6ea1b7a" 2952 | }, 2953 | "outputs": [], 2954 | "source": [ 2955 | "from geometry import Triangle\n", 2956 | "\n", 2957 | "triangle = Triangle(3., 5., 4., 6.)\n", 2958 | "print(\"L'area del triangolo è %.2f\" % triangle.area())\n", 2959 | "\n", 2960 | "from geometry import Square, Rectangle\n", 2961 | "\n", 2962 | "square = Square(5.)\n", 2963 | "print(\"L'area del quadrato è %.2f\" % square.area())\n", 2964 | "\n", 2965 | "rectangle = Rectangle(5.,4.)\n", 2966 | "print(\"L'area del rettangolo è %.2f\" % rectangle.area())" 2967 | ] 2968 | }, 2969 | { 2970 | "cell_type": "markdown", 2971 | "metadata": {}, 2972 | "source": [ 2973 | "### La Standard Library" 2974 | ] 2975 | }, 2976 | { 2977 | "cell_type": "markdown", 2978 | "metadata": {}, 2979 | "source": [ 2980 | "La [Standard Library](https://docs.python.org/3/library/) di Python mette a disposizione tutta una serie di moduli già realizzati per molti utilizzi differenti.\n", 2981 | "
\n", 2982 | "Ad esempio il [modulo os](https://docs.python.org/3/library/os.html) ci permette di utilizzare molte funzioni del nostro sistema operativo." 2983 | ] 2984 | }, 2985 | { 2986 | "cell_type": "code", 2987 | "execution_count": null, 2988 | "metadata": {}, 2989 | "outputs": [], 2990 | "source": [ 2991 | "import os\n", 2992 | "\n", 2993 | "# otteniamo il path alla directory corrente\n", 2994 | "cwd = os.getcwd()\n", 2995 | "print(cwd)" 2996 | ] 2997 | }, 2998 | { 2999 | "cell_type": "markdown", 3000 | "metadata": {}, 3001 | "source": [ 3002 | "Oppure il [modulo datetime](https://docs.python.org/3/library/datetime.html) ci permette di ottenere data e ora corrente ed effetturare operazioni su date." 3003 | ] 3004 | }, 3005 | { 3006 | "cell_type": "code", 3007 | "execution_count": null, 3008 | "metadata": {}, 3009 | "outputs": [], 3010 | "source": [ 3011 | "import datetime\n", 3012 | "\n", 3013 | "#il metodo now ci permette di ottenere data e ora correnti\n", 3014 | "print(datetime.datetime.now())" 3015 | ] 3016 | }, 3017 | { 3018 | "cell_type": "markdown", 3019 | "metadata": {}, 3020 | "source": [ 3021 | "Un'altro modulo simile è il [modulo time](https://docs.python.org/3/library/time.html), vediamo un esempio di come utilizzarlo per calcolare il tempo di esecuzione di una funzione." 3022 | ] 3023 | }, 3024 | { 3025 | "cell_type": "code", 3026 | "execution_count": null, 3027 | "metadata": { 3028 | "colab": { 3029 | "base_uri": "https://localhost:8080/", 3030 | "height": 51 3031 | }, 3032 | "colab_type": "code", 3033 | "id": "HO_nbMIbQOfX", 3034 | "outputId": "0c268f00-2aa0-4543-c1a3-6d442da1cb0c" 3035 | }, 3036 | "outputs": [], 3037 | "source": [ 3038 | "import time\n", 3039 | "\n", 3040 | "n = 2\n", 3041 | "pow = 10\n", 3042 | "\n", 3043 | "n_pow = n\n", 3044 | "\n", 3045 | "tick = time.time()\n", 3046 | "for _ in range(pow):\n", 3047 | " n_pow*=n\n", 3048 | "\n", 3049 | "duration = time.time()-tick\n", 3050 | " \n", 3051 | "print(\"La %d° potenza di %d è %d\" % (pow, n, n_pow))\n", 3052 | "print(\"Tempo di esecuzione: %.5f secondi\" % duration)\n" 3053 | ] 3054 | }, 3055 | { 3056 | "cell_type": "markdown", 3057 | "metadata": {}, 3058 | "source": [ 3059 | "il metodo time() ci permette di ottenere il timestamp corrente, cioè i secondi trascorsi dall'epoca. L'epoca è il punto in cui il tempo inizia per un computer e dipende dal sistema operativo, ad esempio per Unix/Linux è l'1 Gennaio 1970 per Windows è L'1 Gennaio 1601." 3060 | ] 3061 | }, 3062 | { 3063 | "cell_type": "code", 3064 | "execution_count": null, 3065 | "metadata": { 3066 | "colab": { 3067 | "base_uri": "https://localhost:8080/", 3068 | "height": 233 3069 | }, 3070 | "colab_type": "code", 3071 | "id": "CW_oV77BS614", 3072 | "outputId": "80253dfa-1c59-4ae3-8683-8b965f0a1daa" 3073 | }, 3074 | "outputs": [], 3075 | "source": [ 3076 | "from time import time\n", 3077 | "from math import pow\n", 3078 | "\n", 3079 | "n = 2\n", 3080 | "pow = 10\n", 3081 | "\n", 3082 | "tick = time()\n", 3083 | "\n", 3084 | "pow(2,10)\n", 3085 | "\n", 3086 | "# il tempo di esecuzione è la differenza tra i timestamp\n", 3087 | "\n", 3088 | "duration = time()-tick\n", 3089 | "\n", 3090 | "print(\"La %d° potenza di %d è %d\" % (pow, n, n_pow))\n", 3091 | "print(\"Tempo di esecuzione: %.5f secondi\" % duration)" 3092 | ] 3093 | }, 3094 | { 3095 | "cell_type": "markdown", 3096 | "metadata": {}, 3097 | "source": [ 3098 | "Come vedi abbiamo ottenuto un errore, riesci a vederlo ? Il problema è che la funzione pow del modulo math si chiama come la nostra variabile e Python pensa che stiamo cercando di trattare la nostra varaibile come una funzione, quindi genera un'eccezione di tipo TypeError. La soluzione migliore sarebbe rinominare la variabile, noi piuttosto creiamo un aias della funzione pow." 3099 | ] 3100 | }, 3101 | { 3102 | "cell_type": "code", 3103 | "execution_count": null, 3104 | "metadata": { 3105 | "colab": { 3106 | "base_uri": "https://localhost:8080/", 3107 | "height": 233 3108 | }, 3109 | "colab_type": "code", 3110 | "id": "bihwFPnARkIa", 3111 | "outputId": "3bff23f8-001c-4844-c833-95b670448399" 3112 | }, 3113 | "outputs": [], 3114 | "source": [ 3115 | "from time import time\n", 3116 | "from math import pow as power\n", 3117 | "\n", 3118 | "n = 2\n", 3119 | "pow = 10\n", 3120 | "\n", 3121 | "tick = time()\n", 3122 | "\n", 3123 | "n_pow = power(n, pow)\n", 3124 | "\n", 3125 | "duration = time()-tick\n", 3126 | "\n", 3127 | "print(\"La %d° potenza di %d è %d\" % (pow, n, n_pow))\n", 3128 | "print(\"Tempo di esecuzione: %.5f secondi\" % duration)" 3129 | ] 3130 | }, 3131 | { 3132 | "cell_type": "markdown", 3133 | "metadata": {}, 3134 | "source": [ 3135 | "### Python Package Index (PyPI)\n", 3136 | "Oltre ai moduli della Standard Library, Python ci da la possibilità di installare e utilizzare moduli creati da sviluppatori terzi, contenuti all'interno del Python Package Index (PyPI). Per installare uno di questi moduli possiamo usare pip, il gestore di pacchetti Python per eccellenza, utilizzabile da riga di comando e che viene installato automaticamente insieme a Python (se per qualche oscuro motivo pip non è stato installato insieme a Python, fai riferimento a [questa guida](https://pip.pypa.io/en/stable/installing/) per installarlo manualmente).\n", 3137 | "
\n", 3138 | "Utilizziamo pip per installare *numpy*, una utilissima libreria Python per il calcolo scientifico." 3139 | ] 3140 | }, 3141 | { 3142 | "cell_type": "code", 3143 | "execution_count": null, 3144 | "metadata": { 3145 | "colab": { 3146 | "base_uri": "https://localhost:8080/", 3147 | "height": 54 3148 | }, 3149 | "colab_type": "code", 3150 | "id": "fv0B4CN-SlQ5", 3151 | "outputId": "33f73cec-7510-4049-d344-fb6a69a5fd4e" 3152 | }, 3153 | "outputs": [], 3154 | "source": [ 3155 | "!pip install numpy" 3156 | ] 3157 | }, 3158 | { 3159 | "cell_type": "markdown", 3160 | "metadata": {}, 3161 | "source": [ 3162 | "**NOTA BENE** pip è un software che va utilizzato da terminale, in Jupyter Notebook possiamo eseguire un comando da terminale aggiungendo un (!) prima del comando.\n", 3163 | "
\n", 3164 | "Una volta installato possiamo usare Numpy importandolo come qualsiasi altro modulo." 3165 | ] 3166 | }, 3167 | { 3168 | "cell_type": "code", 3169 | "execution_count": null, 3170 | "metadata": { 3171 | "colab": { 3172 | "base_uri": "https://localhost:8080/", 3173 | "height": 51 3174 | }, 3175 | "colab_type": "code", 3176 | "id": "Ms5FsVmqTOmZ", 3177 | "outputId": "6cbea40d-daff-4a5e-9e83-05938c1f3f67" 3178 | }, 3179 | "outputs": [], 3180 | "source": [ 3181 | "from time import time\n", 3182 | "import numpy as np\n", 3183 | "\n", 3184 | "n = 2\n", 3185 | "power = 10\n", 3186 | "\n", 3187 | "tick = time()\n", 3188 | "\n", 3189 | "np_pow = np.power(n, power)\n", 3190 | "\n", 3191 | "duration = time()-tick\n", 3192 | "\n", 3193 | "print(\"La %d° potenza di %d è %s\" % (power, n, n_pow))\n", 3194 | "print(\"Tempo di esecuzione: %.5f secondi\" % duration)" 3195 | ] 3196 | }, 3197 | { 3198 | "cell_type": "markdown", 3199 | "metadata": {}, 3200 | "source": [ 3201 | "Altri comandi utili di pip sono:\n", 3202 | "* pip uninstall *nome_modulo* (per rimuovere un modulo)\n", 3203 | "* pip install *nome_modulo* --upgrade (per aggiornare un modulo)" 3204 | ] 3205 | } 3206 | ], 3207 | "metadata": { 3208 | "colab": { 3209 | "collapsed_sections": [], 3210 | "name": "python_in_60_minuti.ipynb", 3211 | "provenance": [], 3212 | "version": "0.3.2" 3213 | }, 3214 | "kernelspec": { 3215 | "display_name": "Python 3", 3216 | "language": "python", 3217 | "name": "python3" 3218 | }, 3219 | "language_info": { 3220 | "codemirror_mode": { 3221 | "name": "ipython", 3222 | "version": 3 3223 | }, 3224 | "file_extension": ".py", 3225 | "mimetype": "text/x-python", 3226 | "name": "python", 3227 | "nbconvert_exporter": "python", 3228 | "pygments_lexer": "ipython3", 3229 | "version": "3.6.5" 3230 | } 3231 | }, 3232 | "nbformat": 4, 3233 | "nbformat_minor": 1 3234 | } 3235 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Impara a programmare con Python in 100 minuti 2 | 3 | Python è uno dei linguaggi di programmazione più utilizzati al mondo, grazie alla sua semplicità e versalità viene sfruttato per moltissimi scopi diversi come lo sviluppo di applicazioni desktop, web e networking ma da del suo meglio proprio nel calcolo scientifico e nel machine learning. 4 | 5 | In questo tutorial vedremo le sue principali funzionalità in meno di 100 minuti: 6 | 7 | - Input e output 8 | - Le variabili 9 | - Tipi di dati 10 | - Liste, tuple e set 11 | - Dizionari 12 | - I cicli 13 | - Istruzioni condizionali 14 | - Le funzioni 15 | - Le classi 16 | - I moduli 17 | 18 | [Apri il Notebook su Github](https://github.com/ProfAI/Python-in-100-minuti/blob/master/python_in_100_minuti.ipynb) 19 | 20 | [Esegui il Notebook su Colab](https://colab.research.google.com/github/ProfAI/Python-in-100-minuti/blob/master/python_in_100_minuti.ipynb) 21 | -------------------------------------------------------------------------------- /final_project.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "final_project.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "authorship_tag": "ABX9TyPNnfVUUr9yN7l6jlCXaxpl", 10 | "include_colab_link": true 11 | }, 12 | "kernelspec": { 13 | "name": "python3", 14 | "display_name": "Python 3" 15 | }, 16 | "language_info": { 17 | "name": "python" 18 | } 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": { 34 | "id": "7V9jvjHENf6S" 35 | }, 36 | "source": [ 37 | "# Software di un negozio di prodotti vegani\n", 38 | "Questo progetto consiste nel realizzare un software per la gestione di un negozio di prodotti vegani.\n", 39 | "Il software deve avere le seguenti funzionalità:\n", 40 | "- Registrare nuovi prodotti, con nome, quantità, prezzo di vendita e prezzo di acquisto.\n", 41 | "- Elencare tutti i prodotti presenti.\n", 42 | "- Registrare le vendite effettuate.\n", 43 | "- Mostrare i profitti lordi e netti.\n", 44 | "- Mostrare un menu di aiuto con tutti i comandi disponibili.\n", 45 | "\n", 46 | "Il software è testuale, quindi utilizzabile da riga di comando.\n", 47 | "\n", 48 | "### NOTE\n", 49 | "- Cerca di scrivere del buon codice organizzandolo le varie funzionalità in apposite funzioni.\n", 50 | "- Prima di scrivere il codice, pensa a quali sono le migliori strutture dati da utilizzare: liste, tuple, dizionari, o combinazioni di esse come liste di dizionari.\n", 51 | "- Per questo progetto non è richiesto realizzare un programma persistente, cioè le informazioni inserite dall'utente verranno salvate in memoria solo fino a quando il programma è in esecuzione.\n", 52 | "- Assicurati che gli input inseriti dall'utente siano validi, ad esempio che i numeri siano effettivamente numeri, gestisci i casi non validi con eccezioni e messagi di errore.\n", 53 | "- Durante un acquisto, verifica che i prodotti acquistati siano effettivamente presenti nel magazzino, nel caso negativo mostra all'utente un messaggio di errore.\n", 54 | "- Durante l'aggiunta in magazzino, verifica se il prodotto da aggiungere è già presente magazzino, nel caso positivo aggiungi la quantità a quella già presente in magazzino, in questo caso non serve specificare di nuovo il prezzo di acquisto e di vendita, altrimenti registralo come un nuovo prodotto.\n", 55 | "- Il profitto lordo è il totale delle vendite, cioè tutto ciò che i clienti hanno pagato, il profitto netto invece è pari al profitto lordo meno il costo di acquisto per i prodotti." 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": { 61 | "id": "n8mprdSzYNxZ" 62 | }, 63 | "source": [ 64 | "## ESEMPIO DI INTERAZIONE CON IL PROGRAMMA (in grassetto l'input dell'utente)\n", 65 | "Inserisci un comando: **aiuto**
\n", 66 | "I comandi disponibili sono i seguenti: \n", 67 | " - aggiungi: aggiungi un prodotto al magazzino\n", 68 | " - elenca: elenca i prodotto in magazzino\n", 69 | " - vendita: registra una vendita effettuata\n", 70 | " - profitti: mostra i profitti totali\n", 71 | " - aiuto: mostra i possibili comandi\n", 72 | " - chiudi: esci dal programma\n", 73 | "\n", 74 | "\n", 75 | "Inserisci un comando: **aggiungi**
\n", 76 | "Nome del prodotto: **latte di soia**
\n", 77 | "Quantità: **20**
\n", 78 | "Prezzo di acquisto: **0.80**
\n", 79 | "Prezzo di vendita: **1.40**
\n", 80 | "AGGIUNTO: 20 X latte di soia
\n", 81 | "
\n", 82 | "Inserisci un comando: **aggiungi**
\n", 83 | "Nome del prodotto: **tofu* *
\n", 84 | "Quantità: **10**
\n", 85 | "Prezzo di acquisto: **2.20**
\n", 86 | "Prezzo di vendita: **4.19**
\n", 87 | "AGGIUNTO: 10 X tofu
\n", 88 | "
\n", 89 | "Inserisci un comando: **aggiungi**
\n", 90 | "Nome del prodotto: **seitan**
\n", 91 | "Quantità: **5**
\n", 92 | "Prezzo di acquisto: **3**
\n", 93 | "Prezzo di vendita: **5.49**
\n", 94 | "AGGIUNTO: 5 X seitan
\n", 95 | "
\n", 96 | "Inserisci un comando: **elenca**
\n", 97 | "PRODOTTO\tQUANTITA'\tPREZZO
\n", 98 | "latte di soia\t20\t€1.4
\n", 99 | "tofu\t10\t€4.19
\n", 100 | "seitan\t5\t€5.49
\n", 101 | "
\n", 102 | "Inserisci un comando: **vendita**
\n", 103 | "Nome del prodotto: **latte di soia**
\n", 104 | "Quantità: 5
\n", 105 | "Aggiungere un altro prodotto ? (si/no): **si**
\n", 106 | "Nome del prodotto: **tofu**
\n", 107 | "Quantità: **2**
\n", 108 | "Aggiungere un altro prodotto ? (si/no): **no**
\n", 109 | "VENDITA REGISTRATA
\n", 110 | " - 5 X latte di soia: €1.40
\n", 111 | " - 2 X tofu: €4.19
\n", 112 | "\n", 113 | "Totale: €15.38
\n", 114 | "
\n", 115 | "Inserisci un comando: **elenca**
\n", 116 | "PRODOTTO\tQUANTITA'\tPREZZO
\n", 117 | "latte di soia\t15\t€1.4
\n", 118 | "tofu\t8\t€4.19
\n", 119 | "seitan\t5\t€5.49
\n", 120 | "
\n", 121 | "Inserisci un comando: **vendita**
\n", 122 | "Nome del prodotto: **seitan**
\n", 123 | "Quantità: **5**
\n", 124 | "Aggiungere un altro prodotto ? (si/no): **no**
\n", 125 | "VENDITA REGISTRATA
\n", 126 | " - 5 X seitan: €5.49
\n", 127 | "\n", 128 | "Totale: €27.45
\n", 129 | "
\n", 130 | "Inserisci un comando: **elenca**
\n", 131 | "PRODOTTO\tQUANTITA'\tPREZZO
\n", 132 | "latte di soia\t15\t€1.4
\n", 133 | "tofu\t8\t€4.19
\n", 134 | "
\n", 135 | "Inserisci un comando: **profitti**
\n", 136 | "Profitto: lordo=€42.83 netto=€19.43
\n", 137 | "
\n", 138 | "Inserisci un comando: **storna**
\n", 139 | "Comando non valido
\n", 140 | "I comandi disponibili sono i seguenti:
\n", 141 | "- aggiungi: aggiungi un prodotto al magazzino
\n", 142 | "- elenca: elenca i prodotto in magazzino
\n", 143 | "- vendita: registra una vendita effettuata
\n", 144 | "- profitti: mostra i profitti totali
\n", 145 | "- aiuto: mostra i possibili comandi
\n", 146 | "- chiudi: esci dal programma
\n", 147 | "\n", 148 | "Inserisci un comando: **chiudi**
\n", 149 | "Bye bye" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": { 155 | "id": "Hoj3eZFQdueX" 156 | }, 157 | "source": [ 158 | "### La tua soluzione\n", 159 | "Di seguito il loop principale del programma, completalo implementando le varie funzionalità (è normale ottenere un'errore cercando di eseguire il codice base, dato che questo è incompleto)." 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "metadata": { 165 | "colab": { 166 | "base_uri": "https://localhost:8080/", 167 | "height": 130 168 | }, 169 | "id": "XlaL4t9kcbTM", 170 | "outputId": "355ae5c9-992a-4101-f943-5fba23c6053b" 171 | }, 172 | "source": [ 173 | "cmd = None\n", 174 | "\n", 175 | "while cmd!=\"esci\":\n", 176 | "\n", 177 | " cmd = input(\"Inserisci un comando: \")\n", 178 | "\n", 179 | " if cmd==\"vendita\":\n", 180 | " # registra una vendita\n", 181 | " # ...\n", 182 | " elif cmd==\"profitti\":\n", 183 | " # mostra profitti netti e lordi\n", 184 | " # ...\n", 185 | " elif cmd==\"aggiungi\":\n", 186 | " # aggiungi un prodotto al magazzino\n", 187 | " # ...\n", 188 | " elif cmd==\"elenca\":\n", 189 | " # elenca tutti i prodotti nel magazzino\n", 190 | " # ...\n", 191 | " elif cmd==\"aiuto\":\n", 192 | " # mostra i possibili comandi\n", 193 | " # ...\n", 194 | " elif cmd==\"chiudi\":\n", 195 | " # saluta e interrompi il programma\n", 196 | " # ...\n", 197 | " else:\n", 198 | " # comando non valido\n", 199 | " # mostra messaggio di aiuto\n", 200 | " # ..." 201 | ], 202 | "execution_count": null, 203 | "outputs": [ 204 | { 205 | "output_type": "error", 206 | "ename": "IndentationError", 207 | "evalue": "ignored", 208 | "traceback": [ 209 | "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m10\u001b[0m\n\u001b[0;31m elif cmd==\"profitti\":\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n" 210 | ] 211 | } 212 | ] 213 | } 214 | ] 215 | } -------------------------------------------------------------------------------- /geometry.py: -------------------------------------------------------------------------------- 1 | class Triangle: 2 | 3 | """A simple class to calculate measurements of a triangle""" 4 | 5 | def __init__(self, a, b, c, h): 6 | 7 | self.a, self.b, self.c, self.h = a, b, c ,h 8 | 9 | 10 | def area(self): 11 | 12 | """Calculate the triangle's area""" 13 | 14 | return float(self.b)*float(self.h)/2. 15 | 16 | 17 | def perimeter(self): 18 | 19 | """Calculate the triangle's perimeter""" 20 | 21 | return self.a+self.b+self.c 22 | 23 | 24 | 25 | class Square: 26 | 27 | """A simple class to calculate measurements of a square""" 28 | 29 | def __init__(self, l): 30 | self.l = l 31 | 32 | 33 | def area(self): 34 | 35 | """Calculate the square's area""" 36 | 37 | return self.l**2 38 | 39 | 40 | def perimeter(self): 41 | 42 | """Calculate the square's perimeter""" 43 | 44 | return self.l*4. 45 | 46 | 47 | 48 | class Rectangle: 49 | 50 | """A simple class to calculate measurements of a rectangle""" 51 | 52 | def __init__(self, b, h): 53 | self.b, self.h = b, h 54 | 55 | 56 | def area(self): 57 | 58 | """Calculate the rectangle's area""" 59 | 60 | return self.b*self.h 61 | 62 | 63 | def perimeter(self): 64 | 65 | """Calculate the rectangle's perimeter""" 66 | 67 | return 2.*(self.b+self.h) -------------------------------------------------------------------------------- /res/_: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /script.py: -------------------------------------------------------------------------------- 1 | def hello_world(): 2 | print("Hello world!") --------------------------------------------------------------------------------