2.5. Metode pentru șiruri și formatare

Șirurile vin cu un set de instrumente încorporat de metode pentru inspecție și remodelare. Deoarece șirurile sunt imutabile, fiecare metodă returnează un șir nou – originalul rămâne neschimbat.

2.5.1. Inspectarea șirurilor

  • str.startswith() / str.endswith() – test de prefix sau sufix; returnează bool.

  • str.find() – poziția primei apariții a unui subșir sau -1 dacă este absent. str.index() face același lucru, dar ridică ValueError în caz de absență.

  • str.count() – numărul de apariții care nu se suprapun.

  • Cuvântul-cheie in – "MV" in name returnează True dacă subșirul se află oriunde în șir.

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

2.5.2. Curățare și majuscule

  • str.strip() – elimină spațierea de la început și de la sfârșit. Transmite un șir de caractere pentru a elimina un set personalizat (s.strip("/")).

  • str.lower() / str.upper() – conversia majusculelor/minusculelor.

  • str.replace() – substituirea unui subșir.

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

2.5.3. Împărțire și unire

  • str.split() – desparte un șir într-o listă la fiecare apariție a unui separator (implicit: orice secvență de spațiere).

  • str.join() – inversul: lipește o secvență de șiruri folosind receptorul ca separator. Aceasta este modalitatea eficientă de a construi un șir lung din bucăți.

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

2.5.4. f-string-uri

Cea mai simplă modalitate de a interpola valori într-un șir este f-string-ul – un literal de șir prefixat cu f. Orice expresie din interiorul lui {} este evaluată și inserată:

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

Două puncte în interiorul acoladelor introduc o specificație de format care controlează modul în care valoarea este redată:

  • {x:.2f} – float cu 2 cifre după punctul zecimal.

  • {x:>10} – aliniere la dreapta într-un câmp de 10 caractere.

  • {x:<10} – aliniere la stânga.

  • {x:0>4} – completare cu zerouri la început până la lățimea 4.

  • {x:#x} – hexazecimal cu un prefix 0x.

  • {x:b} – reprezentare binară.

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

Un singur = după numele expresiei afișează atât numele, cât și valoarea – util pentru afișări rapide de depanare:

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

2.5.4.1. Conversii între baze de numere întregi

Trei funcții încorporate fac aceeași treabă ca specificațiile de format :b / :o / :x, dar returnează direct șirul convertit:

  • bin() – baza 2, cu un prefix "0b".

  • oct() – baza 8, cu un prefix "0o".

  • hex() – baza 16, cu un prefix "0x".

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

Direcția inversă – transformarea unui șir în baza N înapoi într-un număr întreg – folosește constructorul int cu o bază explicită:

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

Apelează la acestea atunci când vrei șirul brut pentru un int (pentru o linie de jurnal, un fișier de configurare, o descărcare de registre). Apelează la specificația de format atunci când vrei completare, lățime sau să amesteci valoarea cu alt text în același f-string.

2.5.5. Stiluri de formatare mai vechi

f-string-urile reprezintă stilul recomandat, dar două abordări mai vechi încă funcționează și apar în codul existent:

str.format() – acolade cu argumente poziționale sau de tip cuvânt-cheie transmise metodei .format() pe un șir-șablon:

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

Specificațiile de format ({:.2f}, {:>10}, …) funcționează la fel ca în f-string-uri; singura diferență este unde este furnizată valoarea.

Formatare % (stil printf) – un singur operator % substituie valori în coduri de format, câte o valoare per cod. Transmite mai multe valori sub formă de tuplu:

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

Cele mai frecvente coduri de tip sunt %s (șir), %d (întreg), %f (float) și %x (hex).

Fiecare cod % poate purta modificatori între % și litera de tip. Forma completă este %[flags][width][.precision]type:

  • width – numărul minim de caractere pe care trebuie să le ocupe câmpul. Valorile mai scurte sunt completate cu spații; valorile mai lungi se revarsă. %10d rezervă 10 caractere și aliniază numărul la dreapta.

  • precision – semnificația depinde de tip. Pentru float-uri, numărul de cifre după punctul zecimal. %.2f oferă două zecimale. Pentru șiruri, numărul maxim de caractere de preluat (%.5s trunchiază la cinci).

  • Aliniere la stânga – indicatorul - plasează câmpul la stânga. %-10d plasează cifrele în partea stângă cu spații în urmă.

  • Completare cu zerouri – indicatorul 0 completează cu zerouri la început în loc de spații (pentru tipuri numerice). %05d completează cu zerouri până la cinci cifre.

  • Semn – indicatorul + afișează întotdeauna semnul pentru numere, inclusiv un + pentru valorile pozitive.

  • Formă alternativă – indicatorul #. Pentru %x acesta prefixează ieșirea cu 0x; pentru %o o prefixează cu 0o.

Indicatorii, lățimea și precizia pot fi combinate:

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

Ambele stiluri mai vechi sunt mai lente de citit și mai predispuse la erori decât f-string-urile – apelează la f-string-uri în codul nou și recunoaște formele mai vechi atunci când citești cod existent.