Hello World: Ditt första Raspberry Pi-projekt

December 02, 2021
IDatorer, Bärbara Datorer Och Surfplattor Tillbehör Och Hårdvara

När du är ny på Raspberry Pi, kan det vara frestande att hoppa rakt in i de projekt som lockade dig till enheten. Robotar, sensorer, musikspelare och liknande projekt är bra användningsområden för Raspberry Pi. Dessa projekt är dock inte den bästa starten för någon som är ny på enheten. Lär dig istället grunderna innan du laddar in i ett komplext projekt.

Om du är ny till Linux, det kan vara en brantare inlärningskurva. Så det är bäst att börja med enkla projekt för att bekanta dig med hur Pytonorm fungerar, och sedan bygga vidare på den kunskapen över tid.

En mild introduktion

Ett vanligt första projekt på en Raspberry Pi är att skriva ut texten Hej världen, antingen till terminalen med ett skript eller med hjälp av PÅ TOMGÅNG Python utvecklingsmiljö. Detta projekt ger dig en enkel och relevant introduktion till Python. Det är också en funktion som du ofta kommer att använda i framtida projekt.

Här är några varianter av denna traditionella lektion för att få igång dina programmeringskunskaper med Raspberry Pi. Vi kommer att använda Python-skript istället för IDLE.

Hej världen

Du börjar från början med den grundläggande utskriften av texten Hej världen.

Logga in på en terminalsession och skriv sedan in tryck på helloworld.py för att skapa ett nytt python-skript som heter helloworld.py.

Linux-pekkommandot skapar ett nytt tomt dokument. Dokumentnamnet är Hej världen och har .py förlängning för att markera den som en Python-skriptfil.
Stiga på nano helloworld.py för att öppna den nya filen med Nano.

Nano är textredigeraren används i detta exempel. Det är en enkel redigerare som kommer med de flesta Linux-system.
Den här nästa biten är tekniskt valfri, men det är en bra vana att börja med. Överst i dokumentet lägger du till en shebang-rad för att ange vilken version av Python du använder. Detta gör det också möjligt för skriptet att köras som ett kompilerat program. För att lägga till shebang-raden, skriv in:
```
#! /usr/bin/env python3. 
```
Skriv ett par rader ner. Använd sedan skriva ut funktion för att berätta för Python att skriva ut frasen Hej världen! på skärmen. Det ser ut så här:
```
print("Hej världen!")
```
Tryck Ctrl+X och tryck sedan på Y för att spara filen. Terminalen ber dig att trycka Stiga på för att spara filen med det specifika filnamnet. Du har precis skapat din första Python-fil.
Gör skriptet körbart i terminalen. För att göra det, ändra dess behörigheter med detta kommando:
```
chmod +x helloworld.py. 
```
För att köra det nya skriptet, skriv in detta kommando:
```
./helloworld.py. 
```
Detta trycker Hej världen! och stänger skriptet, vilket gör terminalen tillgänglig att använda.

Hej då världen

Dags att gå upp en växel. Detta exempel skriver ut ordet Hej på en rad och Värld! på nästa. Detta lägger till en ny rad till din Python-fil på en enkel nivå.

Öppna ditt manus med Nano. Ange följande i en terminal:
```
nano helloworld.py. 
```
Lägg till ett andra samtal för att skriva ut och bryt upp Hej världen! in i Hej och Värld! För att ge varje ord en egen uppmaning att skriva ut, skriv in följande:
```
print("Hej")
print("Världen!")
```
Spara och avsluta skriptet. Tryck Ctrl+X och svara med Y på frågan.
Kör skriptet från terminalen. Den här gången får du se Hej och Värld! på separata rader. Ange detta kommando för att köra skriptet:
```
./helloworld.py. 
```
Manuset kan göras mer effektivt. Python kan dra nytta av ett specialtecken för att skapa nya rader var som helst i din text. Ta bort den andra skriva ut linje och lägg till Värld! till första raden. Skriptet ska nu se ut så här:
```
print("Hej världen!")
```
Ta bort utrymmet mellan Hej och Värld! Byt sedan ut utrymmet med Unix nyradstecken, \n. Kommandot ser ut så här:
```
print("Hej\nVärlden!")
```
Spara och avsluta en gång skriptfilen.
Kör skriptet. Resultatet är identiskt med de två separata skriva ut rader. För att köra skriptet, skriv in:
```
./helloworld.py. 
```

Hej världen, hejdå värld

Med hjälp av det du lärde dig i föregående exempel kommer du att ändra saker så att skriptet säger Hej världen! nio gånger. Sedan, när manuset är på väg att slutföras, skrivs det ut Hejdå världen!

Dessa instruktioner introducerar några nya koncept:

Importera: Den importera linje tar in tid modul, som låter dig be filen att vänta under en viss tid som du anger. Gör det här med time.sleep (1) senare i filen.
Räkna: Räkneraden definierar en variabel, vilket är ett sätt att hålla ett värde och ge det ett namn. Du börjar detta vid 10, vilket förklaras längre ner.
Medan: Den medan loop loopar koden medan ett villkor är sant. I det här fallet bestämmer räknevariabeln när slingan stannar.
Om uttalanden: Inom slingan finns en om påstående. Den kontrollerar om räknevariabeln är en. Om det är det, är skriptet på väg att sluta, så det skrivs ut Hejdå världen! istället för Hej världen!Indrag är viktig i Pytonorm för sådana här funktioner.

Skapa en ny fil som heter hellogoodbye.py, och öppna den i Nano. Skapa sedan en shebang-linje, så här:
```
#! /usr/bin/env python3. 
```
Importera tid modul. Moduler är förbyggda bitar av kod som du kan lägga till i Python-skript. I mer avancerade stadier kommer du att göra din egen för dina Python-program. Ändå innehåller Python flera som är inbyggda i språket. De tid modulen är ett bra exempel. Importera den med en enkel importera uttalande längst upp i filen, så här:
```
importtid. 
```
Ställ in räkna variabel. Variabler i Python och andra programmeringsspråk lagrar information som kan ändras och nås senare. Variabelnamnet fungerar som en stand-in för informationen som den innehåller. Variabler ger ett konsekvent sätt att komma åt information eftersom informationen kan ändras när som helst, men inte namnet. Du kommer att se det i arbetet i det här skriptet:
```
antal = 10. 
```
A medan loop upprepar samma kod upprepade gånger så länge som villkoret som ges till den förblir sant. För det här exemplet fortsätter loopen så länge som räkna har ett värde större än 0.
```
medan räkning > 0: 
```
Följande några rader är koden som medan loop upprepas. Indrag talar om för Python vilken kod som hör till vilken loop, sats eller funktion. Håll indragen konsekvent hela tiden.

För detta medan loop, börja med att dra in varje rad i slingan med fyra blanksteg. Förse sedan slingan med den första kodbiten som ska köras. I det här fallet är det en om uttalande som kontrollerar om ett villkor är sant. Om så är fallet körs ett visst kodblock.

I det här exemplet är om uttalande kontrollerar om räkna är lika med 1. I Python, ett enda likhetstecken (=) används för att tilldela ett värde. Två likhetstecken (==) kontrollerar om ett värde är lika med ett annat.
```
om räkna == 1: 
```
Precis som med medan slinga, indrag inom den om' påstående. Så dra in ytterligare fyra blanksteg för allt inom om påstående.

Att säga åt Python att skriva ut Hejdå världen! om räkna är lika med 1:
```
print("Adjö världen!")
```
Du kan ha en om uttalande som bara körs om ett villkor är sant och går vidare, eller så kan du säga åt det att göra något annat om villkoret inte är uppfyllt. Du gör det här med annan. Om villkoret är sant, gör detta. Berätta annars för manuset att om räkna är inte lika 1, skriva ut Hej världen!
```
annan:
print("Hej världen!")
```
Du är klar med om uttalande, så denna nästa del är indragen med fyra mellanslag. Använd sömn funktion från tid modul som du importerade för att berätta för Python att vänta en sekund. Detta är inte nödvändigt, men om du inte gör det, går Python igenom skriptet för snabbt för att se vad som händer.
```
time.sleep (1)
```
Säg till Python att minska värdet på räkna variabel. Så här, nästa gång medan springer, räkna håller ett lägre värde och når så småningom noll och stannar. Om du inte minskar värdet stannar det på tio. Manuset kommer aldrig att säga Hejdå världen! och kommer att loopa för alltid.
```
räkna = räkna -1. 
```
Det är lite besvärligt, så det finns ett kortfattat sätt att hantera det:
```
räkna-=1. 
```

Det färdiga skriptet ser ut så här:

#! /usr/bin/env python3
importtid
antal = 10
medan räkning > 0:
om räkna == 1:
print("Adjö världen!")
annan:
print("Hej världen!")
time.sleep (1)
räkna-=1.

Python-skript med loopar och uttalanden på Raspberry Pi

Spara och avsluta genom att trycka på Ctrl+X, Y, och då Stiga på.
Gör den nya filen körbar.
```
chmod +x hellogoodbye.py. 
```
Kör skriptet för att se hur det fungerar. Du kommer att se det tryckt Hej världen! nio gånger, och Hejdå världen! på det tionde och sista passet.