Python-stringinterpolatie: een gids voor beginners

Stel dat je de naam en het beroep van iemand wilt weergeven. Je zou een eenvoudig programma als volgt kunnen schrijven.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)Mogelijk gemaakt door

   My name is Mark, I am 7 years old and my profession is Astronaut.Mogelijk gemaakt door

Die aanpak is niet erg beknopt en slecht leesbaar. Gelukkig biedt stringinterpolatie een betere oplossing. Daarmee kun je variabelen, expressies of functie-uitvoer rechtstreeks in een string invoegen, waardoor het werken met strings dynamisch wordt en je niet meer handmatig hoeft te concatenaten.

Met stringinterpolatie kunnen we de code als volgt herschrijven.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)Mogelijk gemaakt door

   My name is Mark, I am 7 years old and my profession is Astronaut.Mogelijk gemaakt door

De versie met stringinterpolatie laat toe om expressies rechtstreeks in de string op te nemen zonder rommelige concatenaties. Zoals je ziet is dit een veel schonere aanpak.

Basisstringinterpolatie in Python

Er zijn verschillende technieken voor stringinterpolatie in Python. De meest aanbevolen methode is de formatted string literals, ook wel f-strings genoemd, die beschikbaar zijn sinds Python 3.6.

Een andere methode, vaak te zien in code ouder dan Python 3.6, is de .format()-methode. Hoewel deze methode omslachtiger is dan f-strings, heeft ze soms voordelen (details hieronder).

Tot slot kun je in legacycode ook %-stijlformattering tegenkomen.

f-strings gebruiken (Python 3.6+)

f-strings (formatted string literals) zijn een krachtige en beknopte manier om strings in Python te formatteren. Ze werden geïntroduceerd in Python 3.6 en bieden een leesbare en efficiënte manier om variabelen, expressies en functieaanroepen rechtstreeks in strings te plaatsen.

Een eenvoudig voorbeeld van de basis­synthax van een f-string is als volgt.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)Mogelijk gemaakt door

   My name is Mark.Mogelijk gemaakt door

In deze code krijgt de variabele output_string een f-string toegewezen. De prefix f vóór het openingsaanhalingsteken geeft aan dat de string ingesloten expressies ondersteunt. De variabele name wordt geëvalueerd en de waarde ervan wordt in de string ingevoegd, wat resulteert in de uitvoer: "My name is Mark."

Niet alleen variabele waarden, maar ook berekeningen of expressies kun je in f-strings opnemen. Bekijk dit voorbeeld.

import math


a = 3.0
b = 4.0


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')Mogelijk gemaakt door

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.Mogelijk gemaakt door

De expressie math.sqrt(a ** 2 + b ** 2) wordt direct binnen de string geëvalueerd, zodat je de waarde niet apart hoeft te berekenen vóór je die in de string invoegt.

De .format()-methode gebruiken

Net als f-strings laat de .format()-methode toe om variabelen en expressies in een string in te voegen. De basis­synthax van de .format()-methode is als volgt.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)Mogelijk gemaakt door

   My name is Mark.Mogelijk gemaakt door

De accolades {} fungeren als placeholder en geven aan dat op die positie de waarde van een variabele in de string zal worden geplaatst. Welke specifieke variabele in de placeholder komt, wordt bepaald door het argument dat je aan de .format()-methode doorgeeft.

Positionele argumenten

Wat als je meerdere placeholders voor meerdere variabelen nodig hebt? Bekijk de volgende code.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)Mogelijk gemaakt door

   My name is Mark and I am 7 years old.Mogelijk gemaakt door

In dit voorbeeld zijn twee variabelen nodig, name en age. De string bevat daarom twee placeholders, en de variabelen worden ingevoegd in dezelfde volgorde als waarin ze aan de .format()-methode worden doorgegeven. Deze argumenten heten positionele argumenten, omdat hun plaats in de string wordt bepaald door hun positie in de argumentenlijst van de methode.

