2.5. Metody łańcuchów i formatowanie

Łańcuchy mają wbudowany zestaw metod do inspekcji i przekształcania. Ponieważ łańcuchy są niezmienne, każda metoda zwraca nowy łańcuch – oryginał pozostaje nienaruszony.

2.5.1. Inspekcja łańcuchów

  • str.startswith() / str.endswith() – test przedrostka lub przyrostka; zwraca bool.

  • str.find() – pozycja pierwszego wystąpienia podłańcucha lub -1 w razie jego braku. str.index() robi to samo, ale w razie braku zgłasza ValueError.

  • str.count() – liczba nienakładających się wystąpień.

  • Słowo kluczowe in – "MV" in name zwraca True, jeśli podłańcuch znajduje się gdziekolwiek w łańcuchu.

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

2.5.2. Czyszczenie i wielkość liter

  • str.strip() – usuwa wiodące i końcowe białe znaki. Przekaż łańcuch znaków, aby usunąć własny zestaw (s.strip("/")).

  • str.lower() / str.upper() – konwersja wielkości liter.

  • str.replace() – podstawienie podłańcucha.

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

2.5.3. Dzielenie i łączenie

  • str.split() – dzieli łańcuch na listę przy każdym wystąpieniu separatora (domyślnie: dowolny ciąg białych znaków).

  • str.join() – operacja odwrotna: skleja sekwencję łańcuchów, używając obiektu wywołującego jako separatora. To wydajny sposób budowania długiego łańcucha z fragmentów.

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

2.5.4. f-stringi

Najprostszym sposobem wstawienia wartości do łańcucha jest f-string – literał łańcuchowy poprzedzony znakiem f. Dowolne wyrażenie wewnątrz {} jest obliczane i wstawiane:

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

Dwukropek wewnątrz nawiasów klamrowych wprowadza specyfikację formatu, która kontroluje sposób renderowania wartości:

  • {x:.2f} – liczba zmiennoprzecinkowa z 2 cyframi po przecinku.

  • {x:>10} – wyrównanie do prawej w polu o szerokości 10 znaków.

  • {x:<10} – wyrównanie do lewej.

  • {x:0>4} – uzupełnienie wiodącymi zerami do szerokości 4.

  • {x:#x} – liczba szesnastkowa z przedrostkiem 0x.

  • {x:b} – reprezentacja binarna.

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

Pojedynczy znak = po nazwie wyrażenia wypisuje zarówno nazwę, jak i wartość – przydatne przy szybkich wydrukach diagnostycznych:

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

2.5.4.1. Konwersje podstawy liczb całkowitych

Trzy funkcje wbudowane wykonują to samo zadanie co specyfikacje formatu :b / :o / :x, ale zwracają przekonwertowany łańcuch bezpośrednio:

  • bin() – podstawa 2, z przedrostkiem "0b".

  • oct() – podstawa 8, z przedrostkiem "0o".

  • hex() – podstawa 16, z przedrostkiem "0x".

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

Kierunek odwrotny – zamiana łańcucha o podstawie N z powrotem na liczbę całkowitą – korzysta z konstruktora int z jawnie podaną podstawą:

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

Sięgaj po nie, gdy potrzebujesz surowego łańcucha dla liczby całkowitej (do wiersza logu, pliku konfiguracyjnego, zrzutu rejestru). Sięgaj po specyfikację formatu, gdy potrzebujesz dopełnienia, szerokości lub chcesz wymieszać wartość z innym tekstem w tym samym f-stringu.

2.5.5. Starsze style formatowania

f-stringi to zalecany styl, ale dwa starsze podejścia wciąż działają i pojawiają się w istniejącym kodzie:

str.format() – nawiasy klamrowe z argumentami pozycyjnymi lub nazwanymi przekazywanymi do metody .format() na łańcuchu szablonu:

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

Specyfikacje formatu ({:.2f}, {:>10}, …) działają tak samo jak w f-stringach; jedyna różnica polega na tym, gdzie dostarczana jest wartość.

Formatowanie % (w stylu printf) – pojedynczy operator % podstawia wartości do kodów formatu, po jednej wartości na kod. Wiele wartości przekazuj jako krotkę:

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

Najczęstsze kody typów to %s (łańcuch), %d (liczba całkowita), %f (liczba zmiennoprzecinkowa) i %x (szesnastkowa).

Każdy kod % może nieść modyfikatory między % a literą typu. Pełna postać to %[flags][width][.precision]type:

  • width – minimalna liczba znaków, jaką musi zająć pole. Krótsze wartości są uzupełniane spacjami; dłuższe przepełniają pole. %10d rezerwuje 10 znaków i wyrównuje liczbę do prawej.

  • precision – znaczenie zależy od typu. Dla liczb zmiennoprzecinkowych to liczba cyfr po przecinku. %.2f daje dwa miejsca po przecinku. Dla łańcuchów to maksymalna liczba znaków do wzięcia (%.5s skraca do pięciu).

  • Wyrównanie do lewej – flaga - umieszcza pole po lewej stronie. %-10d umieszcza cyfry po lewej stronie z końcowymi spacjami.

  • Uzupełnianie zerami – flaga 0 uzupełnia wiodącymi zerami zamiast spacjami (dla typów liczbowych). %05d uzupełnia zerami do pięciu cyfr.

  • Znak – flaga + zawsze pokazuje znak przy liczbach, w tym + dla liczb dodatnich.

  • Forma alternatywna – flaga #. Dla %x poprzedza ona wynik przedrostkiem 0x; dla %o poprzedza 0o.

Flagi, szerokość i precyzję można łączyć:

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

Oba starsze style są wolniejsze do odczytania i bardziej podatne na błędy niż f-stringi – w nowym kodzie sięgaj po f-stringi, a starsze formy rozpoznawaj podczas czytania istniejącego kodu.