Detta skapar en PDF som du sedan kan skriva ut. Du kan även spara ner PDFn och skriva ut senare.
Titel på utskriften?
Tack för ditt bidrag
Om vi kan använda det så lägger vi upp det på sidan. Nedan en länk till ditt bidrag om du vill spara det.
Spara som ...
Du sparar ditt skript under detta namn och kan sedan hämta tillbaka det med samma namn.
Läs in
Läs in ett tidigare sparat skript. Obs att du enbart kan läsa in skript i den webbläsare där du sparade skriptet. Vill du kunna läsa in och spara skript oberoende av webbläsare, så behöver du skaffa ett login (enkelt och gratis).
Skicka in bidrag
Föreslå rubrik
Beskriv vad din kod gör
Skapa kort länk
Använd en kort URL för att skicka länk till koden via SMS eller epost. När mottagaren klickar på länken, så öppnas denna webbsida, med din kod och din text. Länken rensas bort automatiskt om den inte används.
Rubrik (frivilligt)
Beskrivning (frivilligt)
Länk (kopiera hela)
Funktioner
Man kan se funktioner som att man bakar ihop kod som man ofta använder och ger denna kod ett namn. Så istället för att skriva samma sak flera gånger, så använder man en funktion. Vill man i framtiden ändra något, behöver man bara ändra på ett ställe. Man kan också se funktioner som återvinning. Det blir mindre kod, risken för fel minskar.
Funktioner kan ta parametrar (dvs att vi skickar med ett värde vid anropet) eller inte, kan returnera något (ger ifrån sig ett värde) eller inte. En funktion som inte returnerar någonting brukar ibland kallas procedur. Kan vara bra veta. Funktioner inuti klasser brukar man kalla metoder. Ibland råkar någon kanske förväxla metod och funktion. Häng inte upp dig på det. Försök förstå hur det fungerar, snarare än vad någon kallar det.
procedur()
En enkel funktion/procedur nedan.
def hej():
print("Denna funktion skriver bara ut lite text")
print("----------------------------------------")
def hej():
print("Denna funktion skriver bara ut lite text")
print("----------------------------------------")
Tja, inget händer innan vi anropat vår funktion.
def hej():
print("Denna funktion skriver bara ut lite text")
print("----------------------------------------")
hej()
hej()
def hej():
print("Denna funktion skriver bara ut lite text")
print("----------------------------------------")
hej()
hej()
y = f(x)
Låt oss öka tempot lite ...
Normalt vill man skicka in någonting i funktionen (input), som används inne i funktionen. Vi kallar variablerna som fångar upp det inskickade för parameter. När vi, vid körning, skickar med en konkret siffra, då kallar vi denna siffra för argument. Oftast vill vi också att något skall komma ut i andra änden (output). Vi kallar det returvärde.
Säg att vi vill skapa en funktion som heter dubbla och den dubblar det vi skickar in. Vi vill att själva funktionen skall returnera ett värde (output), dvs man tänker sig att funktionen kan ersättas med returvärdet.
Det som händer här, det är alltså att vi skickar in 4 som argument. I funktionen blir siffra = 4, det är där funktionen startar. Vi dubblar denna siffra i samma veva som vi skickar tillbaka returvärdet. Stirra dig blind på detta exempel, tills det är glasklart.
Funktionen vi skapat kan användas så ofta vi vill, i alla möjliga olika beräkningar.
def dubbla(siffra):
return(siffra * 2)
x = 4
y = dubbla(x)*dubbla(2)+dubbla(5)
print(y)
def dubbla(siffra):
return(siffra * 2)
x = 4
y = dubbla(x)*dubbla(2)+dubbla(5)
print(y)
Nedan funktion tar en poängsumma som argument, 0-50 poäng. Under 20 poäng är underkänt dvs ger 0 i betyg. 20-30 ger 3a, 30-40 ger 4a och 40-50 ger 5a i betyg. Om vi skapar en tuple kan vi också få tydligare om det är underkänt.
Om man håller sig vaken på föreläsningar lär man sig kanske något sånt här, som gör samma sak.
def dec2bin(dec):
bin = ""
while dec > 0:
bit = str(dec % 2)
bin = bit + bin
dec = dec // 2
return bin
print(dec2bin(435))
def dec2bin(dec):
bin = ""
while dec > 0:
bit = str(dec % 2)
bin = bit + bin
dec = dec // 2
return bin
print(dec2bin(435))
lista som argument
En funktion kan ta en lista, tuple, dictionary eller ett set som argument.
lista1 = [1,2,3,4,5,6]
lista2 = [7,8,9,10,11,12]
def finns(tal, lst):
for t in lst:
if(t==tal):
return True
return False
print(finns(3,lista1))
print(finns(3,lista2))
lista1 = [1,2,3,4,5,6]
lista2 = [7,8,9,10,11,12]
def finns(tal, lst):
for t in lst:
if(t==tal):
return True
return False
print(finns(3,lista1))
print(finns(3,lista2))
Leta efter maxvärde eller minvärde ...
def maxvarde(lista):
max = -9999999999
for tal in lista:
if tal > max:
max = tal
return(max)
def minvarde(lista):
min = 9999999999
for tal in lista:
if tal < min:
min = tal
return(min)
lst = [1,2,3,4,5,6,7,8,9]
print(maxvarde(lst))
print(minvarde(lst))
tup = (1,2,3,4,5,6,7,8,9)
print(maxvarde(tup))
print(minvarde(tup))
settet = {1,2,3,4,5,6,7,8,9}
print(maxvarde(settet))
print(minvarde(settet))
def maxvarde(lista):
max = -9999999999
for tal in lista:
if tal > max:
max = tal
return(max)
def minvarde(lista):
min = 9999999999
for tal in lista:
if tal < min:
min = tal
return(min)
lst = [1,2,3,4,5,6,7,8,9]
print(maxvarde(lst))
print(minvarde(lst))
tup = (1,2,3,4,5,6,7,8,9)
print(maxvarde(tup))
print(minvarde(tup))
settet = {1,2,3,4,5,6,7,8,9}
print(maxvarde(settet))
print(minvarde(settet))
Rekursiva funktioner
En funktion kan anropa sig själv. Det gäller här att hålla tungan i rätt mun, så att det inte blir en evighetsloop.
Vi kan omvandla mellan decimaltal och binärt med en rekursiv algoritm såhär.
1. Om talet är udda eller jämt slutar det på 1 eller 0.
2. Repetera med heltalskvoten av division med 2 av talet.
Låt oss titta på ovan rekursiva funktion steg för steg. Så vi bygger alltså successivt på LSB på talet, där %2 testar om det är udda eller jämt. Vi skickar på nytt in heltalskvoten av division med 2 i dec2bin som gör samma sak. Successivt halveras talet och vi får fram alla bitar.
Säg att vi vill räkna ut fakulteten, som exempel. En klassisk rekursiv funktion eftersom den faktiskt är begriplig. Fakultet av 5 skrivs 5! = 1*2*3*4*5 som exempel.
På hur många olika sätt kan 4 personer ställa sig i en kö?
def fak(n):
if(n==1):
return(1)
else:
return(n*fak(n-1))
def personer_i_ko(per):
print("{0} pers kan ställa sig på {1} sätt".format(per,fak(per)))
print("På hur många sätt kan x personer ställa sig i en kö?")
personer_i_ko(2)
personer_i_ko(3)
personer_i_ko(4)
def fak(n):
if(n==1):
return(1)
else:
return(n*fak(n-1))
def personer_i_ko(per):
print("{0} pers kan ställa sig på {1} sätt".format(per,fak(per)))
print("På hur många sätt kan x personer ställa sig i en kö?")
personer_i_ko(2)
personer_i_ko(3)
personer_i_ko(4)
Permutationer
På hur många olika sätt kan vi välja ut 3 stycken pristagare (guld, silver och brons) i en grupp på 30 personer? Detta problem sorterar under kombinatorik inom matematiken. Vi behöver räkna ut antal permutationer av k personer i en grupp på n.
Säg att vi bara skall dela ut 3 stycken likadana diplom bland 30 personer, det står "grattis" på diplomet.
Hur många grupper på 3 personer kan det skapas?
För att förklara poängen med lambda -funktioner, låt oss först titta på ännu ett exempel på funktioner. Nedan ur matteboken, ungefär. Linjens lutning, derivata.
Säg att vi, givet en funktion, t.ex. den rosa linjen här ovan, vill kunna räkna ut denna funktions lutning i en punkt x,f(x)
Dvs, vi skapar en funktion derivata() som tar en funktion som parameter. Sedan räknar vi ut lutningen i punkten x,f(x) för denna funktion.
Lambda kallas också anonym funktion. Grejen är den, att funktionen behöver ju inget namn. Vi definierar den som argument, det är allt vi behöver. Vi vill bara skicka in den, inget mer.
Det går att skriva lambda -funktioner som tar flera parametrar.
def exekvera_funktionen(f, a, b):
return(f(a,b))
formel = input("Ange en formel med x och y, t.ex. 2*x+10*y")
funktionen = "lambda x,y:" + formel
resultat = exekvera_funktionen(eval(funktionen), 5,5)
print("Om man stoppar i x=5 och y=5 i formeln",formel,"så blir det",resultat)
def exekvera_funktionen(f, a, b):
return(f(a,b))
formel = input("Ange en formel med x och y, t.ex. 2*x+10*y")
funktionen = "lambda x,y:" + formel
resultat = exekvera_funktionen(eval(funktionen), 5,5)
print("Om man stoppar i x=5 och y=5 i formeln",formel,"så blir det",resultat)
Du kan också skapa "vanliga" funktioner på detta vis med lambda.
min_fun = lambda x: x*x*x
print(min_fun(10))
min_fun = lambda x: x*x*x
print(min_fun(10))
min_fun = lambda x,y: x*y
print(min_fun(5,5))
min_fun = lambda x,y: x*y
print(min_fun(5,5))
tentafråga
Skriv en lambdafunktion som tar 2 strängar och returnerar den längsta av dem.
x = "kalle"
y= "olle"
def test(fun,a,b):
print(fun(a,b))
test(lambda x,y:x if len(x)>len(y) else y,x,y)
x = "kalle"
y= "olle"
def test(fun,a,b):
print(fun(a,b))
test(lambda x,y:x if len(x)>len(y) else y,x,y)
Lite frågor
Måste en funktion returnera något?
Nej
Ja
Måste man skicka med något till funktionen eller kan man anropa såhär min_fun()
Nej, funktionen måste inte ha parametrar
Ja, minst en parameter
def f(x=1,y=2,z=3):
return(x+y+z)
Om vi gör anropet x = f(2), vad blir x ?
1
2
7
4
lst = [1,2,3,4]
def f(a):
s = 0
for t in a:
s+=t
return s
Om vi gör anropet x = f(lst), vad blir x ?
1
10
7
4
def f(f,x):
return(f(x))
Om vi gör anropet x = f(lambda x:7*x-6,2), vad blir x ?