Il documento introduce il linguaggio di programmazione Python, sviluppato da Guido van Rossum nel 1989, enfatizzando la sua semplicità, portabilità e gestione automatica della memoria. Viene fornita una panoramica delle sintassi di base, delle strutture dati, delle funzionalità di programmazione orientata agli oggetti e delle librerie utilizzabili. Inoltre, include informazioni su utilità come IDE e strumenti per l'installazione di moduli.

2. Python
Primi passi in python
Emanuel Di Nardo
GDG Campania

3. Un po di storia

4. Storia
Sviluppato nel 1989 da Guido Van Rossum [aka benevolent dictator for life (BDFL)] come
semplice “hobby”.
Il nome è stato scelto in onore dei Monty Python.
La filosofia dietro python si può racchiudere in alcuni versi chiamati “Zen of Python”:
● Beautiful is better than ugly
● Explicit is better than implicit
● Simple is better than complex
● Complex is better than complicated
● Readability counts
Per leggere la versione completa provare questo comando nel terminale:
python -c ‘import this’

5. Introduzione

6. Introduzione
● Linguaggio di programmazione ad oggetti / Scripting;
● Linguaggio di alto livello (C / C++ / Java)
● Linguaggio interpretato
● Prototipazione veloce
● Gestione automatica della memoria;
● Sintassi semplice;
● Tipizzazione dinamica;
● Portabilità;

7. Nel dettaglio

8. On platform
● Indipendente dalla piattaforma;
● Interprete scritto in C (“CPython”);
● Disponibile per tutte le piattaforme;
● Versioni disponibili 2.7.x - 3.4.x;
Download: https://www.python.org/downloads/
Utilizzeremo la versione 2.7!!!
● Python 3 non è completamente retrocompatibile!
● La maggior parte delle librerie sono scritte in python 2.x

9. Sintassi
● Mancanza di punti e virgola “;”
● Mancanza di parentesi graffe “{ }”
● Operatore di accesso a moduli / metodi “.”
● Inizio blocchi “:”
● “Indentazione”
>>> print ‘Hello world’ Python
#include <stdio.h> C
int main() {
printf(“Hello world”);
return 0;
}

10. Hello World
print ‘Hello world' Python
● Da terminale;
● python
● python -c ‘codice’
● File python .py;
● python hello.py

11. Tipizzazione
● Tipi / oggetti “primitivi”:
● Numeri;
● Boolean (True, False);
● Stringhe;
● Strutture dati:
● Liste (Array);
● Tuple;
● Dizionari;
● Tipi “speciali”:
● Nulli (None);
>>> x = 3 Python
>>> type(x)
>>> <type 'int'>
>>> x = 3.5
>>> type(x)
>>> <type 'float'>
#include <stdio.h> C
int main() {
int x = 3;
float y = 3.5;
return 0;
}

12. Numeri
● Interi, reali;
● Numeri reali automaticamente riconosciuti come float;
● Operazioni matematiche di base (+ - / * ** %)
x = 3 Python
y = 3.5
sum = x + y
division = sum / x
mult = x * y
po = x ** y
mod = 3 % 2

13. Stringhe
● Si utilizzano doppi apici “stringa” , o apici singoli ‘stringa’;
● Stringhe unicode, bytes, raw;
● Concatenazione di stringhe “+” formattazione stringhe: %s %d ecc…
● Accesso ai caratteri della stringa come se fossero liste;
● Conversione automatica (coercion) da numeri a stringhe non permessa!!!
● Le stringhe si confrontano semplicemente con ==
s1 = “stringa 1” Python
s2 = ‘stringa 2’
s3 = s1 + ‘ ‘ + s2 # concatenazione
s4 = s1 + ‘ %s’ % s2
s5 = s1[:-1] + str(5) # acesso parziale ad s1
s1 == s2 # confronto

14. Strutture dati
● Liste (Array):
● parentesi quadre “[ ]”
● keyword list;
● accesso tramite indice;
● Tuple:
● parentesi tonde “( )”
● keyword tuple;
● accesso tramite indice;
● NON MODIFICABILI!!!
● Dizionari:
● parentesi graffe “{ }”
● keyword dict;
● accesso tramite parola chiave;
● Contenuto non tipizzato!
● E’ possibile annidare strutture dati di uguale o diverso tipo;
Python
lista = [1, 2, 3]
tupla = (1, 2, “ciao”)
dizionario = {
‘chiave’: ‘valore’,
‘secondo’: 2
}
print lista[1]
print dizionario[‘chiave’]
lista[1] = “stringa” # cambio valore elemento uno
dizionario[‘secondo’] = ‘2’
dizionario[‘terzo] = lista # nuovo valore con oggetti annidati
tupla(2) = 0 # errore

15. Conversioni di tipo (cast / coercion)
● Il casting avviene tramite apposite funzioni;
● Interi: int();
● Reali: float();
● Stringhe: str();
● Esistono altre tipologie di conversioni, ma queste sono le principali;
print type(int(‘2’)) Python
print type(float(3))
print type(str(2))
print 1 + 2.5
print 2 / 3
print 2 / 3.
print ‘1 2 ‘ + 3 # errore
print ‘1 2 ‘ + str(3)
print ‘1 2 %d’ % 3

16. Librerie
● Keyword “import”
● Librerie e moduli personali:
● __init__.py
import os Python
from sys import exit
print os.getcwd()
exit() # invece di sys.exit()

