Python f-string: een complete gids

Python f-strings zijn een krachtige en intuïtieve manier om strings te formatteren. f-strings hebben de manier veranderd waarop developers stringformattering in Python aanpakken, waardoor code leesbaarder en beter te onderhouden is dan ooit.

Afbeelding door auteur

F-strings zijn stringliteral­en met het voorvoegsel 'f' of 'F' die expressies bevatten tussen accolades {}. Deze expressies worden tijdens runtime geëvalueerd en vervolgens geformatteerd via het __format__-protocol. In tegenstelling tot traditionele methoden bieden f-strings een eenvoudiger en leesbaarder manier om Python-expressies direct in stringliteral­en op te nemen.

Denk aan dit veelvoorkomende scenario waarin je een eenvoudige begroeting moet formatteren:

name = "Alice"
age = 25
# Using % operator (old style)
print("My name is %s and I'm %d years old" % (name, age))
# Using str.format()
print("My name is {} and I'm {} years old".format(name, age))
# Using f-string
print(f"My name is {name} and I'm {age} years old")

Zie je hoe f-strings de mentale last van het koppelen van variabelen aan placeholders wegnemen? Die helderheid wordt nog waardevoller bij complexe dataformattering in echte applicaties, zoals hieronder:

price = 49.99
quantity = 3
print(f"Total cost: ${price * quantity:.2f}")  # Calculations right in the string!

Naast leesbaarheid blinken f-strings uit in performance. Ze zijn sneller dan zowel %-formatting als str.format() omdat ze tijdens runtime worden geëvalueerd in plaats van meerdere stringoperaties te vereisen. Python optimaliseert f-string-evaluatie, waardoor ze een efficiënte keuze zijn voor stringformattering.

Sinds Python 3.8 zijn f-strings nog handiger voor debuggen dankzij de '='-specifier. Deze handige feature toont zowel variabelnamen als hun waarden op één regel:

x = 10
y = 20
print(f"{x=}, {y=}")  # Output: x=10, y=20

In dit artikel bekijken we f-strings, van de basis­synthax tot geavanceerde formatteringstechnieken. We zien hoe je expressies evalueert, getallen en datums formatteert, met multiregelstrings werkt en best practices toepast in je code.

Basis­synthax van Python f-strings

F-strings bieden een moderne en intuïtieve manier om strings in Python te formatteren met een eenvoudig voorvoegsel en expressiesyntaxis. Laten we beginnen met de basis van het maken van f-strings.

Een f-string maken

Om een f-string te maken, zet je simpelweg de letter 'f' of 'F' voor je stringliteral. Zowel kleine als hoofdletter werken identiek. Het is puur een stijlkeuze. Zo maak je basis-f-strings:

# Both 'f' and 'F' prefixes work exactly the same way message1 = f”This is an f-string”message2 = F”This is also an f-string”
# Without the prefix, it's just a regular string regular_string =  “This is a normal string”

De echte kracht van f-strings zit in het embedden van expressies tussen accolades {}. Deze expressies worden tijdens runtime geëvalueerd en hun waarden in de string ingevoegd. Zo werkt dat in de praktijk:

# You can put the expression directly inside the braces 
print(f"The result is {10 + 5}")

Uitvoer

The result is 15

Variabelen invoegen

Nu we weten hoe je f-strings maakt, kijken we hoe je effectief variabelen invoegt. f-strings laten je variabelen direct en leesbaar in je strings opnemen. Bij verschillende datatypen gaat dat soepel. 

Eerst kijken we hoe f-strings eenvoudige stringvariabelen verwerken:

# Working with string variables
first_name = "John"
last_name = "Doe"
print(f"Full name: {first_name} {last_name}")

Uitvoer

Full name: John Doe

Bij verschillende datatypen gaan f-strings er elegant mee om. Zo werken f-strings met diverse Python-datatypen:

# Working with numeric types
integer_value = 42
float_value = 23.5
print(f"Integer: {integer_value}")
print(f"Float: {float_value}")

Uitvoer

Integer: 42 

Float: 23.5 

F-strings werken naadloos met lijsten; je kunt individuele elementen of de hele lijst gebruiken:

# Working with lists
fruits = ["apple", "banana", "orange"]
print(f"First fruit: {fruits[0]")
print(f"All fruits: {', '.join(fruits)}")

Uitvoer

