Grundlegende Eingabe-, Ausgabe- und Zeichenfolgenformatierung in Python

Um nützlich zu sein, muss ein Programm normalerweise mit der Außenwelt kommunizieren, indem Eingabedaten vom Benutzer abgerufen und dem Benutzer Ergebnisdaten angezeigt werden. Dieses Tutorial führt Sie in die Python-Eingabe und -Ausgabe ein.

Die Eingabe kann direkt vom Benutzer über die Tastatur oder von einer externen Quelle wie einer Datei oder Datenbank erfolgen. Die Ausgabe kann direkt auf der Konsole oder IDE, auf dem Bildschirm über eine grafische Benutzeroberfläche (GUI) oder erneut auf einer externen Quelle angezeigt werden.

In denprevious tutorial dieser Einführungsreihe sind Sie:

Ich habe einen Vergleich einiger verschiedener Paradigmen gesehen, die von Programmiersprachen verwendet werden, um eine bestimmte Iteration zu implementieren
Erfahren Sie mehr über Iterables und Iteratoren, zwei Konzepte, die die Grundlage für eine bestimmte Iteration in Python bilden
Alles zusammengebunden, um mehr über Pythons for-Schleifen zu erfahren

Am Ende dieses Tutorials erfahren Sie, wie Sie:

Übernehmen Sie Benutzereingaben über die Tastatur mit der integrierten Funktioninput()
Anzeige der Ausgabe an der Konsole mit der integrierten Funktionprint()
Formatieren Sie Zeichenfolgendaten mitstring modulo operator

Lassen Sie uns ohne weiteres eintauchen!

Free Bonus:Click here to get a Python Cheat Sheet und lernen Sie die Grundlagen von Python 3 kennen, z. B. das Arbeiten mit Datentypen, Wörterbüchern, Listen und Python-Funktionen.

Eingabe von der Tastatur lesen

Programme müssen häufig Daten vom Benutzer abrufen, normalerweise über die Tastatur. Der einfachste Weg, dies in Python zu erreichen, ist mitinput().

input([])

Liest eine Eingabezeile von der Tastatur.

input() unterbricht die Programmausführung, damit der Benutzer eine Eingabezeile über die Tastatur eingeben kann. Sobald der Benutzer die Taste[.kbd .key-enter]#Enter # drückt, werden alle eingegebenen Zeichen gelesen und als Zeichenfolge zurückgegeben:

>>>

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

Beachten Sie, dass die neue Zeile, die generiert wird, wenn der Benutzer die Taste[.kbd .key-enter]#Enter # drückt, nicht Teil der Rückgabezeichenfolge ist.

Wenn Sie das optionale Argument<prompt> einfügen, zeigtinput() es dem Benutzer als Eingabeaufforderung an, bevor er zum Lesen der Eingabe pausiert:

>>>

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

input() gibt immer einen String zurück. Wenn Sie einen numerischen Typ möchten, müssen Sie die Zeichenfolge mit den integrierten Funktionenint(),float() odercomplex() in den entsprechenden Typ konvertieren:

>>>

 1 >>> n = input('Enter a number: ')
 2 Enter a number: 50
 3 >>> print(n + 100)
 4 Traceback (most recent call last):
 5   File "", line 1, in 
 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

Im obigen Beispiel ist der Ausdruckn + 100 in Zeile 3 ungültig, dan eine Zeichenfolge und100 eine Ganzzahl ist. Zeile 8 konvertiertn in eine Ganzzahl, sodass die Anweisungprint() in Zeile 10 erfolgreich ist.

Python Version Note: Wenn Sie mit Python 2.x-Code arbeiten, stoßen Sie möglicherweise auf einen geringfügigen Unterschied in den Eingabefunktionen zwischen Python-Versionen 2 und 3.

raw_input() in Python 2 liest Eingaben von der Tastatur und gibt sie zurück. raw_input() in Python 2 verhält sich wie oben beschrieben wieinput() in Python 3.

Python 2 hat aber auch eine Funktion namensinput(). In Python 2 liestinput() Eingaben von der Tastatur,parses and evaluates it as a Python expression und gibt dann den resultierenden Wert zurück.

