Rekenkunde — deling, resten en de decimale val

Het probleem dat we oplossen

Er zijn 17 boeken en een doos past er 5 in. Hoeveel dozen, en hoeveel boeken blijven over?

Het antwoord is niet 17 / 5. Dat geeft 3.4, en 3.4 dozen bestaan niet. Je hebt twee aparte antwoorden nodig: hoeveel hele en hoeveel er overblijft. Python heeft voor elk een operator, en het blijken twee van de nuttigste operators die je zult leren — paginering, seconden splitsen in uren en minuten, controleren of een getal even is, komen hier allemaal vandaan.

Er is nog iets dat iedereen de eerste keer stopt: in Python geeft 0.1 + 0.2 niet 0.3. Waarom dat niet zo is, en wat je eraan doet, zit ook in dit hoofdstuk.

Aan het einde van dit hoofdstuk kun je

• De zeven rekenoperators gebruiken
• Zeggen welke berekening eerst gaat, en wanneer haakjes nodig zijn
• Herkennen wanneer // en % de juiste tool zijn
• Uitleggen waarom / altijd een decimaal getal oplevert, ook als de deling exact is
• Berekeningen schrijven die rekening houden met de precisiegrenzen van decimale getallen

Voorkennis: Variabelen en types.

De zeven operators

