Python String Interpolatie: Een Gids voor Beginners

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

# Definieer variabelen
name = 'Mark'
profession = 'Astronaut'
age = 7


# Geef informatie weer
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

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

Dat benadering mist beknopte en leesbaarheid. Gelukkig biedt stringinterpolatie een betere oplossing. Het maakt het mogelijk om variabelen, expressies of functie-uitvoer rechtstreeks in een string in te voegen, waardoor stringmanipulatie dynamisch wordt en de noodzaak voor handmatige concatenatie wordt geëlimineerd.

Met een stringinterpolatiebenadering kunnen we de code als volgt herschrijven.

# Definieer variabelen
name = 'Mark'
profession = 'Astronaut'
age = 7


# Geef informatie weer
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

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

De versie met stringinterpolatie maakt het mogelijk om expressies direct in de string in te bedden zonder het gebruik van rommelige concatenaties. Zoals je kunt zien, is het een veel schonere benadering.

Basis Stringinterpolatie in Python

Er zijn verschillende stringinterpolatietechnieken beschikbaar in Python. De meest aanbevolen methode is geformatteerde string-literals, ook bekend als f-strings, die beschikbaar zijn sinds Python 3.6.

Een andere methode, die vaak wordt gezien in code ouder dan Python 3.6, is de .format() methode. Hoewel deze methode uitgebreider is dan f-strings, heeft het af en toe voordelen (details hieronder).

Ten slotte kunt u %-stijl opmaak tegenkomen in legacy code.

Gebruikmakend van f-strings (Python 3.6+)

f-strings (geformatteerde 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 direct in strings in te voegen.

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

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

   My name is Mark.

In deze code wordt de output_string variabele toegewezen aan een f-string. De f voorvoegsel voor de openingsquote geeft aan dat de string ingesloten expressies ondersteunt. De variabele name wordt geëvalueerd en de waarde ervan wordt ingevoegd in de string, resulterend in de output: "Mijn naam is Mark."

Niet alleen variabele waarden, maar ook berekeningen of expressies kunnen worden ingevoegd in f-strings. Bekijk dit voorbeeld.

import math


a = 3.0
b = 4.0


# Gebruik stringinterpolatie voor de formule
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

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

De expressie math.sqrt(a ** 2 + b ** 2) wordt rechtstreeks geëvalueerd binnen de string, waardoor de noodzaak om de waarde apart te berekenen vóór het invoegen in de string wordt geëlimineerd.

Het gebruik van de .format() methode

Net als bij f-strings, maakt de .format() methode het mogelijk om variabelen en expressies in een string in te voegen. De basis-syntaxis van de .format() methode is als volgt.

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

   My name is Mark.

De accolades {} dienen als een tijdelijke aanduiding, wat aangeeft dat de waarde van een variabele op die positie in de string zal worden ingevoegd. De specifieke waarde van de variabele die in de tijdelijke aanduiding wordt ingevoegd, wordt bepaald door het argument dat aan de .format() methode wordt gegeven.

Positionele argumenten

name = 'Mark'
age = 7


# De tijdelijke aanduidingen worden gevuld in de volgorde van de argumenten
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

In dit voorbeeld zijn er twee variabelen, naam en leeftijd, nodig. Bijgevolg bevat de string twee tijdelijke aanduidingen, en de variabelen worden in dezelfde volgorde ingevoegd als ze verschijnen in de .format() methode. Deze argumenten worden aangeduid als *positional* argumenten omdat hun plaatsing in de string wordt bepaald door hun positie in de argumentenlijst van de methode.

Geïndexeerde en benoemde tijdelijke aanduidingen

Als een variatie op het idee van tijdelijke aanduidingen, overweeg dit voorbeeld.

name = 'Mark'
age = 7


# Print leeftijd twee keer
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

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

Hier hebben we de waarde van de variabele leeftijd twee keer hergebruikt. Het meerdere keren opnemen van dezelfde variabele op deze manier is omslachtig en doet afbreuk aan de leesbaarheid. Is er een manier om een variabele opnieuw te gebruiken in een string die is opgemaakt met de .format() methode zonder deze te herhalen? Ja, dat kan, met behulp van de zogenaamde *geïndexeerde placeholders*. methode zonder deze te herhalen? Ja, dat kan, met behulp van de zogenaamde *geïndexeerde placeholders*. *geïndexeerde placeholders* # Gebruik geïndexeerde placeholders.

name = 'Mark'
age = 7


# Gebruik geïndexeerde 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)

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

In dit voorbeeld hebben we expliciet de volgorde van variabelen binnen de accolades gedefinieerd, volgens de op nul gebaseerde indexering van Python. Bovendien hebben we de variabele op index 1 hergebruikt in plaats van deze te herhalen.

Als alternatief voor positionele indexering kunt u 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))

   My name is Mark and I am 7 years old.

Het genoemde argument wordt geëvalueerd binnen de accolades die de naam specificeren. Als gevolg hiervan wordt de {name} placeholder vervangen door de waarde "Mark", en de {age} placeholder wordt vervangen door 30.

Met behulp van de % operator

De laatste methode voor stringinterpolatie is de % operator. Het werkt op een vergelijkbare manier als het printf() commando in C. Het gebruik ervan is verouderd en sterk afgeraden ten gunste van f-strings of de .format() methode. Het wordt hier genoemd omdat je het kunt tegenkomen in oude codebases.

Het basisformaat voor de % operator is: "formatteerstring" % waarden. De formatteerstring bevat plaatsaanduidingen, zoals %s voor strings, die worden vervangen door waarden. Bijvoorbeeld, het volgende voorbeeld print “Hallo, Mark.”

'Hello %s' % 'Mark'

   'Hello Mark'

Andere veelvoorkomende opmaak-specifiers worden weergegeven in de volgende tabel.

De % operator heeft vele beperkingen. Allereerst is het minder leesbaar dan f-strings. Overweeg de volgende code.

name = "Alice"
age = 30
height = 5.6


# De % operator is moeilijk te scannen
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

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

Is deze code in één oogopslag duidelijk? Waarschijnlijk niet. Er is veel visuele verwerking heen en weer van de aanduiding en de variabelen die de lege plekken invullen. Het is gemakkelijk om verward (of duizelig) te raken door al dat scannen heen en weer.

Overweeg nu equivalentie code met behulp van f-strings.

# Dit is veel schoner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

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

Geen scannen en geen obscure opmaakstrings zijn vereist. De code is schoon, gemakkelijk te begrijpen en gemakkelijk te schrijven. Je kunt andere tips leren om duidelijke, geoptimaliseerde code te schrijven met de Python Programmeervaardigheden van DataCamp.. 

Geavanceerde Python String Interpolatietechnieken

Nu we de basis van Python string interpolatie hebben begrepen, laten we eens kijken naar enkele meer geavanceerde toepassingen. 

Python multiline string interpolatie

f-strings kunnen ook worden gebruikt voor meerregelige inhoud door het gebruik van de f-aanduider met dubbele aanhalingstekens (enkele of dubbele). De tekst kan over meerdere regels worden geschreven en zal precies zo verschijnen in de uitvoer als opgemaakt.

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


# Dit is een voorbeeld van een meerregelige string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Multiline strings kunnen ook worden gemaakt met de .format() methode.

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


# Dit is een multiline string met .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Gebruikssituaties voor multiline string interpolatie

Waarom zou je multiline string interpolatie willen gebruiken? Er zijn veel toepassingen voor multiline string interpolatie. Hier zijn een paar gebruikssituaties:

• Genereren van multiline e-mails of berichten
• Logging en debugging
• Dynamisch genereren van SQL-query’s

Genereren van multiline e-mails of berichten

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)

   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 Team

Met f-strings is het maken van een standaardbrief eenvoudig en efficiënt. Om de naam, het evenement of de datum te wijzigen, hoef je ze alleen maar in de variabelen te wijzigen en de string verandert automatisch.

Logging en debugging

Multiline strings zijn nuttig voor het afdrukken van foutmeldingen voor logs.

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)

   [ERROR 404]

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

   URL: /missing-page

 

   The requested page could not be found.

Deze methode houdt logberichten gestructureerd en maakt debugging gemakkelijker met goed opgemaakte logs.

Dynamisch genereren van SQL-query’s

SQL-query’s kunnen dynamisch worden opgebouwd met behulp van multiline strings.

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


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


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

Deze methode maakt SQL-query’s leesbaar en behoudt de inspringing. Verder elimineert het de noodzaak om + te gebruiken voor stringconcatenatie.

Andere gebruiksgevallen zijn:

• Geformatteerde contracten schrijven
• Markdown of $\LaTeX$ documenten maken
• Multiline HTML/XML-sjablonen
• Het genereren van API-responsen of JSON-achtige tekst

Voordelen van meerdere regels string interpolatie

Zoals we kunnen zien, zijn er verschillende voordelen van meerdere regels string interpolatie.

• String interpolatie behoudt de opmaak zonder de escape-karakter\n. 
• String interpolatie verbetert de leesbaarheid in vergelijking met enkele regel opmaak. 
• String interpolatie vermindert rommel bij het werken met gestructureerde tekst (bijv. logs, query’s, rapporten). 
• Stringinterpolatie maakt dynamische tekstgeneratie mogelijk zonder inspringing te verbreken.

Getallen en speciale waarden formatteren

Om het aantal decimalen dat wordt weergegeven met een f-string te controleren, gebruik de syntaxis: f'{waarde:.nf}', waar waarde het floating-point getal is, n het aantal decimalen is, en f (degene na de .) staat voor float formattering.

Om dit te illustreren, geeft de volgende code $\pi$ uit tot 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}')

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

Opmaak met de .format()-methode is vergelijkbaar.

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))

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

