À l'aide !s c :s pour formater une chaîne de caractères en Python

Question

Je suis vraiment curieux :s chaîne de format dans Python 3. La documentation dit - !s est la conversion et qu' :s est format_spec.

Il dit aussi !s s'appliquera str(), mais elle ne dit rien de semblable à propos de :s. Je pense qu'il n'y a pas de différence significative entre eux, mais je veux être sûr. Quelqu'un peut-il préciser ces?

Quelques exemple de code:

print("{!s}".format("this"))
print("{:s}".format("that"))
# I want to be sure that these two are processed identically internally

C'est encore confuse, mais permettez-moi de conclure avec le mien (laïc) de mots.

1. type("whatever".format) toujours str.
2. Utiliser !s si vous voulez convertir l'objet en str avant le formatage.
3. :s signifie que l'objet(ou la conversion d'un objet) sera traitée comme str au cours de certains processus de mise en forme. C'est la valeur par défaut format_spec.

Est quelque chose de mal ici?

Answer 1

!s, et de ses frères !a et !r s'applique str(), ascii() et repr() respectivement avant d'interpolation et de mise en forme. Ceux-ci sont appelés indicateurs de conversion, et font partie de la Chaîne de Format Syntaxe spec, pas le par-mise en forme de champ spec appliqué à des valeurs lors de l'interpolation:

La conversion champ provoque une contrainte de type avant de formater. Normalement, le travail de mise en forme d'une valeur se fait par l' __format__() méthode de la valeur elle-même. Cependant, dans certains cas, il est souhaitable de forcer un type à être mis en forme comme une chaîne de caractères, en substituant sa propre définition de la mise en forme. Par conversion de la valeur à une chaîne de caractères avant d'appeler __format__(), la logique de mise en forme est court-circuité.

En gras c'est moi qui souligne.

:s ne s'applique ensuite du résultat de la conversion (ou de l'objet d'origine si aucune conversion n'a été appliqué), et que si l' __format__ méthode pour le type d'objet prend en charge que l'option de mise en forme. Habituellement, seuls les objets de type str soutenir ce formateur; c'est là en tant que par défaut, surtout parce que la Spécification de Format Mini-Langage permet l'existence d'un type de personnage et parce que le plus âgé % printf-mise en forme du style avait un %s format. Si vous avez essayé d'appliquer l' s type d'un objet qui n'est pas en charge, vous obtiendrez une exception.

Utiliser !s (ou !a ou !r) lorsque vous avez un objet qui n'est pas elle-même une chaîne de caractères et ne prend pas en charge le formatage dans le cas contraire (pas tous les types de le faire) ou format différent de celui de leurs str(), ascii() ou repr() conversions:

>>> class Foo:
...     def __str__(self):
...         return "Foo as a string"
...     def __repr__(self):
...         return "<Foo as repr, with åéæ some non-ASCII>"
...     def __format__(self, spec):
...         return "Foo formatted to {!r} spec".format(spec)
...
>>> print("""\
... Different conversions applied:
... !s: {0!s:>60s}
... !r: {0!r:>60s}
... !a: {0!a:>60s}
... No conversions: {0:>50s}
... """.format(Foo()))
Different conversions applied:
!s:                                    Foo as a string
!r:             <Foo as repr, with åéæ some non-ASCII>
!a:    <Foo as repr, with \xe5\xe9\xe6 some non-ASCII>
No conversions: Foo formatted to '>50s' spec

Note: tous les mise en forme spécifiée par le format spec sont de la responsabilité de l' __format__ méthode; la dernière ligne ne s'applique pas à l'opération d'alignement dans l' >50s mise en forme spec, l' Foo.__format__ méthode utilisée uniquement comme le texte littéral dans une opération de mise en forme (à l'aide d'un !r conversion ici).

Pour les valeurs converties, d'autre part, l' str.__format__ méthode est utilisée et que la sortie est aligné à droite dans une de 50 caractères champ très large, rembourré avec des espaces à gauche.

Answer 2

Vous n'avez pas de chance vous avez utilisé des chaînes de la valeur à formater. À l'aide de pratiquement n'importe quel autre objet, vous obtiendrez à la façon dont ce ne sont pas les mêmes.

Dans (autant que je peux) termes simples:

• L'absence ou l'existence de la conversion option spécifie le type de la valeur que nous allons format et, par extension, qui est - __format__ , nous allons l'appeler. Comme Martjin souligne, en utilisant ce que nous pouvons ignorer certaines de comportement et de traiter la valeur de manière plus générale (comme une chaîne de caractères). Il est disponible en trois saveurs différentes qui correspondent aux trois manières différentes d'un objet peut choisir de représenter lui-même comme une chaîne de caractères.
• Le spécificateur de type, couplé avec d'autres prescripteurs, spécifie comment le type que nous avons devraient enfin être présenté. Pour les chaînes il n'y a pas un riche ensemble d'options (une chaîne de caractères est présenté comme l'est) mais, pour des types comme ints, vous pouvez avoir différentes présentations.

Je pense, cependant, que type est probablement une confusion de nom à donner à ce spécificateur.

Answer 3

À partir de la documentation, Chaîne Python mise en forme:

Le nom_champ est éventuellement suivie par une conversion de champ, qui est précédé par un point d'exclamation '!', et un format_spec, qui est précédée par un signe deux-points ':'.

Donc non, ce n'est pas la même.

Par exemple:

Si vous souhaitez imprimer un flotteur comme une chaîne de caractères, vous avez besoin d'une conversion (float → string).

"{!s}".format(2.1457)
>>> 2.1457
type("{!s}".format(2.1457))
>>> <type 'str'>

Si vous n'utilisez pas la conversion de la marque, vous obtiendrez une erreur.

"{:s}".format(2.1457)
>>> ValueError: Unknown format code 's' for object of type 'float'