Hello World: Your First Raspberry Pi Project

December 02, 2021
IDatamaskiner, Bærbare Datamaskiner Og Nettbrett Tilbehør Og Maskinvare

Når du er ny på Raspberry Pi, kan det være fristende å hoppe rett inn i prosjektene som tiltrakk deg til enheten. Roboter, sensorer, musikkspillere og lignende prosjekter er gode bruksområder for Raspberry Pi. Disse prosjektene er imidlertid ikke den beste starten for noen som er nye på enheten. Lær i stedet det grunnleggende før du lader til et komplekst prosjekt.

Hvis du er ny til Linux, kan det være en brattere læringskurve. Så det er best å starte med enkle prosjekter for å gjøre deg kjent med hvordan Python fungerer, og deretter bygge videre på den kunnskapen over tid.

En mild introduksjon

Et vanlig første prosjekt på en Raspberry Pi er å skrive ut teksten Hei Verden, enten til terminalen med et skript eller ved å bruke TOMGANG Python utviklingsmiljø. Dette prosjektet gir deg en enkel og relevant introduksjon til Python. Det er også en funksjon du ofte vil bruke i fremtidige prosjekter.

Her er noen varianter av denne tradisjonelle leksjonen for å sette i gang programmeringsferdighetene dine med Raspberry Pi. Vi bruker Python-skript i stedet for IDLE.

Hei Verden

Du starter på begynnelsen med den grunnleggende utskriften av teksten Hei Verden.

Logg på en terminaløkt, og skriv deretter inn trykk på helloworld.py for å lage et nytt python-skript kalt helloworld.py.

Linux-berøringskommandoen oppretter et nytt tomt dokument. Dokumentnavnet er Hei Verden og har .py utvidelse for å merke den som en Python-skriptfil.
Tast inn nano helloworld.py for å åpne den nye filen med Nano.

Nano er tekstredigerer brukt i dette eksemplet. Det er en enkel editor som følger med de fleste Linux-systemer.
Denne neste biten er teknisk valgfri, men det er en god vane å sette seg inn i. Øverst i dokumentet legger du til en shebang-linje for å spesifisere versjonen av Python du bruker. Dette gjør det også mulig å kjøre skriptet som et kompilert program. For å legge til shebang-linjen, skriv inn:
```
#! /usr/bin/env python3. 
```
Skriv inn et par linjer ned. Deretter bruker du skrive ut funksjon for å fortelle Python å skrive ut setningen Hei Verden! på skjermen. Det ser slik ut:
```
print("Hei verden!")
```
trykk Ctrl+X og trykk deretter Y for å lagre filen. Terminalen ber deg trykke Tast inn for å lagre filen med det spesifikke filnavnet. Du har nettopp laget din første Python-fil.
Gjør skriptet kjørbart i terminalen. For å gjøre det, endre tillatelsene med denne kommandoen:
```
chmod +x helloworld.py. 
```
For å kjøre det nye skriptet, skriv inn denne kommandoen:
```
./helloworld.py. 
```
Dette skrives ut Hei Verden! og lukker skriptet, og gjør terminalen tilgjengelig for bruk.

Hei, så verden

På tide å gå opp et gir. Dette eksemplet skriver ut ordet Hallo på en linje og Verden! på neste. Dette legger til en ny linje til Python-filen på et enkelt nivå.

Åpne skriptet ditt med Nano. Skriv inn følgende i en terminal:
```
nano helloworld.py. 
```
Legg til en ny samtale for å skrive ut, og bryte opp Hei Verden! inn i Hallo og Verden! For å gi hvert ord sin egen oppfordring til utskrift, skriv inn følgende:
```
print ("Hei")
print("Verden!")
```
Lagre og avslutt skriptet. trykk Ctrl+X og svar med Y når du blir spurt.
Kjør skriptet fra terminalen. Denne gangen får du se Hallo og Verden! på separate linjer. Skriv inn denne kommandoen for å kjøre skriptet:
```
./helloworld.py. 
```
Manuset kan gjøres mer effektivt. Python kan dra nytte av et spesialtegn for å lage nye linjer hvor som helst i teksten din. Slett den andre skrive ut linje, og legg til Verden! til første linje. Skriptet skal nå se slik ut:
```
print("Hei verden!")
```
Fjern mellomrommet mellom Hallo og Verden! Deretter erstatter du mellomrommet med Unix-nylinjetegnet, \n. Kommandoen ser slik ut:
```
print("Hei\nVerden!")
```
Lagre og avslutt når skriptfilen.
Kjør skriptet. Resultatet er identisk med de to separate skrive ut linjer. For å kjøre skriptet, skriv inn:
```
./helloworld.py. 
```

Hei verden, farvel verden

Ved å bruke det du lærte i forrige eksempel, vil du endre ting slik at skriptet sier Hei Verden! ni ganger. Så, mens manuset er i ferd med å bli ferdig, skrives det ut Farvel verden!

