#05 – CSV Dateien einlesen

CSV hier, CSV dort. Sie sind überall und so ziemlich jedes System kann sie irgendwie irgendwo ausspucken.
Selbst bei meiner Bank kann ich die Umsätze als CSV exportieren!

Aber mal ehrlich … machst du gerne CSV Dateien auf?
Bestimmt nicht. 
Es ist, wie es ist. Sie sind einfach, nicht schön und schon gar nicht übersichtlich. 

„Mal schnell was rauslesen?“ – Ein Ding der Unmöglichkeit!

Oder?
Heute wirst du sehen, wie einfach und übersichtlich die Arbeit mit CSV Dateien sein kann.
Nach dem Teil wird die nächste CSV Datei für dich kein Problem mehr darstellen – Versprochen!

Ach ja und Excel brauchst du dafür auch nicht …

Und los gehts!

Für diesen Teil nutzen wir die california_housing_text.csv Datei.
Hier kannst du sie herunterladen

CSV einlesen

Im letzten Video hast du gesehen, wie du Dateien hier reinbekommst.
Und wenn du gut aufgepasst hast, weißt du auch schon wie du deine CSV Datei einlesen kannst.

import pandas
daten = pandas.read_csv('/content/drive/MyDrive/california_housing_test.csv')
daten.head()

Das ist der Code, den du brauchst

Hier aber trotzdem nochmal Schritt für Schritt.
Aber was passiert hier eigentlich?
Lass mich dir das kurz erklären:

import pandas

Pandas ist ein Modul – oder auch Paket, also eine Erweiterung – für Python, mit dem Ziel, die Arbeit mit Daten so einfach wie möglich zu gestalten.
Einlesen, filtern, analysieren, etc.
Alles was du so mit deinen Daten in Excel machen würdest und noch viel mehr.

Mit dem Schlüsselwort import sagst du der Umgebung, dass du das Paket benutzen willst.
Die Umgebung importiert das Paket und merkt sich alle Funktionen, die da drin enthalten sind, damit du sie später benutzen kannst.

daten = pandas.read_csv('/content/drive/MyDrive/california_housing_test.csv')

Hier passiert schon etwas mehr.
Mit daten = wird eine Variable definiert.
Eine Variable kannst du dir wie eine Box oder einen Container vorstellen, in dem du Daten ablegen kannst.
In anderen Programmiersprachen musst du dafür explizit einen Datentyp mit angeben, also was für „Sachen“ du in die Box werfen willst. 

Python hat auch Datentypen und passt auch sehr genau darauf auf, dass du damit keinen Mist machst.
Bei Variablen kümmert sich Python aber selbst darum.
Sobald du etwas mit dem Gleichheitszeichen in die Box wirfst, schaut sich Python das an und leitet selbst den Datentyp davon ab.

Also was brauchen wir dann für eine Variable?
Einfach nur einen Namen. Sozusagen die Beschriftung für deine Box.
Damit du deine Daten wiederfindest. 
Und genau deshalb solltest du auch unbedingt darauf achten, wie du deine Variablen nennst!
Oder meinst du ein Name wie „az“ sagt dir in zwei Wochen noch was?

Okay, der erste Teil ist jetzt klar.
daten = erzeugt also eine Variable, in der wir Daten ablegen.

Und der Rest?
pandas sollte klar sein. Das hast du ja oben importiert.
Du willst also jetzt auf eine Funktion in dem pandas Paket zugreifen.

Und der Zugriff auf Funktionen geht in Python – wie in vielen Programmiersprachen – über den Punkt.
Du gibst also den Paketnamen an, dann einen Punkt und dann den Namen der Funktion, die du ausführen willst.
Das macht dann zusammen pandas.read_csv.

Dann bleiben noch die Klammern.
Die Klammern sagen, dass du die Funktion auch ausführen willst.
Willst du also nicht nur sagen „das da ist die Funktion“, sondern sie auch wirklich ausführen, brauchst du immer Klammern. Immer immer.

