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

last_version with docker

parent 38cf9487
%% 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