Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

[1]

Basis data types

Getallen

x = 3
print(x, type(x))
3 <class 'int'>
print(x + 1)  # Addition
print(x - 1)  # Subtraction
print(x * 2)  # Multiplication
print(x**2)  # Exponentiation
4
2
6
9
x += 1
print(x)
x *= 2
print(x)
4
8
y = 2.5
print(type(y))
print(y, y + 1, y * 2, y**2)
<class 'float'>
2.5 3.5 5.0 6.25

Booleans

t, f = True, False
print(type(t))
<class 'bool'>
print(t and f)  # Logical AND;
print(t or f)  # Logical OR;
print(not t)  # Logical NOT;
print(t != f)  # Logical XOR;
False
True
False
True

Strings

hello = "hello"  # String literals can use single quotes
world = "world"  # or double quotes; it does not matter
print(hello, len(hello))
hello 5
hw = hello + " " + world  # String concatenation
print(hw)
hello world
hw12 = f"{hello} {world} {12}"  # string formatting
print(hw12)
hello world 12
s = "hello"
print(s.capitalize())  # Capitalize a string
print(s.upper())  # Convert a string to uppercase; prints "HELLO"
print(s.rjust(7))  # Right-justify a string, padding with spaces
print(s.center(7))  # Center a string, padding with spaces
print(s.replace("l", "(ell)"))  # Replace all instances of one substring with another
print("  world ".strip())  # Strip leading and trailing whitespace
Hello
HELLO
  hello
 hello 
he(ell)(ell)o
world

Containers

Lists

xs = [3, 1, 2]  # Create a list
print(xs, xs[2])
print(xs[-1])  # Negative indices count from the end of the list; prints "2"
[3, 1, 2] 2
2
xs[2] = "foo"  # Lists can contain elements of different types
print(xs)
[3, 1, 'foo']
xs.append("bar")  # Add a new element to the end of the list
print(xs)
[3, 1, 'foo', 'bar']
x = xs.pop()  # Remove and return the last element of the list
print(x, xs)
bar [3, 1, 'foo']

Slicing

nums = list(range(5))  # range is a built-in function that creates a list of integers
print(nums)  # Prints "[0, 1, 2, 3, 4]"
print(nums[2:4])  # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print(nums[2:])  # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print(nums[:2])  # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print(nums[:])  # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print(nums[:-1])  # Slice indices can be negative; prints ["0, 1, 2, 3]"
nums[2:4] = [8, 9]  # Assign a new sublist to a slice
print(nums)  # Prints "[0, 1, 8, 9, 4]"
[0, 1, 2, 3, 4]
[2, 3]
[2, 3, 4]
[0, 1]
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 8, 9, 4]

Looping

animals = ["cat", "dog", "monkey"]
for animal in animals:
    print(animal)
cat
dog
monkey
animals = ["cat", "dog", "monkey"]
for idx, animal in enumerate(animals):
    print(f"#{idx + 1}: {animal}")
#1: cat
#2: dog
#3: monkey

List comprehensions

Eenvoudige loops kunnen in elegante one-liners uitgedrukt worden, inclusief condities.

nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
    squares.append(x**2)
print(squares)
[0, 1, 4, 9, 16]
nums = [0, 1, 2, 3, 4]
squares = [x**2 for x in nums]
print(squares)
[0, 1, 4, 9, 16]
nums = [0, 1, 2, 3, 4]
even_squares = [x**2 for x in nums if x % 2 == 0]
print(even_squares)
[0, 4, 16]

Dictionaries

Dit zijn containers (key, value) paren zoals Map in Java.

d = {"cat": "cute", "dog": "furry"}  # Create a new dictionary with some data
print(d["cat"])  # Get an entry from a dictionary; prints "cute"
print("cat" in d)  # Check if a dictionary has a given key; prints "True"
cute
True
d["fish"] = "wet"  # Set an entry in a dictionary
print(d["fish"])  # Prints "wet"
wet
print(d["monkey"])  # KeyError: 'monkey' not a key of d
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[69], line 1
----> 1 print(d["monkey"])  # KeyError: 'monkey' not a key of d

KeyError: 'monkey'
print(d.get("monkey", "N/A"))  # Get an element with a default; prints "N/A"
print(d.get("fish", "N/A"))  # Get an element with a default; prints "wet"
N/A
wet
del d["fish"]  # Remove an element from a dictionary
print(d.get("fish", "N/A"))  # "fish" is no longer a key; prints "N/A"
N/A
d = {"person": 2, "cat": 4, "spider": 8}
for animal, legs in d.items():
    print(f"A {animal} has {legs} legs")
A person has 2 legs
A cat has 4 legs
A spider has 8 legs

Dictionary comprehensions

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x**2 for x in nums if x % 2 == 0}
print(even_num_to_square)
{0: 0, 2: 4, 4: 16}

Sets

Een set is een ongeordende verzameling van unieke elementen.

animals = {"cat", "dog"}
print("cat" in animals)  # Check if an element is in a set; prints "True"
print("fish" in animals)  # prints "False"
True
False
animals.add("fish")  # Add an element to a set
print("fish" in animals)
print(len(animals))  # Number of elements in a set;
True
3
animals.add("cat")  # Adding an element that is already in the set does nothing
print(len(animals))
animals.remove("cat")  # Remove an element from a set
print(len(animals))
3
2

Looping

Dit is identiek aan looping bij lijsten, maar de volgorde ligt niet vast.

animals = {"cat", "dog", "fish"}
for idx, animal in enumerate(animals):
    print(f"#{idx + 1}: {animal}")
#1: fish
#2: dog
#3: cat

Set comprehensions

from math import sqrt

print({int(sqrt(x)) for x in range(30)})
{0, 1, 2, 3, 4, 5}

Tuples

Een tuple is een (immutable) geordende lijst van waarden. In vele opzichten zijn ze gelijkaardig aan lijsten. Een van de meest belangrijke verschillen is dat tuples, in tegenstelling tot lijsten, als dictionary keys en elementen van sets gebruikt kunnen worden.

d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys
t = (5, 6)  # Create a tuple
print(type(t))
print(d[t])
print(d[(1, 2)])
<class 'tuple'>
5
1
t[0] = 1
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[80], line 1
----> 1 t[0] = 1

TypeError: 'tuple' object does not support item assignment

Functies

def sign(x):
    if x > 0:
        return "positive"
    elif x < 0:
        return "negative"
    else:
        return "zero"


for x in [-1, 0, 1]:
    print(sign(x))
negative
zero
positive

Default argumenten

def hello(name, loud=False):
    if loud:
        print(f"HELLO, {name.upper()}")
    else:
        print(f"Hello, {name}!")


hello("Bob")
hello("Fred", loud=True)
Hello, Bob!
HELLO, FRED

Classes

class Greeter:
    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # Instance method
    def greet(self, loud=False):
        if loud:
            print(f"HELLO, {self.name.upper()}")
        else:
            print(f"Hello, {self.name}!")


g = Greeter("Fred")  # Construct an instance of the Greeter class
g.greet()  # Call an instance method; prints "Hello, Fred"
g.greet(loud=True)  # Call an instance method; prints "HELLO, FRED!"
Hello, Fred!
HELLO, FRED
Footnotes