Manche Funktionen machen einfach etwas, manche brauchen Daten, mit denen sie etwas machen sollen.
Und dafür sind die Klammern gut.
Will die Funktion also Daten von dir, schreibst du sie in die Klammern.
Hier ist die Funktion read_csv() – Also „lese Daten im CSV Format ein“.

Na ja dann musst du der Funktion natürlich auch sagen, wo sie die Daten findet.
Und das ist dann auch schon der letzte Teil der Zeile:

'/content/drive/MyDrive/california_housing_test.csv'

Du gibst der Funktion den Pfad zu deiner Datei, die eingelesen werden soll.
Der Pfad wird als Text angegeben.
Text ist auch schon der erste Datentyp.
Texte – oder auch Strings – werden in Python immer in einfachen (‘) oder doppelten (“) Anführungszeichen geschrieben.
Welche du verwendest, bleibt dir überlassen. Python macht da keinen Unterschied.
Du musst nur mit demselben anfangen und aufhören. Das ist alles.
Halte es am besten einheitlich. Das macht es dir später auch leichter.

So … das war doch ein bisschen was …
Aber die Zeile wäre geschafft. 
Es bleibt noch?

daten.head()

Daten ist die Variable, die du erzeugt hast.

read_csv() hat die Datei eingelesen und damit ein DataFrame erzeugt.
Ein weiterer Datentyp.
Der ist speziell von Pandas geschaffen worden, um Daten zu strukturieren und dir all die tollen Möglichkeiten zu geben, die du später noch lernen wirst.

Dieser Datentyp hat jetzt selbst also auch wieder Funktionen.
Sonst könntest du ja nichts damit machen.

Und eine der Funktionen ist head().
head() nimmt einfach nur den Kopf der Daten, also die ersten 5 Zeilen und gibt sie aus.
Wenn du head() jetzt aber auch noch einen Wert mitgibst, also zum Beispiel so:

head(10)

Dann gibt head(10) nicht die ersten 5, sondern die ersten 10 Zeilen aus. Oder welche Zahl du auch immer angegeben hast.
Das Gegenstück zu head(10) ist tail().
tail() funktioniert genauso, zeigt allerdings die letzten 5 Zeilen an – oder eben mehr, wenn du mehr angibst. 

So, du siehst also jetzt die ersten 5 Zeilen deiner Daten!
Und wenn du das nochmal vergleichst mit dem Texteditor …
Das sieht doch schon verdammt gut aus, oder?

Spalten einschränken

Aber zufrieden bist du hoffentlich noch nicht!
Das sind ja noch viel zu viele Daten, die willst du doch bestimmt nicht alles sehen.

Aber welche Spalten gibt es denn überhaupt alle?
Hin und her scrollen ist ja jetzt auch nicht gerade das tolle. 
Und hier geht das noch, aber überleg mal du hast eine Datei mit 20, 50 oder 80 Spalten?

Vorhin hast du ja schon gesehen, dass daten mit head() und tail() eigene Funktionen mitbringt.
Das liegt daran, dass es sich bei einem DataFrame um ein Objekt handelt.
Und Objekte haben immer Funktionen und Attribute, also Werte, bzw. Eigenschaften.

Mit einem Objekt kannst du also bestimmte Funktionen ausführen und Eigenschaften ablesen.

Und was hilft dir das jetzt?
Eine der Eigenschaften, die ein DataFrame mitbringt, heißt columns.
In columns findest du eine Liste aller Spaltennamen, die in dem DataFrame enthalten sind.

Also tausch dein daten.head() einfach mal durch ein daten.columns aus.
Die Ausgabe sollte in etwa so aussehen:

Index(['longitude', 'latitude', 'housing_median_age', 'total_rooms',
 'total_bedrooms', 'population', 'households', 'median_income',
 'median_house_value'],
 dtype='object')

Es ist nicht ganz eine Liste, sondern wieder ein Objekt – ein Index – aber das kannst du erstmal ignorieren.

