Formatage d’entrée, de sortie et de chaîne de base en Python

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 vous présentera les entrées et sorties Python.

L’entrée peut provenir directement de l’utilisateur via le clavier ou d’une source externe comme un fichier ou une base de données. La sortie peut être affichée directement sur la console ou l’IDE, sur l’écran via une interface utilisateur graphique (GUI), ou encore sur une source externe.

Dans le previous tutorial de cette série d’introduction, vous:

Vu une comparaison de certains paradigmes différents utilisés par les langages de programmation pour implémenter une itération définie
Connaître les itérables et les itérateurs, deux concepts qui forment la base de l’itération définie en Python

Tout lié pour en savoir plus sur les boucles Python

*À la fin de ce didacticiel, vous saurez comment:*

*Prenez l'entrée utilisateur du clavier avec la fonction intégrée* `+ entrée () +` *
*Afficher la sortie vers la console avec la fonction intégrée* `+ print () +` *
*Formater les données de chaîne avec* l'opérateur modulo de chaîne *

Sans plus tarder, plongeons-nous!

*Bonus gratuit:* lien: [Cliquez ici pour obtenir une feuille de triche Python] et apprenez les bases de Python 3, comme travailler avec des types de données, des dictionnaires, des listes et des fonctions Python.

Lecture de l’entrée depuis le clavier

Les programmes doivent souvent obtenir des données de l’utilisateur, généralement par le biais d’une saisie au clavier. La manière la plus simple d’accomplir cela en Python est d’utiliser + input () +.

+ entrée ([<invite>]) +

_ Lit une ligne d’entrée à partir du clavier. _

+ input () + suspend l’exécution du programme pour permettre à l’utilisateur de saisir une ligne d’entrée à partir du clavier. Une fois que l’utilisateur a appuyé sur la touche [.keys] # Entrée #, tous les caractères saisis sont lus et renvoyés sous forme de chaîne:

>>>

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

Notez que la nouvelle ligne générée lorsque l’utilisateur appuie sur la touche [.keys] # Entrée # n’est pas incluse dans la chaîne de retour.

Si vous incluez l’argument facultatif + <invite> +, + input () + l’affiche comme une invite à l’utilisateur avant de s’arrêter pour lire l’entrée:

>>>

>>> name = input('What is your name? ')
What is your name? Winston Smith
>>> name
'Winston Smith'

+ input () + renvoie toujours une chaîne. Si vous voulez un type numérique, alors vous devez convertir la chaîne au type approprié avec les fonctions intégrées + int () +, + float () + ou + complex () +:

>>>

 1 >>> n = input('Enter a number: ')
 2 Enter a number: 50
 3 >>> print(n + 100)
 4 Traceback (most recent call last):
 5   File "<stdin>", line 1, in <module>
 6 TypeError: must be str, not int
 7
 8 >>> n = int(input('Enter a number: '))
 9 Enter a number: 50
10 >>> print(n + 100)
11 150

Dans l’exemple ci-dessus, l’expression + n + 100 + sur la ligne 3 n’est pas valide car + n + est une chaîne et + 100 + est un entier. La ligne 8 convertit + n + en un entier, donc l’instruction + print () + de la ligne 10 réussit.

*Remarque sur la version Python:* Si vous travaillez avec du code Python 2.x, vous pouvez rencontrer une légère différence dans les fonctions d'entrée entre les versions 2 et 3 de Python.

+ raw_input () + en Python 2 lit les entrées du clavier et les renvoie. + raw_input () + dans Python 2 se comporte exactement comme + input () + dans Python 3, comme décrit ci-dessus.

Mais Python 2 a également une fonction appelée + input () +. En Python 2, + input () + lit l’entrée du clavier, _ analyse et l’évalue comme une expression Python_, puis renvoie la valeur résultante.

Python 3 ne fournit pas une seule fonction qui fait exactement ce que fait + entrée () + de Python 2. L’effet peut être imité en Python 3 avec l’expression `+ eval (input ()) +. Cependant, cela est considéré comme un risque de sécurité car il permet à un utilisateur d’exécuter du code arbitraire, potentiellement malveillant.

Voir la Python documentation pour plus d’informations sur + eval () +, et la https://en.wikipedia.org/wiki/Eval [Wikipedia + page eval +] pour une discussion sur les risques potentiels pour la sécurité.

Écriture de la sortie sur la console

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

Sortie de console non formatée

Pour afficher les objets dans la console, passez-les sous forme de liste d’arguments séparés par des virgules à + print () +.

+ imprimer (<obj>, …, <obj>) +

_ Affiche une représentation sous forme de chaîne de chaque + <obj> + sur la console. _

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

>>>

>>> fname = 'Winston'
>>> lname = 'Smith'

>>> print('Name:', fname, lname)
Name: Winston Smith

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

>>>

>>> a = [1, 2, 3]
>>> type(a)
<class 'list'>

>>> b = -12
>>> type(b)
<class 'int'>

>>> d = {'foo': 1, 'bar': 2}
>>> type(d)
<class 'dict'>

>>> type(len)
<class 'builtin_function_or_method'>

>>> print(a, b, d, len)
[1, 2, 3] -12 {'foo': 1, 'bar': 2} <built-in function len>

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

Arguments de mot-clé à `+ print () +`

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

Pour l’instant, voici ce que vous devez savoir:

Les arguments des mots clés ont la forme + <mot clé> = <valeur> +. *Tout argument de mot-clé passé à + print () + 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 produite par + print () +.

L’argument de mot clé `+ sep = +`

L’ajout de l’argument de mot clé + sep = <str> + entraîne la séparation des objets par la chaîne + <str> + au lieu de l’espace unique par défaut:

>>>

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

>>> print('foo', 42, 'bar', sep='/')
foo/42/bar

>>> print('foo', 42, 'bar', sep='...')
foo...42...bar

>>> d = {'foo': 1, 'bar': 2, 'baz': 3}
>>> for k, v in d.items():
...     print(k, v, sep=' -> ')
...
foo -> 1
bar -> 2
baz -> 3

Pour écraser les objets ensemble sans aucun espace entre eux, spécifiez + sep = '' +:

>>>

>>> print('foo', 42, 'bar', sep='')
foo42bar

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

L’argument de mot-clé `+ end = +`

L’argument du mot clé + end = <str> + entraîne la sortie de la sortie par + <str> + au lieu de la nouvelle ligne par défaut:

>>>

>>> if True:
...     print('foo', end='/')
...     print(42, end='/')
...     print('bar')
...
foo/42/bar

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

>>>

>>> for n in range(10):
...     print(n)
...
0
1
2
3
4
5
6
7
8
9

>>> for n in range(10):
...     print(n, end=(' ' if n < 9 else '\n'))
...
0 1 2 3 4 5 6 7 8 9

Toute chaîne peut être spécifiée comme terminateur de sortie avec le mot-clé + end = +.

Arguments de mot-clé de flux de sortie

+ print () + accepte deux arguments de mots clés supplémentaires, qui affectent tous deux la gestion du flux de sortie:

* + flush = True +: *Ordinairement, + print () + met en mémoire tampon sa sortie et n’écrit dans le flux de sortie que par intermittence. + flush = True + spécifie que le flux de sortie est vidé de force avec chaque + print () +.

Ces deux arguments de mots clés sont présentés ici par souci d’exhaustivité. Vous n’avez probablement pas besoin de vous préoccuper trop des flux de sortie à ce stade. Ils sont abordés plus loin dans cette série dans le didacticiel sur les E/S sur fichiers.

Sortie de chaîne formatée

+ print () + 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 vous pouvez 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 de l’apparence des données destinées à être affichées. Python fournit plusieurs façons de formater les données de chaîne de sortie. Dans cette section, vous découvrirez l’une des plus anciennes: l’opérateur* string modulo *.

Dans les versions récentes de Python, il existe de nouvelles façons de formater les données de chaîne qui sont sans doute supérieures à l’opérateur modulo de chaîne: la méthode string + .format () + et f-strings . Vous en apprendrez plus dans le prochain didacticiel de cette série. Vous pouvez également consulter ces articles:

Bien que d’autres options de formatage soient disponibles, l’opérateur modulo de chaîne est toujours 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 familiariser avec celui-ci.

*Remarque:* Si vous connaissez la https://en.wikipedia.org/wiki/Printf_format_string [`+ printf () +`] famille de fonctions C, Perl ou Java, alors vous verrez que ceux-ci n'existent pas en Python. Cependant, il y a beaucoup de similitudes entre `+ printf () +` et l'opérateur modulo de chaîne, donc si vous êtes familier avec `+ printf () +`, alors beaucoup des éléments suivants vous sembleront familiers.

D’un autre côté, si vous n’êtes pas familier avec + printf () +, alors ne vous inquiétez pas! Les éléments suivants devraient toujours avoir un sens.

L’opérateur String Modulo

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

>>>

>>> 11 % 3
2

Avec les opérandes de chaîne, l’opérateur modulo a une fonction entièrement différente: le formatage de chaîne. (Les deux opérations ne se ressemblent pas vraiment. Ils partagent le même nom car ils sont représentés par le même symbole: +% +.)

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

<format_string> % <values>

Sur le côté gauche de l’opérateur +% +, + <format_string> + est une chaîne contenant un ou plusieurs spécificateurs de conversion. Les + <valeurs> + sur le côté droit sont insérés dans + <format_string> + à 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 une instruction + print () + qui affiche une chaîne formatée à l’aide de l’opérateur modulo de chaîne:

>>>

>>> print('%d %s cost $%.2f' % (6, 'bananas', 1.74))
6 bananas cost $1.74

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

Dans la sortie, chaque élément du tuple de valeurs est converti en 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 + '% d' + dans la chaîne de format.
L’élément suivant est la valeur de chaîne + 'bananas' +, 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 diagramme suivant:

S’il y a plusieurs valeurs à insérer, elles doivent être incluses dans un tuple comme illustré ci-dessus. S’il n’y a qu’une seule valeur, alors elle peut apparaître d’elle-même:

>>>

>>> print('Hello, my name is %s.' % 'Graham')
Hello, my name is Graham.

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

>>>

>>> s = 'Hello, my name is %s.' % 'Graham'
>>> s
'Hello, my name is Graham.'

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

Spécificateurs de conversion

Les spécificateurs de conversion apparaissent dans le "+ <chaîne de format> +" et déterminent la façon dont 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:

_ +% [<flags>] [<width>] [. <precision>] <type> + _

+% + et + <type> + sont requis. Les autres composants indiqués entre crochets sont facultatifs.

Le tableau suivant résume ce que fait chaque composant d’un spécificateur de conversion:

Component Meaning

Component	Meaning
`%`	Introduces the conversion specifier
`<flags>`	Indicates one or more flags that exert finer control over formatting
`<width>`	Specifies the minimum width of the formatted result
`.<precision>`	Determines the length and precision of floating point or string output
`<type>`	Indicates the type of conversion to be performed

%

Introduces the conversion specifier

<flags>

Indicates one or more flags that exert finer control over formatting

<width>

Specifies the minimum width of the formatted result

.<precision>

Determines the length and precision of floating point or string output

<type>

Indicates the type of conversion to be performed

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

Type de conversion

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

_ +% [<flags>] [<width>] [. <precision>] +* + <type> + * _

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

<type> Conversion Type

`<type>`	Conversion Type
`d`, `i`, `u`	Decimal integer
`x`, `X`	Hexadecimal integer
`o`	Octal integer
`f`, `F`	Floating point
`e`, `E`	Exponential
`g`, `G`	Floating point or Exponential
`c`	Single character
`s`, `r`, `a`	String
`%`	Single `'%'` character

d, i, u

Decimal integer

x, X

Hexadecimal integer

o

Octal integer

f, F

Floating point

e, E

Exponential

g, G

Floating point or Exponential

c

Single character

s, r, a

String

%

Single '%' character

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

Types de conversion entiers

Les types de conversion + d +, + i +, + u +, + x +, + X + et + o + correspondent à des valeurs entières.

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

>>>

>>> '%d, %i, %u' % (42, 42, 42)
'42, 42, 42'

>>> '%d, %i, %u' % (-42, -42, -42)
'-42, -42, -42'

La valeur peut être positive ou négative. S’il est négatif, la valeur résultante commencera par un caractère «» - «».

+ x + et + X + se convertissent en une représentation sous forme de chaîne d’une valeur entière hexadécimale, et + o + se convertissent 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 une sortie en minuscules et + X + produit des majuscules. (Les majuscules + 'O' + ne sont pas un type de conversion valide.)

Vous pouvez obtenir un contrôle supplémentaire sur le format résultant en utilisant* des indicateurs de conversion *, dont vous en apprendrez plus dans une prochaine section.

Types de conversion en virgule flottante

Les types de conversion + f + et + F + se convertissent en une représentation sous forme de chaîne d’un nombre à virgule flottante, tandis que + e + et + E + produisent une chaîne représentant une 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 une sortie en minuscules et + E + produit des majuscules.

_ _ ===== 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 qui n’est pas représentable sous forme de nombre. Python représente cela avec la chaîne + 'NaN' +.

Lorsque ces valeurs sont converties avec l’opérateur modulo de chaîne, le caractère du type de conversion contrôle la casse de la sortie résultante. + f + et + e + produisent une sortie en minuscules, tandis que + F + et + E + produisent des majuscules:

>>>

>>> x = float('NaN')
>>> '%f, %e, %F, %E' % (x, x, x, x)
'nan, nan, NAN, NAN'
>>> y = float('Inf')
>>> '%f, %e, %F, %E' % (y, y, y, y)
'inf, inf, INF, INF'

C’est la seule différence entre les types de conversion + f + et + F +. _ _

Les types de conversion + g + et + G + choisissent entre virgule flottante ou sortie exponentielle, en fonction de l’amplitude de l’exposant et de la valeur spécifiée pour +. <Précision> + '. (Voir ci-dessous.) La sortie est identique à `+ e +/+ E + si l’exposant est inférieur à + -4 + ou pas inférieur à +. <Précision> + '. 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 leur convient raisonnablement, et un format exponentiel sinon.

Semblable aux autres types de conversion à virgule flottante, + g + produit une sortie en minuscules et + G + produit des majuscules.

Types de conversion de caractères

+ c + insère un seul caractère. La valeur correspondante peut être soit un entier soit une chaîne de caractères unique:

>>>

>>> '%c' % 97
'a'

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

Le type de conversion + c + prend également en charge la conversion en Unicode:

>>>

>>> '%c' % 8721
'∑'

+ s +, + r + et + a + produisent une sortie de chaîne en utilisant les fonctions intégrées +str()+ `, https://docs.python.org/3/library/functions.html#repr [

TOC

Formatage d’entrée, de sortie et de chaîne de base en Python