# 6.1. `string` — Opérations usuelles sur des chaînes

Code source : Lib/string.py

Voir aussi

Type Séquence de Texte — str

Méthodes de chaînes de caractères

## 6.1.1. Chaînes constantes

Les constantes définies dans ce module sont :

`string.``ascii_letters`

  La concaténation des constantes `ascii_lowercase` et `ascii.uppercase` décrites ci-dessous. Cette valeur n’est pas dépendante de l’environnement linguistique.

`string.``ascii_lowercase`

  Les lettres minuscules `'abcdefghijklmnopqrstuvwxyz'`. Cette valeur de dépend pas de l’environnement linguistique et ne changera pas.

`string.``ascii_uppercase`

  Les lettres majuscules `'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Cette valeur de dépend pas de l’environnement linguistique et ne changera pas.

`string.``digits`

  La chaîne `'0123456789'`.

`string.``hexdigits`

  La chaîne `'0123456789abcdefABCDEF'`.

`string.``octdigits`

  La chaîne `'01234567`.

`string.``punctuation`

  Chaîne de caractères ASCII considérés comme ponctuation dans l’environnement linguistique `C`.

`string.``printable`

  Chaîne de caractères ASCII considérés comme affichables. C’est une combinaison de `digits`, `ascii_letters`, `punctuation`, et `whitespace`.

`string.``whitespace`

  Une chaîne comprenant tous les caractères ASCII considérés comme espaces. Sont inclus les caractères espace, tabulations, saut de ligne, retour du chariot, saut de page, et tabulation verticale.

## 6.1.2. Formatage personnalisé de chaîne

La classe primitive string fournit la possibilité de faire des substitutions de variables complexes et du formatage de valeurs via la méthode `format()` décrite par PEP 3101. La classe `Formatter` dans le module `string` permet de créer et personnaliser vos propres comportements de formatage de chaînes en utilisant la même implémentation que la méthode primitive `format()`.

class `string.``Formatter`

  La classe `Formatter` a les méthodes publiques suivantes :

  `format`(format_string, *args, **kwargs)

    La méthode principale de l’API. Elle prend une chaîne de format et un ensemble arbitraire d’arguments positions et mot-clefs. C’est uniquement un conteneur qui appelle `vformat()`.

    Obsolète depuis la version 3.5: Passer la chaîne de format comme argument mot-clef format_string est obsolète.

  `vformat`(format_string, args, kwargs)

    Cette fonction fait le travail effectif du formatage. Elle existe comme méthode séparée au cas où vous voudriez passer un dictionnaire d’arguments prédéfini plutôt que décompresser et recompresser le dictionnaire en arguments individuels en utilisant la syntaxe `*args` et `**kwargs`. `vformat()` s’occupe de découper la chaîne de format en données de caractères et champs de remplacement. Elle appelle les différentes méthodes décrites ci-dessous.

  De plus, la classe `Formatter` définit un certain nombre de méthodes qui ont pour vocation d’être remplacées par des sous-classes :

  `parse`(format_string)

    Boucle sur la chaîne de format et renvoie un itérable de tuples (literal_text, field_name, format_spec, conversion). Ceci est utilisé par `vformat()` pour découper la chaîne de format en littéraux ou en champs de remplacement.

    Les valeurs dans le tuple représentent conceptuellement un ensemble de littéraux suivis d’un unique champ de remplacement. S’il n’y a pas de littéral, (ce qui peut arriver si deux champs de remplacement sont placés côte à côte), alors literal_text est une chaîne vide. S’il n’y a pas de champ de remplacement, les valeurs field_name, format_spec et conversion sont mises à `None`.

  `get_field`(field_name, args, kwargs)

    Récupère le champ field_name du tuple renvoyé par `parse()` (voir ci-dessus), le convertit en un objet à formater. Renvoie un tuple (obj, used_key). La version par défaut prend une chaîne de la forme définie par PEP 3101, telle que « 0[name] » ou « label.title ». args et kwargs sont tels que ceux passés à `vformat()`. La valeur renvoyée used_key a le même sens que le paramètre key de `get_value()`.

  `get_value`(key, args, kwargs)

    Récupère la valeur d’un champ donné. L’argument key est soit un entier, soit une chaîne. Si c’est un entier, il représente l’indice de la l’argument dans args. Si c’est une chaîne de caractères, elle représente le nom de l’argument dans kwargs.

    Le paramètre args est défini par la liste des arguments positionnels de `vformat()`, et le paramètre kwargs est défini par le dictionnaire des arguments mot-clefs.

    Pour les noms de champs composés, ces fonctions sont uniquement appelées sur la première composante du nom. Les composantes suivantes sont manipulées au travers des attributs normaux et des opérations sur les indices.

    Donc par exemple, le champ-expression `0.name` amènerait `get_value()` à être appelée avec un argument key valant 0. L’attribut `name` sera recherché après l’appel `get_value()` en faisant appel à la primitive `getattr()`.

    Si l’indice ou le mot-clef fait référence à un objet qui n’existe pas, alors une exception `IndexError` ou `KeyError` doit être levée.

  `check_unused_args`(used_args, args, kwargs)

    Implémente une vérification pour les arguments non utilisés si désiré. L’argument de cette fonction est l’ensemble des clefs qui ont été effectivement référencées dans la chaîne de format (des entiers pour les indices et des chaînes de caractères pour les arguments nommés), et une référence vers les arguments args et kwargs qui ont été passés à vformat. L’ensemble des arguments non utilisés peut être calculé sur base de ces paramètres. `check_unused_args()` est censée lever une exception si la vérification échoue.

  `format_field`(value, format_spec)

    La méthode `format_field()` fait simplement appel à la primitive globale `format()`. Cette méthode est fournie afin que les sous-classes puisse la redéfinir.

  `convert_field`(value, conversion)

    Convertit la valeur (renvoyée par `get_field()`) selon un type de conversion donné (comme dans le tuple renvoyé par la méthode `parse()`). La version par défaut comprend “s” (str), “r” (repr) et “a” (ASCII) comme types de conversion.

## 6.1.3. Syntaxe de formatage de chaîne

La méthode `str.format()` et la classe `Formatter` partagent la même syntaxe pour les chaînes de formatage (bien que dans le cas de `Formatter` les sous-classes puissent définir leur propre syntaxe). La syntaxe est liée à celle des chaînes de formatage littérales, mais il y a quelques différences.

Les chaînes de formatage contiennent des « champs de remplacement » entourés d’accolades `{}`. Tout ce qui n’est pas placé entre deux accolades est considéré comme littéral, qui est copié tel quel dans le résultat. Si vous avez besoin d’inclure une accolade en littéral, elles peuvent être échappées en les doublant : `{{` et `}}`.

La grammaire pour un champ de remplacement est défini comme suit :

>     replacement_field ::=  "{" [field_name] ["!" conversion] [":" format_spec] "}"
>     field_name        ::=  arg_name ("." attribute_name | "[" element_index "]")*
>     arg_name          ::=  [identifier | digit+]
>     attribute_name    ::=  identifier
>     element_index     ::=  digit+ | index_string
>     index_string      ::=  <any source character except "]"> +
>     conversion        ::=  "r" | "s" | "a"
>     format_spec       ::=  <described in the next section>

En termes moins formels, un champ de remplacement peut débuter par un field_name qui spécifie l’objet dont la valeur va être formatée et insérée dans le résultat à l’endroit du champ de remplacement Le field_name peut éventuellement être suivi d’un champ conversion qui est précédé d’un point d’exclamation `'!'`, et d’un format_spec qui est précédé par deux-points `':'`. Cela définit un format personnalisé pour le remplacement d’une valeur.

Voir également la section Mini-langage de spécification de format.

Le champ field_name débute par un arg_name qui est soit un nombre, soit un mot-clef. Si c’est un nombre, il fait référence à un des arguments positionnels et si c’est un mot-clef, il fait référence à un des arguments nommés. Si les valeurs numériques de arg_name dans une chaîne de format sont 0, 1, 2, … dans l’ordre, elles peuvent être omises (toutes ou aucune), et les nombres 0, 1, 2, … seront automatiquement insérés dans cet ordre. Puisque arg_name n’est pas délimité par des guillemets, il n’est pas possible de spécifier des clefs de dictionnaire arbitraires (par exemple les chaînes `'10'` ou `':-]'`) dans une chaîne de format. La valeur arg_name peut être suivie par un nombre d’indices ou d’expressions quelconque. Une expression de la forme `'.name'` sélectionne l’attribut nommé en utilisant `getattr()` alors qu’une expression de la forme `'[index]'` recherche l’indice en utilisant `__getitem__()`.

Modifié dans la version 3.1: Les spécificateurs de position d’argument peuvent être omis dans les appels à `str.format()`. Donc `'{} {}'.format(a, b)` est équivalent à `'{0} {1}'.format(a, b)`.

Modifié dans la version 3.4: Les spécificateurs de position d’argument peuvent être omis pour `Formatter`.

Quelques exemples simples de formatage de chaînes :

    "First, thou shalt count to {0}"  # References first positional argument
    "Bring me a {}"                   # Implicitly references the first positional argument
    "From {} to {}"                   # Same as "From {0} to {1}"
    "My quest is {name}"              # References keyword argument 'name'
    "Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
    "Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Le champ conversion crée une contrainte de type avant de formater. Normalement, le travail de formatage d’une valeur est fait par la méthode `__format__()` de la valeur elle-même. Cependant, dans certains cas, il est désirable de forcer un type à être formaté en une chaîne, en ré-définissant sa propre définition de formatage. En convertissant une valeur en chaîne de caractère avant d’appeler la méthode `__format__()`, on outrepasse la logique usuelle de formatage.

Actuellement, trois indicateurs sont gérés : `'!s'` qui appelle la fonction `str()` sur la valeur, `'!r'` qui appelle la fonction `repr()` et `!a` qui appelle la fonction `ascii()`.

Quelques exemples :

    "Harold's a clever {0!s}"        # Calls str() on the argument first
    "Bring out the holy {name!r}"    # Calls repr() on the argument first
    "More {!a}"                      # Calls ascii() on the argument first

Le champ format_spec contient une spécification sur la manière selon laquelle la valeur devrait être représentée : des informations telles que la longueur du champ, l’alignement, le remplissage, la précision décimale, etc. Chaque type peut définir son propre « mini-langage de formatage » ou sa propre interprétation de format_spec.

La plupart des types natifs gèrent un mini-langage de formatage usuel qui est décrit dans la section suivante.

Un champ format_spec peut contenir un champ de remplacement imbriqué. Ces champs de remplacement imbriqués peuvent contenir un nom de champ, un indicateur de conversion, mais une imbrication récursive plus profonde n’est pas permise. Les champs de remplacement au sein de format_spec sont substitués avant que la chaîne format_spec ne soit interprétée. Cela permet que le formatage d’une valeur soit dynamiquement spécifié.

Voir la section Exemples de formats pour des exemples.

### 6.1.3.1. Mini-langage de spécification de format

Les « Spécifications de format » sont utilisées avec les champs de remplacement contenus dans les chaînes de formatage, pour définir comment les valeurs doivent être représentées (voir Syntaxe de formatage de chaîne et Chaînes de caractères formatées littérales). Elles peuvent aussi être passées directement à la fonction native `format()`. Chaque type formatable peut définir comment les spécifications sur les valeurs de ce type doivent être interprétées.

La plupart des primitives implémentent les les options suivantes, même si certaines options de formatage ne sont supportées que pour les types numériques.

Une convention généralement admise est qu’une chaîne vide (`""`) produit le même résultat que si vous aviez appelé `str()` sur la valeur. Une chaîne de format non vide modifie typiquement le résultat.

La forme générale d’un spécificateur de format standard est :

    format_spec     ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]
    fill            ::=  <any character>
    align           ::=  "<" | ">" | "=" | "^"
    sign            ::=  "+" | "-" | " "
    width           ::=  digit+
    grouping_option ::=  "_" | ","
    precision       ::=  digit+
    type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Si une valeur valide est spécifiée pour align, elle peut être précédée par un caractère fill, qui peut être n’importe quel caractère (espace par défaut si la valeur est omise). Il n’est pas possible d’utiliser une accolade littérale (« `{` » ou « `}` ») comme caractère fill dans une chaîne de formatage littérale ou avec la méthode `str.format()`. Cependant, il est possible d’insérer une accolade à l’aide d’un champ de remplacement imbriqué. Cette limitation n’affecte pas la fonction `format()`.

Le sens des différentes options d’alignement est donné comme suit :