Python 3 bietet keine einzige Funktion, die genau das tut, wasinput()von Python 2 tut. Der Effekt kann in Python 3 mit dem Ausdruckeval(input()) nachgeahmt werden. Dies wird jedoch als Sicherheitsrisiko angesehen, da ein Benutzer damit beliebigen, möglicherweise bösartigen Code ausführen kann.

Weitere Informationen zueval() finden Sie inPython documentation, und inWikipedia eval page finden Sie Informationen zu potenziellen Sicherheitsrisiken.

Ausgabe in die Konsole schreiben

Zusätzlich zum Abrufen von Daten vom Benutzer muss ein Programm dem Benutzer normalerweise auch Daten zurückgeben. Sie können Programmdaten in Python mitprint() auf der Konsole anzeigen.

Unformatierte Konsolenausgabe

Um Objekte auf der Konsole anzuzeigen, übergeben Sie sie als durch Kommas getrennte Argumentliste anprint().

print(, ..., )

Zeigt der Konsole eine Zeichenfolgendarstellung von<obj> an.

Standardmäßig trenntprint() jedes Objekt durch ein einzelnes Leerzeichen und fügt am Ende der Ausgabe eine neue Zeile hinzu:

>>>

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

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

Jeder Objekttyp kann als Argument fürprint() angegeben werden. Wenn ein Objekt keine Zeichenfolge ist, konvertiertprint() es in eine geeignete Zeichenfolgendarstellung, in der es angezeigt wird:

>>>

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


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


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


>>> type(len)


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

Wie Sie sehen, können auch komplexe Typen wie Listen, Wörterbücher und Funktionen mitprint() auf der Konsole angezeigt werden.

Schlüsselwortargumente für`print()`

print() benötigt einige zusätzliche Argumente, die eine bescheidene Kontrolle über das Format der Ausgabe ermöglichen. Jedes dieser Argumente ist ein spezieller Argumenttyp, der alskeyword argument bezeichnet wird. Diese einführende Reihe von Tutorials enthält ein Tutorial zu Funktionen und Parameterübergabe, damit Sie mehr über Schlüsselwortargumente erfahren.

Im Moment müssen Sie Folgendes wissen:

Schlüsselwortargumente haben die Form<keyword>=<value>.
Alle anprint() übergebenen Schlüsselwortargumente müssen am Ende nach der Liste der anzuzeigenden Objekte stehen.

In den folgenden Abschnitten erfahren Sie, wie sich diese Schlüsselwortargumente auf die vonprint() erzeugte Konsolenausgabe auswirken.

Das Schlüsselwortargument`sep=`

Durch Hinzufügen des Schlüsselwortargumentssep=<str> werden Objekte durch die Zeichenfolge<str> anstelle des Standard-Leerzeichens getrennt:

>>>

>>> 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

Geben Siesep='' an, um Objekte ohne Leerzeichen zusammenzudrücken:

>>>

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

Sie können eine beliebige Zeichenfolge als Trennzeichen mit dem Schlüsselwortsep=angeben.

Das Schlüsselwortargument`end=`

Das Schlüsselwortargumentend=<str> bewirkt, dass die Ausgabe durch<str> anstelle der Standard-Zeilenumbruch beendet wird:

>>>

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

Wenn Sie beispielsweise Werte in einer Schleife anzeigen, können Sieend= verwenden, um die Werte in einer Zeile und nicht in einzelnen Zeilen anzuzeigen:

>>>

>>> 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

Jede Zeichenfolge kann als Ausgabe-Terminator mit dem Schlüsselwortend=angegeben werden.

Ausgabestream-Schlüsselwortargumente

print() akzeptiert zwei zusätzliche Schlüsselwortargumente, die sich beide auf die Behandlung des Ausgabestreams auswirken:

file=<stream>: Standardmäßig sendetprint() seine Ausgabe an einen Standard-Stream namenssys.stdout, der normalerweise der Konsole entspricht. Das Argumentfile=<stream> bewirkt, dass die Ausgabe stattdessen an einen alternativen Stream gesendet wird, der mit<stream> bezeichnet ist.
flush=True: Normalerweise puffertprint() seine Ausgabe und schreibt nur zeitweise in den Ausgabestream. flush=True gibt an, dass der Ausgabestream mit jedemprint() zwangsweise geleert wird.

