2.5. Merkkijonometodit ja muotoilu

Merkkijonoissa on mukana sisäänrakennettu työkalupakki metodeja tarkasteluun ja muokkaamiseen. Koska merkkijonot ovat muuttumattomia, jokainen metodi palauttaa uuden merkkijonon – alkuperäinen säilyy muuttumattomana.

2.5.1. Merkkijonojen tarkastelu

  • str.startswith() / str.endswith() – etu- tai jälkiliitteen testi; palauttaa bool.

  • str.find() – alimerkkijonon ensimmäisen esiintymän sijainti, tai -1 jos sitä ei ole. str.index() tekee saman asian mutta nostaa virheen ValueError puuttuessa.

  • str.count() – limittymättömien esiintymien lukumäärä.

  • in-avainsana – "MV" in name palauttaa True, jos alimerkkijono on missä tahansa kohdassa merkkijonoa.

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

2.5.2. Siistiminen ja kirjainkoko

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

2.5.3. Jakaminen ja yhdistäminen

  • str.split() – pilkkoo merkkijonon listaksi jokaisesta erottimen esiintymästä (oletus: mikä tahansa tyhjemerkkijakso).

  • str.join() – käänteinen toimenpide: liimaa merkkijonojen jakson yhteen käyttäen vastaanottajaa erottimena. Tämä on tehokas tapa rakentaa pitkä merkkijono osista.

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

2.5.4. f-merkkijonot

Yksinkertaisin tapa interpoloida arvoja merkkijonoon on f-merkkijono – merkkijonoliteraali, jonka etuliitteenä on f. Mikä tahansa lauseke merkinnän {} sisällä arvioidaan ja sijoitetaan paikalleen:

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

Kaksoispiste aaltosulkeiden sisällä esittelee muotoilumäärittelyn, joka ohjaa arvon esitystapaa:

  • {x:.2f} – liukuluku, jossa 2 numeroa desimaalipilkun jälkeen.

  • {x:>10} – oikealle tasattuna 10 merkin kenttään.

  • {x:<10} – vasemmalle tasattuna.

  • {x:0>4} – täytetään etunollilla leveyteen 4.

  • {x:#x} – heksadesimaali 0x-etuliitteellä.

  • {x:b} – binääriesitys.

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

Yksittäinen = lausekkeen nimen jälkeen tulostaa sekä nimen että arvon – kätevää nopeisiin virheenkorjaustulostuksiin:

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

2.5.4.1. Kokonaisluvun kantamuunnokset

Kolme sisäänrakennettua funktiota tekevät saman työn kuin muotoilumäärittelyt :b / :o / :x, mutta palauttavat muunnetun merkkijonon suoraan:

  • bin() – 2-kantainen, "0b"-etuliitteellä.

  • oct() – 8-kantainen, "0o"-etuliitteellä.

  • hex() – 16-kantainen, "0x"-etuliitteellä.

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

Käänteinen suunta – N-kantaisen merkkijonon muuntaminen takaisin kokonaisluvuksi – käyttää int -konstruktoria eksplisiittisellä kannalla:

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

Tartu näihin, kun haluat raa’an merkkijonon kokonaisluvulle (lokiriville, asetustiedostoon, rekisterivedokseen). Tartu muotoilumäärittelyyn, kun haluat täytön, leveyden tai sekoittaa arvon muuhun tekstiin samassa f-merkkijonossa.

2.5.5. Vanhemmat muotoilutyylit

f-merkkijonot ovat suositeltu tyyli, mutta kaksi vanhempaa lähestymistapaa toimivat yhä ja esiintyvät olemassa olevassa koodissa:

str.format() – aaltosulkeet, joihin välitetään sijainti- tai avainsana-argumentteja mallimerkkijonon .format()-metodille:

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

Muotoilumäärittelyt ({:.2f}, {:>10}, …) toimivat samalla tavalla kuin f-merkkijonoissa; ainoa ero on se, missä arvo annetaan.

%-muotoilu (printf-tyylinen) – yksittäinen %-operaattori sijoittaa arvoja muotoilukoodeihin, yhden arvon kutakin koodia kohden. Anna useita arvoja monikkona:

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

Yleisimmät tyyppikoodit ovat %s (merkkijono), %d (kokonaisluku), %f (liukuluku) ja %x (heksa).

Jokainen %-koodi voi kantaa määreitä merkin % ja tyyppikirjaimen välissä. Täysi muoto on %[flags][width][.precision]type:

  • width – vähimmäismäärä merkkejä, jotka kentän on otettava. Lyhyemmät arvot täytetään välilyönneillä; pidemmät ylittävät kentän. %10d varaa 10 merkkiä ja tasaa numeron oikealle.

  • precision – merkitys riippuu tyypistä. Liukuluvuilla desimaalipilkun jälkeisten numeroiden määrä. %.2f antaa kaksi desimaalia. Merkkijonoilla otettavien merkkien enimmäismäärä (%.5s katkaisee viiteen).

  • Vasemmalle tasaus – --lippu asettaa kentän vasemmalle. %-10d asettaa numerot vasemmalle puolelle loppupuolen välilyöntien kanssa.

  • Nollatäyttö – 0-lippu täyttää etunollilla välilyöntien sijaan (numerotyypeillä). %05d täyttää nollilla viiteen numeroon.

  • Etumerkki – +-lippu näyttää aina etumerkin numeroissa, mukaan lukien + positiivisille.

  • Vaihtoehtoinen muoto – #-lippu. Koodille %x tämä lisää tulosteeseen etuliitteen 0x; koodille %o se lisää etuliitteen 0o.

Lippuja, leveyttä ja tarkkuutta voi yhdistellä:

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

Molemmat vanhemmat tyylit ovat hitaampia lukea ja virhealttiimpia kuin f-merkkijonot – tartu f-merkkijonoihin uudessa koodissa ja tunnista vanhemmat muodot lukiessasi olemassa olevaa koodia.