DataVis_Day1_empty.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2t6QvIhTJaT6"
   },
   "source": [
    "# Working with google Colab\n",
    "\n",
    "During our praticals, we will work in `google colab`, it pretty much works like a `jupyter notebook` but with the advantage that we don´t need to install `python` or `python packages` on our local machine and can start right away! \n",
    "\n",
    "\n",
    "If you want to read more about Colab, you can start here:\n",
    "- [Colab FAQ](https://research.google.com/colaboratory/faq.html)\n",
    "\n",
    "\n",
    "------ -\n",
    "\n",
    "### Awesome! Let´s get started\n",
    "![](https://media0.giphy.com/media/unQ3IJU2RG7DO/200w.webp?cid=ecf05e47f6mswynnu54ew49x7ciyvu7on88fjiseqmbkcw89&rid=200w.webp&ct=g)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Introduction\n",
    "\n",
    "Before we start getting into data visualization, we will briefly introduce some core concepts and how-to`s \n",
    "of python programming. \n",
    "\n",
    "This introduction is far from complete and is rather meant to be a primer. \n",
    "\n",
    "If you want to know more, I suggest the excellent course from my former colleague Peer Herholz [here](https://peerherholz.github.io/Python_for_Psychologists_Winter2021/index.html).\n",
    "\n",
    "\n",
    "If you ever got stuck with a specific problem, using [stackoverflow](http://stackoverflow.com) or `LLMs` with the right query might help you. \n",
    "\n",
    "Besides that `google colab / jupyter notebooks` offer tab completion and additional help functionality by e.g., \n",
    "using `pd.read_csv?`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell Types\n",
    "\n",
    "There are generellay two types of cells in `jupyter notebooks' - either code or markdown cells. This explanation is\n",
    "currently written in a markdown cell. Code is usually written and executed in code cells.\n",
    "\n",
    "We can transform a code cell into a markdown cell via ```esc + m``` and a markdown cell into a code cell via ```esc + y```. \n",
    "In code cells, we usually add comments with `# some comment`.\n",
    "\n",
    "Btw: \n",
    "- `shift+enter` executes a cell \n",
    "- `esc + b` inserts a cell below\n",
    "- `esc + a` inserts a cell above\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules\n",
    "\n",
    "Most functionality in python is derived from modules. To make modules available in your python programme, we need to import it first. \n",
    "\n",
    "This is as easy as:\n",
    "\n",
    "```import math ``` \n",
    "\n",
    "```import numpy as np``` (note, `as` indicates an access-name, this could be anything!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Types and Variable Assignments \n",
    "\n",
    "Python supports a variety of data types and structures:\n",
    "\n",
    "- numbers (integers, floats)\n",
    "- strings\n",
    "- booleans (True/False)\n",
    "- lists\n",
    "- dictionaries \n",
    "... \n",
    "\n",
    "A variable can potentially store any data type or structure. For that, we need to assign a value to a variable. \n",
    "This can be done by `my_variable = value`. Note, that we dont need to specify the data type, as this is done dynamically.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_variable = 5\n",
    "float_variable = 5.1\n",
    "string_variable = \"data visialization is fun!\"\n",
    "bool_variable = True  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 <class 'int'>\n",
      "data visialization is fun! <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(number_variable, type(number_variable))\n",
    "\n",
    "print(string_variable, type(string_variable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### converting data types \n",
    "\n",
    "Data Types can be changed with the following functions:\n",
    "\n",
    "- `int()` converts a variables data type into an integer \n",
    "- `float()` ... \n",
    "- `bool()` ... \n",
    "- `str()` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "int(float_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Structures\n",
    "\n",
    "For now we will exclusively focus on `lists` as they might a bit more common for most usecases. However, bear in mind \n",
    "that are other structures, such as `dictionaries`,  `tuples` ....\n",
    "\n",
    "A list can store elements of different types, e.g., 'strings', 'integers' etc ...\n",
    "\n",
    "The common syntax for a list is:\n",
    "\n",
    "```my_list = [\"hello\", \"world\", 1,2, 4.5]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello', 'world', 1, 2, 4.5]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_list = [\"hello\", \"world\", 1,2, 4.5]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### handling lists\n",
    "\n",
    "Lists are very common and offer a good showcase for some core concepts of python programming, such as\n",
    "\n",
    "- indexing (note: indexing in python starts with 0)\n",
    "- loops\n",
    "\n",
    "and the usage of in-built functions:\n",
    "- sort\n",
    "- remove\n",
    "- append\n",
    "- extend\n",
    "Note: built-in functions are part of `lists` and thus the syntax follows the logic `my_list.sort()` etc ..\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_list[0] #returns the first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_list[-1] #returns the last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['world', 1]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_list[1:3] # slicing, select element, note: python excluded the stop index! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello', 'world', 1, 2, 4.5, 'otter', 'otter']"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "### built in functionality \n",
    "my_list.append(\"otter\")\n",
    "\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello', 'world', 1, 2, 4.5, 'otter']"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_list.remove(\"otter\")\n",
    "my_list\n",
    "# execute cell twice "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "\u001b[0;32m/var/folders/s1/tcr0fxpj0x7dym6zmzp38gm40000gn/T/ipykernel_13598/1879591915.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "my_list.sort()\n",
    "# understanding errors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31mSignature:\u001b[0m \u001b[0mmy_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m/\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mDocstring:\u001b[0m\n",
      "Remove first occurrence of value.\n",
      "\n",
      "Raises ValueError if the value is not present.\n",
      "\u001b[0;31mType:\u001b[0m      builtin_function_or_method\n"
     ]
    }
   ],
   "source": [
    "my_list.remove?\n",
    "# getting help "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Control Flow Operators \n",
    "\n",
    "Python has several features that allow us to control the code execution:\n",
    "\n",
    "- iterations (e.g, for loops)\n",
    "- conditionals (e.g., if else)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n",
      "1\n",
      "2\n",
      "4.5\n",
      "otter\n"
     ]
    }
   ],
   "source": [
    "for element in my_list:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "for element in my_list:\n",
    "    print(type(element))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "hello\n",
      "1\n",
      "world\n",
      "2\n",
      "1\n",
      "3\n",
      "2\n",
      "4\n",
      "4.5\n",
      "5\n",
      "otter\n"
     ]
    }
   ],
   "source": [
    "for ix, element in enumerate(my_list):\n",
    "    print(ix)\n",
    "    # element in my_list is: \".format(ix))\n",
    "    print(element)\n",
    "    \n",
    "## sometimes it is useful to have access to the indices of list elements "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n",
      "WORLD\n",
      "1\n",
      "2\n",
      "4.5\n",
      "OTTER\n"
     ]
    }
   ],
   "source": [
    "for element in my_list:\n",
    "    if type(element) == str:\n",
    "        print(element.upper())\n",
    "    else:\n",
    "        print(element)\n",
    "        \n",
    "#print(\"hello\") #showcase for intendation level!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data visualization is awesome! \n",
      "data visualization is awesome! \n",
      "data visualization is awesome! \n",
      "data visualization is awesome! \n",
      "data visualization is awesome! \n"
     ]
    }
   ],
   "source": [
    "for x in range(5):\n",
    "    print(\"data visualization is awesome! \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "for x in range(5):\n",
    "    print(x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# the last code could be re-written using a \"list comprehension\"\n",
    "# which follows the syntax \n",
    "# do something for each element in an iterable \n",
    "[x**2 for x in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HELLO', 'WORLD', 'OTTER']\n",
      "['HELLO', 'WORLD', 1, 2, 4.5, 'OTTER']\n"
     ]
    }
   ],
   "source": [
    "#list comprehensions also allow for if and else statements\n",
    "\n",
    "\n",
    "print([x.upper() for x in my_list if type(x)== str]) #only prints elements of type(str)\n",
    "\n",
    "\n",
    "print([x.upper() if type(x)== str else x for x in my_list])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RO8ZHdDKQ3x9"
   },
   "source": [
    "# Introduction \n",
    "\n",
    "Python offers multiple modules for **data visualization**. \n",
    "\n",
    "For this course, we will focus on the most common and general ones:\n",
    "\n",
    "- [matplotlib](!https://matplotlib.org/) \n",
    "- [seaborn](!https://seaborn.pydata.org/) \n",
    "\n",
    "\n",
    "# matplotlib \n",
    "\n",
    "- designed to provide complete control over your plots\n",
    "\n",
    "Matplotlib (and all hig level APIs that build upon it) builds upon a specifc anatomy of a figure:\n",
    "\n",
    "![](https://matplotlib.org/stable/_images/sphx_glr_anatomy_001_2_0x.png)\n",
    "\n",
    "\n",
    "Thats a lot of information, but let´s boil it down: \n",
    "\n",
    "- **figures**: the entire graphic on which axes, titles, legends etc. are drawn.\n",
    "- **axes**: an area in which you can locate points in terms of x-y coordinates\n",
    "- **axis**: providing scale for data (ticks, tick labels)\n",
    "- **artist**: everything that you can see on the figure (e.g. text, lines)\n",
    "\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "avkaWJjoaPDZ"
   },
   "source": [
    "## Getting started with `Matplotlib`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hBx7r6UV3WpY"
   },
   "outputs": [],
   "source": [
    "# importing packages\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "# make sure to run the second line to embedd your graphics directly in your jupyter notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q_WGL6sXa53w"
   },
   "outputs": [],
   "source": [
    "x =  ... # generates 20 numbers between 0 and 10 \n",
    "y =  ...                # x square "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 283
    },
    "id": "CPB8lcS2biwf",
    "outputId": "68887c4c-f000-4a09-bb66-e663182ac6f1"
   },
   "outputs": [],
   "source": [
    "... # creates a figure with a specific size on which we can draw\n",
    "... # lineplot "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2wWzoim_cUWt"
   },
   "source": [
    "This was super easy! However, the plot misses some important to make it meaningful, such as `axes label` and a `title`. This can be easily added with matplotlibs `plt` interface.\n",
    "\n",
    "*Note*: As stated above, `matplotlib` allows you full control over your plots, which (often) means more line of code! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 318
    },
    "id": "NwLjtBECc1u_",
    "outputId": "ddb4b3d4-a3f3-4957-d260-291d39291fb4"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(4,4)) \n",
    "plt.plot(x,y) #lineplot\n",
    "... #add xticklabel\n",
    "... #add yticklabel\n",
    "... #add title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lSFQRQnvwr9-"
   },
   "source": [
    "`Matplotlib` also allows to easily draw multiple `subplots` within one `plot` by using the `subplots` function. Graphics are can than be added via the `axes`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 297
    },
    "id": "Qby-7PSDurFR",
    "outputId": "a27fe4b7-92fb-4d5f-cb75-81417cd6d171"
   },
   "outputs": [],
   "source": [
    "... #create subplots nrows=1, ncols=2\n",
    "\n",
    "... #lineplot xy\n",
    "... # lineplot yx\n",
    "\n",
    "plt.tight_layout() #adjusts spacing between plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dCXHo15pZh12"
   },
   "source": [
    "Of course `matplotlib` comes with support for basically all *standard plots* such as `boxplots`,`barplots`, `histograms`, `scatterplots` ... Make sure to check [their great overview](https://matplotlib.org/stable/gallery/index.html) of whats possible! \n",
    "\n",
    "--------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B93l5M0FHthu"
   },
   "source": [
    "# Real Data \n",
    "\n",
    "\n",
    "First we will make use of datasets provided by the seaborn package. For handling the data, we will rely on `pandas`.\n",
    "\n",
    "![](https://media.giphy.com/media/EatwJZRUIv41G/giphy.gif) \n",
    "\n",
    "Oh no, not on that fluffy fellow but a python module of the same name!\n",
    "\n",
    "\n",
    "If you want to learn more about pandas, check:\n",
    "- [10 minutes to pandas](https://pandas.pydata.org/docs/user_guide/10min.html) \n",
    "- [pandas getting started](https://pandas.pydata.org/docs/getting_started/intro_tutorials/index.html)\n",
    "\n",
    "\n",
    "\n",
    "We will cover some very basic dataframe handling in the next few lines, i.e.,\n",
    "- loading data from `sns.load_datasets()`\n",
    "- inspecting the dataframe with `.head()` and `.describe()`\n",
    "- checking for missing values and excluding them\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "phoOj8GMJVhx"
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8p7eUerA51kZ",
    "outputId": "51d537ff-78fd-4460-a49f-4e157fc7b464"
   },
   "outputs": [],
   "source": [
    "df = sns.load_dataset(\"penguins\")\n",
    "... # print shape "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yMFAce9vJxVk"
   },
   "source": [
    "### Understanding the data\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "l-ZqNvFE6DLE",
    "outputId": "1e46f205-d191-4a53-b7a9-c07b944b0ab9"
   },
   "outputs": [],
   "source": [
    "... #depicts the first 5 rows of our dataframe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 300
    },
    "id": "KBTGuM2n7pIt",
    "outputId": "3ae64a8e-58c5-44f7-b394-934c73d549ef"
   },
   "outputs": [],
   "source": [
    "... #summarizes all numeric columns (central tendency, distribution, dispersion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vzPMeYX0kFtB",
    "outputId": "d8145612-cfb9-4bf1-e042-d354c27bfc1b"
   },
   "outputs": [],
   "source": [
    "... # checking for missing values in columns (ie variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OqQv7-xZlIyg"
   },
   "source": [
    "Usually it´s up to you as a researcher how to handle missing data. The most common things to do with missing data is `imputation` or `dropping NaNs`. For now, we will just drop every row that has at least one missing data point (ie `NaN`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ditmI2BpnEgx",
    "outputId": "afac9505-ac74-4fb4-d0e9-b1aaaa23789e"
   },
   "outputs": [],
   "source": [
    "... #dropping rows that contain >= 1 missing value \n",
    "...  #sanity check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o42gfFV2pqVr"
   },
   "source": [
    "Lets investigate whether there might be any interesting relationships between our variables. To get a first (non-visual) impression of the relatedness of our variables, we can compute pairwise correlations between columns using `df.corr()`. Note: This might not be suitable with larger dataframes!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 174
    },
    "id": "rRxHEWTXnFxQ",
    "outputId": "de512d2d-fe34-4cd3-a1ec-e438a64249a2"
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6zbujUe2ZWVH"
   },
   "source": [
    "Now that we have our data at hand, lets try to plot the relationship between\n",
    "`body_mass` and `flipper_length` as a scatterplot using `matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 407
    },
    "id": "abSOblTMqxjS",
    "outputId": "fcee957c-3a69-4fbb-f810-afae2c142b6b"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(5,6))\n",
    "\n",
    "... # plot scatter \n",
    "... # plot xlabel\n",
    "...  # plot ylabel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gldk4SmOdrJ5"
   },
   "source": [
    "# seaborn \n",
    "\n",
    "easy generation of plots with less lines of code (vs. `matplotlib`)\n",
    "\n",
    "- various [styles](https://seaborn.pydata.org/tutorial/aesthetics.html) and [color palettes](https://seaborn.pydata.org/tutorial/color_palettes.html)\n",
    "- wide range of supported plots \n",
    "- good starting point for exploring and visualizing your data \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YELrzLqnjHD6"
   },
   "source": [
    "Lets try to recreate the `scatterplot` from above using `seaborn`.\n",
    "\n",
    "Hint: \n",
    "- using e.g. `sns.scatterplot?` in a code cell will show the functions documentation with all parameters etc\n",
    "- use [stackoverflow](https://stackoverflow.com/) to find answers to literally all coding-related questions you might have, e.g., if you want to find out, how you could change the size of the markers used in `sns.scatterplot`, [here](https://stackoverflow.com/questions/52785101/seaborn-scatterplot-marker-size-for-all-markers) people already got you covered.\n",
    "- check the [python graph gallery](https://www.python-graph-gallery.com/) to see what kind of plots you could make\n",
    "- check the [seaborn tutorial page](https://seaborn.pydata.org/tutorial.html) to get started"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 407
    },
    "id": "Sbw06SOlqe--",
    "outputId": "88d891c6-6549-4804-8193-7a3a15e76eac"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "... #scatterplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nJsuPJJ8rN-i"
   },
   "source": [
    "Now lets try to add `species` as a third varible into our `scatterplot` to visualize whether there might be some *between-species* differences in the association between *body_mass* and *flipper_length*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 407
    },
    "id": "8GWHBbjsj49I",
    "outputId": "7b858c22-201d-4dc7-f506-9736aecf5e30"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "... #scatterplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_D0HL4WBkEnh"
   },
   "source": [
    "From this plot we can see that the `Gentoo` penguins appear to have higher values on our variables of interest. However, from the `scatterplot` we can´t really answer the question whether the association between `body_mass` and `flipper_length` varies as a function of `species`. \n",
    "\n",
    "\n",
    "Lets try to use 'sns.lmplot' ([documentation](https://seaborn.pydata.org/generated/seaborn.lmplot.html)) to plot the same association as above, but now for each `specie` and with `sex` overlayed. Additionally try to change the `color` and use different `markers` for male and female penguins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 406
    },
    "id": "r6quem6IoJ0T",
    "outputId": "90ed3a65-17bf-4090-8878-feccf54fdaa8"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(5,5))\n",
    "## lmplot \n",
    "...\n",
    "...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CbXNptZgrGKh"
   },
   "source": [
    "# Uploading file to colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "uXL0lZQzzBvA",
    "outputId": "35c254b1-fd3a-40b5-b31d-2b2ece1e3e14"
   },
   "outputs": [],
   "source": [
    "from google.colab import files\n",
    "files.upload() ## upload the mistery.csv "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8LhDkMl1Z3bT"
   },
   "source": [
    "Reading different datatables with `pandas` can be done by using one of the functions [here](https://pandas.pydata.org/docs/reference/io.html). One of the most common usecases would be `pandas.read_csv()`, see below for some basic functionality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "0LwD6q0vzEaU",
    "outputId": "94653e36-b52a-4216-e127-5b1db22e8ac6"
   },
   "outputs": [],
   "source": [
    "import os # import operating system\n",
    "os.listdir() #get list of files in current directory\n",
    "\n",
    "# load the data and read it into a dataframe\n",
    "mistery = ... \n",
    "mistery.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 387
    },
    "id": "a9643ewBzLFO",
    "outputId": "480afdc5-4b81-462f-96f1-c5bd13a134f1"
   },
   "outputs": [],
   "source": [
    "# try to figure out what kind of data you have \n",
    "# hint: use sns.relplot in a similar way as sns.lmplot before \n",
    "\n",
    "\n",
    "...\n",
    "...\n",
    "...\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "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": 1
}