Introduzione a Python

[<img src="imgs/linuxvar.png" />](http://linuxvar.it)

di [Riccardo Macoratti](mailto:r.macoratti@gmx.co.uk)

---

Nasce nel 1991 dalla mente di Guido Van Rossum e oggi usato da organizzazioni
quali Google, Yahoo!, CERN e NASA.

Siamo alla versione 3.5, ma è ancora largamente in uso (purtroppo...) la
versione 2.

---

# Perchè usarlo? (1)

* Multiparadigma:

* procedurale
  * orientato agli oggetti
  * semifunzionale

* Leggibile:

* sintassi leggera e quasi del tutto priva di parentesi
  * blocchi di codice definiti usando l'indentazione

---

# Perchè usarlo? (2)

* "Facile":

* molto poco verboso
  * tipizzazione dinamica
  * errori segnalati molto amichevolmente

* Buona documentazione

* a patto che venga usato Google per cercare quello che serve

---

# Perchè non usarlo?

* leeeeeeeeeeeeeeeeeeeeeeeeeeento!

* molto, molto ad alto livello

* per dialogare con l'hardware è necessario passare da C

* il dinanismo a volte può creare problemi in fase di *debugging*

* per progetti grandi, si rischia di perdere il senso generale

---

# 2 versus 3

Molte ragioni per non incominciare un nuovo progetto con Python 2:

* Python 2.7 è EOL, solo aggiornamenti

* Python 2 presenta molte stranezze:

* divisione intera
    * stringhe non unicode
    * comparazioni di variabili di tipo diverso
    * corretto uso degli stream di byte

Usate Python 3!

---

# REPL

Python presenta un utilissimo REPL, cioè una console, al comando `python3`:

```sh
$ python3
Python 3.5.1 (default, Mar  3 2016, 09:29:07)
[GCC 5.3.0] on linux
Type "help", "copyright", "credits" or "license"
for more information.
>>>
```

---

# Sintassi

---

# Selezione

```
if condition:
  print('Hello, if!')
elif condition:
  print('Hello, elif!')
else:
  print('Hello, else!')
```

```
print('True') if condition else print('False')
```

Non esiste il costrutto di `switch`.

---

# Ciclo

```
while condition:
  print('Hello, while!')
```

```
while True:
  if condition:
    break
  print('Hello, do while!)
```

```
for i in range(100):
  print(i)
```

Non esiste il `for` à la C.

```
for n,i in enumerate(range(100)):
  print(n, i)
```

---

# Variabili

```
>>> a = 42
>>> a
42
>>> type(a)
<class 'int'>
```

```
>>> a = 'Linuxvar'
>>> a
'Linuxvar'
>>> type(a)
<class 'str'>
```

Tipi di dato "primitivi":

* stringhe: `'linuxvar'` oppure `"linuxvar"`
  * numeri: `42` oppure `42.7`
  * valori booleani: `True` oppure `False`

---

# Commenti

Linea singola...

```
# qui sotto un metodo miracoloso
fai_miracolo()
```

... e multilinea.

```
'''
Sono
un commento
su più righe
'''
```
```
"""
Anche
io
"""
```

---

# Importare dei moduli

I moduli sono le librerie di Python.

```
>>> import os
>>> os.name
'posix'
>>> os.getcwd()
'/home/user/intro-python'
>>> import sys
>>> sys.byteorder
'little'
```

---

# Funzioni

```
>>> def hello(name):
...  print('Hello, {}!'.format(name))
...
>>> hello('Linux')
Hello, Linux!
>>> type(hello)
<class 'function'>
```

Anche le funzioni, come tutto il resto, sono oggetti e quindi possono essere
assegnate a variabili.

```
>>> a = hello
>>> a('Linuxvar')
Hello, Linuxvar!
>>> type(a)
<class 'function'>
```

---

# Tipi di dato

---

# Tipi di dato

Esistono diversi tipi di dato inclusi nella libreria standard di Python, detti
*built-in*:

* `str` ➝ stringhe
  * `list` e `tuple` ➝ array
  * `dict` ➝ mappe
  * `set` e `frozenset` ➝ insiemi
  * `bytes` ➝ dati binari

---

# Mutable vs. Immutable

Un tipo di dato è "mutabile" o *mutable* se può essere modificato ad un tempo
successivo rispetto alla sua crezione. Viceversa è *immutable*.

La differenza è che i tipi immutable, al contrario di quelli mutable, sono
*hashable* (cioè è possibile, ad esempio, utilizzarli come chiave univoca
all'interno di un tipo dizionario).

---

# Stringhe

La classe `str` modella delle stringhe immutabili di caratteri.

```
>>> stringa = 'Hello, world!'
>>> stringa
'Hello, world!'
```

Sono pensate esattamente come liste di caratteri, perciò si possono scorrere
anche con un ciclo.

```
for i in stringa:
  print(i)
```

* I caratteri sono rappresentati come stringhe di lunghezza singola.
  * Non esistono le tipi stringa mutable

---

# Liste (1)

Le liste sono delle sequenze ordinate, mutabili e di lunghezza variabile di
oggetti.
Possono essere visti come degli array di lunghezza non definita a priori.

```
>>> l1 = []
>>> l2 = list()
>>> l1, l2
([], [])
>>> l1.append('linux')
>>> l1.append(42)
>>> l1.append(False)
>>> l1.append(True)
>>> l1
['linux', 42, False, True]
>>> l1[0]
'linux'
>>> l1.remove(True)
>>> l1
['linux', 42, False]
```

---

# Liste (2)

```
>>> l1.append(True)
>>> l1
['linux', 42, False, True]
>>> del l1[3]
>>> l1
['linux', 42, False]
```

Esiste l'operatore di *slicing*.

```
>>> l1[:2] # solo i primi due valori
['linux', 42]
>>> l1[1:] # solo dal secondo valore in poi
[42, False]
>>> l1[:] # copia la lista
['linux', 42, False]
```

---

# Tuple

Sono delle sequenze ordinate e immutabili di oggetti.

```
>>> t1 = ('a', 'b', 'c')
>>> t2 = tuple('a', 'b', 'c')
>>> t1, t2
(('a', 'b', 'c'), ('a', 'b', 'c'))
>>> t1[1]
'b'
>>> t1[1:]
('b', 'c')
```

---

# Dizionari (1)

I dizionari, o mappe, sono delle sequenze non ordinate di coppie chiave-valore.
Le chiavi devono essere univoche in tutta la collezione.

```
>>> d1 = {}
>>> d2 = dict()
>>> d1['a'] = 1
>>> d2['a'] = 1
>>> d1['b'] = 2
>>> d2['b'] = 2
>>> d1, d2
({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
>>> del d1['b']
>>> d1
{'a': 1}
```

---

# Dizionari (2)

Si può testare l'esistenza di una chiave tramite l'operatore 'in'.

```
>>> if 'a' in d1:
...   print('Trovato!')
...
Trovato!
```

Si può scorrere un dizionario (senza garanzia d'ordine).

```
>>> for k,v in d2.items():
...   print(k, v)
...
a 1
b 2
```

---

# Dizionari (3)

È possibile ottenere la lista delle chiavi...

```
>>> d2.keys()
dict_keys(['a', 'b'])
```

... e dei valori.

```
>>> d2.values()
dict_values([1, 2])
```

---

# Insiemi (1)

Gli insiemi sono delle sequenze non ordinate di oggetti univoci, cioè non
possono esistere duplicati.

```
>>> s = set()
>>> s.update({1, 2, 3})
>>> s
{1, 2, 3}
>>> s.add(1)
>>> s
{1, 2, 3}
```

È possibile testare se un dizionario contiene già un oggetto dato.

```
>>> 1 in s
True
```

---

# Insiemi (2)

Esitono anche dei particolari tipi di insieme che sono invece immutabili, i
`frozenset`.

```
>>> fs = frozenset((1, 2, 3))
>>> fs
frozenset({1, 2, 3})
>>> 1 in fs
True
```

Non sono molto usati in Python, in quanto possono essere facilmente sostituiti
da una tupla.

---

# Per incominciare a programmare

---

# Hello world (1)

Confrontiamo un "Hello, world!" in Java...

```java
class Main {
  public static void main(String[] args) {
    System.out.println("Hello, world!");
  }
}
```

... con un "Hello, world!" in Python3.

```
print('Hello, world!')
```

---

# Main

Non è necessario un vero e proprio `main`.
Per ragioni che vanno al di là dello scopo di questo tutorial, è buona norma,
però, usarlo.

```
def hello_world():
  return 'Hello, world!'

if __name__ == '__main__': # boilerplate
  print(hello_world())
```

---

# Documentazione

Per diventare dei buoni *pythonistas* non si può ignorare la documentazione
del linguaggio, quindi RTFM (**R**ead **T**he **F**ine **M**anual)!