First fruit: apple

All fruits: apple, banana, orange

Bij dictionaries kun je waarden eenvoudig benaderen en formatteren, zoals hieronder:

# Working with dictionaries
user_info = {
    "name": "Alice",
    "age": 28,
    "city": "New York"
}
print(f"User: {user_info['name']} from {user_info['city']}")

Uitvoer

User: Alice from New York

Booleans zijn eenvoudig op te nemen in f-strings, zoals hieronder:

# Working with boolean values
is_active = True
is_admin = False
print(f"Active status: {is_active}")
print(f"Admin privileges: {is_admin}")

Uitvoer

Active status: True

Admin privileges: False

Door te begrijpen hoe f-strings met verschillende datatypen werken, schrijf je leesbaardere en beter onderhoudbare code. In de volgende sectie bekijken we geavanceerdere toepassingen van f-strings.

Geavanceerd gebruik van f-strings

Expressies evalueren

f-strings zijn ideaal om expressies en berekeningen direct in je strings af te handelen. In plaats van vooraf te rekenen, kun je bewerkingen in de accolades uitvoeren.

Eerst bekijken we basis­rekenkundige operaties. Let op hoe we berekeningen rechtstreeks in de stringformattering kunnen doen:

# Basic arithmetic operations
x = 10
y = 5
print(f"Addition: {x + y}")
print(f"Multiplication: {x * y}")
print(f"Division with 2 decimal places: {x / y:.2f}")

Uitvoer

Addition: 15

Multiplication: 50

Division with 2 decimal places: 2.00

Je kunt ook ingebouwde Python-functies gebruiken binnen f-strings, wat ze ongelooflijk veelzijdig maakt voor datamanipulatie. Zo benut je deze functies direct in je strings:

numbers = [1, 2, 3, 4, 5]
text = "python"
print(f"List length: {len(numbers)}")
print(f"Maximum value: {max(numbers)}")
print(f"Uppercase text: {text.upper()}")

Uitvoer

List length: 5

Maximum value: 5

Uppercase text: PYTHON

Voorwaardelijke expressies

Een van de krachtigste features van f-strings is dat je voorwaardelijke logica kunt opnemen. Je kunt de ternary operator gebruiken om je stringformattering afhankelijk te maken van condities. Laten we beginnen met eenvoudige voorbeelden met de ternary operator:

# Simple conditional formatting
score = 85
print(f"Result: {'Pass' if score >= 70 else 'Fail'}")
# Multiple conditions in data analysis
value = 42
print(f"Status: {'High' if value > 75 else 'Medium' if value > 25 else 'Low'}")

Uitvoer

Result: Pass

Status: Medium

In echte data-analyses combineer je vaak condities met berekeningen. Zo maak je meer geavanceerde formatteringsscenario's.

stock_level = 15
reorder_point = 20
price = 49.99
print(f"Stock Alert: {'Order more' if stock_level < reorder_point else 'Stock OK'}")
print(f"Total Value: ${stock_level * price:.2f}")

Uitvoer

Stock Alert: Order more

Total Value: $749.85

Bij langere expressies kun je de leesbaarheid verbeteren door ze op te splitsen. Zo maak je je code beter onderhoudbaar:

# Complex expression broken down for clarity
value = 75
threshold = 50
multiplier = 1.5
result = value > threshold
adjusted_value = value * multiplier if result else value
print(f"Adjusted Value: {adjusted_value}")
print(f"Status: {'Exceeds threshold' if result else 'Within limits'}")

Uitvoer

Adjusted Value: 112.5

Status: Exceeds threshold

F-strings helpen ook bij debuggen met de '='-specifier (ingevoerd in Python 3.8) om zowel variabelnamen als hun waarden te tonen, zoals hieronder:

# Debugging with f-strings
x = 100
y = 200
print(f"{x=}, {y=}")
print(f"{x + y=}")

Uitvoer

x=100, y=200

x + y=300

F-strings maken complexe stringformattering intuïtiever en leesbaarder. In de volgende sectie finetunen we de weergave met precieze getalformattering en tekstuitlijning, onmisbare skills voor professionele data-uitvoer.

Formatteren met f-strings

f-strings bieden krachtige mogelijkheden om onze data-uitvoer te polijsten, zodat die leesbaar en professioneel oogt. Met eenvoudige specifiers kun je alles sturen, van het aantal decimalen tot de uitlijning van tekst, zodat je data effectief zijn verhaal vertelt.

