Introduzione a Python – Ecosistema Python e usi specifici

Python è un linguaggio di programmazione universale, versatile e popolare. È ottimo come primo linguaggio di programmazione per la sua compattezza e semplicità, ma è anche un fondamentale linguaggio nella cassetta degli atrezzi di qualsiasi programmatore per la sua versatilità e disponibilità di librerie. Python viene utilizzato per svariati compiti che vanno dall’analisi di dati, allo sviluppo web, dallo scripting di sistema alla realizzazione di applicazioni scientifiche.

L’intento di questo mini corso di due puntate è quello di fornire a principianti e utenti con una conoscenza di base di programmazione una visione di Python e del suo ecosistema. Alla fine del corso, avrai familiarità con la sintassi di Python e sarai in grado di mettere in pratica quello che avrai imparato.

Transcript

1. Introduzione a python Seconda serata - Ecosistema Python e usi speci ci Enrico Bacis ( UniBG & BgLUG ) 24 maggio 2017
2. Calendario 10 maggio: Funzionalità di base e strutture dati 24 maggio: Ecosistema Python e usi speci ci
3. Errori ed Eccezioni Python è un linguaggio interpretato e dinamicamente tipato, quindi non c'è una fase di compilazione in cui vengono controllati i tipi. Tutti gli errori sono posticipati a runtime (solo se viene eseguito del codice che produce errori)
4. Errori di sintassi Sono i più comuni da commettere per chi sta imparando Python :-) Accadono quando scriviamo una istruzione in maniera sintatticamente errata L'interprete Python non riesce a capirne il signi cato e quindi non può eseguirla # while return print('Hello?') # ??????
5. Eccezioni Rappresentano il veri carsi di situazioni eccezionali Per esempio, cosa succede se stiamo tentando di leggere un le che non esiste? O se lo eliminiamo mentre il nostro programma è in esecuzione?
7. def divide_by_zero(x): # errore se chiamato return x / 0 divide_by_zero(5) --------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) <ipython-input-4-03e025ce82c2> in <module>() ----> 1 divide_by_zero(5) <ipython-input-3-2fdc682b2c6c> in divide_by_zero(x) 1 def divide_by_zero(x): ## errore se chiamato ----> 2 return x / 0 ZeroDivisionError: division by zero
8. try / except Il blocco try / except ci permette di eseguire del codice se si veri ca uno stato di eccezione x = 4 try: print(x, 'diviso 2 =', x / 2) print(x, 'diviso 1 =', x/ 1) print(x, 'diviso 0 =', x/ 0) except ZeroDivisionError: print('non si può dividere per zero') 4 diviso 2 = 2.0 4 diviso 1 = 4.0 non si può dividere per zero
9. sollevare eccezioni In alcuni casi può essere utile sollevare delle eccezioni Per esempio quando una funzione non è in grado di gestire alcuni input Dovranno essere gestite (catturate) dal chiamante della funzione, altrimenti l'utente vedrà un messaggio di errore def invia_email(email, testo): if '@' not in email: raise ValueError("email non valida") # [..] return True
10. invia_email('rms@gnu.org', 'I like Linux') invia_email('rmsgnu.org', 'GNU/Linux') True --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-8-2251df38c004> in <module>() ----> 1 invia_email('rmsgnu.org', 'GNU/Linux') <ipython-input-6-c66205aad977> in invia_email(email, testo) 1 def invia_email(email, testo): 2 if '@' not in email: ----> 3 raise ValueError("email non valida") 4 # [..] 5 return True ValueError: email non valida
11. Files Aprire le open(filename, mode) ritorna un riferimento al le Il parametro mode speci ca la modalità | mode | descrizione | | ---- | ------------------------------- | | 'r' | Apertura in sola lettura | | 'w' | Apertura in sola scrittura | | 'r+' | Apertura in lettura e scrittura | | 'a' | Scrittura in coda |
12. Possiamo interagire con il le tramite i metodi dell'oggetto le (read, readline, write, writeline, close) Ricordiamoci di chiudere sempre il le una volta nito di usarlo, con il metodo close.
13. f = open('test.txt', 'w') f.write("hello\n") f.close() f = open('test.txt', 'r') print(f.readline()) f.close() hello
14. Pythonic Programming
15. Context Manager Sono de niti dal costrutto with seguito da un blocco Permettono di eseguire del codice prima e dopo il blocco
16. open() prima del blocco apre il le, dopo il blocco lo chiude. open() ritorna una instanza e assume all’interno del blocco il nome f f fuori dal blocco non è più utilizzabile per leggere e scrivere sul le with open('test.txt', 'r') as f: for line in f: print line print("read completed")
17. Easier to ask for forgiveness than permission (EAFP) Invece di: my_dict = {'uno': 1, 'due': 2} if "key" in my_dict: x = my_dict["key"] else: print('no key') no key
18. meglio: try: x = my_dict["key"] except KeyError: print('no key') no key
19. True-ish e False-ish bool([]), bool(""), bool({}) bool([1,2]), bool("hello"), bool({1, 2}) (False, False, False) (True, True, True)
20. invece di: meglio: lista = [1,2,3,4] while len(lista) != 0: print(lista.pop()) lista = [1,2,3,4] while lista: print(lista.pop()) 4 3 2 1 4 3 2 1
21. if ternario z = x if condizione else y 1 if True else 2 1
22. Built-ins Sono funzioni sempre disponibili
23. enumerate scorrere una lista insieme al suo indice for idx, elemento in enumerate(['a', 'b', 'c']): print(idx, elemento) # meglio che accesso casuale list(enumerate(['a', 'b', 'c'])) 0 a 1 b 2 c [(0, 'a'), (1, 'b'), (2, 'c')]
24. zip Unire due liste come in una cerniera (zip) lista_1 = ['dieci', 'cento', 'mille'] lista_2 = [10, 100, 1000] list(zip(lista_1, lista_2)) [('dieci', 10), ('cento', 100), ('mille', 1000)]
25. altre built-ins interessanti any([False, False, True]) all([True, False]) sum([10**5, 10**3, 10**1]) True False 101010
26. Programmazione funzionale - In informatica la programmazione funzionale è un paradigma di programmazione in cui il usso di esecuzione del programma assume la forma di una serie di valutazioni di funzioni matematiche. Il punto di forza principale di questo paradigma è la mancanza di effetti collaterali (side- effect) delle funzioni, il che comporta una più facile veri ca della correttezza e della mancanza di bug del programma e la possibilità di una maggiore ottimizzazione dello stesso. wikipedia.it
27. - Si chiama funzionale perché il suo concetto di base risiede nella funzione, ma nel senso matematico del termine. Le funzioni dei linguaggi procedurali o imperativi sono realmente delle procedure piuttosto che delle funzioni e svolgono in questo senso delle pure direttive di calcolo. La funzione matematica invece non esegue calcoli ma si limita a mappare valori e viene de nita infatti, come una: trasformazione o mappa od operatore; essa applica un argomento di un certo valore dall'interno di un dominio verso un'altro dominio, detto codominio pragmas.org
29. Altro paradigma Strutture dati immutabili (no side effects) Uso di ricorsioni Lazy evaluation
30. Funzioni di ordine superiore le funzioni sono solo un altro tipo di dato Si possono ricevere funzioni come argomento def my_map(f, lista): risultato = [] for x in lista: risultato.append( f(x) ) return risultato
31. map Applica una funzione ad ogni elemento di una collezione def quadrato(x): return x ** 2 map(quadrato, [1, 2, 3]) list(map(quadrato, [1, 2, 3])) <map at 0x7f6f7883c4e0> [1, 4, 9]
32. lter Restituisce una sequenza con i soli elementi che veri cano il predicato def is_positive(x): return x > 0 list(filter(is_positive, [1, -1, 2, -3])) [1, 2]
33. Funzioni Anonime (lambda) genera una funzione uguale a: square = lambda x: x ** 2 def square(x): return x ** 2
34. Ora ci è possibile scrivere map(lambda x: x ** 2, [1, 2, 3]) <map at 0x7f6f78830c18>
35. Generatori
36. Lazy evaluation (di default in python3) Risparmio di memoria e di computazioni yield al posto di return transorma una funzione in un generatore Si effettua uno yield di ogni elemento che si vuole ritornare
37. Generatore in nito di numeri def numbers(start=0): while True: yield start start += 1 numbers() <generator object numbers at 0x7f6f78895c50>
38. scorrere i valori di un generatore usando un ciclo for la funzione next(...) ritorna il seguente risultato del generatore gen = numbers() for x in gen: if x > 3: break else: print(x) next(gen) 0 1 2 3 5
39. Fibonacci def fibonacci(): prec, curr = (0, 1) while True: yield curr prec, curr = (curr, prec + curr) f = fibonacci() type(f) generator
40. next(f) for i in range(10): print(next(f)) 1 1 2 3 5 8 13 21 34 55 89
41. [approfondimento] numeri primi def generate_primes(): primes = [] for x in numbers(start=2): if not any(x % prime == 0 for prime in primes): primes.append(x) yield x gen = generate_primes() for i in range(8): print(next(gen)) 2 3 5 7 11 13 17 19
42. Programmazione ad oggetti Nella programmazione ad oggetti (OOP) si modella il problema come un insieme di entità comunicanti tra loro Si racchiudono insieme le variabili ed il codice che le modi ca In Python tutto è un oggetto
43. Classi e istanze una classe crea un nuovo tipo, mentre gli oggetti sono istanze di una classe Le funzioni type e isinstance permettono di ottenere informazioni sul tipo di un oggetto type("bglug") isinstance("bglug", str) isinstance("bglug", bool) str True False
44. Cos’è una classe un contenitore di variabili e funzioni le funzioni modi cano queste variabili le variabili si chiamano attributi le funzioni si chiamano metodi
45. Cos’è un’oggetto È quando una classe prende vita. Si dice che oggetto è una istanza di Classe. class Classe: pass oggetto = Classe() print(oggetto) <__main__.Classe object at 0x7f6f788a1518>
46. Guardare dentro agli oggetti Il comando dir() restituisce il contenuto di un oggetto, attributi e metodi. ', '.join( dir("hello") ) '__add__, __class__, __contains__, __delattr__, __dir__, __doc__, __eq__, __ format__, __ge__, __getattribute__, __getitem__, __getnewargs__, __gt__, __h ash__, __init__, __iter__, __le__, __len__, __lt__, __mod__, __mul__, __ne_ _, __new__, __reduce__, __reduce_ex__, __repr__, __rmod__, __rmul__, __setat tr__, __sizeof__, __str__, __subclasshook__, capitalize, casefold, center, c ount, encode, endswith, expandtabs, find, format, format_map, index, isalnu m, isalpha, isdecimal, isdigit, isidentifier, islower, isnumeric, isprintabl e, isspace, istitle, isupper, join, ljust, lower, lstrip, maketrans, partiti on, replace, rfind, rindex, rjust, rpartition, rsplit, rstrip, split, splitl ines, startswith, strip, swapcase, title, translate, upper, zfill'
47. La variabile self Il primo parametro di ogni metodo è sempre l’istanza su cui si sta operando Convenzionalmente si chiama self La funzione __init__ inizializza l’oggetto (costruttore) class Contatore(): def __init__(self, iniziale=0): self.numero = iniziale def aumenta(self, incremento=1): self.numero += incremento c = Contatore(iniziale=5) c.aumenta(2) print(c.numero) 7
48. Underscores Perché tutti questi underscore? È una convenzione. variabile: variabile generica _variabile: variabile privata. È consigliato non modi carla né usarla __variabile: variabile interna. Modi carla potrebbe creare problemi
49. Duck typing «If it looks like a duck, walks like a duck and quacks like a duck then it just may be a duck» —Walter Reuther «Se un oggetto ha un metodo read(), write() e seek(), ush(), … allora è un le» —Python
50. __getitem__() È possibile creare una classe che si comporta come una lista. Possiamo accedere ai suoi elementi usando la sintassi oggetto[indice] class Tabellina6(): def __getitem__(self, i): return 6 * i t = Tabellina6() t[7] 42
51. Altri metodi interessanti '*' --> __mul__(self, x) '+' --> __add__(self, x) print --> __str__(self) Per una lista più esaustiva ( ) https://docs.python.org/3/reference/datamodel.html
52. Ereditarietà Permette di de nire specializzazioni delle classi (sottoclassi) La classe glio ottiene attributi e metodi dalla classe padre ma può aggiungerne dei suoi speci ci Utile per creare gerarchie
53. class Animale: def __init__(self, peso): self.peso = peso class Gatto(Animale): # ... def miagola(): pass
54. Moduli I le contenenti codice Python hanno estensione .py Ogni le è un modulo È possibile importare variabili, funzioni e classi da altri moduli con l’istruzione import
55. modulo.py programma.py default_lim = 3 def conta(lim=default_lim): for x in range(lim): print(x) import modulo x = modulo.default_lim + 2 modulo.conta(x)
56. from ... import ... È possibile importare solo alcuni elementi da un modulo con la sintassi from <modulo> import <oggetto> Si omette il modulo di provenienza
57. modulo.py programma.py default_lim = 3 def conta(lim=default_lim): for x in range(lim): print(x) from modulo import default_lim, conta x = default_lim + 2 conta(x)
58. __name__ La variabile __name__ Contiene il nome del modulo È utile per sapere se un modulo è stato importato o se è stato eseguito direttamente __name__ if __name__ == '__main__': print('Programma eseguito direttamente') else: print('Questo modulo è stato importato') '__main__' Programma eseguito direttamente
59. I moduli possono derivare da: locale (come appena visto) standard library esterno
60. Moduli della Standard Library Python dispone di numerosi moduli già inclusi ma dove li cerco? buona lettura https://docs.python.org/3/library/
61. : funzioni matematiche : strutture dati particolari : simili a struct C (tuple con nomi) : contano le occorrenze di elementi : dizionari con valori di default : per espressioni regolari math collections namedtuple Counter defaultdict re
62. : espansione di nomi (alla bash) : parsing di stringhe in formato json (da cui avete ricevuto la mail) : interazione con database SQLite : gestione automatica di le in memoria (anche spooled) e : avvio di altri programmi e altre utilità di sistema e : programmazione concorrente glob json smtplib sqlite3 tempfile os subprocess multiprocessing threading
63. argparse creazione sempli cata di command line interfaces (CLI) from argparse import ArgumentParser parser = ArgumentParser(description="Encode a video") parser.add_argument('INPUT', help="input filename") parser.add_argument('OUTPUT', help="output filename") parser.add_argument('-b', '--bitrate', default=2000) parser.add_argument('-c', '--compression', default=1) args = parser.parse_args() print(args.INPUT)
64. $ python test.py --help usage: test.py [-h] [-b BITRATE] [-c COMPRESSION] INPUT OUTPUT Encode a video positional arguments: INPUT input filename OUTPUT output filename optional arguments: -h, --help show this help message and exit -b BITRATE, --bitrate BITRATE -c COMPRESSION, --compression COMPRESSION
65. moduli esterni Le capacità del linguaggio si possono estendere con moduli esterni È possibile installare ulteriori moduli tramite pip
66. Pip, PyPI e virtualenv (o pew) pip (pip2, pip3) è un tool per installare e gestire pacchetti python replacement di easy_install PyPI (Python Package Index) è un repository di pacchetti (attualmente 108947), installabili via pip virtualenv è un tool per creare python environment isolati https://pypi.python.org/pypi
67. Perché usare virtual environments isolamento - diverse versioni delle stelle librerie nel sistema permessi - non serve essere nei sudoers organizzazione - ogni progetto ha le sue librerie
68. Installare pip Dovrebbe già essere installato su Linux e OSX Se non è installato: sudo apt-get install python-pip sudo easy_install pip Alla brutta: Scaricare Eseguire con python ( python3 get-pip.py ) https://bootstrap.pypa.io/get-pip.py
69. Installare virtualenv sudo pip install virtualenv o meglio pip install --user virtualenv
70. Avete anche imparato ad usare pip
71. Usare virtualenv virtualenv venv # cartella dove creare il virtual environment source venv/bin/activate ..... deactivate
72. Librerie interessanti
73. Gooey
74. prima: def main(): parser = ArgumentParser(...) # rest of code
75. dopo: from gooey import Gooey @Gooey def main(): parser = ArgumentParser(...) # rest of code
76. requests >>> r = requests.get('https://api.github.com/user', auth=('user', 'pass')) >>> r.status_code 200 >>> r.text u'{"type":"User"...' >>> r.json() {u'private_gists': 419, u'total_private_repos': 77, ...}
77. millemila altre
78. Links e bibliogra a Python tutorial Altri Notebooks Python Corsi Python POUL (a cui si è ispirata questa presentazione) Peter Norvig - Design of Computer Programs
79. Queste slides sono licenziate Creative Commons Attribution-ShareAlike 3.0 Unported