print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3)
print(10 // 3)
print(10 % 3)
print(10 ** 3)

13
7
30
3.3333333333333335
3
1
1000

De laatste drie verdienen een woordje:

• // — gehele deling. Deelt en houdt het hele deel, gooit de rest weg
• % — modulo, de rest. Wat er overblijft na de deling
• ** — macht. 10 ** 3 is tien tot de derde

/ levert altijd een decimaal getal op. Zelfs 10 / 5 geeft 2.0, niet 2. Als het type ervan afhing of de deling exact uitkwam, zou het gedrag van een programma onvoorspelbaar zijn, dus houdt Python hier één regel aan: / betekent float. Als je een heel getal nodig hebt, gebruik je //.

Het doosprobleem oplossen

books = 17
per_box = 5

full_boxes = books // per_box
left_over = books % per_box

print("Full boxes:", full_boxes)
print("Left over :", left_over)

Full boxes: 3
Left over : 2

Drie dozen worden vol en 2 boeken blijven buiten. // en % komen als een paar — de ene zegt "hoeveel hele", de andere "hoeveel er overblijft".

Dezelfde combinatie komt op veel meer plekken terug:

total_seconds = 500

minutes = total_seconds // 60
seconds = total_seconds % 60

print(minutes, "min", seconds, "sec")

8 min 20 sec

En % is hoe je even en oneven test. Deel elk getal door 2 en de rest is 0 (even) of 1 (oneven):

print(14 % 2)
print(15 % 2)

0
1

Die rest is precies wat een later hoofdstuk over voorwaarden (if) op zal bouwen.

Welke berekening gaat eerst

Python volgt de gewone regels van de rekenkunde — vermenigvuldigen en delen vóór optellen en aftrekken:

print(10 + 5 * 2)
print((10 + 5) * 2)

20
30

Op de eerste regel gebeurde 5 * 2 eerst, daarna werd 10 opgeteld. Op de tweede regel veranderden de haakjes de volgorde.

Van hoog naar laag:

1. **
2. *, /, //, %
3. +, -

print(2 + 3 * 4 ** 2)

50

4 ** 2 is 16, dan is 3 * 16 48, en dan is 2 + 48 50.

Bij twijfel, gebruik haakjes. Zelfs met kennis van de regels is (a + b) / 2 beter geschreven dan a + b / 2 — de volgende persoon die het leest, hoeft geen enkele regel te herinneren. Extra haakjes vertragen de code niet; ze maken hem alleen duidelijk.

Dit is de meest voorkomende fout bij beginners, en hij komt naar voren wanneer je een gemiddelde berekent:

a = 10
b = 20
c = 30

wrong = a + b + c / 3
right = (a + b + c) / 3

print("Wrong:", wrong)
print("Right:", right)

Wrong: 40.0
Right: 20.0

Het programma gaf geen fout. Niets in rood, niets kapot — alleen een verkeerd antwoord. Dat is de gevaarlijkste soort bug die er is, want Python waarschuwt je niet. Alleen door de rekenkunde zelf te controleren, vang je hem.

De decimale val

print(0.1 + 0.2)

0.30000000000000004

Dit is niet de schuld van Python. Computers slaan getallen op in grondtal twee, en 0.1 kan niet exact worden geschreven in grondtal twee — net zoals 1/3 niet exact te schrijven is in decimaal, waar 0.3333... maar doorgaat. Dus slaat de computer iets zeer dichtbij op, en het optellen van twee van die getallen maakt het kleine verschil zichtbaar. JavaScript, Java en C gedragen zich allemaal hetzelfde.

Twee praktische gevolgen:

Eén — afronden wanneer je het weergeeft:

total = 0.1 + 0.2
print(round(total, 2))

0.3

round(total, 2) betekent: bewaar twee plaatsen na de decimale punt.

Twee — vergelijk twee decimalen nooit met ==:

print(0.1 + 0.2 == 0.3)

False

Dit is de val die verkeerde antwoorden oplevert in financiële berekeningen. Serieuze projecten bewaren geen geld in een float — ze slaan de kleinste eenheid op als een heel getal (49.99 wordt 4999), of ze gebruiken de aparte module decimal. Voor nu is het genoeg om te weten waar de grens ligt; modules komen later.

Een compleet voorbeeld

packing.py:

# Work out packing and shipping for one order
total_items = 47
items_per_box = 6
box_cost = 35.5

full_boxes = total_items // items_per_box
loose_items = total_items % items_per_box

# A partly filled box still costs a full box
boxes_needed = full_boxes
if loose_items > 0:
    boxes_needed = full_boxes + 1

shipping = boxes_needed * box_cost

print("Items        :", total_items)
print("Full boxes   :", full_boxes)
print("Loose items  :", loose_items)
print("Boxes needed :", boxes_needed)
print("Shipping     :", round(shipping, 2))

Items        : 47
Full boxes   : 7
Loose items  : 5
Boxes needed : 8
Shipping     : 284.0

De regel met if is nog niet behandeld — daarvoor zijn de volgende hoofdstukken bedoeld. Lees hem nu gewoon: als er artikelen los overblijven, is er één doos extra nodig.

Wanneer het misgaat

ZeroDivisionError: division by zero Er is iets door nul gedeeld. In de wiskunde is dat ook onbepaald, dus houdt Python op. Je moet de deler controleren voordat je deelt — wat makkelijk wordt zodra je voorwaarden kent.

10 / 5 gaf 2.0 en ik heb 2 nodig Gebruik //, of schrijf int(10 / 5). Het eerste is beter: de bedoeling is zichtbaar in de code.

// geeft vreemd uit bij negatieve getallen -7 // 2 geeft -4, niet -3. Python rondt af naar beneden, niet naar nul. Onthoud dit als je met negatieve getallen werkt.

De berekening ziet er goed uit maar het antwoord is verkeerd Tel de haakjes na, en breek elke stap op in een eigen regel en druk die af. De fout is vrijwel altijd de rangorde van operators.

Een lange staart van cijfers na de decimale punt Dat is geen fout, zo gedragen decimalen zich. Maak het korter met round() als je het weergeeft.

Jouw beurt

Schrijf een bestand genaamd time_split.py dat een aantal seconden splitst in uren, minuten en seconden.

Begin met total_seconds = 7385, en de uitvoer moet zijn:

2 h 3 m 5 s

Drie voorwaarden:

1. Gebruik alleen // en % — typ geen van de resultaten met de hand
2. Bewaar de drie waarden in drie aparte, betekenisvolle variabelen
3. Verander total_seconds daarna in 59, 60, 3600 en 86399 en voer elke keer uit — controleer dat alle vier goed uitkomen

Sla die laatste stap niet over. Een programma dat voor één invoer werkt, werkt niet; een programma dat ook aan de randen standhoudt, wel.