Grafica con Python: Turtle

Il modulo turtle in Python è una specie di tartaruga nel mondo reale. Conosciamo una tartaruga come un rettile che si muove molto lentamente e porta la sua casa sul dorso. Nel mondo di Python, una tartaruga è una piccola freccia nera che si muove lentamente sullo schermo. In realtà, considerando che una tartaruga Python lascia una scia mentre si muove sullo schermo, in realtà è meno come una tartaruga e più come una lumaca.

Turtle è un bel modo per imparare alcune delle basi della computer grafica, quindi adesso proveremo ad usare il modulo Python turtle per disegnare alcune semplici forme e linee.

Utilizzo del modulo turtle di Python

Un modulo in Python è un modo per fornire un codice utile che deve essere utilizzato da un altro programma (tra le altre cose, il modulo può contenere funzioni che possiamo usare). Python ha un modulo speciale chiamato turtle che possiamo usare per imparare come i computer disegnano immagini su uno schermo. Il modulo turtle è un modo di programmare la grafica vettoriale, che fondamentalmente si limita a disegnare con semplici linee, punti e curve.

Vediamo come funziona il modulo turtle. Per prima cosa, avvia la shell Python facendo clic sull'icona sul desktop (o se stai usando Ubuntu, seleziona Applicazioni ▸ Programmazione ▸ IDLE). Quindi, dì a Python di usare la tartaruga importando il modulo turtle, come segue:

>>> import turtle

L'importazione di un modulo dice a Python che lo vuoi usare.

Creazione di un canvas

Ora che abbiamo importato il modulo tartaruga, dobbiamo creare un canvas, uno spazio vuoto su cui disegnare, come la tela di un artista. Per fare ciò, chiamiamo la funzione Pen dal modulo turtle, che crea automaticamente una tela. Inseriscilo nella shell Python:

>>> t = turtle.Pen()

Dovresti vedere una casella vuota (la tela), con una freccia al centro, qualcosa come questo:

Muovere la tartaruga

Si inviano istruzioni alla tartaruga utilizzando le funzioni disponibili sulla variabile t che abbiamo appena creato, in modo simile all'utilizzo della funzione Pen nel modulo tartaruga. Ad esempio, l'istruzione in forward dice alla tartaruga di andare avanti. Per dire alla tartaruga di avanzare di 50 pixel, inserisci il seguente comando:

>>> t. forward(50)

Dovresti vedere che la tartaruga si è spostata in avanti di 50 pixel. 

Un pixel è un singolo punto sullo schermo, l'elemento più piccolo che può essere rappresentato. Tutto ciò che vedi sul monitor del tuo computer è composto da pixel, che sono piccoli punti quadrati. Se potessi ingrandire la tela e la linea tracciata dalla tartaruga, potresti vedere che la freccia che rappresenta il percorso della tartaruga è solo un mucchio di pixel. Questa è semplice computer grafica.

Ora diremo alla tartaruga di girare a sinistra di 90 gradi con il seguente comando:

>>> t. left(90)

Se non hai ancora imparato a conoscere i gradi, ecco come pensarci.

Immagina di essere al centro di un cerchio.

La direzione verso cui sei rivolto è 0 gradi.

Se allunghi il braccio sinistro, sarà di 90 gradi a sinistra.

Se allunghi il braccio destro, è di 90 gradi a destra.

Puoi vedere questa svolta di 90 gradi a sinistra o a destra qui:

Se continui intorno al cerchio verso destra da dove punta il braccio destro, 180 gradi è direttamente dietro di te, 270 gradi è la direzione in cui punta il braccio sinistro e 360 gradi è indietro dove hai iniziato; i gradi vanno da 0 a 360. 

Quando la tartaruga di Python gira a sinistra, gira per guardare nella nuova direzione (proprio come se girassi il tuo corpo verso il punto in cui il tuo braccio punta di 90 gradi a sinistra).

Dunque comando t.left(90) che abbiamo utilizzato prima punta la freccia verso l'alto (poiché inizia sempre puntando a destra)

Ora proviamo a disegnare un semplice quadrato con il lato di 50px. Aggiungi il seguente codice alle righe che hai già inserito:

>>> t. forward(50)

>>> t. left (90)

>>> t. forward(50)

>>> t. left (90)

>>> t. forward(50)

>>> t. left(90)

La tua tartaruga dovrebbe aver disegnato un quadrato e ora dovrebbe essere rivolta nella stessa direzione in cui è iniziata:

Per cancellare la tela, utilizza il comando reset. Questo cancella la tela e riporta la tartaruga nella sua posizione di partenza.

>>> t.reset ()

Puoi anche usare Clear, che cancella semplicemente lo schermo e lascia la tartaruga dov'è.

Possiamo anche girare la nostra tartaruga a destra o spostarla all'indietro. Possiamo usare up per sollevare la penna dalla pagina (in altre parole, dire alla tartaruga di smettere di disegnare) e down per iniziare a disegnare. Queste funzioni sono scritte nello stesso modo delle altre che abbiamo usato.

Proviamo un altro disegno utilizzando alcuni di questi comandi. Questa volta, faremo disegnare alla tartaruga due linee parallele. Inserisci il codice seguente:

>>> t.reset()

>>> t.backward(100) 

>>> t.up()

>>> t.right(90)

>>> t.forward(20) 

>>> t.left(90)

>>> t.down()

>>> t. forward(100)

>>> t.clear()

Per prima cosa, resettiamo la tela e riportiamo la tartaruga nella sua posizione iniziale con t.reset(). Successivamente, spostiamo la tartaruga indietro di 100 pixel con t.backward(100), quindi usiamo t.up() per prendere la penna e smettere di disegnare.

Quindi, con il comando t.right(90), ruotiamo la tartaruga a destra di 90 gradi per puntare verso il basso, verso il fondo dello schermo, e con t.forward(20), ci spostiamo in avanti di 20 pixel. Non viene disegnato niente in questo caso perché abbiamo utilizzato il comando up sulla terza riga. Ruotiamo la tartaruga a sinistra di 90 gradi verso destra con t.left(90), quindi con il comando down, diciamo alla tartaruga di rimettere la penna verso il basso e ricominciare a disegnare. Infine, tracciamo una linea in avanti, parallela alla prima linea che abbiamo disegnato, con t.forward(100). Le due linee parallele che abbiamo disegnato finiscono per assomigliare a questa:

Prova di programma con turtle (caleidoscopio)

Adesso che abbiamo imparato le basi per utilizzare la grafica e il modulo turtle proviamo a fare un piccolo e semplice programma per fare un pò di pratica.

1. Prima di tutto creiamo un nuovo file python con DLE e salviamolo con il nome caleidoscopio.py.

2. Importiamo il modulo con il comando import turtle

3. Diamo alcune impostazioni a turtle (colore sfondo, velocità e dimensioni della penna)

>>>>turtle.bgcolor('black')

>>>>turtle.speed('fast')

>>>>turtle.pensize(4)

4. Proviamo a disegnare un cerchio di colore rosso con i seguenti comandi

>>>>turtle.pencolor('red')

>>>>turtle.circle(30)

5. Proviamo a disegnare più cerchi utilizzando una funzione.

Definiamo la funzione disegna_cerchio con il parametro raggio come segue:

def disegna_cerchio(raggio):

        turtle.pencolor('red')

        turtle.circle(raggio)

        disegna_cerchio(raggio)

l'ultima riga della funzione richiama se stessa per fare in modo che venga ripetuta all'infinito (è un modo alternativo per fare un ciclo ed è chiamato ricursione).

Una volta definita la funzione (prima che venga chiamata) la chiameremo utilizzando disegna_cerchio(30) al posto di quanto abbiamo scritto al punto 4

6. Cambiamo i colori e le dimensioni dei cerchi

Per creare modelli più eccitanti, apporta queste modifiche al codice per aumentare la dimensione del cerchio e cambiarne il colore. Questo codice utilizza la funzione cycle(), che accetta un elenco di valori come parametro e restituisce un tipo speciale di elenco che è possibile scorrere all'infinito utilizzando la funzione next(). 

Dopo import turtle inseriamo le seguenti righe:

from itertools import cycle

colori = cycle(['red', 'orange', 'yellow', 'green', 'blue', 'purple'])

e modifichiamo la funzione come segue:

def disegna_cerchio(raggio):

        turtle.pencolor(next(colori))

        turtle.circle(raggio)

        disegna_cerchio(raggio + 5)

7. Aggiungiamo più effetti modificando l'angolo e la posizione

Per aggiungere più effetti al nostro caleidoscopio aggiungiamo due parametri: angolo e posizione

La nostra funzione diventerà come segue:

def disegna_cerchio(raggio, angolo, posizione):

        turtle.pencolor(next(colori))

        turtle.circle(raggio)

        turtle.right(angolo)

        turtle.forward(posizione)

        disegna_cerchio(raggio + 5, angolo + 1, posizione + 1)

In questo modo ogni volta che la nostra funzione richiamerà se stessa il cerchio (freccia di turtle) si sposterà di 1 andando in direzione di angolo +1 ruotato a destra. 

Il programma finale sarà come segue:

Adesso potete provare a divertirvi a vedere cosa succede cambiando la dimensione della penna o i valori dei parametri passati alla funzione ...

Potete anche provare ad alternare ai cerchi altre figure geometriche come quadrati, triangoli, rettangoli ...

Esempio:

Python: 3 - Aggiungere struttura al codice

Strutture di controllo 

Piuttosto che passare semplicemente attraverso un programma ed eseguire ogni riga di codice quando si incontra, probabilmente si desidera un maggiore controllo. Queste strutture di controllo consentono di eseguire codice solo quando esiste una condizione specifica e di eseguire blocchi di codice più volte. Nella maggior parte dei casi, sarà più facile guidarti attraverso questi concetti che cercare di descriverli. 

Istruzione if 

L'istruzione if consente di verificare una condizione prima di eseguire un blocco di codice. La condizione può essere qualsiasi valore o equazione che restituisce true o false. 

Il prossimo pezzo di codice scorre l'elenco dei robot e determina se il robot è Uno. 

>>> for robot in robots: 

            if robot == "Uno": 

                print ("Questo è Uno") 

            else: 

                print (robot + "non è Uno") 

Questo è Uno 

Due non è Uno 

Tre non è Uno 

Ancora una volta, nota il rientro durante la digitazione. IDLE fa rientrare un altro livello dopo ogni riga che termina con due punti, che dovrebbe essere ogni riga che denota un nuovo blocco, come istruzioni di ciclo e condizionali. 

È importante anche notare come testiamo l'uguaglianza. 

Un singolo segno di uguale significa assegnazione. 

I segni di doppio uguale dicono all'interprete di confrontare per l'uguaglianza. 

>>> myRobot = "Uno"

>>> myRobot == "Due"

False 

>>> myRobot == "Uno"

True 

Ecco un elenco di comparatori: 

è uguale a             == 

non uguale             != 

Minore di              <

Maggiore di            > 

Minore o uguale a      <= 

Maggiore o uguale a    > = 

È inoltre possibile utilizzare and e or per verificare più condizioni. 

>>> for robot in robots: 

           if robot == "Due" or robot == "Tre": 

               print("Questi non sono i droidi che sto cercando.") 

Questi non sono i droidi che sto cercando. 

Questi non sono i droidi che sto cercando. 

I confronti vengono spesso utilizzati anche per determinare se un oggetto esiste o contiene un valore. In sostanza, una condizione restituisce true se non restituisce false, 0 o nessuno. Ciò è molto utile quando si desidera eseguire una porzione di codice solo se esiste un oggetto, ad esempio quando si inizializzano sensori o connessioni tramite una porta seriale o una rete.

I Cicli 

Quando lavori con la robotica, ci sono volte in cui vuoi ripetere un blocco di codice. Se eseguire una serie di istruzioni su una raccolta di oggetti o eseguire un blocco di codice per tutto il tempo in cui esiste una condizione, è necessario utilizzare un ciclo. I cicli consentono di ripetere un blocco di codice per eseguire le attività più volte. Esistono due tipi di loop: il ciclo for e il ciclo while. Ciascuno fornisce una funzionalità specifica che è cruciale per scrivere programmi efficienti. 

Ciclo for

Un ciclo for esegue un blocco di codice per ogni elemento in un elenco. 

Una raccolta di valori, una tupla, un elenco o un dizionario, viene fornito al ciclo for. Quindi itera nell'elenco ed esegue il codice contenuto nel blocco di codice. Quando esaurisce gli elementi nella raccolta, il ciclo viene chiuso e viene eseguita la riga di codice successiva all'esterno del blocco for. 

Come con l'istruzione if, inserisci il codice che vuoi eseguire come parte del ciclo in un blocco indicato dal rientro. 

È importante assicurarsi di aver corretto il rientro, altrimenti verrà visualizzato un errore. Quando lo inserisci nella shell Python, fai attenzione a cosa fa con il rientro. Dopo aver inserito il comando di stampa e premuto Invio, è necessario premere nuovamente Invio in modo che la shell sappia che hai finito. 

>>> for robot in robots: 

          print(robot) 

Uno 

Due 

Tre 

Il programma entra nell'elenco dei robot e estrae il primo valore, Uno, che poi stampa. Poiché questa è l'ultima riga del blocco, l'interprete ritorna all'elenco ed estrae il valore successivo. Questo si ripete fino a quando non ci sono più valori nell'elenco. A questo punto, il programma esce dal ciclo. 

Tendo a usare parole plurali per i nomi delle mie liste. Ciò mi consente di utilizzare la forma singolare del nome per fare riferimento agli elementi all'interno dell'elenco per un ciclo. Ad esempio, ogni elemento nella tupla di Robots è un robot. 

Se desideri scorrere gli elementi in un dizionario, devi fornire due variabili per memorizzare i singoli elementi. È inoltre necessario utilizzare il metodo items della classe dictionary. Ciò consente di accedere a turno a ciascuna coppia chiave / valore. 

>>> for nome, dati in Robots.items(): 

                print(nome + ':' + dati) 

colore:nero 

tipo: con ruote 

È possibile utilizzare la funzione enumerate per aggiungere un valore numerico sequenziale all'output di un ciclo for. 

>>> for num, robot in enumerate(robots): 

                print(num, robot) 

(0, 'Uno') 

(1, "Due") 

(2, "Tre") 

Ciclo while 

Mentre un ciclo for esegue un blocco di codice per ogni elemento in un elenco, il ciclo while esegue un blocco di codice fintanto che la sua condizione restituisce true. 

Viene spesso utilizzato per eseguire codice un numero specifico di volte o mentre il sistema si trova in uno stato specifico. Per scorrere il codice un numero specifico di volte, utilizzare una variabile per contenere un valore intero. Nell'esempio seguente, diciamo al programma di eseguire il codice fintanto che il valore della nostra variabile di conteggio è inferiore a cinque. 

>>> conta = 1 

>>> while conta <5: 

            print(conta)

            conta = conta + 1

1 

2 

3 

4 

Iniziamo dichiarando una variabile, conta, per contenere il nostro numero intero, e gli assegniamo il valore 1. 

Entriamo nel ciclo e il valore di 1 è minore di 5, quindi il codice stampa il valore sulla console. 

Quindi incrementiamo il valore di count di 1. Perché questa è l'ultima istruzione del ciclo e l'ultimo valore valutato se la condizione while era inferiore a 5, il codice ritorna alla clausola while. 

Il valore di count, ora 2, è ancora inferiore a 5, quindi il codice viene eseguito di nuovo. Questo processo si ripete fino a quando il valore di count è 5. 

Cinque non è inferiore a cinque, quindi l'interprete esce dal ciclo senza eseguire il codice nel blocco. 

Se ci fossimo dimenticati di incrementare la variabile conta, sarebbe risultato un ciclo aperto. 

Poiché conta è uguale a 1 e non lo incrementiamo mai, il valore di conta è sempre uguale a 1. Uno è inferiore a cinque, quindi l'esecuzione del codice non si interromperà mai e dovremmo premere Ctrl-C per terminarlo. 

Viene anche utilizzato come un tipo di ciclo principale, eseguendo il codice continuamente. Vedi quanto segue in molti programmi: 

while(true): 

True restituisce sempre true; pertanto, il codice all'interno di questo blocco continua a essere eseguito finché non si esce dal programma. 

Questo è chiamato un ciclo aperto poiché non si chiude mai. 

Fortunatamente, esiste un modo conveniente per uscire dai loop aperti. Se ti trovi in ​​un ciclo aperto, o vuoi semplicemente uscire da un programma arbitrariamente, premi Ctrl-C. 

Ciò causa la chiusura immediata del programma. Lo userai frequentemente. Questa tecnica può essere utilizzata anche per far aspettare il programma una condizione specifica da soddisfare. Ad esempio, se richiedessimo la disponibilità di una connessione seriale prima di continuare, avremmo prima avviato il comando di connessione. Quindi potremmo attendere il completamento della connessione prima di continuare utilizzando alcuni come questo: 

while(!connesso): 

            pass

Il punto esclamativo significa not. Quindi, in questo caso, supponendo che la variabile connesso contenga la connessione seriale che restituisce true quando viene stabilita, stiamo dicendo al programma di eseguire il codice contenuto nel blocco while fintanto che non è connesso. In questo caso, il codice che gli diciamo di eseguire è chiamato pass, che è un comando vuoto. Viene utilizzato quando in realtà non vuoi fare nulla, ma hai bisogno di qualcosa in quel posto. Quindi, stiamo dicendo al sistema questo: "Anche se non sei connesso, non fare nulla e continua finché non sei connesso".

Python: 2 - Le Variabili

Le Variabili 

Le variabili sono essenzialmente un comodo contenitore per memorizzare le informazioni. In Python, le variabili sono molto flessibili. Non è necessario dichiarare un tipo. Il tipo viene generalmente determinato quando gli si assegna un valore. Infatti, dichiari una variabile assegnandole un valore. Questo è importante da ricordare quando inizi con i numeri. In Python, c'è una differenza tra 1 e 1.0. Il primo numero è un intero e il secondo è un float. 

Ecco alcune regole generali per le variabili: 

• Possono contenere solo lettere, numeri e trattini bassi 

• Sono sensibili al maiuscolo / minuscolo; ad esempio, variabile non è la stessa di Variabile.  

• Non utilizzare parole chiave Python 

Oltre a queste regole ferree, ecco un paio di suggerimenti: 

• Rendi il nome della variabile significativo con il minor numero di caratteri possibile 

• Fare attenzione quando si utilizza la L minuscola (l) e la O maiuscola (O). Questi caratteri sono molto simili a 1 e 0, il che può creare confusione. Non sto dicendo di non usarli; assicurati solo che sia chiaro cosa stai facendo. È fortemente sconsigliato utilizzarli come nomi di variabili a carattere singolo.

Tipi di dati 

Python è un linguaggio tipizzato dinamicamente. Ciò significa che il tipo di dati memorizzati in una variabile non viene verificato fino a quando il programma non viene eseguito, non durante la compilazione. Ciò consente di posticipare l'assegnazione di un tipo fino a quando non viene assegnato un valore. Tuttavia, anche Python è fortemente tipizzato e fallirà se si tenta di eseguire un'operazione che non è valida per quel tipo di dati. Ad esempio, non è possibile eseguire operazioni matematiche su una variabile contenente una stringa. Pertanto, è importante tenere traccia del tipo di dati a cui fa riferimento la variabile. 

Di seguito farò una breve descrizione di due tipi di dati di base (stringhe e numeri) ed alcuni dei tipi più complessi: tuple, elenchi e dizionari. Python ti consente di definire i tuoi tipi come classi. 

 

Stringhe 

Una stringa è una raccolta di uno o più caratteri contenuti tra virgolette. Le virgolette sono il modo in cui indichi una stringa. Ad esempio, "100" è una stringa; 100 è un numero (un numero intero per essere più precisi). Puoi usare virgolette doppie o singole (ricorda solo cosa hai usato). Puoi annidare un tipo di virgolette all'interno di un altro, ma otterrai un errore o, peggio, risultati imprevisti, se incroci le virgolette. 

Ecco un esempio di virgolette doppie: 

>>> print("Questo è un testo") 

Questo è un testo 

Ecco un esempio di virgolette singole: 

>>> print('Questo è un testo') 

Questo è un testo 

Ecco un esempio di virgolette singole all'interno di virgolette doppie: 

>>> print ("'Questo è testo'") 

'Questo è un testo' 

Ecco un esempio di virgolette doppie all'interno di virgolette singole: 

>>> print ('"Questo è testo"') 

"Questo è un testo" 

Le virgolette triple vengono utilizzate per estendere più righe all'interno di una stringa. Ecco un esempio di virgolette triple: 

>>> print ("""questo

 è 

un

testo""") 

Questo

è 

un

testo 

Puoi usare virgolette singole come apostrofi se prima esegui l'escape. Escape di un carattere significa semplicemente che stai dicendo all'interprete di vedere un carattere come un carattere stringa piuttosto che funzionale. 

Ecco un esempio di escape tra virgolette: 

>>> print('Questo o l'altro non funzionerà') 

File "<stdin>", riga 1 

            print ('Questo o l'altro non funzionerà'') 

                              ^ 

SyntaxError: sintassi non valida 

>>> print ('L\'altro non avrà errori') 

L'altro non avrà errori 

Puoi farlo all'intera stringa rendendola una stringa grezza. In questo esempio successivo, "/n" viene utilizzato per spostarsi su una nuova riga. 

Ecco un esempio di una stringa grezza: 

>>> print('qualcosa \nuovo') 

qualcosa uovo 

>>> print(r'qualcosa \nuovo ') 

qualcosa /nuovo 

Manipolazione delle Stringhe 

Esistono molti modi per manipolare le stringhe. Alcuni sono abbastanza semplici, come la concatenazione, ovvero l'aggiunta di stringhe. Tuttavia, alcuni di loro sono un pò sorprendenti. Le stringhe vengono trattate come un elenco di valori di carattere. Più avanti esploreremo gli elenchi in maggiore dettaglio. Tuttavia, utilizzeremo alcuni dei tratti delle liste per lavorare con le stringhe. 

Poiché le stringhe sono elenchi, simili agli array in altre lingue, possiamo fare riferimento a caratteri specifici all'interno di una stringa. Come gli elenchi, le stringhe sono indicizzate a zero. Ciò significa che il primo carattere di una stringa è nella posizione zero. 

Con le stringhe, come le liste, il primo carattere è all'indice [0]: 

>>> robot = "pippo" 

>>> robot[0] 

p 

Quando si utilizza un numero negativo, l'indice inizia alla fine della stringa e funziona all'indietro. 

>>> robot[-1] 

o 

Il taglio di una stringa consente di estrarre una sottostringa. Quando si taglia una stringa, si forniscono due numeri separati da due punti. Il primo numero è l'indice iniziale e il secondo è l'indice finale. 

>>> robot[0: 3] 

pip 

Si noti che durante il taglio, il primo indice è inclusivo e il secondo indice è esclusivo. Nell'esempio precedente, il valore all'indice [0] restituito, "p"; mentre il valore all'indice [3] non era "p". 

Quando si taglia, se si lascia uno degli indici, si assume l'inizio o la fine della stringa. 

>>> robot[: 3] 

pip 

>>> robot[3:] 

po 

L'unione di stringhe viene chiamata concatenazione. Con Python, puoi facilmente unire stringhe insieme. Funziona con stringhe letterali e variabili stringa. Puoi anche moltiplicare le stringhe per un effetto interessante. Puoi aggiungere due stringhe insieme. 

>>> print("Ro" + "bot") 

Robot 

Puoi aggiungere variabili stringa insieme, in questo modo: 

>>> x = "Ro" 

>>> y = "bot" 

>>> z = x + y 

>>> print(z) 

Robot 

Puoi aggiungere una variabile stringa e un valore letterale. 

>>> print (x + "bot") 

Robot 

Puoi moltiplicare le stringhe letterali. 

>>> print (2 * "ro" + "bot") 

rorobot 

La moltiplicazione delle stringhe, tuttavia, funziona solo sui letterali. Non funzionerà con variabili stringa.

I Numeri 

I numeri in Python sono disponibili in pochi tipi, i più comuni dei quali sono interi e float. 

Un numero intero è un numero intero, mentre un float è un decimale. Python utilizza anche un tipo booleano che ha un valore di uno o zero. Questi sono spesso usati come flag o stato, dove uno significa "acceso" (o vero) e zero significa "spento" (o falso). Un booleano è una sottoclasse di numeri interi e vengono trattati come numeri interi durante l'esecuzione delle operazioni. Come ci si potrebbe aspettare, è possibile eseguire operazioni matematiche con tipi di numeri. In genere, se esegui operazioni aritmetiche con un tipo, il risultato è quel tipo. 

La matematica che utilizza numeri interi di solito produce un numero intero. Tuttavia, se esegui la divisione con numeri interi, il risultato è un float. 

La matematica con i float risulta in un float. Se esegui operazioni aritmetiche con entrambi i tipi, il risultato è un float. 

L'addizione di due numeri interi produce un numero intero. 

>>> 2 + 3 

5 

L'addizione di due float risulta in un float. 

>>> 0,2 + 0,3 

0,5 

Aggiungendo un float e un intero si ottiene un float. 

>>> 1 + 0,5 

1,5 

La sottrazione e la moltiplicazione funzionano allo stesso modo. 

>>> 3-2 

1 

>>> 3-1,5 

1.5 

>>> 2 * 3 

6 

>>> 2 * 0,8 

1,6 

La divisione si traduce sempre in un float. 

>>> 3.2 / 2 

1.6 

>>> 3/2 

1.5 

L'operatore ** risulta nel primo numero elevato alla potenza del secondo. 

>>> 3 ** 2 

9 

Tuttavia, c'è un problema con i float Python. L'interprete a volte produce un numero apparentemente arbitrario di cifre decimali. Questo ha a che fare con il modo in cui la notazione in virgola mobile viene memorizzata in Python e come la matematica viene eseguita all'interno dell'interprete. 

>>> 0,2 + 0,1 

0,30000000000000004

Booleani vero / falso

C'è un terzo tipo di dati in Python che non è esattamente un numero o una stringa. È chiamato booleano (dal nome di un matematico di nome George Boole) e può essere uno dei due valori: Vero o Falso. 

Può sembrare un po 'strano avere un tipo di dati per qualcosa che può essere solo Vero o Falso. Tuttavia, a causa del modo in cui i computer svolgono il loro lavoro, è effettivamente efficiente rendere Vero / Falso il proprio tipo di dati. 

Un singolo bit, che è la più piccola unità di archiviazione in un computer, è tutto ciò che è necessario per memorizzare un valore che può essere solo Vero o Falso.
Nel codice Python, le persone memorizzano i valori True o False nelle variabili utilizzando un formato simile a questo:

x = True

o

X = False

Si capisce che True e False sono booleani perché non sono racchiusi tra virgolette (come sarebbe una stringa) e non sono numeri. Inoltre, è richiesto il limite iniziale. In altre parole, la prima lettera deve essere maiuscola e tutte le lettere successive devono essere minuscole.

Liste 

Un elenco è una raccolta di elementi in un ordine particolare. In altre lingue, sono generalmente noti come array. Puoi mettere tutto quello che vuoi in un elenco. I valori memorizzati in un elenco non devono essere dello stesso tipo di dati. Tuttavia, se mescoli i tipi di dati in un elenco, assicurati di sapere quale tipo stai ricevendo quando lo usi. Lavoravi con le liste quando lavoravi con le stringhe. Una stringa è essenzialmente un elenco di caratteri. Pertanto, l'indicizzazione e la suddivisione in sezioni funzionano anche con gli elenchi. 

Viene creato un elenco utilizzando le parentesi quadre []. 

>>> robots = ["pippo", "Pluto", "Paperino"] 

>>> robots 

["pippo", "Pluto", "Paperino"] 

Come le stringhe, gli elenchi sono indicizzati a zero. Ciò significa che il primo elemento in una lista è in posizione 0, il secondo è in posizione 1 e così via. È possibile accedere ai singoli elementi di un elenco richiamandone l'indice o la posizione all'interno dell'elenco. 

>>> robot[0] 

"pippo" 

>>> robot[-1] 

"Paperino" 

Le liste possono anche essere tagliate. Quando un elenco viene suddiviso, il risultato è un nuovo elenco contenente il sottoinsieme dell'elenco originale. 

>>> robot[1:3] 

["Pluto", "Paperino"] 

È facile aggiungere, modificare e rimuovere membri di un elenco utilizzando la suddivisione in sezioni e la concatenazione. 

Questo esempio aggiunge membri a un elenco. 

>>> more_bots = robots + ["Roomba", "Neato", "InMoov"] 

>>> more_bots 

["pippo", "Pluto", "Paperino", "Roomba", "Neato", "InMoov"] 

Questo esempio modifica i membri in un elenco. 

>>> more_bots[3] = "ASIMO" 

>>> more_bots 

["pippo", "Pluto", "Paperino", "ASIMO", "Neato", "InMoov"] 

Questo esempio rimuove i membri di un elenco. 

>>> more_bots[3:5] = [] 

>>> more_bots 

["pippo", "Pluto", "Paperino", "InMoov"] 

Assegna i membri dell'elenco alle variabili: 

>>> a, b = more_bots [0: 2] 

>>> a 'nomade' 

>>> b "Ponginator" 

Esistono numerosi metodi inclusi automaticamente negli elenchi. Ad esempio, puoi forzare l'iniziale maiuscola della prima lettera di un nome. 

>>> print(robots[0].title()) 

Pippo 

Come ho già detto, un elenco può contenere qualsiasi tipo di dati, inclusi altri elenchi. Infatti, quando iniziamo a lavorare con la visione artificiale, useremo spesso elenchi di elenchi per contenere i dati delle immagini. 

Tuple 

Sentirai molto il termine tuple quando lavori con Python. Un tuple è semplicemente un tipo speciale di elenco che non può essere modificato. Pensa a un tuple come ad un elenco di costanti o ad un elenco di costanti. Dichiari un tuple usando le parentesi anziché le parentesi quadre. Le tuple sono immutabili, il che significa che una volta che un tuple è stata creata, non può essere modificata. 

Per modificare il contenuto di un tuple, è necessario creare un nuovo tuple. 

Questo viene fatto utilizzando le stesse tecniche di suddivisione che abbiamo usato per stringhe ed elenchi. 

>>> colori = ("rosso", "giallo", "blu") 

>>> colori

('rosso', 'giallo', 'blu') 

>>> colori2 = colori[0: 2] 

>>> colori2

('rosso', 'giallo') 

Si noti che abbiamo usato la notazione elenco quando si taglia la tupla, colori[0: 2] invece che colori(0: 2). Il risultato della sezione è ancora un tuple. Un tuple, tuttavia, può essere sostituita. 

>>> colori2 = (1,2,3) 

>>> colori2 

(1,2,3) 

Possono anche essere sostituiti con una tupla vuota. 

>>> colori2 = () 

>>> colori2

() 

Dizionari 

Un dizionario è simile a un elenco tranne per il fatto che ti consente di assegnare un nome agli elementi nell'elenco. Questo viene fatto utilizzando coppie chiave / valore. La chiave diventa l'indice del valore. Ciò ti consente di aggiungere una struttura significativa ai tuoi elenchi. Sono utili per contenere un elenco di parametri o proprietà. Un dizionario viene dichiarato utilizzando le parentesi graffe anziché le parentesi quadre. 

>>> Due = {'tipo': 'windows', 'colore': 'nero', 'processore': 'Intel'} 

>>> print(Due['tipo']) 

windows 

Lavorate con i dizionari più o meno allo stesso modo di un array. Tranne che invece di fornire un numero di indice, fornisci la chiave per accedere a un elemento. Ci sono un paio di cose da sapere sui dizionari prima di usarli.

• La chiave deve essere un valore immutabile, come un numero o una stringa. Le tuple possono essere utilizzate anche come chiavi. 

• Una chiave non può essere definita più di una volta in un dizionario. 

Come le variabili, il valore di una chiave è l'ultimo assegnato. 

>>> Uno = {'tipo': 'test', 'colore': 'nero', 'tipo': 'ruote'} 

>>> Uno 

{'colore': 'nero', 'tipo': 'ruote'} 

In questo esempio, il primo valore di "tipo" è stato sovrascritto dal secondo. 

I dizionari possono essere nidificati come valori all'interno di altri dizionari. Nell'esempio seguente, ho incorporato la definizione per il mio progetto, Due, in un dizionario dei miei amici. 

>>> mieiAmici = {'Uno':  Uno, 'Due': Due, 'Tre': 'TEST'} 

>>> mieiAmici 

{'Uno': {'colore': 'nero', 'tipo': 'ruote'} , 'Due': {'colore': 'nero', 'tipo': 'ruote'}, 'Tre': ' TEST '} 

Ovviamente, un dizionario non sarebbe così utile se non fossi in grado di aggiornare e manipolare i valori contenuti all'interno. Apportare modifiche a un dizionario è simile a apportare modifiche a un elenco. L'unica vera differenza è che usi la chiave piuttosto che la posizione per accedere ai vari elementi. Per aggiornare un valore, utilizzare la chiave per fare riferimento al valore da modificare. 

>>> mieiAmici['Tre'] = 'Ultimo' 

>>> mieiAmici 

{'Uno': {'colore': 'nero', 'tipo': 'ruote'} , 'Due': {'colore': 'nero', 'tipo': 'ruote'}, 'Tre': ' Ultimo'} 

Una coppia chiave / valore 

>>> del mieiAmici["Tre"] 

>>> mieiAmici 

{'Uno': {'colore': 'nero', 'tipo': 'ruote'} , 'Due': {'colore': 'nero', 'tipo': 'ruote'}} 

Un dizionario può essere copiato con il metodo copy della classe dictionary. Per accedere al metodo di copia, inizia con il nome del dizionario e aggiungi .copy() alla fine. 

>>> altriAmici = mieiAmici.copy() 

>>> altriAmici

{'Uno': {'colore': 'nero', 'tipo': 'ruote'} , 'Due': {'colore': 'nero', 'tipo': 'ruote'}} 

Per aggiungere un dizionario alla fine di un altro, utilizzare il metodo update(). 

>>> conoscenti = {'Nome': 'Pluto', 'classe': 'terza'} 

>>> mieiAmici.update(conoscenti) 

>>> mieiAmici 

{'Uno': {'colore': 'nero', 'tipo': 'ruote'} , 'Due': {'colore': 'nero', 'tipo': 'ruote'}, 'Nome': 'Pluto', 'classe': 'terza'} 

Python: 1 - Ambiente di lavoro

Per poter iniziare a programmare in Python dobbiamo impostare il nostro ambiente di lavoro. 
Per iniziare a utilizzare Python sul tuo computer, dovrai seguire questi tre semplici passaggi: 
1. Scarica Python. 
2. Installa Python sul tuo computer. 
3. Prova Python con uno o due programmi semplici.

1. Scarica Python 

Python è gratuito e facile da ottenere dal sito Web di Python: vai su https://www.python.org/, vai alla voce del menu Downloads in alto, scegli il tuo sistema operativo (Windows, Mac, ecc...) e fai clic sul pulsante che inizia con Python 3.

2. Installa Python 

Trova il file che hai appena scaricato (probabilmente si trova nella cartella Download) e fai doppio clic su di esso per eseguire e installare Python e l'editor IDLE. 

IDLE è l'editor di base che viene fornito con Python e può essere utilizzato per fare le prime prove di programmazione.

3. Testare Python con un programma 

Nel menu Start o nella cartella Applicazioni, trova il programma IDLE ed eseguilo. Vedrai un finestra di comando testuale, questa è chiamata shell o terminale di Python. Una shell è una finestra o uno schermo che consente all'utente di immettere comandi o righe di codice. 

Il >>> è chiamato prompt e significa che il computer è pronto per accettare il primo comando. Il computer ti chiede di dirgli cosa fare. 

Scrivi 

print("Ciao a tutti, come state!") 

e premi INVIO o RITORNO sulla tastiera. Dovresti vedere la shell Python che ti risponde stampando il testo tra virgolette che hai inserito tra parentesi: Ciao a tutti, come state!. 

Ecco fatto: hai scritto il tuo primo programma in Python!

Scrittura e salvataggio di programmi in Python 

Per poter scrivere programmi più lunghi di una singola riga, potrai usare IDLE o altri editor (Microsoft VS Code, Jupiter o altro).

Con IDLE, vai al menu File e seleziona File▸Nuova finestra o File▸Nuovo file. Apparirà una schermata vuota, con Senza titolo in alto. 

Scriviamo un programma leggermente più lungo in Python. Nella nuova finestra vuota, digita le seguenti tre righe di codice: 

# ComeMiChiamo.py 

nome = input("Come ti chiami? \n") 

print("Ciao,", nome) 

La prima riga è chiamata commento. I commenti, che iniziano con un cancelletto (#), sono note di programmazione o promemoria che il computer ignora. In questo esempio, il commento è solo una nota per ricordarci il nome del programma. 

La seconda riga chiede all'utente di inserire il suo nome e lo assegna alla variabile nome. 

La terza riga mostra "Ciao", seguito dal valore assegnato alla variabile nome. Notare che è presente una virgola (,) che separa il testo citato "Ciao" dal nome.

Una volta scritto il programma non dobbiamo fare altro che salvarlo (File▸Salva) con il nome ComeMiChiamo.py o quello che vogliamo, ed eseguirlo Run▸Run Module.