Je kunt een f-string gebruiken om percentages te formatteren door de :.nf-syntax te gebruiken in combinatie met%, waar n het aantal decimalen is.

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

   Success rate: 87.50%

Je kunt een f-string gebruiken om valuta te formatteren door gebruik te maken van de :, voor duizendtallen scheidingstekens en .nf om decimalen te controleren. Je kunt ook een valutateken zoals $, €, of £ direct in de string opnemen.

amount = 98765.4321


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

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

F-strings gebruiken met woordenboeken en lijsten

Om f-strings met een woordenboek in Python te gebruiken, krijg je toegang tot de waarden in het woordenboek binnen de accolades met behulp van de vierkante haaknotatie (dict[‘key’]) of door het woordenboek uit te pakken met **.

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']}.")

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

In plaats van elke sleutel handmatig te benaderen, kun je het woordenboek in een f-string uitpakken als volgt.

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


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

   My name is Alice and I am 7 years old.

Om een fout voor ontbrekende sleutels te vermijden, gebruik get() voor woordenboektoegang.

person = {"name": "Alice"}


# Fout: sleutel 'city' ontbreekt
print(f"City: {person['city']}") 

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

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

         3 # Fout: sleutel 'city' ontbreekt

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







   KeyError: 'city'

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

   City: Not specified

Voor- en nadelen van stringinterpolatiemethoden

Zoals we hebben gezien, zijn f-strings en de .format() methode beide nuttige methoden voor stringinterpolatie. Laten we kijken naar een vergelijking van de voor- en nadelen van elke methode.

Wanneer moet je .format() gebruiken in plaats van f-strings?

Veelvoorkomende valkuilen en beste werkwijzen

Hieronder vind je enkele probleemoplossingsmethoden en handige tips voor het gebruik van Python-stringinterpolatie.

Syntaxfouten vermijden met accolades

Er zijn veel syntaxisfouten die men kan maken bij het gebruik van stringinterpolatie met accolades.

• Zorg ervoor dat elke { overeenkomt met }

print('Hello, my name is {name!'}

     Cell In[96], line 1

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

Gelukkig is de fout eenvoudig en is de oplossing makkelijk.

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

Wat gebeurt er als je accolades wilt afdrukken binnen een geïnterpoleerde string? Alles binnen de accolades zal (proberen te) worden geëvalueerd.

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

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

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

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

   NameError: name 'c' is not defined

Python interpreteert a, b, c binnen de accolades als een tuple en probeert een waarde te vinden die geassocieerd is met a. Aangezien er geen dergelijke variabele bestaat, genereert het een KeyError. De oplossing is om dubbele accolades te gebruiken {{}}.

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

   Verzamelingsnotatie: {{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


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


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


# Meet f-string prestaties met expressies
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Meet .format() prestaties met expressies
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print resultaten
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")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

Zoals je kunt zien, vanuit een efficiëntieoogpunt, moet men de voorkeur geven aan f-strings boven .format().

Best practices voor schone en leesbare stringinterpolatie

Om ervoor te zorgen dat je string formattering duidelijk, efficiënt en onderhoudbaar is, volg deze best practices bij het gebruik van geïnterpoleerde strings.

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

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


# Niet aanbevolen (Minder leesbaar)
print("My name is {} and I am {} years old.".format(name, age))


# Vermijd het gebruik van % formattering (Verouderd)
print("My name is %s and I am %d years old." % (name, age))

   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.

• Gebruik benoemde plaatshouders voor duidelijkheid

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


# Gebruik van indexen in .format() (minder leesbaar)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Houd meerdere-regel 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)

   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  

• Gebruik f-strings bij Logging voor Betere Debugging

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

value = 42


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

   value = 42

Conclusie

String interpolatie is een krachtige functie in Python die string opmaak schoner, leesbaarder en efficiënter maakt. Van de beschikbare methoden zijn f-strings de meest moderne en aanbevolen benadering, met betere prestaties, duidelijkheid en flexibiliteit ten opzichte van oudere methoden zoals .format() en % opmaak.

Door best practices te volgen, zoals het gebruik van benoemde aanduidingen, het controleren van decimale precisie, het uitlijnen van tekst voor leesbaarheid en het soepel omgaan met ontbrekende woordenboeksleutels, kunt u schone, professionele en onderhoudbare stringopmaak schrijven in Python.

Of u nu opgemaakte rapporten, meerregelige berichten of gestructureerde gegevensuitvoer genereert, f-strings bieden een eenvoudige maar krachtige manier om variabelen en expressies naadloos te integreren. Het omarmen van f-strings zal niet alleen de kwaliteit van uw code verbeteren, maar ook de efficiëntie ervan verhogen.

Voor meer informatie over Python stringinterpolatie, bekijk de bronnen van DataCamp:

• f-string Formatteren in Python handleiding
• Python String Toevoegen: 6 Essentiële Concatenatietechnieken
• Python Programmeren vaardigheidstraject
• Basisprincipes van Python vaardigheidstraject
• Inleiding tot Data Science in Python cursus