Rückblende

Builtin-Funktion str()

Wie bereits bekannt, wandelt die Funktion str Integer und Float-Zahlen in eine Zeichenkette um, wie z.B. die folgende Hexadezimalzahl

In [2]:
x = 0x34567
In [3]:
x
Out[3]:
214375
In [4]:
str(x)
Out[4]:
'214375'

Die print-Funktion wandelt immer jedes Objekt vor der Ausgabe in eine Zeichenkette um:

In [5]:
print(x)
214375

Generell wandelt die Funktion str jedes Objekt in eine Zeichenkette um, wie z.B. die folgende Funktion:

In [6]:
def f(x):
    return x**2
In [7]:
str(f)
Out[7]:
'<function f at 0x7f9b05429158>'

oder die folgenden Zeichenkette:

In [8]:
a = "Dies ist eine Zeile"
In [9]:
str(a)
Out[9]:
'Dies ist eine Zeile'

bzw. auch die folgende mehrzeilige Zeichenkette

In [10]:
b = """Habe nun, ach! Philosophie,
Juristerei und Medizin,
Und leider auch Theologie
Durchaus studiert, mit heißem Bemühn.
Da steh ich nun, ich armer Tor!
Und bin so klug als wie zuvor;"""
In [11]:
str(b)
Out[11]:
'Habe nun, ach! Philosophie,\nJuristerei und Medizin,\nUnd leider auch Theologie\nDurchaus studiert, mit heißem Bemühn.\nDa steh ich nun, ich armer Tor!\nUnd bin so klug als wie zuvor;'
In [12]:
print(b)
Habe nun, ach! Philosophie,
Juristerei und Medizin,
Und leider auch Theologie
Durchaus studiert, mit heißem Bemühn.
Da steh ich nun, ich armer Tor!
Und bin so klug als wie zuvor;

oder auch die komplexe Zahl

In [13]:
c = complex(3,4)
In [14]:
c
Out[14]:
(3+4j)
In [15]:
str(c)
Out[15]:
'(3+4j)'

Builtin-Funktion repr()

In Python gibt es noch eine weitere Funktion repr, die eine eindeutige Beschreibung des jeweiligen Objektes liefern soll und - wenn möglich - aus dieser Beschreibung das jeweilige Objekt auch wieder herstellen kann. Den Unterschied zur Funktion str lässt sich vielleicht mit dem folgenden Beispiel verdeutlichen

In [16]:
str(3) == str("3")
Out[16]:
True

im Gegensatz dazu ist

In [17]:
repr(3) == repr("3")
Out[17]:
False

Warum sehen wir, wenn wir uns die einzelnen Funktionsaufrufe verdeutlichen:

In [18]:
str(3)
Out[18]:
'3'
In [19]:
str("3")
Out[19]:
'3'
In [20]:
repr(3)
Out[20]:
'3'
In [21]:
repr("3")
Out[21]:
"'3'"

An diesem Beispiel erkennt man auch, dass eben die Funktion repr eine eindeutige Beschreibung liefert. Dennoch ist es für die meisten Fälle üblich, eher die str-Funktion zu verwenden.

In [22]:
%%Mooc StringAssessment
Out[22]:

str-Funktion

In der folgenden Zuweisung wird die Variable a vorbesetzt:


    a = """Dies ist ein
eine dreizeilige
Zeichenkette"""

Welches Ergebnis zeigt die String-Funktion: str(a) ?



String-Formatierung

Grundlegendes

In Python ist die Ausgabe von Ergebnissen in der Regel mittels der print-Funktion durchgeführt worden. Dabei werden die entsprechenden Objekte wie z.B. Variable oder Listen automatisch in Zeichenketten umgewandelt und ausgegeben. Zeichenketten sind in Python als eigene Struktur (als eigene Klasse) implementiert, die entsprechende Funktionen (Methoden) enthält, mit der eine Formatierung, wie die Ausgabe auszusehen hat, leicht umzusetzen ist.

str.format

Die Funktion str.format erlaubt eine schönere Formatierung einer Zeichenkette über eine spezielle Syntax:

In [23]:
a = 7.89
In [24]:
b = int(a * 5)
In [25]:
str.format("a = {} und b = {}",a,b)
Out[25]:
'a = 7.89 und b = 39'

