Formation gratuite Python
Dans le didacticiel précédent de cette série d'introduction, vous avez appris à formater les données de chaîne à l'aide du opérateur modulo chaîne. L'opérateur modulo de chaîne est utile, et il est bon que vous le connaissiez car vous le rencontrerez probablement dans un code Python plus ancien. Cependant, il existe deux nouvelles façons d'utiliser Python pour formater des chaînes qui sont sans doute plus préférables.
Dans ce didacticiel, vous découvrirez:
- le chaîne
.format()méthode - le chaîne littérale formatée, ou f-string
Vous découvrirez ces techniques de formatage en détail et les ajouterez à votre boîte à outils de formatage de chaînes Python. Notez qu'il existe un module standard appelé chaîne contenant une classe appelée Modèle, qui fournit une mise en forme des chaînes par interpolation. L'opérateur modulo de chaîne fournit plus ou moins la même fonctionnalité, vous ne couvrirez donc pas string.Template ici.
La chaîne Python .format() Méthode
La chaîne Python .format() a été introduite dans la version 2.6. Il est similaire à bien des égards à l'opérateur modulo de chaîne, mais .format() va bien au-delà de la polyvalence. La forme générale d'un Python .format() l'appel est indiqué ci-dessous:
<modèle>.format(<positional_argument(s)>, <argument_clé(s)>)
Notez qu'il s'agit d'une méthode, pas d'un opérateur. Vous appelez la méthode sur , qui est une chaîne contenant champs de remplacement. le à la place des champs de remplacement. La chaîne formatée résultante est la valeur de retour de la méthode.
dans le chaîne, les champs de remplacement sont placés entre accolades (). Tout ce qui n'est pas contenu entre accolades est du texte littéral qui est copié directement du modèle dans la sortie. Si vous devez inclure un caractère entre crochets, comme ou , dans la chaîne du modèle, vous pouvez échapper à ce caractère en le doublant:
>>> « 0 '.format('foo')
'foo'
Maintenant, les accolades sont incluses dans votre sortie.
La chaîne .format() Méthode: arguments
Commençons par un exemple rapide pour vous familiariser avant de vous plonger dans plus de détails sur la façon d'utiliser cette méthode en Python pour formater des chaînes. Pour examen, voici le premier exemple du didacticiel précédent sur l'opérateur modulo de chaînes:
>>> impression("%ré % s coût $% .2f" % (6, 'bananes', 1,74))
6 bananes coûtent 1,74 $
Ici, vous avez utilisé l'opérateur modulo de chaîne en Python pour formater la chaîne. Maintenant, vous pouvez utiliser la chaîne de Python .format() pour obtenir le même résultat, comme ceci:
>>> impression("0 1 coût $2".format(6, 'bananes', 1,74))
6 bananes coûtent 1,74 $
Dans cet exemple, est la chaîne «0 1 coûte $ 2». Les champs de remplacement sont 0, 1, et 2, qui contiennent des nombres qui correspondent aux arguments positionnels de base zéro 6, 'bananes', et 1,74. Chaque argument positionnel est inséré dans le modèle à la place de son champ de remplacement correspondant:
L'exemple suivant utilise des arguments de mots clés au lieu de paramètres positionnels pour produire le même résultat:
>>> impression("quantité article coût $prix".format(
... quantité=6,
... article='bananes',
... prix=1,74))
6 bananes coûtent 1,74 $
Dans ce cas, les champs de remplacement sont quantité, article, et prix. Ces champs spécifient des mots clés qui correspondent aux arguments des mots clés quantité = 6, item = 'bananes', et prix = 1,74. Chaque valeur de mot clé est insérée dans le modèle à la place de son champ de remplacement correspondant:
Vous en apprendrez plus sur les arguments de position et de mots clés dans le prochain didacticiel de cette série d'introduction, qui explore les fonctions et le passage d'arguments. Pour l'instant, les deux sections qui suivent vous montreront comment celles-ci sont utilisées avec Python .format() méthode.
Arguments positionnels
Des arguments positionnels sont insérés dans le modèle à la place de champs de remplacement numérotés. Comme l'indexation de liste, la numérotation des champs de remplacement est basée sur zéro. Le premier argument positionnel est numéroté 0, le second est numéroté 1, etc:
>>> "0/1/2".format('foo', 'bar', «baz»)
«foo / bar / baz»
Notez que les champs de remplacement ne doivent pas apparaître dans le modèle dans l'ordre numérique. Ils peuvent être spécifiés dans n'importe quel ordre et peuvent apparaître plusieurs fois:
>>> "2.1.0/0 0.1 1.2 2".format('foo', 'bar', «baz»)
«baz.bar.foo/foofoo.barbar.bazbaz»
Lorsque vous spécifiez un numéro de champ de remplacement hors plage, vous obtenez une erreur. Dans l'exemple suivant, les arguments positionnels sont numérotés 0, 1, et 2, mais vous spécifiez 3 dans le modèle:
>>> "3".format('foo', 'bar', «baz»)
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans Cela soulève une IndexError exception.
À partir de Python 3.1, vous pouvez omettre les nombres dans les champs de remplacement, auquel cas l'interpréteur suppose un ordre séquentiel. C'est ce qu'on appelle numérotation automatique des champs:
>>> "//".format('foo', 'bar', «baz»)
«foo / bar / baz»
Lorsque vous spécifiez la numérotation automatique des champs, vous devez fournir au moins autant d'arguments qu'il y a de champs de remplacement:
>>> " ".format('foo','bar',«baz»)
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans Dans ce cas, il y a quatre champs de remplacement dans le modèle mais seulement trois arguments, donc un IndexError une exception se produit. D'un autre côté, ça va si les arguments sont plus nombreux que les champs de remplacement. Les arguments excédentaires ne sont tout simplement pas utilisés:
>>> " ".format('foo', 'bar', «baz»)
«foobar»
Ici, l'argument «baz» est ignoré.
Notez que vous ne pouvez pas mélanger ces deux techniques:
>>> "1 0".format('foo','bar',«baz»)
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans Lorsque vous utilisez Python pour formater des chaînes avec des arguments positionnels, vous devez choisir entre la numérotation automatique ou explicite des champs de remplacement.
Arguments des mots clés
Les arguments de mots clés sont insérés dans la chaîne de modèle à la place de champs de remplacement de mots clés du même nom:
>>> "X/y/z".format(X='foo', y='bar', z=«baz»)
«foo / bar / baz»
Dans cet exemple, les valeurs des arguments du mot clé X, y, et z prendre la place des champs de remplacement X, y, et z, respectivement.
Si vous faites référence à un argument de mot clé manquant, vous verrez une erreur:
>>> "X/y/w".format(X='foo', y='bar', z=«baz»)
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans Ici, vous spécifiez le champ de remplacement w, mais il n'y a pas d'argument de mot clé correspondant nommé w. Python soulève un KeyError exception.
Vous devez spécifier des arguments positionnels dans un ordre séquentiel, mais vous pouvez spécifier des arguments de mots clés dans n'importe quel ordre arbitraire:
>>> "0/1/2".format('foo', 'bar', «baz»)
«foo / bar / baz»
>>> "0/1/2".format('bar', «baz», 'foo')
«bar / baz / foo»
>>> "X/y/z".format(X='foo', y='bar', z=«baz»)
«foo / bar / baz»
>>> "X/y/z".format(y='bar', z=«baz», X='foo')
«foo / bar / baz»
Vous pouvez spécifier à la fois des arguments de position et de mot clé dans un seul Python .format() appel. Notez simplement que si vous le faites, tous les les arguments positionnels doivent apparaître avant l'un des arguments de mot clé:
>>> "0 x 1".format('foo', 'bar', X=«baz»)
«foobazbar»
>>> "0 x 1".format('foo', X=«baz», 'bar')
Fichier "" , ligne 1
Erreur de syntaxe: l'argument positionnel suit l'argument mot-clé
En fait, l'exigence que tous les arguments de position apparaissent avant tout argument de mot clé ne s'applique pas uniquement aux méthodes de format Python. Cela est généralement vrai pour tout appel de fonction ou de méthode. Vous en apprendrez plus à ce sujet dans le prochain didacticiel de cette série, qui explore les fonctions et les appels de fonction.
Dans tous les exemples présentés jusqu'à présent, les valeurs que vous avez transmises au Python .format() ont été des valeurs littérales, mais vous pouvez également spécifier des variables:
>>> X = 'foo'
>>> y = 'bar'
>>> z = «baz»
>>> "0/1/s".format(X, y, s=z)
«foo / bar / baz»
Dans ce cas, vous passez les variables X et y comme valeurs de paramètres de position et z comme valeur de paramètre de mot clé.
La chaîne .format() Méthode: champs de remplacement simples
Comme vous l’avez vu, lorsque vous appelez Python .format() , la méthode la chaîne contient champs de remplacement. Ceux-ci indiquent où dans le modèle insérer les arguments dans la méthode. Un champ de remplacement se compose de trois composants:
[[[[][![![![! ][:[:[:[: ]
Ces composants sont interprétés comme suit:
| Composant | Sens |
|---|---|
|
Spécifie la source de la valeur à mettre en forme |
|
Indique la fonction Python standard à utiliser pour effectuer la conversion |
|
Spécifie plus de détails sur la façon dont la valeur doit être convertie |
Chaque composant est facultatif et peut être omis. Examinons chaque composant plus en détail.
le
le
[[[[] [![![![!][:[:[:[: ]
0, 1, et baz, respectivement:
>>> X, y, z = 1, 2, 3
>>> "0, 1, baz".format(X, y, baz=z)
«1, 2, 3»
Si un argument est une liste, vous pouvez utiliser des indices avec
>>> une = [[[['foo', 'bar', «baz»]
>>> "0[0], 0[2]".format(une)
'foo, baz'
>>> "ma liste[0], ma liste[2]".format(ma liste=une)
'foo, baz'
De même, vous pouvez utiliser une référence de clé avec
>>> ré = 'key1': 'foo', «key2»: 'bar'
>>> ré[[[['key1']
'foo'
>>> "0[key1]".format(ré)
'foo'
>>> ré[[[[«key2»]
'bar'
>>> "my_dict[key2]".format(my_dict=ré)
'bar'
Vous pouvez également référencer attributs d'objet à partir d'un champ de remplacement. Dans le didacticiel précédent de cette série, vous avez appris que pratiquement chaque élément de données en Python est un objet. Les objets peuvent avoir les attributs qui leur sont attribuées et accessibles en utilisant la notation par points:
Ici, obj est un objet avec un attribut nommé attr. Vous utilisez la notation par points pour accéder à l'attribut de l'objet. Voyons un exemple. Les nombres complexes en Python ont des attributs nommés .réel et .imag qui représentent les parties réelles et imaginaires du nombre. Vous pouvez également y accéder en utilisant la notation par points:
>>> z = 3+5j
>>> type(z)
Il existe plusieurs tutoriels à venir dans cette série sur la programmation orientée objet, dans lesquels vous en apprendrez beaucoup plus sur les attributs d'objet comme ceux-ci.
La pertinence des attributs d'objet dans ce contexte est que vous pouvez les spécifier dans un Python .format() champ de remplacement:
>>> z
(3 + 5j)
>>> 'réel = 0.real, imag = 0.imag".format(z)
«réel = 3,0, imag = 5,0»
Comme vous pouvez le voir, il est relativement simple en Python de formater les composants d'objets complexes en utilisant .format() méthode.
le
le
[[[[] [![![![!] [:[:[:[:]
Python peut formater un objet sous forme de chaîne à l'aide de trois fonctions intégrées différentes:
str ()repr ()ascii ()
Par défaut, le Python .format() utilise la méthode str (), mais dans certains cas, vous pouvez forcer .format() d'utiliser l'un des deux autres. Vous pouvez le faire avec le
| Valeur | Sens |
|---|---|
! s |
Convertir avec str () |
! r |
Convertir avec repr () |
!une |
Convertir avec ascii () |
Les exemples suivants forcent Python à effectuer une conversion de chaîne à l'aide str (), repr (), et ascii (), respectivement:
>>> "0! S".format(42)
«42»
>>> "0! R".format(42)
«42»
>>> "0! A".format(42)
«42»
Dans de nombreux cas, le résultat est le même quelle que soit la fonction de conversion que vous utilisez, comme vous pouvez le voir dans l'exemple ci-dessus. Cela étant dit, vous n'aurez pas souvent besoin du
le
le
[[[[][![![![! ] [:[:[:[:]
.format() fonctionnalité de la méthode. Il contient des informations qui exercent un contrôle précis sur la façon dont les valeurs sont formatées avant d'être insérées dans la chaîne de modèle. La forme générale est la suivante:
:
[[[[[[[[] ][[[[ ][#][0][[[[ ][[[[ ][[[[ ][[[[ ]
Les dix sous-composantes de
| Sous-composant | Effet |
|---|---|
: |
Sépare le |
|
Spécifie comment remplir les valeurs qui n'occupent pas toute la largeur du champ |
|
Spécifie comment justifier les valeurs qui n'occupent pas toute la largeur du champ |
|
Contrôle si un signe de tête est inclus pour les valeurs numériques |
# |
Sélectionne un autre formulaire de sortie pour certains types de présentation |
0 |
Entraîne le remplissage des valeurs à gauche avec des zéros au lieu des caractères d'espace ASCII |
|
Spécifie la largeur minimale de la sortie |
|
Spécifie un caractère de regroupement pour la sortie numérique |
. |
Spécifie le nombre de chiffres après la virgule décimale pour les types de présentation à virgule flottante et la largeur de sortie maximale pour les types de présentation de chaîne |
|
Spécifie le type de présentation, qui est le type de conversion effectué sur l'argument correspondant |
Ces fonctions sont analogues aux composants que vous trouverez dans le spécificateur de conversion de l'opérateur modulo de chaîne, mais avec des capacités un peu plus grandes. Vous verrez leurs capacités expliquées plus en détail dans les sections suivantes.
le
Commençons avec
| Valeur | Type de présentation |
|---|---|
b |
Entier binaire |
c |
Caractère unique |
ré |
Entier décimal |
e ou E |
Exponentiel |
F ou F |
Point flottant |
g ou g |
Virgule flottante ou exponentielle |
o |
Entier octal |
s |
Chaîne |
X ou X |
Entier hexadécimal |
% |
Pourcentage |
Ce sont comme les types de conversion utilisés avec l'opérateur modulo de chaîne, et dans de nombreux cas, ils fonctionnent de la même manière. Les exemples suivants démontrent la similitude:
>>> "%ré" % 42
«42»
>>> ":ré".format(42)
«42»
>>> "%F" % 2.1
«2.100000»
>>> ":F".format(2.1)
«2.100000»
>>> "% s" % «foobar»
«foobar»
>>> ": s".format(«foobar»)
«foobar»
>>> "%X" % 31
«1f»
>>> ":X".format(31)
«1f»
Cependant, il existe quelques différences mineures entre certains des Python .format() types de présentation et types de conversion d'opérateur modulo de chaîne:
| Type | .format() Méthode |
Opérateur Modulo à cordes |
|---|---|---|
| b | Désigne la conversion d'entiers binaires | Non supporté |
| je, u | Non supporté | Désigne la conversion d'entiers |
| c | Désigne la conversion de caractères et la valeur correspondante doit être un entier | Désigne la conversion de caractères, mais la valeur correspondante peut être un entier ou une chaîne à un seul caractère |
| g, G | Choix entre virgule flottante ou sortie exponentielle, mais les règles régissant le choix sont légèrement plus compliquées | Choisit entre une sortie à virgule flottante ou exponentielle, en fonction de la magnitude de l'exposant et de la valeur spécifiée pour
|
| r, a | Non pris en charge (bien que la fonctionnalité soit fournie par le ! r et !une composants de conversion dans le domaine du remplacement) |
Désigne la conversion avec repr () ou ascii (), respectivement |
| % | Convertit un argument numérique en pourcentage | Insère un littéral '%' caractère dans la sortie |
Ensuite, vous verrez plusieurs exemples illustrant ces différences, ainsi que certaines des fonctionnalités ajoutées de Python .format() types de présentation de méthode. Le premier type de présentation que vous verrez est b, qui désigne conversion d'entiers binaires:
>>> ": b".format(257)
«100000001»
L'opérateur modulo ne prend pas du tout en charge le type de conversion binaire:
>>> '% b' % 257
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans Cependant, l'opérateur modulo permet conversion entière décimale avec l'un des ré, je, et u les types. Seulement le ré le type de présentation indique une conversion entière décimale avec le Python .format() méthode. le je et u les types de présentation ne sont pas pris en charge et ne sont pas vraiment nécessaires.
La prochaine étape est conversion d'un seul caractère. L'opérateur modulo autorise une valeur entière ou un caractère unique avec c type de conversion:
>>> "% c" % 35
'#'
>>> "% c" % '#'
'#'
D’un autre côté, Python .format() requiert que la valeur correspondant à la c le type de présentation doit être un entier:
>>> ": c".format(35)
'#'
>>> ": c".format('#')
Traceback (dernier appel le plus récent):
Fichier "" , ligne 1, dans Lorsque vous essayez de transmettre une valeur d'un type différent, vous obtenez un ValueError.
Pour l’opérateur modulo de chaîne et pour Python .format() , la méthode g type de conversion choisit une sortie à virgule flottante ou exponentielle, selon l'amplitude de l'exposant et la valeur spécifiée pour
>>> ":g".format(3.14159)
«3.14159»
>>> ":g".format(-123456789.8765)
«-1.23457e + 08»
Les règles exactes régissant le choix sont légèrement plus compliquées avec .format() qu'avec l'opérateur modulo. En général, vous pouvez être sûr que le choix aura du sens.
g est identique à g sauf lorsque la sortie est exponentielle, auquel cas le «E» sera en majuscule:
>>> ":G".format(-123456789.8765)
«-1.23457E + 08»
Le résultat est le même que dans l'exemple précédent, mais cette fois avec une majuscule «E».
Remarque: Il y a quelques autres situations où vous verrez une différence entre les g et g types de présentations.
Dans certaines circonstances, une opération à virgule flottante peut entraîner une valeur qui est essentiellement infini. La représentation sous forme de chaîne d'un tel nombre en Python est «inf». Il peut également arriver qu'une opération à virgule flottante produise une valeur qui ne peut pas être représentée sous forme de nombre. Python représente cela avec la chaîne «NaN», Qui veut dire Pas un nombre.
Lorsque vous transmettez ces valeurs à Python .format() , la méthode g le type de présentation produit une sortie en minuscules, et g produit une sortie en majuscules:
>>> X = 1e300 * 1e300
>>> X
inf
>>> ":g".format(X)
«inf»
>>> ":g".format(X * 0)
«nan»
>>> ":G".format(X)
«INF»
>>> ":G".format(X * 0)
«NAN»
Vous verrez un comportement similaire avec le F et F types de présentations également:
>>> ":F".format(X)
«inf»
>>> ":F".format(X)
«INF»
>>> ":F".format(X * 0)
«nan»
>>> ":F".format(X * 0)
«NAN»
Pour plus d'informations sur la représentation en virgule flottante, inf, et NaN, consultez la page Wikipedia sur IEEE 754-1985.
L'opérateur modulo prend en charge r et une types de conversion pour forcer la conversion par repr () et ascii (), respectivement. Python .format() la méthode ne prend pas en charge r et une types de présentation, mais vous pouvez accomplir la même chose avec le ! r et !une composants de conversion dans le domaine du remplacement.
Enfin, vous pouvez utiliser le % type de conversion avec l'opérateur modulo pour insérer un littéral '%' caractère dans la sortie:
>>> "%F%%" % 65,0
'65 .000000% '
Vous n'avez besoin de rien de spécial pour insérer un littéral '%' caractère dans le Python .format() la sortie de la méthode, % type de présentation sert un but pratique différent pour pourcentage de sortie. Il multiplie la valeur spécifiée par 100 et ajoute un signe de pourcentage:
>>> ":%".format(0,65)
'65 .000000% '
Les autres parties de
le
Voici les valeurs possibles pour le
Une valeur utilisant le signe inférieur à (<) indique que la sortie est justifiée à gauche:
>>> "0: <8s".format('foo')
'foo'
>>> "0: <8d".format(123)
«123»
Ce comportement est la valeur par défaut pour les valeurs de chaîne.
Une valeur utilisant le signe supérieur à (>) indique que la sortie doit être justifiée à droite:
>>> "0:> 8s".format('foo')
'foo'
>>> "0:> 8d".format(123)
«123»
Ce comportement est la valeur par défaut pour les valeurs numériques.
Une valeur utilisant un caret (^) indique que la sortie doit être centrée dans le champ de sortie:
>>> "0: ^ 8s".format('foo')
'foo'
>>> "0: ^ 8d".format(123)
«123»
Enfin, vous pouvez également spécifier une valeur à l'aide du signe égal (=) pour le
Lorsque la sortie numérique comprend un signe, il est normalement placé directement à gauche du premier chiffre du nombre, comme illustré ci-dessus. Si =), le signe apparaît sur le bord gauche du champ de sortie et un remplissage est placé entre le signe et le nombre:
>>> "0: + 8d".format(123)
'+123'
>>> "0: = + 8d".format(123)
«+ 123»
>>> "0: + 8d".format(-123)
'-123'
>>> "0: = + 8d".format(-123)
«- 123»
Vous couvrirez le
). (Si vous vous sentez vraiment obligé de garnir un champ avec des accolades, alors il vous suffira de trouver un autre moyen!)
Quelques exemples d'utilisation de
>>> "0: -> 8s".format('foo')
'----- foo'
>>> "0: # <8d".format(123)
«123 #####»
>>> "0: * ^ 8s".format('foo')
'** foo ***'
Si vous spécifiez une valeur pour
le
Vous pouvez contrôler si un signe apparaît dans la sortie numérique avec le +) spécifié dans le
>>> "0: + 6d".format(123)
'+123'
>>> "0: + 6d".format(-123)
'-123'
Ici, vous utilisez le signe plus (+), donc un signe sera toujours inclus pour les valeurs positives et négatives. Si vous utilisez le signe moins (-), seules les valeurs numériques négatives incluront un signe de tête et les valeurs positives ne seront pas:
>>> "0: -6d".format(123)
«123»
>>> "0: -6d".format(-123)
'-123'
Lorsque vous utilisez un seul espace (''), cela signifie qu'un signe est inclus pour les valeurs négatives et un caractère d'espace ASCII pour les valeurs positives:
>>> "0: *> 6d".format(123)
«** 123»
>>> "0: *> 6d".format(123)
«*** 123»
>>> "0: *> 6d".format(-123)
«** - 123»
Étant donné que le caractère espace est le caractère de remplissage par défaut, vous ne remarquerez l'effet de ceci que si un autre
Enfin, rappelez-vous ci-dessus que lorsque vous spécifiez le signe égal (=) pour
le # Sous-composant
Lorsque vous spécifiez un caractère de hachage (#) dans # indicateur de conversion pour l'opérateur modulo de chaîne. Pour les types de présentation binaire, octal et hexadécimal, le caractère de hachage (#) entraîne l'inclusion d'un indicateur de base explicite à gauche de la valeur:
>>> "0: b, 0: #b".format(16)
«10000, 0b10000»
>>> "0: o, 0: #o".format(16)
«20, 0o 20»
>>> "0: x, 0: #x".format(16)
'10, 0x10 '
Comme vous pouvez le voir, l'indicateur de base peut être 0b, 0o, ou 0x.
Pour les types de présentation à virgule flottante ou exponentielle, le caractère de hachage force la sortie à contenir un point décimal, même si la sortie se compose d'un nombre entier:
>>> "0: .0f, 0: #. 0f".format(123)
«123, 123.»
>>> "0: .0e, 0: #. 0e".format(123)
«1e + 02, 1.e + 02»
Pour tout type de présentation autre que ceux indiqués ci-dessus, le caractère de hachage (#) n'a aucun effet.
le 0 Sous-composant
Si la sortie est inférieure à la largeur de champ indiquée et que vous spécifiez le chiffre zéro (0) dans
>>> "0: 05d".format(123)
«00123»
>>> "0: 08.1f".format(12,3)
«000012.3»
Vous l'utiliserez généralement pour les valeurs numériques, comme indiqué ci-dessus. Cependant, cela fonctionne également pour les valeurs de chaîne:
>>> "0:> 06s".format('foo')
«000foo»
Si vous spécifiez les deux 0:
>>> "0: *> 05d".format(123)
«** 123»
0 essentiellement contrôler la même chose, donc il n'y a vraiment pas besoin de spécifier les deux. En réalité, 0 est vraiment superflu et a probablement été inclus pour faciliter la tâche aux développeurs qui connaissent les 0 indicateur de conversion.
le
>>> "0: 8s".format('foo')
'foo'
>>> "0: 8d".format(123)
«123»
Notez qu'il s'agit d'un largeur de champ minimale. Supposons que vous spécifiez une valeur supérieure au minimum:
>>> "0: 2s".format(«foobar»)
«foobar»
Dans ce cas,
le
,) ou un caractère de soulignement (_). Ce caractère sépare ensuite chaque groupe de trois chiffres dans la sortie:
>>> "0:, d".format(1234567)
«1,234,567»
>>> '0: _d'.format(1234567)
«1_234_567»
>>> "0:,. 2f".format(1234567.89)
«1 234 567,89»
>>> «0: _. 2f».format(1234567.89)
«1_234_567.89»
UNE _) peut également être spécifié avec les types de présentation binaire, octal et hexadécimal. Dans ce cas, chaque groupe de quatre chiffres est séparé par un caractère de soulignement dans la sortie:
>>> '0: _b'.format(0b111010100001)
«1110_1010_0001»
>>> '0: #_ b'.format(0b111010100001)
«0b1110_1010_0001»
>>> '0: _x'.format(0xae123fcc8ab2)
«ae12_3fcc_8ab2»
>>> '0: #_ x'.format(0xae123fcc8ab2)
«0xae12_3fcc_8ab2»
Si vous essayez de spécifier
le .
Sous-composant
. spécifie le nombre de chiffres après le point décimal pour les types de présentation à virgule flottante:
>>> "0: 8.2f".format(1234.5678)
«1234.57»
>>> "0: 8.4f".format(1,23)
«1.2300»
>>> "0: 8.2e".format(1234.5678)
«1.23e + 03»
>>> "0: 8.4e".format(1,23)
«1.2300e + 00»
Pour les types de chaîne, .
>>> ": .4s".format(«foobar»)
«foob»
Si la sortie est plus longue que la valeur spécifiée, elle sera tronquée.
La chaîne .format() Méthode: champs de remplacement imbriqués
Rappelez-vous que vous pouvez spécifier soit
>>> w = dix
>>> p = 2
>>> "%*.*F" % (w, p, 123,456) # La largeur est de 10, la précision est de 2
«123,46»
Les valeurs associées sont ensuite extraites de la liste d'arguments. Ceci permet
.format() fournit une capacité similaire en utilisant champs de remplacement imbriqués.
Dans un champ de remplacement, vous pouvez spécifier un ensemble imbriqué d'accolades () qui contient un nom ou un numéro faisant référence à l'un des arguments de position ou de mot clé de la méthode. Cette partie du champ de remplacement sera ensuite évaluée au moment de l'exécution et remplacée à l'aide de l'argument correspondant. Vous pouvez obtenir le même effet que l'exemple d'opérateur modulo de chaîne ci-dessus avec des champs de remplacement imbriqués:
>>> w = dix
>>> p = 2
>>> «2:0.1F'.format(w, p, 123,456)
«123,46»
Ici le 2, qui indique le troisième paramètre positionnel dont la valeur est 123,456. Il s'agit de la valeur à formater. Les champs de remplacement imbriqués 0 et 1 correspondent aux premier et deuxième paramètres positionnels, w et p. Ceux-ci occupent le
Vous pouvez utiliser arguments de mots clés avec champs de remplacement imbriqués ainsi que. Cet exemple est fonctionnellement équivalent au précédent:
>>> w = dix
>>> p = 2
>>> «val:wid.prF'.format(wid=w, pr=p, val=123,456)
«123,46»
Dans les deux cas, les valeurs de w et p sont évalués au moment de l'exécution et utilisés pour modifier le
>>> "0: 10.2f".format(123,456)
«123,46»
L'opérateur modulo chaîne permet uniquement
.format() méthode, vous pouvez spécifier n'importe quelle partie de Dans l'exemple suivant, le type de présentation
>>> poubelle(dix), oct(dix), hex(dix)
('0b1010', '0o12', '0xa')
>>> pour t dans («b», «o», 'X'):
... impression(«0: #type '.format(dix, type=t))
...
0b1010
0o12
0xa
Ici, le caractère de regroupement
>>> «0:grpré'.format(123456789, grp='_')
«123_456_789»
>>> «0:grpré'.format(123456789, grp=',')
«123,456,789»
Ouf! C'était une aventure. La spécification de la chaîne de modèle est pratiquement une langue en soi!
Comme vous pouvez le voir, le formatage des chaînes peut être très finement ajusté lorsque vous utilisez Python. .format() méthode. Next, you’ll see one more technique for string and output formatting that affords all the advantages of .format(), but with more direct syntax.
The Python Formatted String Literal (f-String)
In version 3.6, a new Python string formatting syntax was introduced, called the formatted string literal. These are also informally called f-strings, a term that was initially coined in PEP 498, where they were first proposed.
f-String Syntax
An f-string looks very much like a typical Python string except that it’s prepended by the character F:
>>> F'foo bar baz'
'foo bar baz'
You can also use an uppercase F:
>>> s = F'qux quux'
>>> s
'qux quux'
The effect is exactly the same. Just like with any other type of string, you can use single, double, or triple quotes to define an f-string:
>>> F'foo'
'foo'
>>> F"bar"
'bar'
>>> F'''baz'''
'baz'
The magic of f-strings is that you can embed Python expressions directly inside them. Any portion of an f-string that’s enclosed in curly braces () is treated as an expression. The expression is evaluated and converted to string representation, and the result is interpolated into the original string in that location:
>>> s = 'bar'
>>> impression(F'foo.s.baz')
foo.bar.baz
The interpreter treats the remainder of the f-string—anything not inside curly braces—just as it would an ordinary string. For example, escape sequences are processed as expected:
>>> s = 'bar'
>>> impression(F'foonsnbaz')
foo
bar
baz
Here’s the example from earlier using an f-string:
>>> quantity = 6
>>> item = 'bananas'
>>> price = 1.74
>>> impression(F"quantity item cost $price")
6 bananas cost $1.74
This is equivalent to the following:
>>> quantity = 6
>>> item = 'bananas'
>>> price = 1.74
>>> impression("0 1 cost $2".format(quantity, item, price))
6 bananas cost $1.74
Expressions embedded in f-strings can be almost arbitrarily complex. The examples below show some of the possibilities:
-
Variables:
>>>>>> quantity, item, price = 6, 'bananas', 1.74 >>> F"quantity item cost $price" '6 bananas cost $1.74' -
Arithmetic expressions:
>>>>>> quantity, item, price = 6, 'bananas', 1.74 >>> impression(F'Price per item is $price/quantity') Price per item is $0.29 >>> x = 6 >>> impression(F"x cubed is x**3') 6 cubed is 216 -
Objects of composite types:
>>>>>> une = [[[['foo', 'bar', 'baz'] >>> ré = 'foo': 1, 'bar': 2 >>> impression(F'a = a | d = d") a = ['foo', 'bar', 'baz'] | d = 'foo': 1, 'bar': 2 -
Indexing, slicing, and key references:
>>>>>> une = [[[['foo', 'bar', 'baz'] >>> ré = 'foo': 1, 'bar': 2 >>> impression(F'First item in list a = a[0]") First item in list a = foo >>> impression(F'Last two items in list a = a[-2:]") Last two items in list a = ['bar', 'baz'] >>> impression(F'List a reversed = a[::-1]") List a reversed = ['baz', 'bar', 'foo'] >>> impression(F"Dict value for key 'bar' is d['bar']") Dict value for key 'bar' is 2 -
Function and method calls:
>>>>>> une = [[[['foo', 'bar', 'baz', 'qux', 'quux'] >>> impression(F'List a has len(a) items') List a has 5 items >>> s = 'foobar' >>> F'--- s.upper() ---' '--- FOOBAR ---' >>> ré = 'foo': 1, 'bar': 2 >>> impression(F"Dict value for key 'bar' is d.get('bar')") Dict value for key 'bar' is 2 -
Conditional expressions:
>>>>>> x = 3 >>> y = sept >>> impression(F'The larger of x et y is x if x > y else y') The larger of 3 and 7 is 7 >>> âge = 13 >>> F'I am "a minor" if age < 18 else "an adult".' 'I am a minor.' -
Object attributes:
>>>>>> z = 3+5j >>> z (3+5j) >>> impression(F'real = z.real, imag = z.imag") real = 3.0, imag = 5.0
To include a literal curly brace in an f-string, escape it by doubling it, the same as you would in a template string for Python’s .format() method:
>>> z = 'foobar'
>>> F' z[::-1] '
' raboof '
You may prefix an f-string with 'r' ou 'R' to indicate that it is a raw f-string. In that case, backslash sequences are left intact, just like with an ordinary string:
>>> z = 'bar'
>>> impression(F'foonznbaz')
foo
bar
baz
>>> impression(rf'foonznbaz')
foonbarnbaz
>>> impression(fr'foonznbaz')
foonbarnbaz
Note that you can specify the 'r' first and then the 'f', or vice-versa.
f-String Expression Limitations
There are a few minor restrictions on f-string expression. These aren’t too limiting, but you should know what they are. First, an f-string expression can’t be empty:
>>> F'foobar'
Fichier "" , line 1
SyntaxError: f-string: empty expression not allowed
It isn’t obvious why you’d want to do this. But if you feel compelled to try, then just know that it won’t work.
Additionally, an f-string expression can’t contain a backslash () character. Among other things, that means you can’t use a backslash escape sequence in an f-string expression:
>>> impression(F'foonbar')
Fichier "" , line 1
SyntaxError: f-string expression part cannot include a backslash
>>> impression(F'foo'bar')
Fichier "" , line 1
SyntaxError: f-string expression part cannot include a backslash
You can get around this limitation by creating a temporary variable that contains the escape sequence you want to insert:
>>> nl = "n"
>>> impression(F'foonlbar')
foo
bar
>>> citation = "'"
>>> impression(F'fooquotebar')
foo'bar
Lastly, an expression in an f-string that is triple-quoted can’t contain comments:
>>> z = 'bar'
>>> impression(F'''foo
... z
... baz''')
foobarbaz
>>> impression(F'''foo
... z # Comment
... ''')
Fichier "" , line 3
SyntaxError: f-string expression part cannot include '#'
Note, however, that the multiline f-string may contain embedded newlines.
f-String Formatting
Like Python’s .format() method, f-strings support extensive modifiers that control the final appearance of the output string. There’s more good news, too. If you’ve mastered the Python .format() method, then you already know how to use Python to format f-strings!
Expressions in f-strings can be modified by a .format() template. The syntax is identical. In fact, in both cases Python will format the replacement field using the same internal function. In the following example, !r is specified as a .format() template string:
>>> s = 'foo'
>>> "0!r".format(s)
"'foo'"
This forces conversion to be performed by repr(). You can get essentially the same code using an f-string instead:
>>> s = 'foo'
>>> F"s!r"
"'foo'"
Tous les .format() also work with f-strings:
>>> n = 123
>>> ":=+8".format(n)
'+ 123'
>>> F"n:=+8"
'+ 123'
>>> s = 'foo'
>>> "0:*^8".format(s)
'**foo***'
>>> F"s:*^8"
'**foo***'
>>> n = 0b111010100001
>>> '0:#_b'.format(n)
'0b1110_1010_0001'
>>> F'n:#_b'
'0b1110_1010_0001'
Nesting works as well, like nested replacement fields with Python’s .format() method:
>>> une = [[[['foo', 'bar', 'baz', 'qux', 'quux']
>>> w = 4
>>> F'len(a):0wd'
'0005'
>>> n = 123456789
>>> sep = '_'
>>> F'(n * n):sepd'
'15_241_578_750_190_521'
This means formatting items can be evaluated at run-time.
f-strings and Python’s .format() method are, more or less, two different ways of doing the same thing, with f-strings being a more concise shorthand. The following expressions are essentially the same:
F'!:'
'0!:' .format(<expr>)
If you want to explore f-strings further, then check out Python 3’s f-Strings: An Improved String Formatting Syntax (Course).
Conclusion
In this tutorial, you mastered two additional techniques that you can use in Python to format string data. You should now have all the tools you need to prepare string data for output or display!
You might be wondering which Python formatting technique you should use. Under what circumstances would you choose .format() over the f-string? See Python String Formatting Best Practices for some considerations to take into account.
In the next tutorial, you’re going to learn more about functions in Python. Throughout this tutorial series, you’ve seen many examples of Python’s built-in functions. In Python, as in most programming languages, you can define your own custom user-defined functions ainsi que. If you can’t wait to learn how then continue on to the next tutorial!
[ad_2]