Embed Size (px)
Citation preview
1 Innehåll2 IDLE.................................................................................................3
2.1 Det interaktiva läget.........................................................................3
2.2 Standardläget..................................................................................3
2.3 Färger i IDLE...................................................................................3
3 Variabler.........................................................................................3
3.1 Namn...............................................................................................4
3.2 Värde...............................................................................................4
3.3 Typ...................................................................................................4
4 Kommentarer.................................................................................4
5 Att addera och multiplicera variabler...........................................5
6 Felmeddelanden............................................................................6
7 Inbyggda funktioner......................................................................6
7.1 print( )..............................................................................................7
7.2 input( )..............................................................................................7
7.3 Funktioner för att konvertera typ......................................................8
8 Villkorssatser.................................................................................8
8.1 Olika typer av villkor.........................................................................9
8.2 or & and.........................................................................................10
9 Loopar...........................................................................................10
9.1 while...............................................................................................10
9.2 for...................................................................................................11
10 Funktioner....................................................................................12
10.1 Funktionsanrop..............................................................................12
10.2 Argument.......................................................................................13
1
10.3 Returnera.......................................................................................13
10.4 Att definiera egna funktioner..........................................................13
10.5 Att returnera ett värde från en egen funktion.................................15
11 Moduler (ingår ej i kursen)..........................................................15
11.1 Inbyggda moduler..........................................................................16
12 Grafik (ingår ej i kursen)..............................................................17
12.1 Skapa ett fönster med tkinter.........................................................17
12.2 Lägg till en knapp som öppnar ett infofönster................................17
12.3 Widgets..........................................................................................18
12.4 Tutorials.........................................................................................19
12.4.1 Tutorialspoint............................................................................19
12.4.2 YouTube...................................................................................19
2
2 IDLE
I Windows finns det ett program som heter Anteckningar, där man kan skriva in text. Men om vi vill skriva en bok så använder vi gärna ett annat program, t.ex. Word för att det ska se snyggt ut. På samma sätt kan man använda Anteckningar för att skriva ett datorprogram, men det är mycket bekvämare att göra det i ett annat program där det finns fler funktioner. Ett sådant program kallas för en IDE. När man laddar ner Python så installeras det automatiskt en IDE som kallas för IDLE.
2.1 Det interaktiva läget
När man öppnar IDLE på datorn så kommer man direkt till det som kallas för det interaktiva läget. Här kan man skriva en rad kod, och sedan köra den genom att trycka på Enter, skriva en till rad och köra den genom att trycka på Enter osv.
2.2 Standardläget
Från det interaktiva läget kan man även öppna en ny fil där man kan skriva ett längre program med flera rader kod och köra hela programmet på en gång. Fördelen med detta är att man kan spara sin kod och ändra den i efterhand. I standardläget kör man kod genom att trycka på Run i menyn och välja Run Module (F5).
För att ändra i en fil som man har sparat måste man öppna filen via det interaktiva läget genom att trycka på File i menyn och sedan välja Open.
Se guiden under kategorin guider på teknikbloggen för tydligare instruktioner.
2.3 Färger i IDLE
När vi skriver kod i IDLE kommer vissa saker automatiskt få en viss färg. Detta har inget att göra med hur programmet fungerar, men gör det enklare att läsa koden. Olika färger används i olika IDE:er
3 Variabler
Variabler används i alla programmeringsspråk för att lagra data (information) i datorns minne. En variabel har följande tre egenskaper:
namn värde
3
typ
I Python skapar man en variabel genom att använda likhetstecknet:
x = 10
Här har vi skapat en variabel med namnet x och med värdet 10
3.1 Namn
Variabelnamn kan bestå av ord, bokstäver, siffror och understreck, men måste börja med en bokstav. Mellanrum får inte finnas i variabelnamn.
3.2 Värde
Man kan se det som att en variabel är en låda som innehåller något. Namnet är det man skriver på etiketten på lådan och värdet är vad lådan innehåller. Värdet av en variabel kan vara t.ex. ett ord, ett heltal eller ett decimaltal.
3.3 Typ
På samma sätt som en låda kan innehålla olika typer av objekt kan en variabel också göra det. För tillfället tar vi upp tre olika typer av variabler i kursen: int (heltal), float (decimaltal) och string (tecken). Exempel:
variabel_1 = 30variabel_2 = 2.5varaibel_3 = "Oscar"
Här har vi skapat tre variabler med
Namnen: variabel_1, variabel_2 och variabel_3. Värdena: 30, 2.5 och "Oscar". Typerna int (heltal), float (decimaltal) och string (tecken).
Kom ihåg att "Oscar" egentligen bara är en samling med tecken: "O", "s", "c", "a" och "r". Man sätter alltid citationstecken runt värdet när man skapar en variabel av typen string. Värden av typen string kallas för strängar och blir automatiskt gröna i IDLE.
4
4 Kommentarer
Ibland vill man skriva något i sitt program som inte är kod, utan en kommentar till andra programmerare som ska läsa koden. Då använder man det som kallas för en kommentar. Kommentarer blir automatiskt mörkröda i IDLE. Man använder hashtag för att skapa en kommentar i Python. Allt till höger om och på samma rad som hashtagen ingår i kommentaren.
x = 1 # Kommentar, det här läser inte datorn!y = 2 # Kommentar, det här läser inte datorn!# z = 3# Hashtagen gör att z = 3 inte körs. Alltså skapas # aldrig variabeln z.
5 Att addera och multiplicera variabler
Man kan addera två variabler av typen int eller float med varandra:
x = 1y = 2 + x# y får värdet 3 eftersom x har värdet 1.
Man kan även addera två variabler av typen string med varandra:
name_1 = "Oscar"name_2 = "Bergqvist"full_name = name_1 + name_2# Variabeln full_name får värdet "OscarBergqvist"
Vi kan multiplicera variabler av typen int och float:
x = 2 # x är av typen int (heltal)y = 3 # y är av typen int (heltal)z = x*y # z får värdet 6 som väntat
Det går dock inte att multiplicera två variabler av typen string med varandra:
5
x = "2" # x är av typen string (på grund av "")y = "3" # y är av typen stringz = x*y # ERROR! Vi kan inte multiplicera två tecken!
6 Felmeddelanden
När man programmerar skriver man ibland fel. Då visas en röd text med ett felmeddelande.
I den här bilden visas tre felmeddelanden. Läs bara den sista raden i felmeddelanden för att snabbt se vilket felet är.
SyntaxError är att man har skrivit kod som inte datorn kan läsa. Man kanske har glömt en parentes eller ett citationstecken någonstans för att detta ska ske.
NameError: name ’a’ is not defined beror på att man inte har skapat någon variabel som heter a, så det går såklart inte att skriva ut dess värde.
6
7 Inbyggda funktioner
Funktioner är ett centralt koncept inom programmering. En funktion är en instruktion till datorn om att utföra något, t.ex. skriva ut något till användaren eller lagra något som användaren har skrivit in i datorn. En inbyggd funktion skrivs alltid som ett ord följt av parenteser, till exempel print( ) eller input( ). Ordet kallas för funktionens namn och i parenteserna kan man sätta in ett argument, vilket är något som funktionen ska använda sig av när den utför uppgiften. Inbyggda funktioner färgas automatiskt lila i IDLE.
7.1 print( )
Den här funktionen används för att man ska kunna skriva ut text till användaren. Information som kommer från programmet till användaren brukar kallas för output. Exempel på output är att visa värdet av en variabel på skärmen. Man kan alltså säga att print( ) funktionen genererar output i from av text. Mellan parenteserna kan man skriva ett variabelnamn, eller text inom citationstecken:
lite_text = "Blablabla"print()print(lite_text) # Skriver ut: "Blablabla"print() # Skriver ut: "lite_text"
7.2 input( )
Input-funktionen används för att låta användaren skriva in tecken eller ord, som sedan kan lagras i en variabel (av typen string).
Google är ett bra exempel på varför man kan behöver detta. För att Google ska kunna göra något så måste du som användare skriva in något i sökrutan och trycka på Enter-tangenten. Det du har skrivit in kommer i sin tur användas av programmet, som till slut presenterar en lista med sökträffar. Om Google hade varit skrivet i språket Python, hade de kanske använt funktionen input( ) för att plocka in det användaren skriver i sökrutan till programmet. Information som kommer in till programmet kallas allmänt för input i programmering.
Betrakta den här raden kod i ett program:
word_1 = input( )
När programmet körs, och datorn kommer till input( ), så väntar den med att fortsätta läsa koden fram tills användaren skriver in något och trycker på Enter-tangenten.
Låt oss säga att användaren skriver in
7
Hello!
och därefter trycker på Enter-tangenten. När användaren har gjort detta lagras värdet "Hello!" i variabeln word_1.
Om användaren istället hade skrivit in
1
hade istället värdet "1" (som är en string) lagrats i variabeln word_1 efter det att användaren hade tryckt på Enter-tangenten.
7.3 Funktioner för att konvertera typ
Som jag förklarade tidigare så kan man inte köra koden "2" * "3" i Python, när man använder citationstecken kring ett värde tolkar nämligen datorn detta som en string (tecken) och inte som en siffra (int eller float). Att skriva "2" * "3" är alltså lika fel som att skriva "Kalle" * "Shayan", man inte kan multiplicera tecken med varandra! Men om vi säger åt datorn att omvandla "2" och "3" till tal först, det vill säga typen int eller float så går det bra! Det gör vi genom att använda funktionerna int( ) och float( ) på följande sätt:
int("2") * int("3")# Ger resultatet 6 som väntat!float("2") * float("3")# Ger resultatet 6.0 som väntat!
a = "10"b = "20"a * b # FEL!int(a) * int(b) # RÄTT!
8 Villkorssatser
Tänk dig att du gör en hemsida där användare kan registrera sig och se på film. Du vill dock rekommendera olika filmer för personer i olika åldersgrupper. Om man vill göra något beroende på om ett visst villkor är uppfyllt använder man villkorssatser. Låt oss säga att vi har sparat användarens ålder i en variabel med namnet age. I standardläget i Python använder vi nyckelorden if, elif och else för att göra detta. Ett nyckelord är ett ord som har en förutbestämd funktion i Python. Nyckelord får automatiskt färgen gul i IDLE. Man skriver
8
nyckelord villkor :all kod som man vill ska köras om villkoret är uppfyllt skriver man med ett indrag pådet här sättet. Man använder tab-tangenten för att göra ett indrag.
Ett exempel med riktig kod:
if age < 6 :print("Bilar är en bra film!") print("Hitta Nemo är också en bra film!")
elif age < 12 :print("ET är en bra film")
elif age < 17 :print("Skam är en bra TV-serie")
elif age > 65 :print("Bingolotto är ett bra TV-program!")
else :print("Gudfadern är en bra film!")
if testar om age < 6, det vill säga om barnet är mindre än 6 år gammalt och rekommenderar i så fall Bilar och Hitta Nemo.
Om villkoret age < 6 inte är uppfyllt testar elif om age < 12, om det villkoret är uppfyllt så rekommenderas filmen ET.
Om inte heller age < 12 så testar nästa elif om age < 17 och rekommenderar i så fall TV-serien Skam.
Om inte heller age < 17 så testar den tredje elif om personen är en pensionär, det vill säga om age > 65, i så fall rekommenderas Bingolotto.
Slutligen, om ingen av de tidigare villkoren är uppfyllda, det vill säga om personen är 18–64 år så körs det som står under else, det vill säga filmen Gudfadern rekommenderas.
Glöm inte bort att skriva kolon ( : ) efter villkoren, gör man det blir det SyntaxError. IDLE brukar automatiskt göra ett indrag om man trycker på Enter efter att ha skrivit kolon.
8.1 Olika typer av villkor
Villkor Förklaring
x == 10 Testar om x = 10. Kom ihåg att man skriver "==" och inte "=" när man vill testa om en variabel har
9
ett visst värde!
x < 10 Testar om x < 10
x > 10 Testar om x > 10
8.2 or & and
För att testa om något av flera olika villkor är sant, använder man or. Låt oss säga att vi har lagrat ett namn i variabel med namnet name, då kan vi till exempel skriva:
if name == "Oscar" or name == "Anna":print("Du heter antingen Oscar ELLER Anna")
För att testa om samtliga av ett antal villkor är sanna använder man and. Låt oss säga att vi har lagrat en ålder i en variabel med namnet age. Då kan vi till exempel skriva:
if age > 18 and age < 65: print("Du är äldre än 18 OCH yngre än 65 år!")
9 Loopar
Ibland vill vi upprepa en viss bit kod ett antal gånger. I programmering kan man göra detta med hjälp av det som kallas för loopar. Det finns två typer av loopar: while-loopen och for-loopen.
9.1 while
Denna loop fungerar på samma sätt som villkorssatser. Om ett visst villkor är uppfyllt så kör loopen koden om och om igen. Se till exempel:
x = 1while x < 10:
print(x)
Jämför detta med:
10
x = 1if x < 10:
print(x)
I det senare fallet så körs print(x) en gång, eftersom villkoret är uppfyllt. När vi använder while, kommer print(x) att köras om och om igen i all oändlighet eftersom villkoret är uppfyllt. Prova sedan att lägga till en rad:
x = 1if x < 10:
print(x)x = x + 1
Nu kommer
print(x)x = x + 1
att köras tills x < 10 inte längre är uppfyllt. Eftersom x = x + 1 ökar x med 1 varje gång så kommer koden inte att köras i all oändlighet. Prova själv!
9.2 for
På YouTube kan man spara spellistor, det vill säga en lista med videoklipp som du har sparat. Sedan kan man välja att automatiskt spela upp alla videoklipp i listan efter varandra. För att spela upp alla filmer i din spellista funny_cat_videos måste du säga något i den här stilen till datorn:
för varje film i funny_cat_videos: kod för att spela upp film
I Python kan man faktiskt skriva på nästan exakt samma sätt:
for film in funny_cat_videos:kod för att spela upp film
Här antar vi att vi har en lista funny_cat_videos med filmer.
Låt oss nu övergå till ett verkligt exempel. Prova att skriva in den här koden i standardläget i Python och se vad som händer:
for x in ["Ida", "Moa", "Molly"]:print(x)
11
Prova sedan med detta:
for x in [1, 2, 3, 4, 5, 6]:print(x)
I första fallet så skrivs ett namn ut per rad. I det andra fallet skrivs en siffra ut per rad. Man brukar kalla det gröna i koden för listor. En lista är en egen typ av variabel i Python. Man kan skapa variabler av typen list i Python genom att skriva:
listans_namn = [1, 20, 32, 4]
När man har lagrat en lista i en variabel kan man t.ex. skriva ut den med print:
print(listans_namn)
Eller använda den i en for-loop genom att hänvisa till dess namn:
for x in listans_namn: print(x)
10 Funktioner
Vi har redan pratat lite om inbyggda funktioner i Python. Låt oss titta närmare på funktionen input() och funktionen print():
question = "Vad heter du? Svar: "user_data = input(question)print(user_data)
I den första raden skapar vi en variabel av typen string, med värdet "Namn: ".
I den andra raden skapar vi först en variabel user_data. När datorn sedan ser att det står input(question) efter likhetstecknet, skriver den ut värdet av variabeln question och väntar sedan tills användaren har skrivit in något och tryckt på Enter-tangenten. När användaren har gjort detta så lagras det användaren skrev in i variabeln user_data.
I sista raden så används print(user_data) för att skriva ut värdet av variabeln user_data, vilket är det användaren själv skrev in.
12
10.1 Funktionsanrop
Att använda en funktion i Python kallas för att anropa den. Att skriva
print() print("Oscar")
innebär att anropa funktionen print två gånger, första gången utan något mellan parenteserna och andra gången med "Oscar" mellan parenteserna. Att skriva
input()x = input()x = input("Oscar")
är tre olika exempel på hur man kan anropa funktionen input.
10.2 Argument
Det som man skriver in mellan parenteserna i en funktion kallas för argument. Man kan anropa olika funktion med inga, ett eller flera argument separerade med kommatecken, beroende på hur funktionen är definierad:
funktionsnamn(argument_1, argument_2, argument_3)
10.3 Returnera
Om en funktion ger ifrån sig ett värde som kan sparas i en variabel säger man att funktionen returnerar detta värde. Till exempel input() returnerar ett värde som är det användaren själv skriver in medan programmet körs, medan print() inte returnerar ett värde:
x = input("Namn:")# Det returnerade värdet lagras i xprint("HEJ!") # print returnerar inget
10.4 Att definiera egna funktioner
Vi kan definiera (skapa) egna funktioner i Python, som vi kan anropa på samma sätt som de inbyggda funktionerna. För att skapa en egen funktion i Python använder man nyckelordet def.
13
def funktionsnamn():# Här skriver man kod som ska köras när# funktionen anropas.
Det är viktigt att man definierar sina funktioner högst upp i koden. Koden i definitionen av en funktion körs inte förrän funktionen anropas, vilket man gör genom att skriva:
funktionsnamn()
Om man vill kan man definiera en funktion som man kan anropa med ett eller flera argument. Det gör man genom att skriva:
def funktionsnamn(variabel_namn):# Här skriver man kod som ska köras när# funktionen anropas.
Eller med flera:
def funktionsnamn(a, b, c, d):# Här skriver man kod som ska köras när# funktionen anropas.
Man kallar variabel_namn, a, b, c och d för parametrar, inuti funktionsdefinitionen och argument när man anropar funktionen. Parametrar är variabelnamn, argument är värden!
Fundera över följande exempel på hur man kan definiera en funktion:
def spam():for i in range(100):
print()
Anropa den genom att skriva:
spam()
När vi anropar funktionen genom att skriva spam() så säger vi i princip till datorn att köra det som står inom funktionsdefinitionen, det vill säga:
14
for i in range(100):print()
Det funktionen gör är alltså att skriva ut "SPAM!" 100 gångar. Vi kan anropa funktionen hur många gånger som helst:
spam()spam()spam()
För att göra det lite intressantare kan vi låta användaren själv mata in något som ska spammas (googla spam om ni inte är bekanta med begreppet). Detta kan man göra genom att istället definiera funktionen:
def spam(spam_text):for i in range(100):
print(spam_text)
nu har vi skrivit dit en parameter spam_text, som kan få ett värde genom att anropafunktionen med en string som argument, till exempel:
spam()spam()
10.5 Att returnera ett värde från en egen funktion
På samma sätt som med input-funktionen kan man få en funktion att returnera ett värde som går att lagra i en variabel. Detta gör man i slutet av en funktionsdefinition med hjälp av return:
def summa(a, b):svar = a + breturn svar
Nu kan vi anropa funktionen på detta sätt
x = summa(100, 31)
vilket lagrar summan av 100 och 31 i variabeln x. Kom ihåg att vi använder = för att lagra ett värde i en variabel som vanligt. Den enda skillnaden här är att värdet ges av det funktionen summa returnerar, det vill säga summan av de två argumenten (100 och 31).
15
11 Moduler (ingår ej i kursen)
En modul är i grund och botten en fil som innehåller Pythonkod. När du sparar din kod i standardläget i Python kan man säga att du skapar en modul vars namn är namnet du ger din fil när du sparar den. Låt oss säga att du sparar två filer i samma mapp: fil_1.py och fil_2.py. Filen fil_1 innehåller koden:
def summa(a,b):print(a + b)
Låt oss säga att vi i fil_2 vill använda en funktion som är exakt likadan som den som finns i fil_1. Men istället för att kopiera över koden från fil_1 kan vi låta fil_2 importera alla funktioner som finns i fil_1 genom att skriva in följande kod i början av fil_2:
import fil_1
Nu kan vi i fil_2 använda oss av funktionen summa, som redan finns definierad i fil_1. Vi anropar funktioner i fil_1 genom att skriva fil_1.funktionsanrop:
import fil_2fil_1.summa(4,5)
11.1 Inbyggda moduler
När du importerar saker i Python, letar datorn först efter filen du vill importera i mappen där du befinner dig för närvarande (där filen som du jobbar i är sparad). Om den inte hittar modulen där letar den sedan bland de färdiggjorda moduler som kommer med när du laddar ner Python, det så kallade standardbiblioteket.
I nästa kapitel kommer du att använda dig av en modul som kallas för tkinter. Det finns även en modul som heter turtle, där det finns funktioner som kan användas för att styra en pil som ritar upp saker i ett fönster. Prova skapa ett program med koden:
import turtle
for i in range(4):turtle.forward(100)turtle.left(90)
16
Googla Python 3 turtle tutorial för att hitta webbsidor där du kan lära dig mer om turtle.
12 Grafik (ingår ej i kursen)
För många är skärmen en självklar del av en dator, som är lika viktig som andra delar, t.ex. hårddisken och minnet. Men en dator behöver inte alls ha en skärm. I exempelvis moderna bilar finns det oftast en dator, som håller koll på parkeringssensorer och temperaturen i bilen och andra viktiga saker som kräver en del beräkningar. Ibland vill vi dock att datorn ska visa något för oss, exempelvis en bild eller ett spel och då är det bra att ha en skärm kopplad till datorn. Allt som visas på skärmen kallas för grafik. Grafik är också ett användbart sätt att kunna styra datorn. Vi kan få datorn att visa knappar på skärmen och en mus, och programmera den till att göra vissa saker om användaren för musen över skärmen och klickar på knapparna. Ett program som gör att användaren kan interagera med datorn med hjälp av grafik grafik kallas för GUI (graphical user interface). I Python kan man skapa ett GUI på flera olika sätt. Det sätt som vi kommer att titta på är att använda en modul som kallas för tkinter.
12.1 Skapa ett fönster med tkinter
Först och främst behöver vi importera modulen tkinter:
import tkinter
För att sedan skapa ett fönster skriver vi
import tkinter
window = tkinter.Tk()
## Här emellan skriver man in kod för att lägga till## saker, t.ex. knappar, som ska visas i fönstret
tkinter.mainloop()
Vi har gett vårt fönsterobjekt namnet window, och kan med hjälp av detta namn hålla koll på och ändra utseendet av vårt fönster. Den sista raden gör att programmet går in i en evighetsloop där programmet flera gånger i sekunden testar om något har hänt i fönstret, exempelvis att en knapp trycks ner. En sådan loop kallas för spelloop.
17
12.2 Lägg till en knapp som öppnar ett infofönster
För att lägga till en knapp i fönstret window kan vi skriva:
import tkinter
window = tkinter.Tk()button_1 = tkinter.Button(window, text = "Click",
command = on_click)button_1.pack()
tkinter.mainloop()
Nu har knappen namnet button_1. Texten Click! visas på knappen och funktionen on_click kommer att anropas när någon trycker på knappen. Funktionen pack() tilldelar knappen en viss position i fönstret. Vi måste definiera en funktion on_click som bestämmer vad som ska hända när vi klickar på knappen:
import tkinterimport tkinter.messagebox
def on_click():tkinter.messagebox.showinfo("ALERT",
"You pushed the button!")window = tkinter.Tk()button_1 = tkinter.Button(window, text = "Click",
command = on_click)button_1.pack()
tkinter.mainloop()
I koden ovan har jag även behövt importera modulen tkinter.messagebox, vilket är en modul som finns inne i tkinter-modulen. Genom att importera denna modul kan vi använda oss av funktionen showinfo() som skapar en liten inforuta. Prova kör koden själv och klicka på knappen!
18
12.3 Widgets
Ett fönster kan innehålla flera olika objekt, t.ex. knappar, textfält där användaren kan skriva in text, textfält för att visa text till användaren med mera. Dessa grafiska objekt kallas för widgets. Bilden visar några exempel på widgets som man kan lägga till i sitt fönster.
12.4 Tutorials
Här följer ett antal länkar till webbplatser där man kan lära sig mer om tkinter. Du kan även hitta andra tutorials genom att söka på Google eller YouTube efter Python 3 tkinter tutorial.
12.4.1 Tutorialspoint
På hemsidan tutorialspoint finns det en komplett tutorial om Python 3 i textformat. Den kan vara lite svår att förstå i början, men är en jättebra resurs när man väl förstår. Till vänster på hemsidan ser du en lista med samtliga lektioner.
Lektionen som finns länkad nedan har fyra rubriker: Tkinter programming, Tkinter widgets, Standard attributes och Geometry management. Börja med att läsa Tkinter programming, skumma sedan igenom listan med widgets under Tkinter widgets, hoppa över Standard attributes och titta på listan under Geometry management. När du har gjort detta kan du börja lära dig om olika widgets genom att klicka på länkarna i listan under rubriken Tkinter widgets.
https://www.tutorialspoint.com/python3/python_gui_programming.htm
12.4.2 YouTube
I länken nedan finner du en serie tutorials i videoformat som utförligt förklarar tkinter.
https://www.youtube.com/watch?v=YZs9jMAlmsU
19
Text
Radiobutton
Button
