{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2) Dataframe erstellen und speichern\n",
"\n",
"Zu Beginn wird - wie in allen folgenden Kapiteln auch - das Paket **Pandas** importiert, und zwar mit der Abkürzung **pd**, so dass bei jeglicher weiteren Verwendung des Pakets nur mehr **pd** geschrieben werden muss, der Schreibaufwand also minimiert wird. **pd** ist dabei die international übliche Abkürzung für das Importieren von **Pandas** in der Python Community und sollte einheitlich auch in eigenen Scripts oder Programmen so verwendet werden."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.1) Dataframe aus selbst (in Python) eingegebenen Variablen und Werten erstellen\n",
"\n",
"Bevor in Kapitel 4 echte Daten aus bereits vorhandenen Datenfiles geladen bzw. importiert werden, sehen wir uns im Folgenden einige Möglichkeiten an, wie man direkt in Python Variablen und dazugehörige Werte eingibt und daraus ein Dataframe (eine zweidimensionale tabellarische Datenstruktur; also Zeilen und Spalten - wie man es bspw. von Excel oder SPSS kennt) erstellt.\n",
"\n",
"[Pandas DataFrame](https://www.geeksforgeeks.org/python-pandas-dataframe/)\n",
"\n",
"[pandas.DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html)\n",
"\n",
"[Different ways to create Pandas Dataframe](https://www.geeksforgeeks.org/different-ways-to-create-pandas-dataframe/)\n",
"\n",
"Im Folgenden werden 4 (teils recht ähnliche) Möglichkeiten präsentiert, ein Dataframe zu erstellen (es gibt auch noch weitere Möglichkeiten, als die 4 angeführten)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Beispiel 1\n",
"\n",
"Zuerst wird dem Objekt *daten1* ein Dictionary mit Markennamen sowie Preisen zugewiesen, danach wird mit der Funktion **pd.DataFrame()** das Dataframe *df1* (df ist eine häufig verwendete Abkürzung für Dataframe) erstellt, indem ihm das Objekt *daten1* zugewiesen wird und als Spalten(Variablen)namen *Marke* und *Preis* übergeben werden."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"daten1 = {'Marke' : ['Nike','Puma','Adidas','Lacoste'], 'Preis' : [35, 30, 30, 45]}\n",
"\n",
"df1 = pd.DataFrame(daten1 ,columns = ['Marke', 'Preis'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Durch Eingabe des Dataframenamens *df1* erhält man bereits den Output - die tabellarische Darstellung des Dataframeinhalts. Der Zeilenindex ganz links wird übrigens von **Pandas** automatisch erstellt (und wird nicht zu den Spalten gezählt - das Dataframe enthält somit 2 Spalten (unsere beiden Variablen *Marke* und *Preis*))."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Marke
\n",
"
Preis
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Nike
\n",
"
35
\n",
"
\n",
"
\n",
"
1
\n",
"
Puma
\n",
"
30
\n",
"
\n",
"
\n",
"
2
\n",
"
Adidas
\n",
"
30
\n",
"
\n",
"
\n",
"
3
\n",
"
Lacoste
\n",
"
45
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Marke Preis\n",
"0 Nike 35\n",
"1 Puma 30\n",
"2 Adidas 30\n",
"3 Lacoste 45"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Beispiel 2\n",
"\n",
"Wie voriges Beispiel, jedoch ohne gesonderte Angabe der Spaltennamen (ist auch nicht nötig, wenn man alle im Dictionary enthaltenen Spalten übernehmen will. Möchte man nicht alle Spalten ins Dataframe übernehmen, so könnte man in diesem Beispiel auch nur *columns=['Fisch']* angeben, *Länge* würde dann nicht im Dataframe enthalten sein)."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"daten2 = {'Fisch' : ['Karpfen', 'Hecht', 'Forelle', 'Wels'], 'Länge' : [55, 70, 40, 90]} \n",
" \n",
"df2 = pd.DataFrame(daten2) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Und hier der Output nach Eingabe von *df2*, dem Namen des Dataframes aus Bsp. 2."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Fisch
\n",
"
Länge
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Karpfen
\n",
"
55
\n",
"
\n",
"
\n",
"
1
\n",
"
Hecht
\n",
"
70
\n",
"
\n",
"
\n",
"
2
\n",
"
Forelle
\n",
"
40
\n",
"
\n",
"
\n",
"
3
\n",
"
Wels
\n",
"
90
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Fisch Länge\n",
"0 Karpfen 55\n",
"1 Hecht 70\n",
"2 Forelle 40\n",
"3 Wels 90"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Beispiel 3\n",
"\n",
"Die Erstellung des Dictionarys mit den Spaltennamen und dazugehörigen Werten unterscheidet sich nicht von Bsp. 1 bzw. 2. Jedoch wird nun im Rahmen der Erstellung des Dataframes (zweite Codezeile) ein eigener Index (anstelle des wie in Bsp. 1 und 2 automatisch von **Pandas** vergebenen Index) zugewiesen. Ein solcher Index könnte bspw. auch die Fragebogennummer bzw. lfd. Nummer sein (dies sollte man, bspw. falls Daten später kontrolliert bzw. nachgeprüft werden, immer in Datenfiles haben!)."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"daten3 = {'Stadt' : ['Wien', 'Graz', 'Salzburg', 'Fürstenfeld'], 'Einwohner' : [1800000, 280000, 160000, 5000]} \n",
"\n",
"df3 = pd.DataFrame(daten3, index = ['Rang 1', 'Rang 2', 'Rang 3', 'Rang 4'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die Outputtabelle enthält nun den selbst vergebenen Index und nicht einen automatisch von **Pandas** vergebenen."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Stadt
\n",
"
Einwohner
\n",
"
\n",
" \n",
" \n",
"
\n",
"
Rang 1
\n",
"
Wien
\n",
"
1800000
\n",
"
\n",
"
\n",
"
Rang 2
\n",
"
Graz
\n",
"
280000
\n",
"
\n",
"
\n",
"
Rang 3
\n",
"
Salzburg
\n",
"
160000
\n",
"
\n",
"
\n",
"
Rang 4
\n",
"
Fürstenfeld
\n",
"
5000
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Stadt Einwohner\n",
"Rang 1 Wien 1800000\n",
"Rang 2 Graz 280000\n",
"Rang 3 Salzburg 160000\n",
"Rang 4 Fürstenfeld 5000"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Beispiel 4\n",
"\n",
"Das letzte Beispiel geht nun bei der Eingabe der Spaltennamen und der Werte einen anderen Weg als die drei vorhergehenden Beispiele. Nun werden dem Objekt *daten4* zuerst ausschließlich die Werte für die beiden Spalten in Form einer Liste übergeben. Im Zuge der Erstellung des Dataframes werden schließlich die beiden Spaltennamen übergeben."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"daten4 = [['Fred', 180], ['Susi', 165], ['Max', 190], ['Andrea', 175]] \n",
" \n",
"df4 = pd.DataFrame(daten4, columns = ['Name', 'Größe']) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Für den Output spielt dies alles keine Rolle. Abgesehen vom Inhalt ändert sich bei allen vier gezeigten Beispielen nichts am Aufbau oder der Funktionalität der Tabelle."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Name
\n",
"
Größe
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Fred
\n",
"
180
\n",
"
\n",
"
\n",
"
1
\n",
"
Susi
\n",
"
165
\n",
"
\n",
"
\n",
"
2
\n",
"
Max
\n",
"
190
\n",
"
\n",
"
\n",
"
3
\n",
"
Andrea
\n",
"
175
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Name Größe\n",
"0 Fred 180\n",
"1 Susi 165\n",
"2 Max 190\n",
"3 Andrea 175"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2) Dataframe aus Zufallszahlen erstellen\n",
"\n",
"\n",
"Um div. Analysen bzw. Vorgehensweisen mit umfangreicherem Datenmaterial zu simulieren bzw. zu testen, bietet es sich an, die Daten nicht wie vorhin selbst einzutippen, sondern eine beliebige Anzahl von Daten automatisch erstellen zu lassen. Zu diesem Zweck wird vorab das Paket **numpy** mit der Abkürzung **np** importiert."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nun werden zwei Zahlenreihen mit jeweils 5 Zahlen erstellt und den beiden Objekten *a* bzw. *b* zugewiesen. Das Modul **random** im Paket **numpy** enhält die Funktion **randn()**, welche normalverteilte (Mittelwert = 0, Standardabweichung = 1) Zufallszahlen generiert.\n",
"\n",
"[numpy.random](https://docs.scipy.org/doc/numpy-1.16.0/reference/routines.random.html)\n",
"\n",
"[numpy.random.randn](https://docs.scipy.org/doc/numpy-1.16.0/reference/generated/numpy.random.randn.html#numpy.random.randn)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [],
"source": [
"a, b = np.random.randn(5), np.random.randn(5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jetzt wird ein Dataframe gebildet und anschließend aufgerufen, welches aber noch leer ist...\n",
"\n",
"[pandas.DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html#pandas.DataFrame)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
"
"
],
"text/plain": [
"Empty DataFrame\n",
"Columns: []\n",
"Index: []"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"daten = pd.DataFrame()\n",
"\n",
"daten # noch sind aber keine Daten enthalten"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Vorhin erstellte Objekte *a* und *b* werden dem Dataframe nun als Spalten hinzugefügt und mit *'a'* bzw. *'b'* bezeichnet. Das Dataframe ist nun fertig, d.h. enthält die Spalten und alle Werte."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
a
\n",
"
b
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
-0.584532
\n",
"
1.834036
\n",
"
\n",
"
\n",
"
1
\n",
"
-0.445541
\n",
"
1.112410
\n",
"
\n",
"
\n",
"
2
\n",
"
-1.731362
\n",
"
0.103345
\n",
"
\n",
"
\n",
"
3
\n",
"
0.754921
\n",
"
0.492159
\n",
"
\n",
"
\n",
"
4
\n",
"
1.253666
\n",
"
-0.834235
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" a b\n",
"0 -0.584532 1.834036\n",
"1 -0.445541 1.112410\n",
"2 -1.731362 0.103345\n",
"3 0.754921 0.492159\n",
"4 1.253666 -0.834235"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"daten ['a'] = a\n",
"daten ['b'] = b\n",
"\n",
"daten # nun sind die vorhin erstellten Zahlen enthalten"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Noch schneller geht's mit folgender direkten Methode\n",
"\n",
"Die Erstellung des Dataframes, die Bennenung der Spalten sowie die Generierung der Zufallszahlen für beide Spalten können auch leicht in einer einzigen Codezeile eingegeben werden"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [],
"source": [
"df = pd.DataFrame({'A' : np.random.randn(3), 'B' : np.random.randn(3)})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hier das erstellte Dataframe:"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
A
\n",
"
B
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
1.298208
\n",
"
2.093076
\n",
"
\n",
"
\n",
"
1
\n",
"
-1.386325
\n",
"
1.412125
\n",
"
\n",
"
\n",
"
2
\n",
"
0.500713
\n",
"
1.323926
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" A B\n",
"0 1.298208 2.093076\n",
"1 -1.386325 1.412125\n",
"2 0.500713 1.323926"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Streudiagramm\n",
"\n",
"Diagramme und Korrelationsanalysen sind zwar erst Thema späterer Kapitel (und werden dort erklärt), jedoch bietet es sich an dieser Stelle an, die normalverteilten Zufallszahlen genauer zu betrachten, d.h. die beiden Variablen miteinander abzubilden. Da es sich um zwei normalverteilte Zufallsvariablen handelt, wird die Korrelation zwischen beiden Variablen zumeist eher gering sein. Mit zunehmender Fallzahl wird sie immer öfter nahe bei Null liegen."
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEGCAYAAAB7DNKzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQJUlEQVR4nO3df2zc9X3H8ddr/kEtq5nHckAKyJdKUVeIxISsFNapyzSngqiSW6mr8D+g6qSIrmh/R6pE/9g/2/6KKAwUyajAH2Z/lVhbKKVoFe02NjuUkLCVkbGrCInIFWozzC2Ovff+8JfOcc4fX+Lzfe7s50M6+Xvf71d376+/kGfuZxwRAgBgLb+VewAAQGcjFACAJEIBAEgiFACAJEIBAEjqzT3AZti5c2eUy+XcYwBA1zhx4sSvIqLUaNuWDEW5XNbMzEzuMQCga9j+5VrbeOoJAJBEKAAASYQCAJBEKAAASYQCAJBEKLCl1eZrmn53WrX5Wu5RgK5FKLBlTZ6a1PCRYR145oCGjwxr8vRk7pGArkQosCXV5muqTFVUX6xr7uKc6ot1VY5VeGQBXANCgS2pOltVf0//Zev6evpUna3mGQjoYoQCW1J5qKyFpYXL1l1auqTyUDnPQEAXIxTYkkqDJU2MTWigd0A7rtuhgd4BTYxNqDTY8KtsACRsye96AiRpfO+4RnePqjpbVXmoTCSAa0QosKWVBksEAtggnnoCACQRCgBAEqEAACQRCgBAEqEAACQRCgBAEqEAACQRCgBAEqEAACQRCgBAEqEAACQRCgBAEqEAACQRCgBAEqEAACQRCgBAEqEAACRlDYXtJ21fsH16je37bc/Zfq24PNzuGQFgu8v9T6F+X9Kjkp5O7PPTiPhKe8YBAKyW9RFFRLws6YOcMwAA0rrhNYq7bZ+0/bzt29fayfYh2zO2Z2q1WjvnA4AtrdND8aqk4Yi4Q9L3JD231o4RcTQiRiJipFQqtWs+ANjyOjoUEfFhRHxULB+X1Gd7Z+axAGBb6ehQ2L7JtovlfVqe9/28UwHA9pL1XU+2JyXtl7TT9llJ35XUJ0kR8YSkr0v6lu1FSXVJ90VEZBoXALalrKGIiPF1tj+q5bfPAgAy6einngAA+REKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAAJBEKAEASoQAaqM3XNP3utGrztdyjANkRCmCVyVOTGj4yrAPPHNDwkWFNnp7MPRKQFaEAVqjN11SZqqi+WNfcxTnVF+uqHKvwyALbGqEAVqjOVtXf03/Zur6ePlVnq3kGAjoAoQBWKA+VtbC0cNm6S0uXVB4q5xkI6ACEAlihNFjSxNiEBnoHtOO6HRroHdDE2IRKg6XcowHZ9OYeAOg043vHNbp7VNXZqspDZSKBbY9QAA2UBksEAihkferJ9pO2L9g+vcZ2237E9hnbr9u+s90zAsB2l/s1iu9Luiex/V5Je4rLIUmPt2EmAMAKWUMRES9L+iCxy5ikp2PZK5KGbO9qz3QAACn/I4r13CzpnRXXzxbrrmD7kO0Z2zO1Gh+OAoBW6fRQuMG6aLRjRByNiJGIGCmVeBESAFql00NxVtKtK67fIulcplkAYFvq9FBMSbq/ePfTXZLmIuJ87qEAYDvJ+jkK25OS9kvaafuspO9K6pOkiHhC0nFJByWdkfSxpG/mmRQAtq+soYiI8XW2h6Rvt2kcAEADnf7UEwAgM0IBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEjKGgrb99h+0/YZ24cbbN9ve872a8Xl4RxzAsB21pvrjm33SHpM0gFJZyVN256KiH9btetPI+IrbR8QwJZXm6+pOltVeais0mAp9zgdq6lQ2P6UpD+T9IeSQtLPJD0eEf+zgfveJ+lMRLxd3MezksYkrQ4FALTc5KlJVaYq6u/p18LSgibGJjS+dzz3WB2p2aeenpZ0u6TvSXpU0uclPbPB+75Z0jsrrp8t1q12t+2Ttp+3fftaN2b7kO0Z2zO1Wm2DowHYymrzNVWmKqov1jV3cU71xboqxyqqzfNnRyPNPvX0uYi4Y8X1f7B9coP37QbrYtX1VyUNR8RHtg9Kek7SnkY3FhFHJR2VpJGRkdW3AwC/UZ2tqr+nX/XF+m/W9fX0qTpb5SmoBpp9RPFz23d9csX2FyT94wbv+6ykW1dcv0XSuZU7RMSHEfFRsXxcUp/tnRu8XwDbXHmorIWlhcvWXVq6pPJQOc9AHS4ZCtunbL8u6QuS/sl21fZ/SfpnSV/a4H1PS9pje7ftfkn3SZpadf832XaxvK+Y9/0N3i+Aba40WNLE2IQGege047odGugd0MTYBI8m1rDeU0+b9m6jiFi0/ZCkFyT1SHoyIt6w/WCx/QlJX5f0LduLkuqS7osInlYCsGHje8c1unuUdz01wVvxz92RkZGYmZnJPQYAdA3bJyJipNE2PpkNAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEIBAEgiFACAJEKxQm2+pul3p1Wbr+UeBQA6BqEoTJ6a1PCRYR145oCGjwxr8vRk7pEAoCMQCi0/kqhMVVRfrGvu4pzqi3VVjlV4ZAEAIhSSpOpsVf09/Zet6+vpU3W2mmcgAOgghEJSeaishaWFy9ZdWrqk8lA5z0AA0EEIhaTSYEkTYxMa6B3Qjut2aKB3QBNjEyoNlnKPBgDZ9eYeoFOM7x3X6O5RVWerKg+ViQQAFAjFCqXBEoEAgFWyPvVk+x7bb9o+Y/twg+22/Uix/XXbd+aYEwC2s2yhsN0j6TFJ90q6TdK47dtW7XavpD3F5ZCkx9s6JAAg6yOKfZLORMTbEbEg6VlJY6v2GZP0dCx7RdKQ7V3tHhQAtrOcobhZ0jsrrp8t1l3tPpIk24dsz9ieqdX4oBwAtErOULjBuriGfZZXRhyNiJGIGCmVeEEaAFolZyjOSrp1xfVbJJ27hn0AAJsoZyimJe2xvdt2v6T7JE2t2mdK0v3Fu5/ukjQXEefbPSgAbGfZPkcREYu2H5L0gqQeSU9GxBu2Hyy2PyHpuKSDks5I+ljSN3PNCwDbVdYP3EXEcS3HYOW6J1Ysh6Rvt3suAMD/47ueAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkNSb405tXy/pbyWVJVUlfSMift1gv6qk/5a0JGkxIkbaNyUAQMr3iOKwpJciYo+kl4rra/njiPh9IgEAeeQKxZikp4rlpyR9NdMcAIB15ArFjRFxXpKKnzessV9I+pHtE7YPpW7Q9iHbM7ZnarVai8cFgO1r016jsP1jSTc12PSdq7iZL0bEOds3SHrR9i8i4uVGO0bEUUlHJWlkZCSuemAAQEObFoqIGF1rm+33bO+KiPO2d0m6sMZtnCt+XrD9A0n7JDUMBQBgc+R66mlK0gPF8gOSjq3ewfag7U9/sizpy5JOt21CAICkfKH4S0kHbL8l6UBxXbY/Y/t4sc+Nkn5m+6Skf5X09xHxwyzTAsA2luVzFBHxvqQ/abD+nKSDxfLbku5o82gAgFX4ZDYAIIlQAACSCAUAIIlQAACSCAUAIIlQAACSCAUAIIlQAACSCAUAIIlQAACSCAUAIIlQAACSCAUAIIlQAACSCAUAIIlQAACSCAUAbAG1+Zqm351Wbb7W8tsmFADQ5SZPTWr4yLAOPHNAw0eGNXl6sqW3TygAoIvV5muqTFVUX6xr7uKc6ot1VY5VWvrIglAAQBerzlbV39N/2bq+nj5VZ6stuw9CAQBdrDxU1sLSwmXrLi1dUnmo3LL7IBQA0MVKgyVNjE1ooHdAO67boYHeAU2MTag0WGrZffS27JYAAFmM7x3X6O5RVWerKg+VWxoJiVAAwJZQGiy1PBCf4KknAEASoQAAJBEKAEASoQAAJBEKAECSIyL3DC1nuybpl7nnaGCnpF/lHqJFOJbOxLF0pm44luGIaPi2qS0Zik5leyYiRnLP0QocS2fiWDpTtx8LTz0BAJIIBQAgiVC019HcA7QQx9KZOJbO1NXHwmsUAIAkHlEAAJIIBQAgiVBsItt/avsN2/9re823xtmu2j5l+zXbM+2csVlXcSz32H7T9hnbh9s5Y7NsX2/7RdtvFT9/Z439Ova8rPd79rJHiu2v274zx5zNaOJY9tueK87Da7YfzjHnemw/afuC7dNrbO+ac3KFiOCySRdJn5f0OUk/kTSS2K8qaWfueTd6LJJ6JP2npM9K6pd0UtJtuWdvMOdfSzpcLB+W9FfddF6a+T1LOijpeUmWdJekf8k99waOZb+kv8s9axPH8iVJd0o6vcb2rjgnjS48othEEfHvEfFm7jlaoclj2SfpTES8HRELkp6VNLb50121MUlPFctPSfpqvlGuSTO/5zFJT8eyVyQN2d7V7kGb0C3/zawrIl6W9EFil245J1cgFJ0hJP3I9gnbh3IPswE3S3pnxfWzxbpOc2NEnJek4ucNa+zXqeelmd9zt5yLZue82/ZJ28/bvr09o7Vct5yTK/Av3G2Q7R9LuqnBpu9ExLEmb+aLEXHO9g2SXrT9i+JvJ23VgmNxg3VZ3n+dOparuJmOOC8NNPN77phzsY5m5nxVy99D9JHtg5Kek7RnswfbBN1yTq5AKDYoIkZbcBvnip8XbP9Ayw/H2/4HUguO5aykW1dcv0XSuQ3e5jVJHYvt92zviojzxUP/C2vcRkeclwaa+T13zLlYx7pzRsSHK5aP2/4b2zsjotO/ZG+1bjknV+Cpp8xsD9r+9CfLkr4sqeG7JrrAtKQ9tnfb7pd0n6SpzDM1MiXpgWL5AUlXPFrq8PPSzO95StL9xTtt7pI098nTbR1m3WOxfZNtF8v7tPzn1vttn3TjuuWcXCn3q+lb+SLpa1r+W8RFSe9JeqFY/xlJx4vlz2r5nR4nJb2h5ad5ss9+LcdSXD8o6T+0/E6WTj2W35X0kqS3ip/Xd9t5afR7lvSgpAeLZUt6rNh+Sol33eW+NHEsDxXn4KSkVyT9Qe6Z1ziOSUnnJV0q/l+pdOs5WX3hKzwAAEk89QQASCIUAIAkQgEASCIUAIAkQgEASCIUAIAkQgEASCIUQJvYfq74gsE3OuxLBoEkPnAHtInt6yPiA9sDWv7qij+KiG78KgpsM3wpINA+f277a8XyrVr+BlRCgY5HKIA2sL1f0qikuyPiY9s/kfSpnDMBzeI1CqA9flvSr4tI/J6W/ylMoCsQCqA9fiip1/brkv5Cy9+CCnQFXswGACTxiAIAkEQoAABJhAIAkEQoAABJhAIAkEQoAABJhAIAkPR/5Ak30r2Nz1UAAAAASUVORK5CYII=\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"ax = daten.plot.scatter(x = 'a', y = 'b', c = 'green')\n",
"# x und y bezeichnen die Variablen, c bezeichnet die Farbe der Punkte im Streudiagramm"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Korrelationskoeffizient nach Pearson\n"
]
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
a
\n",
"
b
\n",
"
\n",
" \n",
" \n",
"
\n",
"
a
\n",
"
1.000
\n",
"
-0.422
\n",
"
\n",
"
\n",
"
b
\n",
"
-0.422
\n",
"
1.000
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" a b\n",
"a 1.000 -0.422\n",
"b -0.422 1.000"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"print(\"\\nKorrelationskoeffizient nach Pearson\")\n",
"daten.corr(method = 'pearson').round(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.3) Speichern des Datenfiles/Dataframes\n",
"\n",
"Ein Dataframe sollte - sofern man es zu einem späteren Zeitpunkt wieder verwenden möchte - natürlich auch gespeichert werden. Nachfolgend wurde rund um die Funktion **to_csv()** eine einfache Funktion geschrieben, die einerseits nachfragt, ob gespeichert werden soll oder nicht und andererseits auch die Eingabe eines Dateinamens erlaubt. Gespeichert wird die Datei dann im CSV-Format, d.h. als Datei, in denen die einzelnen Spalten durch ein Komma getrennt sind.\n",
"\n",
"[How to Export Pandas DataFrame to a CSV File](https://datatofish.com/export-dataframe-to-csv/)\n",
"\n",
"[Saving a pandas Dataframe as a CSV File](https://medium.com/@waliamrinal/saving-a-pandas-dataframe-as-a-csv-file-4f8b74b7a1bc)\n",
"\n",
"[Saving a Pandas Dataframe as a CSV](https://www.geeksforgeeks.org/saving-a-pandas-dataframe-as-a-csv/)\n",
"\n",
"[How to avoid Python/Pandas creating an index in a saved csv?](https://stackoverflow.com/questions/20845213/how-to-avoid-python-pandas-creating-an-index-in-a-saved-csv)\n",
"\n",
"[pandas.DataFrame.to_csv](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_csv.html)\n",
"\n",
"Durch die Angabe von *index=False* wird vermieden, dass bei jedem Speichervorgang ein neuer (zusätzlicher) Zeilenindex eingefügt wird!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def save(df):\n",
" speichern = input(\"Dataframe \\n\\n{}\\n\\n als CSV File speichern? j/n \".format(df.head(3)))\n",
" if speichern == \"j\":\n",
" file = input(\"\\n Filename: \")\n",
" df.to_csv(\"C:\\\\Datenfiles\\\\{}.csv\".format(file), index = False) # 'index = False' ist relevant!\n",
" print('File {} wurde gespeichert'.format(file))\n",
" elif speichern == \"n\":\n",
" print(\"\\n Ok, nicht speichern...\")\n",
" else:\n",
" print(\"\\n Ungültige Eingabe!\")\n",
" save(df)\n",
"\n",
"# Speichern des neuen Dataframes - kann auch als eigenes Modul ausgelagert und erweitert (z.B. um Pfadangabe usw.) werden"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wird die Funktion mit **save(df)** ('df' steht für den Namen des zu speichernden Dataframes) aufgerufen, wird auch noch eine dreizeilige Ansicht des zu speichernden Dataframes angezeigt. Somit kann man nochmals kurz prüfen, ob man das richtige Dataframe speichert."
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dataframe \n",
"\n",
" a b\n",
"0 -0.584532 1.834036\n",
"1 -0.445541 1.112410\n",
"2 -1.731362 0.103345\n",
"\n",
" als CSV File speichern? j/n n\n",
"\n",
" Ok, nicht speichern...\n"
]
}
],
"source": [
"save(daten) # 'daten' = Name des zu speichernden Dataframes!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Kurzversion\n",
"\n",
"Dabei wird das Dataframe nicht mehr angezeigt und auch nicht nachgefragt, ob man wirklich speichern möchte."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [],
"source": [
"daten.to_csv(\"C:\\\\Datenfiles\\\\testversion.csv\", index = False)\n",
"# 'daten' steht für den Namen des zu speichernden Dataframes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### In die Zwischenablage kopieren, für die Weiterverwendung in beliebigen anderen Programmen\n",
"\n",
"Mit der Funktion **to_clipboard()** können beliebige Ausschnitte eines Dataframes (oder auch das ganze Dataframe) in die Windows Zwischenablage kopiert und danach in anderen Programmen (z.B. Excel, Word, usw.) eingefügt und weiterverwendet werden.\n",
"\n",
"[pandas.DataFrame.to_clipboard](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_clipboard.html)"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [],
"source": [
"daten.head(3).round(2).to_clipboard() # kopiert die Outputtabelle in die Windows Zwischenablage\n",
"# (allerdings mit . als Dezimaltrennzeichen, somit Probleme bspw. beim Einfügen in Excel weil Kommazahlen nicht erkannt!)\n",
"\n",
"# nachfolgend abgebildete Tabelle ist nur ein Symbolbild"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| |a|b|\n",
"|-|-|-|\n",
"|0|-0.39|1.22|\n",
"|1|2.19|2.17|\n",
"|2|-2.66|-1.44|\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.4) Aktuelles Arbeitsverzeichnis identifizieren und ev. ändern\n",
"\n",
"Man kann das aktuelle Arbeitsverzeichnis - also jenes Verzeichnis, aus dem Files geladen werden bzw. in dem Files gespeichert werden sofern man keinen anderen Pfad angibt - identifizieren. Dazu muss zuerst das Modul **os** importiert werden. In diesem Modul befindet sich die Funktion **getcwd()**, welche wir aufrufen, um das aktuelle Arbeitsverzeichnis in Erfahrung zu bringen.\n",
"\n",
"[How to change current working directory in python?](https://thispointer.com/how-to-change-current-working-directory-in-python/)"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [],
"source": [
"import os"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'C:\\\\'"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"os.getcwd() # Aktuelles Arbeitsverzeichnis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Zum Ändern des Arbeitsverzeichnisses (für die aktuelle Sitzung, also nicht dauerhaft für alle Zeiten...) gibt es die Funktion **chdir()**, welcher man den Pfad zum gewünschten neuen Arbeitsverzeichnis übergeben kann. In untenstehender Funktion wird zuerst zudem noch geprüft, ob das gewünschte neue Arbeitsverzeichnis überhaupt existiert (d.h. angelegt ist)."
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Arbeitsverzeichnis wurde geändert\n"
]
}
],
"source": [
"if os.path.exists(\"C:\\\\\"): \n",
" os.chdir(\"C:\\\\Datenfiles\") # Dies soll das neue Arbeitsverzeichnis sein, sofern es existiert\n",
" print(\"Arbeitsverzeichnis wurde geändert\")\n",
"else:\n",
" print(\"Änderung nicht möglich, ev. existiert der Ordner nicht...\") "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ein erneuter Aufruf von **getcwd()** bestätigt, dass das Arbeitsverzeichnis wunschgemäß geändert wurde."
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'C:\\\\Datenfiles'"
]
},
"execution_count": 68,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"os.getcwd()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.7.9"
}
},
"nbformat": 4,
"nbformat_minor": 2
}