Diese beiden Schlüsselwortargumente werden hier der Vollständigkeit halber dargestellt. Sie müssen sich an dieser Stelle wahrscheinlich nicht zu viele Gedanken über Ausgabestreams machen. Sie werden später in dieser Reihe im Tutorial zu Datei-E / A erläutert.

Formatierte Zeichenfolgenausgabe

print() unterstützt die Formatierung der Konsolenausgabe, die bestenfalls rudimentär ist. Sie können auswählen, wie gedruckte Objekte getrennt werden sollen, und Sie können angeben, was am Ende der gedruckten Zeile steht. Das ist alles.

In vielen Fällen benötigen Sie eine genauere Kontrolle über das Erscheinungsbild der zur Anzeige bestimmten Daten. Python bietet verschiedene Möglichkeiten zum Formatieren von Ausgabezeichenfolgendaten. In diesem Abschnitt erfahren Sie mehr über eines der älteren:string modulo operator.

In neueren Versionen von Python gibt es neuere Möglichkeiten zum Formatieren von Zeichenfolgendaten, die dem Zeichenfolgenmodulo-Operator wohl überlegen sind:string .format() method undf-strings. Weitere Informationen hierzu finden Sie im nächsten Tutorial dieser Reihe. Vielleicht möchten Sie auch diese Artikel lesen:

Obwohl andere Formatierungsoptionen verfügbar sind, wird der String-Modulo-Operator immer noch häufig verwendet. Wenn Sie vorhandenen Python-Code lesen, werden Sie wahrscheinlich auf den String-Modulo-Operator stoßen. Daher ist es hilfreich, sich mit ihm vertraut zu machen.

Note: Wenn Sie mit der Funktionsfamilieprintf()von C, Perl oder Java vertraut sind, werden Sie feststellen, dass diese in Python nicht vorhanden sind. Es gibt jedoch eine gewisse Ähnlichkeit zwischenprintf() und dem String-Modulo-Operator. Wenn Sie also mitprintf() vertraut sind, werden sich viele der folgenden Punkte vertraut fühlen.

Wenn Sie jedoch nicht mitprintf() vertraut sind, machen Sie sich keine Sorgen! Folgendes sollte noch Sinn machen.

Der String Modulo Operator

Dasmodulo operator (%) wird normalerweise mit Zahlen verwendet. In diesem Fall wird der Rest aus der Division berechnet:

>>>

>>> 11 % 3
2

Bei String-Operanden hat der Modulo-Operator eine ganz andere Funktion: die String-Formatierung. (Die beiden Operationen sind einander nicht sehr ähnlich. Sie haben denselben Namen, weil sie durch dasselbe Symbol dargestellt werden:%.)

So sieht die Syntax des String-Modulo-Operators aus:

Auf der linken Seite des Operators% ist<format_string> eine Zeichenfolge, die einen oder mehrere Konvertierungsspezifizierer enthält. Die<values> auf der rechten Seite werden anstelle der Konvertierungsspezifizierer in<format_string> eingefügt. Die resultierende formatierte Zeichenfolge ist der Wert des Ausdrucks.

Beginnen wir mit einem Beispiel. Hier ist eineprint()-Anweisung, die eine formatierte Zeichenfolge mit dem String-Modulo-Operator anzeigt:

>>>

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

Zusätzlich zur Darstellung der String-Modulo-Operation selbst bezeichnet das Zeichen'%' auch die Konvertierungsspezifizierer in der Formatzeichenfolge - in diesem Fall'%d','%s' und'%.2f'.

In der Ausgabe wird jedes Element aus dem Wertetupel in einen Zeichenfolgenwert konvertiert und anstelle des entsprechenden Konvertierungsspezifizierers in die Formatzeichenfolge eingefügt:

Das erste Element im Tupel ist6, ein numerischer Wert, der'%d' in der Formatzeichenfolge ersetzt.
Das nächste Element ist der Zeichenfolgenwert'bananas', der'%s' ersetzt.
Das letzte Element ist der Gleitkommawert1.74, der'%.2f' ersetzt.

Die resultierende Zeichenfolge ist6 bananas cost $1.74, wie im folgenden Diagramm gezeigt:

Wenn mehrere Werte eingefügt werden müssen, müssen sie wie oben dargestellt in ein Tupel eingeschlossen werden. Wenn es nur einen Wert gibt, kann er von selbst angezeigt werden:

>>>

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

Beachten Sie auch, dass der String-Modulo-Vorgang nicht nur zum Drucken dient. Sie können Werte auch formatieren und einer anderen Zeichenfolgenvariablen zuweisen:

>>>

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

(Wenn Sie mit den Funktionen vonprintf() vertraut sind, erinnert dies ansprintf(). Wenn Sie es nicht sind, schwitzen Sie nicht.)

Konvertierungsspezifizierer

Konvertierungsspezifizierer werden in<format_string>angezeigt und bestimmen, wie Werte beim Einfügen formatiert werden.

Ein Konvertierungsspezifizierer beginnt mit einem%-Zeichen und besteht aus folgenden Komponenten:

%[][][.]

% und<type> sind erforderlich. Die übrigen Komponenten in eckigen Klammern sind optional.

Die folgende Tabelle fasst zusammen, was jede Komponente eines Konvertierungsspezifizierers tut:

Komponente Bedeutung

Komponente	Bedeutung
`%`	Führt den Konvertierungsspezifizierer ein
	Zeigt ein oder mehrere Flags an, die eine genauere Kontrolle über die Formatierung ausüben
	Gibt die Mindestbreite des formatierten Ergebnisses an
`.`	Bestimmt die Länge und Genauigkeit der Gleitkomma- oder Zeichenfolgenausgabe
	Gibt die Art der durchzuführenden Konvertierung an

%

Führt den Konvertierungsspezifizierer ein

Zeigt ein oder mehrere Flags an, die eine genauere Kontrolle über die Formatierung ausüben

Gibt die Mindestbreite des formatierten Ergebnisses an

.

Bestimmt die Länge und Genauigkeit der Gleitkomma- oder Zeichenfolgenausgabe

Gibt die Art der durchzuführenden Konvertierung an

Lesen Sie weiter, um mehr darüber zu erfahren, wie diese funktionieren.

Konvertierungstyp

Der Konvertierungstyp<type> ist die letzte Komponente des Konvertierungsspezifizierers:

%[][][.]

Es bestimmt die Art der Konvertierung, die der entsprechende Wert vor dem Einfügen in die Formatzeichenfolge durchläuft. In der folgenden Tabelle sind die möglichen Konvertierungstypen aufgeführt:

Konvertierungstyp

	Konvertierungstyp
`d`,`i`,`u`	Dezimalzahl
`x`,`X`	Hexadezimale Ganzzahl
`o`	Oktale Ganzzahl
`f`,`F`	Gleitkomma
`e`,`E`	Exponentiell
`g`,`G`	Gleitkomma oder Exponential
`c`	Einzelzeichen
`s`,`r`,`a`	String
`%`	Einzelzeichen von`'%'`

d,i,u

Dezimalzahl

x,X

Hexadezimale Ganzzahl

o

Oktale Ganzzahl

f,F

Gleitkomma

e,E

Exponentiell

g,G

Gleitkomma oder Exponential

c

Einzelzeichen

s,r,a

String

%

Einzelzeichen von'%'

In den folgenden Abschnitten erfahren Sie, wie Sie diese Konvertierungstypen verwenden.

Integer-Konvertierungstypen

Die Konvertierungstypend,i,u,x,X undo entsprechen ganzzahligen Werten.

d,i undu sind funktional äquivalent. Sie alle konvertieren das entsprechende Argument in eine Zeichenfolgendarstellung einer Dezimalzahl:

>>>

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

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

Der Wert kann entweder positiv oder negativ sein. Wenn es negativ ist, beginnt der resultierende Wert mit einem'-'-Zeichen.

x undX werden in eine Zeichenfolgendarstellung eines hexadezimalen Ganzzahlwerts konvertiert, undo wird in eine Zeichenfolgendarstellung eines oktalen Ganzzahlwerts konvertiert:

>>>

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

x erzeugt eine Ausgabe in Kleinbuchstaben undX erzeugt Großbuchstaben. (Großbuchstaben'O' ist kein gültiger Konvertierungstyp.)

Mitconversion flags können Sie das resultierende Format zusätzlich steuern. Weitere Informationen hierzu finden Sie in einem der nächsten Abschnitte.

