Python guida in pochi passi, Sintesi del corso di Sistemi Digitali

Scarica Python guida in pochi passi e più Sintesi del corso in PDF di Sistemi Digitali solo su Docsity!

Il tutorial di Python

traduzione a cura di Riccardo Polignieri

21 mag 2022

Indice

16.1 Modalità interattiva.......................................... 103

Indice 105

iii

Il tutorial di Python

Nota per la traduzione italiana.

Questa è una traduzione del Tutorial ufficiale della documentazione di Python, mantenuta in sincrono con il testo della repository GitHub. Questa è la traduzione della versione «stabile» del Tutorial per Python 3.9 , ed è aggiornata al 8 maggio 2022. Raccomandiamo comunque di installare la versione più recente di Python e di seguire il tutorial corrispondente. La repository GitHub di questo progetto si trova qui: potete essere informati sugli aggiornamenti metten- do una «star» alla repository. Ogni collaborazione è gradita: se intendete partecipare, leggete prima il file CONTRIBUTING.rst. Gli esempi non sono tradotti, perché il codice dovrebbe sempre essere scritto in Inglese. Tuttavia i commenti all’interno del codice sono tradotti e così pure le stringhe, quando il loro contenuto è utile alla comprensione del tutorial. (traduzione a cura di Riccardo Polignieri)

Introduzione

Python è un linguaggio di programmazione molto produttivo e semplice da imparare. È dotato di efficienti strutture-dati di alto livello e propone un approccio alla programmazione a oggetti semplice ma efficace. La sua sintassi elegante e la tipizzazione dinamica, oltre al fatto di essere un linguaggio interpretato, ne fanno uno strumento ideale per lo scripting e lo sviluppo rapido di applicazioni, in molti campi e su molte piattaforme. L’interprete di Python e la sua vasta libreria standard sono disponibili sul sito web https://www.python.org/, sotto forma sia di codice sorgente sia di eseguibile binario, per tutte le piattaforme più diffuse, e possono es- sere liberamente redistribuiti. Il sito, inoltre, ospita direttamente o indirizza verso molti altri moduli Python, programmi e strumenti sviluppati da terze parti e documentazione aggiuntiva. L’interprete Python si può estendere facilmente con nuove funzioni e tipi di dati implementati in C o C++ (o altri linguaggi interfacciabili con C). Python è inoltre adatto come linguaggio integrato per estendere e personalizzare altre applicazioni. Questo tutorial introduce il lettore in modo informale ai concetti e alle funzioni di base del linguaggio e del suo ambiente. Può essere utile avere sotto mano un interprete Python per provare direttamente il codice, ma tutti gli esempi mostrano anche il loro output: è quindi possibile leggere il tutorial anche a sé stante. Per una descrizione delle funzionalità e dei moduli, si veda la documentazione della libreria standard. La guida di riferimento del linguaggio approfondisce in modo formale la struttura di Python. Per scrivere estensioni in C o C++ si può consultare la guida su come estendere e incorporare Python e il manuale delle API C di Python. Ci sono poi molti libri dedicati all’approfondimento di Python. Questo tutorial non vuole essere una descrizione esauriente che copre ogni singola funzionalità, o anche solo quelle comuni. Piuttosto, è un’introduzione agli aspetti più notevoli di Python e può dare un’idea dello stile e del «gusto» del linguaggio. Dopo averlo letto, sarete in grado di leggere e scrivere moduli e programmi in Python, e sarete pronti ad approfondire i diversi moduli contenuti nella libreria standard. Vale anche la pena di dare un’occhiata al glossario.

Indice 1

Il tutorial di Python

• il raggruppamento delle istruzioni avviene rientrando il codice, invece di racchiuderlo tra parentesi;
• non c’è bisogno di dichiarare le variabili.

Python è estensibile : se conoscete il C, è facile aggiungere all’interprete una nuova funzione predefinita o un modulo, sia per aumentare la velocità di esecuzione in punti critici del codice, sia per collegare un programma Python a librerie disponibili solo in forma binaria (per esempio, librerie grafiche di terze parti). Una volta che siete diventati esperti, potete collegare l’interprete Python all’interno di un programma scritto in C e usarlo come un’estensione, o un linguaggio interno di quel programma.