> Option | Signification
> --- | ---
> `'<'` | Force le champ à être aligné à gauche dans l’espace disponible (c’est le spécificateur par défaut pour la plupart des objets).
> `'>'` | Force le champ à être aligné à droite dans l’espace disponible (c’est le spécificateur par défaut pour les nombres).
> `'='` | Force le remplissage (padding) à être placé après le signe (si signe il y a) mais avant les chiffres. L’option est utilisée pour afficher les champs sous la forme « +000000120 ». Cette option d’alignement est valide uniquement pour les types numériques. Elle devient activée par défaut quand « 0 » précède directement la largeur de champ.
> `'^'` | Force le champ à être centré dans l’espace disponible.

Notons que la longueur du champ est toujours égale à la la taille nécessaire pour remplir le champ avec l’objet à moins que la valeur minimum ne soit précisée. Ainsi, si aucune valeur n’est précisée, l’option d’alignement n’a aucun sens.

L’option sign est uniquement valide pour les type numériques, et peut valoir :

> Option | Signification
> --- | ---
> `'+'` | indique que le signe doit être affiché pour les nombres tant positifs que négatifs.
> `'-'` | indique que le signe doit être affiché uniquement pour les nombres négatifs (c’est le comportement par défaut).
> espace | indique qu’un espace doit précéder les nombres positifs et qu’un signe moins doit précéder les nombres négatifs.

L’option `'#'` impose l’utilisation de la « forme alternative » pour la conversion. La forme alternative est définie différemment pour différent types. Cette option est uniquement valide pour les types entiers flottants, complexes, et décimaux. Pour les entiers, quand l’affichage binaire, octal ou hexadécimal est utilisé, cette option ajoute le préfixe `'0b'`, `'0o'`, ou `'0x'` à la valeur affichée. Pour les flottants, les complexes, et les décimaux, la forme alternative impose que le résultat de la conversion contienne toujours une virgule, même si aucun chiffre ne vient après. Normalement, une virgule apparaît dans le résultat de ces conversions seulement si un chiffre le suit. De plus, pour les conversions `'g'` et `'G'`, les zéros finaux ne sont pas retirés du résultat.

L’option `','` signale l’utilisation d’une virgule comme séparateur des milliers. Pour un séparateur conscient de l’environnement linguistique, utilisez plutôt le type de présentation entière `'n'`.

Modifié dans la version 3.1: Ajout de l’option `','` (voir PEP 378).

L’option `'_'` demande l’utilisation d’un tiret bas comme séparateur des milliers pour les représentations de nombres flottants et pour les entiers représentés par le type `'d'`. Pour les types de représentation d’entiers `'b'`, `'o'`, `'x'` et `'X'`, les tirets bas seront insérés tous les 4 chiffres. Pour les autres types de représentation, spécifier cette option est une erreur.

Modifié dans la version 3.6: Ajout de l’option `'_'` (voir aussi PEP 515).

width est un entier en base 10 qui définit la longueur minimale du champ. Si elle n’est pas spécifiée, alors le champ width est déterminé par le contenu.

Quand aucun alignement explicite n’est donné, précéder le champs width d’un caractère zéro (`'0'`) active le remplissage par zéro des types numériques selon leur signe. Cela est équivalent à un caractère de remplissage fill valant `'0'` avec le type d’alignement alignment valant `'='`.

La valeur precision est un nombre en base 10 indiquant combien de chiffres doivent être affichés après la virgule pour une valeur à virgule flottante formatée avec `'f'` ou `'F'`, ou avant et après le point-décimal pour une valeur à virgule flottante formatée avec `'g'` ou `'G'`. Pour les types non numériques, ce champ indique la taille maximale du champ, autrement dit, combien de caractères du champ sont utilisés. Le spécificateur precision n’est pas autorisé sur les entiers.

Finalement, le spécificateur type détermine comment la donnée doit être représentée.

Les types disponibles de représentation de chaîne sont :

> Type | Signification
> --- | ---
> `'s'` | Format de chaîne. C’est le type par défaut pour les chaînes de caractères et peut être omis.
> `None` | Pareil que `'s'`.

Les types disponibles de représentation d’entier sont :

> Type | Signification
> --- | ---
> `'b'` | Format binaire. Affiche le nombre en base 2.
> `'c'` | Caractère. Convertit l’entier en le caractère Unicode associé avant de l’afficher.
> `'d'` | Entier décimal. Affiche le nombre en base 10.
> `'o'` | Format octal. Affiche le nombre en base 8.
> `'x'` | Hex format. Outputs the number in base 16, using lower-case letters for the digits above 9.
> `'X'` | Hex format. Outputs the number in base 16, using upper-case letters for the digits above 9.
> `'n'` | Nombre. Pareil que `'d'` si ce n’est que l’environnement linguistique est utilisé afin de déterminer le séparateur de nombres approprié.
> `None` | Pareil que `'d'`.

