Tal, operatorer og matematiske funktioner

Tal og operatorer

I dette afsnit vil du lære om hvordan Python arbejder med tal og værdier.

Hel- og decimaltal

Python arbejder med 2 forskellige taltyper:

• Heltal, som kaldes integers
• Decimaltal, som kaldes float

Vi kan kende taltypen på om der er et . (punktum) i det eller ej, og vi kan få Python til at fortælle det med kommandoen type().

Når man arbejder med tal i Python skal man ikke definere om man arbejder med hel- eller decimaltal (intergers eller floating point). Det holder Python selv styr på ud fra din indtastning. Husk at bruge . (punktum) ved decimaltal.

>>> a = 3
>>> b = 3.14
>>> type(a)
<class 'int'>
>>> type(b)
<class 'float'>

Computeren tæller fra 0

Computere tæller anderledes end os mennesker, fordi 0 er den første værdi. For os er tallet 1 den første værdi, fordi tæller når der er noget at tælle. Vi bruger f.eks. fingrene.

Computere holder styr på tallene ved hjælp af transistorer, som enten kan være tændt eller slukket. Så når computeren skal starte med at tælle, så afsætter den et antal transistorer dertil - Her kigger vi på to.

Selvom ingen af transistorerne i den første tilstand er tændt, så er det computerens første værdi. Og den er 0 - for der er ingen aktivitet. Tallene 00, 01, 10 og 11 kaldes for binære tal. I stedet for at skifte position efter 10 værdier (base 10) ... skifter de efter 2 (base 2).

Er du lidt nysgerrig på binære tal kan du bruge Python til at undersøge dem, ved at læse herunder:

>>> int("111111",2)
63
>>> int("10111001",2)
185

>>> bin(200)
'0b11001000'
>>> bin(3)
'0b11'

>>> int("ff",16)
255
>>> hex(255)
'0xff'

Regneregler

Regningsarterne fungerer ved at anvende tegnene: +, -, * og /. Se herunder:

>>> 6+3
9
>>> 6-3
3
>>> 6*3
18
>>> 6/3
2.0

Læg mærke til at resultatet ved division er en float. Python vil altid konvertere divisionsstykker til float uanset om det giver et heltal eller ej. Er resultatet med et

XX.0

ligesom her, kan det konverteres til en int med kommandoen int(2.0).

Python anvender korrekte regneregler, hvilket vil sige at + og - adskiller ledene. Der skal altsåsættes paranteser for at omgå dette. Se eksemplerne herunder:

>>> 3+2*6
15
>>> (3+2)*6
30
>>> 3+6/2
6.0
>>> (3+6)/2
4.5	

Øvelse

I de nedenstående opgaver skal du lave regnestykker ved hjælp af at bruge alle tallene, regningsarterne +, -, * og / samt parenteser:

Afrunding af decimaler

Pythons udregninger er med alle cifre. Når vi ser på resultater er vi ofte ikke interesseret i mere end 2-4 decimalers nøjagtighed.

For at afrunde decimaler anvender vi round(). Funktionen virker på følgende måde:

round ([Tal],[Antal_decimaler])

Lad os se et praktisk eksempel:

>>> 2/3
0.6666666666666666
>>> round(_,2)
0.67

Afrunding af hele tal

Nogle gange har vi brug for at afrunde decimaltal til et helt tal, og alt efter situationen skal der rundes op eller ned.

Lad os sige at vi har et resultat på

4,3

, så kan det have stor betydning om det er antallet af passagerer i en bil eller antallet af sodavand der skal købes ind. Ingen vil være

0,3

passager, og de fleste vil blive skuffet hvis alle andre fik en sodavand og man selv blev snydt.

I dette tilfælde har Python 2 funktioner vi kan anvende:

math.floor()

Runder tallet ned til nærmeste hele tal

math.ceil()

Runder tallet op til nærmeste hele tal

For at anvende math.floor() og math.ceil() skal vi først importere pakken math.

Lad os tage eksemplet fra før med værdien

4,3

>>> import math #importere math pakkerne
>>> math.floor(4.3)
4
>>> math.ceil(4.3)
5

Vi kan altså løbende rette vores resultater til alt efter om der skal rundes op eller ned i forhold til heltallet.

Modulus og floor division

Hvis man kun har brug for heltallet eller resten efter en beregning. Det gør man med // (floor division) og % (modulus).

Her vil jeg tage udgangspunkt i disse to brøker: \( \frac 7 4 = 1 \frac 3 4 \) og \( \frac 8 3 = 2 \frac 2 3\).

Floor division - //

Returnerer heltalsdelen af divisionen

>>> 7//4
1
>>> 8//3
2

Som vi kan se returnerer floor division heltalsdelen

Modulus - %

Returnerer resten af divisionen

>>> 7%4
3
>>> 8%3
2

Der er altså henholdsvis \( \frac 3 4 \) og \( \frac 2 3 \) tilbage i rest.

Man kan ved hjælp af modulus og floor division omskrive en uægte brøk til en blandet brøk efter følgende model:

Anvendelse

modulus og floor division virker i første omgang lidt underlige, men har en masse praktiske anvendelser. F.eks:

• Hvis noget skal ske hver tredie gang: x%3 == 0
• Antal fyldte ølkasser: *antal flasker* // 30

Brøker

For at regne med brøker skal man importere funktionen Fraction fra pakken fractions.

Her vælger vi kun at importere en del af pakken og det gør vi på følgende måde:

>>> from fractions import Fraction

For at lave en brøk skriver vi det på følgende måde:

Fraction([TÆLLER],[NÆVNER])

Lad os prøve at kigge på følgende udtryk: \( \frac{ 2 }{ 3 } \cdot \frac{ 3 }{ 4 } = \frac{ 1 }{ 2 } \)

>>> from fractions import Fraction
>>> brøk1 = Fraction(3,4) # brøken 3/4
>>> brøk2 = Fraction(2,3) # brøken 2/3
>>> brøk1 * brøk2
Fraction(1, 2)

Python svarer at resultatet er

\( \frac 1 2 \) (fraction(1,2))

Input med Fraction

Man kan også lave input med Fraction. Her skal man skrive selve brøken TÆLLER/NÆVNER og ikke (TÆLLER,NÆVNER).

>>> brøk = Fraction(input("Enter Fraction: "))
Enter Fraction: 4/7
>>> brøk
Fraction(4, 7)

Hvis du vil bruge selve brøken som input, så skal den laves som en string.

>>> Fraction("1/3")
Fraction(1, 3)

Hvad er brøken

Vi kan også bruge Fraction() til at finde en tilnærmet brøk - altså en brøk der ligger så tæt på tallet som muligt.

Hvad er f.eks. 0.125?

>>> Fraction(0.125)
Fraction(1, 8)

0,125 er altså det sammen som "\( \frac 1 8 \), hvilket i dette tilfælde er korrekt.

Du kan læse mere om at finde tilnærmede brøker herunder:

>>> Fraction(0.185)
Fraction(3332663724254167, 18014398509481984)

>>> Fraction(0.185).limit_denominator()
Fraction(37, 200)

>>> Fraction(0.185).limit_denominator(100)
Fraction(5, 27)

Tilfældige tal

Python har to funktioner der kan bruges til at lave tilfælde tal:

randrange([START],[SLUT])

Bruges til at lave hele tilfælde tal mellem start og slut.

random()

Bruges til at lave tilfælde tal mellem 0 og 1

For at bruge funktionerne skal de først importeres. Det gør du sådan her:

from random import random, randrange

Tilfældige heltal f.eks: terningkast

For at simulere et terningkast(D6) bruger vi følgende kommando:

>>> randrange(1,7)
3
>>> randrange(1,7)
4

Læg mærke til at jeg har skrevet 1,7 i parentesen. Det er fordi funktionen vælger et tilfældig heltal fra 1 til 7 - altså hvor 7 ikke er med.

Det svarer til når vi siger vi har læst fra kapitel 1 til kapitel 3 i en bog - altså hvor vi har læst kapitel 1 og 2.

Det skal man lige vænne sig til, men som du vil se senere, så er det smart at gøre det på den måde.

Tilfældige tal

Til nogle beregninger har man brug for et tilfældig tal mellem i intervallet \( [~0~;1] \). Dem laver man på følgende måde:

>>> random()
0.3484349123341326
>>> random()
0.19551293791949897

Opgaver

Terningspil 1

Lav et program hvor man skal spille terning mod computeren, og hvor den største værdi vinder.

• Terningen bliver kastet 1 gang
• Brugeren skal kunne indtaste sit navn
• Output skal være om computer eller bruger er vinder eller at der er uafgjort

Output

Output

	========================= RESTART: /home/tj/test.py =========================
Hvad er dit navn: Thomas

Thomas: 4
Computer: 4

Det blev uafgjort	

Ordsprog

Lav et program der ved hjælp af random() udskriver et ud af mindst 4 forskellige ordsprog.

Potens og rødder

For at finde potens tal og rødder anvendes funktionen pow(a,b), hvor a er grundtallet og b er potensen.

\( a^b \) = pow(a,b)

For at regne rødder ud skal man anvende følgende omskrivning:

Rødder regnes altså ud på følgende måde:

\( \sqrt [b] {a} \) = pow(a,1/b)

Eksempler

>>> pow(4,2)
16
>>> pow(16,1/2)
4.0

Man kan have funktioner inde i funktioner, f.eks:

>>> pow(pow(7,2),1/5)
2.17790642448278
>>> round(_,4)
2.1779

Opgave

Beregn følgende tal:

Alternativ skrivemåde

På nettet kan du støde ind i denne skrivemåde:

>>> 4**2
16

Jeg anbefaler at du ikke bruger denne, da den ikke er lige så læselig som pow()

Konstanter

I matematik bruger vi konstanter som f.eks. \( \pi \) og \( e \).

For at få adgang til dem skal vi igen importere math.

math.pi

Indeholder tallet \( \pi \)

math.e

Eulers tal ... eller basen for den naturlige algoritme

>>> import math
>>> math.pi
3.141592653589793
>>> math.e
2.718281828459045

Absolutte tal

Absolutte tal er altid positive.

Det er faktisk mere brugbart end man lige forestiller sig, fordi det kan bruges til at beskrive forskellen mellem 2 tal uanset hvilket man starter med.

Et eksempel kan være temperatur hvor de to målinger er på henholdsvis 18° og 20°.

>>> 18-20
-2
>>> 20-18
2

Du og jeg kan hurtigt se, at temperaturforskellen er på to grader, men for en computer er der 4 grader til forskel. Altså temperaturen fra -2 → 2.

Det kan vi ordne ved at funktionen abs(), som returnerer forskellen mellem 2 tal:

>>> abs(18-20)
2
>>> abs(20-18)
2

Operatorer

Når vi skriver at noget er lig med =større end >, så bruger vi operatorer. Operatorer beskriver forholdet mellem to værdier.

Når vi bruger operatorer, så svarer Python om det er sandt eller falsk.

Se nedenstående skema:

Herunder kan du se nogle eksempler

==       Lig med

>>> 5 == 5
True
>>> 5 == 8
False

!=       Ikke lig med

>>> 5 != 5
False
>>> 5 != 8
True

>       Større end

>>> 5 > 8
False
>>> 8 > 5
True

<       Mindre end

>>> 5 < 8
True
>>> 8 < 5
False

>=       Større end eller lig med

>>> 5 >= 5
True
>>> 5 >= 6
False

<=       Mindre end eller lig med

>>> 5 <= 5
True
>>> 5 <= 4
False

x and y       Både x og y skal være sand

>>> 5 == 5 and 6 > 5
True
>>> 5 == 5 and 4 > 5
False

x or y       Enten x eller y skal være sand

>>> 5 == 5 or 6 > 5
True
>>> 5 == 5 or 4 > 5
True

Intervaller

Man kan beskrive et afgrænset talområde matematisk ved hjælp af sammensatte uligheder f.eks:

Det udtrykket siger er: "15 er mindre end x, som er mindre end 25". Oversat til 2 udtryk:

1. x skal være større end 15 og
2. x skal være mindre end 24

I Python skal man skrive det som ovenfor. Altså :

>>> x > 15 and x <= 24

Nu kan vi bruge det til at teste:

>>> x = 20
>>> x > 15 and x < 24
True
>>> x = 30
>>> x > 15 and x <= 24
False

Logaritmer

For at regne med logaritmer anvender vi funktionen math.log(). Funktionen bruges på følgende måde:

math.log(x,base)

Udelader du basen, bruger Python som standard den naturlige logaritme \( e \), altså det vi matematik plejer at notere som \( ln(x) \).

Skal du funde ud af hvad potensen er i udtrykket: \( 10^a = 100 \) er a =

100

og basen=

10

.

For at anvende logaritmer skal pakken math importeres.

>>> import math
>>> math.log(100,10)
2.0

Udtrykket \( 0,45^x = 0,83 \) vil altså være:

>>> math.log(0.83,0.45)
0.23334725397646897

For at tjekke det er korrekt:

>>> pow(.45,_)
0.83