{ "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 }