Introduzione a Python – Funzionalità di base e strutture dati

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 Prima serata - Funzionalità di base e strutture dati Enrico Bacis ( UniBG & BgLUG ) 10 maggio 2017
2. Calendario 10 maggio: Funzionalità di base e strutture dati 24 maggio: Ecosistema Python e usi speci ci
3. Avviso
4. Python Python è un linguaggio di programmazione di alto livello. Creato nei primi anni '90 dal programmatore olandese Guido van Rossum ( ) che gli diede questo nome per la sua passione per i Monty Python. BDFL
5. Caratteristiche di Python Facile da imparare (la sintassi è semplice ed elegante) Standard library estesa (batteries included) Documentazione eccellente, community ed ecosistema maturi Linguaggio interpretato (non necessita di compilazione) Variabili dinamicamente tipate a = 1 a = "hi"
6. Caratteristiche di Python Sia gli interpreti che il linguaggio stesso sono Open Source Strutture dati di alto livello (liste, tuple, insiemi, dizionari, ...) Sviluppo rapido multi-piattaforma (sintassi compatta e tooling) Multi-paradigma (imperativo, object-oriented, funzionale) Ottimo per: sviluppo web, tool di sistema, scripting Utilizzato da Google, Yahoo, IBM, Nasa, ...
8. Svantaggi di Python • non adatto per: sviluppo mobile (ma esiste ), giochi 3D • è lento si ma, è un linguaggio dinamico • è lento si ma, è un linguaggio interpretato • È LENTO!!! SI OK, È LENTO, ma sappiamo come velocizzarlo ;) Kivy
9. 1. Python può essere esteso facilmente con codice C (è spesso utilizzato come **linguaggio colla** per rendere accessibili librerie sviluppate in altri linguaggi) 2. Non esiste un solo interprete, il termine _python_ infatti indica solo una sintassi, esistono poi vari interpreti. L'interprete di default si chiama CPython pypy è un'altro interprete estremamente veloce (JIT) scritto in python ( ¯\_(ツ)_/¯ it's obscure )
10. Installazione Linux: dovrebbe esserci già (digitate python3 nel terminale). Windows Mac OS X
11. L'interprete (o REPL) REPL = Read Eval Print Loop esistono REPL online: $ python3 Python 3.5.3 (default, Jan 19 2017, 14:11:04) [GCC 6.3.0 20170118] on linux Type "help", "copyright", "credits" or "license" for more information. >>> repl.it
12. Editor vi(m) / emacs (sempre la scelta migliore) pycharm (versione community open source) pydev (plugin per eclipse) sublimetext / limetext atom gedit / geany
13. Hello World!
14. C #include <stdio.h> int main() { printf("hello, world\n"); return 0; }
15. Java public class HelloWorld { public static void main(String[] args) { System.out.println("hello, world"); } }
16. Python 3 print("hello, world!") hello, world!
18. Perché Python 3?
19. Python 2 Python 3 chi inizia oggi a programmare in python dovrebbe usare python3 print "hello, world" print("hello, world")
20. Prima di continuare - le regole
21. import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those!
22. Le basi
23. Commenti # questo è un commento singola riga """ tre apici indicano una stringa multi-riga spesso viene usata come commento multi-riga o come documentazione """ 1 + 1 # posso commentare a fondo riga 2
24. Variabili Possiamo associare nomi a valori ed usarli per riferirci ai valori x = 8 3 * x y = x + 4 y y = z = 2.5 print(x, y, z) 24 12 8 2.5 2.5
25. Python è dinamicamente tipato x = 1 print(x) x = "hello" print(x) 1 hello
26. input dall'utente Ci sono casi in cui vogliamo che il nostro programma interagisca con l'utente. Per esempio chiedendo di inserire dei valori di ingresso (input) all'utente e stampando dei risultati in output. Useremo input() per ricevere dei valori e print() per stamparli. nome = input('Inserisci il tuo nome: ') print('hello,', nome) Inserisci il tuo nome: enrico hello, enrico
27. input in python 3 restituisce sempre una stringa, sta a noi poi convertirlo al tipo che vogliamo int("100") float("123.45") int("100", 2) 100 123.45 4
28. Tipi
29. Booleani Possono assumere solo i valori True o False True or False True and False True False
30. Il risultato degli operatori <, <=, ==, !=, >=, > è un booleano 1 == 'a' 2.5 < 3 'a' < 'b' False True True
31. (10 < 4) or (2 + 2 == 4) not (2 < 3) True False
32. Numeri x = 10 type(x) pi = 3.14 type(pi) googol = 10 ** 100 # 10 alla 100 googol type(googol) int float 1000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000 int
33. Altri operatori Simili a quelli di C 17 / 3 # la divisione ritorna sempre un float (python 3) 17 // 3 # divisione intera (SCARTA la parte decimale) 17 % 3 # resto della divisione 17 == 5 * 3 + 2 # dividendo = quoziente * divisore + resto 5.666666666666667 5 2 True
34. Stringhe Le stringhe possono essere racchiuse tra apici ('...') o doppi apici ("...") Il carattere di escape è "\". s = "Hello" len(s) "questa è una stringa" 'anche questa è una stringa' 'posso usare "doppi apici" ma devo fare attenzione con gli \'apici\'.' 5 'posso usare "doppi apici" ma devo fare attenzione con gli \'apici\'.'
35. Come usare "\" nelle stringhe? Easy, Use Linux! print('C:\Windows\dir\name') C:\Windows\dir ame
36. doppio backslash oppure print('C:\\Windows\\dir\\name') print(r'C:\Windows\dir\name') # raw strings (notare la r iniziale) # comodo per espressioni regolari C:\Windows\dir\name C:\Windows\dir\name
37. Costruzione di stringhe Esistono vari modi per costruire stringhe a partire da variabili, il più facile è la sintassi "alla C". i = 5 "l'intero i vale %d" % i "la stringa s di prima era '%s'" % s f = 2.5 "il valore di f è %f" % f "l'intero i vale 5" "la stringa s di prima era 'Hello'" 'il valore di f è 2.500000'
38. Altre operazioni sulle stringhe Le stringhe possono essere concatenate con il "+", e ripetute con "*": # "na" * 16 + " Batman!"
40. Altre operazioni sulle stringhe Le stringhe possono essere concatenate con il "+", e ripetute con "*": "na" * 16 + " Batman!" 'nananananananananananananananana Batman!'
41. Le stringhe possono essere indicizzate partendo dall'indice 0. Non esiste il tipo carattere. Un carattere è una stringa di lunghezza 1. Gli indici possono anche essere negativi, per iniziare a contare da destra: word = "Python" word[0] # carattere in posizione 0 word[5] # carattere in posizione 5 word[-1] # ultimo carattere word[-6] 'P' 'n' 'n' 'P'
42. Slicing Come indicizzazione ma si usa sintassi [from:to] +---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1 word[0:2] # caratteri dall'indice 0 (incluso) al 2 (escluso) word[2:5] # caratteri dall'indice 2 (incluso) al 5 (escluso) 'Py' 'tho'
43. Se "from" omesso -> inizio stringa Se "to" omesso -> ne stringa word[:3] word[3:] 'Pyt' 'hon'
44. Possibile anche speci care "step" (passo) con sintassi [from:to:step] word[::2], word[1::2] word[::-1] # step negativo -> from: fine, to: inizio ('Pto', 'yhn') 'nohtyP'
45. Le stringhe sono immutabili Se serve, creane altre word[0] = 'J' # errore 'J' + word[1:] word[:2] + 'py' --------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-7-7227217c78fc> in <module>() ----> 1 word[0] = 'J' # errore NameError: name 'word' is not defined 'Jython' 'Pypy'
46. Liste, Tuple, Dizionari Lista: [4, "abc", 4.3] Tupla: (4, "abc", 4.3) Dizionario: {"a": 3, "b": 42} (le vedremo meglio nel capitolo strutture dati)
47. Strutture di controllo if, while, for
48. if Permette di eseguire istruzioni solo al veri carsi di certe condizioni
49. x = int(input("x: ")) y = int(input("y: ")) if x > y: # da notare: per identificare i blocchi si usano 4 spazi # tutte le istruzioni del blocco devono avere stessa indentazione print(x, "è maggiore di", y) x: 10 y: 5 10 è maggiore di 5
50. x = int(input("x: ")) y = int(input("y: ")) if x > y: print(x, "è maggiore di", y) else: print(x, "non è maggiore di", y) x: 10 y: 20 10 non è maggiore di 20
51. x = int(input("x: ")) y = int(input("y: ")) if x > y: print(x, "è maggiore di", y) elif x == y: print(x, "è uguale a", y) else: print(x, "è minore di", y) x: 10 y: 10 10 è uguale a 10
52. while Eseguire più volte le stesse istruzioni ( ntantoché una condizione è vera) x = 0 while x < 3: x = x + 1 print("x =", x) x = 1 x = 2 x = 3
53. for Cicli di esecuzione sulle sequenze for i in [0, 1, 2, 3, 4]: print("i =", i) i = 0 i = 1 i = 2 i = 3 i = 4
54. range
55. help(range) Help on class range in module builtins: class range(object) | range(stop) -> range object | range(start, stop[, step]) -> range object | | Return an object that produces a sequence of integers from start (inclus ive) | to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j- 1. | start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3. | These are exactly the valid indices for a list of 4 elements. | When step is given, it specifies the increment (or decrement). | | Methods defined here: | | __contains__(self, key, /) | Return key in self. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /)
56. | Return hash(self). | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signatu re. | | __reduce__(...) | helper for pickle | | __repr__(self, /) | Return repr(self). | | __reversed__(...) | Return a reverse iterator. | | count(...) | rangeobject.count(value) -> integer -- return number of occurrences of value | | index(...) | rangeobject.index(value, [start, [stop]]) -> integer -- return index of value. | Raise ValueError if the value is not present.
57. for i in range(4): print(i) range(10 ** 1000) 0 1 2 3 range(0, 1000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000)
58. break, continue break: interrompe l'iterazione continue: salta all'iterazione successiva for i in [0, 1, 2, 3, 4, 5, 6, 7]: if i == 2: continue if i == 6: break print(i) 0 1 3 4 5
59. Funzioni sequenze di istruzioni con degli ingressi e un'uscita abs(-3) min([10, 4, 2, 50]) print(1, 2, 3) 3 2 1 2 3
60. De nizione di funzioni def test(): pass
61. Parametri e argomenti Valori che provengono dall'esterno (input) e che servono alla funzione def test(a, b): print('a + b =', a + b) test(10, 5) a + b = 15
62. Argomenti di default Se omettiamo un parametro, la funzione userà quello di default def say(message, times=1): print(message * times) say('Hello') say('na', 16) Hello nananananananananananananananana
63. Keyword arguments Invece che passare gli argomenti in ordine, possiamo chiamarli per nome def func(a, b=5, c=10): print('a is', a, 'and b is', b, 'and c is', c) func(3, 7) func(25, c=24) func(c=50, a=100) a is 3 and b is 7 and c is 10 a is 25 and b is 5 and c is 24 a is 100 and b is 5 and c is 50
64. Approfondimento: Varargs possiamo accettare tutti i parametri che ci vengono passati, sia quelli passati in ordine, sia quelli passati assieme ad un nome def test(*args, **kwargs): print(type(args), args) print(type(kwargs), kwargs) test(1, 2, 3, a=4, b=5) <class 'tuple'> (1, 2, 3) <class 'dict'> {'b': 5, 'a': 4}
65. return statement Tramite il comando return diciamo quale è l'output della funzione def square(x): return x ** 2 square(5) 25
66. In python è comodo restituire più valori: def powers(x): return x ** 2, x ** 3, x ** 4 # crea una tupla powers(5) (25, 125, 625)
67. Documentazione con le docstrings Fact: passati tre mesi da quando avete scritto un pezzo di codice, non saprete più cosa fa.
68. def print_max(x, y): """Prints the maximum of two numbers. The two values must be integers.""" x = int(x) y = int(y) if x > y: print(x, 'is maximum') else: print(y, 'is maximum') help(print_max) Help on function print_max in module __main__: print_max(x, y) Prints the maximum of two numbers. The two values must be integers.
69. Strutture Dati Liste, tuple, insiemi, dizionari
70. Liste Le liste contengono una sequenza ordinata di oggetti Sono mutabili: possono essere alterate aggiungendo, modi cando o rimuovendo elementi Si de niscono separando gli elementi con le virgole e racchiudendoli tra parentesi quadre quadrati = [1, 4, 9, 16] print(type(quadrati), quadrati) <class 'list'> [1, 4, 9, 16]
71. Come le stringhe (ed ogni altro tipo "sequence"), le liste possono essere indicizzare e tagliate (slicing): quadrati[0] # l'indicizzazione ritorna l'elemento quadrati[2:] # slicing ritorna una nuova lista 1 [9, 16]
72. quadrati[0] = "UNO" # le liste sono mutabili quadrati quadrati = [1, 4, 9, 16] quadrati.append(25) quadrati quadrati = [1, 2, 4, 9, 16] # indice: 0 1 2 3 4 del quadrati[1] quadrati ['UNO', 4, 9, 16] [1, 4, 9, 16, 25] [1, 4, 9, 16]
73. lista = [30, 60, 40, 10, 20, 80, 90, 50, 70, 60] lista.extend([10, 20, 30]) lista lista.sort() lista lista.count(10) lista.index(30) [30, 60, 40, 10, 20, 80, 90, 50, 70, 60, 10, 20, 30] [10, 10, 20, 20, 30, 30, 40, 50, 60, 60, 70, 80, 90] 2 4
74. List Comprehension Python sempli ca la generazione de nendo il risultato che si vuole ottenere. Per esempio se dobbiamo generare i primi 10 quadrati possiamo scrivere un ciclo for: La sintassi delle list comprehension è.. più facile da vedere che da spiegare res = [] for i in range(1, 11): x = i ** 2 res.append(x) print(res) [i ** 2 for i in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
75. Possiamo anche aggiungere delle condizioni [i ** 2 for i in range(1, 11) if i % 2 == 0] [4, 16, 36, 64, 100]
76. Tuple (42, "hello", 3.14) Le tuple raggruppano elementi Simili alle liste, ma immutabili Si de niscono separando gli elementi con le virgole e racchiudendoli tra parentesi tonde
77. t = () # tupla con zero elementi print(type(t), t) t = (42) print(type(t), t) t = (42,) # necessario la virgola print(type(t), t) <class 'tuple'> () <class 'int'> 42 <class 'tuple'> (42,)
78. # tuple unpacking a, b, c = (42, "hello", 3.14) print(a, b, c) # le tuple si usano per costruire stringhe con più elementi "a: %d, b: %s, c: %f" % (a, b, c) 42 hello 3.14 'a: 42, b: hello, c: 3.140000'
79. Sequenze Liste, tuple e stringhe sono sequenze, quindi possibile indicizzazione, slicing, e controllo di appartenenza: quadrati = [1, 4, 9, 16, 25] 9 in quadrati 10 not in quadrati True True
80. Insiemi (set) {'mela', 'pera', 'banana'} Un set è una collezione non ordinata di oggetti senza elementi duplicati Supportano le operazioni matematiche degli insiemi come unione, intersezione, differenza Si de niscono separando gli elementi con le virgole e racchiudendoli tra parentesi graffe set('abracadabra') {'a', 'b', 'c', 'd', 'r'}
81. s1 = {1, 2, 3, 4} s2 = {3, 4, 5, 6} s1.add(0) s1 s1.union(s2) s1.intersection(s2) {0, 1, 2, 3, 4} {0, 1, 2, 3, 4, 5, 6} {3, 4}
82. Dizionari Permettono di associare chiavi a valori E recuperare un valore in maniera ef ciente conoscendo la relativa chiave Sono simili ad una rubrica con cui possiamo recuperare l'email (valore) di una persona sapendo solo il suo nome (chiave): rubrica = { "Linus Torvalds": " torvalds@linux-foundation.org", "Richard Stallman": "rms@gnu.org", } rubrica["Linus Torvalds"] ' torvalds@linux-foundation.org'
83. print(rubrica["Enrico Bacis"]) print(rubrica.get("Enrico Bacis")) rubrica.keys() rubrica.values() rubrica.items() --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-3-f43809e926cf> in <module>() ----> 1 print(rubrica["Enrico Bacis"]) KeyError: 'Enrico Bacis' None dict_keys(['Richard Stallman', 'Linus Torvalds']) dict_values([' torvalds@linux-foundation.org', 'rms@gnu.org']) dict_items([('Linus Torvalds', ' torvalds@linux-foundation.org'), ('Richard Stallman', 'rms@gnu.org')])
84. Quando usare liste, tuple, set o dizionari? liste: conta l'ordine, ammettono duplicati, modi cabili tuple: conta l'ordine, non modi cabili set: non conta l'ordine, modi cabili, controllo di appartenenza estremamente veloce esiste anche la versione non modi cabile: frozenset dizionari: non conta l'ordine, modi cabili, chiavi non numeriche, elementi non determinabili a priori
85. Riferimenti e puntatori
86. Riferimenti e puntatori Quando assegnamo un oggetto ad una variabile, la variabile contiene solo un riferimento all'oggetto e non l'oggetto stesso. spesa_a = ['mela', 'mango'] spesa_b = spesa_a spesa_b.append('carota') spesa_b spesa_a ['mela', 'mango', 'carota'] ['mela', 'mango', 'carota']
87. spesa_a is spesa_b spesa_c = spesa_a[:] spesa_a == spesa_c spesa_a is spesa_c True True False
88. Links e bibliogra a Python tutorial Altri Notebooks Python Corso Python POUL (a cui si è ispirata questa presentazione) Peter Norvig - Design of Computer Programs
89. Queste slides sono licenziate Creative Commons Attribution-ShareAlike 3.0 Unported