# Corsi Python 2017

----

Potete ottenere questa presentazione recandovi all'indirizzo:

[slides.poul.org/2017/python](https://slides.poul.org/2017/python)

---

# Perché Python?

- Ottimo per i principianti
- Facile da usare
- Estremamente diffuso
- Moduli per qualunque cosa

----

## C

```c
#include <stdio.h>

int main() {
    printf("Hello, world!\n");
    return 0;
}
```

----

## Java

```java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Goodbye, world!");
    }
}
```

----

## Python

```python
print('Hello, world!')
```

----

![import antigravity](https://imgs.xkcd.com/comics/python.png)

----

## Breve storia

- Nasce nel 1991 per mano di Guido van Rossum
- Prende il nome dai Monty Python
- È in continua evoluzione
- Convivono due versioni (2 e 3)
- Noi useremo Python 3
- Fatelo anche voi

----

## Interpretato vs. compilato

- Compilato: tradotto in linguaggio macchina
- Interpretato: eseguito da un altro programma
- Python è interpretato (circa)

Notes:
Python è compilato in quanto la sintassi Python è compilata in bytecode, ed
è interpretato in quanto il bytecode è eseguito da un altro programma, la VM
Python e non eseguito direttamente dal processore.

----

## Cosa serve

- Per scrivere il codice, un editor di testo:
  - Multipiattaforma: Atom
  - Windows: Notepad++
- In quanto linguaggio interpretato, l'interprete Python
  - Linux: generalmente preinstallato, altrimenti utilizzare il package manager
  - macOS: [Installer](https://www.python.org/ftp/python/3.6.1/python-3.6.1-macosx10.6.pkg)
  - Windows: [32bit](https://www.python.org/ftp/python/3.6.1/python-3.6.1.exe)
    o [64bit](https://www.python.org/ftp/python/3.6.1/python-3.6.1-amd64.exe)

---

# Il linguaggio

----

## REPL

**R**ead, **E**val, **P**rint **L**oop

```
$ python3
Python 3.6.1 (default, Mar 27 2017, 00:27:06) 
[GCC 6.3.1 20170306] on linux
Type "help", "copyright", "credits" or "license" for more info...
>>> print('Hello, world!')
Hello world!
```

Per uscire: `quit()`

Notes:
Mostrare la differenza tra interprete (il software che converte le istruzioni
in bytecode e poi esegue quest'ultimo) e l'interfaccia REPL Python (il
software che si interfaccia con l'utente).

----

## Espressioni

```
>>> 2 + 2
4
```

```
>>> 3 * 3
9
```

```
>>> 4 < 5
True
```

----

## Commenti

Tutto ciò posto dopo il cancelletto (`#`) non è interpretato.

```
>>> 1 + 1  # qui posso scrivere quello che voglio
2
```

----

## Errori

```
>>> 3 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
```

Il segreto degli hacker? Leggere le scritte!

([Lettura consigliata](http://www.girodivite.it/Diario-di-un-aspirante-hacker.html))

----

## Variabili

```
>>> x = 6
>>> y = 2
>>> x
6
>>> y
2
```

```
>>> 2 * y
4
>>> x + y
8
```

```
>>> z = x + y
>>> z
8
```

---

# Tipi

----

## Cosa ho di fronte?

```
>>> type(3)
<class 'int'>
```

```
>>> type(3.14)
<class 'float'>
```

----

## Interi (`int`)

Cifre senza punto

```
12       # notazione decimale
0xAB     # notazione esadecimale
0b101    # notazione binaria
```

----

## Decimali (`float`)

Cifre con punto

```
>>> 3.14 + 1.234
4.3740000000000006
```

```
>>> 100 / 3
33.333333333333336
```

```
>>> 100 // 3
33
```

----

## Casting

- È l'azione di conversione del tipo
- Si usa il nome del tipo destinazione

```
>>> int(4.20)
4
```

```
>>> x = float(13)
>>> x
13.0
```

```
>>> type(x)
float
>>> type(13)
int
```

----

## Booleani (`bool`)

- Possono assumere due valori: `True` o `False`
- Supportano operazioni logiche (`and`, `or`, `not`)
- Sono il risultato delle operazioni di confronto

----

```
>>> 4 < 5
True
```

```
>>> 3.14 < 2
False
```

```
>>> (4 < 5) or (3.14 < 2)
True
```

```
>>> (4 < 5) and (3.14 < 2)
False
```

----

```
>>> (3.14 < 2) or print('Hello world!')
Hello world!
```

```
>>> (3.14 < 2) and print('Hello world!')
False
```

- È necessario che il valore di solo un membro dell'espressione sia falso per
  rendere tutta l'espressione falsa. Tutti gli altri membri perdono di
  significato.
- Python valuta i membri di una espressione finché ritiene sia necessario
  per la corretta esecuzione del codice

---

# Collezioni

----

## Stringhe (`str`)

- Testo
- Racchiuse tra singoli apici (`'`) o virgolette (`"`)
- Per stringhe su più righe racchiuse tra tripli apici (`'''`) o virgolette (`"""`)
- Sono *immutabili*

```
>>> a = "Hello"
>>> b = "World"
>>> a + ' ' + b
'Hello World'
```

----

## Liste (`list`)

- Collezione **ordinata** di elementi, anche di tipi diversi
- Si definiscono ponendo all'interno di parentesi quadre gli elementi
  intervallati da una virgola

```
lista = [False, 1, "due", 3.0, 4, 5]
```

- Il primo elemento ha indice 0 (zero-based)
- Si accede a un elemento della lista aggiungendo l'indice dell'elemento
  desiderato tra parentesi quadre

```
>>> lista[2]
'due'
```

----

```
>>> lista = [False, 1, "due", 3.0, 4, 5]
>>> lista
[False, 1, 'due', 3.0, 4, 5]
```

```
>>> lista[0] = 0.0
>>> lista
[0.0, 1, 'due', 3.0, 4, 5]
```

```
>>> lista.append('sei')
>>> lista
[0.0, 1, "due", 3.0, 4, 5, 'sei']
```

```
>>> lista.remove('sei')
>>> lista
[0.0, 1, "due", 3.0, 4, 5]
```

```
>>> lista.reverse()
>>> lista
[5, 4, 3.0, 'due', 1, 0.0]
```

```
>>> len(lista)
6
```

----

### Unpacking

Estrarre valori da un contenitore

```
>>> t = (1, 2)
```

```
>>> a, b = t
>>> b
2
```

```
>>> a, b = b, a
>>> a
2
```

```
>>> c, _ = t
>>> c
1
```

----

### L'operatore `in`

Valuta l'appartenenza di un elemento ad una collezione

```
>>> lista = ['a', 'b', 'c']
>>> 'c' in lista
True
```

- È un'espressione booleana
- Si può usare con l'operatore `not`

```
>>> lista = ['a', 'b', 'c']
>>> 'c' not in lista
False
```

----

## Tuple (`tuple`)

- Esattamente come le liste, ma **immutabili**
- Sono quindi anche **ordinate**
- Si definiscono con le parentesi tonde

```python
tupla = ('a', 1, 2, '3.0')
```

```
>>> tupla[1] = 1.0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
```

```
>>> tupla.append('sei')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
```

----

## Riferimenti

- Quando assegniamo un oggetto ad una variabile, la variabile contiene solo un
  *riferimento* all'oggetto
- **Non** l'oggetto stesso.

```
>>> spesa_a = ['mela', 'mango']
```

```
>>> spesa_b = spesa_a
>>> spesa_b.append('carota')
>>> spesa_b
['mela', 'mango', 'carota']
```

```
>>> spesa_a
['mela', 'mango', 'carota']
```

----

## Insiemi (`set`)

- Come gli insiemi matematici
- **Non sono ordinati**
- Non contengono elementi duplicati

```
>>> frutta = {"mele", "pere", "zucchine", "mele"}
>>> frutta
{'mele', 2, 'arance', 'pere'}
```

----

Supportano le operazioni insiemistiche

```
>>> frutta = {"mele", "pere", "zucchine", "mele"}
>>> verdure = {"zucchine", "verze", "coste", "porri"}
```

```
>>> frutta.union(verdure)
{'porri', 'verze', 'pere', 'zucchine', 'coste', 'mele'}
```

```
>>> frutta.intersection(verdure)
{'zucchine'}
```

```
>>> frutta.difference(verdure)
{'pere', 'mele'}
```

```
>>> verdure.difference(frutta)
{'verze', 'coste', 'porri'}
```

----

La sintesi è anche espressività

```
>>> frutta = {"mele", "pere", "zucchine", "mele"}
>>> verdure = {"zucchine", "verze", "coste", "porri"}
```

```
>>> frutta | verdure
{'coste', 'verze', 'mele', 'pere', 'porri', 'zucchine'}
```

```
>>> frutta & verdure
{'zucchine'}
```

```
>>> frutta - verdure
{'mele', 'pere'}
```

```
>>> verdure - frutta
{'coste', 'verze', 'porri'}
```

----

## Dizionari (`dict`)

- Associano una chiave ad un valore
- Le chiavi devono essere immutabili (stringhe, tuple)

```python
d = {
    "chiave": "valore",
    "nome":"Tancredi",
    "cognome":"Orlando",
    ('immutable', 'types'): ['are', 'cool']
    }
```

Si accede ai campi come si accede agli elementi di una lista, usando la chiave
al posto dell'indice.

```
>>> d['nome']
'Tancredi'
```

```
>>> print('these things ' + ' '.join(d[('immutable', 'types')])
these things are cool
```

---

# Controllo del flusso

----

## `if`

Se una condizione è vera esegue un blocco di codice.

```python
if 3 > 2:
    print('Condizione vera')
```

## Blocchi
- Sono corpi di codice allineati con una spaziatura multipla coerente
- Per bontà agli dèi usate quattro spazi ed evitate le tabulazioni come la peste

Notes:
Dire perché qua stiamo usando `print` e non scrivendo il valore e basta come
prima.

----

## `else`

- Il blocco viene eseguito solo se il più vicino if risulta falso

```python
if 3 > 2:
    print('Condizione vera')
else:
    print('Condizione falsa')
```

----

## `while`

- Esegue più volte le stesse istruzioni
- Fintantoché una condizione rimane vera

```python
>>> x = 0
>>> while x < 3:
... 	x = x + 1
... 	print("ora x vale", x)
...
ora x vale 1
ora x vale 2
ora x vale 3
```

----

## `for`

- Esegue un blocco per ogni elemento di una sequenza

```python
for i in [0, 1, 2, 3, 4]:
	print(i)
```

- Si può creare al volo una sequenza fornendo gli estremi

```python
>>> for i in range(0,4):
...    print(i)
... 
0
1
2
3
```

Notes:
Dire che il secondo estremo non è compreso e come mai è così.

----

## `break`, `continue`

* `break`: interrompe l'iterazione
* `continue`: salta all'iterazione successiva

```python
for i in [0, 1, 2, 3, 4, 5, 6, 7]:
	if i == 2:
		continue
	if i == 6:
		break
	print(i)
```

---

# Funzioni

----

## Funzioni

- Porzioni riusabili di un programma
- Il concetto più importante per costruire un programma
- Ci permettono di dare un nome a un blocco di istruzioni
- E di eseguirle quando vogliamo, "chiamando" la funzione
- Si definiscono con la keyword `def`

----

## Esempio

```python
def say_hello():
	print('hello world')
	

say_hello()  # chiama la funzione
say_hello()  # chiama la funzione di nuovo
```

----

## Parametri e Argomenti

- Le funzioni possono specificare dei "parametri"
- Se si chiama la funzione, bisogna assegnargli dei valori
- I valori che vengono passati durante la chiamata sono detti "argomenti"

----

## Lo statement `return`

Tramite il `return` la funzione ci dà un risultato

```python
>>> def somma(a, b):
... 	return a + b
...
>>> somma(1, 2)
3
```

Notes:
- è importante che venga visto il `return` il prima possibile
- spiegare comunque la differenza tra restituire un valore e fare una `print`

----

## Variabili locali

- Le variabili definite dentro una funzione sono **locali**
- Non sono correlate con variabili dello stesso nome, definite fuori

----

## Lo statement `global`

- Permette di definire una variabile globale all'intero di una funzione
- Unico modo per modificare una variabile definita fuori dalla funzione

```python
>>> x = 3
>>> def increment_x():
...     global x
...     x = x + 1
...
>>> increment_x()
>>> x
4
```

Notes:
Accennare alle virtù della programmazione priva di side effects.

----


### Argomenti di default

- Alcuni parametri possono essere resi opzionali
- Si fa assegnando ai parametri dei valori di default
- Se omettiamo l'argomento, la funzione userà quello di default


```python
def f(a, b=3, c=6):
    print(a, b, c)
```

```
>>> f(1)
1 3 6

>>> f(1, 2)
1 2 6

>>> f(1, c=4)
1 3 4
```

----

## None

- Equivale al `NULL` di C o Java
- Valore restituito quando il `return` viene omesso

---

# Moduli

----

## Moduli

- Riutilizzare codice di altri programmi (o librerie)
- Suddividere un programma complesso in piccoli pezzi
- Sono file con estensione `.py`
- Un modulo può essere importato con la keyword `import`
 
 
```python
>>> import math
>>> math.sqrt(16)
4.0
```

----

## `from ... import`

Permette di importare solo alcune funzioni

```python
>>> from math import s3qrt
>>> sqrt(16)
4.0
```

----

## La variabile `__name__`

- Contiene il nome del modulo

- Modulo importato o eseguito direttamente?

```python
if __name__ == '__main__':
	print('Programma eseguito direttamente')
else:
	print('Questo modulo è stato importato')
```

---

# Input e Output

----

## I/O

- A volte può essere utile interagire con l'utente
- Per esempio chiedere valori in ingresso e stampare risultati
- Useremo `input()` per ricevere dei valori e `print()` per stamparli.

```python
nome = input("Inserisci il tuo nome: ")
print("Il tuo nome è", nome)
```

----

## Formattazione dell'Output

- Per formattare l'output spesso `print()` da sola non è sufficiente.

- Possiamo usare i metodi della classe `str` e in particolare `str.format()`

```python
>>> s = 'This {food} is {adjective}.'.format(
... 	food='spam', adjective='horrible')
>>> print(s)
This spam is horrible
```

---

# Errori ed Eccezioni

----

## Errori di Sintassi

```python
>>> while return print('Hello?') # ??????
SyntaxError: invalid syntax
```

- Sono i più comuni da commettere per chi sta imparando Python :-)

- Accadono quando scriviamo una istruzione in maniera *sintatticamente* errata

- L'interprete Python non riesce a capirne il significato e quindi non può eseguirla

----

## Eccezioni

- Rappresentano il verificarsi di situazioni *eccezionali*

- Cosa succede se stiamo tentando di leggere un file che non esiste? O se
  cerchiamo di dividere per zero?

----

## Gestire le Eccezioni

- Possiamo (e dovremmo) gestire le eccezioni racchiudendo le nostre istruzioni in un blocco `try/except`

```python
try:
	x = int(input('Inserisci un intero: '))
except ValueError:
	print('Oops! Non era un intero.')
```

----

## Sollevare Eccezioni

- In alcuni casi può essere utile sollevare delle eccezioni

- Per esempio quando una funzione non è in grado di gestire alcuni input

- Dovranno essere gestite (catturate) dal chiamante della funzione,
altrimenti l'utente vedrà un messaggio di errore

```python
def mandaEmail(email, testo):
	if not '@' in email:
		raise ValueError("email non valida")
	# [..]
```

---

# The End

----

# Thank you!

Queste slides sono sotto licenza Creative Commons<br>
Attribution-ShareAlike 3.0 Unported

## [poul.org](https://www.poul.org)