2. Configurazione di un ambiente di sviluppo

2.1. Python 3.8.1

Gli esempi contenuti in questo documento sono stati testati con l'interprete Python 3.8.1 disponibile all'URL |https://www.python.org/downloads/| (febbraio 2020) su un computer con sistema operativo Windows 10:

L'installazione di Python crea la directory dei file [1] e il menu [2] nell'elenco dei programmi:

[3-4]: due interpreti Python interattivi;
[5]: documentazione di Python;
[6]: documentazione dei moduli Python;

Non useremo l'interprete Python interattivo. È semplicemente importante sapere che gli script in questo documento potrebbero essere eseguiti usando questo interprete. Sebbene sia utile per testare come funziona una funzionalità di Python, non è molto pratico per gli script che devono essere riutilizzati. Ecco un esempio che utilizza l'opzione [4] sopra:

Il prompt >>> consente di inserire un'istruzione Python che viene eseguita immediatamente. Il codice digitato sopra ha il seguente significato:

>>> nom="tintin"
>>> print("nom=%s" % nom)
nom=tintin
>>> print("type=%s" % type(nom))
type=<class 'str'>
>>>

Righe:

1: Inizializzazione di una variabile. In Python non si dichiara il tipo delle variabili. Esse assumono automaticamente il tipo del valore loro assegnato. Questo tipo può cambiare nel tempo;
2: visualizzazione del nome. 'name=%s' è un formato di visualizzazione in cui %s è un parametro formale che indica una stringa. name è il parametro effettivo che verrà visualizzato al posto di %s;
3: il risultato della visualizzazione;
4: visualizzazione del tipo della variabile name;
5: La variabile name è di tipo class in questo caso. In Python 2.7, avrebbe il valore <type 'str'>;

Ora, apriamo una console di Windows:

Il fatto che siamo riusciti a digitare [python] in [1] e che l'eseguibile [python.exe] sia stato trovato dimostra che si trova nel PATH del computer Windows. Questo è importante perché significa che gli strumenti di sviluppo Python saranno in grado di trovare l'interprete Python. Possiamo verificarlo come segue:

in [2], usciamo dall'interprete Python;
in [3], il comando che visualizza il PATH per gli eseguibili sul computer Windows;
in [4], vediamo che la cartella dell'interprete Python 3.8 fa parte del PATH;

2.2. L'IDE PyCharm Community

2.2.1. Introduzione

Per compilare ed eseguire gli script in questo documento, abbiamo utilizzato l'editor [PyCharm] Community Edition, disponibile (febbraio 2020) all'URL |https://www.jetbrains.com/fr-fr/pycharm/download/#section=windows|:

Scaricare l'IDE PyCharm Community [1-3] e installarlo.

Avviare l'IDE PyCharm e creare il primo progetto Python:

In [2-4], creare un nuovo progetto;

L'IDE PyCharm visualizza il progetto creato come segue:

In [2-3], esaminiamo le proprietà dell'IDE;

in [4], l'interprete Python che verrà utilizzato per il progetto;
in [5], un elenco a discesa degli interpreti disponibili;
In [6], selezionare l'interprete scaricato nella sezione |Python 3.8.1|;

in [7], l'interprete selezionato;
in [8], l'elenco dei pacchetti disponibili con questo interprete. I pacchetti contengono moduli che gli script Python possono utilizzare. Sono disponibili centinaia di moduli;

Iniziamo creando una cartella in cui inseriremo il nostro primo script Python:

Fai clic con il tasto destro del mouse sul progetto, quindi [1-2] per creare una cartella;
In [3], digita il nome della cartella: verrà creata nella cartella del progetto;

Successivamente, creiamo uno script Python:

Fai clic con il tasto destro sulla cartella [bases], quindi [1-3];
In [4-5], inserisci il nome dello script;

Scriviamo il nostro primo script:

In [3], scriviamo il seguente script:

righe 1, 3: i commenti iniziano con il simbolo #;
riga 2: inizializzazione di una variabile. Python non dichiara il tipo delle sue variabili;
riga 4: output sullo schermo. La sintassi utilizzata qui è [formato % dati] con:
- formato: nome=%s dove %s indica il segnaposto per una stringa. Questa stringa si troverà nella parte [dati] dell'espressione;
- dati: il valore della variabile [nome] sostituirà il segnaposto %s nella stringa di formato;

Con [4-5], riformattiamo il codice secondo le raccomandazioni dell'ente di controllo di Python;

Lo script viene eseguito facendo clic con il tasto destro del mouse sul codice [6]:

in [7], il comando eseguito;
in [8], il risultato dell'esecuzione;

Per eseguire lo script nel documento, scaricare il codice dall'URL |https://tahe.developpez.com/tutoriels-cours/python-flask-2020/documents/python-flask-2020.rar| e poi procedere come segue in PyCharm:

in [1-2], aprire un progetto esistente: selezionare la cartella contenente il codice scaricato;
in [3], il progetto è aperto;
in [4-5], esegui uno degli script del progetto;

in [7-8], i risultati dell'esecuzione;

2.2.2. Ambiente di esecuzione virtuale

Il nostro ambiente di lavoro è ora attivo e funzionante. Tuttavia, lo modificheremo per scrivere gli script per questo corso. Per prima cosa, modifichiamo la configurazione di PyCharm:

Nella finestra a destra:

Per impostazione predefinita, la casella [1] è selezionata. Deselezionarla in modo che PyCharm non apra l'ultimo progetto per impostazione predefinita, ma ci permetta di scegliere quale aprire;
In [2], non confermiamo l'uscita da PyCharm quando chiudiamo la finestra dell'applicazione;
In [3], i nuovi progetti si aprono in una finestra separata;
in [4], se chiudi PyCharm mentre un programma è in esecuzione, questo verrà interrotto;

Ora chiudiamo PyCharm e poi lo riapriamo:

In [1], creare un nuovo progetto;
In [2], specificare la cartella del progetto;
In [3], seleziona un ambiente virtuale. Un ambiente virtuale è specifico per il progetto che stai creando. Non si mescola con gli ambienti virtuali di altri progetti. Un progetto Python/Flask utilizza molte librerie esterne che devono essere installate. Il progetto P1 potrebbe utilizzare la libreria B nella versione v1, mentre il progetto P2 potrebbe utilizzare la stessa libreria B ma nella versione v2. Queste due versioni potrebbero essere più o meno compatibili. Tuttavia, quando si installa una libreria nella versione v2 e la versione v1 è già installata, la versione v1 viene sovrascritta dalla versione v2. Ciò può essere problematico per il progetto che utilizzava la versione v1 se la nuova versione v2 non è pienamente compatibile con la versione v1. Per evitare questi problemi, ogni progetto è isolato in un ambiente virtuale;
in [4], specificare la cartella in cui verranno memorizzate le librerie Python scaricate durante il progetto. Qui, abbiamo scelto una cartella [venv] (ambiente virtuale) all'interno della cartella del progetto. Non è obbligatorio farlo;
in [5], l'interprete Python del progetto. Si tratta di quello che abbiamo installato nel passaggio precedente;
in [6], creare il progetto;

in [7-8], il progetto creato;
in [9], l'ambiente di runtime del progetto, chiamato ambiente virtuale;
in [10], la cartella [site-packages] è dove verranno memorizzate le librerie scaricate in seguito;

2.2.3. Git

Successivamente, attiviamo un sistema di controllo delle versioni. Qui useremo Git [1-4]:

Un sistema di controllo delle versioni (VCS) consente di tenere traccia delle modifiche apportate a un progetto. È possibile acquisire istantanee del progetto in diversi momenti del suo ciclo di vita tramite un'operazione chiamata commit. Se si effettuano due commit nei momenti T e T+1, il VCS consente di vedere cosa è cambiato tra le due versioni sottoposte a commit. Normalmente, l' e del VCS è utilizzata da un team di sviluppatori. Essi effettuano il commit del loro codice una volta che è stato accuratamente testato. Dal VCS, altri sviluppatori possono recuperare questo codice convalidato e utilizzarlo.

In questo caso, c'è un solo sviluppatore. L'esperienza dimostra che un'applicazione può funzionare al momento T ma non più al momento T+1. In tal caso, vorremmo tornare al momento T per ricominciare da zero. Il VCS lo consente, ed è per questo che lo useremo qui.

Vi mostreremo come farlo con Git.

In [1], selezionate la scheda [Git] (in basso a sinistra);
in [2], potete vedere che ci sono 495 file di progetto che non sono sottoposti a controllo di versione da Git. Ciò significa che non saranno inclusi nell'istantanea del progetto durante i commit;
in [3], il pulsante [commit] o il pulsante di convalida del progetto. Come accennato, Git acquisisce quindi un'istantanea del progetto e la memorizza in una cartella [.git] nella radice del progetto (non visualizzata da PyCharm ma visibile in Esplora file);

Eseguiamo il commit [3] del progetto nel suo stato attuale.

In [4], l'elenco dei file non sottoposti a controllo di versione;
in [5], tutti questi file non sottoposti a controllo di versione appartengono all'ambiente virtuale [venv];
In [6], ogni commit deve essere accompagnato da un messaggio. Qui, lo sviluppatore descrive le modifiche introdotte dalla versione da sottoporre a commit rispetto all'ultima versione sottoposta a commit;

Alcune cartelle o file possono essere ignorati da Git. In tal caso, non vengono mai inclusi nell'istantanea. In [5] sopra, fare clic con il tasto destro del mouse sulla cartella [venv].

In [1-3], specifichiamo che la cartella [venv] non deve essere inclusa negli snapshot di Git. L'elenco delle cartelle e dei file ignorati da Git è memorizzato in un file chiamato [.gitignore] [4];