Es geht jetzt nur darum einen Überblick über alle Spalten zu bekommen, damit du dir die heraussuchen kannst, die dich interessieren.

Die Spalten housing_median_age, population, median_income, median_house_value reichen aus. Damit lässt sich doch was anfangen.
Also warum den Rest überhaupt erst aus der Datei laden und anzeigen?
Richtig. Überflüssig. Also weg damit.

daten = pandas.read_csv('/content/drive/MyDrive/california_housing_test.csv',
                         usecols=['housing_median_age', 'population', 'median_income',   
                                  'median_house_value'])

Das ist doch gleich viel übersichtlicher.

Die Funktion read_csv() kann also neben der Pfadangabe noch weitere Werte entgegennehmen!
Mit dem Parameter usecols kannst du die Spalten auflisten, die du sehen willst.
Und das sofort beim Laden der Datei!
Pandas muss also nicht wie Excel erstmal alles laden und dann fängst du an einzuschränken.
Du kannst sofort nur das laden lassen, was dich interessiert und direkt Speicher sparen und Geschwindigkeit gewinnen.

Moment … Parameter? Liste? Und wieso das Gleichheitszeichen? War das nicht für Variablen?

Eins nach dem Anderen:
Erstmal die Parameter.
Werte, die du an eine Funktion übergibst, heißen Parameter.
Wenn eine Funktion definiert wird, wird auch angegeben, wie viele Parameter – also Werte – sie entgegennehmen kann.
Und wie diese Werte heißen!

Und genau hier kommt das Gleichheitszeichen ins Spiel.
Anders als in anderen Programmiersprachen kann eine Funktion in Python sagen, dass sie einen Parameter nicht unbedingt braucht.
Sie benutzt dann einfach einen Standard-Wert und du musst den Wert dann nicht mehr angeben.
Du kannst den Parameter aber angeben, wenn du das willst.

Wenn die Funktion erstellt wird, stehen die Parameter in einer bestimmten Reihenfolge.
Zum Beispiel kommt hier bei read_csv() zuerst ein filepath, dann ein sep – also mit welchem Zeichnen die einzelnen Werte der CSV voneinander getrennt sind (Komma, Semikolon, Tab, etc.) und dann noch viele andere, bevor irgendwann das usecols kommt, dass du benutzen willst.

Würdest du alle Parameter der Reihe nach angeben, müsstest du keinen Parameternamen angeben.
Hier gibst du zuerst den Pfad an.
Der ist an der richtigen Position, braucht also keinen Namen.
Dann überspringst du aber mehrere Parameter und kommst direkt zu usecols.
Das musst du Python mitteilen, damit klar ist, welcher Parameter gefüllt werden soll.
Und das machst du, indem du einfach den Parameternamen wie eine Variable benutzt.
Deshalb das Gleichheitszeichen.

Dann noch die Liste.
Liste ist auch ein Datentyp in Python und ist … na ja einfach eine Liste.
Also eine Aufzählung von verschiedenen Werten.
Das können Strings sein, Zahlen, wieder Listen oder ganze Objekte. Das ist egal.
Erzeugt wird eine Liste einfach durch zwei eckige Klammern.
Dazwischen kannst du beliebig viele Werte schreiben.

Zeilen einschränken

Gut, dann hast du jetzt die Spalten auf das relevante eingeschränkt.
Die ersten 5 Zeilen helfen jetzt aber noch nicht sooo arg viel.

Also weg mit dem head() und einfach mal nur daten hinschreiben.
Damit bekommst du alles, ohne Einschränkung.

Oder?
Jetzt siehst du die ersten 5 Zeilen, dann die letzten 5 und da drunter so etwas

3000 rows × 4 columns

Es sind also insgesamt 3000 Zeilen da. Und du siehst 10. und dazwischen dann ein paar Punkte.
Pandas macht das absichtlich, um nicht einfach den ganzen Bildschirm vollzuladen.
Wie kommst du also jetzt an die Zeilen, die du brauchst?

