11_03_pandas_advanced_functions_lambda.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./pic/advanced_functions/lambda/1_title.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>marke</th>\n",
       "      <th>modell</th>\n",
       "      <th>preis</th>\n",
       "      <th>kilometer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>Golf</td>\n",
       "      <td>9.797 €</td>\n",
       "      <td>79.449 km</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>Golf</td>\n",
       "      <td>13.890 €</td>\n",
       "      <td>76.486 km</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mercedes-Benz</td>\n",
       "      <td>SLK 300</td>\n",
       "      <td>19.990 €</td>\n",
       "      <td>84.000 km</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Mercedes-Benz</td>\n",
       "      <td>SLK 350</td>\n",
       "      <td>19.990 €</td>\n",
       "      <td>84.000 km</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Mercedes-Benz</td>\n",
       "      <td>A 220</td>\n",
       "      <td>17.450 €</td>\n",
       "      <td>109.252 km</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           marke   modell     preis   kilometer\n",
       "0     Volkswagen     Golf   9.797 €   79.449 km\n",
       "1     Volkswagen     Golf  13.890 €   76.486 km\n",
       "2  Mercedes-Benz  SLK 300  19.990 €   84.000 km\n",
       "3  Mercedes-Benz  SLK 350  19.990 €   84.000 km\n",
       "4  Mercedes-Benz    A 220  17.450 €  109.252 km"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('./csv/replace_split/cars.csv', usecols=['marke', 'modell', 'preis', 'kilometer'])\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine `Lambda`-Funktion in der `Python`-Programmierung ist eine anonyme Funktion oder eine Funktion, die keinen Namen hat. Es handelt sich um eine kleine und eingeschränkte Funktion mit <u>**nicht mehr als einer Zeile**</u>. Genau wie eine normale Funktion kann eine `Lambda`-Funktion mehrere Argumente mit einem Ausdruck haben.\n",
    "\n",
    "In `Python` werden `Lambda`-Ausdrücke (oder `Lambda`-Formen) verwendet, um anonyme Funktionen zu konstruieren. Dazu verwendest du das Schlüsselwort **`lambda`** (so wie du **`def`** zur Definition normaler Funktionen verwenden). Jede anonyme Funktion, die du in Python definierst, besteht aus 3 wesentlichen Teilen:\n",
    "\n",
    "- Das lambda-Schlüsselwort.\n",
    "- Die Parameter (oder gebundenen Variablen) und\n",
    "- den Funktionsrumpf.\n",
    "\n",
    "Eine Lambda-Funktion kann eine beliebige Anzahl von Parametern haben, aber der Funktionskörper kann nur einen Ausdruck enthalten. Außerdem wird eine `Lambda`-Funktion in einer einzigen Codezeile geschrieben und kann auch sofort aufgerufen werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](./pic/advanced_functions/lambda/2_lambda.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <u>Beispiel 1:</u> Markenname zu lower-case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mit Funktion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_lower(x):\n",
    "    try:\n",
    "        return x.lower()\n",
    "    except:\n",
    "        return np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0          volkswagen\n",
       "1          volkswagen\n",
       "2       mercedes-benz\n",
       "3       mercedes-benz\n",
       "4       mercedes-benz\n",
       "            ...      \n",
       "9995       volkswagen\n",
       "9996             audi\n",
       "9997       volkswagen\n",
       "9998              bmw\n",
       "9999       volkswagen\n",
       "Name: marke, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.marke.apply(to_lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mit `lambda`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um erst einmal zu veranschaulichen wie `lambda` arbeitet, droppen wir die `Nan` Values aus der Spalte **marke** von dem `DataFrame`. Wie man diese selbst mit `lambda` umgehen kann, wirst du im *Beispiel 2* lernen. Der Einfachheitshalber löschen wir diese Daten aus diesem einführenden Beispiel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.dropna(subset=['marke'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9541, 4)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...und können dann, sämtliche Inhalte der Spalte **marke** zu `lower-case` umformen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0          volkswagen\n",
       "1          volkswagen\n",
       "2       mercedes-benz\n",
       "3       mercedes-benz\n",
       "4       mercedes-benz\n",
       "            ...      \n",
       "9995       volkswagen\n",
       "9996             audi\n",
       "9997       volkswagen\n",
       "9998              bmw\n",
       "9999       volkswagen\n",
       "Name: marke, Length: 9541, dtype: object"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.marke.apply(lambda x: x.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie du also sehen kannst, steht das **`x`** für jeweils eine Zeile der `Series`. Also werden nach und nach sämtliche Markennamen zu Kleinbuchstaben umgeformt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <u>Beispiel 2:</u> Punctuation entfernen (Spalte `preis`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mit Funktion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_punctuation(x):\n",
    "    try:\n",
    "        return x.replace('.', '').replace(' €', '')\n",
    "    except:\n",
    "        return np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        9797\n",
       "1       13890\n",
       "2       19990\n",
       "3       19990\n",
       "4       17450\n",
       "        ...  \n",
       "9995    14900\n",
       "9996    17990\n",
       "9997    16490\n",
       "9998    14749\n",
       "9999    12950\n",
       "Name: preis, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.preis.apply(remove_punctuation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mit `lambda`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anstatt die `Nan`-Values zu entfernen, fragen wir diese in diesem Fall direkt mit ab. Die folgende `lambda` Funktion bedeutet:\n",
    "> Wenn der aktuelle Wert `Nan` ist, dann hinterlege auch wieder `Nan`, ansonsten führe die hinterlegte Operation aus und replace den `.` mit `nichts` und `leer €` ebenfalls mit `nichts`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        9797\n",
       "1       13890\n",
       "2       19990\n",
       "3       19990\n",
       "4       17450\n",
       "        ...  \n",
       "9995    14900\n",
       "9996    17990\n",
       "9997    16490\n",
       "9998    14749\n",
       "9999    12950\n",
       "Name: preis, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.preis.apply(lambda x: np.nan if x is np.nan else x.replace('.', '').replace(' €', ''))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <u>Beispiel 3:</u> Punctuation entfernen (Spalte `kilometer`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df3 = df.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mit Funktion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_punctuation(x):\n",
    "    try:\n",
    "        return x.replace('.', '').replace(' km', '')\n",
    "    except:\n",
    "        return np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        79449 km\n",
       "1        76486 km\n",
       "2        84000 km\n",
       "3        84000 km\n",
       "4       109252 km\n",
       "          ...    \n",
       "9995     93500 km\n",
       "9996     96500 km\n",
       "9997    103000 km\n",
       "9998     94505 km\n",
       "9999     84500 km\n",
       "Name: kilometer, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.kilometer.apply(remove_punctuation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'79.449\\xa0km'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.loc[0, 'kilometer']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        79449\n",
       "1        76486\n",
       "2        84000\n",
       "3        84000\n",
       "4       109252\n",
       "         ...  \n",
       "9995     93500\n",
       "9996     96500\n",
       "9997    103000\n",
       "9998     94505\n",
       "9999     84500\n",
       "Name: kilometer, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.kilometer.apply(lambda x: np.nan if x is np.nan else x.replace('.', '').replace('\\xa0km', ''))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## <u>Übung</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>marke</th>\n",
       "      <th>leistung</th>\n",
       "      <th>hubraum</th>\n",
       "      <th>schadstoffklasse</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>63 kW (86 PS)</td>\n",
       "      <td>1.197 cm³</td>\n",
       "      <td>Euro5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>92 kW (125 PS)</td>\n",
       "      <td>1.395 cm³</td>\n",
       "      <td>Euro6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Mercedes-Benz</td>\n",
       "      <td>170 kW (231 PS)</td>\n",
       "      <td>2.997 cm³</td>\n",
       "      <td>Euro5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Mercedes-Benz</td>\n",
       "      <td>170 kW (231 PS)</td>\n",
       "      <td>2.997 cm³</td>\n",
       "      <td>Euro5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Mercedes-Benz</td>\n",
       "      <td>125 kW (170 PS)</td>\n",
       "      <td>2.143 cm³</td>\n",
       "      <td>Euro6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9995</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>90 kW (122 PS)</td>\n",
       "      <td>1.395 cm³</td>\n",
       "      <td>Euro5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9996</th>\n",
       "      <td>Audi</td>\n",
       "      <td>165 kW (224 PS)</td>\n",
       "      <td>1.984 cm³</td>\n",
       "      <td>Euro6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9997</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>162 kW (220 PS)</td>\n",
       "      <td>1.984 cm³</td>\n",
       "      <td>Euro6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9998</th>\n",
       "      <td>BMW</td>\n",
       "      <td>135 kW (184 PS)</td>\n",
       "      <td>1.995 cm³</td>\n",
       "      <td>Euro5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9999</th>\n",
       "      <td>Volkswagen</td>\n",
       "      <td>110 kW (150 PS)</td>\n",
       "      <td>1.395 cm³</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>10000 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              marke         leistung    hubraum schadstoffklasse\n",
       "0        Volkswagen    63 kW (86 PS)  1.197 cm³            Euro5\n",
       "1        Volkswagen   92 kW (125 PS)  1.395 cm³            Euro6\n",
       "2     Mercedes-Benz  170 kW (231 PS)  2.997 cm³            Euro5\n",
       "3     Mercedes-Benz  170 kW (231 PS)  2.997 cm³            Euro5\n",
       "4     Mercedes-Benz  125 kW (170 PS)  2.143 cm³            Euro6\n",
       "...             ...              ...        ...              ...\n",
       "9995     Volkswagen   90 kW (122 PS)  1.395 cm³            Euro5\n",
       "9996           Audi  165 kW (224 PS)  1.984 cm³            Euro6\n",
       "9997     Volkswagen  162 kW (220 PS)  1.984 cm³            Euro6\n",
       "9998            BMW  135 kW (184 PS)  1.995 cm³            Euro5\n",
       "9999     Volkswagen  110 kW (150 PS)  1.395 cm³              NaN\n",
       "\n",
       "[10000 rows x 4 columns]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('./csv/replace_split/cars.csv', usecols=['marke', 'leistung', 'hubraum', 'schadstoffklasse'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ü1: Extrahiere die PS als alleinstehende Zahl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'63\\xa0kW\\xa0(86\\xa0PS)'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[0, 'leistung']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ü1 = df.leistung.apply(lambda x: np.nan if x is np.nan else x.replace('(', '').replace(')', '').split('\\xa0')[2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        86\n",
       "1       125\n",
       "2       231\n",
       "3       231\n",
       "4       170\n",
       "       ... \n",
       "9995    122\n",
       "9996    224\n",
       "9997    220\n",
       "9998    184\n",
       "9999    150\n",
       "Name: leistung, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ü1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ü2: Extrahiere den Hubraum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.197\\xa0cm³'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[0, 'hubraum']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ü2 = df.hubraum.apply(lambda x: np.nan if x is np.nan else float(x.split('\\xa0')[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       1.197\n",
       "1       1.395\n",
       "2       2.997\n",
       "3       2.997\n",
       "4       2.143\n",
       "        ...  \n",
       "9995    1.395\n",
       "9996    1.984\n",
       "9997    1.984\n",
       "9998    1.995\n",
       "9999    1.395\n",
       "Name: hubraum, Length: 10000, dtype: float64"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ü2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ü3: Extrahiere die Schadstoffklasse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Euro5'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[0, 'schadstoffklasse']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(df.loc[0, 'schadstoffklasse'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Euro5', 'Euro6', nan, 'Euro6d-TEMP', 'Euro4', 'Euro3', 'Euro6c',\n",
       "       'Euro6d', 'Euro2'], dtype=object)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['schadstoffklasse'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ü3 = df.schadstoffklasse.apply(lambda x: np.nan if x is np.nan else x[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0         5\n",
       "1         6\n",
       "2         5\n",
       "3         5\n",
       "4         6\n",
       "       ... \n",
       "9995      5\n",
       "9996      6\n",
       "9997      6\n",
       "9998      5\n",
       "9999    NaN\n",
       "Name: schadstoffklasse, Length: 10000, dtype: object"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ü3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}