{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"pycharm": {
"name": "#%% md\n"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Software Entwicklung \n",
"\n",
"## Kapitel 1: Einführung \n",
"\n",
"### 1.4 Datentypen \n",
"\n",
"Wie bereits erwähnt setzt sich ein Wert in Python zusammen aus\n",
"\n",
"- dem Datentyp (z.B. int
für eine ganze Zahl)\n",
"- der Ausprägung (z.B. die Zahl 17)\n",
"\n",
"des Werts. Beide Informationen werden im Speicher abgelegt und sind\n",
"abrufbar.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.1 Operationen mit Datentypen\n",
"\n",
"Je nach Datentyp können mit einem Wert unterschiedliche Operationen ausgeführt werden. \n",
"Für den Befehl zur Ausführung einer Operation gibt es unterschiedliche Notationen:\n",
"\n",
"- Infix-Notation zwischen zwei Werten, z.B. bei 3 + 4
, um eine Addition auszuführen\n",
"- Funktionsaufruf mit dem Wert als Parameter, z.B. bei Built-In Funktionen wie len(\"Hello World\")
\n",
"- Dot-Notation, d.h. der Operationsaufruf wird mit einem Punkt getrennt direkt an den Wert angängt, z.B. bei \n",
" \"pYthon\".capitalize()
\n",
" \n",
"In jedem Fall wird etwas mit dem Wert \"gemacht\" und ein Ergebniswert zurückgegeben."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"3 + 4"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"len(\"Test\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"\"pYthon\".capitalize()\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Im Folgenden werden die elementaren Datentypen von Python mit ihren Infix-Operationen betrachtet.\n",
"\n",
"#### 1.4.2 Ganze Zahlen\n",
"\n",
"Ganze Zahlen werden in Python als Integer-Werte int
bezeichnet. Anders als in anderen Programmiersprachen \n",
"gibt es keine genaue Vorgabe, wie viele Bytes für einen Integer-Wert verwendet werden. Python nimmt einfach so viele, \n",
"wie für die Darstellung des Werts notwendig sind. In der Konsequenz ist der Wertebereich von Integers nur durch den\n",
"Arbeitsspeicher begrenzt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"big_number = 100 * 100 * 100 * 100 * 100 * 1000000\n",
"print(big_number)\n",
"print(type(big_number))"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Für den Datentyp int
gibt es die üblichen Infix-Rechenoperationen\n",
"\n",
"| *Operation* | *Schreibweise* | *Ergebnis* |\n",
"|----------------|----------------------|----------------|\n",
"| Addition | 1 + 2
| 3
|\n",
"| Subtraktion | 3 - 2
| 1
|\n",
"| Multiplikation | 2 * 3
| 6
|\n",
"| Division | 7 // 3
| 2
|\n",
"| Modulo | 7 % 3
| 1
|\n",
"| Potenzierung | 2 ** 3
| 8
|\n",
"| bitweises AND | 2 & 3
| 2
|\n",
"| bitweises OR | 2 \\| 3
| 3
|\n",
"| bitweises XOR | 2 ^ 3
| 1
|\n",
"| bitweiser Shift links | 3 << 1
| 6
|\n",
"| bitweiser Shift rechts | 8 >> 2
| 2
|\n",
"\n",
"\n",
"Bei der Divison //
handelt es sich um die ganzzahlige Division, bei der das\n",
"Ergebnis auf den nächstgelegenen Integer-Wert abgerundet wird. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"1 + 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"3 - 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"2 * 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"7 // 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"7 % 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"2 ** 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"2 & 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"2 | 3\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"2 ^ 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"3 << 1\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"8 >> 2"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Neben der Dezimalschreibweise können ganze Zahlen auch binär mit dem Präfix 0b
,\n",
"oktal mir dem Präfix 0o
und hexadezimal mit dem Präfix 0x
angegeben werden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"0b111"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"0o15"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"0xAB"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.3 Gleitkommazahlen\n",
"\n",
"Gleitkommazahlen werden in Python float
genannt. Im Gegensatz zu den ganzen Zahlen ist\n",
"die Speicherrepräsentation auf 64 Bit begrenzt und durch IEEE 754 vorgegeben.\n",
"\n",
"![Speicherrepräsentation IEEE754](../img/IEEE754.png \"IEEE754\") \n",
"\n",
"Somit ergibt sich ein Wertebereich von ca. $-10^{308}$ bis $+10^{308}$. \n",
"\n",
"Gleitkommazahlen werden mit einem Dezimalpunkt geschrieben. Die bei den ganzen Zahlen aufgeführten \n",
"Operationen auch bei Gleitkommazahlen möglich - auch in Kombination mit ganzen Zahlen. Der Rückgabewert ergibt sich \n",
"aber immer als eine Gleitkommazahl, sobald einer der Operanden eine Gleitkommazahl ist."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"1.0 + 2.0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"3.0 - 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"2 * 3.2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"7.0 / 3.0"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"7.1 % 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"2.5 ** 3"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Ist bei der Divison //
einer der Operanden eine Gleitkommazahl, so wird das Ergebnis ebenfalls \n",
"abgerundet, jedoch als Gleitkommazahl zurückgegeben.\n",
"\n",
"Die Divison ohne Rundung wird mit einem einfachen Schrägstrich /
ausgedrückt. Sie liefert immer\n",
"eine Gleitkommazahl. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"6 / 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"7 / 3"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"7.0 / 3.0"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Wird der Wertebereich der Gleitkommazahlen verlassen, so ergibt sich entweder der Rückgabewert inf
\n",
"(Infinity) oder eine Fehlermeldung."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"1e308 * 1000\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"2 ** 1e308 "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.4 Zeichenketten\n",
"\n",
"Zeichenketten oder *Strings* (abgekürzt str
) sind ein weiterer Datentyp in Python. String-Literale \n",
"können mit einfachen oder doppelten Hochkommas begrenzt werden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"name = 'Paulus'\n",
"type(name)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python behandelt Strings als Sequenz von einzelnen Unicode-Zeichen, auf die mit einem Index zugegriffen werden kann."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"name[3]\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Auch String-Werte besitzen Infix-Operationen.\n",
"\n",
"| *Operation* | *Schreibweise* | *Ergebnis* |\n",
"|----------------|--------------------------|----------------|\n",
"| Konkatenation | 'A' + 'B'
| 'AB'
|\n",
"| Wiederholung | 3 * 'AB'
| 'ABABAB'
|"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"'A' + 'B'"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"'AB' * 3"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
},
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Für die Ermittlung der *Länge* eines Strings kann die Build-In Funktion len
verwendet werden. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"len('ABC')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Sonderzeichen, die nicht über die Tastatur eingebbar sind, können trotzdem mit Hilfe von *Escape-Sequenzen* in \n",
"einen String eingefügt werden. Sie haben ihren Ursprung aus der Zeit der zeilenorientierten Drucker mit einem\n",
"Druckkopf, den es zu steuern gilt.\n",
"\n",
"| *Escape-Sequenz* | *Bedeutung* | \n",
"|--------------------|-----------------------|\n",
"| \\n
| Neue Zeile |\n",
"| \\r
| Wagenrücklauf | \n",
"| \\t
| Tabulatorsprung | \n",
"| \\\\\\\\
| Das Zeichen \\ | \n",
"| \\\\\"
| Das Zeichen \" | \n",
"| \\\\'
| Das Zeichen ' | \n",
"| \\\\'
| Das Zeichen ' | \n",
"| \\uXXXX'
| Das Unicode-Zeichen XXXX | "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"print(\"Zeile 1 \\n Zeile 2 \\r Text1 \\t Text2\")\n",
"print('Los geht\\'s!')\n",
"print('\\u263A')"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "-"
}
},
"source": [
"Unicode-Zeichen können aus mehreren Bytes bestehen; die aus Programmiersprachen wie *C* bekannte Regel\n",
"\n",
"1 Zeichen im String = 1 Byte\n",
"\n",
"gilt damit **NICHT**."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.5 Bytes\n",
"\n",
"Für die Verwaltung einer Folge von Bytes existiert in Python ein eigner Datentyp bytes
. Ein \n",
"Bytes-Literal ähnelt einem String-Literal, besitzt aber ein Präfix b
\n",
"als Kennzeichen. Es sind dann aber nur\n",
"ASCII-Zeichen als Inhalt erlaubt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"raw_text = b'Hello World'\n",
"type(raw_text)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Infix-Operationen des Bytes-Datentyps entsprechen denen des String-Datentyps. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.6 Boolean\n",
"\n",
"In Python gibt es einen weiteren Datentyp *Boolean* (bool
), der nur die Werte True
\n",
"und False
annehmen kann."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"ja = True\n",
"nein = False\n",
"type(ja)"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Die Infix-Operationen des Datentyps *Boolean* entsprechen den bekannten Operationen der booleanschen Algebra.\n",
"\n",
"| *Operation* | *Schreibweise* | *Ergebnis* |\n",
"|------------------------|--------------------------|----------------|\n",
"| Konjunktion | True and False
| False
|\n",
"| Disjunktion | True or False
| True
|\n",
"| Negation (Präfix) | not True
| False
|"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"(1==1) and (3<2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"True or False"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"not True"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Boolean-Werte sind häufig das Ergebnis eines Vergleichs zweier Werte eines anderen Datentyps.\n",
"\n",
"| *Operation* | *Schreibweise* | *Ergebnis* |\n",
"|------------------------|--------------------------|----------------|\n",
"| Gleichheit | 1 == 2
| False
|\n",
"| Ungleichheit | 1 != 2
| True
|\n",
"| Ordnung | 1 > 2
| False
|"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"1 == 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"1 != 2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"1 > 2"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.7 None\n",
"\n",
"Python stellt die Konstante None
bereit, mit der der Wert *Nichts* ausgedrückt werden kann. \n",
"Die Konstante None
besitzt einen eigenen Datentyp NoneType
.\n",
"\n",
"Die Überprüfung auf None
erfolgt mit dem Vergleichsoperator is
."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"nichts = None\n",
"type(nichts)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"nichts is None\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.8 Operatorpriorität\n",
"\n",
"Enthält ein Python-Ausdruck mehrere Infix-Operationen, so muss geregelt sein, in welcher \n",
"Reihenfolge die Operationen ausgeführt werden (vergleichbar zur *Punkt-vor-Strich*-Regel).\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Die Priorität der Operatoren ist wie folgt festgelegt:\n",
"\n",
"| *Priorität* | *Operator* | *Erläuterung* |\n",
"|----------------|--------------------------|-------------------|\n",
"| _Höchste_ | ( )
| Durch Klammerung kann immer eine abweichende Priorität festgelegt werden |\n",
"| | **
| Exponent |\n",
"| | *, /, //, %
| Multiplikation und Division |\n",
"| | +, -
| Addition und Subtraktion |\n",
"| | <<, >>
| Shift-Operatoren |\n",
"| | &
| bitweises AND |\n",
"| | ^
| bitweises XOR |\n",
"| | \\|
| bitweises OR |\n",
"| | <, >, ==, !=, is
| Vergleiche |\n",
"| | not
| logisches NOT |\n",
"| | and
| logisches AND |\n",
"| _Niedrigste_ | or
| logisches OR |"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"\"b\" > \"c\" or not 3 < 2 "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Im Zweifelsfall aber am Besten lieber klammern, alleine schon für eine bessere Lesbarkeit."
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### 1.4.9 Typumwandlung\n",
"\n",
"Operationen erwarten, dass die Operanden einen bestimmten Datentyp besitzen. So ist z.B. der Modulo-Operator \n",
"%
nur sinnvoll, wenn die Operanden Zahlen sind. Manchmal besitzen Operatoren auch eine unterschiedliche\n",
"Semantik in Abhängigkeit vom Datentyp der Operanden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"3 + 4"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"\"3\" + \"4\""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Daher ist es gelegentlich notwendig, den Datentyp eines Wertes umzuwandeln. Python stellt hierfür eine ganze Reihe \n",
"von Built-In Functions bereit. Eine *implizite Typumwandlung*, bei der der Typ eines Wertes \"en passant\" passend gemacht \n",
"wird, findet in Python - anders als in anderen Sprachen - kaum statt (mit Ausnahme der Umwandlung von ganzen Zahlen in \n",
"Gleitkommawerte).\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"int(\"5\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"int(4.9)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"int(\"Hello\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"int(True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"float(\"5.1\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"float(4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"float(10**310)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%%\n"
},
"slideshow": {
"slide_type": "subslide"
}
},
"outputs": [],
"source": [
"str(10**310)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%%\n"
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"str(3.1415)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"str(True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"ord('A')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"chr(66)"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
},
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Eine Sonderform der Typumwandlung ist die Formatierung beliebiger Werte als lesbarer String.\n",
"Eine einfache Möglichkeit ist die Angabe eines Formatstrings mit dem Präfix f
\n",
"und Platzhaltern für die einzusetzenden Werte."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"article = \"Eis\"\n",
"price = 2.50\n",
"\n",
"f\"{article} kostet {price} Euro\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bei den Platzhaltern kann zusätzlich eine Information zur Mindestbreite etc. hinterlegt werden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"f\"{article:10} kostet {price:2.2f} Euro\""
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Es ist nicht notwendig, die Werte in benannten Variablen vorzuhalten, wenn\n",
"anstelle des Präfix f
die Funktion format
verwendet wird,\n",
"die bei jedem String mit Hilfe der Dot-Notation aufgerufen werden kann."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"\"{:10} kostet {:2.2f} Euro\".format(\"Eis\", 2.5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In diesem Fall kann die Reihenfolge der Parameter und ihr Auftauchen im Ergebnis auch abweichen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"\"{1:10} kostet {0:2.2f} Euro\".format(2.5, \"Eis\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"Hinweis: man findet gelegentlich noch die inzwischen veraltete Form der String-Formatierung, die aber nicht \n",
"mehr verwendet werden sollte."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"pycharm": {
"is_executing": false,
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"\"%-10s kostet %2.2f Euro\" % (\"Eis\", 2.5)"
]
}
],
"metadata": {
"celltoolbar": "Slideshow",
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.9"
},
"pycharm": {
"stem_cell": {
"cell_type": "raw",
"metadata": {
"collapsed": false
},
"source": []
}
}
},
"nbformat": 4,
"nbformat_minor": 1
}