Gleitkommakonvertierungstypen

Die Konvertierungstypenf undF konvertieren in eine Zeichenfolgendarstellung einer Gleitkommazahl, währende undE eine Zeichenfolge erzeugen, die die exponentielle (wissenschaftliche) Notation darstellt:

>>>

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

e erzeugt eine Ausgabe in Kleinbuchstaben undE erzeugt Großbuchstaben.

===== Deep Dive:inf undNaN

Unter bestimmten Umständen kann eine Gleitkommaoperation zu einem Wert führen, der im Wesentlichen unendlich ist. Die Zeichenfolgendarstellung einer solchen Zahl in Python ist'inf'.

Es kann auch vorkommen, dass eine Gleitkommaoperation einen Wert erzeugt, der nicht als Zahl dargestellt werden kann. Python repräsentiert dies mit der Zeichenfolge'NaN'.

Wenn diese Werte mit dem String-Modulo-Operator konvertiert werden, steuert das Zeichen des Konvertierungstyps den Fall der resultierenden Ausgabe. f unde erzeugen eine Ausgabe in Kleinbuchstaben, währendF undE Großbuchstaben erzeugen:

>>>
>>> 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'
Dies ist der einzige Unterschied zwischen den Konvertierungstypenf undF.

Die Umrechnungstypeng undG wählen je nach Größe des Exponenten und dem für.<precision> angegebenen Wert zwischen Gleitkomma- oder Exponentialausgabe. (Siehe unten.) Die Ausgabe entsprichte /E, wenn der Exponent kleiner als-4 oder nicht kleiner als.<precision> ist. Ansonsten ist es dasselbe wief /F:

>>>

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

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

Grundsätzlich können Sie sich diese Konvertierungstypen als eine „vernünftige“ Wahl vorstellen. Sie erzeugen eine Gleitkommaausgabe, wenn der betreffende Wert angemessen geeignet ist, und ansonsten ein Exponentialformat.

Ähnlich wie bei den anderen Gleitkommakonvertierungstypen erzeugtg eine Kleinbuchstabenausgabe undG Großbuchstaben.

Zeichenkonvertierungstypen

c fügt ein einzelnes Zeichen ein. Der entsprechende Wert kann entweder eine Ganzzahl oder eine Einzelzeichenfolge sein:

>>>

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

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

Der Konvertierungstypcunterstützt auch die Konvertierung inUnicode-Zeichen:

>>>

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

s,r unda erzeugen eine Zeichenfolgenausgabe unter Verwendung der integrierten Funktionenstr(),repr() bzw.ascii():

>>>

>>> '%s' % 'foo'
'foo'
>>> '%r' % 'foo'
"'foo'"
>>> '%a' % 'foo'
"'foo'"

Die Ausrichtung und das Auffüllen der Zeichenfolgenausgabe können mit den Spezifizierern<width> und.<precision> gesteuert werden, wie Sie in Kürze sehen werden.

Einfügen eines`'%'`-Zeichens

Geben Sie zwei aufeinanderfolgende%-Zeichen in die Formatzeichenfolge ein, um ein Literalzeichen'%'in die Ausgabe einzufügen. Der erste führt einen Konvertierungsspezifizierer ein (wie üblich), und der zweite gibt an, dass der Konvertierungstyp% ist, was zu einem einzelnen'%'-Zeichen in der Ausgabe führt.

In diesem Beispiel bedeutet%d%% einen dezimalen Ganzzahlkonvertierungstyp, gefolgt von einem Literalzeichen'%':

>>>

>>> 'Get %d%% off on %s today only!' % (30, 'bananas')
'Get 30% off on bananas today only!'

Beachten Sie, dass der Konvertierungstyp%keinen der<values>rechts neben dem String-Modulo-Operator verwendet.

Breiten- und Präzisionsspezifizierer

<width> und.<precision> befinden sich in der Mitte des Konvertierungsspezifizierers:

%[][][.]

Sie bestimmen, wie viel horizontalen Raum ein formatierter Wert einnimmt.

Der`<width>`-Bezeichner

