2.5. Методы строк и форматирование

Строки поставляются со встроенным набором методов для проверки и преобразования. Поскольку строки неизменяемы, каждый метод возвращает новую строку — оригинал остаётся неизменным.

2.5.1. Проверка строк

  • str.startswith() / str.endswith() — проверка префикса или суффикса; возвращает bool.

  • str.find() — позиция первого вхождения подстроки или -1, если она отсутствует. str.index() делает то же самое, но вызывает ValueError при отсутствии.

  • str.count() — число неперекрывающихся вхождений.

  • Ключевое слово in — "MV" in name возвращает True, если подстрока находится где-либо в строке.

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

2.5.2. Очистка и регистр

  • str.strip() — удаляет начальные и конечные пробельные символы. Передайте строку символов, чтобы удалить собственный набор (s.strip("/")).

  • str.lower() / str.upper() — преобразование регистра.

  • str.replace() — подстановка подстроки.

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

2.5.3. Разбиение и объединение

  • str.split() — разбивает строку на список при каждом вхождении разделителя (по умолчанию: любая последовательность пробельных символов).

  • str.join() — обратная операция: склеивает последовательность строк вместе, используя получатель в качестве разделителя. Это эффективный способ построить длинную строку из частей.

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

2.5.4. f-строки

Простейший способ подставить значения в строку — это f-строка — строковый литерал с префиксом f. Любое выражение внутри {} вычисляется и вставляется:

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

Двоеточие внутри фигурных скобок вводит спецификацию формата, которая управляет тем, как отображается значение:

  • {x:.2f} — число с плавающей точкой с 2 знаками после запятой.

  • {x:>10} — выравнивание по правому краю в поле шириной 10 символов.

  • {x:<10} — выравнивание по левому краю.

  • {x:0>4} — дополнение ведущими нулями до ширины 4.

  • {x:#x} — шестнадцатеричное число с префиксом 0x.

  • {x:b} — двоичное представление.

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

Одиночный = после имени выражения печатает и имя, и значение — удобно для быстрых отладочных выводов:

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

2.5.4.1. Преобразования целых чисел между системами счисления

Три встроенные функции делают ту же работу, что и спецификации формата :b / :o / :x, но возвращают преобразованную строку напрямую:

  • bin() — основание 2, с префиксом "0b".

  • oct() — основание 8, с префиксом "0o".

  • hex() — основание 16, с префиксом "0x".

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

Обратное направление — превращение строки с основанием N обратно в целое число — использует конструктор int с явным основанием:

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

Обращайтесь к ним, когда вам нужна сырая строка для целого числа (для строки журнала, файла конфигурации, дампа регистра). Обращайтесь к спецификации формата, когда вам нужно дополнение, ширина или смешивание значения с другим текстом в той же f-строке.

2.5.5. Более старые стили форматирования

f-строки — рекомендуемый стиль, но два более старых подхода всё ещё работают и встречаются в существующем коде:

str.format() — фигурные скобки с позиционными или именованными аргументами, передаваемыми методу .format() строки-шаблона:

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

Спецификации формата ({:.2f}, {:>10}, …) работают так же, как в f-строках; единственное отличие — где подаётся значение.

Форматирование % (в стиле printf) — единственный оператор % подставляет значения в коды формата, по одному значению на код. Передавайте несколько значений в виде кортежа:

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

Самые распространённые коды типов — %s (строка), %d (целое число), %f (число с плавающей точкой) и %x (шестнадцатеричное).

Каждый код % может нести модификаторы между % и буквой типа. Полная форма — %[flags][width][.precision]type:

  • width — минимальное число символов, которое должно занимать поле. Более короткие значения дополняются пробелами; более длинные переполняют поле. %10d резервирует 10 символов и выравнивает число по правому краю.

  • precision — смысл зависит от типа. Для чисел с плавающей точкой — число знаков после запятой. %.2f даёт два десятичных знака. Для строк — максимальное число символов для взятия (%.5s усекает до пяти).

  • Выравнивание по левому краю — флаг - помещает поле слева. %-10d помещает цифры слева с конечными пробелами.

  • Дополнение нулями — флаг 0 дополняет ведущими нулями вместо пробелов (для числовых типов). %05d дополняет нулями до пяти цифр.

  • Знак — флаг + всегда показывает знак у чисел, включая + для положительных.

  • Альтернативная форма — флаг #. Для %x это добавляет к выводу префикс 0x; для %o добавляет префикс 0o.

Флаги, ширину и точность можно комбинировать:

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

Оба более старых стиля медленнее читаются и более подвержены ошибкам, чем f-строки — обращайтесь к f-строкам в новом коде и узнавайте более старые формы при чтении существующего кода.