Geïndexeerde en benoemde placeholders

Als variatie op het placeholder-idee, bekijk dit voorbeeld.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)Mogelijk gemaakt door

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Mogelijk gemaakt door

Hier gebruiken we de waarde van de variabele age twee keer. Dezelfde variabele meerdere keren opnemen zoals hier is onhandig en gaat ten koste van de leesbaarheid. Kun je in een met .format() geformatteerde string een variabele hergebruiken zonder te herhalen? Ja, met zogeheten geïndexeerde placeholders.

name = 'Mark'
age = 7


# Use indexed placeholders
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)Mogelijk gemaakt door

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Mogelijk gemaakt door

In dit voorbeeld definiëren we expliciet de volgorde van variabelen binnen de accolades, volgens de nulgebaseerde indexering van Python. Bovendien hergebruiken we de variabele op index 1 in plaats van die te herhalen.

Als alternatief voor positionele indexen kun je ook benoemde argumenten gebruiken, waarbij elk argument een naam krijgt.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))Mogelijk gemaakt door

   My name is Mark and I am 7 years old.Mogelijk gemaakt door

Het benoemde argument wordt geëvalueerd binnen de accolades die de naam specificeren. Daardoor wordt de placeholder {name} vervangen door de waarde "Mark" en de placeholder {age} door 30.

De %-operator gebruiken

De laatste methode voor stringinterpolatie is de %-operator. Die werkt vergelijkbaar met het printf()-commando in C. Het gebruik ervan is verouderd en wordt sterk afgeraden ten gunste van f-strings of de .format()-methode. We noemen het hier omdat je het in legacycode kunt tegenkomen.

De basisvorm voor de %-operator is: "format string" % values. De formatstring bevat placeholders, zoals %s voor strings, die worden vervangen door waarden. Zo print het volgende voorbeeld "Hello, Mark."

'Hello %s' % 'Mark'Mogelijk gemaakt door

   'Hello Mark'Mogelijk gemaakt door

Andere veelgebruikte formatspecificaties staan in de volgende tabel.

De %-operator heeft veel beperkingen. Hij is onder meer minder leesbaar dan f-strings. Bekijk de volgende code.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)Mogelijk gemaakt door

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Mogelijk gemaakt door

Is deze code in één oogopslag duidelijk? Waarschijnlijk niet. Je moet visueel heen en weer tussen de placeholders en de variabelen die de gaten opvullen. Het is gemakkelijk om in de war te raken (of duizelig te worden) van al dat heen-en-weer scannen.

Bekijk nu equivalente code met f-strings.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)Mogelijk gemaakt door

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Mogelijk gemaakt door

Geen gescan en geen cryptische formatteringsstrings nodig. De code is schoon, gemakkelijk te begrijpen en gemakkelijk te schrijven. Je kunt meer tips leren om heldere, geoptimaliseerde code te schrijven met DataCamp’s Python Programming skill track. 

Geavanceerde technieken voor Python-stringinterpolatie

Nu we de basis van Python-stringinterpolatie begrijpen, kijken we naar wat geavanceerdere toepassingen. 

Python-multiline stringinterpolatie

Je kunt f-strings ook gebruiken voor meerrijige content door de f-aanduiding te gebruiken met drie aanhalingstekens (enkel of dubbel). De tekst kan over meerdere regels worden geschreven en verschijnt in de output precies zoals geformatteerd.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)Mogelijk gemaakt door

   Name: Mark

   Profession: Astronaut

   Age: 7Mogelijk gemaakt door

 Meerrijige strings kun je ook maken met de .format()-methode.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)Mogelijk gemaakt door

   Name: Mark

   Profession: Astronaut

   Age: 7Mogelijk gemaakt door

Gebruiksscenario’s voor meerrijige stringinterpolatie

Waarom zou je meerrijige stringinterpolatie gebruiken? Er zijn veel toepassingen. Enkele use-cases:

• Meerrijige e-mails of berichten genereren
• Loggen en debuggen
• SQL-queries dynamisch genereren

Meerrijige e-mails of berichten genereren

Stel dat je een standaardbrief verstuurt naar veel genodigden voor een techconferentie.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)Mogelijk gemaakt door

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event TeamMogelijk gemaakt door

Met f-strings is het maken van een standaardbrief simpel en efficiënt. Wil je de naam, het event of de datum aanpassen, verander dan gewoon de variabelen en de string past zich automatisch aan.

Loggen en debuggen

Meerrijige strings zijn handig om foutmeldingen voor logs af te drukken.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)Mogelijk gemaakt door

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.Mogelijk gemaakt door

Deze methode houdt logberichten gestructureerd en maakt debuggen makkelijker met netjes geformatteerde logs.

SQL-queries dynamisch genereren

SQL-queries kun je dynamisch opbouwen met meerrijige strings.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)Mogelijk gemaakt door

   SELECT *

   FROM users

   WHERE email = '[email protected]';Mogelijk gemaakt door

Deze aanpak houdt SQL-queries leesbaar en behoudt de inspringing. Bovendien hoef je geen + te gebruiken voor stringconcatenatie.

Andere use-cases zijn:

• Geformatteerde contracten schrijven
• Markdown- of $\LaTeX$-documenten maken
• Meerrijige HTML/XML-templates
• API-responses of JSON-achtige tekst genereren

Voordelen van meerrijige stringinterpolatie

Zoals we zien, heeft meerrijige stringinterpolatie verschillende voordelen.

• Stringinterpolatie behoudt de opmaak zonder het escape-teken \n. 
• Stringinterpolatie verbetert de leesbaarheid ten opzichte van formatteren op één regel. 
• Stringinterpolatie vermindert rommel bij gestructureerde tekst (zoals logs, queries, rapporten). 
• Stringinterpolatie laat dynamische tekstopbouw toe zonder inspringing te breken. 

Getallen en speciale waarden formatteren

Om het aantal decimalen te bepalen met een f-string, gebruik je de syntaxis: f'{value:.nf}', waarbij value het drijvende-kommagetal is, n het aantal decimalen en f (na de .) staat voor float-formattering.

Ter illustratie: de volgende code geeft $\pi$ met verschillende decimalen.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')Mogelijk gemaakt door

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Mogelijk gemaakt door

Formatteren met de .format()-methode lijkt hierop.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))Mogelijk gemaakt door

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Mogelijk gemaakt door

Je kunt met een f-string percentages formatteren door de :.nf-syntaxis te combineren met %, waarbij n het aantal decimalen is.

score = 0.875
print(f"Success rate: {score:.2%}")Mogelijk gemaakt door

   Success rate: 87.50%Mogelijk gemaakt door

Je kunt met een f-string valuta formatteren door :, te gebruiken voor duizendtallen en .nf om het aantal decimalen te bepalen. Je kunt ook direct een valutateken zoals $, € of £ in de string opnemen.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")Mogelijk gemaakt door

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Mogelijk gemaakt door

f-strings gebruiken met dictionaries en lijsten

Om f-strings met een dictionary in Python te gebruiken, kun je dictionarywaarden binnen de accolades benaderen met blokhaken (dict['key']) of door de dictionary met ** te unpacken.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")Mogelijk gemaakt door

   My name is Alice, I am 30 years old, and I live in New York.Mogelijk gemaakt door

In plaats van elke key handmatig te benaderen, kun je de dictionary als volgt in een f-string unpacken.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))Mogelijk gemaakt door

   My name is Alice and I am 7 years old.Mogelijk gemaakt door

Om een fout bij ontbrekende keys te vermijden, gebruik je get() voor dictionarytoegang.

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") Mogelijk gemaakt door

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Error: key 'city' is missing

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'Mogelijk gemaakt door

print(f"City: {person.get('city', 'Not specified')}")Mogelijk gemaakt door

   City: Not specifiedMogelijk gemaakt door

Voor- en nadelen van methoden voor stringinterpolatie

Zoals we hebben gezien, zijn f-strings en de .format()-methode allebei nuttig voor stringinterpolatie. Laten we de voor- en nadelen per methode vergelijken.

Wanneer gebruik je .format() liever dan f-strings?

Veelvoorkomende valkuilen en best practices

Hieronder vind je enkele tips voor troubleshooting en toptips voor Python-stringinterpolatie. 

Syntaxisfouten met accolades vermijden

Er zijn allerlei syntaxisfouten mogelijk bij stringinterpolatie met accolades.

• Zorg dat elke { een bijpassende } heeft

print('Hello, my name is {name!'}Mogelijk gemaakt door

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('Mogelijk gemaakt door

Gelukkig is de fout duidelijk en is de oplossing eenvoudig.

• Gebruik {{ en }} om letterlijke {} weer te geven

Wat als je accolades wilt afdrukken binnen een geïnterpoleerde string? Alles binnen accolades wordt (geprobeerd te) evalueren.

print(f'Set notation: {a, b, c}')Mogelijk gemaakt door

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not definedMogelijk gemaakt door

Python interpreteert a, b, c binnen de accolades als een tuple en probeert een waarde te vinden die bij a hoort. Omdat zo’n variabele niet bestaat, ontstaat er een KeyError. De oplossing is dubbele accolades {{}} gebruiken.

print("Set notation: {{a, b, c}}")Mogelijk gemaakt door

   Set notation: {{a, b, c}}

Prestatievergelijking: f-strings vs .format()

Laten we de prestaties van f-strings en .format() vergelijken.

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Measure f-string performance
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Measure .format() performance
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")Mogelijk gemaakt door

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsMogelijk gemaakt door

Zoals je ziet, verdient vanuit efficiëntie-oogpunt f-strings de voorkeur boven .format().

Best practices voor schone en leesbare stringinterpolatie

Volg deze best practices om je stringformattering duidelijk, efficiënt en onderhoudbaar te maken.

• Geef de voorkeur aan f-strings voor leesbaarheid (Python 3.6+)

# Recommended
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))Mogelijk gemaakt door

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Mogelijk gemaakt door

• Benoemde placeholders gebruiken voor duidelijkheid

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))Mogelijk gemaakt door

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Mogelijk gemaakt door

• Houd meerrijige strings leesbaar.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)Mogelijk gemaakt door

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  Mogelijk gemaakt door

• Gebruik f-strings in logging voor beter debuggen

Python 3.8 en later ondersteunt = voor debuggen in f-strings.

value = 42


# Output: value = 42
print(f"{value = }") Mogelijk gemaakt door

   value = 42Mogelijk gemaakt door

Conclusie

Stringinterpolatie is een krachtige functie in Python die stringformattering schoner, leesbaarder en efficiënter maakt. Van de beschikbare methoden zijn f-strings het modernst en het meest aanbevolen, met betere prestaties, duidelijkheid en flexibiliteit dan oudere methoden zoals .format() en %-formattering. 

Door best practices te volgen, zoals benoemde placeholders gebruiken, decimale precisie beheersen, tekst uitlijnen voor leesbaarheid en ontbrekende dictionarykeys netjes afhandelen, schrijf je schone, professionele en onderhoudbare stringformattering in Python. 

Of je nu geformatteerde rapporten, meerrijige berichten of gestructureerde data-output genereert, f-strings bieden een eenvoudige maar krachtige manier om variabelen en expressies naadloos te integreren. Door f-strings te omarmen verbeter je niet alleen de kwaliteit van je code, maar ook de efficiëntie. 

Voor meer informatie over Python-stringinterpolatie kun je de bronnen van DataCamp bekijken:

• f-string Formatting in Python tutorial
• Python Append String: 6 Essential Concatenation Techniques
• Python Programming skill track
• Python Fundamentals skill track
• Introduction to Data Science in Python course