4. Räkna med programmering
Logga in
| | 8 sidor teori |
| | 12 Uppgifter - Nivå 1 - 3 |
| | Varje lektion är menad motsvara 1-2 lektioner i klassrummet. |
import math print(math.pi) x = 19.7531
print(math.sqrt(x))
print(round(x,1)) en_lista = [-7, 2, 19, 3]
print(max(en_lista))
print(sum(en_lista))
print(len(en_lista))Kan du lista ut vad kodraderna ovan gör? Ändra värdena i x och en_lista för att se hur resultatet påverkas. Vad gör tror du ettan på rad 7 gör? Vad händer om första raden tas bort?
I den här lektionen går vi igenom följande begrepp:
// mellan täljaren och nämnaren. Om man t.ex. skriver 32 // 5 får man resultatet 6 eftersom det finns 6 hela 5:or i 32. kvot = 32 // 5
print(kvot)För att beräkna resten man får vid heltalsdivision använder man modulo-operatorn. I Python skrivs den som ett procenttecken mellan täljaren och nämnaren, t.ex. 32 % 5, vilket ger resultatet 2 eftersom det blir 2 över om man delar 32 med 5.
rest = 32 % 5
print(rest)print("Kvot:", 23 // 12, "Rest:", 23 % 12)
print("Kvot:", 3001 // 103, "Rest:", 3001 % 103)
print("Kvot:", 87178291199 // 115249, "Rest:", 87178291199 % 115249)Använd operatorn // för kvoten och % för resten.
För att beräkna heltalskvoten använder vi operatorn // mellan täljaren och nämnaren, alltså 23 // 12. På samma sätt använder vi operatorn % för att beräkna resten och skriver 23 % 12. Vi lägger även till några extra utskrifter så att vi vet vad det är som skrivs ut.
print("Kvot:", 23 // 12, "Rest:", 23 % 12)>
Kvot: 1 Rest: 11Genom att kopiera denna rad och byta ut värdena kan vi återanvända koden och göra samma sak för de två andra divisionerna.
print("Kvot:", 23 // 12, "Rest:", 23 % 12)
print("Kvot:", 3001 // 103, "Rest:", 3001 % 103)
print("Kvot:", 87178291199 // 115249, "Rest:", 87178291199 % 115249)>
Kvot: 1 Rest: 11
Kvot: 29 Rest: 14
Kvot: 756434 Rest: 29133I Python finns många inbyggda funktioner som kan vara användbara. Dessa kan t.ex. användas för att göra olika matematiska beräkningar. Pythons nummerfunktioner som abs(), int() och float() omvandlar enskilda värden eller konverterar mellan olika typer.
| Funktioner för tal | |
|---|---|
abs()
|
Beräknar absolutbeloppet av argumentet. Skriver man t.ex. abs(-35) beräknas ∣−35∣ och man får det positiva talet 35 som resultat.
|
int() och float()
|
Konverterar värden till datatypen heltal respektive flyttal. Dessa kan man bland annat använda för att konvertera strängar till värden man kan räkna med. T.ex. får man heltalet 23 om man skriver int('23'). Det är viktigt att tänka på att int() struntar i eventuella decimaldelar av ett tal, så int(2.94) ger resultatet 2.
|
Listfunktioner som sum(), len(), min() och max() analyserar samlingar som helhet och beräknar sammanlagda egenskaper.
| Funktioner för listor | |
|---|---|
sum()
|
Används för att beräkna summan av ett antal värden i en lista. Exempelvis ger sum([1, 2, 3]) resultatet 6.
|
len()
|
Använder man detta kommando på en lista svarar det listans längd, alltså antalet element i listan. T.ex. får man resultatet 3 om man skriver len([1, 2, 3]).
|
min() och max()
|
Används för att hitta det minsta respektive största värdet i en lista. I listan [1, 2, 3] får man exempelvis ut 1 om man skriver min([1, 2, 3]) och 3 om man skriver max([1, 2, 3]).
|
En modul kan också kallas bibliotek
eller paket
. Det är kod man kan läsa in i sitt program för att få tillgång till fler funktioner. I Python finns t.ex. modulen math, som innehåller matematiska funktioner, och matplotlib, med funktioner för att rita grafer och diagram. För att importera, dvs. läsa in, en modul skriver man import överst i programmet.
import mathFunktioner från modulen kan sedan användas var som helst i programmet genom att skriva modulens namn följt av en punkt och funktionens namn.
import math
print(math.sqrt(9))>
3.0math - modul
Modulen math används till mer avancerade matematiska beräkningar i Python.
pi, esqrt()exp()log()log(100, 10) ger t.ex. tiologaritmen av 100.radians()degrees()sin(), cos(), tan()asin(), acos(), atan()
I trigonometrin får man lära sig att sin(90∘)=1 och att arccos(−1)=180∘. Pythons funktioner sin() och acos() räknar dock inte vinklar i enheten grader, utan i radianer. Det är viktigt att tänka på detta när man skriver program, så att man inte får helt fel värden.
import math
vinkel1 = 90
sinus = math.sin(vinkel1)
print(sinus)>
0.8939966636005579import math
cosinus = -1
vinkel2 = math.acos(cosinus)
print(vinkel2)>
3.141592653589793degrees() och radians() så att sinus blir 1 och vinkel2 blir 180 i beräkningarna ovan.
import math
vinkel1 = math.radians(90)
sinus = math.sin(vinkel1)
print(sinus)import math
cosinus = -1
vinkel2 = math.degrees(math.acos(cosinus))
print(vinkel2)Använd radians() för att omvandla grader till radianer och degrees() för att omvandla radianer till grader.
Grader och radianer är olika enheter att mäta vinklar i, på samma sätt som t.ex. ett avstånd kan mätas i både cm och tum. För att beräkningarna ska fungera som förväntat måste vi ta hänsyn till de olika enheterna. Grader omvandlas till radianer med radians(), och den första vinkeln kan därför skrivas om på det här sättet.
import math
vinkel1 = math.radians(90)
sinus = math.sin(vinkel1)
print(sinus)>
1.0Nu får vi rätt sinusvärde. Den andra vinkeln att omvandla är resultatet av beräkningen math.acos(cosinus), eftersom funktionen acos() svarar med vinklar i radianer. För att omvandla radianer till grader används degrees().
import math
cosinus = -1
vinkel2 = math.degrees(math.acos(cosinus))
print(vinkel2)>
180.0round()
För att avrunda värden i Python använder man kommandot round() och skriver det tal man vill avrunda innanför parenteserna.
print(round(2.75))>
3Som standard avrundas värdet till ett heltal, men genom att lägga till ett extra argument kan man välja hur man avrundar. Argumentet anger hur många steg från decimaltecknet avrundningen sker, där positiva tal anger steg till höger och negativa tal anger steg till vänster. T.ex. avrundar man till hundradelar om argumentet är 2 och till tiotal om det är −1.
print(round(1786.1314, 2))
print(round(1786.1314, -1))>
1786.13
1790.0På grund av hur man har valt att avrundning ska fungera i Python och hur decimaltal lagras kan man inte lita på att avrundningen exakt kommer att följa de avrundningsregler man är van vid. Oftast stämmer det, men man får t.ex. resultatet 2 om man skriver round(2.5). För att alltid avrunda uppåt eller nedåt använder man funktionen ceil respektive floor från modulen math.
import math
print(math.ceil(3.14159))
print(math.floor(2.71828))>
4
2Skriv ett program som tar en lista med ett udda antal element och skrivet ut värdet i mitten. Testa programmet på listorna [9, -38, 15, 2, -1] och ['hej', 'på', 'dig'].
Vi börjar med att skapa själva listan, som vi kan kalla en_lista.
en_lista = [9, -38, 15, 2, -1]
För att hitta det värde som står i mitten av listan behöver vi det elementets index, alltså dess placering i listan. Eftersom elementet finns i mitten låter det som en god idé att börja med att dela listans längd med 2. Längden kan vi beräkna med hjälp av kommandot len(), så vi skulle kunna skriva
len(en_lista) / 2.Detta ger dock resultatet 2.5, vilket inte fungerar som ett index eftersom det inte är ett heltal. Indexeringen börjar på 0, så det index vi faktiskt är ute efter för listan [9, -38, 15, 2, -1] är 2. Det kan vi få antingen genom att avrunda 2.5 neråt med hjälp av floor() eller att göra en heltalsdivision med operatorn // istället för en vanlig division. Vi kan alltså antingen skriva
math.floor(len(en_lista) / 2)len(en_lista) // 2.Dessa ger samma resultat, så vi väljer det andra alternativet eftersom det är kortare. Vi sparar resultatet i variabeln index.
en_lista = [9, -38, 15, 2, -1]
index = len(en_lista) // 2
Vi kan nu välja ut mittenvärdet genom att skriva en_lista[index]. Vi skriver också ut värdet så att vi kan bekräfta att vi har gjort rätt.
en_lista = [9, -38, 15, 2, -1]
index = len(en_lista) // 2 mittvarde = en_lista[index] print(mittvarde)
> 15
Vi ändrar till sist första raden för att testa programmet på listan ['hej', 'på', 'dig'].
en_lista = ['hej', 'på', 'dig']
index = len(en_lista) // 2 mittvarde = en_lista[index] print(mittvarde)
> på
Gör ett program som använder variabeln alder (ålder i antal år) och skriver ut hur många miljoner sekunder man levt, avrundat till närmsta heltal. T.ex. ska alder = 16 ge resultatet nedan.
>
Du har levt i 505 miljoner sekunder!Vi börjar med att räkna ut hur många sekunder man levt. Varje år är 365 dygn, varje dygn är 24 timmar, varje timme är 60 minuter och varje minut är 60 sekunder.
alder = 16 sekunder = alder * 365 * 24 * 60 * 60 print(sekunder)
> 504576000
Antalet sekunder är alltså 504 576 000. En miljon är 1 000 000 eller 10^6, så antalet miljoner sekunder blir
504 576 00010^6.
Vi sparar detta i en ny variabel, milj_sek = sekunder / 10**6. Slutligen behöver vi bara avrunda detta till ett heltal, vilket görs med round().
alder = 16 sekunder = alder * 365 * 24 * 60 * 60 milj_sek = sekunder / 10**6 print('Du har levt i', round(milj_sek), 'miljoner sekunder!')
> Du har levt i 505 miljoner sekunder!
Det går också att avrunda sekunder till ett helt antal miljoner innan man gör en division. Då används andra argumentet i round() där man sätter -6 eftersom miljontalen räknas 6 steg vänster från kommatecknet.
alder = 16 sekunder = alder * 365 * 24 * 60 * 60 print(round(sekunder, -6))
> 505000000
Nu behöver vi bara skala bort de sex extra nollorna på slutet. Det gör vi genom att beräkna heltalskvoten då talet delas med 10^6, dvs. en miljon.
alder = 16 sekunder = alder * 365 * 24 * 60 * 60 print(round(sekunder, -6) // 10**6)
> 505
Då är beräkningen klar, vi behöver bara sätta ett meddelande runt resultatet.
alder = 16 sekunder = alder * 365 * 24 * 60 * 60 milj_sek = round(sekunder, -6) // 10**6 print('Du har levt i', milj_sek, 'miljoner sekunder!')
> Du har levt i 505 miljoner sekunder!
Skriv ett program som, givet en täljare och en nämnare, skriver ut heltalsdivisionens kvot och rest men utan att använda // eller %.
Operatorerna // och % hade fått fram kvot och rest direkt, men de får vi alltså inte använda. Då får vi nog nöja oss med vanlig division, så vi börjar med att utföra den divisionen. För att ha några tal att räkna med väljer vi en täljare och en nämnare, t.ex. 8 och 3.
taljare = 8 namnare = 3 print(taljare / namnare)
> 2.6666666666666665
Detta visar att 3 går två hela gånger i 8. Decimalutvecklingen är en följd av att divisionen inte går jämnt upp, dvs. att det finns en rest. Men heltalsdelen är kvoten vi är ute efter, och decimalutvecklingen kan skalas bort genom att avrunda talet nedåt med math.floor().
import math
taljare = 8 namnare = 3 kvot = math.floor(taljare / namnare) ##round() kan inte användas här eftersom den hade avrundat upp till 3, och så många treor får inte plats i 8. print(kvot)
> 2
De två 3:or som får plats blir 6 tillsammans, vilket är 2 steg från täljaren 8. Resten ska alltså bli 2. Vi får programmet att räkna ut det genom att ta kvot * namnare, vilket lägger ihop alla hela treor, och subtraherar detta från taljare. Skillnaden blir vår rest.
rest = taljare - kvot*namnare
Sista steget är att skriva ut våra resultat.
import math
taljare = 8 namnare = 3 kvot = math.floor(taljare / namnare) rest = taljare - kvot*namnare print('Kvot:', kvot) print('Rest:', rest)
Kvot: 2 Rest: 2
Programmet nedan är tänkt att lagra ett stort antal sekunder i variabeln n samt dela upp tiden på ett sådant sätt att man kan skriva ut hur många år, dygn, timmar, minuter och sekunder det motsvarar. Ersätt varje ☐-tecken med antingen % eller // så att programmet fungerar som det ska.
n = 4367841237
s = n ☐ 60
m = (n ☐ 60) ☐ 60
t = (n ☐ 3600) ☐ 24
d = (n ☐ (3600*24)) ☐ 365
y = n ☐ (3600*24*365)
print(n,'sekunder är',y,'år,',d,'dygn,',t,'timmar,',m,'minuter och',s,'sekunder.')Här måste vi komma ihåg att // och % är operatorer för heltalsdivision, där // ger antalet hela medan % ger resten. Vi börjar på rad 3.
s = n ☐ 60
Det är rimligt att anta att denna rad ska bestämma antalet sekunder som blir över
när tiden delas in i hela antal år, dygn, timmar och minuter. Så vilken operator ska ☐ bytas ut mot? Beräkningen n // 60 ger antalet hela minuter, eftersom det går 60 sekunder på 1 minut. n % 60 ger istället antal sekunder som blir över när antalet hela minuter beräknats, dvs. precis det vi söker!
s = n % 60
På rad 4 finns variabeln m, vilken bör stå för antalet överblivna minuter. För att beräkna det behövs först det totala antalet hela minuter, dvs. n // 60. Om detta delas med 60 får vi antalet timmar, där resten är antal överblivna minuter. Vi byter allså första rutan mot // och andra mot %.
m = (n // 60) % 60
Sedan är det bara att upprepa resonemanget. Det går 60* 60 = 3600 sekunder på en timme, och därför är antalet hela timmar n // 3600. Vi tar resten då antalet hela timmar delas med 24, för att få antalet timmar som blir över när timmarna delas in i hela dygn.
t = (n // 3600) % 24
På rad 6 bestämmer vi överblivna dygn då dessa delas in i år. Det går 3600 sekunder på en timme och 24 timmar på ett dygn, så 3600 * 24 ger antal sekunder på ett dygn. n // (3600 * 24) motsvarar då antal hela dygn, och vi avslutar med % 365 för att bestämma hur många dygn som blir över.
d = (n // (3600 * 24)) % 365
Slutligen vill vi beräkna antalet år. Det går 365 dygn på ett år, vilket blir 3600 * 24 * 365 sekunder. Här bryr vi oss bara om antalet hela år - någon rest behövs inte eftersom åren inte delas in
i någon större enhet.
n = 4367841237
s = n % 60 m = (n // 60) % 60 t = (n // 3600) % 24 d = (n // (3600*24)) % 365 y = n // (3600*24*365) print(n,'sekunder är',y,'år,',d,'dygn,',t,'timmar,',m,'minuter och',s,'sekunder.')
> 4367841237 sekunder är 138 år, 183 dygn, 17 timmar, 13 minuter och 57 sekunder.