Python library
Built-in functies
- abs() = returnt de absolute waarde van een nummer (input: integer of float, waarde is positief)
* De afstand tussen 0 en het desbetreffende getal
- all() = returnt True wanneer alle elementen tussen haakjes waar zijn, of wanneer de haakjes leeg zijn
(uitspraken over lijst van booleans)
- any() = returnt True wanneer één of meerdere elementen tussen de haakjes waar is, wanneer de
haakjes leeg zijn is de return False
- bool() = True of False
- dict() = maakt een nieuwe dictionary (zonder argument een leeg woordenboek)
* my_dict = dict(a=1, b=2, c=3), print(my_dict) output: {“a”: 1, “b”: 2, “c”: 3}
- dir() = returnt een lijst van valide attributen voor het gegeven object tussen haakjes (mogelijkheden
om te doen met het object)
* my_list = [1, 2, 3], print(dir(my_list)) output: [“capitalize”, “find”, ...]
- enumerate() = returnt een tuple met telling (index), hetgeen wat je tussen haakjes invult is dus een
sequentie
* my_list = [“a”, “b”, “c”], result = list(enumerate(my_list, start=1)), print(result) output:
[(1, “a”), (2, “b”), (3, “c”)]
- float() = maakt een kommagetal van de gegeven iterable (een “string” in dit geval), hierbij kun je +
en - gebruiken (0 wanneer er geen argument wordt gegeven)
- hash() = geeft de hash waarde van het object, wanneer het dit heeft (is een integer). Even grote
getallen (1.0 en 1 bv) hebben dezelfde hashwaarde (hashwaarde is een bepaald getal)
- help() = laat zien waarvoor de functies dienen (wat je met de variabele kunt doen)
* Geeft ingebouwde functies, modules en klassen van het ingegeven object
* Help(str.upper) -> geeft aan wat dit doet/waarvoor je het kunt gebruiken
- id() = geeft de identiteit van een object, is een unieke “code” (integer, identificaitenummer)
- input() = iemand anders moet tijdens het uitvoeren van de code hier iets invullen
- int() = maakt een heel/afgerond getal van de gegeven iterable (een string in dit geval), wanneer er
geen argument wordt gegeven geeft het 0 terug
- len() = returnt de lengte (aantal items) van een object. Het argument kan een sequentie (string,
bytes, tuple, list, range) of een collectie (dictionary, set) zijn
- list() = maakt een lijst, een mutable sequentie (kan ook leeg zijn wanneer er geen
argumenten/iterable gegeven wordt)
* my_list = list(range(5)), print(my_list) output: [0, 1, 2, 3, 4]
- max() = geeft de hoogste waarde van twee of meer argumenten (in een iterable)
- min() = geeft de laagste waarde van een of meer argumenten (in een iterable)
- next() = geeft het volgende item van de iterator
- open() = opent het document
* file = open(“example.txt”, “r”), content = file.read(), print(content)
- print() = print de inhoud van het gegeven argument
,- pow( , ) = eerste getal tot de macht tweede getal
- range() = immutable sequentie, verschillende vormen: range(stop), range(start, stop), range(start,
stop, stepsize), de output eindigt vóór de aangegeven stop en neemt dat getal/woord niet meer mee
* my_range = list(range(1, 5)), print(my_range) output: [1, 2, 3, 4]
- reversed() = draai het argument (sequentie) om
- round() = wanneer je geen ndigits aangeeft (of None) dan returnt het een integer die het dichtste
ligt bij de input, wanneer je wel een nummer aangeeft wordt het achter het decimale punt zo precies
mogelijk afgerond (round(number, ndigits=1)
* result = round(3.14159, 2), print(result) output: 3.14
- set() = returnt een set {}, kan ook leeg zijn
- slice() = knip in een object, net als bij range: slice(start, stop, stepsize)
1) my_string[i] -> je krijgt het karakter van index i
2) my_string[start:end] -> de substring die starten bij start en eindigen voor eind
3) my_string[start:end:stepsize] -> alle karakters die starten bij start en eindigen voor eind
4) my_string[:i] -> de substring die beginnen bij index 0 en eindigen net voor i
5) my_string[i:] -> de substring die start bij i en tot het eind loopt
6) my_string[::i] -> de substring die van het begin tot het einde loopt met stapgrootte i
7) my_string[:] = maak een kopie van my_string
8) my_string[::-1] = kopieer my_string, maar dan achterstevoren (string keren)
- sorted() = sorteert de gegeven argumenten op alfabetische volgorde of van klein naar groot
- str() = maakt van een object een “string”
- sum() = telt het begin en de items van de iterable op van links naar rechts en returnt het totaal
(nummers)
- tuple() = immutable sequentie type (verandert iterables in tuples)
* my_tuple = tuple([1, 2, 3]), print(my_tuple) output: (1, 2, 3)
- type() = het type object dat het gegeven argument/variabele is
* result = type(“Hello”), print(result) output: <class “str”>
- zip() = maakt een tuple van de iterable, met de variabele en het bijpassende nummer bij elkaar
* names = [“Alice”, “Bob”, “Charlie”], ages = [25, 30, 35], result = list(zip(names, ages)),
print(result) output: [(“Alice”, 25), (“Bob”, 30), (“Charlie”, 35)]
-> None = afwezigheid van een waarde
Boolean operatoren
- x OR y = if x is true, then x, else y (kijkt alleen naar het tweede argument als de eerste false is, want
één van de twee moet true zijn om true als uitkomst te hebben)
- x AND y = if x is false, then x, else y (kijkt alleen naar het tweede argument als de eerste true is, want
beide argumenten moeten true zijn om true als uitkomst te hebben, anders false)
- NOT x = if x is false, then True, else False
Vergelijkingen
- x < y = x is kleiner dan y
- x <= y = x is kleiner dan of gelijk aan y
- x > y = x is groter dan y
- x >= x = x is groter of gelijk aan y
- x == y = x en y zijn gelijk
- x != y = x en y zijn NIET gelijk
Bool() verandert elke waarde naar een boolean -> True/False
- Boolean operators: and (&), or (|) en not (!=) -> woorden over tekens verkozen
,Numerieke types (int, float)
Operatoren
- x + y = som van x en y
- x – y = verschil tussen x en y
- x * y = x keer y
- x / y = x gedeeld door y
- x // y = afgeronde quotiënt van x en y (afgerond naar dichtstbijzijnde hele getal)
* 10 // 3 = 3
- x % y = overblijfsel van x/y
* 10 % 3 = 1 (want 10/3 = 9, nog 1 getal is dan over tot de 10)
- -x = x negatief
- +x = x onveranderd
- abs(x) = absolute waarde van x (positief getal, afstand tot 0)
- int(x) = x verandert naar integer
- float(x) = x verandert naar float
- pow(x, y) = x tot de macht y
- x ** y = x tot de macht y
- x | y = x óf y
* 1010 | 0011 = 1011 (geeft een 1 wanneer er op die plek minimaal één 1 staat)
- x ^ y = vergelijking van de bits van x en y en produceert een nieuw getal?
- x & y = x én y
* 1010 & 0011 = 0010 (geeft een 1 wanneer er op die plek twee 1’en staan)
- x << n = x verschoven naar links met n bits
- x >> n = x verschoven naar rechts met n bits
Sequentie types (lists, tuples, range)
- x in s = True wanneer een item van s gelijk is aan x, anders False
- x not in s = False wanneer een item van s gelijk is aan x, anders True
- s + t = samenvoeging/aaneenschakeling van s en t
- s * n or n * s = het n keer optellen van s (dus n herhalingen van s)
- s[i] = het zoveelste item van s (index, begint bij 0)
- s[i:j] = slice van s, van i tot j
- s[I:j:k] = slice van s, van i tot j, met stapgrootte k
- len(s) = lengte van s (aantal karakters, inclusief spaties)
- min(s) = kleinste item van s
- max(s) = grootste item van s
- s.index(x[, i[, j]]) = index van de eerste verschijning van x in s (op of na index i en vóór index j)
- s.count(x) = het aantal keer dat x in s voorkomt
-> Wanneer i of j negatief is, is de index relatief aan het einde van de sequentie s: len(s) + i of len(s) + j
is vervangen. (-0 is nog steeds 0)
, Immutable sequentie types
- De enige bewerking die door onveranderlijke reekstypen doorgaans wordt geïmplementeerd en die
niet ook door veranderbare reekstypen wordt geïmplementeerd, is ondersteuning voor de
ingebouwde hash().
- Dankzij deze ondersteuning kunnen onveranderlijke reeksen, zoals tuple-instanties, worden gebruikt
als dicteersleutels en worden opgeslagen in set- en frozenset-instanties.
Mutable sequentie types
- s[i] = x = item i van s is vervangen door x
- s[i:j] = t = slice van s van i tot j is vervangen de content van iterable t
- del s[i:j] = slice van s i tot j is verwijderd (hetzelfde als s[i:j] = [])
- s[i:j:k] = t = de elementen van s[i:j:k] worden vervangen door deze van t
- s.append(x) = voegt x toe aan het einde van de sequentie (hetzelfde als s[len(s):len(s)] = [x])
- s.clear() = verwijdert alle items van s (hetzelfde als del s[:])
- s.copy() = maakt een kopie van s (hetzelfde als s[:])
- s.extend(t) or s += t = breidt s uit met de content van t
- s *= n = update s met de content, maar dan n keer herhaald
- s.insert(i, x) = voegt x toe bij index i (zelfde als s[i:i] = [x])
- s.pop() or s.pop(i) = haalt item i op en verwijdert het uit s
- s.remove(x) = verwijdert het eerste item uit s waar s[i] gelijk is aan x
- s.reverse() = draait de items van s om (op volgorde)
Lists []
- Mutable sequenties, geordende lijst van elementen
Een lijst maken
- Gebruik een paar vierkante haken om de lege lijst aan te duiden: []
- Gebruik vierkante haken en scheid items met komma's: [a], [a, b, c]
