data.PREP #Python – Data Types: Introduction and Ints and Floats
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 17 | |
| Author | 0000-0002-5178-8497 (ORCID) | |
| License | CC Attribution 4.0 International: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/66079 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | |||||
| Genre | |||||
| Abstract |
| ||||
| Keywords |
|
data.PREP #Python11 / 17
10
00:00
Lecture/ConferenceMeeting/InterviewComputer animation
05:22
Lecture/ConferenceComputer animation
10:37
Lecture/ConferenceComputer animationMeeting/Interview
16:18
Computer animationLecture/Conference
Transcript: German(auto-generated)
00:08
Herzlich willkommen zu einer neuen Folge von Data Prep Python. Heute wollen wir uns ansehen, welche Typen es in Programmiersprachen gibt. Was sind Typen? Bislang haben wir zwei verschiedene
00:22
Datentypen kennengelernt, mit denen wir schon einfach Operationen durchgeführt haben, das waren numerische Werte und wir haben zwei verschiedene kennengelernt, das waren nämlich die ganzen Zahlen und die Gleitpunktzahlen in Python Int und Float. Nach dieser Session können
00:41
Sie die anderen Python-Grunddatentypen oder alle vier Python-Grunddatentypen voneinander unterscheiden, aber wichtiger ist, dass Sie auch den Zweck kennen, warum es überhaupt diese vier unterschiedlichen Datentypen gibt. Sie können das dann erläutern und vor allen Dingen sich dann
01:00
eben überlegen, wenn Sie selbst Programme schreiben und Daten auswerten, welche Typen brauchen Sie eigentlich für welchen Zweck und das wollen wir uns gleich am Code ansehen. Ich hatte eben schon gesagt, es gibt in Python vier Grunddatentypen und diese vier Grunddatentypen gibt es in praktisch allen Programmiersprachen. Das schauen wir uns im Einzelnen an. Int sind ganze Zahlen und ein
01:26
Beispiel dafür hatten wir Ihnen auch schon genannt, ist so eine Zahl 42 oder Float, das sind die Gleitpunktzahlen auf Englisch, Deutsch leider Gleitkommazahlen, also Floating Point Numbers und das wollen wir uns in Beispielen an und zwei weitere Datentypen möchte ich jetzt einführen,
01:43
das sind einerseits Buche-Werte, Wahrheitswerte und andererseits Strings, das schauen wir uns jeweils im Code an. Schauen wir als erstes einen Wert, einen Zahlwert, der Wert 42 und wir haben eine Funktion type und die verrät uns, welchen Typ hat der Wert 42 und gibt den hier aus. Das heißt
02:05
type, der Datentyp von dieser Zahl 42 ist ganze Zahl auf Englisch integer und als Python Name int. Genauso können wir uns ansehen eine Gleitpunktzahl, auch die haben wir schon kennengelernt, hier
02:21
abgekürzt ein bisschen Pi, also der Typ dieser Gleitpunktzahl, wenn wir den uns ansehen wollen und wenn der Interpreter uns den erklären soll, ist Float. Jetzt habe ich schon darauf hingewiesen, leider gibt es so eine unterschiedliche Konvention, im anglo-saxischen Raum werden
02:46
Gleitpunktzahlen mit Punkten getrennt, hier 3.1415, während im deutschen leider Gleitkommazahlen verwendet werden. Deshalb ein Hinweis schon mal, es kann ihnen passieren, dass sie aus der deutschen Mathematik kommt aus Versehen eine Gleitkommazahl schreiben und dann
03:07
kommt hier eine Fehlermeldung zustande. Das heißt, wenn wir eine Gleitpunktzahl haben wollen, dann müssen wir die mit Punkt schreiben. So schauen wir die beiden anderen Typen an, die wir jetzt neu einführen. Das eine ist ein Typ für Wahrheitswerte. Gut und Wahrheitswerte sind
03:27
binäre Werte. Eine Aussage ist entweder wahr oder sie ist falsch und dafür gibt es eben in Grammiersprachen auch einen Typ, also einen binären Typ, der diese beiden Wahrheitswerte
03:41
unterscheidet und weil die meisten Dinge englisch benannt werden, sind die Werte, die wir in diesem Typ haben einmal true und einmal false und das hatte ich ja auch schon als Beispiel für nicht erlaubte Namen verwendet, diese Bezeichnung true. Der Wahrheitswert true ist natürlich wahr und der falsche wird dann als false geschrieben. Sie sehen, dass auch beides wieder hervorgehoben als
04:05
reservierte Worte. So und wir sehen auch hier wieder, der Typ wird also als bool bezeichnet. Boolean Werte sind eben die, die eben genau nur zwei verschiedene Werte einnehmen können. Und letztlich gibt es noch einen Wert Text, einen Datentyp Text und das habe ich hier eingegeben.
04:28
Der Wert ist hier, das ist ein Text und Sie sehen, dass der zwischen solchen einfachen Hochkommata geschrieben wird. Und jetzt die Frage, ich hatte schon gesagt, diese vier Datentypen gibt es praktisch in allen Programmiersprachen und die Frage ist, warum ist das so? Wir haben so
04:45
unterschiedliche Sprachen, die über Jahre gewachsen sind und immer wieder sind die Grunddatentypen die gleichen. Der Grund ist, dass das die Basis ist, eigentlich um generell mit Daten arbeiten zu Das reicht auch aus, um auf der Basis dieser Grunddatentypen dann weitere komplexe Daten
05:00
aufzubauen. Und wenn wir überlegen, warum, was unterscheidet jetzt oder warum sind das die Grunddatentypen, dann können wir sagen, okay, wenn wir Programme schreiben, dann wollen wir Dinge abzählen, dann wollen wir Dinge nummerieren, Indizes schreiben oder wir wollen etwas kodieren. Also häufig sehen Sie ja, dass irgendwie ein Etikett mit irgendeinem QR-Code ausgezeichnet ist
05:25
und da steht dann auch irgendeine Nummer, das sind immer wieder ganze Zahlen. Oder man kann auch Zustände kodieren mit, ich bin im Zustand eins oder zwei oder drei, man kann also zwischen Programmen hin und her wechseln und so weiter. Für all diese Dinge brauchen wir immer ganze Zahlen, also dass man etwas abzählen kann und dann eben andieren kann und so weiter. Und diese ganzen Zahlen haben
05:44
wir kennengelernt, sind in Python eben der Typ int. Dann für float, das war ja auch schon kein Gleitpunktzahlen, das sind dann eben die Zahlen, die Werte im Programm, die physikalische Werte repräsentieren. Also zum Beispiel Messdaten, irgendwelche Messreihen, wie Temperaturen oder
06:07
Schneehöhe oder Regenmenge und so weiter. Das sind in der Regel keine ganzen Zahlen, sondern die sind eben Gleitpunktzahlen. Und dafür haben wir eben in Python den Typ float. Jetzt ist die Frage, warum brauchen wir boolean, also bool, und warum brauchen wir Text? Text brauchen wir in Programmen,
06:26
weil Programme mit Menschen interagieren. Das heißt, die müssen, wenn irgendwelche Dinge berechnet wurden, wenn irgendwelche Datenstrukturen aufgebaut wurden, wenn welche Analysen stattgefunden haben, dann müssen die Programme ja den Menschen, die diese Programme nutzen,
06:41
auch das Ergebnis präsentieren, also mitteilen. Und Menschen können eben Texte lesen, in denen auch Ziffern und Werte und Tabellen und so weiter vorkommen. Sie können aber nicht die interne Repräsentation der Werte auf dem Rechner verstehen, denn die sind alle binärkodiert. Das heißt,
07:02
in Wirklichkeit ist es immer eine lange Folge von Nullen und Einsen, aber um jetzt die Information rüberzugeben an Menschen, müssen wir das lesbar ausgestalten. Und dafür braucht man den Typ string für Text. Genauso umgekehrt, wenn Menschen Werte eingeben, wenn sie irgendwelche Erklärungen
07:22
schreiben wollen, auch dafür brauchen sie eben Text, den man eingeben kann. Und der letzte Typ ist dann boolean, bool, das sind die Wahrheitswerte. Und wofür sind die in Programmen, in allen Werte? Die brauchen wir für Programmsteuerung. Bisher haben wir immer nur einzelne Zellen oder
07:43
mehrere Anweisungen innerhalb einer Zelle geschrieben und die wurden immer von oben nach unten ausgeführt. Programme sind aber nicht so einfach, dass sie immer genau den gleichen Ablauf nehmen, sondern unter bestimmten Bedingungen verhalten sie sich verschieden. Also sie wollen darauf reagieren, was genau die
08:02
aktuellen Werte sind, was ein Nutzer eingegeben hat, welche Sensordaten gerade geliefert wurden. Das heißt, dafür muss man im Programm immer wieder Daten auswerten, Sensoren auswerten, Bedingungen auswerten. Und in Abhängigkeit der Bedingungen kann man dann sagen, dann will ich diesen Code so ausführen oder ich will was anderes machen oder ich muss einen Alarm geben, weil jetzt
08:24
hier ein Grenzwert überschritten wurde. Das sind also immer wieder Bedingungen. Das heißt, es liegen irgendwelche Werte vor und ich muss diesen Wert vergleichen mit, hat das einen Grenzwert überschritten? Und das Ergebnis ist entweder wahr oder falsch. Und wenn es wahr ist, dann muss ich Alarm setzen,
08:41
solange der Grenzwert noch nicht überschritten ist, falls kann ich was anderes machen, den normalen Programm Code weiterführen. Das sind also die vier Grunddatentypen, die wir haben und alles andere lässt sich dann als Kombination dieser Grunddatentypen in Peifen ausdrücken. Also wenn wir eine ganze Studie haben und Messreihen über verschiedene Werte und das 100.000 Werte hintereinander, dann
09:06
haben wir dafür eine ganze Reihe, eine Sequenz von vielen Messwerten. Meistens haben wir irgendwelche Kombinationen, also einen Messwert zu einem bestimmten Zeitpunkt. Dann hat man also zwei Werte, die man irgendwie als Tupel oder irgendwie zusammenfasst als eine Einheit. Oder wir kennen
09:23
Spreadsheets, um irgendwelche Daten auszuwerten, wo man eben eine ganze Menge von Daten in Spalten aufgliedert und dann davon mehrere Ausführungen hat. Also solche Dinge, das sind dann Zusammensetzungen. Jede einzelne Zelle in einem Spreadsheet hat halt einen Datentyp und dieser komplexe Datentyp ist
09:43
eben zusammengesetzt als eine Art Tabelle von verschiedenen Grunddatentypen. Aber auch Bilder, Videos, Audio, alles was wir eben auf dem Rechner kennen, was wir sehen, wenn wir uns ein Video ansehen, ist natürlich intern codiert mit Binärwerten und die basieren wiederum auf einer
10:03
Kombination von verschiedenen Grunddatentypen. Also Bilder sind die Werte als Ganzzahl, die jedes einzelne Pixel auf dem Bildschirm hat, um die Helligkeit oder die Farbe und so weiter für jedes Pixel einzeln zu codieren. Dafür haben wir dann die ganzen Zahlen. Und ein Gesamtbild setzt sich
10:23
zusammen aus der Menge aller Pixel, die eben dieses Bild hat. Okay, wir kennen jetzt unsere Grunddatentypen und die können wir natürlich dann auch entsprechend verschiedenen Variablen zuweisen und entsprechend die Operationen drauf ausführen. Wenn wir also eine Studie haben und
10:40
wir wollen eben auswerten, wie viele haben an der Studie teilgenommen, dann können wir uns eine variable Samplesize überlegen, der weisen wir den Wert 200 zu. Und wenn wir jetzt mit der Samplesize irgendetwas machen wollen, dann können wir eben auch wieder immer fragen, welchen Typ hat denn jetzt der Wert, der in der variable Samplesize gespeichert ist. Und das wäre wieder mit unserem
11:02
Type-Funktion wäre das eben der Typ int. Genauso können wir sagen, wir haben eine Messreihe von Temperaturwerten über den Tag, wie sich so die Temperatur entwickelt, die können wir dann immer zuweisen an einer variablen Temperature. Und der Type dieser variablen Temperature, der Wert, der darin gespeichert ist, ist Float. Oder meine Studie heißt dann My Awesome Analysis. Auch hier
11:25
sehen wir wieder, dass eben Texte dann eben entsprechend für die Ausgabe der Gesamtresultate zum Beispiel verwendet werden. Oder auch hier wieder nochmal ein Beispiel für eine Buhlsche Variable, die eben auch wieder deutlich ausdrückt, welcher Typ eigentlich dahinter stecken soll. Das ist
11:43
die sinnvolle Benennung von Variablen. Wenn ich meine Auswertung vollständig habe, dann will ich eine Variable oder in einer Variablen will ich mir merken, während der Auswertung ist die Auswertung denn schon vollständig. Und dann kann ich fragen, ja der Typ davon ist False. Wenn ich
12:03
dann meine Studie vollständig ausgewertet habe, dann kann ich im Programm zum Beispiel das Ganze auf True setzen und das ist dann True. So jetzt habe ich das alles einzeln gezeigt. Wir können auch mit Print Anweisungen uns die Typen von Variablen eben mit Print Anweisungen ansehen.
12:24
Und das möchte ich an der Stelle eben nebenbei einführen. Wir sehen Print, haben wir bis jetzt immer mit einem Argument hier verwendet. Wir können aber auch mehrere angeben. Wir können also hier Print 1 plus 2 Arguments and more. Das heißt hier ist durch Komma getrennt in der Print Methode,
12:43
in der Print Funktion mehrere Argumente mitgegeben und dann gibt diese Print Funktion alle drei hintereinander aus. We can print 1 plus 2 wird ausgerechnet als der Wert 3. We can print 3 und dann Arguments and more und so weiter. Das ist der Text. So warum habe ich Ihnen das gezeigt? Weil
13:03
die Ausgaben, die ich bis jetzt immer so einzeln gemacht habe, muss ich jetzt ja immer einzeln zuordnen. Hier steht Class Int in der ersten Zeile. Das war das erste Print. Da ist die Variable Sample Size gemeint. Dann kommt in der dritten Zeile String. Dann muss ich wieder hier oben gucken, was ist mein drittes Print und so. Dann sehe ich hier auch Study Title. Das Ganze
13:24
kann ich auch etwas schöner aufbereiten, indem ich zum Beispiel das, was ich ausgebe auch in der Statistik. Nicht, wenn ich hier ein Beispiel kurz etwas schreibe, aber für Programme, die Sie entwickeln, ist es sinnvoll, damit Sie nicht das ganze Programm immer durchgehen müssen, wenn Sie
13:43
mehrere Print Anweisungen haben. Was wird da eigentlich ausgegeben, wenn da ein Wert ausgegeben wird? Und deshalb ist es oft schön zu sagen, okay, hier gebe ich den Wert der Variablen Sample Size aus. Dann ist das zweite Argument genau die Variable Sample Size. Und jetzt, weil wir die
14:00
Informationen zusammen haben wollen, schreibe ich auch noch den Typ hin. Welchen Typ hat denn diese Variable oder der Wert in der Variablen? Und dann frage ich auch nochmal das Ergebnis dieser Typabfrage. Und das mache ich jetzt in vier Zeilen nacheinander. Und dadurch sehen wir eben, dass das Ganze jetzt für sich ganz gut lesbar ist. Die Variable Sample Size hat den Wert 200 und ist
14:22
vom Typ Int. Und die Variable DataComplete ist momentan true und ist von der Klasse Boolean. Gut, damit haben wir kennengelernt die vier Grunddatentypen und wie wir entsprechende Variablen benennen. Jetzt gibt es auch noch den Fall, dass wir zwischen Typen konvertieren
14:42
wollen. Intern werden alle Werte ja als Folge von Nullen und Einsen kodiert. Das heißt, ich kann eigentlich einen Wert einer Variablen zuweisen und dadurch wird bestimmt, wie es interpretiert wird. Also wenn wir hier sagen Sample Size ist 245 und ich schreibe das jetzt in diesen Hochkommata,
15:04
dann habe ich hier in Wirklichkeit nicht einen Wert 245 zugewiesen, sondern die Zeichenfolge 245. Das passiert immer dann, wenn ich in einem Programm einen Wert von einem Nutzer einlese und tippe dann 245. Aber das Eingelesene wird nicht als die Zahl 245 gesetzt, sondern da die Tastatur
15:29
ja nicht definiert, was wird gerade geschrieben, Buchstaben oder Ziffern, wird es immer eine Eingabe von der Tastatur als Zeichenfolge, als String interpretiert. Das heißt hier,
15:41
wenn etwas von der Tastatur zum Beispiel kommt, wird es also der Variablen Sample Size als der String mit der Ziffernfolge 245 zugewiesen. Das können wir immer wieder in unserem Programm überprüfen und wir sehen eben, das ist der Typ String. Dann hatte ich noch eine Variable und ich möchte auf die Variable Participants die aktuelle Anzahl der Teilnehmer aufaddieren,
16:07
die ich ja vermeintlich, weil ich es über Tastatur eingegeben habe, als die Zahl 245 dem Programm mitgeteilt habe. Wenn ich versuche das auszurechnen, Participants plus gleich Sample Size, dann will ich das aufaddieren und sehe, ohje, es funktioniert nicht. Wir müssen wieder in den
16:25
Fehler reinschauen, um zu verstehen, was hier passiert ist. Es gibt den sogenannten Type Error und hier sehen wir eben, dass Variablen unterschiedliche Typen haben können und dass die Operationen, die man ausführt, in dem Fall auf Participants Sample Size aufaddieren,
16:41
sind davon abhängig, ob die Typen da zueinander passen. Was uns der Interpreter hier an dieser Stelle sagt, ist unsupported operant types vor plus gleich, also für das Aufaddieren in der Variable Participants, weil die eine Variable hat den Typ Int, die andere aber String. Das heißt,
17:02
wenn ich das Ganze machen möchte, wenn ich also die Variable Sample Size so verwenden möchte, wie ich mir das in dem Programm eigentlich gedacht habe, dann muss ich jetzt die Interpretation dieser Variablen ändern. Das heißt, der String, der eingegeben wurde mit den Ziffernfolgen 2, 4, 5, soll eigentlich interpretiert werden als ganze Zahl, denn gemeint ist hier eigentlich die
17:27
ganze Zahl 245. Und dafür gibt es eine Konversionsfunktion, die konvertiert, in diesem Fall einen String, der in Sample Size steht, in einen Integer, in eine ganze Zahl. Und wenn
17:43
ich das Ganze konvertiere, dann kann ich es auch aufaddieren. Das heißt, in dem Fall auf meine 12.345 die neuen 245 Werte. Das heißt, wenn wir einfach mal sehen, dieses Int Sample Size, das gebe ich noch mal einzeln aus, um das zu verdeutlichen. Also wir haben erst mal Sample
18:08
Size, das ist der String 2, 4, 5. Wenn ich hier jetzt Int-Konversion von Sample Size mache, dann sehen wir, das konvertiert das Ganze in den Wert 245. Und in dem Moment, wo ich das
18:30
konvertiert habe mit 245, kann ich eben entsprechend rechnen. Wir können das Gleiche mit Zuweisungen machen und wir sehen, dass wenn ich eine neue Variable oder umgekehrt, wenn ich solche Rechnungen
18:45
öfters durchführe, wenn ich also die Sample Size noch an verschiedenen Stellen mache, dann würde ich die nicht nur in dieser Berechnung konvertieren, sondern vermutlich macht es Sinn, nachdem ich die Sample Size eingelesen habe vom Benutzer, diese dann in einer neuen Variable zu merken. Zum Beispiel
19:04
New Participants, das ist das, was es eigentlich darstellt. Und der Typ dieser Konversion ist eben Int. In einem anderen Fall kann ich mir vorstellen, dass wir auch wieder per Benutzereingabe oder per Sensor ablesen, einen Wert auslesen. Und wenn wir eine Benutzereingabe haben, dann kann es sein, dass
19:21
wir eine Studie haben und wir wollen jetzt den Benutzer des Thermostat ablesen lassen, den Wert eingeben, dann wissen wir schon, das wird als String eingegeben. Wenn ich jetzt also sage, okay, ich möchte jetzt den Wert, den wir haben, ja konvertieren, damit ich damit auch rechnen kann, dann könnte ich auch wieder das Int 42.75 versuchen. Und das funktioniert allerdings nicht, wir erhalten wieder
19:46
einen Fehler, weil ich jetzt versuche, eine Eingabe, die keine ganze Zahl ist, sondern eine Gleitpunktzahl in einen Integer zu verwandeln. Wenn ich das also korrekt durchführen möchte, dann muss ich den Wert einlesen und in eine Gleitpunktzahl umwandeln, in dem Fall eben in
20:04
42.75 und dann ist das ein Float. Diese Konvertierungsfunktionen gibt es jetzt also für Integer und für Float. Genauso kann ich auch aus Zahlen Strings machen oder auch aus Werten,
20:20
Buhlsche Werte. Dazu kommen wir dann in einer späteren Session. Jetzt haben wir gesehen, eine Konversion geht also durch diesen Int, also ich erzeuge aus einer Gleitpunktzahl eine ganze Zahl. In dem Fall, was passiert mit 179? Wenn ich also 1.79 in eine ganze Zahl konvertiere,
20:45
dann wird das so interpretiert, dass der Anteil, der ganzzahlige Anteil interpretiert wird. Das heißt, 1.79 wird nicht etwa gerundet, sondern es wird eben der Wert 1 ausgerechnet. Das habe ich auch entsprechend ausgegeben. Der Typ ist jetzt Int, aber wenn ich Int 179 rechne, dann ist der Wert,
21:06
der eben entsteht, der Wert 1. Genauso kann man True zu einem Int interpretieren. Das heißt, wir können uns mal ansehen, welchen Int-Wert hat True und der hat auch den Wert 1. Und wir
21:20
natürlich auch versuchen, einen String in einen Int zu konvertieren. Und auch hier haben wir wieder ein Problem, denn dies kann man nicht als ganze Zahl interpretieren, genauso wie mit der Gleitpunktzahl. So, damit haben wir die Grunddatentypen kennengelernt und ich möchte jetzt in den folgenden Sessions noch darauf eingehen, auf einzelne Beispiele, also die vier
21:45
Grunddatentypen, unterscheiden.
Recommendations
Series of 17 media