Commit ab3cdbc7 authored by JackV's avatar JackV

Topics cleanup

parent 3f990298
......@@ -73,19 +73,6 @@ 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
......@@ -183,441 +170,54 @@ Il segreto degli [hacker](http://www.girodivite.it/Diario-di-un-aspirante-hacker
---
# Tipi
----
## Cosa ho di fronte?
```
>>> type(3)
<class 'int'>
```
```
>>> type(3.14)
<class 'float'>
```
----
## Numeri interi (`int`)
```
12 # notazione decimale
0xAB # notazione esadecimale
0b101 # notazione binaria
```
----
## Numeri decimali (`float`)
```
>>> 3.14 + 1.23
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
```
----
## Short-circuit evaluation
```
>>> (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 termini non vengono
valutati.
- 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]
```
- Si accede a un elemento della lista aggiungendo l'indice dell'elemento
desiderato tra parentesi quadre
- Il primo elemento ha indice 0 (zero-based)
```
>>> lista[2]
'due'
```
# Input e Output
----
```
>>> 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
```
- Purtroppo a volte è necessario interagire con l'utente
- È possibile ottenere un valore dall'utente
- È possibile accedere a un file presente sul disco
----
### Slicing
- Permette di formare sottoinsiemi di elementi contigui
- Bisogna indicare un intervallo di indici, separando inizio e fine con
due punti (`:`)
- L'elemento finale non è incluso
```
>>> lista = [0.0, 1, "due", 3.0, 4, 5, 'sei']
```
## Formattazione dell'output
```
>>> lista[2:5]
['due', 3.0, 4]
>>> s = 'Corsi {} {}'
>>> s.format('Python', '2017')
'Corsi Python 2017'
>>> s.format('Linux', 'base')
'Corsi Linux base'
```
----
### Slicing
- È possibile indicare tutti gli elementi dall'inizio o fino alla fine di una
lista omettendone l'indice
```
>>> lista[:4]
[0.0, 1, 'due', 3.0]
>>> lista[4:]
[4, 5, 'sei']
>>> s = 'Corsi {argomento} {tipo}'
>>> s.format(tipo='avanzati', argomento='antani')
'Corsi antani avanzati'
```
- Utilizzando indici negativi si parte a contare dal fondo
```
>>> lista[-4:]
[3.0, 4, 5, 'sei'] # ultimi 4 elementi
from math import pi
>>> '{:.2f}'.format(pi)
3.14
```
----
### Unpacking
Estrarre valori da un contenitore
```
>>> t = (1, 2)
```
```
>>> a, b = t
>>> b
2
```
## Input dall'utente
```
>>> a, b = b, a
>>> a = input()
asd
>>> 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', 'zucchine', 'pere'}
```
----
Supportano le operazioni insiemistiche
```
>>> frutta = {"mele", "pere", "zucchine", "mele"}
>>> verdure = {"zucchine", "verze", "coste", "porri"}
```
```
>>> frutta.union(verdure)
{'coste', 'mele', 'pere', 'porri', 'verze', 'zucchine'}
```
```
>>> 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
{'porri', 'verze', 'pere', 'zucchine', 'coste', 'mele'}
```
```
>>> frutta & verdure
{'zucchine'}
```
```
>>> frutta - verdure
{'pere', 'mele'}
```
```
>>> verdure - frutta
{'verze', 'coste', 'porri'}
```
----
## Dizionari (`dict`)
- Associano ogni 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'
'asd'
```
```
>>> print('these things ' + ' '.join(d[('immutable', 'types')])
these things are cool
>>> nome = input("Inserisci il tuo nome: ")
Gattuso
>>> 'Il tuo nome è {}.'.format(nome)
'Il tuo nonme è Gattuso.'
```
---
......@@ -889,255 +489,6 @@ None
esatto!
```
---
# Moduli
----
- I file contenenti codice Python hanno estensione `.py`
- Ogni file è un **modulo**
- È possibile importare variabili, funzioni e classi da altri moduli con
l'istruzione `import`
- modulo.py
```
default_lim = 3
def conta(lim=default_lim):
for x in range(lim):
print(x)
```
- programma.py
```
import modulo
x = modulo.default_lim + 2
modulo.conta(x)
```
----
- È possibile importare solo alcuni elementi da un modulo con la sintassi
`from <modulo> import <oggetto>`
- Aiuta la leggibilità del codice
- Si omette il modulo di provenienza
- modulo.py
```
default_lim = 3
def conta(lim=default_lim):
for x in range(lim):
print(x)
```
- programma.py
```
from modulo import default_lim, conta
x = default_lim + 2
conta(x)
```
----
Il codice posto nello scope del modulo è comunque eseguito, anche se sono
importati alcuni elementi con la sintassi `from ... import`.
- modulo.py
```
a = 'variabile'
def f():
print('funzione')
print('modulo')
```
- dalla REPL
```
>>> from modulo import f
modulo
>>> f()
funzione
```
----
È possibile eseguire del codice solo se il file è eseguito direttamente
e non è stato importato come modulo
if __name__ == '__main__':
print('Programma eseguito direttamente')
else:
print('Questo modulo è stato importato')
```
- La variabile `__name__` contiene il nome del modulo corrente
- Se un modulo è eseguito direttamente la variabile `__name__` assume valore
‘`__main__`’
----
- Python dispone di numerosi moduli già inclusi
- Le capacità del linguaggio si possono estendere con moduli esterni
- È possibile installare ulteiori moduli tramite `pip`
```
$ pip install --user shouty
Collecting shouty
Installing collected packages: shouty
Successfully installed shouty-0.1.dev6
```
---
# Input e Output
----
- Purtroppo a volte è necessario interagire con l'utente
- È possibile ottenere un valore dall'utente
- È possibile accedere a un file presente sul disco
----
## Formattazione dell'output
```
>>> s = 'Corsi {} {}'
>>> s.format('Python', '2017')
'Corsi Python 2017'
>>> s.format('Linux', 'base')
'Corsi Linux base'
```
```
>>> s = 'Corsi {argomento} {tipo}'
>>> s.format(tipo='avanzati', argomento='antani')
'Corsi antani avanzati'
```
```
from math import pi
>>> '{:.2f}'.format(pi)
3.14
```
----
## Input dall'utente
```
>>> a = input()
asd
>>> a
'asd'
```
```
>>> nome = input("Inserisci il tuo nome: ")
Gattuso
>>> 'Il tuo nome è {}.'.format(nome)
'Il tuo nonme è Gattuso.'
```
----
## Aprire i file
```python
f = open("documento.txt", "w")
f.write("contenuto")
f.close()
```
- `open(filename, mode)` ritorna un riferimento al file
- Il parametro `mode` specifica la modalità
| mode | descrizione |
| :---- | :------------------------------ |
| r | Apertura in sola lettura |
| w | Apertura in sola scrittura |
| r+ | Apertura in lettura e scrittura |
| a | Scrittura in coda |
----
## Usare i file
- Per scrivere su un file
```
>>> f = open("documento.txt", "w")
>>> f.write("Contenuti serissimi.")
20
>>> f.close()
```
- Per leggere da un file
```
>>> f = open("documento.txt", "r")
>>> f.read()
'Contenuti serissimi.'
>>> f.close()
```
- I metodi `readline` e `writeline` leggono e scrivono una riga alla volta
- Ricordiamoci di chiudere sempre il file con la funzione `close()`
----
## Una scorciatoia
```python
with open("documento.txt", "w") as f:
f.write("contenuto")
```
- All'interno del blocco, `f` è un riferimento al file
- Non serve chiudere esplicitamente
- Se vengono sollevati errori o eccezioni il file viene chiuso
- Usate `with` quando potete
----
## Guardiamoci le spalle
- Gli errori non sono sempre causati dal programmatore