Mal angenommen, du willst die Zeilen 10 bis 20 sehen.
Dann kannst du das einfach wie bei Listen über den Index lösen.
Änder dein daten einfach auf daten[9:20] ab und schon bekommst du die Zeilen 10 – 20 ausgegeben.

Jede Liste hat automatisch einen Index.
Über den Index wird angegeben, an welcher Position ein Element in der Liste steht.
Dabei fängt der Index immer bei 0 an zu zählen.
Das erste Element steht also an Position 0.
Das zweite Element an Position 1.
Und so weiter.

Wenn du jetzt ein bestimmtes Element haben willst, kannst du über den Index, also über seine Position darauf zugreifen und sagen „Hey Liste – gib mir mal bitte das Element an der Stelle 9“.

Den Befehl schreibst du einfach in eckigen Klammern direkt und ohne Leerzeichen hinter deine Liste:

daten[9]

ACHTUNG: Da du hier keine Liste, sondern ein ganzes DataFrame hast, wird dieser Zugriff in einer Fehlermeldung enden.

Wenn du nicht nur einen Wert möchtest, sondern gleich einen ganzen Bereich wie in dem Fall jetzt, dann gibst du einfach den ganzen Bereich an. 
Das machst du, indem du den Startwert und den Endwert durch einen Doppelpunkt trennst.

daten[9:20]

Dabei musst du nur 2 Dinge berücksichtigen:

• Der Index fängt bei 0 an zu zählen
  • Element 10 ist also an Stelle 9
• Der angegebene Endwert wird nicht mit ausgegeben
  • Element 20 an Stelle 19 heißt also du musst die Stelle 20 als Endwert angeben.

Das ist sicher schonmal hilfreich.
Oft reicht das aber noch nicht.
Interessant wäre sicher, die Datei nach bestimmten Bedingungen durchsuchen zu können, oder?
Das zeige ich dir dann im nächsten Video!

Zusammenfassung

Also bleibt dran und lass uns jetzt erstmal kurz rekapitulieren:

• Mit dem Keyword import kannst du Module, bzw. Pakete importieren und dessen Funktionen benutzen.
• Eine Variable ist ein Container, in dem du Werte ablegen und später benutzen kannst.
• Ein beliebiger, aber sprechender Name, gefolgt von einem Gleichheitszeichen, erzeugt eine Variable und legt einen Wert hinein
• Über einen Punkt kannst du auf die Eigenschaften und Funktionen von einem Objekt zugreifen
• Python arbeitet mit verschiedenen Datentypen
  • String
    • Gekennzeichnet durch einfache oder doppelte Anführungszeichen
    • Es macht keinen Unterschied, welche der Beiden du verwendest
  • Liste
    • Eine Aufzählung beliebig vieler Werte beliebiger Art zwischen zwei eckigen Klammern
    • Unterschiedliche Datentypen können in einer Liste vermischt werden
    • Jede Liste hat einen Index, der angibt, an welcher Position ein Element steht
    • Ein Index fängt immer bei 0 an zu zählen
    • Mit eckigen Klammern hinter einer Liste kann man auf den Index zugreifen
    • Mit einem Doppelpunkt in den eckigen Klammern lässt sich ein Anfang und ein Ende angeben.
    • Bei einem Bereich ist der Anfang immer mit dabei, das Ende nicht.
  • DataFrame
    • Ein Datentyp (Objekt), dass von Pandas mitgeliefert wird und nicht zum Python Standard gehört
• Parameter sind Werte die an eine Funktion übergeben werden können
• Die Funktion read_csv() braucht als Parameter einen Pfad zu einer CSV Datei und liest die dann ein
• Die Eigenschaft columns gibt eine Liste aller Spalten aus, die in der Datei zur Verfügung stehen
• Der Parameter usecols schränkt ein, welche Spalten eingelesen werden sollen
• Du kannst einzelne Zeilen aus einem Dataframe auslesen, indem du sie über den Listenindex direkt ansprichst.

Anfang verpasst? Hier gehts zum vollen Kurs: