Commit 3f990298 authored by JackV's avatar JackV
Browse files

Post-merge corrections

parent 5470189a
This diff is collapsed.
......@@ -38,12 +38,12 @@
<div class="slides">
<section class="intro">
<h1>Corsi Punto Croce 2018</h1>
<h2>Come fare gli orli</h2>
<h1>Corso Python 2019</h1>
<h2>Introduzione</h2>
<img src="poul/img/logo-text-white.svg"/>
<p>Autore &lt;email@email.com&gt;</p>
<p>Giacomo Vercesi &lt;1vercesig@gmail.com&gt;</p>
</section>
<section data-markdown="content.md"
data-charset="utf-8"
......@@ -60,7 +60,7 @@
<img class="cc" src="poul/img/creativecommons-by-nc-sa.svg"/>
<p>Autore &lt;email@email.com&gt;</p>
<p>Giacomo Vercesi &lt;1vercesig@gmail.com&gt;</p>
</section>
</div>
</div>
......
# Corso Python 2018
Niccolò Izzo
[izzo.niccolo@gmail.com](mailto:izzo.niccolo@gmail.com)
D. Raffaele Jr. Di Campli
[dcdrj.pub@gmail.com](mailto:dcdrj.pub@gmail.com)
![POuL logo](lib/img/logo-text-white.svg)
----
Potete ottenere questa presentazione recandovi all'indirizzo:
[slides.poul.org/2018/python](https://slides.poul.org/2018/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()` o `CTRL-D`
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](http://www.girodivite.it/Diario-di-un-aspirante-hacker.html)? Leggere le scritte!
----
## 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'>
```
----
## 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'
```
----
```
>>> 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
```
----
### 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']
```
```
>>> lista[2:5]
['due', 3.0, 4]
```
----
### 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']
```
- Utilizzando indici negativi si parte a contare dal fondo
```
>>> lista[-4:]
[3.0, 4, 5, 'sei'] # ultimi 4 elementi
```
----
### 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', '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'
```
```
>>> 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: