Hello World: il tuo primo progetto Raspberry Pi

December 02, 2021
NelComputer, Laptop E Tablet Accessori E Hardware

Quando sei nuovo nel Lampone Pi, si può essere tentati di lanciarsi direttamente nei progetti che ti hanno attratto verso il dispositivo. Robot, sensori, lettori musicali e progetti simili sono ottimi usi per il Raspberry Pi. Tuttavia, questi progetti non sono il miglior inizio per qualcuno che non conosce il dispositivo. Invece, impara le basi prima di caricare in un progetto complesso.

Se tu sei nuovo per Linux, può essere una curva di apprendimento più ripida. Quindi, è meglio iniziare con progetti semplici per familiarizzare con come Pitone funziona, e poi costruire su quella conoscenza nel tempo.

Una gentile introduzione

Un primo progetto comune su un Raspberry Pi è stampare il testo Ciao mondo, sia al terminale con uno script o usando il OZIARE Ambiente di sviluppo Python. Questo progetto ti offre un'introduzione facile e pertinente a Python. È anche una funzione che utilizzerai spesso in progetti futuri.

Ecco alcune varianti di questa lezione tradizionale per dare il via alle tue abilità di programmazione con il Raspberry Pi. Useremo script Python invece di IDLE.

Ciao mondo

Inizierai dall'inizio con la stampa di base del testo Ciao mondo.

Accedi a una sessione del terminale, quindi inserisci tocca ciaoworld.py per creare un nuovo script Python chiamato ciaomondo.py.

Il comando touch di Linux crea un nuovo documento vuoto. Il nome del documento è Ciao mondo e ha il .py estensione per contrassegnarlo come file di script Python.
accedere nano helloworld.py per aprire il nuovo file con Nano.

Nano è l'editor di testo usato in questo esempio. È un semplice editor che viene fornito con la maggior parte dei sistemi Linux.
Questo pezzo successivo è tecnicamente facoltativo, ma è una buona abitudine da prendere. Nella parte superiore del documento, aggiungi una riga shebang per specificare la versione di Python che stai utilizzando. Ciò consente anche l'esecuzione dello script come un programma compilato. Per aggiungere la riga shebang, inserisci:
```
#! /usr/bin/env python3. 
```
Inserisci un paio di righe più in basso. Quindi, usa il Stampa funzione per dire a Python di stampare la frase Ciao mondo! sullo schermo. Sembra così:
```
print("Ciao mondo!")
```
premere Ctrl+X e poi premere sì per salvare il file. Il terminale ti chiede di premere accedere per salvare il file con il nome file specifico. Hai appena creato il tuo primo file Python.
Nel terminale, rendi eseguibile lo script. Per fare ciò, modifica i suoi permessi con questo comando:
```
chmod +x helloworld.py. 
```
Per eseguire il nuovo script, inserisci questo comando:
```
./helloworld.py. 
```
Questo stampa Ciao mondo! e chiude lo script, rendendo il terminale disponibile all'uso.

Ciao, allora mondo

È ora di cambiare marcia. Questo esempio stampa la parola Ciao su una riga e Mondo! al prossimo. Questo aggiunge una nuova riga al tuo file Python a un livello semplice.

Apri il tuo script con Nano. Immettere quanto segue in un terminale:
```
nano helloworld.py. 
```
Aggiungi una seconda chiamata per stampare e separarti Ciao mondo! in Ciao e Mondo! Per assegnare a ogni parola la propria chiamata alla stampa, inserisci quanto segue:
```
print("Ciao")
print("Mondo!")
```
Salva ed esci dallo script. premere Ctrl+X e rispondi con sì quando viene richiesto.
Esegui lo script dal terminale. Questa volta vedrai Ciao e Mondo! su righe separate. Inserisci questo comando per eseguire lo script:
```
./helloworld.py. 
```
Lo script può essere reso più efficiente. Python può sfruttare un carattere speciale per creare nuove righe ovunque nel testo. Elimina il secondo Stampa riga e aggiungi Mondo! alla prima riga. Lo script dovrebbe ora assomigliare a questo:
```
print("Ciao mondo!")
```
Rimuovi lo spazio tra Ciao e Mondo! Quindi, sostituisci lo spazio con il carattere di nuova riga Unix, \n. Il comando è simile a questo:
```
print("Ciao\nMondo!")
```
Salva ed esci una volta dal file di script.
Esegui lo script. Il risultato è identico ai due separati Stampa Linee. Per eseguire lo script, inserisci:
```
./helloworld.py. 
```

Ciao mondo, addio mondo

Usando ciò che hai imparato nell'esempio precedente, cambierai le cose in modo che lo script dica Ciao mondo! nove volte. Quindi, quando lo script sta per finire, viene stampato Addio mondo!

Queste istruzioni introducono alcuni nuovi concetti:

Importare: Il importare la linea porta in tempo modulo, che ti consente di chiedere al file di attendere per un periodo di tempo in cui specifichi. Fallo con tempo.sonno (1) più avanti nel file.
Contare: La linea di conteggio definisce a variabile, che è un modo per contenere un valore e dargli un nome. Inizierai alle 10, come spiegato più in basso.
Mentre: Il mentre il ciclo esegue il ciclo del codice mentre una condizione è vera. In questo caso, la variabile count determina quando il ciclo si interrompe.
Se affermazioni: All'interno del ciclo è uno Se dichiarazione. Controlla se la variabile count è uno. Se lo è, lo script sta per finire, quindi viene stampato Addio mondo! invece di Ciao mondo!rientro è importante in Pitone per funzioni come questa.

Crea un nuovo file chiamato ciaoarrivederci.pye aprilo in Nano. Quindi, crea una linea shebang, in questo modo:
```
#! /usr/bin/env python3. 
```
Importa il tempo modulo. I moduli sono blocchi di codice predefiniti che puoi aggiungere agli script Python. Nelle fasi più avanzate, creerai il tuo per i tuoi programmi Python. Tuttavia, Python ne contiene diversi incorporati nel linguaggio. Il tempo modulo è un ottimo esempio. Importalo usando un semplice importare un'istruzione all'inizio del file, in questo modo:
```
tempo di importazione. 
```
Impostare il contare variabile. Le variabili in Python e altri linguaggi di programmazione memorizzano informazioni che possono essere modificate e accessibili in seguito. Il nome della variabile funge da sostituto delle informazioni che contiene. Le variabili forniscono un modo coerente per accedere alle informazioni perché le informazioni possono cambiare in qualsiasi momento, ma il nome no. Lo vedrai nel lavoro in questo script:
```
conteggio = 10. 
```
UN mentre loop ripete lo stesso codice ripetutamente finché la condizione data rimane vera. Per questo esempio, il ciclo continua finché contare contiene un valore maggiore di 0.
```
mentre conta > 0: 
```
Le seguenti poche righe sono il codice che il mentre ripetizioni del ciclo. L'indentazione indica a Python quale codice appartiene a quale ciclo, istruzione o funzione. Mantieni il rientro coerente in tutto.

Per questo mentre loop, inizia facendo rientrare ogni riga all'interno del loop con quattro spazi. Quindi, fornire al ciclo il primo bit di codice da eseguire. In questo caso è an Se istruzione che verifica se una condizione è vera. Se lo è, viene eseguito un determinato blocco di codice.

In questo esempio, il Se l'istruzione controlla se contare è uguale a 1. In Python, un singolo segno di uguale (=) viene utilizzato per assegnare un valore. Due segni di uguale (==) controlla se un valore è uguale a un altro.
```
se conta == 1: 
```
Proprio come con il mentre loop, rientro all'interno del Se' dichiarazione. Quindi, rientra quattro spazi in più per tutto all'interno di Se dichiarazione.

Per dire a Python di stampare Addio mondo! Se contare è uguale a 1:
```
print("Addio mondo!")
```
Puoi avere un Se istruzione che viene eseguita solo se una condizione è vera e va avanti, oppure puoi dirgli di fare qualcos'altro nel caso in cui la condizione non sia soddisfatta. Lo fai con altro. Se la condizione è vera, esegui questa operazione. Altrimenti, dì allo script che if contare non è uguale 1, Stampa Ciao mondo!
```
altro:
print("Ciao mondo!")
```
Hai finito con il Se istruzione, quindi questa parte successiva è rientrata con quattro spazi. Utilizzare il dormire funzione da tempo modulo che hai importato per dire a Python di attendere un secondo. Questo non è necessario, ma se non lo fai, Python esegue lo script troppo velocemente per vedere cosa sta succedendo.
```
tempo.sonno (1)
```
Di' a Python di diminuire il valore di contare variabile. In questo modo, la prossima volta mentre corre, contare mantiene un valore minore e alla fine raggiunge lo zero e si ferma. Se non diminuisci il valore, rimane a dieci. La sceneggiatura non dirà mai Addio mondo! e girerà per sempre.
```
conteggio = conteggio -1. 
```
È un po' imbarazzante, quindi c'è un modo breve per gestirlo:
```
conteggio-=1. 
```

Lo script completato si presenta così:

#! /usr/bin/env python3
tempo di importazione
conteggio = 10
mentre conta > 0:
se conta == 1:
print("Addio mondo!")
altro:
print("Ciao mondo!")
tempo.sonno (1)
conteggio-=1.

Script Python con loop e istruzioni su Raspberry Pi

Salva ed esci premendo Ctrl+X, sì, poi accedere.
Rendi eseguibile il nuovo file.
```
chmod +x ciaogoodbye.py. 
```
Esegui lo script per vedere come funziona. Lo vedrai stampare Ciao mondo! nove volte, e Addio mondo! al decimo e ultimo passaggio.