Al termine di questo capitolo sarai in grado di:
input();Python è un linguaggio di programmazione general purpose, cioè progettato per essere utilizzato in moltissimi contesti.
È nato all'inizio degli anni Novanta per iniziativa di Guido van Rossum e nel corso degli anni è diventato uno dei linguaggi più utilizzati.
Python viene impiegato, tra gli altri, per:
Una delle ragioni del suo successo è la particolare attenzione dedicata alla leggibilità del codice.
Un linguaggio ad alto livello permette al programmatore di esprimere le proprie intenzioni utilizzando costrutti relativamente vicini al linguaggio umano e lontani dai dettagli dell'hardware.
Per esempio:
total = price * quantityè molto più immediato da comprendere rispetto alla gestione manuale delle istruzioni macchina necessarie per ottenere lo stesso risultato.
Lo stesso programma Python può essere eseguito, con gli opportuni strumenti, su:
In Python non è necessario dichiarare esplicitamente il tipo di una variabile prima di assegnarle un valore:
age = 25
name = "Mario"
price = 9.90Python determina il tipo a partire dal valore assegnato.
Questo non significa che Python sia "senza tipi": ogni valore ha comunque un tipo.
Per ragioni didattiche si dice spesso che Python è un linguaggio "interpretato". È una semplificazione utile per iniziare: normalmente scriviamo il codice sorgente e lo affidiamo all'interprete Python, senza dover produrre manualmente un eseguibile nativo prima dell'esecuzione.
L'implementazione più comune, CPython, utilizza comunque una fase intermedia di compilazione in bytecode.
Per ora è sufficiente ricordare il concetto pratico:
Scriviamo codice Python e lo eseguiamo attraverso l'interprete Python.
Indica se le seguenti affermazioni sono vere o false.
Indica almeno tre ambiti nei quali Python può essere utilizzato.
Cosa succede secondo te al termine di questo programma?
value = 10
value = "Python"Per programmare in Python servono principalmente:
Il sito ufficiale di riferimento è:
https://www.python.org/
Dopo l'installazione possiamo verificare la versione disponibile dal terminale:
python --versionSu alcuni sistemi il comando è:
python3 --versionLa versione esatta dipende dall'ambiente utilizzato.
Un programma Python viene normalmente salvato in un file con estensione:
.pyPer esempio:
hello.pyUn file Python è semplicemente un file di testo contenente istruzioni Python.
Il primo programma può essere estremamente semplice:
print("Hello, World!")La funzione print() visualizza un valore sullo standard output.
Possiamo naturalmente utilizzare una frase italiana:
print("Benvenuto nel corso di Python!")Se il file si chiama hello.py, dal terminale possiamo eseguire:
python hello.pyoppure, quando necessario:
python3 hello.pyPython mette a disposizione anche una console interattiva chiamata REPL:
Read -- Eval -- Print -- Loop
La REPL legge un'istruzione, la valuta, mostra il risultato e torna in attesa di una nuova istruzione.
Esempio:
>>> 2 + 3
5
>>> 10 * 5
50
>>> print("Ciao Python")
Ciao PythonLa REPL è particolarmente utile per:
.py?La REPL è ottima per esperimenti veloci.
Un file .py è invece più adatto quando vogliamo:
Apri la REPL ed esegui:
2 + 3poi:
10 * 7e infine:
100 / 4Osserva i risultati.
Crea un file chiamato hello.py che visualizzi:
Benvenuto nel corso di Python!Aggiungi poi una seconda riga contenente il tuo nome.
Prova nella REPL:
7 + 3 * 2e poi:
(7 + 3) * 2I risultati sono uguali? Perché?
Python non punta soltanto a permettere di scrivere programmi funzionanti. Punta anche a rendere il codice leggibile.
Puoi visualizzare lo Zen di Python con:
import thisTra i principi più importanti troviamo idee come:
Non è necessario imparare a memoria lo Zen di Python. È però utile farne propria l'idea principale:
Il codice deve essere scritto prima di tutto per essere compreso dalle persone.
Per esempio, questo codice è tecnicamente possibile:
x = 12
y = 5
z = x * yma, in un programma reale, questo è spesso più leggibile:
item_price = 12
item_quantity = 5
total_cost = item_price * item_quantityIl secondo esempio comunica immediatamente il significato dei dati.
Riscrivi il seguente codice utilizzando nomi più descrittivi:
a = 7.50
b = 4
c = a * bUna variabile è un nome associato a un valore.
Per creare una variabile utilizziamo l'operatore di assegnazione:
nome = valoreEsempio:
name = "Mario"
age = 25Abbiamo creato due variabili:
name contiene la stringa "Mario";age contiene l'intero 25.Possiamo utilizzare le variabili successivamente:
name = "Mario"
age = 25
print(name)
print(age)Output:
Mario
25= non significa "uguale"Questa distinzione è fondamentale.
In matematica:
x = 10può essere letto come "x è uguale a 10".
In Python, è più corretto leggerlo come:
assegna il valore 10 alla variabile
x.
Per esempio:
x = 10
x = 20Dopo la seconda istruzione, x contiene 20.
Python consente di riassegnare una variabile:
score = 10
print(score)
score = 20
print(score)Output:
10
20Il nome score continua a essere lo stesso, ma ora è associato a un
valore diverso.
Ogni valore in Python ha un tipo.
I quattro tipi fondamentali che utilizzeremo più spesso all'inizio sono:
Tipo Nome Esempio
int intero 42
float numero decimale 3.14
str stringa "Python"
bool booleano True
intRappresenta numeri interi:
age = 25
quantity = 100
temperature = -3floatRappresenta numeri in virgola mobile:
price = 9.99
weight = 2.5
temperature = 18.75In Python il separatore decimale è il punto, non la virgola:
price = 9.99non:
price = 9,99Quest'ultima espressione ha infatti un significato diverso in Python.
strUna stringa rappresenta testo:
name = "Mario"
product = 'Milk'Possiamo utilizzare sia gli apici singoli sia le virgolette doppie.
boolUn booleano può assumere soltanto due valori:
True
FalseAttenzione alle maiuscole: in Python si scrive True, non true.
Esempio:
is_available = True
is_closed = Falsetype()La funzione type() permette di conoscere il tipo di un valore:
age = 25
print(type(age))Output:
<class 'int'>Altri esempi:
print(type(3.14))
print(type("Python"))
print(type(True))Possiamo utilizzarla anche con le variabili:
price = 9.99
print(type(price))Python permette di aggiungere indicazioni sul tipo atteso:
age: int = 25
price: float = 9.99
name: str = "Mario"Queste indicazioni sono chiamate type hints o annotazioni di tipo.
Sono utili per:
È importante però capire che:
un type hint non trasforma Python in un linguaggio a tipizzazione statica e, da solo, non impedisce di assegnare un valore di tipo diverso.
Definisci:
item_name = "Eggs"
item_price = 3.99
item_stock_quantity = 120
in_stock = TrueStampa tutte le variabili.
Per ciascuna variabile dell'esercizio precedente stampa anche il tipo
usando type().
Scrivi:
score = 10poi assegna 25 alla stessa variabile e stampa il risultato.
Riscrivi le quattro variabili dell'esercizio 7 utilizzando type hints.
Un buon nome rende il codice più facile da capire.
Python impone alcune regole sintattiche.
Un nome può iniziare con:
_.Non può iniziare con un numero.
Sono validi:
item_name = "Apple"
_price = 0.99
item1_quantity = 10Non sono validi:
2item = "Apple"
5_price = 10Dopo il primo carattere possiamo utilizzare lettere, numeri e underscore:
item1_quantity = 10Non possiamo usare il trattino:
item-name = "Orange"Il simbolo - viene interpretato come operatore di sottrazione.
Le seguenti variabili sono diverse:
item = "Milk"
Item = "Bread"
ITEM = "Eggs"Python è quindi case-sensitive.
Python possiede parole riservate che hanno un significato speciale nella sintassi del linguaggio, come:
if
else
for
while
class
return
importNon possono essere utilizzate come normali nomi di variabile.
È inoltre fortemente consigliato non sovrascrivere i nomi di funzioni
integrate che utilizzeremo, come print, type o input.
Per esempio, evitare:
print = 5perché in seguito print() non sarà più disponibile come previsto.
snake_caseLa convenzione più comune per le variabili Python è snake_case:
user_name = "Alice"
total_price = 15.75
items_in_stock = 230È preferibile a nomi poco descrittivi come:
x = 15.75
a = 230quando il significato può essere espresso in modo chiaro.
Quali dei seguenti nomi sono validi?
total_price
2price
user-name
user_name
_price
class
item2Correggi:
user Name = "Mario"
item-price = 3.50
2items = 20Rendi più leggibili:
a = "Bread"
b = 4.52
c = 230Una variabile diventa davvero utile quando possiamo utilizzarla nelle espressioni.
Esempio:
item_price = 0.50
item_quantity = 100
total_cost = item_price * item_quantity
print(total_cost)Il risultato è:
50.0Abbiamo separato i dati dal calcolo:
prezzo × quantità = totaleQuesta è una delle idee fondamentali della programmazione.
item_name = "Cupcakes"
item_price = 0.50
item_quantity = 100
total_cost = item_price * item_quantity
print("Item:", item_name)
print("Price:", item_price)
print("Quantity:", item_quantity)
print("Total cost:", total_cost)Una variabile deve essere assegnata prima di essere utilizzata:
print(total_cost)se total_cost non è stata precedentemente definita, produce un errore:
NameErrorLa regola pratica è semplice:
Prima crea il dato, poi utilizzalo.
Definisci:
item_name = "Soda"
item_price = 6.99
purchase_quantity = 5Calcola:
total_cost = item_price * purchase_quantitye stampa tutti i dati.
Un prodotto costa 2.75 € e ne vengono acquistati 8.
Calcola il totale usando due variabili.
Python mette a disposizione i normali operatori matematici.
Operatore Significato Esempio
+ somma 5 + 2
- sottrazione 5 - 2
* moltiplicazione 5 * 2
/ divisione 5 / 2
// divisione intera 5 // 2
% resto 5 % 2
** potenza 5 ** 2
a = 5
b = 2
print(a + b)
print(a - b)
print(a * b)Output:
7
3
10/L'operatore / esegue la divisione:
print(5 / 2)Risultato:
2.5//L'operatore // restituisce il quoziente intero della divisione:
print(7 // 3)Risultato:
2%L'operatore % restituisce il resto:
print(7 % 3)Risultato:
1È molto utile, per esempio, per verificare se un numero è pari:
number = 8
print(number % 2)Se il risultato è 0, il numero è pari.
**print(2 ** 3)Risultato:
8Python applica le normali regole di precedenza.
Per esempio:
result = 10 + 5 * 2produce:
20perché la moltiplicazione viene eseguita prima della somma.
Le parentesi permettono di rendere esplicito l'ordine:
result = (10 + 5) * 2che produce:
30Una buona pratica è utilizzare le parentesi quando aiutano a rendere evidente l'intenzione del programmatore.
Dati:
a = 10
b = 3stampa:
Dato:
number = 17usa % per stabilire se il numero è pari o dispari.
Calcola separatamente:
10 + 5 * 2e:
(10 + 5) * 2Spiega la differenza.
Una stringa è una sequenza di caratteri.
Possiamo crearla con apici singoli:
name = 'Python'oppure con virgolette doppie:
name = "Python"Entrambe le forme sono valide.
Le stringhe possono contenere:
Esempio:
message = "Benvenuto al corso di Python!"Le stringhe possono contenere sequenze speciali precedute da \.
Le più comuni sono:
Sequenza Significato
\n nuova riga
\t tabulazione
\" virgolette doppie
\' apice singolo
\\ backslash
Esempio:
print("Hello\nWorld")Output:
Hello
WorldTabulazione:
print("Item:\tMilk")Virgolette:
print("She said: \"Hello\"")Backslash:
print("C:\\Users\\Mario")Quando dobbiamo scrivere stringhe contenenti molti backslash, può essere comodo utilizzare una raw string:
path = r"C:\Users\Mario\Documenti"
print(path)La r davanti alla stringa indica che il contenuto deve essere
trattato, per quanto riguarda le sequenze di escape, come una raw
string.
È particolarmente utile per:
Stampa:
Ciao
Python!utilizzando una sola stringa e \n.
Produci un output simile a:
Nome: Mario
Età: 25utilizzando \t.
Stampa:
C:\Users\Studente\Desktop\pythonprima utilizzando \\, poi utilizzando una raw string.
Possiamo unire due stringhe usando +:
first = "Hello"
second = "World"
message = first + " " + second
print(message)Output:
Hello WorldLa concatenazione funziona tra stringhe.
Non possiamo invece concatenare direttamente una stringa e un numero:
age = 25
print("Age: " + age)Questo produce un TypeError.
Dovremmo convertire il numero in stringa:
print("Age: " + str(age))Ma esiste un modo ancora più leggibile, che vedremo tra poco: le f-string.
L'operatore * può essere utilizzato con una stringa e un intero:
print("Ha" * 3)Output:
HaHaHaUna stringa è una sequenza. Ogni carattere occupa una posizione chiamata indice.
Consideriamo:
word = "Apple"Gli indici sono:
A p p l e
0 1 2 3 4L'indicizzazione in Python parte da 0.
Possiamo accedere a un carattere con:
print(word[0])Output:
AL'ultimo carattere può essere ottenuto utilizzando l'indice negativo
-1:
print(word[-1])Output:
eGli indici negativi partono dalla fine:
A p p l e
-5 -4 -3 -2 -1len()La funzione len() restituisce il numero di caratteri:
word = "Python"
print(len(word))Risultato:
6Gli spazi vengono conteggiati:
text = "Ciao mondo"
print(len(text))La lunghezza comprende anche lo spazio.
Dato:
grocery_item = "Milk"stampa:
Chiedi una parola all'utente e stampa:
La parola contiene X caratteriData:
word = "Programmazione"stampa:
Lo slicing permette di estrarre una parte di una sequenza.
La sintassi fondamentale è:
string[start:end]L'indice start è incluso.
L'indice end è escluso.
Per esempio:
fruit = "Strawberries"
print(fruit[0:5])produce:
StrawPerché vengono considerati gli indici:
0 1 2 3 4
S t r a wma non l'indice 5.
startword = "Python"
print(word[:3])Risultato:
Pytendprint(word[2:])Risultato:
thoncopy = word[:]La sintassi completa è:
string[start:end:step]Per esempio:
word = "Python"
print(word[::2])Prende un carattere ogni due.
Un esempio molto utile:
word = "Pizza"
print(word[::-1])Risultato:
azziPPossiamo estrarre parti di stringhe e poi unirle.
Esempio:
item = "Chocolate"
short = item[:5] + "..."
print(short)Output:
Choco...Possiamo anche lavorare su un testo più lungo:
grocery_items = "milk, eggs, cheese, bread, apples"
dairy1 = grocery_items[0:4]
dairy2 = grocery_items[12:18]
bakery1 = grocery_items[20:25]
message = (
"We have dairy and bakery items: "
+ dairy1
+ ", "
+ dairy2
+ ", and "
+ bakery1
+ " in aisle 5"
)
print(message)In questo caso lo slicing è stato utilizzato per estrarre porzioni precise della stringa.
Nella programmazione reale, se il testo ha una struttura variabile, non è generalmente una buona idea affidarsi a indici fissi. In questo capitolo lo facciamo intenzionalmente per imparare lo slicing.
Dato:
word = "Programming"estrai:
Dato:
word = "Python"crea una nuova stringa contenente la parola al contrario.
Dati:
a = "spaghetti"
b = "gelato"usa slicing e concatenazione per costruire:
spatoLe stringhe possiedono numerosi metodi integrati.
Consideriamo:
text = " Python è Fantastico ".upper()Converte in maiuscolo:
print(text.upper()).lower()Converte in minuscolo:
print(text.lower()).capitalize()Rende maiuscola la prima lettera:
print(text.capitalize()).title()Converte il testo in formato titolo:
print(text.title()).swapcase()Inverte maiuscole e minuscole:
print(text.swapcase()).strip()Rimuove gli spazi all'inizio e alla fine:
clean_text = text.strip()Esistono anche:
text.lstrip()
text.rstrip()che rimuovono rispettivamente gli spazi a sinistra e a destra.
.replace()Sostituisce una parte della stringa:
text = "Python è Fantastico"
print(text.replace("Fantastico", "Potente")).find()Cerca una sottostringa e restituisce la posizione della prima occorrenza:
text = "Ciao mondo"
print(text.find("mondo"))Se il testo non viene trovato, find() restituisce -1.
.count()Conta quante volte compare una sottostringa:
text = "banana"
print(text.count("a")).startswith() e .endswith()Permettono di verificare l'inizio e la fine di una stringa:
filename = "documento.pdf"
print(filename.startswith("doc"))
print(filename.endswith(".pdf"))Questi metodi restituiscono booleani.
Questo concetto è importante.
Le stringhe Python sono immutabili: un metodo come .upper() non
modifica direttamente la stringa originale.
Per esempio:
text = "python"
text.upper()
print(text)stampa ancora:
pythonPer conservare il risultato dobbiamo assegnarlo:
text = text.upper()
print(text)Ora otteniamo:
PYTHONQuesta caratteristica spiega perché spesso vediamo codice come:
text = text.strip()
text = text.lower()Dato:
text = " Python è Divertente ""Divertente" con "Potente".Dato:
text = "Python è un linguaggio potente"usa .find() per trovare la posizione di "linguaggio".
Dato:
filename = "report.pdf"verifica con .endswith() se il file è un PDF.
La conversione di tipo, o casting, permette di trasformare un valore in un altro tipo quando la conversione è possibile.
Le funzioni più utilizzate sono:
Funzione Risultato
int() intero
float() numero decimale
str() stringa
bool() booleano
number = int("42")Ora number è un intero.
price = float("3.99")age = 25
text = str(age)Questo è utile quando dobbiamo combinare un numero con testo attraverso concatenazione:
age = 25
print("Age: " + str(age))Non tutte le conversioni sono possibili:
number = int("abc")produce un ValueError, perché "abc" non rappresenta un intero
valido.
input(): leggere dati dall'utenteLa funzione input() permette di leggere un valore inserito
dall'utente:
name = input("Inserisci il tuo nome: ")
print("Ciao", name)Un dettaglio fondamentale:
input()restituisce sempre una stringa.
Anche se l'utente digita:
25Python riceve:
"25"e non:
25Per questo, se vogliamo eseguire operazioni numeriche, dobbiamo convertire il valore.
age = int(input("Inserisci l'età: "))
print(age + 1)Per un numero decimale:
price = float(input("Inserisci il prezzo: "))Questo codice non funziona come potremmo aspettarci:
number = input("Inserisci un numero: ")
print(number + 1)number è una stringa, quindi Python non può sommare direttamente una
stringa e un intero.
La correzione è:
number = int(input("Inserisci un numero: "))
print(number + 1)Chiedi:
Stampa:
Ciao Marco, hai 20 anniChiedi l'età e stampa quanti anni avrà l'utente tra 5 anni.
Chiedi due numeri interi e stampa:
Chiedi un prezzo e una quantità, convertendo correttamente i dati, poi calcola il totale.
I confronti producono valori booleani.
Gli operatori principali sono:
Operatore Significato
== uguale
!= diverso
> maggiore
< minore
>= maggiore o uguale
<= minore o uguale
Esempio:
age = 20
print(age >= 18)Risultato:
True= e ==Sono due operatori diversi.
age = 20assegna 20 a age.
age == 20chiede invece:
ageè uguale a20?
Il risultato è un booleano.
Immaginiamo di voler sapere se un prodotto è sotto la soglia minima:
milk_quantity = 12
low_stock_threshold = 10
low_stock = milk_quantity <= low_stock_threshold
print("Is the item low in stock?", low_stock)Il risultato è:
Is the item low in stock? FalseSe milk_quantity fosse 10, il risultato sarebbe True, perché
abbiamo utilizzato <=.
Dato:
total_cost = 25.00crea una variabile booleana che indichi se il cliente ha diritto allo
sconto quando il totale è almeno 20.00.
Per:
number = 15crea espressioni che verifichino:
I confronti diventano molto potenti quando possiamo combinarli.
Gli operatori logici principali sono:
and
or
notandRichiede che entrambe le condizioni siano vere:
age = 30
result = age >= 18 and age <= 65
print(result)Il risultato è True.
orÈ sufficiente che almeno una condizione sia vera:
day = "Saturday"
is_weekend = day == "Saturday" or day == "Sunday"notInverte un valore booleano:
is_closed = False
print(not is_closed)Risultato:
TruePossiamo costruire condizioni più significative.
Esempio:
stock = 50
minimum_stock = 10
on_sale = False
promotion = not on_sale and stock >= minimum_stock
print(promotion)Analizziamo l'espressione un pezzo alla volta:
not on_saleproduce True, perché on_sale vale False.
Poi:
stock >= minimum_stockproduce True, perché 50 >= 10.
Infine:
True and Trueproduce:
TrueQuesta tecnica è molto importante: costruire una condizione complessa partendo da condizioni semplici.
Dato:
age = 35verifica se l'età è compresa tra 18 e 65 anni.
Dato:
day = "Sunday"verifica se è sabato oppure domenica.
Un prodotto può essere promosso se:
Scrivi l'espressione booleana.
in e not inGli operatori:
in
not inpermettono di verificare se un elemento è contenuto in una sequenza o in un altro oggetto che supporta l'appartenenza.
Con le stringhe possiamo verificare la presenza di una sottostringa:
item_name = "Strawberries"
print("Straw" in item_name)Risultato:
TruePossiamo usare anche not in:
print("Banana" not in item_name)Python distingue maiuscole e minuscole:
"raw" in "RAW milk"restituisce:
Falseperché "raw" e "RAW" sono stringhe diverse.
Un modo semplice per rendere il controllo indipendente dalle maiuscole è normalizzare il testo:
description = "RAW milk"
contains_raw = "raw" in description.lower()
print(contains_raw)Dato:
description = "Fresh organic milk from local farms"verifica se contiene:
"organic";"local".Verifica che "meat" non sia presente nella descrizione.
Modifica il programma per trovare "ORGANIC" anche se nella descrizione
compare "organic".
Possiamo usare type() anche per confrontare il tipo di un valore:
product_name = "Almond Milk"
product_price = 3.49
product_quantity = 30
print(type(product_name) == str)
print(type(product_price) == float)
print(type(product_quantity) == int)Il risultato di ciascun confronto è un booleano.
Un caso interessante è quando il dato arriva come stringa:
product_price = "3.49"
print(type(product_price) == float)Il risultato è:
FalseIl contenuto sembra un prezzo, ma il tipo è str.
In Python moderno, quando si vuole verificare il tipo tenendo conto
anche dell'ereditarietà, può essere preferibile utilizzare
isinstance():
is_price_numeric = isinstance(product_price, (int, float))Per ora è sufficiente sapere che type() permette di osservare il tipo
effettivo di un valore e che isinstance() è spesso più flessibile per
controllare se un oggetto appartiene a un determinato tipo o famiglia di
tipi.
Dati:
price = 4.50
count = 10crea:
price_is_float
count_is_intutilizzando type().
Dato:
price = "4.50"verifica il tipo e spiega perché:
type(price) == floatrestituisce False.
Le f-string sono il metodo più pratico e leggibile per costruire stringhe che contengono valori.
Esempio:
name = "Anna"
age = 25
print(f"Ciao {name}, hai {age} anni")Le variabili vengono inserite direttamente tra parentesi graffe:
{name}
{age}Possiamo inserire anche espressioni:
age = 25
print(f"Tra 5 anni avrai {age + 5} anni")Output:
Tra 5 anni avrai 30 anniSupponiamo di avere:
price = 9.5Possiamo visualizzarlo con due cifre decimali:
print(f"Prezzo: {price:.2f} €")Output:
Prezzo: 9.50 €La parte:
:.2fsignifica che vogliamo rappresentare il numero in formato decimale con due cifre dopo il punto.
Questo:
print("Price: " + str(price) + " €")funziona, ma è meno leggibile.
Questo:
print(f"Price: {price:.2f} €")è generalmente più chiaro.
Per questo motivo, nelle nostre esercitazioni useremo prevalentemente le f-string.
Chiedi:
Stampa con una sola f-string:
Nome: Mario Rossi – Età: 25Dato:
price = 7.5stampa:
Prezzo: 7.50 €Dati:
price = 4.25
quantity = 6calcola il totale e visualizzalo con due cifre decimali.
Ora possiamo combinare diversi concetti.
Realizziamo un piccolo programma che gestisce un acquisto.
Il programma deve:
Una possibile soluzione è:
product = input("Inserisci il prodotto: ")
price = float(input("Inserisci il prezzo: "))
quantity = int(input("Inserisci la quantità: "))
total = price * quantity
print()
print("=== RIEPILOGO ACQUISTO ===")
print(f"Prodotto: {product}")
print(f"Prezzo: {price:.2f} €")
print(f"Quantità: {quantity}")
print(f"Totale: {total:.2f} €")Esempio di esecuzione:
Inserisci il prodotto: Pane
Inserisci il prezzo: 2.50
Inserisci la quantità: 3
=== RIEPILOGO ACQUISTO ===
Prodotto: Pane
Prezzo: 2.50 €
Quantità: 3
Totale: 7.50 €Abbiamo utilizzato:
input();str;float;int;Questo è già un vero piccolo programma, anche se molto semplice.
Possiamo applicare gli stessi concetti a un'altra situazione.
name = input("Nome: ")
surname = input("Cognome: ")
age = int(input("Età: "))
full_name = f"{name} {surname}"
print()
print(f"{full_name} ha {age} anni")
print(f"Il nome completo contiene {len(full_name)} caratteri")
print(f"L'anno prossimo avrà {age + 1} anni")In questo esempio abbiamo anche utilizzato len() e un'espressione
dentro una f-string.
Imparare a programmare significa anche imparare a leggere gli errori.
NameErrorSi verifica quando utilizziamo un nome che Python non conosce:
print(total)se total non è mai stata definita.
TypeErrorSi verifica quando tentiamo di eseguire un'operazione incompatibile con i tipi coinvolti:
age = 25
print("Age: " + age)Correzione:
print("Age: " + str(age))oppure, meglio:
print(f"Age: {age}")ValueErrorSi verifica quando una conversione riceve un valore non valido:
number = int("abc")Python non può trasformare "abc" in un intero.
L'accesso diretto a un carattere con un indice non valido produce
IndexError:
word = "Hi"
print(word[5])Lo slicing è invece più permissivo:
print(word[5:10])restituisce semplicemente una stringa vuota.
Questa differenza è importante.
= e ==?input()?type()?-1?/ e //?%?and, or e not?in e not in?:.2f in una f-string?int("10") e "10"?Crea le variabili:
item_name
item_price
items_in_stock
in_stockutilizzando tipi appropriati.
Stampa:
Prodotto: ...
Prezzo: ... €
Disponibilità: ...
Pezzi: ...Utilizza una f-string per ogni riga.
Chiedi all'utente:
Calcola il totale e visualizza il risultato con due cifre decimali.
Chiedi una parola all'utente e visualizza:
Esempio:
Parola: Python
Lunghezza: 6
Primo carattere: P
Ultimo carattere: n
Maiuscolo: PYTHON
Al contrario: nohtyPDato:
description = "Fresh organic milk from local farms"verifica se contiene:
"organic";"local";"meat".Stampa i tre risultati.
Dati:
stock = 12
minimum_stock = 10crea una variabile:
low_stockche valga True quando la quantità è minore o uguale alla soglia
minima.
Chiedi l'età all'utente e verifica se è compresa tra 18 e 65 anni.
Non è necessario utilizzare if: per ora è sufficiente produrre e
stampare il valore booleano.
È arrivato il momento di mettere insieme tutto ciò che abbiamo imparato.
Realizza un programma Python per la gestione di un prodotto di magazzino.
Il programma deve chiedere all'utente:
Il programma deve poi:
valore_magazzino = prezzo × quantitàIl prodotto è disponibile se la quantità è maggiore di 0.
Utilizza una soglia:
minimum_stock = 10e determina se la scorta è bassa.
Verifica se la descrizione contiene la parola:
organicIl controllo deve funzionare anche se l'utente scrive Organic o
ORGANIC.
L'output deve essere leggibile e utilizzare le f-string.
Un possibile risultato è:
========================================
SCHEDA PRODOTTO
========================================
Prodotto: Organic Milk
Categoria: Dairy
Prezzo: 3.49 €
Quantità disponibile: 25
Valore magazzino: 87.25 €
Disponibile: True
Scorta bassa: False
Prodotto organic: True
========================================Per questa versione della sfida puoi utilizzare esclusivamente i concetti studiati nel capitolo:
input();int();float();str;bool;and, or, not;in, not in;len();Non utilizzare ancora if, for, while, liste o dizionari.
L'obiettivo è imparare a costruire un programma significativo utilizzando soltanto i mattoni fondamentali.
Una possibile soluzione è:
product = input("Nome prodotto: ")
category = input("Categoria: ")
price = float(input("Prezzo: "))
quantity = int(input("Quantità disponibile: "))
description = input("Descrizione: ")
minimum_stock = 10
stock_value = price * quantity
available = quantity > 0
low_stock = quantity <= minimum_stock
is_organic = "organic" in description.lower()
print()
print("========================================")
print(" SCHEDA PRODOTTO")
print("========================================")
print()
print(f"Prodotto: {product}")
print(f"Categoria: {category}")
print(f"Prezzo: {price:.2f} €")
print(f"Quantità disponibile: {quantity}")
print(f"Valore magazzino: {stock_value:.2f} €")
print()
print(f"Disponibile: {available}")
print(f"Scorta bassa: {low_stock}")
print(f"Prodotto organic: {is_organic}")
print("========================================")Il programma è interessante non perché sia complesso, ma perché mette insieme molte idee fondamentali:
input()
↓
conversione dei dati
↓
variabili
↓
calcoli
↓
confronti
↓
metodi delle stringhe
↓
valori booleani
↓
f-string
↓
outputQuesta sequenza rappresenta uno schema che incontreremo continuamente nei programmi reali:
acquisire dati → elaborarli → produrre un risultato
In questo capitolo abbiamo costruito le fondamenta necessarie per iniziare a programmare in Python.
Abbiamo visto che:
.py;int, float, str e bool;type() permette di conoscere il tipo di un valore;snake_case è la convenzione normalmente utilizzata per le
variabili;len() restituisce la lunghezza di una stringa;int(), float() e str() permettono di convertire i valori;input() restituisce sempre una stringa;and, or e not permettono di combinare condizioni;in e not in permettono di verificare l'appartenenza;Questi concetti sono i mattoni fondamentali sui quali costruiremo tutto il resto del linguaggio.
Nel prossimo capitolo potremo utilizzare questi strumenti per fare qualcosa di ancora più interessante: far prendere decisioni ai nostri programmi.