Laten we zien hoe we verschillende aspecten van formattering met f-strings kunnen regelen.

Getalformattering

Bij numerieke data zorgt precieze formattering voor professionelere en beter leesbare uitvoer.

Om decimalen te formatteren gebruiken f-strings een dubbelepunt gevolgd door een punt en het gewenste aantal decimalen. Een voorbeeld:

# Controlling decimal places
pi = 3.14159
price = 19.99999
percentage = 0.8525
print(f"Pi to 2 decimal places: {pi:.2f}")
print(f"Price rounded to 2 decimals: {price:.2f}")
print(f"Percentage with 1 decimal: {percentage:.1%}")

Uitvoer

Pi to 2 decimal places: 3.14

Price rounded to 2 decimals: 20.00

Percentage with 1 decimal: 85.2%

Bij grote getallen wil je vaak duizendtallen scheiden voor de leesbaarheid. Zo helpt f-strings met die opmaak:

# Formatting large numbers
population = 1234567
revenue = 1234567.89
# Using comma as thousand separator
print(f"Population: {population:,}")
print(f"Revenue: ${revenue:,.2f}")
# Using underscore as thousand separator
print(f"Population: {population:_}")
print(f"Revenue: ${revenue:_.2f}")

Uitvoer

Population: 1,234,567

Revenue: $1,234,567.89

Population: 1_234_567

Revenue: $1_234_567.89

Uitlijning en opvullen van tekst

Voor een heldere presentatie is correcte uitlijning vaak nodig. Zo bereik je perfecte uitlijning met f-strings.

Je kunt tekst links, rechts of gecentreerd uitlijnen met respectievelijk '<', '>' en '^':

# Basic text alignment
name = "Python"
width = 20
print(f"Left aligned:   |{name:<20}|")
print(f"Right aligned:  |{name:>20}|")
print(f"Center aligned: |{name:^20}|")

Uitvoer

Left aligned:   |Python              |
Right aligned:  |              Python|
Center aligned: |       Python       |

Voor tabeldata kun je uitlijning combineren met aangepaste opvultekens voor een professionele uitstraling. Zo maak je nette tabellen:

# Creating a simple data table
languages = ["Python", "R", "SQL"]
scores = [85, 92, 78]
print("Programming Language Scores")
print("-" * 30)
for lang, score in zip(languages, scores):
    print(f"{lang:<10} | {score:>5}")

Uitvoer

Programming Language Scores
------------------------------
Python     |    85
R          |    92
SQL        |    78

Soms moet je nummers met nullen opvullen, bijvoorbeeld bij codes of ID's. Enkele technieken:

# Padding numbers with zeros
customer_id = 42
invoice_number = 157
print(f"Customer ID: {customer_id:04d}")
print(f"Invoice: INV-{invoice_number:05d}")

Uitvoer

Customer ID: 0042

Invoice: INV-00157

Deze technieken zijn belangrijk voor data-professionals die hun resultaten netjes willen presenteren. In de volgende sectie bekijken we multiregel-f-strings, vooral handig voor grotere tekstblokken of rapporttemplates.

Multiregel f-strings

Bij grotere tekstblokken of complexe opmaak kunnen enkelregelige f-strings onhandig worden. De multiregel f-strings van Python lossen dit elegant op, zodat je overzichtelijke, leesbare tekst over meerdere regels kunt maken. Zo gebruik je deze krachtige feature effectief.

Multiregelstrings maken