En plus des types de représentation ci-dessus, les entiers peuvent aussi être formatés avec les types de représentation des flottants listés ci-dessous (à l’exception de `'n'` et `None`). Dans ce cas, la fonction `float()` est utilisée pour convertir l’entier en flottant avant le formatage.

Les types de représentation pour les nombres flottants et les valeurs décimales sont :

> Type | Signification
> --- | ---
> `'e'` | Notation par exposant. Affiche le nombre dans sa notation scientifique en utilisant la lettre “e” pour indiquer l’exposant. La précision par défaut est `6`.
> `'E'` | Notation par exposant. Pareil que `'e'` sauf l’utilisation de la lettre majuscule “E” comme séparateur.
> `'f'` | Fixed-point notation. Displays the number as a fixed-point number. The default precision is `6`.
> `'F'` | Fixed-point notation. Same as `'f'`, but converts `nan` to `NAN` and `inf` to `INF`.
> `'g'` | Format général. Pour une précision donnée `p >= 1`, ceci arrondit le nombre à `p` chiffres significatifs et puis formate le résultat soit en virgule fixe soit en notation scientifique, en fonction de la magnitude. Les règles précises sont les suivantes : supposons que le résultat formaté avec le type de représentation `'e'` et une précision `1` ait un exposant `exp`. Alors, si `-4 <= exp <= p`, le nombre est formaté avec le type de représentation `'f'` et une précision `p-1-exp`. Sinon, le nombre est formaté avec le type de représentation `'e'` et une précision `p-1`. Dans les deux cas, les zéros finaux et non significatifs sont retirés, et la virgule est également retirée s’il n’y a aucun chiffre la suivant. Les valeurs suivantes : infini négatif, infini positif, zéro positif, zéro négatif, not a number sont formatées respectivement par `inf`, `-inf`, `0`, `-0` et `nan`, peu importe la précision. Une précision de `0` est interprétée comme une précision de `1`. La précision par défaut est `6`.
> `'G'` | Format général. Pareil que `'G'` si ce n’est que `'E'` est utilisé si le nombre est trop grand. Également, la représentation des infinis et de Nan sont en majuscules également.
> `'n'` | Nombre. Pareil que `'g'`, si ce n’est que l’environnement linguistique est pris en compte pour insérer le séparateur approprié.
> `'%'` | Pourcentage. Multiplie le nombre par 100 et l’affiche en virgule fixe (`'f'`), suivi d’un symbole pourcent `'%'`.
> `None` | Pareil que `'g'`, si ce n’est que lorsque la notation en virgule fixe est utilisée, il y a toujours au moins un chiffre derrière la virgule. La précision par défaut celle nécessaire pour afficher la valeur donnée. L’effet visé est de le faire correspondre à la valeur renvoyée par `str()` altérée par les autres modificateurs de format.

### 6.1.3.2. Exemples de formats

Cette section contient des exemples de la syntaxe de `str.format()` et des comparaisons avec l’ancien formatage par `%`.

Dans la plupart des cases, la syntaxe est similaire à l’ancien formatage par `%`, avec l’ajout de `{}` et avec `:` au lieu de `%`. Par exemple : `'%03.2f'` peut être changé en `'{03.2f}'`.

The new format syntax also supports new and different options, shown in the following examples.

Accéder à un argument par sa position :

    >>> '{0}, {1}, {2}'.format('a', 'b', 'c')
    'a, b, c'
    >>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only
    'a, b, c'
    >>> '{2}, {1}, {0}'.format('a', 'b', 'c')
    'c, b, a'
    >>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
    'c, b, a'
    >>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
    'abracadabra'

Accéder à un argument par son nom :

    >>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
    'Coordinates: 37.24N, -115.81W'
    >>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
    >>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
    'Coordinates: 37.24N, -115.81W'

Accéder aux attributs d’un argument :

    >>> c = 3-5j
    >>> ('The complex number {0} is formed from the real part {0.real} '
    ...  'and the imaginary part {0.imag}.').format(c)
    'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
    >>> class Point:
    ...     def __init__(self, x, y):
    ...         self.x, self.y = x, y
    ...     def __str__(self):
    ...         return 'Point({self.x}, {self.y})'.format(self=self)
    ...
    >>> str(Point(4, 2))
    'Point(4, 2)'

