Werkplaats / De werkplaats
In jouw eigen tempo
← Wiskunde-fundament
MODULE 02 · LES 03

Een matrix doet iets met een vector

Lees vormen, verwissel rijen en kolommen en bouw een lineaire afbeelding.

45 min3 checkpoints
DIT GA JE ONTDEKKEN
  • Je onderscheidt het aantal rijen van het aantal kolommen.
  • Je berekent een matrix-vectorproduct en legt de betekenis van de kolommen uit.

Een model kan uit woonoppervlakte en aantal kamers meerdere scores maken. Elke score combineert dezelfde invoer met andere gewichten. Een matrix (matrix) bewaart die gewichten als een rechthoek van getallen: elke rij maakt één uitvoer.

Stel je een machine voor met twee invoerknoppen en twee meters. De eerste meter telt tweemaal de eerste invoer; de tweede telt eenmaal de eerste en driemaal de tweede. Voordat we die machine bouwen, leren we haar getallen netjes lezen.

1. Rijen lopen horizontaal

Een matrix kan ook gewoon een gegevenstabel zijn. Hieronder staan twee huizen met steeds drie kenmerken, in dezelfde volgorde:

Twee huizen, drie kenmerken
HuisOppervlakteKamersBouwjaar
08031990
112042010

De vorm (shape) is het aantal rijen, gevolgd door het aantal kolommen: hier (2, 3). Python bewaart een matrix als een lijst van rijen. A[1] kiest de tweede rij; A[1][2] kiest daaruit het derde getal, dus bouwjaar 2010.

A = [[80, 3, 1990], [120, 4, 2010]]
print(A[1])           # [120, 4, 2010]
print(A[1][2])        # 2010
print((len(A), len(A[0])))   # (2, 3)

len(A) telt de rijen en len(A[0]) de getallen in de eerste rij. De haakjes rond twee waarden met een komma maken een tuple: een vaste geordende verzameling, hier de vorm. Net als bij lijsten lees je het eerste element met [0]; een tuple kun je niet op zijn plaats wijzigen.

Veelgemaakte fout: drie kenmerken betekent niet drie rijen. Lees eerst hoe de gegevens zijn opgeslagen. In deze les zijn matrices altijd niet leeg en rechthoekig: alle rijen zijn even lang.

Maak vorm(A) en geef de twee aantallen als tuple terug.

01
CHECKPOINTEerst de vorm, dan rekenen

2. Dezelfde getallen anders ordenen

Bij transponeren (transpose) wordt iedere kolom een rij. Voor [[1, 2, 3], [4, 5, 6]] lees je eerst de kolom 1, 4; daarna 2, 5; daarna 3, 6. Het resultaat is [[1, 4], [2, 5], [3, 6]], met vorm (3, 2).

Om een nieuwe rij te bouwen, begin je met de lege lijst []. Met .append(waarde) voeg je achteraan één element toe. Dit voorbeeld verzamelt de eerste kolom:

A = [[1, 2, 3], [4, 5, 6]]
nieuwe_rij = []
for i in range(len(A)):
    nieuwe_rij.append(A[i][0])
print(nieuwe_rij)   # [1, 4]

Voor alle kolommen zet je hier een buitenste lus omheen, met j als kolompositie. range(len(A[0])) geeft hier 0, 1, 2; de bovengrens telt niet mee. Onderstaande structuur laat zien waar iedere lijst begint en wanneer zij klaar is:

resultaat = []
for j in range(len(A[0])):
    nieuwe_rij = []
    for i in range(len(A)):
        nieuwe_rij.append(A[i][j])
    resultaat.append(nieuwe_rij)
print(resultaat)
# [[1, 4], [2, 5], [3, 6]]

De binnenste lus vult één rij; daarna bewaart de buitenste lus die hele rij. Maak nieuwe_rij telkens opnieuw, anders blijven eerdere getallen erin staan. Bouw hiermee transpose(A); zet return resultaat buiten beide lussen, binnen de functie, en laat A zelf intact.

02
CHECKPOINTVan rij naar kolom

3. Iedere rij maakt één getal

Terug naar onze machine. Bij invoer (4, 2) geeft de eerste meter 2 × 4 + 0 × 2 = 8; de tweede geeft 1 × 4 + 3 × 2 = 10. Dit is per rij het inproduct uit de vorige les.

