Skip to content

GitLab

Commit 82976a53 authored by Andrei - Tudor Corduneanu's avatar Andrei - Tudor Corduneanu
Browse files

last_version with docker

parent 38cf9487
Hide whitespace changes
Inline Side-by-side
.ipynb_checkpoints/Prima_giornata-checkpoint.ipynb 0 → 100644
View file @ 82976a53
{
"cells": [
{
"cell_type": "markdown",
"id": "00e3afed",
"metadata": {},
"source": [
"\n",
" # Python\n",
"\n",
"- Invecchia molto bene\n",
"- community --> librerie\n",
"- documentazione ([python.org](https://docs.python.org/3))\n",
"- interpretato --> fast development"
]
},
{
"cell_type": "markdown",
"id": "a84df39b",
"metadata": {},
"source": [
"## Questa prima giornata\n",
"Le basi del linguaggio:\n",
"- Variabili\n",
"- Flow control\n",
"- Funzioni\n",
"- Data Structures"
]
},
{
"cell_type": "markdown",
"id": "7f08ef93",
"metadata": {},
"source": [
"### Cosa serve per usare Python\n",
"Consiglierei di partire dal [sito di python](https://www.python.org/)..\n",
"Nella sezione _download_ si trovano le istruzioni per installare il loro software per i vari sistemi operativi.\n",
"\n",
"Un buon editor di testo è consigliato se si stanno scrivendo script/programmi.. so che [pycharm](https://www.jetbrains.com/pycharm/) è molto usato e performante sui sistemi operativi mainstream.\n",
"Confido che chi di base usa GNU/Linux abbia già il suo editor preferito.\n",
"\n",
"In questo caso l'uso di Jupyter-Notebok faciliterà i primi passi (tutto il codice sotto riportato potrà essere eseguito), ma l'[interprete di python](https://docs.python.org/3/tutorial/interpreter.html) è di norma la scelta migliore per testare/imparare il linguaggio."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "19853476",
"metadata": {},
"outputs": [],
"source": [
"variabile = 12 ## Integer\n",
"print(variabile)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fb51da4f",
"metadata": {},
"outputs": [],
"source": [
"variabile = \"dodici\" ## stringa\n",
"variabile2 = 'tredici' ## sempre una stringa\n",
"print(variabile)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a4c5765f",
"metadata": {},
"outputs": [],
"source": [
"x = 4\n",
"y = 2\n",
"print(x > y) ## >, <, >=, !=, ...\n",
"print(x / y) ## *, /, +, -, %"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dd2b96bc",
"metadata": {},
"outputs": [],
"source": [
"alfa = 12\n",
"beta = 3\n",
"theta = alfa + beta ## una variabile per contenere la somma\n",
"print(theta)"
]
},
{
"cell_type": "markdown",
"id": "a4e7b63f",
"metadata": {},
"source": [
"\n",
"## Molto facile, molto versatile.\n",
"\n",
" si adatta al programmatore:\n",
"\n",
"- [Architetture complesse](https://www.djangoproject.com/download/)\n",
"- [App da linea di comando](https://en.wikipedia.org/wiki/Command-line_interface)\n",
"- [Scripting](https://cat.eduroam.org/)\n",
"- [Scraping](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)\n",
"- [Bot](https://www.selenium.dev/documentation/en/)\n",
"- [...](https://pypi.org/search/)\n"
]
},
{
"cell_type": "markdown",
"id": "d41a9c9f",
"metadata": {},
"source": [
"\n",
"## Come Scrivere Hello World in _C_\n",
"\n",
"```c\n",
"#include <stdio.h>\n",
"\n",
"int main() {\n",
" printf(\"Hello, world!\\n\");\n",
" return 0;\n",
"}\n",
"```\n"
]
},
{
"cell_type": "markdown",
"id": "23eb6909",
"metadata": {},
"source": [
"## In python ci sono più modalità per fare la stessa cosa"
]
},
{
"cell_type": "markdown",
"id": "b9721e29",
"metadata": {},
"source": [
"### quella complessa"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7f7628ed",
"metadata": {},
"outputs": [],
"source": [
"def greet(what):\n",
" def decorator(foo):\n",
" def hello():\n",
" print(what, end=\", \")\n",
" foo()\n",
" return hello\n",
" return decorator\n",
"\n",
"@greet(\"hello\")\n",
"def hello_world():\n",
" print(\"world\")\n",
" \n",
"## Ciò che sta sopra definisce ####\n",
"## Ciò che sta sotto \"chiama\" ####\n",
"\n",
"hello_world()\n"
]
},
{
"cell_type": "markdown",
"id": "42e8c06b",
"metadata": {},
"source": [
"### quella modulare"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f60870ed",
"metadata": {},
"outputs": [],
"source": [
"class Class_hello:\n",
" def __init__(self, who):\n",
" self.who = who\n",
"\n",
" def hello(self):\n",
" print(\"hello, \" + self.who)\n",
" \n",
"classe = Class_hello(\"world\")\n",
"classe.hello()"
]
},
{
"cell_type": "markdown",
"id": "49c2a540",
"metadata": {},
"source": [
"### quella diretta"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a39340e6",
"metadata": {},
"outputs": [],
"source": [
"print(\"Hello, world!\")"
]
},
{
"cell_type": "markdown",
"id": "591abe2c",
"metadata": {},
"source": [
"### L'approccio varia in base a ciò che vuoi fare...\n",
"\n",
"vuoi che funzioni?\n",
"\n",
"vuoi che funzioni bene?\n",
"\n",
"vuoi metterlo nel tuo curriculum?\n"
]
},
{
"cell_type": "markdown",
"id": "02bee160",
"metadata": {},
"source": [
"# Il linguaggio"
]
},
{
"cell_type": "markdown",
"id": "8feb317e",
"metadata": {},
"source": [
"## Variabili\n",
"Le variabili in *python* non sono come le variabili di un linguaggio di basso livello (come il C ad esempio).\n",
"\n",
"Una volta dichiarato il tipo di variabile in *C*, questo non può cambiare:\n",
"```c\n",
"int x;\n",
"x = strdup(\"stringa\"); // Produrrà un errore brutto da vedere\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "215d0c74",
"metadata": {},
"outputs": [],
"source": [
"x = 12\n",
"x = \"una stringa\"\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"id": "9757674f",
"metadata": {},
"source": [
"### \"Storing Values in Variables\"\n",
"\n",
"> A variable is like a box in the computer’s memory where you can store a single value.\n",
">\n",
"> If you want to use the result of an evaluated expression later in your program, you can save it inside a variable.\n",
">\n",
"> [@AlSweigart python books](https://automatetheboringstuff.com/2e/chapter1/)\n"
]
},
{
"cell_type": "markdown",
"id": "48686371",
"metadata": {},
"source": [
"### Un programma con queste sole skill"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b7559721",
"metadata": {},
"outputs": [],
"source": [
"print(\"Ciao utente..\")\n",
"cestino = 12\n",
"print(\"[*] il cestino contiene \" + str(cestino) + \" mele.\")\n",
"mele_aggiunte = 6\n",
"cestino += mele_aggiunte\n",
"print(\"[*] al cestino sono state aggiunte \" + str(mele_aggiunte) + \" mele, oer un totale di \" + str(cestino) + \" mele.\")\n",
"cestino %= 2\n",
"print(\"[*] ...\")"
]
},
{
"cell_type": "markdown",
"id": "c57c59ee",
"metadata": {},
"source": [
"# controllo del flusso del programma\n",
"Un blocco di codice viene eseguito a determinate condizioni, che occorrono in base alla valutazione logica di un'espressione.\n",
"\n",
"Verranno quindi trattate le tematiche:\n",
"- Blocchi di codice\n",
"- Espressioni logiche\n",
"- Esecuzione condizionale\n",
"- Esecuzione per iterazione"
]
},
{
"cell_type": "markdown",
"id": "b6c5c7b1",
"metadata": {},
"source": [
"## Un blocco di codice\n",
"mentre in C i blocchi di codice vengono racchiusi tra *{* *}*:\n",
"```c\n",
"int main(void)\n",
"{\n",
" int x;\n",
" char xx;\n",
" printf(\"Program initializing...\")\n",
" //// ....Some other code\n",
" return 0;\n",
"}\n",
"```\n",
"\n",
"in python i blocchi di codice vengono definiti dalla loro indentazione:\n",
"```python\n",
"\n",
"def main():\n",
" x = 11\n",
" y = 2\n",
" something = \"something\"\n",
" print(\"Program initialized...\")\n",
" # Some other code....\n",
" return something\n",
"\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "b6974e2e",
"metadata": {},
"source": [
"### Espressioni logiche\n",
"Confrontare il valore di due espressioni"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "710a290a",
"metadata": {},
"outputs": [],
"source": [
"x = True\n",
"y = False\n",
"z = 1\n",
"zz = 2\n",
"\n",
"print( x != y )\n",
"print( x == y )\n",
"print(\"======\")\n",
"print( z > zz )\n",
"print( zz <= z )\n",
"print(\"======\")\n",
"print(\"zz % 2 = \" + str(zz % 2) )\n",
"print( zz % 2 == 0 )"
]
},
{
"cell_type": "markdown",
"id": "5a2ee7d0",
"metadata": {},
"source": [
"## Esecuzione CONDIZIONALE\n",
"- *if* --- controlla l'espressione, esegue il blocco di codice se risulta *vera*\n",
"- *else* --- esegue il blocco di codice se risulta *non vera*\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a5502bc7",
"metadata": {},
"outputs": [],
"source": [
"cestino = 18\n",
"\n",
"if cestino % 2 == 0:\n",
" print(\"[*] Il cestino contiene un numero pari di mele\")\n",
"else:\n",
" print(\"[*] Il cestino contiene un numero dispari di mele\")"
]
},
{
"cell_type": "markdown",
"id": "6ce2ac60",
"metadata": {},
"source": [
"...una casistica più ampia:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "82f16964",
"metadata": {},
"outputs": [],
"source": [
"cestino = 0\n",
"\n",
"if cestino == 0:\n",
" print(\"[*] Il cestino è vuoto\")\n",
"elif cestino % 2 == 0:\n",
" print(\"[*] Il cestino contiene un numero pari di mele\")\n",
"else:\n",
" print(\"[*] Il cestino contiene un numero dispari di mele\")"
]
},
{
"cell_type": "markdown",
"id": "9efbb974",
"metadata": {},
"source": [
"## Esecuzione per ITERAZIONE\n",
"- while -- esegue il blocco in 'loop' finchè l'espressione valutata è *vera*\n",
"- for -- esegue il blocco in 'loop' per ogni elemento in una sequenza"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2b0f2b31",
"metadata": {},
"outputs": [],
"source": [
"cestino = 4\n",
"while cestino >= 0:\n",
" cestino -= 1\n",
" print(\"Lo user ha lanciato una mela\")\n",
"print(\"\\nNon ci sono più mele nel cestino :(\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b735e4f5",
"metadata": {},
"outputs": [],
"source": [
"i = 1\n",
"while i <= 10:\n",
" print(\"9 x \" + str(i) + \" = \" + str(i*9))\n",
" i += 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4bb34b90",
"metadata": {},
"outputs": [],
"source": [
"for indice in \"mela\":\n",
" print(indice)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "07c05863",
"metadata": {},
"outputs": [],
"source": [
"cestino = 0\n",
"for i in range(5):\n",
" cestino += 1\n",
" print(\"lo user ha aggiunto una mela, ce ne sono \" + str(cestino))"
]
},
{
"cell_type": "markdown",
"id": "2ef8aa5d",
"metadata": {},
"source": [
"## break & continue"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9fab3f84",
"metadata": {},
"outputs": [],
"source": [
"for i in range(100):\n",
" print(i)\n",
" break"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f1331407",
"metadata": {},
"outputs": [],
"source": [
"i = 0\n",
"while i < 10:\n",
" print(\"[*!*]\")\n",
" i += 5\n",
" continue\n",
" print(\"cinque\")\n",
" y += 1\n",
"\n",
"#print(y)"
]
},
{
"cell_type": "markdown",
"id": "e6120a5b",
"metadata": {},
"source": [
"# Funzioni\n",
"\"Scatole nere\", possono prendere dei parametri in entrata, possono ritornare dei valori in uscita.\n",
"\n",
"Permettono la riusabilità del codice, permettono di fare cose complesse in poco tempo, col codice scritto da altri."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8ce5dc96",
"metadata": {},
"outputs": [],
"source": [
"def say_hello():\n",
" print(\"Hello, world!\")\n",
"\n",
"say_hello()\n",
"say_hello()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b7602820",
"metadata": {},
"outputs": [],
"source": [
"def say_hello(name):\n",
" print(\"Hello, \" + name + \"!\")\n",
" \n",
"say_hello(\"user\")\n",
"say_hello(\"Mario\")\n",
"say_hello(\"Abbecedario\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3d5775fd",
"metadata": {},
"outputs": [],
"source": [
"def hello_e_basta():\n",
" return \"Hello\"\n",
"\n",
"saluto = hello_e_basta()\n",
"print(saluto)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef6890cd",
"metadata": {},
"outputs": [],
"source": [
"def hello(name=\"user\"):\n",
" print(\"Hello, \" + name)\n",
" \n",
"hello()\n",
"hello(\"user\")\n",
"hello(\"Mario\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f171d145",
"metadata": {},
"outputs": [],
"source": [
"def hello_fun():\n",
" print(\"Hello, world!\")\n",
"hello_var = hello_fun\n",
"hello_var()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bcd3c9c1",
"metadata": {},
"outputs": [],
"source": [
"def tabelline(x = 7):\n",
" i = 1\n",
" while i <= 10:\n",
" print(str(x) + \" x \" + str(i) + \" = \" + str(x*i))\n",
" i += 1\n",
" \n",
"#tabelline()\n",
"### Trasformato l'esempio precedente in una funzione"
]
},
{
"cell_type": "markdown",
"id": "9e1c3bae",
"metadata": {},
"source": [
"## Scope, o visibilità del codice\n",
"Le variabili/funzioni hanno un loro contesto, per ragioni di praticità.\n",
"- collisioni tra nomi\n",
"- comportamenti inaspettati"