day_1.md

# 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

- Per scrivere il codice, un editor di testo:
  - Multipiattaforma: Atom
  - Windows: Notepad++
- In quanto linguaggio compilato, 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:
- 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 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

```python
>>> x = 6

>>> x
6

>>> 2 * x
12

>>> y = x + 4

>>> y
10
```

---

# 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 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 (zero-based)

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

- Possono essere modificate

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

----

## Tuple (`tuple`)

- Esattamente come le liste, ma immutabili
- 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'
```

----

## Unpacking

- Estrarre valori da un contenitore

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

>>> a, b = b, a
>>> b
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
```

----

## Riferimenti

- Quando assegniamo 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 (`set`)

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

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

- Supportano le operazioni insiemistiche

```python
>>> verdure = {"zucchine", "verze", "coste", "porri"}
>>> frutta.intersection(verdure)
{'zucchine'}
```

----

## Dizionari (`dict`)

- 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')
```

## Blocchi
- Si allineano con quattro spazi
- Funzionano anche 2 o 8 spazi, o i TAB
- Per favore usate i quattro spazi

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 eseguirlo un numero qualsiasi di volte, "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 posso specificare dei "parametri"
- ogni volta che si chiama la funzione, il loro valore viene assegnato
- 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

----


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

----

## None

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

---

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

---

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