[2013][42]=[810]

De vierkante haken groeperen de getallen; twee blokken naast elkaar betekenen hier matrixvermenigvuldiging. Een vector staat in de formule rechtop, terwijl Python haar als gewone lijst bewaart. De vector moet precies zoveel componenten hebben als de matrix kolommen heeft.

A = [[2, 0], [1, 3]]
x = [4, 2]
print(A[0][0] * x[0] + A[0][1] * x[1])
# 8
print(A[1][0] * x[0] + A[1][1] * x[1])
# 10

Dit heet een lineaire afbeelding (linear map). Bij invoer (1, 0) krijg je (2, 1), precies de eerste kolom; bij (0, 1) krijg je (0, 3), de tweede kolom. Deze twee invoervectoren heten basisvectoren: zij kiezen afzonderlijk de horizontale en verticale bijdrage.

DE KOLOMMEN WIJZEN DE WEGEen matrix verandert de ruimte

Groen is de eerste kolom, oranje de tweede. Samen beelden ze (1, 1) af.

xy
A(1, 1) (1.0, 1.0)det(A) 1.00

Zet de vier getallen op 2, 0, 1, 2 en bekijk de twee gekleurde pijlen: de kolommen (2, 1) en (0, 2). Het vierkant met zijden één toont hoe een heel gebied mee verandert. Laat de meetwaarde det(A) nog even staan: die leer je twee lessen verder kennen.

Maak matvec(A, x) voor passende vormen. Loop over de rijen, start per rij een totaal op nul en tel alle componentproducten op; voeg elk berekend totaal aan de uitvoerlijst toe. Een nulvector blijft nul: deze machine kan niet zomaar alles een vaste afstand verschuiven.

03
CHECKPOINTIedere rij maakt één uitvoer

Wat neem je mee?

  • De vorm vertelt eerst rijen, dan kolommen; A[i][j] kiest rij i en daarin kolom j.
  • Transponeren maakt van elke kolom een nieuwe rij.
  • Matrix maal vector berekent per rij één inproduct; de kolommen tonen de uitvoer voor de basisvectoren.

In de volgende les koppel je twee van deze machines en onderzoek je waarom hun volgorde uitmaakt.

Verder lezen & bronnen

Inhoud gecontroleerd op 2026-10-26.
DE VOLGENDE STAPTwee transformaties achter elkaar
JOUW EXPERIMENT

Probeer het zelf

Python
main.py

Python start zodra jij code uitvoert.

UITVOER

Je uitvoer verschijnt hier.
Alles rekent in je eigen browser.

Jouw checkpoints0 / 3
01
Eerst de vorm, dan rekenen

Geef met vorm(A) de tuple (aantal rijen, aantal kolommen) terug. A is niet leeg en rechthoekig.

Een hint

len(A) telt rijen, len(A[0]) kolommen. Zet de twee aantallen met een komma tussen ronde haakjes.

02
Van rij naar kolom

Maak transpose(A): iedere oorspronkelijke kolom wordt een nieuwe rij. Laat A intact.

Een hint

Begin per kolom j een nieuwe lege rij; voeg A[i][j] toe voor iedere rij i. Bewaar de nieuwe rij na de binnenste lus.

03
Iedere rij maakt één uitvoer

Maak matvec(A, x) voor passende vormen en geef de uitvoer als nieuwe lijst terug.

Een hint

Start per rij een totaal op nul. Tel A[i][j] * x[j] voor alle j op en voeg daarna dat totaal toe.

Vastgelopen? Bekijk de voorbeeldoplossing
def vorm(A):
    return (len(A), len(A[0]))


def transpose(A):
    resultaat = []
    for j in range(len(A[0])):
        nieuwe_rij = []
        for i in range(len(A)):
            nieuwe_rij.append(A[i][j])
        resultaat.append(nieuwe_rij)
    return resultaat


def matvec(A, x):
    resultaat = []
    for i in range(len(A)):
        totaal = 0
        for j in range(len(x)):
            totaal = totaal + A[i][j] * x[j]
        resultaat.append(totaal)
    return resultaat

Voer de code uit en verklaar voor jezelf waarom elke stap werkt.