samenvatting Softwareontwerp en Programmeren 1 (SOEP1) (2024) 17/20 1e zit

DEEL 1: BASISSYNTAX
1. BASIS DATA TYPES
Integers:
- Gehele getallen
- Type int
Floats:
- Kommagetallen
- Kunnen in wetenschappelijke notatie
- Type float
Functies voor cijfers:
- round(getal,decimalen) = afronden van getal op aantal decimalen na de komma
- max(getal1, getal2) = het grootste van grootste van getal1 of getal2 weergeven
 min(getal1, getal2) = het kleinste van getal1 of getal2 weergeven
- pow(getal, macht) = machtsverheffing van getal tot macht
Booleans:
- Waar/vals waarden (True/False zijn gereserveerde keywords)
- Type bool
Strings:
- Type str
- Sequentie van tekens/characters
- Sterke overeenkomsten met lijsten (zie later) – beiden zijn itereerbare types
o Makkelijk vanwege het gebruik van indices
- Kunnen aangemaakt worden met zowel enkele als dubbele aanhalingstekens (‘ en “ maar niet door elkaar):
o ‘Escape characters’ zoals ‘\’ nodig om haakjes binnen een aanhalingsteken te gebruiken:



- Concatenatie van strings: operatoren als +, -, /, *, **, //, … → strings kunnen aan elkaar geplakt worden
- \n = enter \t = tab
Conversie tussen types: int(), bool(), str()
type() geeft het type van de variabele

2. VARIABELEN
‘=’ = een veriabele een waarde toewijzen
Variabele wijzigen: stel a = b
- Lijsten: a wijzigen → zowel a als b zijn gewijzigd (want nieuw object aangemaakt)
- Strings/integers: a wijzigen → b blijft behouden (geen nieuw object, a en b blijven naar hetzelfde object
verwijzen)
 Moeten deep copy maken van string:
o String/int/float/boolean verwijzen naar object met 1 waarde
▪ Kopiëren van waarde is vanzelfsprekend bij een wijziging van de waarde
o Samengestelde types (lijst/set/eigen gemaakt object): bevatten (mogelijks) meerdere waarden:
▪ Geen eenduidig overzicht welke waarden moeten worden behouden/aangepast
 !! dynamische typering is gevaarlijk:
o a is string geworden, b nog steeds integer → kan niet langer optellen
o zowel a als b string geworden → kan wel nog optellen




1

, 3. COMPOSIETE TYPES
- Verzamelingen = sets
- Lijsten = lists / tuples
- Woordenboeken = dictionaries
- Zelfgemaakte klasses (later)
Verzamelingen
= ongeordende collecties (maar wel itereerbaar)
- Alle elementen zijn uniek
- Niet noodzakelijk alle elementen van hetzelfde type
- Niet-veranderbaar
- Makkelijk om vergelijkingen te maken via deelverzamelingen
set() = lege verzameling aanmaken OF nieuwe_set = {x,y,z} → maar dan mag hij niet leeg zijn
.add() = elementen toevoegen
∈ operator = 5 in nieuwe_set → output: True of False
Methodes  operatoren:
- Objecten hebben gereserveerde functies die op hen kunnen toegepast worden = methodes
- In plaats van methodes (van het object) te gebruiken, kunnen ook operatoren gebruikt worden (over het
object/de objecten):
o print(set_1 | set_2 | set_3) → output: {set1, set2, set3} { set1, set2, set3}
= print(set_1.union(set_2).union(set_3))
o print(set_1 & set_2) → output: {wat set1 en set2 in common hebben}
= print(set_1.intersection(set_2))
o print(set_1 - set_2) → output: {waarin set1 van set2 verschilt}
= print(set_1.difference(set_2)) ! set_1 – set_2 != set_2 – set_1
Elementen verwijderen en toevoegen:
- .add(): toevoegen van 1 of meerdere elementen
- .remove(): verwijdert een element maar geeft een foutenboodschap als het element niet aanwezig is
- .discard(): probeert een element te verwijderen, of het aanwezig is of niet
- .pop(): verwijdert een willekeurig element (foutenboodschap bij lege set)
- .clear(): maakt de set leeg