Dopo il passaggio precedente, tutti i file nella cartella [venv] scompaiono dall'elenco dei file non sottoposti a controllo di versione. Rimane solo il file [.gitignore] appena creato;
In [5], lo selezioniamo in modo che venga salvato;
In [6], creiamo un messaggio di commit:
in [7], confermiamo. Viene quindi eseguita un'istantanea del progetto;

in [8-9], il contenuto del file [.gitignore]: una singola riga con il nome della cartella [/venv], che indica che il suo contenuto deve essere ignorato nelle istantanee;

Ora vediamo come Git può essere utile. Per prima cosa, creiamo una cartella [git] (puoi usare qualsiasi altro nome: potrà essere cancellata alla fine della dimostrazione):

in [1-5], creiamo una cartella [git];

nei passaggi [6-10], creiamo uno script Python [git_01];

nei passaggi [11-12], lo script contiene solo un commento;
In [13-14], creare una copia di [git_01]. Per farlo, selezionare [git_01], premere Ctrl-C (Copia), poi Ctrl-V (Incolla) e inserire [git_02] come nome del file;

Ora, eseguiamo il commit del nostro progetto. Verrà creata un'istantanea dei due file [git_01, git_02];

In [1-3], esegui il commit del progetto;
In [4], seleziona i file non sottoposti a controllo di cui vuoi eseguire il commit — in questo caso, tutti;
In [5], inserisci il messaggio di commit;
In [6], confermiamo;

in [1-2], confermare il commit;
in [3], seleziona la scheda [Log];
In [4], una vista dei rami del progetto. Qui, c'è un solo ramo chiamato [master];
in [5-6], il commit appena effettuato;

Ora creiamo uno script [git_03] seguendo la stessa procedura:

Modifica lo script [git_02] ed elimina lo script [git_01]:

Quindi esegui il commit della nuova versione:

Ora abbiamo due commit nei log:

Quando selezioni un commit specifico, l'albero dei file del progetto appare alla sua destra:

Supponiamo ora che l'ultimo commit ci abbia portato in un vicolo cieco e che vogliamo tornare a uno stato corrispondente a uno dei commit precedenti:

In [1-2], seleziona il commit a cui vuoi tornare;
in [3-5], sono disponibili diverse modalità di ripristino. Scegliamo la modalità [hard], che ripristina lo stato selezionato scartando le modifiche apportate da allora;

in [6], abbiamo recuperato [git_01], che era stato cancellato;
in [7-8], troviamo [git_02] nel suo stato originale senza la modifica che era stata apportata;

Ora, modifichiamo [git_02] e aggiungiamo [git_03] [1-4]:

Ora, ripetiamo il processo di ripristino al commit iniziale:

in [1-4], torniamo allo snapshot del commit n. 1;
In [5-6], scegliamo l'opzione [Keep] invece di [Hard]. Queste opzioni non sono facili da capire. Quindi dobbiamo provarle:

in [1], il file [git_03] è ancora presente;
in [2-3], il file [git_02] ha mantenuto le sue modifiche;

È difficile capire cosa abbia fatto questo [Revert Commit]. Ora eseguiamo il commit dello stato attuale:

In [1-6], il commit;

in [9], vediamo il nuovo commit;

Ora, proviamo a tornare al commit 1 come abbiamo fatto prima:

in [1-6], torniamo al commit n. 1 in modalità [Hard];

come indicato nei paragrafi [7-8], questa volta abbiamo effettivamente perso tutte le modifiche apportate dopo il primo commit;

Da questo punto in poi, non torneremo più su [Git]. Il lettore può procedere come segue:

può seguire gli esempi forniti digitandole personalmente o scaricandole dal sito web del corso;
ogni volta che un esempio funziona, può eseguire il commit del proprio progetto;
quando sviluppa il proprio codice e si trova in un vicolo cieco, sa che può tornare a uno stato stabile ripristinando un commit precedente;

2.3. Convenzioni di codifica Python

È possibile scrivere codice Python senza seguire le convenzioni di codifica, e funzionerà comunque. Tuttavia, potrebbe non essere apprezzato dalla comunità Python, che ha stabilito delle convenzioni di codifica. Queste sono riassunte in un post su |https://stackoverflow.com/questions/159720/what-is-the-naming-convention-in-python-for-variable-and-function-names|:

il nome di un modulo (module_name) segue una convenzione talvolta chiamata [snake_case]: tutto in minuscolo, con le parole separate da trattini bassi se necessario. Questa convenzione [snake_case] si applica ai nomi di metodi, pacchetti, variabili e funzioni;
il nome di una classe (ClassName) segue una convenzione talvolta chiamata [PascalCase]: una sequenza di parole unite tra loro con la prima lettera di ogni parola maiuscola;
I nomi delle costanti seguono la convenzione [SNAKE_CASE]: una sequenza di parole maiuscole separate da trattini bassi;

Queste convenzioni sono state generalmente seguite in questo documento. Tuttavia, per i moduli che definiscono una classe, ho dato al modulo lo stesso nome della classe che contiene. Segue quindi la convenzione [PascalCase] invece di [snake_case]. Volevo poter identificare rapidamente i moduli di classe.