2.5. Stringmethoden en opmaak

Strings worden geleverd met een ingebouwde gereedschapskist aan methoden voor inspectie en hervormgeving. Omdat strings onveranderlijk zijn, retourneert elke methode een nieuwe string – het origineel blijft ongewijzigd.

2.5.1. Strings inspecteren

  • str.startswith() / str.endswith() – test op voor- of achtervoegsel; retourneert een bool.

  • str.find() – positie van het eerste voorkomen van een substring, of -1 als deze ontbreekt. str.index() doet hetzelfde, maar veroorzaakt een ValueError bij afwezigheid.

  • str.count() – aantal niet-overlappende voorkomens.

  • in-sleutelwoord – "MV" in name retourneert True als de substring ergens in de string voorkomt.

>>> name = "OpenMV Cam"
>>> name.startswith("Open")
True
>>> name.find("MV")
4
>>> name.count("m")
1
>>> "Cam" in name
True

2.5.2. Opschonen en hoofdlettergebruik

  • str.strip() – verwijder witruimte aan begin en einde. Geef een string met tekens door om een aangepaste set te verwijderen (s.strip("/")).

  • str.lower() / str.upper() – hoofdletter-/kleineletterconversie.

  • str.replace() – substringvervanging.

>>> "  hello  ".strip()
'hello'
>>> "abc-123".replace("-", "_")
'abc_123'
>>> "OpenMV".lower()
'openmv'

2.5.3. Splitsen en samenvoegen

  • str.split() – splits een string in een lijst bij elk voorkomen van een scheidingsteken (standaard: elke witruimtereeks).

  • str.join() – het omgekeerde: lijm een reeks strings aan elkaar met de ontvanger als scheidingsteken. Dit is de efficiënte manier om een lange string uit stukken op te bouwen.

>>> "1,2,3".split(",")
['1', '2', '3']
>>> "hello world".split()
['hello', 'world']
>>> ", ".join(["a", "b", "c"])
'a, b, c'

2.5.4. f-strings

De eenvoudigste manier om waarden in een string te interpoleren is de f-string – een stringliteral met het voorvoegsel f. Elke expressie binnen {} wordt geëvalueerd en ingevoegd:

>>> name = "OpenMV"
>>> count = 42
>>> f"{name} saw {count} blobs"
'OpenMV saw 42 blobs'

Een dubbele punt binnen de accolades introduceert een format spec die bepaalt hoe de waarde wordt weergegeven:

  • {x:.2f} – float met 2 cijfers na de komma.

  • {x:>10} – rechts uitlijnen in een veld van 10 tekens.

  • {x:<10} – links uitlijnen.

  • {x:0>4} – opvullen met voorloopnullen tot breedte 4.

  • {x:#x} – hexadecimaal met een 0x-voorvoegsel.

  • {x:b} – binaire weergave.

>>> f"pi is roughly {3.14159:.3f}"
'pi is roughly 3.142'
>>> f"reg = {0xAB:#x}"
'reg = 0xab'
>>> for i in range(3):
...     print(f"line {i:0>3}")
line 000
line 001
line 002

Een enkele = na de expressienaam print zowel de naam als de waarde – handig voor snelle debug-prints:

>>> v = 3.14
>>> print(f"{v=}")
v=3.14

2.5.4.1. Integer-basisconversies

Drie ingebouwde functies doen hetzelfde werk als de format specs :b / :o / :x, maar retourneren de geconverteerde string direct:

  • bin() – grondtal 2, met een "0b"-voorvoegsel.

  • oct() – grondtal 8, met een "0o"-voorvoegsel.

  • hex() – grondtal 16, met een "0x"-voorvoegsel.

>>> hex(255)
'0xff'
>>> bin(10)
'0b1010'
>>> oct(8)
'0o10'

De omgekeerde richting – een grondtal-N-string terugzetten naar een integer – gebruikt de int-constructor met een expliciet grondtal:

>>> int("ff", 16)
255
>>> int("0b1010", 2)         # the "0b" prefix is allowed
10

Grijp hiernaar wanneer je de ruwe string voor een int wilt (voor een logregel, een configuratiebestand, een registerdump). Grijp naar de format spec wanneer je opvulling, breedte wilt, of de waarde met andere tekst in dezelfde f-string wilt mengen.

2.5.5. Oudere opmaakstijlen

f-strings zijn de aanbevolen stijl, maar twee oudere benaderingen werken nog steeds en komen voor in bestaande code:

str.format() – accolades met positionele of trefwoordargumenten die aan de .format()-methode op een sjabloonstring worden doorgegeven:

>>> "Hello, {}".format(name)
'Hello, OpenMV'
>>> "{0} + {0} = {1}".format(2, 4)
'2 + 2 = 4'
>>> "{name}: {value}".format(name="frames", value=42)
'frames: 42'

Format specs ({:.2f}, {:>10}, …) werken hetzelfde als in f-strings; het enige verschil is waar de waarde wordt geleverd.

%-opmaak (printf-stijl) – een enkele %-operator vervangt waarden in opmaakcodes, één waarde per code. Geef meerdere waarden door als een tuple:

>>> "Hello, %s" % name
'Hello, OpenMV'
>>> "%d + %d = %d" % (2, 2, 4)
'2 + 2 = 4'
>>> "%.2f" % 3.14159
'3.14'

De meest voorkomende typecodes zijn %s (string), %d (integer), %f (float) en %x (hex).

Elke %-code kan modificatoren bevatten tussen de % en de typeletter. De volledige vorm is %[flags][width][.precision]type:

  • width – minimaal aantal tekens dat het veld moet innemen. Kortere waarden worden met spaties opgevuld; langere waarden lopen over. %10d reserveert 10 tekens en lijnt het getal rechts uit.

  • precision – de betekenis hangt af van het type. Voor floats is dit het aantal cijfers na de komma. %.2f geeft twee decimalen. Voor strings is dit het maximale aantal tekens dat wordt genomen (%.5s kapt af tot vijf).

  • Links uitlijnen – de --vlag plaatst het veld links. %-10d plaatst de cijfers aan de linkerkant met spaties erachter.

  • Nul-opvulling – de 0-vlag vult op met voorloopnullen in plaats van spaties (voor numerieke typen). %05d vult met nullen op tot vijf cijfers.

  • Teken – de +-vlag toont altijd het teken bij getallen, inclusief een + voor positieve getallen.

  • Alternatieve vorm – de #-vlag. Voor %x voegt dit het voorvoegsel 0x aan de uitvoer toe; voor %o voegt het 0o toe.

Vlaggen, breedte en precisie kunnen worden gecombineerd:

>>> "%10d" % 42
'        42'                 # width 10, space-padded, right-aligned
>>> "%-10d|" % 42
'42        |'                # width 10, left-aligned
>>> "%05d" % 42
'00042'                      # width 5, zero-padded
>>> "%8.2f" % 3.14159
'    3.14'                   # width 8, 2 decimal places
>>> "%08.2f" % 3.14159
'00003.14'                   # width 8, zero-padded
>>> "%+d" % 42
'+42'                        # explicit sign
>>> "%#06x" % 0xAB
'0x00ab'                     # 0x prefix, zero-pad to 6 chars total

Beide oudere stijlen zijn trager te lezen en foutgevoeliger dan f-strings – grijp naar f-strings in nieuwe code en herken de oudere vormen bij het lezen van bestaande code.