# 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

Notes:
- Ricordatevi il nome di Guido
- Aggiungere statistiche sullo sviluppo di python

----

## Interpretato vs. compilato

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

Notes:
- Parlare della VM Python

---

## Cosa serve

- Editor di testo (Atom, Notepad++)
- 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)

----

## REPL

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

```bash
$ 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 information.
>>> print('Hello world!')
Hello world!
```

Per uscire: quit()

Notes:
- Differenza tra interprete (il software che converte le istruzioni in bytecode e
poi esegue quest'ultimo) e REPL (il software che si interfaccia con l'utente)

----

## Espressioni

```
>>> 2 + 2
4

>>> 3 * 3
9

>>> 4 < 5
True
```

----

## Commenti

Tutto quello scritto dopo il `#` non viene interpretato

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

----

## Errori

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

"Le scritte vanno lette" o "Il segreto degli hacker"

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

----

## Variabili

```python
>>> x = 6

>>> x
6

>>> 2 * x
12

>>> y = x + 4

>>> y
10
```

----

### Cosa ho di fronte?

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

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

----

### Interi (`int`)

- Cifre senza punto.
```
12
0xAB
0b101
```

----

### 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

```
# esempi + corto circuito e quando ti esplode in faccia la vita
# cast a booleano?
```

----

### None  ← metterlo parlando di funzioni?

- Equivale al `NULL` di C o Java

----

### 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

- Collezione ordinata di elemeti, anche di tipi diversi.
- Si definiscono con le parentesi quadre

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

- Per accedere ad un elemento si usano le parentesi quadre
- Il primo elemento ha indice 0

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

- Possono essere modificate

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

----

### Tuple

- Esattamente come le liste, ma immutabili.
- Si definiscono con le parentesi tonde.

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

---

### Unpacking

- Estrarre valori da un contenitore

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

>>> a, b = b, a
>>> b
1
```

----

### in

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

----

## Riferimenti

- Quando assegnamo un oggetto ad una variabile, la variabile contiene solo un *riferimento* all'oggetto

- **Non** l'oggetto stesso.

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

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

----

### Insiemi

- Come gli insiemi matematici,
- Non sono ordniati
- Non contengono elementi duplicati

```python
insieme = {"mele", "pere", 2, "arance"}
```

- Supportano operazioni logiche

---

### Dizionari

- Associano una chiave ad un valore
- Le chiavi devono essere immutabili
- I valori possono essere cambiati

```python
d = {
    "nome":"Tancredi",
    "cognome":"Orlando"
    }
```

- Si accede ai campi usando le chiavi

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

----

## Strutture di controllo

Notes:
- parlare di musica

----

### if

Se una condizione è vera esegue un blocco di codice

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

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

### Blocchi
Si allineano con quattro spazi

(si possono usare anche 2 o 8 spazi, o i TAB, ma per favore non fatelo)

### else

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


----

## `while`

Eseguire più volte le stesse istruzioni (fintantoché una condizione è 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`

Cicli di esecuzione sulle sequenze

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

--

## `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 <!-- .element: class="fragment" -->
* Il concetto più importante per costruire un programma <!-- .element: class="fragment" -->
* Ci permettono di dare un nome a un blocco di istruzioni <!-- .element: class="fragment" -->
* E di eseguirlo un numero qualsiasi di volte, "chiamando" la funzione <!-- .element: class="fragment" -->
* <!-- .element: class="fragment" --> Si definiscono con la keyword `def`

--

## Esempio

```python
def say_hello():
	# block belonging to the function
	print('hello world')

# End of function

say_hello() # call the function
say_hello() # call the function again
```

--

## Parametri e Argomenti

- Le funzioni posso specificare dei "parametri"
 - ogni volta che si chiama la funzione, deve essere passato un valore per ogni parametro
- I valori che vengono passati durante la chiamata sono detti "argomenti"

```python
def test(a, b): # a, b sono i parametri
	print(a+b)

test(3, 4) # 3, 4 sono gli argomenti
```

--

## 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

--


### Argomenti di default

- Alcuni parametri possono essere dichiarati opzionali
- 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
```

## Il `return` statement

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

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

Notes:
- differenza tra restituire un valore e stamparlo

---

# Moduli

--

## Moduli

- Riutilizzare funzioni o tenere un programma ordinato

- Semplicemente un file con estensione .py

- Un modulo può essere importato da un altro programma
 
 
```python
>>> import math
>>> math.sqrt(16)
4.0
```

--

## `from ... import`

Permette di importare solo alcune funzioni

```python
>>> from math import sqrt
>>> 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')
```


### i/o

- print
- input

## 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 di sintassi

---

# 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)