<width> gibt die minimale Breite des Ausgabefelds an. Wenn die Ausgabe kürzer als<width> ist, ist sie standardmäßig in einem Feld mit einer Breite von<width> rechtsbündig und links mit ASCII-Leerzeichen aufgefüllt:

>>>

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

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

(Das Rechtfertigungs- und Füllzeichen kann geändert werden. Sieheconversion flags unten.)

Wenn die Ausgabelänge größer als<width> ist, hat<width> keine Auswirkung:

>>>

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

Jedes dieser Beispiele gibt eine Feldbreite von2 an. Da die zu formatierenden Werte jedoch mehr als zwei Zeichen umfassen, ist das Ergebnis dasselbe wie wenn kein<width> angegeben wird.

Der`.<precision>`-Bezeichner

.<precision> wirkt sich auf die Konvertierungstypen Gleitkomma, Exponential und Zeichenfolge aus.

Für die Typenf,F,e undE bestimmt.<precision> die Anzahl der Stellen nach dem Dezimalpunkt:

>>>

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

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

Für die Typeng undG bestimmt.<precision> die Gesamtzahl der signifikanten Stellen vor und nach dem Dezimalpunkt:

>>>

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

Mit den Typens,r unda formatierte Zeichenfolgenwerte werden auf die durch.<precision> angegebene Länge abgeschnitten:

>>>

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

Es ist sehr üblich, dass<width> und.<precision> zusammen verwendet werden:

>>>

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

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

Als Sternchen (*) kann entweder<width> oder.<precision> angegeben werden. In diesem Fall wird der zu verwendende Wert dem nächsten Element im Tupel<values> entnommen ::

>>>

>>> '%*d' % (5, 123)
'  123'

Dies ist nicht sehr erforderlich, wenn der Wert von<width>als Konstante angegeben wird. Es gibt keinen funktionalen Unterschied zwischen dem oben angegebenen Beispiel und diesem:

>>>

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

Sie können aber auch<width> und.<precision> nach Variablen angeben:

>>>

>>> for i in range(3):
...     w = int(input('Enter width: '))
...     print('[%*s]' % (w, 'foo'))
...
Enter width: 2
[foo]
Enter width: 4
[ foo]
Enter width: 8
[     foo]

Auf diese Weise kann die Breite oder Genauigkeit zur Laufzeit bestimmt werden und möglicherweise von einer Ausführung zur nächsten geändert werden.

Conversion-Flags

Optionale Konvertierung<flags> werden direkt nach dem Anfangszeichen%angegeben:

%[][][.]

Diese ermöglichen eine genauere Kontrolle über die Anzeige bestimmter Konvertierungstypen. <flags> kann eines der in der folgenden Tabelle aufgeführten Zeichen enthalten:

Charakter Kontrollen

Charakter	Kontrollen
`#`	Anzeige des Basis- oder Dezimalpunkts für Ganzzahl- und Gleitkommawerte
`0`	Auffüllen von Werten, die kürzer als die angegebene Feldbreite sind
`-`	Begründung von Werten, die kürzer als die angegebene Feldbreite sind
`+` `' '` (Leerzeichen)	Anzeige des Leitzeichens für numerische Werte

#

Anzeige des Basis- oder Dezimalpunkts für Ganzzahl- und Gleitkommawerte

0

Auffüllen von Werten, die kürzer als die angegebene Feldbreite sind

-

Begründung von Werten, die kürzer als die angegebene Feldbreite sind

+
' ' (Leerzeichen)

Anzeige des Leitzeichens für numerische Werte

In den folgenden Abschnitten wird die Funktionsweise von Konvertierungsflags ausführlicher erläutert.

Das`#` Flag

Bei den Konvertierungstypen Oktal und Hexadezimal bewirkt das Flag#, dass Basisinformationen in die formatierte Ausgabe aufgenommen werden. Für den Konvertierungstypo fügt dieses Flag ein führendes'0o' hinzu. Für die Konvertierungstypenx undX werden führende'0x' oder'0X' hinzugefügt:

>>>

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

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

Das Flag# wird für die Dezimalumrechnungstypend,i undu ignoriert.

Bei Gleitkommawerten erzwingt das Flag#, dass die Ausgabe immer einen Dezimalpunkt enthält. Normalerweise enthalten Gleitkommawerte keinen Dezimalpunkt, wenn keine Ziffern dahinter stehen. Dieses Flag erzwingt die Aufnahme eines Dezimalpunkts:

>>>

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

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

Dies funktioniert auch für Werte, die wie gezeigt in Exponentialschreibweise angezeigt werden.

Das`0` Flag

Wenn ein formatierter numerischer Wert kürzer als die angegebene Feldbreite ist, wird das Feld standardmäßig mit ASCII-Leerzeichen aufgefüllt. Das0-Flag bewirkt stattdessen ein Auffüllen mit'0' Zeichen:

>>>

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

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

Das0-Flag kann mit allen numerischen Konvertierungstypen verwendet werden:d,i,u,x,X,o) s,f,F,e,E,g undG.

Das`-` Flag

Wenn ein formatierter Wert kürzer als die angegebene Feldbreite ist, ist er im Feld normalerweise rechtsbündig. Das--Flag bewirkt, dass der Wert stattdessen im angegebenen Feld linksbündig ausgerichtet wird:

>>>

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

>>> '%-8.2f' % 123.3
'123.30  '

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

Sie können das Flag- mit den Zeichenfolgenkonvertierungstypens,a undr sowie allen numerischen Konvertierungstypen verwenden. Wenn bei numerischen Typen sowohl0 als auch- vorhanden sind, wird0 ignoriert.

Die Flags`+` und`' '`

Standardmäßig haben positive numerische Werte kein Vorzeichen. Das Flag+ fügt links von der numerischen Ausgabe ein Zeichen'+'hinzu:

>>>

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

Das Flag' ' (Leerzeichen) bewirkt, dass positiven numerischen Werten ein Leerzeichen vorangestellt wird:

>>>

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

Diese Flags haben keine Auswirkung auf negative numerische Werte, die immer ein führendes'-'-Zeichen haben.

Festlegen von Werten durch Wörterbuchzuordnung

Die in die Formatzeichenfolge eingefügten<values> können als Wörterbuch anstelle eines Tupels angegeben werden. In diesem Fall muss jeder Konvertierungsspezifizierer einen der Wörterbuchschlüssel in Klammern unmittelbar nach dem Zeichen'%'enthalten.

Hier ist ein Beispiel:

>>>

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

>>> d = {'quantity': 6, 'item': 'bananas', 'price': 1.74}
>>> '%(quantity)d %(item)s cost $%(price).2f' % d
'6 bananas cost $1.74'

Mit dieser Technik können Sie die eingefügten Werte in beliebiger Reihenfolge angeben:

>>>

>>> d = {'quantity': 6, 'item': 'bananas', 'price': 1.74}

>>> '%(quantity)d %(item)s cost $%(price).2f' % d
'6 bananas cost $1.74'

>>> 'It will cost you $%(price).2f for %(item)s, if you buy %(quantity)d' % d
'It will cost you $1.74 for bananas, if you buy 6'

Alle oben gezeigten Conversion-Spezifikatorelemente -<flags>,<width>,.<precision> und<type> - haben immer noch dieselbe Bedeutung:

>>>

>>> 'Quantity: %(quantity)03d' % d
'Quantity: 006'

>>> 'Item:     %(item).5s' % d
'Item:     banan'

Note: Wenn Sie<values> durch Wörterbuchzuordnung angeben, können Sie* nicht verwenden, um<width> oder.<precision> anzugeben.

Python-Ein- und Ausgabe: Fazit

In diesem Tutorial haben Sie Informationen zur Eingabe und Ausgabe von Python und zur Kommunikation Ihres Python-Programms mit dem Benutzer erhalten. Sie sollten jetzt in der Lage sein, Daten vom Benutzer mitinput() abzurufen und Ergebnisse mitprint() auf der Konsole anzuzeigen.

Sie haben auch gelernt, wie Sie dem Benutzer angezeigte Daten durch Formatieren mitstring modulo operator besser darstellen können.

So vielseitig der String-Modulo-Operator auch ist, Python bietet zwei neuere Möglichkeiten zum Formatieren von String-Daten, die noch besser sind:string .format() method undformatted string literal. Gehen Sie zum nächsten Tutorial, um mehr darüber zu erfahren!

TOC

Grundlegende Eingabe-, Ausgabe- und Zeichenfolgenformatierung in Python