Python Per Principianti: Una Guida Per Iniziare

Python per principianti: cos'è Python?

Python è un linguaggio di programmazione creato da Guido Van Rossum nel 1991.

Considerato un linguaggio semplice, bello da leggere e da vedere, adatto ai principianti, oggi Python è usato in moltissimi settori:

• sviluppo web con Django e Flask.
• data science.
• machine learning e computer vision.
• scripting (automazione).
• manipolazione dati e data mining.

Oggi Python è giunto alla versione 3.8 e secondo gli ultimi dati è il linguaggio di programmazione che sta crescendo più velocemente nel mondo (1).

Python per principianti: Python è intepretato e di alto livello

Tempo di cominciare la nostra esplorazione! Python prima di tutto è un linguaggio interpretato (interpreted).

Interpretato significa che il codice Python che scrivi viene letto al volo da un "traduttore" che lo trasforma in linguaggio "macchina", ovvero una lingua che può essere compresa solo dal processore del tuo computer.

Da questo momento mi riferirò al "traduttore" come al motore Python, lo strumento che legge e interpreta il nostro codice.

Il passaggio da codice a esecuzione è quindi quasi immediato e tu non ti devi preoccupare di dettagli di basso livello come la memoria o le istruzioni per il processore.

Oltre ai linguaggi di programmazione interpretati ci sono anche quelli compilati, dove il codice che scrivi parla in modo più diretto alla macchina, e deve essere tradotto da uno strumento chiamato compilatore (esempi di linguaggi compilati sono C, C#, Java).

Il compilatore produce poi il tuo programmino, chiamato binario, che puoi lanciare sul computer. Il passaggio da codice a esecuzione qui è leggermente più macchinoso. I linguaggi compilati sono anche più difficili da padroneggiare di quelli interpretati perché parlano alla macchina da vicino.

I linguaggi interpretati come Python invece possono essere scritti in una "lingua" molto simile all'inglese, e per questo motivo si dice che Python è di alto livello (high level).

Un altro esempio di linguaggio interpretato e di alto livello è JavaScript.

Python per principianti: Python è dinamico

Oltre ad essere interpretato e di alto livello, Python è anche un linguaggio dinamico.

In programmazione dinamico significa che se abbiamo una variabile (pensa alla variabile come a una scatola) che contiene un gatto, più avanti nel codice possiamo scambiare il gatto con un umano.

Considera questo esempio in pseudocodice (non è Python):

"""
Linguaggio con tipi dinamici
"""

contenitore = gatto

contenitore = umano

# tutto ok!

Contenitore prima è un gatto, poi diventa un umano, e il programma non fa una piega. Si dice che i tipi sono dinamici.

Python permette anche questo e lascia molta libertà allo sviluppatore (un altro esempio di linguaggio dinamico è JavaScript).

L'opposto di un linguaggio dinamico è invece linguaggio statico, dove se una variabile (il contenitore) contiene un tipo di gatto, più avanti non è possibile togliere il gatto e metterci dentro un umano:

"""
Linguaggio con tipi statici
"""

contenitore: gatto = siamese

contenitore = umano

# errore! Il programma si ferma

La differenza tra i linguaggi statici e dinamici è che i primi sono più rigidi dei secondi, e per certi versi più sicuri, soprattutto per applicazioni "critiche" come quelle finanziarie (esempi di linguaggi statici, ovvero statically typed, sono C#, Java, TypeScript).

Da qualche anno anche Python può essere trasformato in un linguaggio statico con le cosiddette type annotations (concetto avanzato, ma sei hai tempo e voglia guarda questo mio video).

Python per principianti: Python è orientato agli oggetti

In qualsiasi tutorial si parla di Python come di linguaggio orientato agli oggetti.

Ok ma cosa sono questi oggetti? Quello che fa un programmatore non è altro che prendere concetti dal mondo reale come nave, casa, persona, auto, albero e trasportarli nel codice.

Quando prendiamo un'entità come "albero" e la fissiamo nel codice Python come Tree, non stiamo facendo altro che creare un nuovo oggetto.

Si dice che Python è orientato agli oggetti perché è molto facile creare nuovi oggetti e ragionare su di essi in modo molto comodo.

Più avanti capirai meglio di che cosa si tratta.

Python per principianti: Python è attento allo stile

Una delle caratteristiche più importanti di Python è l'attenzione per lo stile.

Per stile non intendo solo codice bello o brutto, ma anche come lo stesso viene intepretato dal motore Python (ricorda, il motore Python è quello strumento che legge ed intepreta il codice).

Facciamo un esempio pratico, con la tua prima riga di codice Python. Guarda questa istruzione:

    print("Hello Python!")

Puoi notare come sia spostata di quattro spazi verso destra (un colpo di tabulazione). Se faccio girare questo codice Python avrò un errore (detto anche eccezione): IndentationError.

Che cosa significa? In Python è importante non solo scrivere codice "bello" ma anche rispettare la cosiddetta indentazione, ovvero la tabulazione del codice.

Il motore Python infatti legge il codice proprio in base a come è indentato. L'esempio di prima non girerà, ma rispettando la tabulazione, così:

print("Hello Python!")

vedrai "Hello Python!" stampato da qualche parte (a breve scoprirai dove).

Python per principianti: come faccio a far girare Python?

Disclaimer: prima di proseguire leggi qui se non sai cos'è un terminale.

Per usare Python devi scaricarlo ed installarlo sul tuo computer.

Python è già installato su alcuni sistemi operativi come Linux (Fedora, Ubuntu), mentre per MacOs e Windows devi scaricarlo ed installarlo a mano. Ti rimando qui per il download, in questa sezione voglio spiegarti velocemente come far girare codice Python.

Dopo aver installato Python (assicurati di installare la versione 3.x) dovresti avere l'eseguibile python3 sul sistema.

Ci sono due modi per usare Python sul tuo computer. La prima opzione è creare dei file con codice Python ed estensione .py, per poi lanciarli con l'eseguibile Python.

Esempio, per stampare un semplice messaggio sul terminale crea un file di nome hello.py con il seguente codice:

print("Hello Python!")

e poi lancialo con:

python3 hello.py

Quando crei file Python ti suggerisco di chiamare il file con un nome descrittivo, che non contenga spazi. Esempio hello.py va bene, ma "mio file python che bello.py" no. Non va bene neanche print("Hello Python!").py.

Seconda opzione per far girare codice Python: la console Python. Dopo aver installato Python, apri un terminale e lancia l'eseguibile python3:

python3

Ti ritroverai nella console di Python (dovresti vedere il simbolo >>>) dove potrai lanciare direttamente piccole istruzioni e scrivere codice per veloci test:

>>> print("Hello Python!")

Negli esempi che seguono troverai sia file Python, sia istruzioni lanciate direttamente nella console.

Python per principianti: tipi di dato base

Iniziamo finalmente la nostra esplorazione di Python, partendo dai "tipi di dato".

Quando parliamo di tipi di dato in programmazione ci riferiamo a dei blocchi fondamentali su cui è costruito tutto il resto.

Ma per essere più precisi “il tipo” è un po’ quello che per la vita sulla terra è la specie. Noi per esempio siamo Homo sapiens, mentre i lupi sono della specie Canis lupus.

Allo stesso modo in programmazione possono esserci dati di varie specie.

Ad esempio in Python un dato può essere:

float è un numero decimale, mentre int è un numero intero (integer è una parola latina ;-) ).

string è la stringa di testo, boolean è un valore booleano che può essere True oppure False. None invece è un valore nullo, una sorta di segnaposto che ha un utilizzo ben preciso e che vedrai più avanti.

Ogni tipo di dato corrisponde ad un valore che può essere associato ad un contenitore, le cosiddette variabili.

Python per principianti: le variabili

Nota: da questo momento per fare pratica puoi lanciare tutti gli esempi che ti propongo nella console di Python (o salvali in un file e lanciali con l'eseguibile).

In "Python è dinamico" ho parlato di variabili come di scatole in cui mettere "roba". Le variabili in Python sono ovunque e servono per contenere dei dati.

Quando creiamo una nuova variabile la stiamo dichiarando e per dichiarare variabili in Python basta fissarne il nome, seguito da un valore. Ecco alcuni esempi:

name = "Cate"
age = 31
city = "Rotterdam"
married = False
count = 105.00

Quando ad una variabile viene assegnato un particolare tipo, quella variabile diventa "di quel tipo". Qui sopra ad esempio "name" è una stringa, "age" è un numero, e così via.

Ricollegandoci sempre a "Python è dinamico", anche se una variabile nasce stringa non è detto che debba morire tale:

name = "Cate"
name = 81
# Prima name è una stringa
# e poi diventa un numero

A ragion veduta anche se Python lo permette non è detto che tu debba scambiare i tipi continuamente. Una variabile che si chiama "name" non ha alcun motivo per diventare un numero.

Nei linguaggi con tipi statici come Java o TypeScript tutto questo non è permesso così liberamente, ed anche Python ha una "sicura" opzionale come ho accennato prima.

Vale la pena chiarire anche che Python considera come variabili tutti i nomi che nel programma non sono contenuti tra virgolette. Questo significa che il seguente esempio:

name = "Liz"

si legge come stringa Liz assegnata alla variabile name. Questo codice invece significa tutt'altro e non è neanche valido:

"name" = "Liz"

Quando parleremo delle funzioni vedrai perché è importante fare attenzione a questi dettagli.

Scrivere variabili alla maniera di Python

Non solo Python si aspetta di trovare il codice ben allineato, devi fare anche attenzione ad alcune regole che il mondo Python si è dato per rendere più piacevole il lavoro degli sviluppatori.

Facciamo qualche esempio. In alcuni linguaggi di programmazione le variabili vengono scritte con la forma cosiddetta camel case:

# Non farlo in Python
myVariable = "Liz"

In Python questa forma è da evitare perché non è nè comune nè accettata dalla community. La forma corretta invece è:

# ok!
my_variable = "Liz"

Separa quindi con un underscore i nomi lunghi. Un'altra cosa da evitare è il maiuscolo (a parte per un caso particolare):

# Non farlo in Python
MYVARIABLE = "Liz"

Un altro errore comune ma comprensibile che molti principianti commettono è quello di non avere consistenza nello scrivere i nomi delle variabili.

Non è raro vedere cose del genere (incoraggiate anche da materiale didattico ufficiale per la preparazione ad alcuni esami):

# NON CI SIAMO
Nome = "Cate"
ETà = 31
CITTA = "Rotterdam"
Married = False
count = 105.00

Per quanto ami l'italiano che difendo sempre a spada tratta contro la follia del break even point che se non abbiamo un businnes plan non possiamo parlare con gli investor e poi il competitor ci sorpassa, è buona norma in Python scrivere le variabili in minuscolo ed in inglese.

Questi piccoli accorgimenti migliorano la leggibilità del codice e rendono ciò che scrivi familiare anche agli altri sviluppatori Python.

Python per principianti: operatori aritmetici

Non c'è tanto da dire sugli operatori aritmetici in Python, se non che non potevano mancare. Ci sono infatti tutti gli operatori classici come somma, divisione, sottrazione, elevazione a potenza:

Qualche riga a parte per la divisione intera e per il modulo. Il simbolo che per noi è quello della percentuale, in Python è invece detto modulo e serve per calcolare il resto di una divisione (anche altri linguaggi di programmazione hanno l'operatore modulo):

>>> 80 % 2
0

Un quiz che ricorre spesso nelle interviste tecniche è "calcola se numero x è pari o dispari". Un numero è pari quando è divisible per 2, quindi ritorna resto zero. Dispari è invece quando il resto della divisione ritorna 1. L'operatore modulo serve proprio a questo.

Python ha anche un operatore di divisione intera detto floor division. La divisione intera ritorna appunto la parte intera del risultato nel caso in cui lo stesso sia decimale (float):

# divisione normale
>>> 89 / 4
22.25

# divisione intera
>>> 89 // 4
22

Python per principianti: i commenti

A questo punto ti starai chiedendo cosa sono tutti questi cancelletti # nel codice.

Il simbolo # in Python è un commento, e serve per lasciare indicazioni nel codice, sia per gli altri sviluppatori, sia per noi stessi.

I commenti vengono ignorati dal motore Python e quindi sono molto utili per annotare e spiegare il codice, eliminare temporaneamente istruzioni, e così via.

Ci sono due tipi di commento in Python, il commento a linea singola:

# ciao, sono un commento
name = "Amy"

ed il commento multilinea:

"""
This is a
multi line
comment
"""
name = "Andrea"

Come avrai intuito i commenti multilinea sono utili per illustrare l'intento del nostro codice e possono fare anche da documentazione, come vedrai più avanti.

Python per principianti: introduzione alle stringhe

Nella programmazione le stringhe sono ovunque e vale la pena spendere qualche parola su come usarle in Python.

Per iniziare, alcuni operatori aritmetici funzionano anche sulle stringhe, come l'addizione e la moltiplicazione. Considera questi esempi:

>>> "a" + "b"
"ab"

>>> "bb" * 4 
"bbbbbbbb"

L'addizione può concatenare più stringhe insieme mentre la moltiplicazione le ripete.

In particolare concatenare le stringhe è un'operazione molto comune nel codice, ma nel caso di frasi complesse può sfuggire di mano.

Ad esempio per concatenare più parole intervallate da spazi potresti fare qualcosa del genere:

>>> "ciao" + " " + "il mio nome è" + " " + "Vale" 
'ciao il mio nome è Vale'

Come vedi non è una cosa molto pratica. Fortunatamente con la versione 3.6 di Python è stato aggiunto un piccolo tool chiamato f-strings.

L'esempio sopra può essere riscritto con f-strings in questo modo:

>>> f"ciao il mio nome è Vale"
'ciao il mio nome è Vale'

Come vedi basta chiamare f seguito da virgolette.

Come hai visto prima, le stringe possono essere anche salvate all'interno di variabili:

name = "Cate"

Quindi combinando f-strings e le variabili è possibile interpolare variabili all'interno di stringhe:

>>> name = "Cate"
>>> f"ciao il mio nome è {name}"
'ciao il mio nome è Cate'

Per la precisione esistono anche altri modi di concatenare ed interpolare stringhe in Python ma f-strings è la forma più chiara, che ritengo adatta a chi inizia con Python.

Prima di passare avanti tieni presente che un numero tra virgolette non è un numero ma una stringa:

age = "18"

C'è un modo per convertire la stringa 18 nel numero 18 e lo vedremo dopo.

Ora affrontiamo ora uno degli argomenti più importanti in programmazione: le funzioni. Ma non prima di aver dato uno sguardo ad "in".

L'operatore in sulle stringhe

Oltre agli operatori aritmetici, Python come tutti i linguaggi di programmazione ha anche altri tipi di operatori intesi come istruzioni che operano su qualcosa. Uno degli operatori non aritmetici più interessanti in Python è l'operatore in, chiamato in gergo membership operator.

L'operatore in in particolare è molto utile sulle stringhe (ma anche su altri tipi di dato più complessi) per controllare se un carattere oppure una sotto-stringa compare nella stringa bersaglio. Ecco alcuni esempi:

>>> "guest" in "1 - insert a new guest"
True

>>> "g" in "1 - insert a new guest"
True

>>> "Gastgeber" in "1 - insert a new guest"
False

L'operatore in risponde sempre alla seguente domanda: x contiene y? La risposta è un booleano, che può essere True o False a seconda che l'elemento da controllare compaia o meno nel bersaglio.

Interludio: prepara l'ambiente di lavoro

Da questo punto in poi scriveremo codice Python su più righe e diventerebbe scomodo lanciarlo dalla console.

Se vuoi provare il codice seguendo gli esempi prepara un ambiente di lavoro. Prima di tutto apri un terminale, e crea un nuovo folder nella tua home directory, per comodità lo chiameremo "python_code":

mkdir ~/python_code

Poi all'interno di questo folder crea un nuovo file. Puoi chiamarlo ad esempio functions.py visto che fra poco parleremo di funzioni.

Python per principianti: le funzioni

Le funzioni in programmazione sono blocchi di codice riutilizzabili. Puoi pensare alle funzioni come a ricette pronte all'uso per i più svariati utilizzi.

Per creare una funzione in Python devi usare la parola chiave def, seguita dal nome della funzione, due parentesi tonde, e due punti:

def my_first_function():
    pass

(Da questo momento puoi provare gli esempi in un file Python che puoi salvare nel folder ~/python_code).

La parola chiave pass è un'istruzione Python che semplicemente non fa nulla e per ora serve a non mandare Python in errore.

Le funzioni sono molto utili, ma a patto che facciano qualcosa. Estendiamo la tua prima funzione calcolando una semplice operazione aritmetica:

def my_first_function():
    result = 5 * 10

Super ma ancora poco utile. Le funzioni infatti iniziano ad essere interessanti quando ritornano il loro risultato all'esterno. Come?

Con la parola chiave return:

def my_first_function():
    result = 5 * 10
    return result

Copia il codice nel file functions.py che hai creato prima e lancialo con (devi essere in ~/python_code):

python3 functions.py

Che cosa vedi? Se la risposta è "nulla" niente panico. Per catturare il valore di ritorno di una funzione devi prima di tutto chiamarla:

def my_first_function():
    result = 5 * 10
    return result

my_first_function()

Come vedi la chiamata della funzione consiste nello scrivere il nome della funzione seguito da parentesi tonde.

Attenzione anche qui all'indentazione. La chiamata deve comparire sulla stessa colonna della d di def.

Nella prossima sezione vedremo finalmente come stampare il risultato della nostra funzione.

Python per principianti: funzioni custom e built-in

La funzione my_first_function che hai scritto è una funzione personalizzata, custom.

In Python però ci sono anche molte funzioni già pronte, dette built-in. Ne hai visto una nelle prime sezioni della guida: print.

print è una funzione Python built-in che stampa qualsiasi cosa tu gli dia in pasto:

>>> print("Hello Python!")

Che ne pensi di usare print per stampare il risultato di my_first_function? Riprendiamo il codice in mano:

def my_first_function():
    result = 5 * 10
    return result

my_first_function()

Prima di tutto elimina la variabile result dal corpo della funzione, basta solo il return seguito dall'operazione aritmetica (ora pass non serve più):

def my_first_function():
    return 5 * 10

my_first_function()

Poi per comodità catturiamo il risultato di my_first_function in una variabile:

def my_first_function():
    return 5 * 10


result = my_first_function()

Se la cosa ti può aiutare, il codice dell'ultima riga va letto da destra verso sinistra: la funzione my_first_function viene chiamata ed il risultato finisce nella variabile result, che ora contiene il risultato di 5 * 10.

A questo punto possiamo stampare result:

def my_first_function():
    return 5 * 10


result = my_first_function()

print(result)

Lancia il codice con:

python3 functions.py

e dovresti vedere 50 stampato sulla tua console.

Ottimo lavoro con la tua prima funzione Python! Ricapitolando:

print è una funzione built-in Python che stampa tutto quello che ci viene in mente.

my_first_function è una funzione Python che hai scritto tu e produce il risultato di 5 per 10.

Le funzioni in Python devono essere prima create (si dice anche dichiarate) e poi eseguite.

Eseguire una funzione significa chiamarla per nome, aggiungendo parentesi tonde.

Qualche parola su "return"

Usare la keyword "return" in una funzione ha molteplici effetti:

• il motore Python esce dalla funzione e libera la memoria
• la funzione termina immediatamente

Sul secondo punto vale la pena spendere qualche parola, molti principianti infatti si aspettano di poter continuare a scrivere codice dopo aver usato return:

def my_first_function():
    return 5 * 10
    another_variable = 80 * 10
    return another_variable

Peccato che qualsiasi istruzione posta dopo il primo return non verrà mai raggiunta.

Molti editor mostreranno un avviso e potrai correggere l'errore, ma è bene comunque tenere la cosa a mente per evitare di perdere ore a capire perché la funzione non funziona come previsto!

Python per principianti: parametri, argomenti e funzioni

Le funzioni sono comode ma diventano ancora più versatili quando producono un risultato a partire da un input variabile.

Prepariamo una nuova funzione per moltiplicare due numeri, ma questa volta diamogli un nome più descrittivo:

def multiply():
    return 5 * 10

Niente male, ma possiamo fare di meglio? Moltiplicare 5 per 10 ogni volta non è il massimo.

Se volessimo moltiplicare invece due valori non fissi, che per comodità chiamiamo x ed y?

def multiply():
    return x * y

E' alla base di questa esigenza che nasce il concetto di parametri in programmazione. I parametri infatti sono variabili che possono essere passate ad una funzione.

L'unico accorgimento è quello di dichiarare i parametri nelle parentesi tonde:

def multiply(x, y):
    return x * y

Questo codice Python dice: la funzione multiply accetta due parametri denominati x ed y, li moltiplica e li ritorna.

Con questa funzione in mano ora possiamo calcolare il prodotto di qualsiasi numero, passando i valori come argomenti quando chiamiamo la funzione:

def multiply(x, y):
    return x * y


multiply(8, 99)

A prima vista sembra magico ma Python associa 8 e 99 rispettivamente con x e y.

Ricorda: quando sono nella dichiarazione della funzione si chiamano parametri. Quando invece i valori compaiono tra parentesi nella chiamata della funzione si chiamano argomenti.

Vale la pena notare che gli argomenti di una funzione sono posizionali, ovvero, Python li associa ai parametri nell'ordine di comparizione. Quindi questo:

def multiply(x, y):
    return x * y


multiply(8, 99)

**NON è la stessa cosa di:

def multiply(x, y):
    return x * y


multiply(99, 8)

anche se nel nostro caso il prodotto della moltiplicazione è sempre il medesimo. Ora un piccolo esercizio per te: prova a stampare sulla console il risultato della moltiplicazione.

Python per principianti: ancora sulle stringhe

Quello che possiamo fare sulle stringhe in Python non è solo limitato a ripeterle, concatenarle, o assegnarle a variabili. Scrivi questo codice nella console di Python (vai in un terminale ed aprila con il comando python3):

>>> age = "diciotto"

Ora prova ad aggiungere un punto dopo age e premi il tasto tab. Dovresti vedere qualcosa del genere:

>>> age.
age.capitalize(
age.casefold(
age.count(

Da dove sbucano fuori queste "funzioni" ed a cosa servono? Prova a lanciarne una:

>>> age.capitalize()
'Diciotto'

Nota sempre come le parentesi dopo il nome della funzione siano fondamentali per eseguire la stessa.

Com'è lecito aspettarsi capitalize trasforma la prima lettera della nostra stringa in maiuscolo.

Ma non è ancora chiaro cosa sia questa sintassi strana, e da dove viene "capitalize". Lo scoprirai presto, ma prima un altra piccola prova: che cosa è successo alla stringa originale?

>>> age
'diciotto'

E' ancora lì! Proviamo di nuovo ad usare capitalize, e poi a visualizzare la stringa, in un colpo solo:

>>> age.capitalize()
'Diciotto'
>>> age
'diciotto'

Come vedi la stringa originale rimane immutata. In Python infatti le stringhe sono immutabili, così come anche gli altri tipi di dato fondamentali come int, float, boolean.

Qualora volessi catturare la nuova stringa dovrei salvare il risultato della chiamata a capitalize in una nuova variabile:

>>> age_capitalize = age.capitalize()

Oppure puoi anche sovrascrivere la variabile originaria:

>>> age = age.capitalize()

Ed ora uno sguardo approfondito a capitalize.

Python per principianti: oggetti, metodi e funzioni

Quello che abbiamo visto prima sulle stringhe è solo la punta dell'iceberg ma è utile se non altro ad introdurre uno dei concetti più importanti in Python: gli oggetti.

Anche se sembra una nozione astratta, gli oggetti in Python sono ovunque. Per esempio anche la nostra banale stringa è un oggetto:

>>> age = "diciotto"

Lo abbiamo appena scoperto chiamando:

>>> age.capitalize()
'Diciotto'

capitalize infatti è un metodo (non una funzione) collegato al tipo stringa di Python. Ricordi i tipi base?

Prova nella console di Python a digitare:

>>> str.capitalize("una stringa")
'Una stringa'

Bingo! capitalize è disponibile anche su "str", che in Python è un oggetto. Tutti gli oggetti di una determinata specie hanno quindi a disposizione dei metodi "universali" che operano su quell'oggetto.

Come distinguere quindi metodi e funzioni?

Le funzioni sono blocchi di codice riutilizzabili, indipendenti da (quasi) qualsiasi oggetto. Esempio: print(), oppure multiply() che abbiamo creato prima.

I metodi invece sono operazioni legate sempre agli oggetti, come str.capitalize e li puoi riconoscere dalla sintassi nome_oggetto.nome_metodo.

Quasi tutto in Python è un oggetto e sono oggetti anche i tipi base: str, bool, float, int.

Puoi scoprire quali metodi ci sono su un qualsiasi oggetto in due modi. Aggiungendo il punto e premendo tab in una console Python:

>>> str.
age.capitalize(
age.casefold(
age.count(

Oppure usando le due funzioni built-in help e dir. La funzione help ritorna l'aiuto per un determinato oggetto:

>>> help(str)
# si apre la documentazione per il tipo str

Mentre la funzione dir ritorna tutti i metodi (ed anche altre cose "strane" chiamati attributi) disponibili su un oggetto:

>>> dir(str)

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Anche per gli oggetti Python ci sono quelli built-in, ovvero già presenti nel linguaggio, e quelli custom, creati dai programmatori. Ma questa è una storia per un altro post!

Ora continuiamo la nostra esplorazione.

Python per principianti: input ed output

Stampare stringhe è una delle operazioni più comuni in Python. Hai visto già un esempio nella parte iniziale di questo tutorial:

print("Hello Python!")

print è una funzione built-in Python che consente di stampare a console messaggi per i nostri utenti. Se print può essere considerata una funzione di output la corrispondente funzione per gestire gli input è, che sorpresa, input.

Questa funzione accetta un messaggio come argomento, che verrà mostrato all'utente:

input("Please, insert your age\n")

L'istruzione \n è una sequenza di escape e serve a dare un a capo dopo il messaggio. Lanciando il codice sopra nella console Python dovresti vedere "Please, insert your age", seguito dalla possibilità di inserire un input per il programma.

Python per principianti: tipi di dato complessi

Molto spesso i tipi di dato base come float, int, str, e bool, non bastano a contenere tutto ciò che potremmo voler rappresentare in un programma.

E' a questo punto che entrano in gioco i cosiddetti tipi di dato complessi. Complessi non nel senso che sono difficili da capire, ma perché permettono di contenere informazioni in forma più strutturata rispetto a semplici numeri o stringhe.

Così oltre ai tipi di dato base, in Python ci sono anche strutture dati più organizzate, in particolare liste, tuple, dizionari e set.

Vale la pena vederle nel dettaglio, passandole in rassegna nelle prossime sezioni. (Tratterò i set in futuro).

Le liste in Python

Le liste in Python sono collezioni di elementi, definite anche array in altri linguaggi di programmazione. La necessità di avere liste nasce dal fatto che molto spesso abbiamo bisogno di gruppi di elementi nel nostro programma, e rappresentarli come singole variabili sarebbe deleterio.

Considera questo esempio:

city1 = "London"
city2 = "Berlin"
city3 = "Rotterdam"

Ci serve una lista di città ma per il momento l'unico modo che conosciamo per organizzare ogni città è salvarla in singole variabili. Ma c'è un modo migliore, e le liste Python permettono proprio di strutturare questo tipo di dati. Come?

Le liste in Python possono essere create con due parentesi quadre ed all'interno puoi dichiarare i singoli elementi:

cities = ["London", "Berlin", "Rotterdam"]

Questa è la tua prima lista! A questo punto vorrai accedere ad ogni singolo elemento della lista, che da questo momento in poi viene associato ad un indice numerico che parte da zero.

Per selezionare un elemento ora puoi chiamare cities seguito da parentesi quadre, più il numero dell'indice (provalo nella console di Python):

>>> cities = ["London", "Berlin", "Rotterdam"]
>>> cities[0]
'London'
>>> cities[1]
'Berlin'
>>> cities[2]
'Rotterdam'

Anche le liste in Python sono oggetti e se ricordi cosa ho detto qualche sezione fa, ti basterà mettere il punto dopo cities e premere tab per rivelare i metodi della lista:

>>> cities.
cities.append(   
cities.clear(    
cities.copy(
cities.count(    
cities.extend(   
cities.index(    
cities.insert(   
cities.pop(      
cities.remove(   
cities.reverse(  
cities.sort(

Prova a sperimentare con questi metodi ed osservane il risultato nella console di Python. Chiamando ad esempio il metodo reverse ti accorgerai che le liste sono mutabili:

>>> cities = ["London", "Berlin", "Rotterdam"]
>>> cities.reverse()
>>> cities
['Rotterdam', 'Berlin', 'London']

Un'altra caratteristica delle liste è che hanno una lunghezza, che può essere esaminata con la funzione built-in len:

>>> cities = ["London", "Berlin", "Rotterdam"]
>>> len(cities)
3

Le parentesi quadre inoltre non sono l'unico modo per creare liste. Chiamando list() infatti possiamo costruire liste partendo da altri tipi di dato.

Ma per il momento ti basti sapere che le liste Python sono molto utili per contenere collezioni di elementi. Ed ora uno sguardo al ciclo "for".

Il ciclo for sulle liste

Quando parliamo di cicli in programmazione, ci riferiamo ad istruzioni che passano su ogni elemento di una particolare struttura dati, eseguendo un'operazione che decidiamo noi.

Uno dei cicli più comuni è for, che data una lista (o una stringa), scorre su ogni elemento della sequenza.

Non ho introdotto il termine finora ma sappi che stringhe e liste in Python sono dette anche sequenze.

Venendo a for, ecco come funziona:

for element in ["London", "Berlin"]:
    print(element)

Tradotto in italiano sarebbe: per ogni elemento nella lista stampa l'elemento.

La variabile "element" è una mia invenzione, puoi chiamarla come ti pare. Anche il ciclo for è un po' magico perché Python sa che per ogni passaggio element prenderà un valore diverso.

Ecco come puoi immaginartelo:

1. element diventa "London" e viene stampato
2. element diventa "Berlin" e viene stampato

Tieni anche present che il ciclo for scorre automaticamente su tutti gli elementi della sequenza.

Se vuoi provare il codice sopra salvalo in un file ciclo_for.py e lancialo con

python3 ciclo_for.py

Dovresti vedere questo output sulla console:

London
Berlin

Prova ad usare for su una stringa. Come funziona?

List comprehension in Python

La list comprehension in Python è uno degli idiomi più belli di questo linguaggio. Ma a cosa serve esattamente?

Sono numerosi i casi in cui vogliamo creare nuove liste a partire da una lista di partenza.

La list comprehension permette di esprimere questa necessità in modo chiaro e conciso. Ecco un esempio.

Immagina di avere una lista Python composta da numeri:

>>> numbers = [1, 2, 3, 4, 5]

Ora, vogliamo moltiplicare tutti i numeri per 4 e creare una nuova lista come risultato. Una prima soluzione, logica, potrebbe essere quella di usare un ciclo for.

Ma in Python si può fare di meglio, con la list comprehension. Guarda che eleganza:

>>> numbers = [1, 2, 3, 4, 5]
>>> multiplied = [n * 4 for n in numbers]

Tra parentesi quadre diciamo a Python che deve moltiplicare ogni n per 4, per ogni n in numbers.

Il risultato è una nuova lista, multiplied, con il risultato:

>>> numbers = [1, 2, 3, 4, 5]
>>> multiplied = [n * 4 for n in numbers]
>> multiplied
[4, 8, 12, 16, 20]

Fai qualche esperimento sulla console Python e quando sei pronta/o scopri come filtrare le liste Python in questo video, proprio con la list comprehension.

Le tuple in Python

Se le liste Python sono mutabili, le tuple nascono proprio dalla necessità di proteggere determinati dati all'interno dei nostri programmi, prevenendo modifiche inattese.

Le tuple in Python infatti sono liste immutabili di elementi, e vengono dichiarate con una sintassi che prende a prestito le parentesi tonde:

>>> immutable_cities = ("London", "Berlin", "Rotterdam")

Anche gli elementi di una tupla possono essere recuperati con l'accesso via indice:

>>> immutable_cities = ("London", "Berlin", "Rotterdam")
>>> immutable_cities[1]
'Berlin'

Ma la cosa importante è che non possono essere modificati:

>>> immutable_cities = ("London", "Berlin", "Rotterdam")
>>> immutable_cities[1] = "Rome"

TypeError: 'tuple' object does not support item assignment

I dizionari in Python

Quando liste e tuple non bastano i dizionari Python diventano lo strumento adatto per descrivere dati più strutturati.

Se vuoi crearti uno schema mentale pensa ai dizionari come ad elenchi telefonici dove ogni numero di telefono è associato ad un nome. Ecco un esempio:

my_phonebook = {
    "giovanni rossi": "02886655",
    "giovanni galli": "02886655",
    "gianni rivera": "02886655",
}

Nel nostro esempio il nome dell'utente è una stringa e così anche il valore associato sulla destra.

Il nome dell'utente è anche la chiave (key) per accedere al suo numero di telefono, ovvero al valore (value).

I dizionari Python (detti anche dict per brevità) comunque non sono limitati solo a contenere stringhe. I valori di una chiave possono essere infatti di qualsiasi tipo:

caty = {
    "name": "Caty",
    "age": 30,
    "job": "Teacher",
    "interests": ["Hiking", "Reading"],
    "parents": ["Tony", "Chiara"],
}

In questo altro esempio abbiamo la chiave "age" a cui è assegnato un numero, e le chiavi "interests" e "parents" a cui sono assegnate liste di stringhe.

Ma a cosa servono i dizionari in fin dei conti? Dopo averne dichiarato uno puoi accedere ad ogni valore del dizionario attraverso la chiave corrispondente:

caty = {
    "name": "Caty",
    "age": 30,
    "job": "Teacher",
    "interests": ["Hiking", "Reading"],
    "parents": ["Tony", "Chiara"],
}

print(caty["name"])
print(caty["interests"])

Come puoi notare la sintassi per accedere ai valori è:

caty["name"]
caty["interests"]

Se il valore a cui accedi è una lista oppure una tupla non dimenticare di usare l'indice per recuperare gli elementi:

caty["interests"][0]

I dizionari in Python: modificare e cancellare i valori

A differenza di stringhe e tuple, i dizionari Python sono mutabili. Questo significa che è possibile modificarne i valori:

paul = {
    "name": "Paul",
    "age": 34,
    "city": "London",
    "occupation": "Developer",
    "married": False,
}

paul["occupation"] = "Biologist"
paul["age"] = 31

Non solo, nel caso in cui un valore non sia più richiesto è possibile eliminarlo completamente con l'operatore Python del:

paul = {
    "name": "Paul",
    "age": 34,
    "city": "London",
    "occupation": "Developer",
    "married": False,
}

del paul["married"]
del paul["age"]

Nota che modificare o cancellare i valori significa sempre e comunque farlo attraverso la rispettiva chiave.

Python per principianti: controllo del flusso

COMING SOON

Python per principianti: i moduli

Una delle caratteristiche più importanti di Python è la sua modularità. In programmazione un modulo è un insieme di funzioni correlate, che in genere servono per lavorare su un tipo di dato specifico.

Esempi di moduli potrebbero essere un gruppo di funzioni per lavorare sulle stringhe oppure un gruppo di funzioni per operare sui numeri.

La cosa interessante è che qualsiasi file Python che contiene dichiarazioni di funzioni o di variabili diventa un modulo. Crea un file Python, chiamalo str_utils.py (assicurati di essere sempre in ~/python_code) ed all'interno crea due semplici funzioni:

def includes(member, target):
    return member in target


def capitalize(string):
    return string.capitalize()

Hai creato il tuo primo modulo! Ma a cosa serve davvero un modulo? La comodità sta nel poter dichiarare funzioni e variabili in un file per poi importarle e riutilizzarle altrove nel programma.

Python infatti trasforma automaticamente ogni file in un modulo, che può essere importato in altri file con l'istruzione import. Se ad esempio abbiamo un file denominato str_utils.py` possiamo importarlo in un altro punto del programma.

Crea un nuovo file (sempre in ~/python_code) e chiamalo testing_str_utils.py. Nel file importa str_utils.py in testa:

import str_utils

L'istruzione import legge il file e rende disponibili in testing_str_utils.py le due funzioni dichiarate in str_utils.py, cosicchè possiamo usarle come se fossero metodi dell'oggetto str_utils, quindi con la sintassi nome_oggetto.nome_metodo:

import str_utils

str_utils.includes("a", "valentino")
str_utils.capitalize("valentino")

L'istruzione import offre anche una variazione, from nome_modulo import funzione, che risulta utile quando siamo interessati a singole funzioni del modulo.

Mettiamo caso di avere un modulo con tre funzioni:

def includes(member, target):
    return member in target


def capitalize(string):
    return string.capitalize()


def concat(string, other):
    return f"{string} {other}"

Volendo importare solo includes e concat in un altro file possiamo usare il seguente formato di import:

from str_utils import includes, concat

A questo punto le due funzioni diventano disponibili direttamente, senza usare nome_modulo.nome_metodo:

from str_utils import includes, concat

includes("a", "valentino")
concat("valentino", "oooo")

Come puoi intuire i moduli sono ottimi per creare gruppi di funzioni riutilizzabili: se le funzioni sono ricette, i moduli sono libri di ricette!

I moduli della standard library Python

A parte i moduli "fatti in casa", uno dei punti di forza di Python è il vasto catalogo di moduli già pronti, detto stdlib (che sta per standard library). Il concetto di standard library non è esclusivo di Python, quasi tutti i linguaggi di programmazione hanno un certo numero di moduli inclusi.

Sotto questo punto di vista Python abbonda, e molti sono i moduli built-in disponibili per l'importazione nei tuoi programmi Python. Per citarne alcuni, il modulo time è utile per lavorare con tutto quello che riguarda il tempo.

Ecco come generare un timestamp per esempio:

import time

timestamp = time.time()

print(timestamp)

"Famoso" anche il modulo random, comodo per produrre valori casuali:

import random

r = random.randint(0, 1500)

print(r)

La standard library di Python è veramente vasta. Per esplorare tutti i moduli ti rimando alla documentazione ufficiale: Python standard library.

Nella prossima sezione ci dedicheremo ad un aspetto di Python molto importante: l'ambiente virtuale. E nel frattempo vedremo anche i moduli Python di terze parti.

Ambienti virtuali e moduli di terze parti

Cosa succede quando la standard library di Python non basta ed abbiamo bisogno di moduli più specializzati che non sono inclusi nel linguaggio?

Niente paura: Python offre la possibilità di scaricare moduli di terze parti, messi a disposizione dalla community su un "mega repo" chiamato Python Package Index.

Non è tutto rose e fiori però, ed i problemi con i moduli di terze parti iniziano quando ne installiamo diversi, o quando alcuni moduli hanno bisogno di aggiornamenti.

Una tipica installazione di Python infatti tende per natura ad installare eventuali moduli esterni globalmente, rendendoli disponibili a tutte le applicazioni Python che girano sul sistema (o sul tuo computer).

Per evitare conflitti, o "rotture" improvvise di programmi Python a causa di aggiornamenti, negli anni sono stati studiate diverse soluzioni.

La più popolare si basa sui virtual environment Python, ovvero ambienti virtuali isolati all'interno dei quali puoi installare moduli di terze parti.

Come funziona? Mettiamo il caso di voler installare qualcosa come Django nel folder del tuo progetto ~/python_code. Una volta all'interno del folder:

cd ~/python_code

puoi lanciare:

python3 -m venv venv

Con questa istruzione crei un ambiente virtuale Python, ovvero un'installazione di Python stand-alone che non interferisce con quella del sistema.

Dopo aver creato l'ambiente virtuale devi attivarlo con:

source venv/bin/activate

Se l'attivazione va a buon fine il prompt del terminale cambierà, segno che sei nell'ambiente virtuale:

(venv) valentino@nome_host:~/python_code$

A questo punto puoi installare i moduli localmente al progetto, senza timore di "rompere" il sistema. Per installare un pacchetto Python puoi usare un tool chiamato pip, che è disponibile di default in ogni ambiente virtuale.

Supponendo quindi di voler installare Django nel tuo progetto puoi lanciare:

pip install django

Da questo momento Django sarà disponibile nell'ambiente virtuale, e solo per quel progetto.

Se tutti questi concetti hanno poco senso per te ora non disperare. Con il tempo avrai tanti momenti "a-ha" ripensando a questa guida!

Nota: Se il comando "python3 -m venv venv" non funziona su Ubuntu installa il modulo venv con:

sudo apt install python3-venv

Risorse

Cosa fare dopo aver finito questo tutorial? Il prossimo passo potrebbe essere costruire qualche piccola applicazione Python per risolvere le tue necessità: un bot Twitter, un calendario. Qualsiasi cosa che ti possa dare soddisfazione.

Altri strumenti interessanti basati su Python che potresti approfondire: Django, Flask.

Se ti interessa il machine learning e la computer vision ti suggerisco il canale Youtube del caro Maziar: AI and Coding.

Se sei una ragazza e la programmazione ti affascina tieni d'occhio anche Django Girls, un workshop gratuito che ti introdurrà al mondo Python e Django.

Django Girls organizza workshop in varie città d'Italia durante l'anno e per partecipare basta poco: un computer e tanta voglia d'imparare. Vai su Django Girls per scoprire le prossima date.

Domande frequenti

Che differenza c'è tra Django e Wordpress?

DISCLAIMER: il confronto sembra mele:pere, ma la domanda nasce perché Django è "venduto" anche per costruire semplici blog, e per avvicinare sempre più pubblico alla programmazione Python. Molte persone quindi si chiedono quale strada intraprendere e se vale la pena studiare Python/Django per fare siti web.

In parole povere possono fare grosso modo le stesse cose: sia Django che Wordpress sono adatti per creare blog e siti web. Wordpress è uno strumento "chiavi in mano" basato su PHP, indicato per i principianti che vogliono costruire siti web da zero in pochi minuti.

Django invece è uno strumento molto più potente di Wordpress, è scritto in Python, un linguaggio relativamente semplice da imparare. Lo sviluppatore che ha voglia di studiare e "sporcarsi le mani" può costruire con Django non solo blog, ma anche applicazioni molto complesse. La curva di apprendimento però più alta di Wordpress.

Che differenza c'è tra Django e Flask?

Django è un framework chiavi in mano e lo ritengo adatto anche a chi inizia perché permette di costruire una semplice applicazione web in poco tempo.

Flask invece è minimale e richiede che tutti i pezzi che compongono l'applicazione debbano essere assemblati uno per uno.

Non posso affermare che uno sia meglio dell'altro, però cambia lo stile di apprendimento: con Flask devi studiare di più prima di avere un progetto funzionante. Con Django invece hai quasi "la pappa pronta".

Dipende da quanta fretta ha lo studente: chi ha tempo e voglia di studiare tutti i singoli componenti può scegliere Flask, che è molto più educativo sotto questo punto di vista. chi invece ha fretta di vedere subito qualcosa di funzionante può optare per Django.

Per fare un'analogia, Flask è un puzzle da costruire, Django invece è un puzzle quasi tutto assemblato, dove restano pochi tasselli da completare.

Links

1. Python is eating the world: How one developer's side project became the hottest programming language on the planet