17. Condizioni
● if condizione ... elif condizione … else
● Operatore ternario: condizione if … else …
● Non esiste lo switch!
● Per concatenare più espressioni si usano:
● keyword “or”;
● keyword “and”;
if 3 > 2: Python
print True
else: # non obbligatorio
print False
if 3 > 4:
print True
elif 3 > 2: # non obbligatorio
print True
else: # non obbligatorio
print False
if 3 < 5 < 7:
print True
print True if 3 > 2 else False

18. Cicli
● for:
● Accesso diretto ai valori in liste e tuple;
● Accesso diretto alle chiave dei dizionari;
● for … else:
● Identico al for, ma se il ciclo termina senza
interruzioni viene richiamato l’else;
● while:
● Ciclo condizionale;
● Non esiste il do-while!
● Per interrompere un ciclo: break;
● Per saltare alla prossima iterazione: continue;
for i in xrange(10): Python
print i
for i in xrange(10):
print i
else:
print True
i = 0
while i < 10:
i += 1

19. Operatori utili
● in:
● Verifica se un elemento è presente
in una lista;
● not:
● Operatore di negazione;
● is:
● Operatore di confronto (identità);
● Da non utilizzare per confrontare valori!
● Utilizzato per lo più per i confronti con valori
nulli;
a = [1, 2, 3] Python
for i in a:
print i
if 2 in a:
print True
if a is not None:
print True
b = [1, 2, 3]
print a == b # True
print a is b # False

20. Eccezioni
● try … except:
● Permette di gestire le eccezioni;
● try … except … else:
● Se l’eccezione non viene lanciata, verrà
eseguito l’else;
● try … except … finally:
● Il finally viene sempre eseguito;
● Se l’eccezione non viene gestita prima del
finally questa viene lanciata di nuovo!
● raise:
● Lancia un’eccezione;
try: Python
print q
except NameError as e:
print e
else:
print ‘OK’
finally:
print ‘fine’

21. Funzioni
● Keyword “def”;
● Argomenti opzionali e non tipizzati;
● Ogni funzione può tornare o meno dei dati,
utilizzare la keyword “return”;
● Return dinamico, possono ritornare
uno o più dati (verrà creata una tupla);
● Argomenti con *:
● *args: crea una lista con gli
elementi passati alla funzione;
● **kwargs: crea un dizionario
con gli elementi passati alla funzione;
Python
def print_nome(nome, cognome=None):
s = ‘Ciao ‘ + nome
if cognome is not None:
s += ‘ ‘ + cognome
print s
def moltiplica(num, *args):
molt = None
if len(args) == 0:
molt = [2, 3, 4]
else:
molt = args[:]
return num*molt[0], num*molt[1], num*molt[2]
nome = raw_input(‘Come ti chiami?’)
print_nome(nome)
n1, n2, n3 = moltiplica(2)

22. Classi
● Dato “astratto” che definisce un oggetto;
● Attributi (dati interni) e metodi (azioni);
● I dati sono solo pubblici! (underscore “_” per convenzione “private”);
● Accesso alle componenti interne della classe tramite self.componente;
● Ereditarietà “multipla”, polimorfismo;
● Ogni classe eredità da object;

23. Classi - Attributi e metodi
● Gli attributi possono essere definiti:
● All’esterno dei metodi (no self), devono essere inizializzati!
● All’interno dei metodi (usare self);
● Gli attributi una volta definiti sono globali all’interno della classe;
● I metodi sono definiti:
● in modo simile alle funzioni con la keyword “def”;
● il primo argomento deve essere self
● Per accedere ad attributi e metodi si utilizza l’operatore “.”;
● L’utilizzo del doppio underscore prima del nome dell’elemento
(e al più un underscore dopo il nome) causa name mangling.
class Auto: Python
marca = None
def set_marca(self, marca):
self.marca = marca.tolower()
self.sigla_marca = self.marca[0:2]

24. Funzioni di aiuto
● dir(object) stampa in una lista tutti i metodi e attributi dell’oggetto;
● help(object) visualizza la documentazione relativa all’oggetto se presente;

25. Classi - Subclassing, costruttore
● Ogni classe estende implicitamente “object”;
● Per estendere una classe si usano le parentesi tonde;
● E’ possibile estendere più di una classe;
● Il costruttore di ogni classe è il metodo __init__;
● Per richiamare la superclasse è possibile usare il metodo super;
class Auto(Telaio): Python
marca = None
def __init__(self, marca):
super(Auto, self).__init__()
self.marca = marca.tolower()

26. Utilizzo
● Web development:
● Django;
● Bottle;
● Flask;
● App Engine;
● Standalone development & GUI:
● wxPython;
● PyQt;
● TkInter;
● Scientific calculus:
● SciPy;
● Matplotlib;
● “Anaconda”;

27. Utility
● “IDE”:
● Editor di testo (Sublime Text);
● PyCharm;
● Spyder;
● Installazione automatica moduli:
● pip; (pip install module_name)
● easy_install; (easy_install module_name)
● Installazione manuale moduli:
● python setup.py install;
● Eseguibili:
● pyinstaller;
● py2exe;
● py2app;

28. Demo

29. <Thank You!>
email:
emanuel.dinardo@gmail.com
G+ plus.google.com/+EmanuelDiNardo
twitter @bboymasa
website http://emanueldinardo.com