A proposito, il nome del linguaggio deriva dallo show della BBC «Monty Python’s Flying Circus» e non ha niente a che vedere con i rettili. Ogni riferimento agli sketch dei Monty Python nella documentazione è non solo permesso ma anzi incoraggiato.

Adesso che siete incuriositi da Python, avrete voglia di esaminarlo più nel dettaglio. Siccome il miglior modo di imparare un linguaggio è usarlo, vi invitiamo a sperimentare con l’interprete man mano che leggete il tutorial.

Dedichiamo il prossimo capitolo a spiegare il meccanismo di funzionamento dell’interprete. Si tratta di infor- mazioni di servizio, ma sono importanti per consentirvi di provare gli esempi che verranno presentati più in là.

I capitoli successivi descrivono e dimostrano diverse funzionalità di Python e del suo ambiente, a cominciare da semplici espressioni, istruzioni e tipi di dati, proseguendo poi con le funzioni e i moduli, fino ad accennare agli argomenti più avanzati come le eccezioni e la creazione di classi personalizzate.

CAPITOLO 2

Usare l’interprete Python.

2.1 Invocare l’interprete

L’interprete Python di solito è installato in /usr/local/bin/python3.9 sui computer dove è disponibile. Aggiungere /usr/local/bin alla path della shell Unix vi permette di invocarlo con il comando^1

python3.

Dal momento che la scelta della directory dell’interprete è un’opzione di installazione, sono possibili altre confi- gurazioni. Chiedete a un esperto di Python o all’amministratore del sistema. Per esempio, un’alternativa popolare è /usr/local/python.

Su Windows, se avete installato Python dal Microsoft Store, sarà disponibile il comando python3.9. Se avete installato il launcher py.exe potete usare il comando py. Il paragrafo Excursus: Impostare le variabili d’ambiente descrive altri modi per avviare Python.

Inserire il carattere terminatore del file (Control-D in Unix, Control-Z in Windows) nel prompt principale co- stringe l’interprete a uscire con exit status 0. Se non funziona, potete uscire dall’interprete con questo comando: quit().

Sui sistemi che supportano la libreria GNU Readline, l’interprete consente di fare editing interattivo, auto- completamento e storico degli inserimenti. Il modo più rapido per controllare se l’editing della riga di comando è supportato, è inserire Control-P appena il prompt primario di Python è disponibile. Se sentite un beep, l’editing è supportato; l’Appendice Editing e history substitution nell’input interattivo presenta un’introduzione a questi comandi. Se invece non succede nulla, o se risponde semplicemente ^P, l’editing non è disponibile: potete solo usare il backspace per cancellare i caratteri.

L’interprete funziona più o meno come la shell di Unix: quando è invocato con lo standard input collegato al terminale, legge ed esegue interattivamente i comandi; quando è invocato con il nome di un file come parametro, o con lo standard input collegato a un file, legge ed esegue il file come script.

Un altro modo di avviare l’interprete è python -c command [arg] ..., che esegue l’istruzione (o le istruzioni) in command , analogamente all’opzione -c della shell. Siccome le istruzioni Python di solito comprendono spazi o altri caratteri speciali della shell, è consigliabile racchiudere command tra apici singoli.

Alcuni moduli Python possono essere eseguiti come script. Si possono invocare con python -m module [arg] ..., che esegue il file module come se ne aveste scritto il nome per intero nella riga di comando.

(^1) In ambiente Unix, l’eseguibile dell’interprete Python 3.x non è installato col nome python, così da non entrare in conflitto con l’eseguibile di Python 2.x, anch’esso contemporaneamente presente.

Il tutorial di Python

dove encoding è uno dei vari codecs supportati da Python.

Per esempio, per dichiarare che occorre usare l’encoding Windows-1252 per leggere il file, la prima riga del codice dovrebbe essere:

-- coding: cp1252 --

L’eccezione alla regola è quando lo script inizia invece con una shebang UNIX. In questo caso, la dichiarazione di encoding deve essere la seconda riga del file. Per esempio:

#!/usr/bin/env python

-- coding: cp1252 --

2.2. L’interprete e il suo ambiente 6

CAPITOLO 3

Un’introduzione informale a Python

