Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Andrew
intro
Commits
3f990298
Commit
3f990298
authored
Apr 24, 2019
by
JackV
Browse files
Post-merge corrections
parent
5470189a
Changes
3
Hide whitespace changes
Inline
Side-by-side
content.md
View file @
3f990298
# Intro e outro dentro l'HTML
Il markdown contiene solo il contenuto.
Potete ottenere questa presentazione recandovi all'indirizzo:
Di base si possono fare le slide anche in HTML se si vogliono animazioni buffe.
[
slides.poul.org/2019/python
](
https://slides.poul.org/2019/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!'
)
```
----

----
## 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'}
```
----
This is a long dash -- made of two little dashes (
`--`
).
## 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
```
This dash is even longer --- and it is made of three little dashes (
`---`
).
---
"Quoting" is fun and easy.
`"`
Plain quoting
`"`
is ugly.
# Controllo del flusso
----
# Heading level 1
## `if`
Se una condizione è vera esegue un blocco di codice.
## Heading level 2
```
python
if
3
>
2
:
print
(
'Condizione vera'
)
```
##
# Heading level 3
##
Blocchi
#### Heading level 4
-
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
There are
**no**
more heading levels.
Notes:
Dire perché qua stiamo usando
`print`
e non scrivendo il valore e basta come
prima.
----
## `else`
-
Se la condizione di una istruzione
`if`
è falsa viene eseguito il blocco
della istruzione
`else`
(se presente)
```
python
import
sys
if
3
>
2
:
print
(
'Condizione vera'
)
else
:
print
(
'Condizione falsa'
)
```
----