Accéder aux éléments d’un argument :

    >>> coord = (3, 5)
    >>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
    'X: 3;  Y: 5'

Remplacer `%s` et `%r` :

    >>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
    "repr() shows quotes: 'test1'; str() doesn't: test2"

Aligner le texte et spécifier une longueur minimale :

    >>> '{:<30}'.format('left aligned')
    'left aligned                  '
    >>> '{:>30}'.format('right aligned')
    '                 right aligned'
    >>> '{:^30}'.format('centered')
    '           centered           '
    >>> '{:*^30}'.format('centered')  # use '*' as a fill char
    '***********centered***********'

Remplacer `%+f`, `%-f`, et `%f` et spécifier un signe :

    >>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
    '+3.140000; -3.140000'
    >>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
    ' 3.140000; -3.140000'
    >>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
    '3.140000; -3.140000'

Remplacer `%x` et `%o` et convertir la valeur dans différentes bases :

    >>> # format also supports binary numbers
    >>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
    'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
    >>> # with 0x, 0o, or 0b as prefix:
    >>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
    'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

Utiliser une virgule comme séparateur des milliers :

    >>> '{:,}'.format(1234567890)
    '1,234,567,890'

Exprimer un pourcentage :

    >>> points = 19
    >>> total = 22
    >>> 'Correct answers: {:.2%}'.format(points/total)
    'Correct answers: 86.36%'

Utiliser un formatage propre au type :

    >>> import datetime
    >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
    >>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
    '2010-07-04 12:15:58'

Arguments imbriqués et des exemples plus complexes :

    >>> for align, text in zip('<^>', ['left', 'center', 'right']):
    ...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)
    ...
    'left<<<<<<<<<<<<'
    '^^^^^center^^^^^'
    '>>>>>>>>>>>right'
    >>>
    >>> octets = [192, 168, 0, 1]
    >>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
    'C0A80001'
    >>> int(_, 16)
    3232235521
    >>>
    >>> width = 5
    >>> for num in range(5,12):
    ...     for base in 'dXob':
    ...         print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')
    ...     print()
    ...
        5     5     5   101
        6     6     6   110
        7     7     7   111
        8     8    10  1000
        9     9    11  1001
       10     A    12  1010
       11     B    13  1011

## 6.1.4. Chaînes modèles

Template strings provide simpler string substitutions as described in PEP 292. A primary use case for template strings is for internationalization (i18n) since in that context, the simpler syntax and functionality makes it easier to translate than other built-in string formatting facilities in Python. As an example of a library built on template strings for i18n, see the flufl.i18n package.

Template strings support `$`-based substitutions, using the following rules:

- `$$` est un échappement ; il est remplacé par un simple `$`.

- `$identifier` dénomme un substituant lié à la clef `"identifier"`. Par défaut, `"identifier"` est restreint à toute chaîne de caractères ASCII alphanumériques sensibles à la casse (avec les underscores) commençant avec un underscore ou un caractère alphanumérique. Le premier caractère n’étant pas un identifieur après le `$` termine la spécification du substituant.

- `${identifier}` est équivalent à `$identifier`. Cette notation est requise quand un caractère valide pour une clef de substituant suit directement le substituant mais ne fait pas partie du substituant, comme `"${noun}ification"`.

Tout autre présence du symbole `$` dans une chaîne résultera en la levée d’une `ValueError`.

Le module `string` fournit une classe `Template` qui implémente ces règles. Les méthodes de `Template` sont :

class `string.``Template`(template)

  Le constructeur prend un seul argument qui est la chaîne du template.

  `substitute`(mapping, **kwds)

    Applique les substitutions du template, et la renvoie dans une nouvelle chaîne. mapping est un objet dictionnaire-compatible qui lie les substituants dans le template. De même, vous pouvez fournir des arguments mot-clefs tels que les mot-clefs sont les substituants. Quand à la fois mapping et kwds sont donnés et qu’il y a des doublons, les substituants de kwds sont prioritaires.

  `safe_substitute`(mapping, **kwds)

    Comme `substitute()`, si ce n’est qu’au lieu de lever une `KeyError` si un substituant n’est ni dans mapping, ni dans kwds, c’est le nom du substituant inchangé qui apparaît dans la chaîne finale. Également, à l’inverse de `substitute()`, toute autre apparition de `$` renverra simplement `$` au lieu de lever une exception `ValueError`.

    While other exceptions may still occur, this method is called « safe » because it always tries to return a usable string instead of raising an exception. In another sense, `safe_substitute()` may be anything other than safe, since it will silently ignore malformed templates containing dangling delimiters, unmatched braces, or placeholders that are not valid Python identifiers.

  Les instances de la classe `Template` fournissent également un attribut public :

  `template`

    C’est l’objet template passé comme argument au constructeur. En général, vous ne devriez pas le changer, mais un accès en lecture-seule n’est pas possible à fournir.