Negli esempi che seguono, l’input e l’output si distinguono dalla presenza o assenza del prompt (>>> e... ). Per riprodurre gli esempi, quando appare il prompt dovete inserire tutto ciò che segue nella riga; le righe che non hanno il prompt sono l’output dell’interprete. Si noti che quando una riga riporta solo il prompt secondario senza nient’altro, significa che dovete inserire una riga vuota: questo serve a terminare un’istruzione multi-linea.

Molti esempi nella documentazione, anche quelli da inserire nell’interprete interattivo, includono dei commenti. I commenti in Python iniziano con il «cancelletto» # e comprendono tutto il resto della riga. Un commento può partire all’inizio della riga o dopo uno spazio, ma non può essere inserito all’interno di una stringa: un cancelletto dentro una stringa è solo un cancelletto. Siccome i commenti servono a spiegare il codice, ma non sono processati da Python, non dovete copiarli quando provate gli esempi.

Ecco alcuni esempi:

questo è il primo commento

spam = 1 # e questo è il secondo

... ed ecco il terzo!

text = "# Questo non è un commento perché è dentro una stringa."

3.1 Usare Python come una calcolatrice

Proviamo qualche semplice istruzione Python. Avviate l’interprete e aspettate il prompt primario >>> (non dovrebbe volerci molto).

3.1.1 Numeri

L’interprete funziona come una semplice calcolatrice: potete inserire un’espressione e lui restituirà il suo valore. La sintassi delle espressioni è banale: gli operatori +, - , * e / funzionano come negli altri linguaggi (Pascal o C, per esempio); le parentesi (()) si possono usare per i raggruppamenti. Per esempio:

>>> 2 + 2 4 >>> 50 - 5* 20 >>> (50 - 5*6) / 4 (continua...)

Il tutorial di Python

(...segue)

>>> price + _

>>> round(_, 2)

Questa variabile dovrebbe essere considerata di sola lettura. Non cercate di assegnare esplicitamente un valore a _: avreste creato una variabile locale con lo stesso nome, che maschera la quella predefinita, con il suo comportamento speciale.

Oltre a int e float, Python supporta altri tipi numerici, come Decimal e Fraction. Python ha anche il supporto per i numeri complessi e usa il suffisso j o J per la parte immaginaria (e.g. 3+5j).

3.1.2 Stringhe

Oltre ai numeri, Python può manipolare le stringhe, che si possono esprimere in molti modi. Potete delimitarle con apici singoli ('...') o doppi ("..."): funzionano allo stesso modo^2. Usate \ ( backslash ) per fare escaping degli apici:

>>> 'spam eggs' # apici singoli 'spam eggs' >>> 'doesn't' # usate ' per inserire un apice singolo nella stringa... "doesn't" >>> "doesn't" # ...o usate apici doppi per delimitarla "doesn't" >>> '"Yes," they said.' '"Yes," they said.' >>> ""Yes," they said." '"Yes," they said.' >>> '"Isn't," they said.' '"Isn't," they said.'

Nell’output dell’interprete interattivo, le stringhe sono chiuse tra apici e i caratteri speciali sono resi con il backslash di escape. A volte l’output può sembrare diverso dall’input, perché gli apici possono cambiare, ma le due versioni sono equivalenti. La stringa è chiusa nei doppi apici se contiene un apice singolo e nessun apice doppio; altrimenti è delimitata da apici singoli. La funzione print() produce un output più leggibile perché omette gli apici iniziali e finali, e «stampa» anche i caratteri speciali:

