VS Code per Python, esercizi spiegati
Cinque situazioni, una scelta alla volta
- 20 minuti di lettura
Cinque situazioni che a Piazza Query capitano davvero. Ognuna ha lo stesso ritmo:
- Prevedi: leggi la situazione e rispondi, su un foglio, prima di aprire la risposta.
- In italiano: cosa sta succedendo, a parole.
- Passo per passo: cosa fa VS Code, un gesto alla volta.
- Cosa portiamo a casa: la cosa da ricordare.
Gli output sono veri: sono stati ottenuti lanciando i comandi. Le schermate di VS Code, invece, qui le descriviamo: i nomi dei pulsanti sono quelli esatti, in inglese, come li vedi tu.
A · Due cartelle, un solo programma
Marta Villa ha un programma, dove_sono.py, che stampa la cartella da cui parte e cerca orari.txt lì accanto. Il progetto sta in banco-vscode/palestra/01-cartella/campo, e orari.txt è dentro campo.
Lucia Ferri prova due volte. La prima apre in VS Code proprio campo e preme ▶. La seconda apre 01-cartella, la cartella sopra, e preme ▶ sullo stesso file.
Il ▶ lancia il programma dalla cartella aperta. È come se nel terminale scrivessi:
cd campo
python dove_sono.pye poi:
cd ..
python campo/dove_sono.pyCosa stampano i due tentativi?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Sono partito da: /Users/marta/corso/banco-vscode/palestra/01-cartella/campo
Gli orari li trovo: orari.txtSono partito da: /Users/marta/corso/banco-vscode/palestra/01-cartella
Gli orari non li trovo: da qui orari.txt non esisteStesso file, stesso Python, risultati diversi: cambia solo la cartella da cui si parte.
In italiano. Il programma cerca orari.txt «qui», cioè nella cartella da cui è stato lanciato, non in quella dove sta il file .py. Nel primo tentativo «qui» è campo, e orari.txt c'è. Nel secondo «qui» è la cartella sopra, e orari.txt non c'è.
Passo per passo.
| Gesto | Cartella aperta in VS Code | Da dove parte il ▶ | orari.txt |
|---|---|---|---|
code campo, poi ▶ | campo | campo | trovato |
code 01-cartella, poi ▶ | 01-cartella | 01-cartella | non trovato |
Cosa portiamo a casa. Il ▶ non parte da dove sta il file: parte dalla cartella che hai aperto. Prima di dare la colpa al codice, guarda in cima all'Explorer.
B · Lo stesso file, due Python
Nel computer di Piazza Query ci sono due venv: quello dello zip (banco-vscode/.venv) e quello del tabellone (.../tabellone/.venv). chi_sono.py stampa quale Python lo ha eseguito.
In VS Code, il ▶ scrive nel terminale interprete scelto + file. Prima Ernesto sceglie come interprete il venv dello zip, poi quello del tabellone. A mano:
../../../../.venv/bin/python chi_sono.py
.venv/bin/python chi_sono.py(Si parte da banco-vscode/palestra/02-interprete/campo/tabellone.) Cosa stampa ognuno?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Mi ha eseguito il Python di: /Users/marta/corso/banco-vscode/.venv
Mi ha eseguito il Python di: /Users/marta/corso/banco-vscode/palestra/02-interprete/campo/tabellone/.venvIl primo percorso è il venv dello zip, il secondo è quello del tabellone: tutti e due finiscono con .venv.
In italiano. sys.prefix dice la cartella del venv che sta eseguendo il programma. Cambiando interprete cambia questa riga, e con lei i pacchetti che il programma può importare: ogni venv ha i suoi.
Passo per passo.
- Apri il file
.py. In basso a destra leggi l'interprete: una versione e.venv. - Non sei sicuro di quale
.venvsia? Clicca sul pulsante: si apre l'elenco. Sotto ogni voce c'è il percorso. - Quello che vuoi non c'è, o ne vedi due uguali? Palette dei comandi → Python: Select Interpreter → Enter interpreter path… → Find…, e vai a prendere
.venv/bin/pythondentrotabellone. - Premi ▶ e guarda la riga stampata.
Cosa portiamo a casa. Due .venv si chiamano uguale: li distingue il percorso. Quando un programma dice No module named ... in VS Code ma non nel terminale, il primo sospetto è l'interprete.
C · Il terminale già aperto
Tommaso Greco ha aperto VS Code su banco-vscode e il terminale integrato era già lì. Poi ha scelto l'interprete .venv. Nel terminale il prompt non ha (.venv).
Cosa deve fare per avere il venv acceso? E come controlla di averlo?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Chiude il terminale con l'icona del cestino e ne apre uno nuovo (View → Terminal). Il terminale nuovo parte con (.venv) nel prompt, perché VS Code lo accende da solo. Oppure, nello stesso terminale, scrive:
source .venv/bin/activatePer controllare:
which python
echo $VIRTUAL_ENV/Users/marta/corso/banco-vscode/.venv/bin/python
/Users/marta/corso/banco-vscode/.venvIn italiano. L'impostazione python.terminal.activateEnvironment accende il venv quando il terminale nasce. Un terminale già aperto non rilegge niente. which python dice quale Python risponde, $VIRTUAL_ENV dice quale venv è acceso: se non coincidono con il progetto, qualcosa è spento o sbagliato.
Passo per passo.
| Cosa vedi | Cosa vuol dire | Cosa fai |
|---|---|---|
Prompt con (.venv) e which python dentro il progetto | tutto a posto | niente |
Prompt senza (.venv) | il terminale è nato prima dell'interprete | cestino, terminale nuovo |
(.venv) ma which python dice un altro progetto | hai acceso il venv di un altro progetto | deactivate, cd giusto, source .venv/bin/activate |
Il perché dei comandi source e which è nel capitolo Il venv e pip.
Cosa portiamo a casa. Nel terminale integrato vale quello che già sai, con un aiuto in più: VS Code accende il venv da solo, ma solo ai terminali nuovi.
D · I test nel pannello, e il file che nasce
Il progetto dei biglietti ha tre test, e il pannello Testing (la provetta a sinistra) è vuoto. Marta lo configura: Testing → Configure Python Tests → pytest → . Root directory.
Cosa succede sul disco? E quando preme ▶ in cima al pannello, cosa vede? (Uno dei tre test è rosso apposta.)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
VS Code scrive il file .vscode/settings.json dentro la cartella aperta:
{
"python.testing.pytestArgs": [
"."
],
"python.testing.unittestEnabled": false,
"python.testing.pytestEnabled": true
}E il pannello fa quello che farebbe pytest dal terminale, nella stessa cartella:
..F [100%]
=================================== FAILURES ===================================
________________________ test_il_ridotto_costa_la_meta _________________________
def test_il_ridotto_costa_la_meta():
> assert prezzo(2, ridotto=True) == 2.20
E assert 4.4 == 2.2
E + where 4.4 = prezzo(2, ridotto=True)
test_biglietti.py:15: AssertionError
=========================== short test summary info ============================
FAILED test_biglietti.py::test_il_ridotto_costa_la_meta - assert 4.4 == 2.2
1 failed, 2 passed in 0.01sDue spunte verdi e una croce rossa. Il tutto è l'output di python -m pytest -q, lanciato dentro campo.
In italiano. Il pannello è un telecomando per pytest. Per usarlo gli servono tre informazioni, e le trova nel settings.json della cartella: usa pytest (pytestEnabled), non usare unittest (unittestEnabled), cerca qui (pytestArgs con il punto: la cartella aperta).
Passo per passo.
- Apri la cartella giusta. Il pannello cerca i test da lì.
- Scegli l'interprete: serve pytest dentro quel venv.
- Configure Python Tests → pytest → . Root directory.
- Compaiono i test. Premi ▶. Se il pannello resta vuoto dopo la configurazione, Refresh Tests (le due frecce in cerchio).
- Apri
.vscode/settings.json: ci sono le tre righe di sopra.
Cosa portiamo a casa. Tutto quello che VS Code «sa» di un progetto sta in un file di testo che puoi aprire e leggere. Come leggere il rosso e il verde è nel capitolo Lanciare i test.
E · Il file scritto di fretta
Sergio Colombo ha scritto in fretta turni_di_servizio.py: virgolette di due tipi, spazi dove capitano, una riga lunghissima. Prima di Ruff era così:
"""I turni del personale della Linea Menta."""
turni = {'Lucia Ferri':'M12','Sergio Colombo':'M14',
'Tommaso Greco':'T28'}
def turno_di( nome ):
if nome in turni :
return turni[nome]
return 'nessun turno'
def riepilogo(turni, ore_per_turno=8, straordinari=2):
righe=[]
for nome,treno in turni.items():
righe.append(nome+' guida il '+treno+' per '+str(ore_per_turno+straordinari)+' ore, compresi gli straordinari')
return righe
print( riepilogo(turni) )Sergio dà Format Document con Ruff e salva. Cosa succede alla riga con righe.append(...), la più lunga? E alle virgolette?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Dal terminale, Ruff si lancia con ruff format:
ruff format turni_di_servizio.py1 file reformattedE il file diventa:
"""I turni del personale della Linea Menta."""
turni = {"Lucia Ferri": "M12", "Sergio Colombo": "M14", "Tommaso Greco": "T28"}
def turno_di(nome):
if nome in turni:
return turni[nome]
return "nessun turno"
def riepilogo(turni, ore_per_turno=8, straordinari=2):
righe = []
for nome, treno in turni.items():
righe.append(
nome
+ " guida il "
+ treno
+ " per "
+ str(ore_per_turno + straordinari)
+ " ore, compresi gli straordinari"
)
return righe
print(riepilogo(turni))Se lo lanci una seconda volta, Ruff non ha niente da fare e lo dice:
1 file already formattedIn italiano. Ruff riscrive il file con regole fisse: virgolette doppie, uno spazio dopo la virgola e attorno a =, due righe vuote tra le funzioni, righe lunghe al massimo 88 caratteri (quelle più lunghe vengono spezzate). Non cambia cosa fa il programma: dopo il formato, riepilogo(turni) dà gli stessi risultati di prima.
Passo per passo.
- Controlla che l'estensione Ruff sia installata (e, su WSL, anche dentro Ubuntu: Install in WSL: Ubuntu).
- Apri il file. Tasto destro → Format Document. La prima volta, se VS Code ti chiede quale formattatore, scegli Ruff.
- Per non doverlo più fare a mano, scrivi nel
.vscode/settings.json:
{
"editor.formatOnSave": true,
"[python]": {
"editor.defaultFormatter": "charliermarsh.ruff"
}
}- Salva un file disordinato: si sistema da solo.
Cosa portiamo a casa. Il formato non si discute e non si fa a mano: lo fa Ruff, e con formatOnSave lo fa a ogni salvataggio. Le regole stanno in due righe del settings.json, una per dire quando, una per dire chi.