Voici un exemple de comment utiliser un Template :

    >>> from string import Template
    >>> s = Template('$who likes $what')
    >>> s.substitute(who='tim', what='kung pao')
    'tim likes kung pao'
    >>> d = dict(who='tim')
    >>> Template('Give $who $100').substitute(d)
    Traceback (most recent call last):
    ...
    ValueError: Invalid placeholder in string: line 1, col 11
    >>> Template('$who likes $what').substitute(d)
    Traceback (most recent call last):
    ...
    KeyError: 'what'
    >>> Template('$who likes $what').safe_substitute(d)
    'tim likes $what'

Usage avancé : vous pouvez faire dériver vos sous-classes de `Template` pour personnaliser la syntaxe des substituants, les caractères délimiteurs, ou l’entièreté de l’expression rationnelle utilisée pour analyser les chaînes templates. Pour faire cela, vous pouvez redéfinir les attributs suivants :

- delimiter – La chaîne littérale décrivant le délimiteur pour introduire un substituant. Sa valeur par défaut ests `$`. Notez qu’il ne doit pas être une expression rationnelle, puisque l’implémentation appellera `re.escape()` sur cette chaîne si nécessaire.

- idpattern – L’expression rationnelle décrivant le motif pour les substituants non entourés d’accolades (les accolades sont ajoutées automatiquement si c’est approprié). La valeur par défaut de cette expression rationnelle est `(?-i:[_a-zA-Z][_a-zA-Z0-9]*)`.

  Note

  Puisque par défaut flags vaut `re.IGNORECASE`, des caractères non-ASCII peuvent correspondre au motif `[a-z]`. C’est pourquoi on utilise une option locale `-i` ici.

  Bien que flags reste par défaut à `re.IGNORECASE` pour des raisons de compatibilité descendente, vous pouvez le mettre à `0` ou `re.IGNORECASE | re.ASCII` si vous en héritez.

- flags – L’indicateur d’expression rationnelle qui sera appliqué lors de la compilation de l’expression rationnelle pour reconnaître les substitutions. La valeur par défaut est `re.IGNORECASE`. Notez que `re.VERBOSE` sera toujours ajouté à l’indicateur. Donc, un idpattern personnalisé doit suivre les conventions des expressions rationnelles verbose.

  Nouveau dans la version 3.2.

Également, vous pouvez fournir le motif d’expression rationnelle en entier en redéfinissant l’attribut pattern. Si vous faites cela, la valeur doit être un objet “expression rationnelle” avec quatre groupes de capture de noms. Les groupes de capture correspondent aux règles données au-dessus, ainsi qu’à la règle du substituant invalide :

- escaped – Ce groupe lie les séquences échappées (par exemple `$$`) dans le motif par défaut.

- named – Ce groupe lie les substituants non entourés d’accolades ; il ne devrait pas inclure le délimiteur dans le groupe de capture.

- braced – Ce groupe lie le nom entouré d’accolades ; il ne devrait inclure ni le délimiteur, ni les accolades dans le groupe de capture.

- invalid – Ce groupe lie tout autre motif de délimitation (habituellement, un seul délimiteur) et il devrait apparaître en dernier dans l’expression rationnelle.

## 6.1.5. Fonctions d’assistance

`string.``capwords`(s, sep=None)

  Divise l’argument en mots en utilisant `str.split()`, capitalise chaque mot en utilisant `str.capitalize()` et assemble les mots capitalisés en utilisant `str.join()`. Si le second argument optionnel sep est absent ou vaut `None`, les séquences de caractères blancs sont remplacées par un seul espace et les espaces débutant et finissant la chaîne sont retirés. Sinon, sep et utilisé pour séparer et ré-assembler les mots.