Lijsten
= collective van eender welk type objecten opgeslagen in de volgorde waarin ze worden meegegeven
- Volledig geïndexeerd
- Makkelijk te navigeren
Elementen verwijderen en toevoegen: ! ook bruikbaar voor strings (= ook itereerbaar)
- lijst[i] = het (i+1)e element van de lijst → i = index van dat element in de lijst
- lijst[-1] = het laatste element van de lijst
- lijst[i:j] = elementen met index i tot j (zonder j)
- lijst[i:j:k] = elementen met index i tot j (zonder j) met een sprong van k
- lijst[i:] = vanaf het ide element, lijst[:i] = tot het ide element
- lijst[-i: ] = vanaf het ide laatste element
- lijst[: : -1] = tot het laatste element
- lijst = lijst+[i] → werkt zoals .extend() maar korter , moet aan een reeds bestaande lijst koppelen: niet lijst +=[i]!
- del lijst[i:j] = een stuk van index i tot j uit de lijst verwijderen
- lijst.remove(element) = element i uit de lijst verwijderen, maar geeft foutboodschap als “element” niet in de lijst
aanwezig is
- lijst.append(element) = element toevoegen achteraan de lijst = lijst.extend(element)
- lijst.pop(element) = laatste element verwijderen uit de lijst
- lijst.insert(index, element) = element toevoegen op plek index
Nesten van lijsten:
- Eender welk soort object kan in een lijst gestopt worden: (dus ook andere lijsten)
- Zo kunnen bv. matrices worden gebouwd:
- matrix[i][j] = element uit rij i+1 en kolom j+1 in de matrix

2

, list(lijst1) = kopie van een lijst maar wanneer je iets in lijst1 verandert zal het ook in deze veranderen en omgekeerd
(tenzij je iets toevoegt, dan voegt het enkel in die lijst toe)
 .deepcopy(lijst1) = kopie van lijst1, volledig onafhankelijk van lijst 1
Tuples
= niet-mutabele lijsten
- kunnen wel in sets gebruikt worden
- gebruiken dezelfde indexering als lijsten
- ronde haakjes
- bv tuple.append(element) → error! Want niet-mutabel
Dictionaries
wb = {“sleutel0”:”waarde0”, “sleutel1“: “waarde1”, …}
- sleutels zijn uniek
- waardes kunnen meerdere malen voorkomen
- sleutels moeten niet van hetzelfde type zijn, maar wel immutable (zie sets)
- woordenboek opvullen: wb[sleutel] = waarde → kan ook oude waardes overschrijven
- info opvragen:
o wb.items() : geeft de data als paren terug
→ output: wb_items([(“sleutel0”, “waarde0”),(“sleutel1”, “waarde1”)])
o wb.keys() : geeft de sleutels terug → output: wb_keys([“sleutel0”, “sleutel1”])
o wb.values() : geeft de waardes terug → output: wb_values([“waarde0”, “waarde1”])
o type(wb.keys()) : geeft het type van de sleutels
o list(wb.keys()) : geeft de sleutels weer in een lijst → output: [“sleutel0”, “sleutel1”]
o list(wb.values()[0]) : geeft de eerste waarde van het woordenboek i/e lijst → output: [waarde0]
- zelf itereren:
o we krijgen telkens een paar terug dat we in 2 variabelen stoppen : key EN value
o code:
for key, value in wb.items():
print(“Sleutel:”, key, “\t waarde:”, value)
output:
Sleutel: sleutel0 waarde: waarde0
Sleutel: sleutel1 waarde: waarde1
- verwijderen & samenvoegen
o wb1.update(wb2) = wb2 elementen toevoegen aan wb1
o del wb[sleutel] = sleutel en bijhorende waarde verwijderen uit wb
o waarde = wb.pop(sleutel) : verwijdert de sleutel en waarde en geeft de waarde als resultaat
Sorteren van itereerbare objecten
- sets, lijsten, woordenboeken, …
- enkel mogelijk indien elementen vergelijkbaar zijn , bv:
o getallen (=,<,>,>=, …)
o strings (alfabetisch)
- 2 methoden:
o sorted(lijst) = ingebouwde Python functie (zoals len() of type()) die gesorteerd object teruggeeft
→ nieuw object
o lijst.sort() = ingebouwde methode van itereerbare objecten - eens opgeroepen is het object voor altijd
gesorteerd → hetzelfde object

4. OPERATOREN & BEWERKINGEN
Basisbewerkingen met operatoren:
- Interpretatie anders per type van variabele/waarde waarop het is toegepast: bv a+b
o Strings: concatenatie (= aaneenplakken van de strings)
o Getallen: som
- Moeten altijd met dezelfde types gebruikt worden (bv niet string+integer)
- Volgorde is van belang
3