Werken met strings in Python

Een string is een sequentie van tekens met het type str. Een string kan een naam, een zin, een code of helemaal geen tekens bevatten. Python bewaart de tekens op volgorde, inclusief spaties en leestekens.

Schrijf de waarde tussen bij elkaar passende aanhalingstekens

Enkele en dubbele aanhalingstekens maken hetzelfde soort waarde: 'hello' en "hello" zijn gelijk. De buitenste aanhalingstekens geven de grenzen aan; het zijn geen tekens in de waarde. Kies aanhalingstekens die eventuele aanhalingstekens binnen de tekst goed leesbaar houden:

message = "It's late"
reply = 'She said "yes"'
empty = ""

In 'It's late' sluit de apostrof de string te vroeg af, wat een SyntaxError veroorzaakt. Dubbele aanhalingstekens lossen dit op, of je kunt 'It\'s late' schrijven. Gebruik rechte aanhalingstekens in code.

Sla regelafbrekingen en backslashes op

Een escapesequentie begint met een backslash. Python leest \n als één regeleinde, \t als één tab en \\ als één backslash. Geëscapete aanhalingstekens, \' en \", plaatsen aanhalingstekens in tekst.

text = "a\nb"
print(len(text))  # 3
print(text)

De laatste aanroep drukt a en b op afzonderlijke regels af. De waarde heeft drie tekens: a, een regeleinde en b. Escapesequenties worden verwerkt wanneer Python de literal leest. De shell toont een representatie met aanhalingstekens en waar nodig escapesequenties; print() toont de tekens zelf. Zo wordt "\x41" bijvoorbeeld "A", zodat de shell de oorspronkelijke escapesequentie niet hoeft te tonen.

Met driedubbele aanhalingstekens kan een literal over meerdere regels lopen. Elke regelafbreking daarin wordt een regeleindeteken:

notice = """Door closed
Use side entrance"""

Een ruwe string heeft een r vóór de aanhalingstekens. In r"C:\new" blijven de backslash en n afzonderlijk, wat zes tekens oplevert. In "C:\new" wordt \n een regeleinde, wat vijf tekens oplevert. Ruwe stringliterals zijn handig als backslashes in de tekst thuishoren.

Meet en combineer tekst

len() telt elk teken, ook spaties: len("Hi there!") is 9 en len("") is 0. Preciezer gezegd telt de functie Unicodecodepunten. len("café") is 4 als é één codepunt is; len("👍🏽") is 2, ook al ziet de emoji eruit als één symbool.

Gebruik + om strings samen te voegen en * om een string te herhalen:

first = "Ada"
last = "Lovelace"
full = first + " " + last  # "Ada Lovelace"
rule = "-" * 10           # ten dashes

Concatenatie voegt niets voor je in. Zonder " " worden de namen "AdaLovelace". Als je "ab" nul keer herhaalt, krijg je de lege string.

Bepaal of cijfers tekst of getallen zijn

Beide operanden van stringconcatenatie moeten strings zijn. "Age: " + 30 werpt een TypeError op; "Age: " + str(30) geeft "Age: 30". Omgekeerd geeft input() tekst terug: "3" + "4" geeft "34". Om hun numerieke waarden op te tellen, zet je ze eerst om: int("3") + int("4") geeft 7.

Een index selecteert één teken op basis van zijn positie. Python begint bij nul te tellen, dus de positie van een teken is één minder dan de plaats bij een gewone telling vanaf links.

Breng de posities in beeld

Voor word = "Python" heeft elk teken een niet-negatieve en een negatieve index:

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[-1])  # n

De vierkante haakjes achter de string selecteren het teken. Het resultaat is een string met lengte één: Python heeft geen apart tekentype. Je kunt geselecteerde tekens samenvoegen, dus word[0] + word[-1] geeft "Pn".

Voor lengte n lopen de geldige indexen van -n tot en met n - 1 als n > 0. Niet-negatieve indexen tellen vanaf het begin; negatieve indexen tellen vanaf het einde. Een index -k selecteert hetzelfde teken als n - k; in dit woord van zes tekens selecteren -2 en 4 allebei "o".

Houd de lengte en de laatste index uit elkaar

len(word) is 6, maar word[6] werpt een IndexError op: er is geen zevende teken. Het laatste teken is word[len(word) - 1], of eenvoudig word[-1]. Te ver gaan vanaf een van beide uiteinden levert een fout op; ook word[-7] werpt een IndexError op.

Een index moet een geheel getal zijn. word[1.0] werpt een TypeError op, ook al heeft het zwevendekommagetal een gehele waarde. Gebruik // bij het berekenen van een middelste positie:

word = "Pyt"
middle = len(word) // 2  # 1
print(word[middle])      # y

De operator / zou 1.5 opleveren, waarmee je geen string kunt indexeren. Bij een oneven lengte selecteert len(word) // 2 het middelste teken. Bij een even lengte selecteert dit het rechter van de twee middelste tekens: "Python"[3] is "h".

Maak initialen van eerste tekens

first = "Grace"
last = "Hopper"
initials = first[0] + last[0]
print(initials)  # GH

Van elke naam wordt het teken op index 0 gebruikt. Met first[-1] zou je "e" krijgen, de laatste letter. Voor deze methode moet elke naam minstens één teken bevatten.

Controleer lege invoer vóór indexering

De lege string heeft lengte nul en geen geldige tekenindex. ""[0] werpt een IndexError op. Een lengtecontrole kan voorkomen dat een programma een teken leest dat niet bestaat:

line = input("Comment: ")
if len(line) > 0 and line[0] == "#":
    print("Comment line")

Python evalueert and van links naar rechts. Als de lengtecontrole onwaar is, slaat Python line[0] over. Als je die twee controles omdraait, wordt eerst de onveilige indexering geprobeerd. Als je alleen wilt weten of een regel begint met "#", werkt line.startswith("#") ook bij lege invoer en geeft het False terug.

Een uitsnede selecteert een aaneengesloten reeks tekens en geeft die terug als string. Hiermee kun je een beginstuk nemen, een einde verwijderen of velden scheiden die vaste posities innemen.

De startwaarde telt mee; de eindgrens niet

Schrijf text[start:stop]. Met s = "Monty Python" geeft s[0:5] de string "Monty" en s[6:12] de string "Python". De spatie staat op index 5, dus de tweede uitsnede begint bij 6.

Stel je de getallen van een uitsnede voor als tussenruimtes. Tussenruimte 0 staat vóór het eerste teken en tussenruimte 5 na de eerste vijf. Alles daartussen nemen levert vijf tekens op. Voor 0 <= start <= stop <= len(text) is de lengte stop - start.

word = "Monty"
print(word[0:4])  # Mont
print(word[0:5])  # Monty

De eindpositie is de eerste positie die wordt weggelaten. Door één op te tellen bij de gewenste laatste index neem je dat laatste teken mee.

Laat een grens weg

Op elke splitsingspositie k geeft s[:k] + s[k:] de string s terug. De uitsneden sluiten op dezelfde tussenruimte aan, zonder ontbrekend of herhaald teken.

Uitsnedegrenzen voorbij de uiteinden worden teruggebracht tot de uiteinden. "cat"[1:100] is "at"; "cat"[5:] is "". Voor een voorwaartse uitsnede geeft een startwaarde op of voorbij de eindgrens een lege string, zoals in s[4:2]. Anders dan bij een index voor één teken werpt een uitsnede buiten het bereik geen IndexError op.

Kies een stapgrootte

De derde plaats in text[start:stop:step] bepaalt hoe ver je tussen geselecteerde posities opschuift:

letters = "abcdefgh"
print(letters[::2])   # aceg
print(letters[1::2])  # bdfh
print(letters[::-1])  # hgfedcba

Een negatieve stapgrootte loopt achteruit. Als beide grenzen zijn weggelaten, begint [::-1] bij het laatste teken en doorloopt het alle tekens in omgekeerde volgorde. Een stapgrootte van nul werpt een ValueError op. De richting moet passen bij de grenzen: de regel hierboven dat een startwaarde op of voorbij de eindgrens een leeg resultaat geeft, geldt voor een positieve stapgrootte.

Pas uitsneden toe op een vaste indeling

d = "2026-07-04"
year = d[:4]
month = d[5:7]
day = d[8:10]
print(month + "/" + day + "/" + year)  # 07/04/2026

De posities werken omdat deze indeling altijd vier cijfers voor het jaar en twee voor de maand en dag gebruikt. Tekst met wisselende veldlengtes moet je doorzoeken of splitsen.

Omkering levert ook een palindroomtest op: word == word[::-1]. "level" voldoet, maar "Level" niet, omdat hoofdletters en kleine letters meetellen. Ken clean = word.lower() toe en toets clean == clean[::-1] om hoofdletters en kleine letters buiten beschouwing te laten.

Gebruik een lus wanneer over elk teken een beslissing moet worden genomen. De lus kan overeenkomsten tellen, hun posities gebruiken, bij de eerste overeenkomst stoppen of de tekens verzamelen die in een resultaat thuishoren.

Doorloop tekens rechtstreeks

for ch in "hi!":
    print(ch)

De lusinhoud wordt drie keer uitgevoerd, met ch achtereenvolgens gelijk aan "h", "i" en "!". Bij de lege string wordt de lusinhoud nul keer uitgevoerd. Een lus die de tekens rechtstreeks doorloopt, heeft geen index nodig als je alleen het huidige teken gebruikt.

Initialiseer voor een telling de teller vóór de lus en verhoog die alleen als het teken aan de voorwaarde voldoet:

text = "Programming in Python"
count = 0
for ch in text.lower():
    if ch in "aeiou":
        count += 1
print(count)  # 5

Door alles naar kleine letters om te zetten, voldoen ook klinkers in hoofdletters aan de voorwaarde. De teststring bepaalt welke klinkers worden geteld; y staat er niet in. Als je count binnen de lus opnieuw op nul zou zetten, zou het totaal van eerdere iteraties verloren gaan.

Gebruik posities als naburige tekens van belang zijn

range(len(text)) levert de indexen van nul tot en met de laatste geldige index. Voor een taak waarvoor je zowel de positie als het teken nodig hebt, levert enumerate(text) ze samen:

for i, ch in enumerate("abc"):
    print(i, ch)

Dit drukt 0 a, daarna 1 b en vervolgens 2 c af. De twee lusvariabelen krijgen de index en het teken van elk paar.

Om buren te vergelijken, kan de laatste index niet de huidige positie zijn, omdat er geen volgend teken is:

text = "bookkeeper"
pairs = 0
for i in range(len(text) - 1):
    if text[i] == text[i + 1]:
        pairs += 1
print(pairs)  # 3

De overeenkomsten zijn oo, kk en ee. Met range(len(text)) zou de laatste iteratie text[len(text)] proberen en een IndexError opwerpen.

Houd een positie bij met while

i = 0
while i < len(text):
    print(text[i])
    i += 1

De voorwaarde gebruikt strikt <: positie len(text) ligt voorbij het einde. De verhoging brengt de lus dichter bij het einde; als je die weglaat, blijft de lus bij niet-lege tekst eindeloos hetzelfde teken lezen. Om achteruit te lopen, begin je bij len(text) - 1, ga je door zolang i >= 0 en trek je er bij elke iteratie één van af.

Zoek of verzamel

Stop bij het eerste cijfer in "Room 42B" zodra een overeenkomst is gebruikt:

for ch in "Room 42B":
    if ch.isdigit():
        print(ch)  # 4
        break

Zonder break zouden beide cijfers worden afgedrukt. Voor een eenvoudige aanwezigheidscontrole geeft "4" in text al ja of nee als antwoord.

Om tekst te verzamelen, begin je met result = "" en voeg je elk gewenst teken toe. Voor "a b c" bouw je "abc" op door alleen toe te voegen als ch != " ". De toekenning ch = ch.upper() binnen een lus verandert alleen de lusvariabele; ze verandert niet de tekens die in text zijn opgeslagen.

Strings zijn onwijzigbaar: hun tekens kunnen niet worden veranderd nadat de string bestaat. Een programma dat tekst lijkt te wijzigen, maakt een andere string en kiest welke variabele daarnaar verwijst.

Lees een teken, maar ken er niets aan toe

name = "Jane"
name[0] = "D"  # TypeError

Met de index kun je "J" lezen, maar je kunt er geen waarde aan toekennen. Ook del name[0] werpt een TypeError op. Om "Dane" te krijgen, combineer je het gewenste eerste teken met het ongewijzigde einde:

name = "Jane"
name = "D" + name[1:]
print(name)  # Dane

Python evalueert eerst de rechterkant en maakt daarbij een nieuwe string. Daarna laat Python name naar dat resultaat verwijzen.

Vervang of voeg in op een bekende positie

Voor een geldige niet-negatieve index i gebruiken deze expressies verschillende uitsneden aan de rechterkant:

Bij vervanging wordt het oude teken overgeslagen; bij invoeging blijft het behouden. Met text = "cat", i = 1 en new = "X" geeft vervanging "cXt", terwijl invoeging "cXat" geeft.

Zet een negatieve index om naar de niet-negatieve tegenhanger voordat je dit vervangingspatroon gebruikt. Voor het laatste teken van "cat" is i = len(text) - 1 gelijk aan 2. Als je -1 rechtstreeks in text[i + 1:] invult, wordt dat text[0:]. Daardoor wordt de volledige oude string toegevoegd en krijg je "caXcat".

Bewaar het resultaat van een methode

Bewerkingsmethoden volgen dezelfde regel van onwijzigbaarheid:

msg = "hello"
msg.upper()
print(msg)       # hello
msg = msg.upper()
print(msg)       # HELLO

De eerste aanroep berekent een resultaat dat het programma weggooit. De toekenning bewaart het tweede resultaat. Stringmethoden wijzigen de oorspronkelijke string nooit, maar hun retourtypen verschillen: upper() geeft een string terug, find() een geheel getal en isdigit() een booleaanse waarde.

Volg twee namen voor één waarde

Na a = "cat" en b = a verwijzen beide variabelen naar "cat". De uitvoering van a = a + "s" geeft a de nieuwe waarde "cats"; b verwijst nog steeds naar "cat". Geen enkel teken in de gedeelde oude string is veranderd. a += "s" voert voor een string dezelfde soort hernieuwde toekenning uit.

Bouw een gewijzigde waarde op in een lus

word = "secret"
masked = ""
for ch in word:
    if ch in "aeiou":
        masked += "*"
    else:
        masked += ch
print(masked)  # s*cr*t
print(word)    # secret

Elke iteratie breidt masked uit met één gekozen teken. Als je in plaats daarvan elk teken vooraan zet met result = ch + result, wordt de tekst omgekeerd: de iteraties over "drawer" bouwen "d", "rd", "ard", "ward", "eward" en "reward" op.

Herhaalde concatenatie is handig voor korte voorbeelden. Als delen al in een lijst staan, bouwt "".join(pieces) rechtstreeks één resultaat op en kan het ook scheidingstekst tussen de delen plaatsen.

Een methode is een functie die aan een waarde is verbonden. Stringmethoden voeren veelvoorkomende taken uit, zoals hoofdletters en kleine letters wijzigen, invoer aan de randen opschonen en tekst vervangen. Elke aanroep geeft een resultaat terug en laat de oorspronkelijke string ongewijzigd.

Roep een methode aan met puntnotatie

Schrijf value.method(arguments), zoals in "hello".upper(). De ronde haakjes zorgen ervoor dat de aanroep wordt uitgevoerd. name.upper zonder haakjes verwijst naar de methode zelf; het levert geen tekst in hoofdletters op. Met upper(name) wordt geen zelfstandige functie met de naam upper gevonden. Gebruik dir("") om stringmethoden te tonen en help(str.upper) om over een methode te lezen.

Kies een bewerking voor hoofdletters en kleine letters

capitalize() wijzigt het eerste teken en zet de rest om in kleine letters; title() begint opnieuw met woorden na tekens die geen letters zijn. Daardoor wordt "they're".title() gelijk aan "They'Re", dus automatisch hoofdletters plaatsen in titels moet je soms controleren.

Voor vergelijkingen zonder onderscheid tussen hoofdletters en kleine letters verwerkt casefold() meer gevallen in verschillende talen dan lower(). "Straße".lower() is "straße", terwijl "Straße".casefold() gelijk is aan "strasse". Pas hoofdletternormalisatie toe op beide strings voordat je ze vergelijkt.

Schoon de uiteinden van tekst op

strip() verwijdert witruimte aan het begin en einde, waaronder spaties, tabs en regeleinden. De spatiëring binnen de tekst blijft behouden: " New York \n".strip() is "New York". lstrip() schoont alleen het linkeruiteinde op; rstrip() alleen het rechteruiteinde.

Met een argument verwijdert de methode de opgegeven tekens herhaaldelijk van de uiteinden. Ze verwijdert geen exact woord:

print("...Wow!!!".strip(".!"))          # Wow
print("report.txt".rstrip(".txt"))     # repor
print("report.txt".removesuffix(".txt"))  # report

De laatste t in report behoort ook tot de verzameling te verwijderen tekens en verdwijnt dus. removeprefix() en removesuffix() verwijderen exacte tekst aan een uiteinde; ze zijn beschikbaar in Python 3.9 en later.

Vervang overeenkomsten en schakel bewerkingen aaneen

replace(old, new) vervangt elke exacte overeenkomst. Een derde argument beperkt hoeveel overeenkomsten worden gewijzigd: "a-b-c".replace("-", "", 1) geeft "ab-c". Een lege vervanging verwijdert overeenkomsten. Hoofdletters en kleine letters tellen mee, dus "Cat cat".replace("cat", "dog") geeft "Cat dog".

answer = "  YES \n"
answer = answer.strip().lower()
print(answer == "yes")  # True

De aanroepen worden van links naar rechts uitgevoerd: strip() geeft "YES" terug, daarna geeft lower() "yes" terug. Een keten werkt als de volgende methode past bij het type van het vorige resultaat. Een zoekresultaat is een geheel getal en ondersteunt dus geen methoden voor het opschonen van strings.

Voor opvulling geeft "7".zfill(3) de string "007", voegt "Total".ljust(8) rechts drie spaties toe en geeft "Hi".center(8, "*") de string "***Hi***". rjust() vult links op. Deze breedtes zijn minima; langere tekst blijft volledig behouden.

Zoeken kan drie verschillende vragen beantwoorden: of tekst voorkomt, waar die begint en hoe vaak die voorkomt. Kies het resultaat dat past bij de beslissing die je programma moet nemen.

Kies een zoekresultaat

Een deelstring is een aaneengesloten reeks tekens. "py" in "happy" is True, maar "hpy" in "happy" is False. De overeenkomst is hoofdlettergevoelig: "Py" in "python" is False. not in keert de aanwezigheidscontrole om. De lege string komt in elke string voor.

Vind het juiste voorkomen

text = "banana"
print(text.find("an"))     # 1
print(text.find("an", 2))  # 3
print(text.rfind("an"))    # 3

De optionele startpositie slaat eerdere mogelijkheden over. De teruggegeven index telt nog steeds vanaf het begin van de volledige string. index() geeft dezelfde positie terug als er een overeenkomst is, maar de fout bij een ontbrekende overeenkomst maakt de methode nuttig als afwezigheid wijst op een onverwacht probleem.

Controleer een positie voordat je een uitsnede maakt

email = "maria.lopez@example.org"
at = email.find("@")
if at != -1:
    user = email[:at]
    domain = email[at + 1:]
    print(user)    # maria.lopez
    print(domain)  # example.org

De zoekactie geeft 11 terug. De eerste uitsnede stopt vóór @; de tweede begint één teken erna. Als de markering zou ontbreken, zou at gelijk zijn aan -1. Als je dat als uitsnedegrens gebruikt, wordt ongemerkt tekst aan het einde geselecteerd. Handel een ontbrekende markering daarom af voordat je delen selecteert.

Gebruik if text.find("x"): niet als aanwezigheidscontrole. Een overeenkomst op index 0 geldt als onwaar in een voorwaarde, terwijl de waarde -1 voor een ontbrekend resultaat als waar geldt. Gebruik if "x" in text: of vergelijk de positie expliciet met -1.

Zoek vanaf een bekende markering

Voor line = "Order #4521 shipped" volgt het getal op # en eindigt het bij de volgende spatie:

start = line.find("#") + 1
end = line.find(" ", start)
number = line[start:end]
print(number)  # 4521

Hier zijn beide markeringen aanwezig. Door de tweede zoekactie bij start te beginnen, sla je de eerdere spatie na Order over. Als markeringen kunnen ontbreken, controleer dan elk onbewerkt zoekresultaat voordat je er één bij optelt of een uitsnede maakt; één optellen bij -1 zou de mislukte zoekactie verhullen door er 0 van te maken.

Tel volledige overeenkomsten

"banana".count("a") is 3 en "banana".count("ana") is 1. De twee mogelijke overeenkomsten met ana overlappen, dus count() telt ze niet allebei. Evenzo is "aaaa".count("aa") gelijk aan 2.

Om hoofdletters en kleine letters buiten beschouwing te laten, zoek je in een omgezette versie, zoals "python" in sentence.lower(). De zoekactie zoekt nog steeds naar een exacte overeenkomst binnen die versie. Voor tellingen en aanwezigheidscontroles kun je de omgezette string rechtstreeks gebruiken; een index hoort bij de specifieke string die is doorzocht.

Stringcontroles geven booleaanse waarden terug die een voorwaarde kunnen sturen. Ze helpen je invoer te accepteren die aan een regel voldoet en tekst in een consistente vorm te vergelijken.

Controleer de uiteinden of de tekens

startswith() en endswith() controleren exacte tekst aan de uiteinden. Met een tuple kan één controle meerdere eindstukken accepteren: name.endswith((".jpg", ".png")). De hoofdletters in "photo.PNG" zorgen ervoor dat die naam niet aan de controle voldoet, tenzij je hem eerst naar kleine letters omzet.

Alle vijf geven False terug voor "". Letters hoeven niet Engels te zijn: "café".isalpha() is True. Door de spatie in "hello world" is isalpha() onwaar.

isupper() en islower() kijken naar tekens met een hoofdletter- en kleinelettervariant en vereisen er minstens één. "ABC1".isupper() is True; het cijfer verandert niets aan de hoofdletters. "123" heeft geen tekens met een hoofdletter- en kleinelettervariant, dus beide controles zijn onwaar.

Valideer vóór conversie

Een cijfercontrole beschrijft niet elk getal dat Python kan lezen. "-5".isdigit(), "3.5".isdigit() en " 42".isdigit() zijn onwaar omdat een plus- of minteken, punt of spatie geen cijfer is. Ook "²".isdigit() is waar, hoewel int("²") mislukt. isdecimal() wijst dat bovenschrift af en is geschikt voor invoer van een gewoon niet-negatief geheel getal.

text = input("Tickets: ").strip()
if text.isdecimal() and int(text) > 0:
    print("Accepted")
else:
    print("Enter a positive whole number")

De stringcontrole wordt eerst uitgevoerd. Als die onwaar is, slaat and de conversie over, zodat lege of niet-numerieke invoer veilig wordt afgehandeld. " 12 " wordt "12" en voldoet; "0" wordt veilig omgezet, maar voldoet niet aan de controle op een positieve waarde. Deze regel wijst invoer met een plus- of minteken of decimale punt bewust af.

Een regel voor gebruikersnamen kan lengte- en tekencontroles combineren: 3 <= len(name) <= 12 and name.isalnum(). "ada99" voldoet, "ada 99" voldoet niet aan de tekencontrole en "ad" voldoet niet aan de lengtecontrole.

Vergelijk opgeschoonde tekst

Voor gelijkheid zijn dezelfde tekens in dezelfde volgorde nodig. "Yes" == "yes" en "yes " == "yes" zijn onwaar. Voor antwoorden waarbij hoofdletters, kleine letters en witruimte aan de uiteinden geen rol mogen spelen, vergelijk je typed.strip().casefold() met expected.strip().casefold().

Ordening werkt teken voor teken. Het eerste verschillende Unicodecodepunt is beslissend. ord("A") is 65, ord("Z") is 90 en ord("a") is 97; chr(97) geeft "a". Dus "Zebra" < "apple" is waar. Als de ene string een voorvoegsel van de andere is, komt de kortere eerst: "app" < "apple".

Strings met cijfers gebruiken ook tekenvolgorde: "10" < "9" is waar omdat "1" vóór "9" komt. Zet ze om in getallen wanneer je hoeveelheden vergelijkt. Ook bij letters met een accent moet je opletten: ord("é") is 233, dus "école" > "zoo" is waar. Deze ingebouwde volgorde volgt codepunten, niet de woordenboekvolgorde van een taal.

split() zet één string om in een lijst met strings. Een lijst is een geordende collectie tussen vierkante haakjes. Je kunt een element via een index lezen, de elementen met een lus doorlopen of ze tellen met len().

Kies witruimte of een exacte scheidingstekst

Zonder argument behandelt split() een reeks witruimte als één grens en negeert het witruimte aan beide uiteinden:

words = "  the quick  brown fox ".split()
print(words)       # ['the', 'quick', 'brown', 'fox']
print(len(words))  # 4
print(words[0])    # the

Met expliciete scheidingstekst wordt bij elk exact voorkomen gesplitst. Opeenvolgende scheidingsteksten behouden een leeg veld:

fields = "red,green,,blue".split(",")
# ["red", "green", "", "blue"]

Het lege derde element kan een waarde voorstellen die is opengelaten. Het telt nog steeds als een element in de lijst.

Scheidingstekst kan meerdere tekens bevatten, maar die moeten allemaal overeenkomen. Als er geen scheidingstekst voorkomt, bevat het resultaat de volledige oorspronkelijke string als één element. Splitsen op een komma met spatie verschilt daarom van splitsen op een komma.

Beperk hoeveel tekst wordt gesplitst

Het tweede argument, maxsplit, beperkt het aantal splitsingen, niet het aantal elementen dat ontstaat:

print("key=value=more".split("=", 1))
# ["key", "value=more"]
print("archive.tar.gz".rsplit(".", 1))
# ["archive.tar", "gz"]

split() begint links; rsplit() begint rechts. Eén splitsing vanaf rechts scheidt de laatste bestandsextensie zonder bij eerdere punten te splitsen.

Lees velden en zet hoeveelheden om

line = "Lovelace,Ada,1815"
parts = line.split(",")
if len(parts) == 3:
    last = parts[0]
    first = parts[1]
    year = int(parts[2])
    print(f"{first} {last} was born in {year}.")

De uitvoer is "Ada Lovelace was born in 1815.". De lengtecontrole voorkomt dat een ontbrekend element een IndexError veroorzaakt. Ze controleert niet of het jaar numeriek is; daarvoor is een aparte invoerregel nodig als de gegevens ongeldig kunnen zijn.

Elk afgesplitst deel is aanvankelijk een string. Om "3 14 15" op te tellen, initialiseer je total = 0, doorloop je line.split() met een lus en tel je int(part) erbij op. Het resultaat is 32; als je de niet-omgezette delen aaneenvoegt, worden de cijfers samengevoegd.

Expliciete scheidingstekst behoudt omringende spaties. "a, b".split(",") geeft ["a", " b"]. Roep strip() aan op elk deel als die spaties ongewenst zijn.

Herken twee verwante resultaten

splitlines() splitst bij regelafbrekingen: "line one\nline two".splitlines() geeft twee strings. partition("=") geeft altijd een tuple met drie delen terug: de tekst vóór de eerste scheidingstekst, de scheidingstekst en de tekst erna. "user=ada".partition("=") geeft ("user", "=", "ada"); met "user" geeft het ("user", "", "").

join() bouwt één string op uit een sequentie van strings. De string vóór de punt levert de scheidingstekst, die tussen aangrenzende elementen verschijnt.

Zet de scheidingstekst vooraan

colors = ["red", "green", "blue"]
text = ", ".join(colors)
print(text)  # red, green, blue

Lees dit als “gebruik een komma en spatie om de kleuren samen te voegen”. Er staat geen scheidingstekst vóór het eerste element of na het laatste. Je kunt de indeling van de uitvoer wijzigen door alleen de scheidingstekst te wijzigen:

join() hoort bij de string met scheidingstekst. Als je ["a", "b"].join(",") schrijft, krijg je een AttributeError, omdat de lijst geen methode join heeft. Eén aanroep past zich ook aan het aantal delen aan; je hoeft niet voor elke andere lijstlengte een nieuwe keten van +-bewerkingen te schrijven.

Zet delen die geen string zijn eerst om

Alle delen moeten al strings zijn. ", ".join([1, 2, 3]) werpt een TypeError op. map(str, items) past str() op elk element toe, dus dit werkt:

items = [1, 2, 3]
text = " ".join(map(str, items))
print(text)  # 1 2 3

De str die aan map() wordt doorgegeven, is de conversiefunctie. join() ontvangt de omgezette delen en geeft één string terug.

Een string is zelf een sequentie van strings van één teken, dus " ".join("ABC") geeft "A B C". Dit kan handig zijn, maar als je één woord doorgeeft terwijl je een lijst met woorden bedoelde, komen er scheidingstekens tussen de tekens.

Pas spatiëring en scheidingstekst aan

text = "too   many    spaces"
cleaned = " ".join(text.split())
print(cleaned)  # too many spaces

Eerst levert splitsen op witruimte de drie woorden op. Door ze met één spatie samen te voegen, kies je een vaste tussenruimte en blijven er geen spaties aan de uiteinden over. De oorspronkelijke spatiëring gaat bij het splitsen verloren.

Met expliciete scheidingstekst bewaren de lege velden genoeg informatie om de exacte tekst weer op te bouwen. Als s = "a,,b,", geeft s.split(",") de lijst ["a", "", "b", ""] en geeft ",".join(...) weer "a,,b,". Voor die exacte reconstructie moet de scheidingstekst dezelfde zijn.

Als je de scheidingstekst verandert, verandert de indeling: "-".join("2026/07/04".split("/")) geeft "2026-07-04". Hier is replace("/", "-") ook een directe oplossing.

Verzamel een kort resultaat uit woorden

Voor een letterwoord splits je "portable network graphics", begin je met acronym = "" en voeg je voor elk woord word[0].upper() toe. Splitsen op witruimte levert niet-lege woorden op, dus hun eerste tekens bestaan. Zo bouw je "PNG" op. Als de letters al in een lijst staan, bouwt ".".join(["P", "N", "G"]) de string "P.N.G" op, zonder afsluitende punt.

Een f-string is een stringliteral met f of F vóór het openingsaanhalingsteken. Daarin bevatten accolades expressies waarvan de waarden in de tekst worden ingevoegd.

Voeg variabelen en expressies in

name = "Ada"
age = 36
message = f"{name} is {age} years old."
print(message)  # Ada is 36 years old.

Getallen worden binnen een veld automatisch tekst. Hetzelfde bericht zou concatenatie en str(age) kunnen gebruiken, maar de f-string houdt de uiteindelijke indeling op één plaats zichtbaar.

De accolades kunnen rekenkundige expressies, methodeaanroepen of functieaanroepen bevatten:

price = 4.5
qty = 3
print(f"Cost: {price * qty}")  # Cost: 13.5
print(f"Name: {name.upper()}")  # Name: ADA
word = "Python"
print(f"{len(word)} letters")  # 6 letters

Python evalueert elke expressie wanneer de regel wordt uitgevoerd. Een opgeslagen string blijft niet verbonden met de variabelen waarmee die is opgebouwd. Als qty verandert nadat message is opgebouwd, behoudt die string zijn bestaande tekens.

Maak onderscheid tussen gewone tekst en velden

Zonder het voorvoegsel is "Hello {name}" gewone tekst en behoudt die de accolades. Een ontbrekende f is een veelvoorkomende reden dat een programma de variabelenaam afdrukt in plaats van de waarde. Met het voorvoegsel werpt een naam waaraan geen waarde is toegekend een NameError op wanneer de expressie wordt uitgevoerd.

Om een letterlijke accolade weer te geven, verdubbel je die:

x = 5
print(f"{{x}} = {x}")  # {x} = 5

De dubbele accolades leveren de letterlijke tekst {x}. Het enkele paar rond de laatste x levert de waarde ervan.

Houd expressies met aanhalingstekens goed leesbaar

Gebruik binnen een veld de andere soort aanhalingstekens:

print(f"Shout: {'hi'.upper()}")  # Shout: HI

Deze stijl werkt in alle Pythonversies met f-strings, die in 3.6 werden ingevoerd. Python 3.12 en later staan ook toe om binnen het veld de buitenste soort aanhalingstekens opnieuw te gebruiken. Escapesequenties blijven werken in f-strings: f"Name: {name}\nAge: {age}" drukt af op twee regels.

Voor een snelle weergave tijdens het debuggen accepteren Python 3.8 en later = achter een expressie. Met x = 5 geeft f"{x=}" de string "x=5"; met total = 12 geeft f"{total = }" de string "total = 12". Getypte spaties rond de expressie en het gelijkteken verschijnen in de weergave.

Lees oudere opmaakstijlen

Bestaande Pythoncode kan dezelfde tekst op andere manieren opbouwen:

str.format() vult velden tussen accolades met de argumenten. Genummerde velden kunnen een argument opnieuw gebruiken: "{0} {1} {0}".format("a", "b") geeft "a b a". Bij procentopmaak voegt %s tekst in en %d een geheel getal. Als je die velden herkent, kun je een programma ook lezen wanneer het is geschreven voordat f-strings gebruikelijk waren.

Een opmaakspecificatie bepaalt hoe een waarde wordt weergegeven. Zet een dubbele punt achter de expressie, gevolgd door de aanwijzingen: f"{value:spec}". Opmaak geeft tekst terug en laat de oorspronkelijke numerieke waarde ongewijzigd.

Stel decimalen in en begrijp afronding

.Nf toont precies N cijfers na de decimale punt. f"{3.14159:.2f}" geeft "3.14", f"{2/3:.3f}" geeft "0.667" en f"{5:.2f}" geeft "5.00". .0f toont geen decimale punt: f"{7.6:.0f}" geeft "8".

Bij afronding wordt de daadwerkelijk opgeslagen waarde gebruikt. De meeste decimale breuken zijn zeer nauwkeurige binaire benaderingen. Het zwevendekommagetal 2.675 ligt iets onder die exacte decimale waarde, dus f"{2.675:.2f}" geeft "2.67". Waarden die precies halverwege liggen, worden afgerond op een even laatste cijfer: 0.125 wordt met twee decimalen weergegeven als "0.12", terwijl 0.375 wordt weergegeven als "0.38". f"{2.5:.0f}" geeft "2". Programma’s die exact met geld moeten rekenen, slaan hele centen vaak op als gehele getallen.

Voeg groepering en percentages toe

