last_version with docker

.ipynb_checkpoints/Prima_giornata-checkpoint.ipynb

+%% Cell type:markdown id:00e3afed tags:
+
+
+ # Python
+
+- Invecchia molto bene
+- community --> librerie
+- documentazione ([python.org](https://docs.python.org/3))
+- interpretato --> fast development
+
+%% Cell type:markdown id:a84df39b tags:
+
+## Questa prima giornata
+Le basi del linguaggio:
+- Variabili
+- Flow control
+- Funzioni
+- Data Structures
+
+%% Cell type:markdown id:7f08ef93 tags:
+
+### Cosa serve per usare Python
+Consiglierei di partire dal [sito di python](https://www.python.org/)..
+Nella sezione _download_ si trovano le istruzioni per installare il loro software per i vari sistemi operativi.
+
+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.
+Confido che chi di base usa GNU/Linux abbia già il suo editor preferito.
+
+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 id:19853476 tags:
+
+``` python
+variabile = 12       ## Integer
+print(variabile)
+```
+
+%% Cell type:code id:fb51da4f tags:
+
+``` python
+variabile = "dodici" ## stringa
+variabile2 = 'tredici' ## sempre una stringa
+print(variabile)
+```
+
+%% Cell type:code id:a4c5765f tags:
+
+``` python
+x = 4
+y = 2
+print(x > y)  ##  >, <, >=, !=, ...
+print(x / y)  ##  *, /, +, -, %
+```
+
+%% Cell type:code id:dd2b96bc tags:
+
+``` python
+alfa = 12
+beta = 3
+theta = alfa + beta  ## una variabile per contenere la somma
+print(theta)
+```
+
+%% Cell type:markdown id:a4e7b63f tags:
+
+
+## Molto facile, molto versatile.
+
+ si adatta al programmatore:
+
+- [Architetture complesse](https://www.djangoproject.com/download/)
+- [App da linea di comando](https://en.wikipedia.org/wiki/Command-line_interface)
+- [Scripting](https://cat.eduroam.org/)
+- [Scraping](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)
+- [Bot](https://www.selenium.dev/documentation/en/)
+- [...](https://pypi.org/search/)
+
+
+%% Cell type:markdown id:d41a9c9f tags:
+
+
+## Come Scrivere Hello World in _C_
+
+```c
+#include <stdio.h>
+
+int main() {
+    printf("Hello, world!\n");
+    return 0;
+}
+```
+
+
+%% Cell type:markdown id:23eb6909 tags:
+
+## In python ci sono più modalità per fare la stessa cosa
+
+%% Cell type:markdown id:b9721e29 tags:
+
+### quella complessa
+
+%% Cell type:code id:7f7628ed tags:
+
+``` python
+def greet(what):
+    def decorator(foo):
+        def hello():
+            print(what, end=", ")
+            foo()
+        return hello
+    return decorator
+
+@greet("hello")
+def hello_world():
+    print("world")
+    
+## Ciò che sta sopra definisce    ####
+## Ciò che sta sotto "chiama"     ####
+
+hello_world()
+
+```
+
+%% Cell type:markdown id:42e8c06b tags:
+
+### quella modulare
+
+%% Cell type:code id:f60870ed tags:
+
+``` python
+class Class_hello:
+    def __init__(self, who):
+        self.who = who
+
+    def hello(self):
+        print("hello, " + self.who)
+        
+classe = Class_hello("world")
+classe.hello()
+```
+
+%% Cell type:markdown id:49c2a540 tags:
+
+### quella diretta
+
+%% Cell type:code id:a39340e6 tags:
+
+``` python
+print("Hello, world!")
+```
+
+%% Cell type:markdown id:591abe2c tags:
+
+### L'approccio varia in base a ciò che vuoi fare...
+
+vuoi che funzioni?
+
+vuoi che funzioni bene?
+
+vuoi metterlo nel tuo curriculum?
+
+
+%% Cell type:markdown id:02bee160 tags:
+
+# Il linguaggio
+
+%% Cell type:markdown id:8feb317e tags:
+
+## Variabili
+Le variabili in *python* non sono come le variabili di un linguaggio di basso livello (come il C ad esempio).
+
+Una volta dichiarato il tipo di variabile in *C*, questo non può cambiare:
+```c
+int x;
+x = strdup("stringa"); // Produrrà un errore brutto da vedere
+```
+
+%% Cell type:code id:215d0c74 tags:
+
+``` python
+x = 12
+x = "una stringa"
+print(x)
+```
+
+%% Cell type:markdown id:9757674f tags:
+
+### "Storing Values in Variables"
+
+> A variable is like a box in the computer’s memory where you can store a single value.
+>
+> If you want to use the result of an evaluated expression later in your program, you can save it inside a variable.
+>
+> [@AlSweigart python books](https://automatetheboringstuff.com/2e/chapter1/)
+
+
+%% Cell type:markdown id:48686371 tags:
+
+### Un programma con queste sole skill
+
+%% Cell type:code id:b7559721 tags:
+
+``` python
+print("Ciao utente..")
+cestino = 12
+print("[*] il cestino contiene " + str(cestino) + " mele.")
+mele_aggiunte = 6
+cestino += mele_aggiunte
+print("[*] al cestino sono state aggiunte " + str(mele_aggiunte) + " mele, oer un totale di " + str(cestino) + " mele.")
+cestino %= 2
+print("[*] ...")
+```
+
+%% Cell type:markdown id:c57c59ee tags:
+
+# controllo del flusso del programma
+Un blocco di codice viene eseguito a determinate condizioni, che occorrono in base alla valutazione logica di un'espressione.
+
+Verranno quindi trattate le tematiche:
+- Blocchi di codice
+- Espressioni logiche
+- Esecuzione condizionale
+- Esecuzione per iterazione
+
+%% Cell type:markdown id:b6c5c7b1 tags:
+
+## Un blocco di codice
+mentre in C i blocchi di codice vengono racchiusi tra *{* *}*:
+```c
+int main(void)
+{
+ int x;
+ char xx;
+ printf("Program initializing...")
+ //// ....Some other code
+ return 0;
+}
+```
+
+in python i blocchi di codice vengono definiti dalla loro indentazione:
+```python
+
+def main():
+    x = 11
+    y = 2
+    something = "something"
+    print("Program initialized...")
+    # Some other code....
+    return something
+
+```
+
+%% Cell type:markdown id:b6974e2e tags:
+
+### Espressioni logiche
+Confrontare il valore di due espressioni
+
+%% Cell type:code id:710a290a tags:
+
+``` python
+x = True
+y = False
+z = 1
+zz = 2
+
+print( x != y )
+print( x == y )
+print("======")
+print( z > zz )
+print( zz <= z )
+print("======")
+print("zz % 2 = " + str(zz % 2) )
+print( zz % 2 == 0 )
+```
+
+%% Cell type:markdown id:5a2ee7d0 tags:
+
+## Esecuzione CONDIZIONALE
+- *if* --- controlla l'espressione, esegue il blocco di codice se risulta *vera*
+- *else* --- esegue il blocco di codice se risulta *non vera*
+
+
+%% Cell type:code id:a5502bc7 tags:
+
+``` python
+cestino = 18
+
+if cestino % 2 == 0:
+    print("[*] Il cestino contiene un numero pari di mele")
+else:
+    print("[*] Il cestino contiene un numero dispari di mele")
+```
+
+%% Cell type:markdown id:6ce2ac60 tags:
+
+...una casistica più ampia:
+
+%% Cell type:code id:82f16964 tags:
+
+``` python
+cestino = 0
+
+if cestino == 0:
+    print("[*] Il cestino è vuoto")
+elif cestino % 2 == 0:
+    print("[*] Il cestino contiene un numero pari di mele")
+else:
+    print("[*] Il cestino contiene un numero dispari di mele")
+```
+
+%% Cell type:markdown id:9efbb974 tags:
+
+## Esecuzione per ITERAZIONE
+- while -- esegue il blocco in 'loop' finchè l'espressione valutata è *vera*
+- for   -- esegue il blocco in 'loop' per ogni elemento in una sequenza
+
+%% Cell type:code id:2b0f2b31 tags:
+
+``` python
+cestino = 4
+while cestino >= 0:
+    cestino -= 1
+    print("Lo user ha lanciato una mela")
+print("\nNon ci sono più mele nel cestino :(")
+```
+
+%% Cell type:code id:b735e4f5 tags:
+
+``` python
+i = 1
+while i <= 10:
+    print("9 x " + str(i) + " = " + str(i*9))
+    i += 1
+```
+
+%% Cell type:code id:4bb34b90 tags:
+
+``` python
+for indice in "mela":
+    print(indice)
+```
+
+%% Cell type:code id:07c05863 tags:
+
+``` python
+cestino = 0
+for i in range(5):
+    cestino += 1
+    print("lo user ha aggiunto una mela, ce ne sono " + str(cestino))
+```
+
+%% Cell type:markdown id:2ef8aa5d tags:
+
+## break & continue
+
+%% Cell type:code id:9fab3f84 tags:
+
+``` python
+for i in range(100):
+    print(i)
+    break
+```
+
+%% Cell type:code id:f1331407 tags:
+
+``` python
+i = 0
+while i < 10:
+    print("[*!*]")
+    i += 5
+    continue
+    print("cinque")
+    y += 1
+
+#print(y)
+```
+
+%% Cell type:markdown id:e6120a5b tags:
+
+# Funzioni
+"Scatole nere", possono prendere dei parametri in entrata, possono ritornare dei valori in uscita.
+
+Permettono la riusabilità del codice, permettono di fare cose complesse in poco tempo, col codice scritto da altri.
+
+%% Cell type:code id:8ce5dc96 tags:
+
+``` python
+def say_hello():
+    print("Hello, world!")
+
+say_hello()
+say_hello()
+```
+
+%% Cell type:code id:b7602820 tags:
+
+``` python
+def say_hello(name):
+    print("Hello, " + name + "!")
+    
+say_hello("user")
+say_hello("Mario")
+say_hello("Abbecedario")
+```
+
+%% Cell type:code id:3d5775fd tags:
+
+``` python
+def hello_e_basta():
+    return "Hello"
+
+saluto = hello_e_basta()
+print(saluto)
+```
+
+%% Cell type:code id:ef6890cd tags:
+
+``` python
+def hello(name="user"):
+    print("Hello, " + name)
+    
+hello()
+hello("user")
+hello("Mario")
+```
+
+%% Cell type:code id:f171d145 tags:
+
+``` python
+def hello_fun():
+    print("Hello, world!")
+hello_var = hello_fun
+hello_var()
+```
+
+%% Cell type:code id:bcd3c9c1 tags:
+
+``` python
+def tabelline(x = 7):
+    i = 1
+    while i <= 10:
+        print(str(x) + " x " + str(i) + " = " + str(x*i))
+        i += 1
+        
+#tabelline()
+### Trasformato l'esempio precedente in una funzione
+```
+
+%% Cell type:markdown id:9e1c3bae tags:
+
+## Scope, o visibilità del codice
+Le variabili/funzioni hanno un loro contesto, per ragioni di praticità.
+- collisioni tra nomi
+- comportamenti inaspettati
+
+%% Cell type:code id:ca699f1d tags:
+
+``` python
+x = "abercrombie"
+
+def fun1():
+    x = "alfabeto"
+    print("valore di x interno a fun1 --> " + str(x))
+    
+def fun2():
+    x = "abbecedario"
+    print("valore di x interno a fun2 --> " + str(x))
+
+def fun3():
+    print("valore di x interno a fun3 --> " + str(x))
+    
+print("valore globale di x --> " + str(x))
+fun1()
+fun2()
+fun3()
+```
+
+%% Cell type:markdown id:f15f0b15 tags:
+
+# Data Structures
+Dati organizzati in una struttura che ne faciliti la lavorazione.
+
+%% Cell type:markdown id:78606f2d tags:
+
+## Sequenze:
+
+### List -- __sequenze mutabili__
+- collezioni **ordinate**, **disomogenee**
+- si definiscono usando *\[*  *\]*
+
+## Tuple -- __sequenze immutabili__
+- collezioni **ordinate**, **disomogenee**
+- si definiscono usando *(* *)*
+
+%% Cell type:code id:49ded31e tags:
+
+``` python
+## definizione di una funzione
+def dimostrazione(sequenza):
+    for i in sequenza:
+        print(i)
+        
+    print("- partendo da destra: ", end="")
+    print(sequenza[-1])
+    
+    sequenza[0] = "valore modificato"
+    print("- modifica: " + sequenza[0])
+    
+## strutture
+lst = ["cane","gatto","undici",13]
+tpl = ("cane","gatto","undici",13)
+
+## esecuzione della funzione con le strutture come parametri
+dimostrazione(lst)
+#dimostrazione(tpl)
+```
+
+%% Cell type:code id:c69bbd3c tags:
+
+``` python
+lst = ["alpaca","lama","capra"]
+for i in lst:
+    print(i)
+print("\n=================\n")
+
+### slicing...
+for i in lst[1:]:
+    print(i)
+```
+
+%% Cell type:markdown id:97901482 tags:
+
+## Mappings
+
+### Dictionaries -- key/value pairs
+
+- collezioni **mutabili**, **disomogenee**
+- si definisce usando *{* *}*
+
+
+
+%% Cell type:code id:87d6bf3f tags:
+
+``` python
+dct =  {1: "cane", 2: "gatto", 3: "alpaca"}
+dct2 = {"alfabeto": "alpaca", "cane": 1}
+dct3 = {(1,2): "uno", (1,3): "2"}
+#dct4 = {[1,2]: "uno", [2,3]: 2}
+```
+
+%% Cell type:code id:ea9347d9 tags:
+
+``` python
+## Global(/extern??) functions/methods/../whatever
+def return_person_list():
+    lst = []
+    lst.append("Mario")
+    lst.append("Rossi")
+    lst.append(27)
+    return lst
+
+def return_person_dict():
+    d = {}
+    d["firstname"] = "Mario"
+    d["lastname"]  = "Rossi"
+    d["age"] =  27
+    return d
+
+
+### !_Our_! functions to build a "person"
+
+def init():
+    dict_populate()
+    
+def list_populate():
+    lst = return_person_list()
+    firstname = lst[0]
+    lastname = lst[1]
+    age = lst[2]
+    print_person(firstname, lastname, age)
+
+def dict_populate():
+    d = return_person_dict()
+    firstname = d["firstname"]
+    lastname = d["lastname"]
+    age = d["age"]
+    print_person(firstname, lastname, age)
+
+def print_person(firstname, lastname, age):
+    print("My name is {} {}, and I'm {}.".format(firstname, \
+                                                 lastname, \
+                                                 age))
+
+init()
+```
+
+%% Cell type:markdown id:7b5fd216 tags:
+
+## Other data types...
+
+Per altri data types non citati...
+
+- **Strings**
+- numbers.**Complex**
+- **Bytes**
+- **Queues**
+- ...
+
+
+Per tutto ciò che non si conosce/ricorda riguardo al linguaggio..
+sicuramente c'è una sezione apposta nella doc.
+
+In questo caso: [python - Data Model ](https://docs.python.org/3/reference/datamodel.html#the-standard-type-hierarchy).
+
+
+%% Cell type:markdown id:28d2f026 tags:
+
+# I/O -- ovvero Input/Output
+