Jedesmal, wenn in der ersten Zeichenkette eine geschweifte Klammer auf- und wieder zugeht, dann wird das nächste Argument in der Parameterliste der Funktion format hergenommen und für die geschweiften Klammern ersetzt.

Statt der obigen Formulierung kann jedoch die Funktion format direkt an die Zeichenkette angehängt werden:

In [26]:
c = "a = '{}', b = \"{}\"".format(a,b)
print(c)
a = '7.89', b = "39"

Syntax der Formatierung

Parameter-Indizierung {0},{1},...

In dem obigen Beispiel sind die beiden Parameter durch ihre Reihenfolge ausgegeben worden, im folgenden Beispiel wird durch eine Indizierung die Reihenfolge der Ausgabe festgelegt - d.h. 0 entspricht dem ersten Argument, 1 dem zweiten, usw.

In [27]:
c = "a = '{1}', b = \"{0}\"".format(b,a)
print(c)
a = '7.89', b = "39"

Ausgabe von Listen {0[i]}

Objekte in einer Liste können ebenfalls über ihren Index ausgegeben werden - in den beiden folgenden Beispielen wird nur die Listenvariable als Parameter übergeben, das jeweilige Listenobjekt wird dann durch den Index in einer eckigen Klammer an der 0 für das erste (und in beiden Fällen einzige) Argument angesprochen:

In [28]:
primzahlen = [2,3,5,7,11,13,17,19,23,29]
print("Die erste Primzahl ist {0[0]}, die fünfte Primzahl ist {0[4]}".format(primzahlen))
Die erste Primzahl ist 2, die fünfte Primzahl ist 11
In [29]:
hsz = [['Hochschulzentrum Donau-Ries', 'Emil-Eigner-Straße',1,8672,'Nördlingen'],
       ['Hochschulzentrum Memmingen','Am Galgenberg',1,88770,'Memmingen']]
In [30]:
for adresse in hsz:
    print("{0[0]}: \n\tAdresse: \n\t\t{0[1]} {0[2]}\n\t\t{0[3]} {0[4]}".format(adresse))
Hochschulzentrum Donau-Ries: 
	Adresse: 
		Emil-Eigner-Straße 1
		8672 Nördlingen
Hochschulzentrum Memmingen: 
	Adresse: 
		Am Galgenberg 1
		88770 Memmingen

Fixe Breite {:b}

Wenn z.B. mehrere Werte in einer Tabelle ausgegeben werden sollen, dann ist es lesbarer, wenn diese Werte in einer gleichförmigen Form ausgegeben werden, dies gechieht über die Syntax eines Doppelpunktes und der anschliessenden Zeichenbreite - die Formatierungssyntax muss dabei immer innerhalb der geschweiften Klammern stehen:

In [31]:
print("Tabelle der Potenz-Zahlen ")
print(" x  x**2 x**3 x**4")
for x in range(1,11):
    print("{:2}  {:3} {:4} {:5}".format(x,x**2,x**3,x**4))
Tabelle der Potenz-Zahlen 
 x  x**2 x**3 x**4
 1    1    1     1
 2    4    8    16
 3    9   27    81
 4   16   64   256
 5   25  125   625
 6   36  216  1296
 7   49  343  2401
 8   64  512  4096
 9   81  729  6561
10  100 1000 10000

Formatierung von Integer-Zahlen in unterschiedlichen Datenformaten

Mit der folgenden Syntax kann eine Integer-Zahl in seinen unterschiedlichen Datenformaten sowohl als Dezimalzahl, Binärzahl(b), Oktalzahl(o) oder Hexdezimalzahl(x) ausgegeben werden:

In [32]:
print("Zahlendarstellungen")
print("Dezimal  Hexadezimal Oktal Binär")
for i in range(10):
    print("{0}        0x{0:x}         0o{0:o}   0b{0:b}".format(i))
Zahlendarstellungen
Dezimal  Hexadezimal Oktal Binär
0        0x0         0o0   0b0
1        0x1         0o1   0b1
2        0x2         0o2   0b10
3        0x3         0o3   0b11
4        0x4         0o4   0b100
5        0x5         0o5   0b101
6        0x6         0o6   0b110
7        0x7         0o7   0b111
8        0x8         0o10   0b1000
9        0x9         0o11   0b1001