Een komma groepeert duizendtallen; de punt leidt de precisie voor decimalen in. Houd voor een bedrag in dollars het dollarteken buiten het veld: met amount = 1250.5 geeft f"${amount:,.2f}" de string "$1,250.50".

Het type % vermenigvuldigt met 100 en voegt % toe. Gebruik een breuk zoals 0.256 om 25.6% weer te geven. Als je 25.6 opgeeft, wordt het weergegeven percentage opnieuw vermenigvuldigd. Zonder expliciete precisie toont % zes decimalen.

Maak gehele getallen en datumdelen op

d is voor gehele getallen. f"{42:d}" werkt, maar f"{3.0:d}" werpt een ValueError op omdat een zwevendekommagetal geen geheel getal is. Een voorloopnul vóór een breedte vult op met nullen; een plusteken vraagt om een zichtbaar plus- of minteken:

print(f"{7:03d}")   # 007
print(f"{5:+d}")    # +5
print(f"{-5:+d}")   # -5

Voor maand 7, dag 4 en jaar 2026 bouwt f"{month:02d}/{day:02d}/{year}" de string "07/04/2026" op. Voor uur 9 en minuut 5 bouwt f"{hour}:{minute:02d}" de string "9:05" op. De voorloopnul voorkomt dat een minuut van één cijfer verschijnt als "9:5".

Combineer aanwijzingen in de juiste volgorde

De volgorde is opvulteken, uitlijning, plus- of minteken, nul, breedte, groepering, precisie, type. Je kunt onderdelen die je niet nodig hebt weglaten. f"{12345.678:>12,.2f}" gebruikt uitlijning rechts, breedte 12, groepering met een komma en twee decimalen, en geeft " 12,345.68".

De precisie kan uit een andere variabele komen: met places = 3 geeft f"{3.14159:.{places}f}" de string "3.142". Dezelfde specificaties werken in velden van format(value, spec) en str.format(). Bewaar het oorspronkelijke getal voor berekeningen; round(value, 2) geeft een afgerond getal terug wanneer de berekening dat nodig heeft.

Een veldbreedte reserveert een minimaal aantal tekenposities voor een waarde. Door breedtes te combineren maak je korte tabellen en kassabonnen leesbaar in een terminal.

Kies breedte en uitlijning

Strings worden standaard links uitgelijnd en getallen rechts. f"{'cat':6}" geeft "cat ", terwijl f"{42:6}" de string " 42" geeft. Gebruik een uitlijningsteken om expliciet te kiezen:

Wanneer centreren een oneven aantal spaties overlaat, plaatst de uitlijning van f-strings de extra spatie rechts: f"{'hi':^7}" geeft " hi ".

De breedte is een minimum. f"{'elephant':4}" geeft nog steeds "elephant"; het woord wordt niet afgekapt. Een lang element kan daardoor latere kolommen uit de lijn duwen.

Voeg een opvulteken toe of beperk tekst

Een opvulteken staat direct vóór de uitlijning. f"{'hi':*^10}" geeft "****hi****" en f"{7:0>3}" geeft "007". Opvulling vereist een uitlijningsteken. f"{'':-^20}" vult een leeg veld met twintig streepjes.

De precisie van een string beperkt het aantal weergegeven tekens:

place = "Washington"
print(f"{place:.4}")      # Wash
print(f"|{place:10.4}|")  # |Wash      |

De precisie beperkt de weergegeven tekst eerst tot vier tekens; de breedte vult die vervolgens op tot tien. Gebruik een passende breedte en precisie als tekst binnen een vaste kolom moet blijven. De oorspronkelijke place is nog steeds "Washington".

Bouw één regel van een kassabon op

item = "Apples"
qty = 3
price = 4.50
row = f"{item:<8}{qty:>4}{qty * price:>9.2f}"
print(row)

Het resultaat is "Apples 3 13.50". Het artikelveld heeft zes letters en twee spaties. Het hoeveelheidsveld voegt drie spaties toe vóór 3. Het kostenveld voegt vier spaties toe vóór 13.50, dat vijf tekens heeft. Samen nemen de velden 21 tekens in.

Gebruik die breedtes opnieuw voor brood (1 à 2,25) en koffie (2 à 11,00). Hun regels zijn "Bread 1 2.25" en "Coffee 2 22.00". Een totaalregel kan de eerste twee velden combineren:

print(f"{'Total':<12}{37.75:>9.2f}")
# "Total           37.75"

Het kostenveld begint op dezelfde positie en heeft dezelfde precisie voor decimalen, zodat de bedragen onder elkaar staan.

Stem de indeling af op de weergave

Kies breedtes die ruimte laten voor de langste elementen en tussenruimte, of kort tekst bewust in. Een variabele kan een breedte leveren: met w = 10 vult f"{name:<{w}}" name op tot tien tekens.

Kolommen op basis van tekens hebben een lettertype met vaste tekenbreedte nodig, zoals een terminal gebruikt. Voor gewone opvulling buiten een f-string gedragen ljust() en rjust() zich als < en >. center() en ^ centreren allebei tekst, maar kunnen oneven opvulling anders verdelen: "hi".center(7) geeft " hi ", terwijl f"{'hi':^7}" de string " hi " geeft.