2.5. Strängmetoder och formatering

Strängar kommer med en inbyggd verktygslåda av metoder för inspektion och omformning. Eftersom strängar är oföränderliga returnerar varje metod en ny sträng – originalet förblir oförändrat.

2.5.1. Inspektera strängar

  • str.startswith() / str.endswith() – test av prefix eller suffix; returnerar bool.

  • str.find() – positionen för den första förekomsten av en delsträng, eller -1 om den saknas. str.index() gör samma sak men ger upphov till ValueError om den saknas.

  • str.count() – antalet icke-överlappande förekomster.

  • Nyckelordet in – "MV" in name returnerar True om delsträngen finns någonstans i strängen.

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

2.5.2. Rensning och skiftläge

  • str.strip() – ta bort inledande och avslutande blanktecken. Skicka en sträng med tecken för att rensa en anpassad uppsättning (s.strip("/")).

  • str.lower() / str.upper() – skiftlägeskonvertering.

  • str.replace() – substitution av delsträng.

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

2.5.3. Uppdelning och sammanfogning

  • str.split() – bryt upp en sträng i en lista vid varje förekomst av en avgränsare (standard: valfri följd av blanktecken).

  • str.join() – inversen: limma ihop en sekvens av strängar med mottagaren som avgränsare. Detta är det effektiva sättet att bygga en lång sträng från delar.

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

2.5.4. f-strängar

Det enklaste sättet att interpolera värden i en sträng är f-strängen – en stränglitteral med prefixet f. Varje uttryck inuti {} utvärderas och infogas:

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

Ett kolon inuti klammerparenteserna inför en formatspecifikation som styr hur värdet återges:

  • {x:.2f} – flyttal med 2 siffror efter decimalkommat.

  • {x:>10} – högerjustera i ett 10 tecken brett fält.

  • {x:<10} – vänsterjustera.

  • {x:0>4} – fyll ut med inledande nollor till bredden 4.

  • {x:#x} – hexadecimalt med ett 0x-prefix.

  • {x:b} – binär representation.

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

Ett enkelt = efter uttrycksnamnet skriver ut både namnet och värdet – praktiskt för snabba felsökningsutskrifter:

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

2.5.4.1. Konvertering av heltalsbas

Tre inbyggda funktioner gör samma jobb som formatspecifikationerna :b / :o / :x men returnerar den konverterade strängen direkt:

  • bin() – bas 2, med ett "0b"-prefix.

  • oct() – bas 8, med ett "0o"-prefix.

  • hex() – bas 16, med ett "0x"-prefix.

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

Den omvända riktningen – att omvandla en bas-N-sträng tillbaka till ett heltal – använder int-konstruktorn med en explicit bas:

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

Ta till dessa när du vill ha den råa strängen för ett heltal (för en loggrad, en konfigurationsfil, en registerdump). Ta till formatspecifikationen när du vill ha utfyllnad, bredd, eller blanda värdet med annan text i samma f-sträng.

2.5.5. Äldre formateringsstilar

f-strängar är den rekommenderade stilen, men två äldre tillvägagångssätt fungerar fortfarande och dyker upp i befintlig kod:

str.format() – klammerparenteser med positions- eller nyckelordsargument som skickas till metoden .format() på en mallsträng:

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

Formatspecifikationer ({:.2f}, {:>10}, …) fungerar på samma sätt som i f-strängar; den enda skillnaden är var värdet tillhandahålls.

%-formatering (printf-stil) – en enda %-operator infogar värden i formatkoder, ett värde per kod. Skicka flera värden som en tupel:

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

De vanligaste typkoderna är %s (sträng), %d (heltal), %f (flyttal) och %x (hex).

Varje %-kod kan bära modifierare mellan % och typbokstaven. Den fullständiga formen är %[flags][width][.precision]type:

  • width – minsta antal tecken som fältet måste ta. Kortare värden fylls ut med mellanslag; längre värden flödar över. %10d reserverar 10 tecken och högerjusterar talet.

  • precision – betydelsen beror på typen. För flyttal antalet siffror efter decimalkommat. %.2f ger två decimaler. För strängar det maximala antalet tecken som tas (%.5s trunkerar till fem).

  • Vänsterjustering – flaggan - placerar fältet till vänster. %-10d placerar siffrorna på vänster sida med efterföljande mellanslag.

  • Nollutfyllnad – flaggan 0 fyller ut med inledande nollor i stället för mellanslag (för numeriska typer). %05d nollfyller till fem siffror.

  • Tecken – flaggan + visar alltid tecknet på tal, inklusive ett + för positiva tal.

  • Alternativ form – flaggan #. För %x prefixar detta utdata med 0x; för %o prefixar det 0o.

Flaggor, bredd och precision kan kombineras:

>>> "%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

Båda de äldre stilarna är långsammare att läsa och mer felbenägna än f-strängar – ta till f-strängar i ny kod, och känn igen de äldre formerna när du läser befintlig kod.