Disse instruksjonene introduserer noen nye konsepter:

Import: Den import linje bringer inn tid modul, som lar deg be filen vente i en periode der du spesifiserer. Gjør dette med time.sleep (1) senere i filen.
Telle: Tellelinjen definerer en variabel, som er en måte å holde en verdi på og gi den et navn. Du starter dette klokken 10, som er forklart lenger ned.
Samtidig som: Den mens loop sløyfer koden mens en betingelse er sann. I dette tilfellet bestemmer tellevariabelen når sløyfen stopper.
Hvis uttalelser: Innenfor løkken er en hvis uttalelse. Den sjekker om tellevariabelen er én. Hvis det er det, er skriptet i ferd med å avsluttes, så det skrives ut Farvel verden! i stedet for Hei Verden!Innrykk er viktig i Python for funksjoner som dette.

Lag en ny fil kalt hellogoodbye.py, og åpne den i Nano. Deretter lager du en shebang-linje, slik:
```
#! /usr/bin/env python3. 
```
Importer tid modul. Moduler er forhåndsbygde biter av kode som du kan legge til Python-skript. På mer avanserte stadier vil du lage din egen for Python-programmene dine. Likevel inneholder Python flere som er innebygd i språket. De tid modul er et godt eksempel. Importer den ved hjelp av en enkel import uttalelse mot toppen av filen, slik:
```
importtid. 
```
Sett telle variabel. Variabler i Python og andre programmeringsspråk lagrer informasjon som kan endres og åpnes senere. Variabelnavnet fungerer som en stand-in for informasjonen den inneholder. Variabler gir en konsistent måte å få tilgang til informasjon på fordi informasjonen kan endres når som helst, men navnet kan ikke. Du vil se det i arbeid i dette skriptet:
```
antall = 10. 
```
EN samtidig som loop gjentar den samme koden gjentatte ganger så lenge betingelsen gitt til den forblir sann. For dette eksemplet fortsetter løkken så lenge som telle har en verdi større enn 0.
```
mens teller > 0: 
```
De følgende få linjene er koden som samtidig som loop gjentas. Innrykk forteller Python hvilken kode som tilhører hvilken løkke, uttalelse eller funksjon. Hold innrykk konsekvent hele veien.

For dette samtidig som løkke, begynn med å rykke inn hver linje i løkken med fire mellomrom. Deretter gir du løkken den første kodebiten som skal kjøres. I dette tilfellet er det en hvis uttalelse som sjekker om en betingelse er sann. Hvis det er det, kjører en bestemt kodeblokk.

I dette eksemplet er hvis erklæring sjekker om telle er lik 1. I Python, et enkelt likhetstegn (=) brukes til å tilordne en verdi. To likhetstegn (==) sjekker om en verdi er lik en annen.
```
hvis teller == 1: 
```
Akkurat som med samtidig som løkke, innrykk innenfor hvis' uttalelse. Så, rykk inn ytterligere fire mellomrom for alt innenfor hvis uttalelse.

For å fortelle Python å skrive ut Farvel verden! hvis telle er lik 1:
```
print("Farvel verden!")
```
Du kan ha en hvis setning som bare kjører hvis en betingelse er sann og går videre, eller du kan be den om å gjøre noe annet i tilfelle betingelsen ikke er oppfylt. Du gjør dette med ellers. Hvis betingelsen er sann, gjør dette. Ellers fortell manuset at hvis telle er ikke lik 1, skrive ut Hei Verden!
```
ellers:
print("Hei verden!")
```
Du er ferdig med hvis uttalelse, så denne neste delen er rykket inn med fire mellomrom. Bruke søvn funksjon fra tid modul som du importerte for å fortelle Python å vente et sekund. Dette er ikke nødvendig, men hvis du ikke gjør det, kjører Python gjennom skriptet for raskt for å se hva som skjer.
```
time.sleep (1)
```
Be Python om å redusere verdien av telle variabel. På denne måten, neste gang samtidig som løper, telle har en lavere verdi og når til slutt null og stopper. Hvis du ikke reduserer verdien, forblir den på ti. Manuset vil aldri si Farvel verden! og vil løkke for alltid.
```
telle = telle -1. 
```
Det er litt vanskelig, så det er en kort måte å håndtere det på:
```
telle-=1. 
```

Det ferdige skriptet ser slik ut:

#! /usr/bin/env python3
importtid
antall = 10
mens teller > 0:
hvis teller == 1:
print("Farvel verden!")
ellers:
print("Hei verden!")
time.sleep (1)
telle-=1.

Python-skript med looper og uttalelser på Raspberry Pi

Lagre og avslutt ved å trykke Ctrl+X, Y, og så Tast inn.
Gjør den nye filen kjørbar.
```
chmod +x hellogoodbye.py. 
```
Kjør skriptet for å se hvordan det fungerer. Du vil se den skrives ut Hei Verden! ni ganger, og Farvel verden! på tiende og siste pass.