2.5. Méthodes de chaîne et formatage

Les chaînes sont accompagnées d’une boîte à outils intégrée de méthodes d’inspection et de remodelage. Comme les chaînes sont immuables, chaque méthode renvoie une nouvelle chaîne – l’originale reste inchangée.

2.5.1. Inspecter des chaînes

  • str.startswith() / str.endswith() – test de préfixe ou de suffixe ; renvoie un bool.

  • str.find() – position de la première occurrence d’une sous-chaîne, ou -1 si absente. str.index() fait la même chose mais lève une ValueError en cas d’absence.

  • str.count() – nombre d’occurrences non chevauchantes.

  • mot-clé in – "MV" in name renvoie True si la sous-chaîne se trouve n’importe où dans la chaîne.

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

2.5.2. Nettoyage et casse

  • str.strip() – supprimer les espaces de début et de fin. Passez une chaîne de caractères pour supprimer un ensemble personnalisé (s.strip("/")).

  • str.lower() / str.upper() – conversion de casse.

  • str.replace() – substitution de sous-chaîne.

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

2.5.3. Découpage et assemblage

  • str.split() – décomposer une chaîne en une liste à chaque occurrence d’un séparateur (par défaut : toute suite d’espaces).

  • str.join() – l’inverse : coller une séquence de chaînes en utilisant le récepteur comme séparateur. C’est la manière efficace de construire une longue chaîne à partir de fragments.

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

2.5.4. f-strings

La manière la plus simple d’interpoler des valeurs dans une chaîne est la f-string – un littéral de chaîne préfixé par f. Toute expression à l’intérieur de {} est évaluée et insérée :

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

Un deux-points à l’intérieur des accolades introduit une spécification de format qui contrôle la manière dont la valeur est rendue :

  • {x:.2f} – flottant avec 2 chiffres après la virgule.

  • {x:>10} – aligné à droite dans un champ de 10 caractères.

  • {x:<10} – aligné à gauche.

  • {x:0>4} – complété par des zéros en tête jusqu’à une largeur de 4.

  • {x:#x} – hexadécimal avec un préfixe 0x.

  • {x:b} – représentation binaire.

>>> 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 simple = après le nom de l’expression affiche à la fois le nom et la valeur – pratique pour des affichages de débogage rapides :

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

2.5.4.1. Conversions de base d’entiers

Trois fonctions intégrées font le même travail que les spécifications de format :b / :o / :x mais renvoient directement la chaîne convertie :

  • bin() – base 2, avec un préfixe "0b".

  • oct() – base 8, avec un préfixe "0o".

  • hex() – base 16, avec un préfixe "0x".

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

Le sens inverse – reconvertir une chaîne en base N en un entier – utilise le constructeur int avec une base explicite :

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

Recourez à celles-ci lorsque vous voulez la chaîne brute pour un entier (pour une ligne de journal, un fichier de configuration, un vidage de registre). Recourez à la spécification de format lorsque vous voulez du remplissage, une largeur, ou mêler la valeur à d’autres textes dans la même f-string.

2.5.5. Anciens styles de formatage

Les f-strings sont le style recommandé, mais deux approches plus anciennes fonctionnent encore et apparaissent dans le code existant :

str.format() – des accolades avec des arguments positionnels ou nommés passés à la méthode .format() sur une chaîne modèle :

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

Les spécifications de format ({:.2f}, {:>10}, …) fonctionnent de la même manière que dans les f-strings ; la seule différence est l’endroit où la valeur est fournie.

formatage % (style printf) – un unique opérateur % substitue des valeurs dans des codes de format, une valeur par code. Passez plusieurs valeurs sous forme de tuple :

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

Les codes de type les plus courants sont %s (chaîne), %d (entier), %f (flottant), et %x (hexadécimal).

Chaque code % peut porter des modificateurs entre le % et la lettre de type. La forme complète est %[flags][width][.precision]type :

  • width – nombre minimal de caractères que le champ doit occuper. Les valeurs plus courtes sont complétées par des espaces ; les valeurs plus longues débordent. %10d réserve 10 caractères et aligne le nombre à droite.

  • precision – sa signification dépend du type. Pour les flottants, le nombre de chiffres après la virgule. %.2f donne deux décimales. Pour les chaînes, le nombre maximal de caractères à prendre (%.5s tronque à cinq).

  • Alignement à gauche – l’indicateur - place le champ à gauche. %-10d place les chiffres du côté gauche avec des espaces à la suite.

  • Remplissage par zéros – l’indicateur 0 complète par des zéros en tête au lieu d’espaces (pour les types numériques). %05d complète par des zéros jusqu’à cinq chiffres.

  • Signe – l’indicateur + affiche toujours le signe sur les nombres, y compris un + pour les positifs.

  • Forme alternative – l’indicateur #. Pour %x, il préfixe la sortie par 0x ; pour %o, il préfixe par 0o.

Les indicateurs, la largeur et la précision peuvent être combinés :

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

Les deux anciens styles sont plus lents à lire et plus sujets aux erreurs que les f-strings – recourez aux f-strings dans le nouveau code, et reconnaissez les anciennes formes lors de la lecture du code existant.