Multiregel f-strings gebruiken drie aanhalingstekens (""" of ''') om meerdere regels te beslaan en toch de code leesbaar te houden. Zie het als een canvas waarop je tekst precies zo verschijnt als je wilt. Zo werkt het:

# Basic multiline f-string
name = "Alice"
role = "Data Scientist"
experience = 5
profile = f"""
Team Member Profile:
------------------
Name: {name}
Role: {role}
Experience: {experience} years
"""
print(profile)

Uitvoer

Team Member Profile:
------------------
Name: Alice
Role: Data Scientist
Experience: 5 years

Inzetranden (inspringing) in multiregel f-strings zijn belangrijk voor nette opmaak. De inspringing binnen de drie aanhalingstekens wordt onderdeel van de string zelf, zoals hieronder:

# Working with indentation
data = {
    'title': 'Monthly Report',
    'month': 'October',
    'value': 1234.56
}
report = f"""
    {data['title']}
    Month: {data['month']}
    Value: ${data['value']:,.2f}
        - Generated automatically
        - All values in USD
"""
print(report)

Uitvoer

    Monthly Report
    Month: October
    Value: $1,234.56
        - Generated automatically
        - All values in USD

Meerdere f-strings combineren

Soms willen we complexe strings stap voor stap opbouwen. Python laat ons meerdere f-strings combineren op verschillende manieren om precies de gewenste opmaak te bereiken, zoals hieronder:

# Building a report with multiple f-strings
title = "Sales Analysis"
period = "Q3 2024"
sales = 150000
growth = 27.5
header = f"""
{title}
{'=' * len(title)}
Period: {period}
"""
metrics = f"""
Performance Metrics:
- Total Sales: ${sales:,}
- Growth Rate: {growth}%
"""
notes = f"""
Additional Notes:
- All figures are preliminary
- Data updated as of {period}
"""
# Combining all sections
full_report = f"{header}\n{metrics}\n{notes}"
print(full_report)

Uitvoer

Sales Analysis
=============
Period: Q3 2024
Performance Metrics:
- Total Sales: $150,000
- Growth Rate: 27.5%
Additional Notes:
- All figures are preliminary
- Data updated as of Q3 2024

Bij data-analyserapporten moet je vaak meerdere datapunten gestructureerd formatteren. Multiregel f-strings zijn hier erg goed in en leveren heldere, georganiseerde output op, zoals hieronder:

# Creating a data analysis summary
metrics = {
    'mean': 75.32,
    'median': 72.50,
    'std_dev': 12.45,
    'sample_size': 1000
}
summary = f"""
Statistical Summary
------------------
Sample Size: {metrics['sample_size']:,}
Central Tendency:
    Mean:   {metrics['mean']:.2f}
    Median: {metrics['median']:.2f}
Variation:
    Std Dev: {metrics['std_dev']:.2f}
"""
print(summary)

Uitvoer

Statistical Summary
------------------
Sample Size: 1,000
Central Tendency:
    Mean:   75.32
    Median: 72.50
Variation:
    Std Dev: 12.45

Multiregel f-strings maken het eenvoudig om leesbare, netjes geformatteerde tekstuitvoer te maken voor je data-analyses. In de volgende sectie bespreken we veelvoorkomende valkuilen en best practices, zodat je stringformattering efficiënt en onderhoudbaar blijft.

Veelvoorkomende valkuilen en best practices

Zelfs ervaren Python-developers kunnen bij f-strings op onverwachte problemen stuiten. Door deze valkuilen te kennen en best practices te volgen, schrijf je betrouwbaardere en beter onderhoudbare code. Dit zijn belangrijke aandachtspunten waar zorgvuldigheid veel uitmaakt.

Accolades escapen

Een veelvoorkomende uitdaging is het gebruik van letterlijke accolades in je tekst. Omdat f-strings accolades gebruiken voor expressies, is speciale behandeling nodig om echte accolades te tonen.

Eerst: wat gaat er mis als we accolades verkeerd gebruiken?

# Incorrect way - will raise an error
try:
    print(f"This {variable} is inside {braces}")
except NameError:
    print("The above code would raise an error")

Uitvoer

The above code would raise an error

Om letterlijke accolades weer te geven, verdubbel je ze. Zo doe je het goed:

# Correct way - doubling the braces
print(f"This {{variable}} is inside {{braces}}")
# Mixing literal and expression braces
name = "Python"
print(f"{{Here's a name in braces: {name}}}")

Uitvoer

This {variable} is inside {braces}

{Here's a name in braces: Python}

Bij geneste structuren is correct escapen van accolades nog belangrijker:

# Working with nested dictionary
data = {"name": "Alice", "score": 95}
# Demonstrating nested dictionary formatting
print(f"Data: {{key: {data['name']}, value: {data['score']}}}")

Uitvoer

Data: {key: Alice, value: 95}

Voor complexere geneste structuren kunnen drie aanhalingstekens de leesbaarheid verbeteren, zoals hieronder:

# Using triple quotes for complex structures
data = {"name": "Alice", "score": 95}
template = f"""
Dictionary Format:
    {{'name': '{data["name"]}',
     'score': {data['score']}}}
"""
print(template)

Uitvoer

Dictionary Format:

    {'name': 'Alice',

     'score': 95}

Performance-overwegingen

F-strings draaien niet alleen om gemak – ze zijn ook snel. Eerst bekijken we eenvoudige stringconcatenatie:

# Basic string formatting comparison
import timeit
name = "Python"
version = 3.9
# Using + operator (slowest for multiple items)
def concat_plus():
    return "Running " + name + " version " + str(version)
# Using % formatting (old style)
def format_percent():
    return "Running %s version %s" % (name, version)
# Using str.format()
def format_method():
    return "Running {} version {}".format(name, version)
# Using f-string
def format_fstring():
    return f"Running {name} version {version}"
# Let's time each method
print("Time taken (microseconds):")
print(f"+ operator: {timeit.timeit(concat_plus, number=100000):.2f}")
print(f"% operator: {timeit.timeit(format_percent, number=100000):.2f}")
print(f"str.format: {timeit.timeit(format_method, number=100000):.2f}")
print(f"f-string:   {timeit.timeit(format_fstring, number=100000):.2f}")

Uitvoer

Time taken (microseconds):

+ operator: 0.14

% operator: 0.15

str.format: 0.14

f-string:   0.13

In loops wordt correct gebruik van f-strings extra belangrijk. Hier een vergelijking van verschillende aanpakken:

# Loop performance comparison
data = [("Alice", 95), ("Bob", 87), ("Charlie", 92)]
# Less efficient approach - creating new format string each time
def format_inefficient():
    result = []
    for name, score in data:
        result.append("Name: {} | Score: {}".format(name, score))
    return "\n".join(result)
# More efficient approach - create template once
def format_efficient():
    template = "Name: {} | Score: {}"
    result = []
    for name, score in data:
        result.append(template.format(name, score))
    return "\n".join(result)
# F-string approach
def format_fstring():
    result = []
    for name, score in data:
        result.append(f"Name: {name} | Score: {score}")
    return "\n".join(result)
# Time comparison
print("Time taken (microseconds):")
print(f"Inefficient: {timeit.timeit(format_inefficient, number=10000):.2f}")
print(f"Efficient:   {timeit.timeit(format_efficient, number=10000):.2f}")
print(f"F-string:    {timeit.timeit(format_fstring, number=10000):.2f}")

Uitvoer

Time taken (microseconds):

Inefficient: 0.02

Efficient:   0.02

F-string:    0.01

Voor complexe berekeningen is het beter om die buiten de f-string uit te voeren:

import math
radius = 5
# Bad practice - complex expression inside f-string
print(f"Circle area: {math.pi * radius ** 2:.2f}")
# Better practice - calculate complex expressions separately
area = math.pi * radius ** 2
print(f"Circle area: {area:.2f}")

Onthoud deze best practices bij f-strings:

1. Gebruik geen f-strings als het niet nodig is. Voor statische strings zijn gewone stringliteral­en efficiënter.
2. Als je dezelfde string meerdere keren met verschillende waarden nodig hebt, overweeg een template met standaard stringformattering.
3. Let op de complexiteit van expressies in f-strings – complexe berekeningen kun je beter buiten de f-string uitvoeren.

Praktische voorbeelden en use cases

f-strings zijn onmisbaar voor heldere, leesbare uitvoer. We bekijken praktische scenario's waarin f-strings je code eleganter maken en je output professioneler, met focus op dataformattering en debuggen.

Dataformattering

Bij data-analyse is heldere presentatie cruciaal voor effectieve communicatie. f-strings zijn uitstekend in het omzetten van ruwe data naar goed geformatteerde, makkelijk te begrijpen output. Dit zijn veelvoorkomende scenario's die je tegenkomt.

Financiële data vragen om precieze decimalen en correcte valutannotatie. Bekijk dit voorbeeld met verkoopdata:

# Financial data formatting
monthly_sales = 123456.789
profit_margin = 0.1856
units_sold = 1234
sales_report = f"""
Monthly Sales Report
-------------------
Total Sales:    ${monthly_sales:,.2f}
Profit  {profit_">Units Sold:     {units_sold:,}
Profit:         ${monthly_sales * profit_">"""
print(sales_report)

Uitvoer

Monthly Sales Report
-------------------
Total Sales:    $123,456.79
Profit  18.6%
Units Sold:     1,234
Profit:         $22,912.94

Bij statistische data helpen juiste uitlijning en formattering om je resultaten leesbaarder te maken. Zo kunnen f-strings statistische samenvattingen formatteren:

# Statistical data presentation
dataset = {
    'mean': 67.89123,
    'median': 65.5,
    'std_dev': 12.34567,
    'min_value': 42.5,
    'max_value': 95.75
}
stats_summary = f"""
Statistical Analysis
-------------------
Mean:        {dataset['mean']:.2f}
Median:      {dataset['median']:.1f}
Std Dev:     {dataset['std_dev']:.3f}
Range:       {dataset['min_value']:.1f} - {dataset['max_value']:.1f}
"""
print(stats_summary)

Uitvoer

Statistical Analysis
-------------------
Mean:        67.89
Median:      65.5
Std Dev:     12.346
Range:       42.5 - 95.8

Logging en debuggen

Tijdens development en data-analyse zijn goed loggen en debuggen essentieel. f-strings maken dit eenvoudiger en informatiever. Enkele praktische debugsituaties:

# Enhanced debugging with f-strings
def analyze_data(data_list, threshold):
    # Debug information about input parameters
    print(f"[DEBUG] Processing {len(data_list)} items with threshold {threshold}")
    
    filtered_data = [x for x in data_list if x > threshold]
    
    # Debug information about processing results
    print(f"[DEBUG] Found {len(filtered_data)} items above threshold")
    print(f"[DEBUG] Filtered ratio: {len(filtered_data)/len(data_list):.1%}")
    
    return filtered_data
# Example usage
data = [1, 5, 3, 7, 2, 9, 4, 6]
result = analyze_data(data, 5)

Uitvoer

[DEBUG] Processing 8 items with threshold 5
[DEBUG] Found 3 items above threshold
[DEBUG] Filtered ratio: 37.5%

Bij het debuggen van complexe datastructuren helpen f-strings om duidelijke, informatieve output te maken. Zo zou je een dataverwerkingspipeline debuggen:

# Debugging data transformations
def process_user_data(user_info):
    print(f"""
[DEBUG] Processing user data:
    Input type: {type(user_info)}
    Fields present: {', '.join(user_info.keys())}
    Data sample: {
        {k: user_info[k] for k in list(user_info.keys())[:3]}
    }
""")
    
    # Example processing
    user_data = {
        'name': user_info['name'].upper(),
        'age': user_info['age'] + 1  # Simulated transformation
    }
    
    print(f"[DEBUG] Transformation complete: {user_data}")
    return user_data
# Example usage
sample_data = {
    'name': 'alice',
    'age': 30,
    'city': 'New York',
    'occupation': 'Data Scientist'
}
processed = process_user_data(sample_data)

Uitvoer

[DEBUG] Processing user data:
    Input type: <class 'dict'>
    Fields present: name, age, city, occupation
    Data sample: {'name': 'alice', 'age': 30, 'city': 'New York'}
[DEBUG] Transformation complete: {'name': 'ALICE', 'age': 31}

Deze praktische voorbeelden laten zien hoe f-strings je dagelijkse werk als dataprofessional verbeteren. Of je nu analyseresultaten formatteert, complexe transformaties debugt of informatieve logberichten maakt: f-strings bieden een schone, efficiënte manier om stringformattering aan te pakken.

Conclusie

f-strings hebben de manier waarop Python-developers stringformattering doen veranderd, met een perfecte mix van leesbaarheid, performance en flexibiliteit. Zoals we hebben gezien, bieden ze een intuïtieve manier om expressies en data direct in strings te verwerken, waardoor onze code schoner en onderhoudsvriendelijker wordt.

De voordelen van f-strings gaan verder dan syntaxis. Ze bieden:

1. Betere leesbaarheid: variabelen en expressies staan precies waar ze in de uitvoer verschijnen.
2. Hogere performance: f-strings zijn sneller dan traditionele formatteringsmethoden.
3. Meer flexibiliteit: van simpele variabele-inserties tot complexe expressies, f-strings kunnen het allemaal aan.
4. Debugmogelijkheden: de '='-specifier maakt inspectie en debuggen eenvoudiger.

Wil je meer leren om alles uit Python te halen? Bekijk dan onze Python Programming skill track.