Formatage de base des entrées, des sorties et des chaînes en Python – Real Python

By | juin 24, 2019

Python pas cher

Pour être utile, un programme doit généralement communiquer avec le monde extérieur en obtenant des données d'entrée de l'utilisateur et en affichant les données de résultat à l'utilisateur. Ce tutoriel va vous présenter les entrées et les sorties Python.

Les entrées peuvent provenir directement de l'utilisateur via le clavier ou de sources externes telles qu'un fichier ou une base de données. La sortie peut être affichée directement sur la console ou IDE, sur l'écran via une interface utilisateur graphique (GUI) ou encore sur une source externe.

Dans le didacticiel précédent de cette série d'introduction, vous:

  • Vu une comparaison de différents paradigmes utilisés par les langages de programmation pour implémenter une itération définie
  • Appris sur les iterables et les itérateurs, deux concepts à la base de l'itération définie en Python
  • Tout est réuni pour en savoir plus sur les boucles d’exploration de Python

À la fin de ce tutoriel, vous saurez comment:

  • Saisissez les entrées utilisateur du clavier avec la fonction intégrée contribution()
  • Afficher la sortie sur la console avec la fonction intégrée impression()
  • Formater les données de chaîne avec le opérateur modulo de chaîne

Sans plus tarder, plongez!

Lecture des entrées du clavier

Les programmes doivent souvent obtenir des données de l'utilisateur, généralement par le biais d'une saisie au clavier. Le moyen le plus simple d’accomplir cela en Python est avec contribution().

contribution([[[[])

Lit une ligne de saisie à partir du clavier.

contribution() met en pause l'exécution du programme pour permettre à l'utilisateur de taper une ligne d'entrée à partir du clavier. Une fois que l'utilisateur appuie sur le Entrer key, tous les caractères saisis sont lus et renvoyés sous forme de chaîne:

>>>

>>> s = contribution()
foo bar baz
>>> s
'foo bar baz'

Notez que la nouvelle ligne générée lorsque l'utilisateur appuie sur la touche Entrer key ne fait pas partie de la chaîne de retour.

Si vous incluez l’option argument, contribution() l'affiche sous forme d'invite à l'utilisateur avant de s'interrompre pour lire l'entrée:

>>>

>>> prénom = contribution('Quel est votre nom? ')
Quel est votre nom? Winston Smith
>>> prénom
'Winston Smith'

contribution() renvoie toujours une chaîne. Si vous voulez un type numérique, vous devez convertir la chaîne en un type approprié avec le int (), flotte(), ou complexe() fonctions intégrées:

>>>

    1 >>> n = contribution('Entrez un numéro:')
    2 Entrez un nombre: 50
    3 >>> impression(n + 100)
    4 Traceback (dernier appel le plus récent):
    5   Fichier "", ligne 1, dans 
    6 Erreur-type: doit être str, pas int
    7 
    8 >>> n = int(contribution('Entrez un numéro:'))
    9 Entrez un nombre: 50
dix >>> impression(n + 100)
11 150

Dans l'exemple ci-dessus, l'expression n + 100 sur la ligne 3 est invalide parce que n est une ficelle et 100 est un entier. Ligne 8 convertit n à un entier si le impression() déclaration à la ligne 10 réussit.

Écrire une sortie sur la console

En plus d’obtenir des données de l’utilisateur, un programme devra également les présenter à l’utilisateur. Vous pouvez afficher les données du programme sur la console en Python avec impression().

Sortie de console non formatée

Pour afficher des objets sur la console, transmettez-les sous forme de liste d’arguments séparée par des virgules. impression().

impression(, ..., )

Affiche une représentation sous forme de chaîne de chaque à la console.

Par défaut, impression() sépare chaque objet par un seul espace et ajoute une nouvelle ligne à la fin de la sortie:

>>>

>>> fname = 'Winston'
>>> lname = 'Forgeron'

>>> impression('Prénom:', fname, lname)
Nom: Winston Smith

Tout type d'objet peut être spécifié comme argument pour impression(). Si un objet n'est pas une chaîne, alors impression() le convertit en une représentation de chaîne appropriée pour l'afficher:

>>>

>>> une = [[[[1, 2, 3]
>>> type(une)


>>> b = -12
>>> type(b)


>>>  = 'foo': 1, 'bar': 2
>>> type()


>>> type(len)


>>> impression(une, b, , len)
[1, 2, 3]    -12 'foo': 1, 'bar': 2 

Comme vous pouvez le constater, même des types complexes comme les listes, les dictionnaires et les fonctions peuvent être affichés sur la console avec impression().

Arguments de mot clé à impression()

impression() prend quelques arguments supplémentaires qui fournissent un contrôle modeste sur le format de la sortie. Chacun de ceux-ci est un type spécial d'argument appelé un argument de mot clé. Cette série d'introduction de didacticiels comprendra un didacticiel sur les fonctions et la transmission de paramètres afin que vous puissiez en savoir plus sur les arguments de mots clés.

Pour le moment, voici ce que vous devez savoir:

  • Les arguments de mots clés ont la forme =.
  • Tous les arguments de mots clés passés à impression() doit venir à la fin, après la liste des objets à afficher.

Dans les sections suivantes, vous verrez comment ces arguments de mots clés affectent la sortie de la console générée par impression().

le sep = Argument de mot clé

Ajout de l'argument de mot clé sep = fait en sorte que les objets soient séparés par la chaîne au lieu de l'espace simple par défaut:

>>>

>>> impression('foo', 42, 'bar')
foo 42 bar

>>> impression('foo', 42, 'bar', SEP='/')
foo / 42 / bar

>>> impression('foo', 42, 'bar', SEP='...')
foo ... 42 ... bar

>>>  = 'foo': 1, 'bar': 2, 'baz': 3
>>> pour k, v dans .articles():
...     impression(k, v, SEP='->')
...
foo -> 1
bar -> 2
baz -> 3

Pour écraser des objets ensemble sans laisser d'espace, spécifiez sep = '':

>>>

>>> impression('foo', 42, 'bar', SEP='')
foo42bar

Vous pouvez spécifier n’importe quelle chaîne arbitraire comme séparateur avec le sep = mot-clé.

le fin = Argument de mot clé

L'argument du mot clé fin = provoque la sortie de se terminer par au lieu de la nouvelle ligne par défaut:

>>>

>>> si Vrai:
...     impression('foo', fin='/')
...     impression(42, fin='/')
...     impression('bar')
...
foo / 42 / bar

Par exemple, si vous affichez des valeurs dans une boucle, vous pouvez utiliser fin = pour que les valeurs soient affichées sur une ligne plutôt que sur des lignes individuelles:

>>>

>>> pour n dans intervalle(dix):
...     impression(n)
...
0
1
2
3
4
5
6
7
8
9

>>> pour n dans intervalle(dix):
...     impression(n, fin=('' si n < 9 autre ' n'))
...
0 1 2 3 4 5 6 7 8 9

Toute chaîne peut être spécifiée comme terminaison de sortie avec fin = mot-clé.

Arguments de mot clé de flux de sortie

impression() accepte deux arguments de mot clé supplémentaires, qui affectent tous deux le traitement du flux de sortie:

  1. fichier =: Par défaut, impression() envoie sa sortie à un flux par défaut appelé sys.stdout, qui est généralement équivalent à la console. le fichier = argument provoque l'envoi de la sortie vers un autre flux désigné par au lieu.

  2. flush = True: Ordinairement, impression() met en mémoire tampon sa sortie et écrit uniquement de manière intermittente dans le flux de sortie. flush = True spécifie que le flux de sortie est vidé de force avec chaque impression().

Ces deux arguments de mots clés sont présentés ici dans un souci de complétude. Vous n’avez probablement pas besoin d’être trop préoccupé par les flux de sortie à ce stade. Ils sont discutés plus tard dans cette série dans le tutoriel sur File I / O.

Sortie de chaîne formatée

impression() prend en charge le formatage de la sortie de la console qui est au mieux rudimentaire. Vous pouvez choisir comment séparer les objets imprimés et spécifier ce qui se passe à la fin de la ligne imprimée. C'est à peu près ça.

Dans de nombreux cas, vous aurez besoin d’un contrôle plus précis sur l’apparence des données destinées à être affichées. Python fournit plusieurs méthodes pour formater les données de chaîne en sortie. Dans cette section, vous découvrirez l’un des plus anciens: le opérateur modulo de chaîne.

Dans les versions récentes de Python, il existe de nouveaux moyens de formater les données de chaîne qui sont sans doute supérieurs à l'opérateur de chaîne modulo: chaîne .format() méthode, et f-strings. Vous en apprendrez plus dans le prochain tutoriel de cette série. Vous pouvez également consulter ces articles:

Bien que d'autres options de formatage soient disponibles, l'opérateur de chaîne modulo est encore largement utilisé. Si vous lisez du code Python existant, vous rencontrerez probablement l’opérateur modulo de chaîne. Il sera donc utile de vous en familiariser.

L'opérateur String Modulo

L'opérateur modulo (%) est généralement utilisé avec des nombres, auquel cas il calcule le reste à partir de la division:

Avec les opérandes de chaîne, l'opérateur modulo a une fonction totalement différente: le formatage de chaîne. (Les deux opérations ne se ressemblent pas vraiment. Elles portent le même nom car elles sont représentées par le même symbole: %.)

Voici à quoi ressemble la syntaxe de l’opérateur modulo de chaîne:

<format_string> % <valeurs>

Sur le côté gauche de la % opérateur, est une chaîne contenant un ou plusieurs spécificateurs de conversion. le sur le côté droit se faire insérer dans à la place des spécificateurs de conversion. La chaîne formatée résultante est la valeur de l'expression.

Commençons par un exemple. Voici un impression() déclaration qui affiche une chaîne mise en forme à l'aide de l'opérateur modulo:

>>>

>>> impression('%ré % s    coûtent $% .2f' % (6, 'bananes', 1,74))
6 bananes coûtent 1,74 $

En plus de représenter l'opération modulo de chaîne elle-même, le '%' caractère désigne également les spécificateurs de conversion dans la chaîne de format – dans ce cas, '%ré', '% s', et '% .2f'.

Dans la sortie, chaque élément du tuple de valeurs est converti en une valeur de chaîne et inséré dans la chaîne de format à la place du spécificateur de conversion correspondant:

  • Le premier élément du tuple est 6, une valeur numérique qui remplace '%ré' dans la chaîne de format.
  • L'élément suivant est la valeur de chaîne 'bananes', qui remplace '% s'.
  • Le dernier élément est la valeur flottante 1,74, qui remplace '% .2f'.

La chaîne résultante est 6 bananes coûtent 1,74 $, comme le montre le schéma suivant:

Illustration de l'utilisation d'un opérateur modulo de chaîne Python
L'opérateur String Modulo

S'il y a plusieurs valeurs à insérer, elles doivent alors être placées dans un tuple, comme illustré ci-dessus. S'il n'y a qu'une seule valeur, alors elle peut apparaître toute seule:

>>>

>>> impression('Bonjour, mon nom est % s' % 'Graham')
Bonjour, je m'appelle Graham.

Notez également que l’opération modulo de chaîne n’est pas uniquement destinée à l’impression. Vous pouvez également formater des valeurs et les affecter à une autre variable de chaîne:

>>>

>>> s = 'Bonjour, mon nom est % s' % 'Graham'
>>> s
«Bonjour, je m'appelle Graham.

(Encore une fois, si vous connaissez les fonctions liées à printf (), alors cela rappelle sprintf (). Si ce n’est pas le cas, ne vous en faites pas.)

Spécificateurs de conversion

Les spécificateurs de conversion apparaissent dans et déterminez comment les valeurs sont formatées lorsqu’elles sont insérées.

Un spécificateur de conversion commence par un % caractère et se compose de ces composants:

%[[[[][[[[][[[[

]

% et sont requis. Les composants restants indiqués entre crochets sont facultatifs.

Le tableau suivant résume le rôle de chaque composant d'un spécificateur de conversion:

Composant Sens
% Introduit le spécificateur de conversion
Indique un ou plusieurs indicateurs qui exercent un contrôle plus précis sur le formatage.
Spécifie la largeur minimale du résultat formaté
. Détermine la longueur et la précision de la sortie en virgule flottante ou en chaîne
Indique le type de conversion à effectuer

Lisez la suite pour plus de détails sur leur fonctionnement.

Type de conversion

Le type de conversion, , est le dernier composant du spécificateur de conversion:

%[[[[][[[[][[[[]

Il détermine le type de conversion que la valeur correspondante subit avant son insertion dans la chaîne de formatage. Voici un tableau qui répertorie les types de conversion possibles:

Type de conversion
, je, vous Entier décimal
X, X Hexadécimal entier
o Entier octal
F, F Point flottant
e, E Exponentiel
g, g Virgule flottante ou exponentielle
c Caractère unique
s, r, une Chaîne
% Unique '%' personnage

Vous verrez comment utiliser ces types de conversion dans les sections suivantes.

Types de conversion entiers

le , je, vous, X, X, et o les types de conversion correspondent à des valeurs entières.

, je, et vous sont fonctionnellement équivalents. Ils convertissent tous l'argument correspondant en une représentation sous forme de chaîne d'un entier décimal:

>>>
>>> '%ré, %je, % u' % (42, 42, 42)
42, 42, 42 '

>>> '%ré, %je, % u' % (-42, -42, -42)
'-42, -42, -42'

La valeur peut être positive ou négative. Si elle est négative, la valeur résultante commencera par un '-' personnage.

X et X convertir en une représentation sous forme de chaîne d'une valeur entière hexadécimale, et o convertit en une représentation sous forme de chaîne d'une valeur entière octale:

>>>

>>> '%X, %X' % (252, 252)
'fc, FC'
>>> '% o' % 16
'20'

X produit des caractères minuscules et X produit en majuscule. (Majuscule 'O' n'est pas un type de conversion valide.)

Vous pouvez obtenir un contrôle supplémentaire sur le format résultant en utilisant drapeaux de conversion, que vous en apprendrez plus dans une section à venir.

Types de conversion en virgule flottante

Types de conversion F et F convertir en une représentation sous forme de chaîne d’un nombre à virgule flottante, tandis que e et E produire une chaîne représentant la notation exponentielle (scientifique):

>>>

>>> '%F, %F' % (3.14159, 3.14)
'3.141590, 3.140000'
>>> '% e, % E' % (1000.0, 1000.0)
'1.000000e + 03, 1.000000E + 03'

e produit des caractères minuscules et E produit en majuscule.

Plongée profonde: inf et NaN

Dans certaines circonstances, une opération en virgule flottante peut entraîner une valeur essentiellement infinie. 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 non représentable par un nombre. Python représente cela avec la chaîne 'NaN'.

Lorsque ces valeurs sont converties avec l'opérateur modulo string, le caractère de type de conversion contrôle la casse de la sortie résultante. F et e produire des caractères minuscules, F et E produire des majuscules:

>>>

>>> X = flotte('NaN')
>>> '%F, % e, %F, % E' % (X, X, X, X)
'nan, nan, NAN, NAN'
>>> y = flotte('Inf')
>>> '%F, % e, %F, % E' % (y, y, y, y)
'inf, inf, INF, INF'

C’est la seule différence entre le F et F types de conversion.

le g et g Les types de conversion choisissent une sortie en virgule flottante ou exponentielle, en fonction de la magnitude de l'exposant et de la valeur spécifiée pour .

. (Voir ci-dessous.) La sortie est la même que e/E si l'exposant est inférieur à -4 ou pas moins de .. Sinon, c’est la même chose que F/F:

>>>
>>> '%g' % 3.14
'3.14'

>>> '%g' % 0.00000003
'3e-08'
>>> '%G' % 0.00000003
'3E-08'

Fondamentalement, vous pouvez considérer ces types de conversion comme un choix «raisonnable». Ils produiront une sortie en virgule flottante si la valeur en question lui convient, et un format exponentiel dans le cas contraire.

Similaire aux autres types de conversion en virgule flottante, g produit des caractères minuscules et g produit en majuscule.

Types de conversion de caractère

c insère un seul caractère. La valeur correspondante peut être un entier ou une chaîne d'un seul caractère:

>>>

>>> '% c' % 97
'une'

>>> '[[[[% c]' % 'y'
'[y]'

le c Le type de conversion prend également en charge la conversion en caractères Unicode:

s, r, et une produire une sortie de chaîne en utilisant les fonctions intégrées str (), repr (), et ascii (), respectivement:

>>>

>>> '% s' % 'foo'
'foo'
>>> '% r' % 'foo'
"'foo'"
>>> '%une' % 'foo'
"'foo'"

La justification et le remplissage de la sortie de chaîne peuvent être contrôlés avec le et .

spécificateurs, comme vous le verrez bientôt.

Insérer un '%' Personnage

Pour insérer un littéral '%' caractère dans la sortie, spécifiez deux fois consécutives % caractères dans la chaîne de format. La première introduit un spécificateur de conversion (comme d'habitude) et la seconde spécifie que le type de conversion est %, ce qui entraîne un seul '%' caractère dans la sortie.

Dans cet exemple, %ré%% signifie un type de conversion entier décimal suivi d'un littéral '%' personnage:

>>>
>>> 'Obtenir %ré%%    éteint allumé % s    aujourd'hui seulement!' % (30, 'bananes')
"Obtenez 30% de réduction sur les bananes aujourd'hui seulement!"

Notez que le % type de conversion ne consomme aucun des à droite de l'opérateur modulo de chaîne.

Spécificateurs de largeur et de précision

et .

assis au milieu du spécificateur de conversion:

%[[[[][[[[][[[[]

Ils déterminent l'espace horizontal occupé par une valeur mise en forme.

le Spécificateur

spécifie la largeur minimale du champ de sortie. Si la sortie est plus courte que , alors, par défaut, il est justifié à droite dans un champ qui est caractères larges, et complétée par des espaces ASCII à gauche:

>>>
>>> '% 5s' % 'foo'
'foo'

>>> '% 3d' % 4
'4'

(La justification et le caractère de remplissage peuvent être modifiés. Voir drapeaux de conversion au dessous de.)

Si la longueur de sortie est supérieure à , puis n'a aucun effet:

>>>

>>> '% 2d' % 1234, '%ré' % 1234
('1234', '1234')
>>> '% 2s' % 'foobar', '% s' % 'foobar'
('foobar', 'foobar')

Chacun de ces exemples spécifie une largeur de champ de 2. Mais comme les valeurs à formater sont plus de deux caractères, le résultat est le même que lorsque aucun est spécifié.

le .

Spécificateur

. affecte les types de conversion virgule flottante, exponentielle et chaîne.

Pour le F, F, e, et E les types, . détermine le nombre de chiffres après la virgule décimale:

>>>
>>> '% .2f' % 123.456789
'123.46'

>>> '% .2e' % 123.456789
'1.23e + 02'

Pour le g et g les types, .

détermine le nombre total de chiffres significatifs avant et après la virgule décimale:

>>>
>>> '% .2g' % 123.456789
'1.2e + 02'

Valeurs de chaîne formatées avec le s, r, et une les types sont tronqués à la longueur spécifiée par .

:

>>>
>>> '% .4s' % 'foobar'
'foob'

Il est très fréquent de voir et .

utilisé ensemble:

>>>
>>> '% 8.2f' % 123.45678
'123.46'

>>> '% 8.3s' % 'foobar'
'foo'

Soit de ou .

peut être spécifié en tant que caractère astérisque (*), auquel cas la valeur à utiliser est extraite du prochain élément de la tuple:

>>>
>>> '%*ré' % (5, 123)
'123'

Cela n’a pas vraiment besoin d’être la valeur est donnée sous forme de constante. Il n’existe aucune différence fonctionnelle entre l’exemple donné ci-dessus et celui-ci:

>>>

>>> '% 5d' % 123
'123'

Mais vous pouvez aussi spécifier et .

par variable:

>>>
>>> pour je dans intervalle(3):
...     w = int(contribution('Entrez la largeur:'))
...     impression('[[[[% * s]' % (w, 'foo'))
...
Entrez la largeur: 2
[foo]
Entrez la largeur: 4
[ foo]
Entrez la largeur: 8
[     foo]

Cela permet de déterminer la largeur ou la précision au moment de l'exécution et éventuellement de changer d'une exécution à l'autre.

Drapeaux de conversion

Conversion facultative sont spécifiés juste après la première % personnage:

%[[[[][[[[][[[[

]

Celles-ci permettent un contrôle plus précis de l'affichage de certains types de conversion. peut inclure n’importe lequel des caractères indiqués dans le tableau suivant:

Personnage Les contrôles
# Affichage du point de base ou du point décimal pour les valeurs entières et à virgule flottante
0 Rembourrage de valeurs plus courtes que la largeur de champ spécifiée
- Justification des valeurs plus courtes que la largeur de champ spécifiée
+
'' (espace)
Affichage du signe de tête pour les valeurs numériques

Les sections suivantes expliquent plus en détail le fonctionnement des indicateurs de conversion.

le # Drapeau

Pour les types de conversion octal et hexadécimal, le # flag permet d’inclure les informations de base dans la sortie formatée. Pour le o type de conversion, ce drapeau ajoute un premier '0o'. Pour le X et X types de conversion, il ajoute un leader '0x' ou '0X':

>>>
>>> '% # o' % 16
'0o20'

>>> '%#X' % 16, '%#X' % 16
('0x10', '0X10')

le # l'indicateur est ignoré pour les types de conversion décimale , je, et vous.

Pour les valeurs en virgule flottante, le # flag force la sortie à toujours contenir un point décimal. Normalement, les valeurs en virgule flottante ne contiennent pas de point décimal s’il n’ya pas de chiffres après. Ce drapeau force l’inclusion d’un point décimal:

>>>

>>> '% .0f' % 123
'123'
>>> '% # 0f' % 123
'123.'

>>> '% .0e' % 123
'1e + 02'
>>> '% # 0e' % 123
'1.e + 02'

Cela fonctionne également pour les valeurs affichées en notation exponentielle, comme indiqué.

le 0 Drapeau

Lorsqu'une valeur numérique formatée est inférieure à la largeur de champ spécifiée, le comportement par défaut consiste à remplir le champ avec des caractères d'espacement ASCII. le 0 drapeau provoque un remplissage avec '0' caractères à la place:

>>>

>>> '% 05d' % 123
'00123'

>>> '% 08.2f' % 1.2
'00001.20'

le 0 flag peut être utilisé avec tous les types de conversion numériques: , je, vous, X, X, o, F, F, e, E, g, et g.

le - Drapeau

Lorsqu'une valeur mise en forme est plus courte que la largeur de champ spécifiée, elle est généralement justifiée à droite dans le champ. le - flag provoque la valeur d'être justifiée à gauche dans le champ spécifié à la place:

>>>

>>> '% -5d' % 123
'123'

>>> '% -8.2f' % 123,3
'123.30'

>>> '% - * s' % (dix, 'foo')
'foo'

Vous pouvez utiliser le - drapeau avec les types de conversion de chaîne s, une, et r, ainsi que tous les types de conversion numérique. Pour les types numériques, si les deux 0 et - sont présents, alors 0 est ignoré.

le + et '' Drapeaux

Par défaut, les valeurs numériques positives n'ont pas de caractère de signe avant. le + drapeau ajoute un '+' caractère à gauche de la sortie numérique:

>>>

>>> '% + d' % 3
'+3'
>>> '% + 5d' % 3
'+3'

le '' (caractère d'espacement) indique que les valeurs numériques positives sont précédées d'un caractère d'espacement:

Ces drapeaux n’ont aucun effet sur les valeurs numériques négatives, qui ont toujours un premier '-' personnage.

Spécification de valeurs par mappage de dictionnaire

le inséré dans la chaîne de format peut être spécifié comme un dictionnaire au lieu d'un tuple. Dans ce cas, chaque spécificateur de conversion doit contenir l’une des clés du dictionnaire entre parenthèses juste après le '%' personnage.

Voici un exemple:

>>>

>>> '%ré % s    coûtent $% .2f' % (6, 'bananes', 1,74)
'6 bananes coûtent 1,74 $'

>>>  = 'quantité': 6, 'article': 'bananes', 'prix': 1,74
>>> '% (quantité) d %(articles    coûtent $% (prix) .2f' % 
'6 bananes coûtent 1,74 $'

En utilisant cette technique, vous pouvez spécifier les valeurs insérées dans n'importe quel ordre:

>>>

>>>  = 'quantité': 6, 'article': 'bananes', 'prix': 1,74

>>> '% (quantité) d %(articles    coûtent $% (prix) .2f' % 
'6 bananes coûtent 1,74 $'

>>> 'Cela vous coûtera $% (prix) .2f    pour %(articles, si vous achetez % (quantité) d' % 
'Il vous en coûtera 1,74 $ pour les bananes, si vous achetez 6'

Tous les éléments de spécificateur de conversion indiqués ci-dessus—, , .

, et —Sont toujours la même signification:

>>>
>>> 'Quantité: % (quantité) 03d' % 
'Quantité: 006'

>>> 'Article:     % (item) .5s' % 
'Article: banan'

Entrée et sortie Python: Conclusion

Dans ce tutoriel, vous avez découvert les entrées et sorties Python et comment votre programme Python peut communiquer avec l'utilisateur. Vous devriez maintenant pouvoir obtenir des données de l’utilisateur avec contribution()et afficher les résultats sur la console avec impression().

Vous avez également appris à rendre les données affichées à l'utilisateur plus présentables en les formatant avec le opérateur modulo de chaîne.

Aussi polyvalent que l’opérateur de modulo de chaîne soit, Python fournit deux méthodes plus récentes pour formater des données de chaîne encore meilleures: la chaîne .format() méthode et le littéral de chaîne formatée. Rendez-vous au prochain tutoriel pour en savoir plus sur eux!