Zusammen mit der Syntax für die feste Breite kann die Tabelle noch schöner ausgegeben werden, dabei bedeutet die 0 vor der Zahl für die Breite, dass entsprechend mit 0 aufgefüllt wird:

In [33]:
print("Zahlendarstellungen")
print("Dezimal  Hexadezimal   Oktal    Binär")
for i in range(1,11):
    print("     {0:02}         0x{0:02x}    0o{0:02o}   0b{0:04b}".format(i))
Zahlendarstellungen
Dezimal  Hexadezimal   Oktal    Binär
     01         0x01    0o01   0b0001
     02         0x02    0o02   0b0010
     03         0x03    0o03   0b0011
     04         0x04    0o04   0b0100
     05         0x05    0o05   0b0101
     06         0x06    0o06   0b0110
     07         0x07    0o07   0b0111
     08         0x08    0o10   0b1000
     09         0x09    0o11   0b1001
     10         0x0a    0o12   0b1010
In [34]:
%%Mooc StringAssessment
Out[34]:

Tabellenformatierung

Verwenden sie die obige Tabelle der Zahlendarstellungen und erstellen sie eine mehrzeilige Zeichenkette mit einer Zeile pro Zahl und mit einem Semikolon als Trennzeichen für die einzelnen Darstellungen


    zahlendarstellungen = "Dezimal;Hexadezimal;Oktal;Binär\n"
    for i in range(1,11):
        pass

Geben sie den Ausduck an, mit dem pass ersetzt werden muss, sodass das Ergebnis der Tabelle in der Variablen zahlendarstellungen enthalten ist

Ausgabe einer Tabelle zur Zahlendarstellung



Formatierung von Float-Zahlen

Mit der folgenden Syntax kann eine Float-Zahl (Gleitpunktzahl) z.B. mit einer festen Länge (im folgenden Beispiel 3 Ziffern) hinter dem Punkt ausgegeben werden, dabei muss jede Formatierung nach dem Doppelpunkt angegeben werden:

In [35]:
a = 87.456782324
c = "a = '{:.3f}'".format(a)
print(c)
a = '87.457'

Formatierung mittels Schlüsselworten

Anstelle der Formatierung über Indizes, wie es oben beschrieben ist, können auch Schlüsselwörter verwendet werden, dabei müssen die entsprechenden Schlüsselwörter in die geschweiften Klammer (analog wie die 0 oder 1) aber dann auch zusätzlich als Schlüsselwörter in die Funktion übernommen werden:

In [36]:
a = 96
b = 39
c = "a = '{pa}', b = \"{pb}\"".format(pa=a,pb=b)
print(c)
a = '96', b = "39"
In [37]:
%%Mooc MultipleChoiceAssessment
Out[37]:

Formatierung für eine Rechnung

Sie haben folgende Variablen für Produktnummer, Preis und Anzahl für ein bestelltes Produkt und die entsprechende Ausgabe einer Zeilenüberschrift:

    produktnr = '2346767'
    preis = 96.4525
    anzahl = 2
    print('Produkt		Anzahl		Gesamtpreis in €')
    

Wie lautet die Formatierung für eine entsprechende Rechnungszeile?

print('{}\t\t{}\t\t{}'.format(produktnr,anzahl,preis*anzahl))
print('{produktnr}\t\t{anzahl}\t\t{preis}'.format(produktnr,anzahl,preis))
print('{produktnr}\t\t{anzahl}\t\t{preis:.2f}'.format(produktnr,anzahl,preis))
print('{produktnr}\t\t{anzahl}\t\t{preis:.2f}'.format(produktnr=produktnr,anzahl=anzahl,preis=preis))
print('{produktnr}\t\t{anzahl}\t\t{preis:.2f}'.format(produktnr=produktnr,anzahl=anzahl,preis=preis*anzahl))

In [38]:
%%Mooc Video
Out[38]:

Weitere Literatur

In [39]:
%%Mooc WebReference

Fancier Output Formatting

https://docs.python.org/3/tutorial/inputoutput.html#fancier-output-formatting

Hinweis: Einführung in der Ausgabeformatierung

In [40]:
%%Mooc WebReference

Format String Syntax

https://docs.python.org/3/library/string.html#format-string-syntax

Hinweis: Die offizielle Syntax für die Formatierung von Zeichenketten