>>> '"Isn't," they said.' '"Isn't," they said.' >>> print('"Isn't," they said.') "Isn't," they said. >>> s = 'First line.\nSecond line.' # \n significa "a-capo" >>> s # senza print(), \n viene incluso nell'output 'First line.\nSecond line.' >>> print(s) # con print(), \n produce una nuova riga First line. Second line.

Se non volete che il carattere dopo un backslash \ sia interpretato come un carattere speciale, potete usare le raw strings con il prefisso r prima dell’apice iniziale:

>>> print('C:\some\name') # qui \n vuol dire "a-capo"! C:\some ame (continua...) (^2) A differenza di altri linguaggi, i caratteri speciali come \n hanno lo stesso significato con apici singoli ('...') o doppi ("..."). L’unica differenza tra i due è che all’interno di apici singoli non c’è bisogno di fare escaping di " (ma occorre farlo per ') e viceversa.

3.1. Usare Python come una calcolatrice 9

Il tutorial di Python

(...segue)

>>> print(r'C:\some\name') # si noti la r iniziale C:\some\name

Le stringhe possono occupare più di una riga. Un modo per ottenere questo è usare gli apici tripli: """...""" o '''...'''. Gli «a-capo» sono inclusi automaticamente nelle stringhe, ma è possibile evitarlo aggiungendo un backslash \ alla fine della riga. Questo esempio:

print(""" Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """)

produce questo output (si noti che lo «a-capo» iniziale non è incluso):

Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to

Potete concatenare («incollare insieme») le stringhe con l’operatore + e ripeterle con il *:

>>> # 3 volte 'un', seguito da 'ium' >>> 3 * 'un' + 'ium' 'unununium'

Due o più stringhe (racchiuse tra apici) una accanto all’altra sono automaticamente concatenate.

>>> 'Py' 'thon' 'Python'

Questo torna utile quando volete spezzare una stringa lunga:

>>> text = ('Mettete diverse stringhe tra parentesi ' ... 'per unirle insieme.') >>> text 'Mettete diverse stringhe tra parentesi per unirle insieme.'

Questo però funziona solo con le stringhe «pure», non con le variabili o le espressioni:

>>> prefix = 'Py' >>> prefix 'thon' # non potete concatenare una variabile e una stringa File "", line 1 prefix 'thon' ^ SyntaxError: invalid syntax >>> ('un' * 3) 'ium' File "", line 1 ('un' * 3) 'ium' ^ SyntaxError: invalid syntax

Per concatenare le variabili, o una variabile con una stringa, usate l’operatore +:

>>> prefix + 'thon' 'Python'

Le stringhe possono essere indicizzate (indirizzate): il primo carattere ha indice 0. Non esiste un tipo di dato separato per rappresentare un carattere; un carattere è semplicemente una stringa di lunghezza uno:

3.1. Usare Python come una calcolatrice 10

Il tutorial di Python

>>> word[42] # la stringa ha solo 6 caratteri Traceback (most recent call last): File "", line 1, in IndexError: string index out of range

Tuttavia, gli indici che escono dai limiti sono comunque consentiti, quando li usiamo per estrarre una sezione:

>>> word[4:42] 'on' >>> word[42:] ''

Le stringhe in Python non possono essere modificate: sono immutabili. Di conseguenza, assegnare alla posizione di un indice produce un errore:

>>> word[0] = 'J' Traceback (most recent call last): File "", line 1, in TypeError: 'str' object does not support item assignment >>> word[2:] = 'py' Traceback (most recent call last): File "", line 1, in TypeError: 'str' object does not support item assignment

Se vi serve una nuova stringa, dovete crearla:

>>> 'J' + word[1:] 'Jython' >>> word[:2] + 'py' 'Pypy'

La funzione predefinita len() restituisce la lunghezza di una stringa:

>>> s = 'supercalifragilisticexpialidocious' >>> len(s) 34

Vedi anche:

Sequenze di testo - str Le stringhe sono esempi del tipo di dati sequenza , e supportano le comuni operazioni possibili con le sequenze.

Metodi per le stringhe Le stringhe hanno un gran numero di metodi per manipolazioni di base e ricerca.

Stringhe formattate Le stringhe possono includere delle espressioni al loro interno.

Sintassi di format Informazioni sulla formattazione delle stringhe con str.format().

Formattazione in stile printf Il vecchio modo di formattare, con l’operatore % a destra della stringa.

3.1. Usare Python come una calcolatrice 12

Il tutorial di Python

3.1.3 Liste

Python ha alcuni tipi di dati composti , che servono a raggruppare insieme altri dati. Il più versatile di questo è la lista , che si può scrivere come un elenco di valori (elementi) separati da virgola e racchiusi tra parentesi quadre. Le liste possono contenere valori di tipo diverso, anche se di solito tutti gli elementi hanno lo stesso tipo.

>>> squares = [1, 4, 9, 16, 25] >>> squares [1, 4, 9, 16, 25]

Come le stringhe e tutti gli altri tipi di sequenza, le liste possono essere indicizzate e sezionate:

>>> squares[0] # l'indice restituisce l'elemento 1 >>> squares[-1] 25 >>> squares[-3:] # la sezione restituisce una nuova lista [9, 16, 25]

Tutte le operazioni di sezionamento restituiscono una nuova lista che contiene gli elementi richiesti. Ciò significa che la sezione dell’esempio seguente restituisce una copia per indirizzo della lista:

>>> squares[:] [1, 4, 9, 16, 25]

Le liste supportano anche operazioni come il concatenamento:

>>> squares + [36, 49, 64, 81, 100] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

A differenza delle stringhe che sono immutabili le liste sono un tipo mutabile, per cui è possibile cambiare il loro contenuto:

>>> cubes = [1, 8, 27, 65, 125] # c'è qualcosa di sbagliato >>> 4 ** 3 # 4 al cubo fa 64, non 65! 64 >>> cubes[3] = 64 # rimpiazza il valore sbagliato >>> cubes [1, 8, 27, 64, 125]

Potete anche aggiungere nuovi elementi alla fine della lista, con il metodo append() (parleremo meglio dei metodi più tardi):

>>> cubes.append(216) # aggiunge il cubo di 6 >>> cubes.append(7 ** 3) # e il cubo di 7 >>> cubes [1, 8, 27, 64, 125, 216, 343]

È possibile inoltre assegnare a una sezione, cosa che può anche cambiare la dimensione della lista o svuotarla del tutto:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> # rimpiazza alcuni valori >>> letters[2:5] = ['C', 'D', 'E'] >>> letters ['a', 'b', 'C', 'D', 'E', 'f', 'g'] >>> # adesso li rimuove (continua...)

3.1. Usare Python come una calcolatrice 13

Il tutorial di Python

sequenza vuote sono «false». Il test usato in questo esempio è una semplice comparazione. Gli operatori standard per la comparazione sono gli stessi di C: < (minore di), > (maggiore di), == (uguale a), <= (minore o uguale a), >= (maggiore o uguale a) e != (diverso da).

• Il corpo del ciclo è rientrato : il rientro è il modo di Python per raggruppare le istruzioni. In modalità interattiva, dovete inserire una tabulazione o degli spazi per ciascuna riga rientrata. In realtà, preparerete le istruzioni più complicate in un editor da programmatore: tutti gli editor validi hanno la funzione di rientro automatico. Quando inserite un’istruzione composta in modalità interattiva, dovete concluderla con una riga bianca per indicare che è terminata, dal momento che il parser non può indovinare quando avete inserito l’ultima riga. Si noti che ciascuna riga all’interno di un blocco deve essere rientrata della stessa misura.
• La funzione print() scrive il valore del parametro o dei parametri che le passate. È diverso da scrivere semplicemente l’espressione da calcolare (come avete fatto prima nell’esempio della calcolatrice), in quanto print() può gestire più parametri, numeri con la virgola e stringhe. Le stringhe sono stampate senza apici; tra ciascun parametro viene inserito uno spazio, per permettervi di formattare l’output in modo elegante, così:

>>> i = 256* >>> print('Il valore di i è', i) Il valore di i è 65536

Potete usare il parametro keyword «end» per evitare l’inserimento di una riga vuota dopo ciascun output, o per terminare l’output con una stringa diversa:

>>> a, b = 0, 1 >>> while a < 1000: ... print(a, end=',') ... a, b = b, a+b ... 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

3.2. I primi passi verso la programmazione 15

CAPITOLO 4

Altri strumenti per il controllo di flusso

Oltre a while di cui abbiamo già parlato, Python utilizza le consuete istruzioni per il controllo del flusso, comuni a molti linguggi, con qualche peculiarità.

4.1 Istruzione if

Forse l’istruzione più famosa è la if. Per esempio:

>>> x = int(input("Please enter an integer: ")) Please enter an integer: 42 >>> if x < 0: ... x = 0 ... print('Negative changed to zero') ... elif x == 0: ... print('Zero') ... elif x == 1: ... print('Single') ... else: ... print('More') ... More

Possono esserci nessuna, una o più sezioni elif e la sezione else è opzionale. La parola riservata “elif” è una scorciatoia per «else if», e permette di evitare troppi livelli annidati. Una sequenza if... elif... elif... sostituisce le istruzioni switch o case tipiche di altri linguaggi.