Classes_01_Arrays.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/abelowska/eegML-exercises/blob/main/Classes_01_Arrays.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yXi0l2XpclEA"
      },
      "source": [
        "# Introduction to Arrays and DataFrames"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlxE9uISw0Yv"
      },
      "source": [
        "<a name='Review'></a>\n",
        "## Review from the first lecture\n",
        "\n",
        "\n",
        "The first lecture covered basic mathematical operations, variables, and lists. That lecture also introduced you to conditional statements, loops, and basic plotting using matplotlib. Before moving forward, here is a quick review."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gODpUW41w0Yw"
      },
      "outputs": [],
      "source": [
        "ourList = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tyj8M4Tbw0Yw"
      },
      "source": [
        " **Loops** with **dummy variables** are useful to iterate over lists and perform operations on each element."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hTYBYH_Ww0Yw"
      },
      "outputs": [],
      "source": [
        "i = 0\n",
        "while i < len(ourList):\n",
        "    num = ourList[i] * 10\n",
        "    print(num)\n",
        "    i = i+1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T12P3qJ7w0Yw"
      },
      "source": [
        "Conditional statements like **if** and **else** are used to implement more complex logic."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Odjh-Z-Sw0Yw"
      },
      "outputs": [],
      "source": [
        "i = 0\n",
        "while i < len(ourList):\n",
        "    num = ourList[i]\n",
        "    if num < 5:\n",
        "        print(num)\n",
        "    else:\n",
        "        print(\"I only print numbers less than 5!\")\n",
        "    i = i+1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yCyvx4yWMGKT"
      },
      "source": [
        "The other kind of loop that you might encounter more often while working in Python is the `for` loop. A for-loop has the dummy variable \"built in,\" in a sense."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-YjZ_Rn7MZF-"
      },
      "outputs": [],
      "source": [
        "for num in ourList:\n",
        "    print(num)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oKUpRTFXMv1N"
      },
      "source": [
        "The `range` function can be iterated over to produce a regular sequence of numbers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gJkQuou8M5x9"
      },
      "source": [
        "`range` can be used as `range(end_)`, or as `range(start_, end_)`, or as `range(start_, end_, step_)`. Here's the [official documentation](https://docs.python.org/3/library/functions.html#func-range) as well as an [easier-to-read explainer webpage](https://www.w3schools.com/python/ref_func_range.asp)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r0-kbZDTM1qL"
      },
      "outputs": [],
      "source": [
        "for num in range(10):\n",
        "    print(num)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y7scwvhLw0Yw"
      },
      "source": [
        "Finally, recall that the **matplotlib** module can be used to plot data.\n",
        "\n",
        "First, import the module - this is always the first step whenever you're using a python module, but it's easy to forget! Then, we use a magic command that makes the figure appear within the cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nyQHClgow0Yw"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "squareList = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
        "\n",
        "plt.plot(ourList,squareList)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q82yTzDTw0Yx"
      },
      "source": [
        "# Lecture 2 - NumPy, Functions, and Data\n",
        "\n",
        "Today, we will learn about NumPy and learn about handling data in Python.\n",
        "\n",
        "1. An introduction to **numpy** and **numpy arrays** and a discussion of their usefulness in solving real problems\n",
        "3. Introduction to **Pandas** dataframes.\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eWoP8Tfuw0Yy"
      },
      "source": [
        "<a name='intro'></a>\n",
        "## A. Introduction to Numpy Arrays - Initialization and Advanced Indexing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3DR1oDfEw0Yy"
      },
      "source": [
        "The Python `list` is a fast and flexible built-in data type, but because of its flexbility, it is limited in the operations we can perform on it. A popular scientific computing package called `numpy`, short for \"numerical Python\", can help by way of its incredibly powerful object type: the `array`. For further information on Python lists vs Numpy arrays, see: [https://www.geeksforgeeks.org/python-lists-vs-numpy-arrays/](https://www.geeksforgeeks.org/python-lists-vs-numpy-arrays/)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DKWCEZRKw0Yy"
      },
      "outputs": [],
      "source": [
        "c = list(range(10))\n",
        "c"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ra9Iga_sw0Yz"
      },
      "outputs": [],
      "source": [
        "d = c**2\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The code above yielded an error - lists and ranges do not support mathematical operations. The solution is to perform the operation in a loop:"
      ],
      "metadata": {
        "id": "pFk1RDC1jOvy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = []\n",
        "for item in c:\n",
        "  d_item = item**2\n",
        "  d.append(d_item)\n",
        "print(d)"
      ],
      "metadata": {
        "id": "4tGpwDLGj9nM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Or using list comprehension:"
      ],
      "metadata": {
        "id": "1_xNypjQkRWH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = # put your code here\n",
        "print(d)"
      ],
      "metadata": {
        "id": "ivbw-ZzzkQkV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KLVB6o30cEKW"
      },
      "source": [
        "But the most efficient and elegant way is provided via numpy library.\n",
        "\n",
        "First, import the numpy module. We typically abbreviate it as `np`.\n",
        "\n",
        "To convert the list to a numpy array, use `np.array()`.\n",
        "<a name='array'></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IX82Khm_w0Yz"
      },
      "outputs": [],
      "source": [
        "# Import the numpy lib\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u8dlnbV3w0Yz"
      },
      "outputs": [],
      "source": [
        "# convert the list c to an array\n",
        "c = np.array(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UFqeZJ-Kw0Yz"
      },
      "outputs": [],
      "source": [
        "d = c**2\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J8hqYtbYw0Yz"
      },
      "source": [
        "<a name='ranges'></a>\n",
        "There are a few easier ways to create arrays besides creating a list and turning it into a numpy array. These include:\n",
        "* `np.arange(start_,stop_,step_)`\n",
        "* `np.linspace(first_,last_,num_)`\n",
        "\n",
        "(And the accompanying official documentation pages: [numpy.arange](https://numpy.org/doc/stable/reference/generated/numpy.arange.html), [numpy.linspace](https://numpy.org/doc/stable/reference/generated/numpy.linspace.html#numpy.linspace))\n",
        "\n",
        "These create arrays of numbers within a range with a fixed step-size between each consecutive number in the array. You can try these out below.\n",
        "\n",
        "`np.arange(start_,stop_,step_)` works just like the `range` function we introduced at the beginning of this lesson! But instead of the mysterious `range` object type, the numpy function returns a nice, neat numpy array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xDhsW07Fw0Yz"
      },
      "outputs": [],
      "source": [
        "np.arange(0, 10, 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_Ooc_Ia5w0Yz"
      },
      "outputs": [],
      "source": [
        "np.linspace(0, 10, 11)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j62mXK4xw0Yz"
      },
      "source": [
        "<a name='empty'></a>\n",
        "Sometimes it is handy to create an array of all constant values, which can then be replaced later with data. This can be done in several ways by using the following commands:\n",
        "\n",
        "* [`np.zeros(size_)`](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html) To fill the array with zeros\n",
        "* [`np.ones(size_)`](https://numpy.org/doc/stable/reference/generated/numpy.oness.html) To fill the array with ones\n",
        "* [`np.empty(size_)`](https://numpy.org/doc/stable/reference/generated/numpy.empty.html) To fill the array with arbitrary values\n",
        "\n",
        "These create arrays of the given size, filled with zeros, ones, or arbitrary values, depending on your specific needs. Great for initializing an array to store important data in later!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xj08PatOw0Yz"
      },
      "outputs": [],
      "source": [
        "data = np.zeros(10)\n",
        "print(data)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "h9_sUv6iw0Yz"
      },
      "source": [
        "<a name='indexing'></a>\n",
        "We can also assign new values to elements of existing arrays, using the following \"square bracket\" notation. This is the same as the list indexing we taught you in Lecture #1!\n",
        "> `array_name[index_number] = value`\n",
        "\n",
        "This command will replace whatever value is currently in the position corresponding to ``index_number`` in the array called ``array_name`` with the value stored in ``value``.\n",
        "\n",
        "Recall that arrays are numbered starting from 0, such that\n",
        "\n",
        "* Index of first position = 0\n",
        "* Index of second position = 1\n",
        "* Index of third position = 2\n",
        "* etc.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xmMeeKOzw0Yz"
      },
      "outputs": [],
      "source": [
        "data[0] = 2\n",
        "print(data[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SFN325_pw0Yz"
      },
      "source": [
        "**Negative indexing** is the same as normal indexing, but backward, in the sense that you start with the last element of the array and count forward.  More explicitly, for any array:\n",
        "\n",
        "* array[-1] = last element of array\n",
        "* array[-2] = second to last element of the array\n",
        "* array[-3] = third to last element of the array\n",
        "* etc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ykJvqGYki-60"
      },
      "source": [
        "<a name='neg_ex'></a>\n",
        "### **Exercise 1**: Negative Indexing\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s83A7lKmkaDu"
      },
      "source": [
        "Create an array with 10 elements using `np.arange()` and print out the last and second-to-last elements using negative indexing!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nHDQLDKpw0Yz"
      },
      "outputs": [],
      "source": [
        "#Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oT7kzVoTw0Yz"
      },
      "source": [
        "Sometimes it's useful to access more than one element of an array. Let's say that we have an array spanning the range [0,10] (including endpoints), with a step size of 0.1. If you recall, this can be done via the `np.linspace()` or `np.arange()` functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IhK6eu2bw0Yz"
      },
      "source": [
        "<a name='slicing'></a>\n",
        "In order to get a range of elements in an array, rather than simply a single one, use **array slicing**:\n",
        "\n",
        "* `array_name[start_index:end_index]` To grab all of the values from `start_index` to `end_index - 1`\n",
        "* `array_name[:end_index]` To grab all of the values up to `end_index-1`\n",
        "* `array_name[start_index:]` To grab all of the values from `start_index` and beyond\n",
        "\n",
        "In this notation, \":\" means you want everything between your start and end indices, including the value to the left but excluding the value to the right."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gOG4eEu4l17Z"
      },
      "source": [
        "<a name='range_ex'></a>\n",
        "### **Exercise 2**: `np.linspace` and `np.arange`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V2Nr0LiHkmVz"
      },
      "source": [
        "Create an array named `x` of values from 0 to 10 (including 10) in steps of 0.1."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OPd_0Zffw0Yz",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "#Your code here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2kHmtmQ_G8wh"
      },
      "source": [
        "Once you're done above, **think** about what these slices should print, but don't run them yet! **Put your answers onto a piece of paper and then check your answers running the code.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "46plKnZtw0Yz"
      },
      "outputs": [],
      "source": [
        "x[1:4]\n",
        "\n",
        "x[90:]\n",
        "\n",
        "x[:25]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2YRR7FmdnZCk"
      },
      "source": [
        "<a name='slice_ex'></a>\n",
        "### **Exercise 3**: Indexing and slicing\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gkn9iwvQw0Yz"
      },
      "source": [
        "\n",
        "So, let's say that you would want everything up to and including the tenth element of the array $x$. How would you do that?\n",
        "\n",
        "(Remember, the tenth element has an index of 9)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OI0RRhV6w0Yz"
      },
      "outputs": [],
      "source": [
        "#Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tm6NGKp5w0Y0"
      },
      "source": [
        "Now try to select just the first half of the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GB0GmxO-w0Y0"
      },
      "outputs": [],
      "source": [
        "#Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cN6BSHqpw0Y0"
      },
      "source": [
        "Then, pick out middle sixty elements of the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bir2j1ztw0Y0"
      },
      "outputs": [],
      "source": [
        "#Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nd8BK-OwptIp"
      },
      "source": [
        "Let's try a few more. In the next block of code, perform the following actions on different lines:\n",
        "\n",
        "* Access all elements of your `x` up to, but not including the 17th element\n",
        "* Access the last 20 elements of `x`\n",
        "* Create a new array named `y` that contains the 12th through 38th elements of `x`, including the 38th element\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "p1eH9J4np94W"
      },
      "outputs": [],
      "source": [
        "#Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zuFluWa6w0Y0"
      },
      "source": [
        "Finally, how would you get all of the elements in the array using colon notation?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S-aNw-Miw0Y0"
      },
      "outputs": [],
      "source": [
        "#Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "<a name='df'></a>\n",
        "## B. Introduction to Padas Dataframes"
      ],
      "metadata": {
        "id": "dvp_tqy0nGtG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A [Pandas](https://pandas.pydata.org) DataFrame is a 2 dimensional data structure, like a 2 dimensional array, or a table with rows and columns.\n",
        "\n",
        "![finallpandas.png](data:image/png;base64,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)\n",
        "\n",
        "[Source](https://media.geeksforgeeks.org/wp-content/uploads/finallpandas.png)"
      ],
      "metadata": {
        "id": "FjFrYbPKGPdL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the pandas lib\n",
        "import pandas as pd"
      ],
      "metadata": {
        "id": "UBAGM_FpnGCU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Series"
      ],
      "metadata": {
        "id": "cbM9HeTkquzg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "[`Series`](https://pandas.pydata.org/docs/reference/api/pandas.Series.html#pandas.Series) is a one-dimensional labeled array capable of holding any data\n",
        "type (integers, strings, floating point numbers, Python objects, etc.). The axis\n",
        "labels are collectively referred to as the **index**. The basic method to create a [`Series`](https://pandas.pydata.org/docs/reference/api/pandas.Series.html#pandas.Series) is to call:\n",
        "\n",
        "> `s = pd.Series(data, index=index)`\n",
        "\n",
        "Here, data can be many different things:\n",
        "\n",
        "- a Python dict\n",
        "- an ndarray\n",
        "- a scalar value (like 5)\n",
        "\n",
        "The passed index is a list of axis labels. Thus, this separates into a few cases depending on what data is:"
      ],
      "metadata": {
        "id": "0LGpxkZ8pl3y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### From dict"
      ],
      "metadata": {
        "id": "dtcg1Edfq3hj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a dict of values\n",
        "d = {\"b\": 1, \"a\": 0, \"c\": 2}"
      ],
      "metadata": {
        "id": "hesBWSLvq2xK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# create a pandas Series from dict\n",
        "pd.Series(d)"
      ],
      "metadata": {
        "id": "PxVWmZPQo2Po"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If an index is passed, the values in data corresponding to the labels in the index will be pulled out."
      ],
      "metadata": {
        "id": "cfu0aKRJrO8U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = {\"a\": 0.0, \"b\": 1.0, \"c\": 2.0}\n",
        "pd.Series(d, index=[\"b\", \"c\", \"d\", \"a\"])"
      ],
      "metadata": {
        "id": "92cB3Ph-o2SZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "NaN (not a number) is the standard missing data marker used in pandas."
      ],
      "metadata": {
        "id": "DyjMa2IurYQF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### From ndarray"
      ],
      "metadata": {
        "id": "41o6We9trb8z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If `data` is an ndarray, index must be the same length as data. If no index is passed, one will be created having values `[0, ..., len(data) - 1]`."
      ],
      "metadata": {
        "id": "XvKFwDJjriH6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = pd.Series(np.random.randn(5))\n",
        "s"
      ],
      "metadata": {
        "id": "X3kqLjzOruNV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s = pd.Series(np.random.randn(5), index=[\"a\", \"b\", \"c\", \"d\", \"e\"])\n",
        "s"
      ],
      "metadata": {
        "id": "B09QAeqXrZSZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### From scalar value"
      ],
      "metadata": {
        "id": "uthVPZlWr5Nz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If `data` is a scalar value, an index must be provided. The value will be repeated to match the length of **index**."
      ],
      "metadata": {
        "id": "iokgZeeMr9_6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "v = pd.Series(5.0, index=[\"a\", \"b\", \"c\", \"d\", \"e\"])\n",
        "v"
      ],
      "metadata": {
        "id": "gZXMtMSYr7q8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Series is ndarray-like"
      ],
      "metadata": {
        "id": "ZfQfjkX3sJya"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`Series` acts very similarly to a `ndarray` and is a valid argument to most NumPy functions. However, **operations such as slicing will also slice the index**.\n"
      ],
      "metadata": {
        "id": "haSE8nm1sUfU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = pd.Series(np.random.randn(5))\n",
        "s"
      ],
      "metadata": {
        "id": "UyAxRLG2sppT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s[0]"
      ],
      "metadata": {
        "id": "8r0nimiIsPom"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s[:3]"
      ],
      "metadata": {
        "id": "kszCnwJMswg6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s[s > s.median()]"
      ],
      "metadata": {
        "id": "Lb1aDKees7aj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# yield error\n",
        "s[4,3,2]"
      ],
      "metadata": {
        "id": "twcUa32ttFTx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Why?"
      ],
      "metadata": {
        "id": "VWQ-pcg-QJo3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# right way to slice specific sub-set of values based on indexes\n",
        "s_subset = s[[4, 3, 1]]\n",
        "s_subset"
      ],
      "metadata": {
        "id": "CwqekxXrs7eL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(s_subset)"
      ],
      "metadata": {
        "id": "ObHCfL8lu_qC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.exp(s)"
      ],
      "metadata": {
        "id": "McAgHGDXtYSn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "While `Series` is ndarray-like, if you need an actual `ndarray`, then use `Series.to_numpy()`."
      ],
      "metadata": {
        "id": "TMCSbugStsWM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s.to_numpy()"
      ],
      "metadata": {
        "id": "jX1a9rvDtq5k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Series is dict-like"
      ],
      "metadata": {
        "id": "BtawZ1STt8mL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A `Series` is also like a fixed-size dict in that you can get and set values by index label:"
      ],
      "metadata": {
        "id": "fd7OvhIsuFuQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = pd.Series(np.random.randn(5), index = [\"a\", \"b\", \"c\", \"d\", \"e\"])\n",
        "s"
      ],
      "metadata": {
        "id": "xQhQAR3vuCpT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s[\"a\"]"
      ],
      "metadata": {
        "id": "iMGMjtSJuCrn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s[\"e\"] = 12.0\n",
        "s"
      ],
      "metadata": {
        "id": "h6JLwdb9uUgI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"e\" in s"
      ],
      "metadata": {
        "id": "XtFcsxd0uXC1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"f\" in s"
      ],
      "metadata": {
        "id": "9TYf1alFvZwZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# If a label is not contained in the index, an exception is raised:\n",
        "s[\"f\"]"
      ],
      "metadata": {
        "id": "HzxmeNdsvdhB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## DataFrame"
      ],
      "metadata": {
        "id": "7-1fPiulvu3t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "[`DataFrame`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html#pandas.DataFrame) is a 2-dimensional labeled data structure with columns of potentially different types. You can think of it like a spreadsheet or a dict of Series objects. It is generally the most commonly used pandas object.\n",
        "\n",
        "Along with the data, you can optionally pass index (row labels) and columns (column labels) arguments. If you pass an index and / or columns, you are guaranteeing the index and / or columns of the resulting DataFrame. Thus, a dict of Series plus a specific index will discard all data not matching up to the passed index."
      ],
      "metadata": {
        "id": "EvioldnXwyvi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Object creation\n"
      ],
      "metadata": {
        "id": "XTlq1vxizj94"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### From dict of Series or dicts"
      ],
      "metadata": {
        "id": "0Q39wrXQxNIF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = {\n",
        "    \"one\": pd.Series([1.0, 2.0, 3.0], index=[\"a\", \"b\", \"c\"]),\n",
        "    \"two\": pd.Series([1.0, 2.0, 3.0, 4.0], index=[\"a\", \"b\", \"c\", \"d\"]),\n",
        "}"
      ],
      "metadata": {
        "id": "xccNq-RtvuJE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df = pd.DataFrame(d)\n",
        "df"
      ],
      "metadata": {
        "id": "myLSNE2zxSQI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### From dict of ndarrays / lists"
      ],
      "metadata": {
        "id": "UtB5Konfy7zE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The ndarrays must all be the same length. If an index is passed, it must also be the same length as the arrays. If no index is passed, the result will be `range(n)`, where n is the array length."
      ],
      "metadata": {
        "id": "4AGVBRak0fSP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = {\"one\": [1.0, 2.0, 3.0, 4.0], \"two\": [4.0, 3.0, 2.0, 1.0]}\n",
        "d"
      ],
      "metadata": {
        "id": "rayRpsuXzOgi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.DataFrame(d)"
      ],
      "metadata": {
        "id": "43QcB04z0nK_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### From dict of Objects"
      ],
      "metadata": {
        "id": "-QFQlN9A1Ych"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df2 = pd.DataFrame(\n",
        "    {\n",
        "        \"A\": 1.0,\n",
        "        \"B\": pd.Timestamp(\"20130102\"),\n",
        "        \"C\": pd.Series(1, index=list(range(4)), dtype=\"float32\"),\n",
        "        \"D\": np.array([3] * 4, dtype=\"int32\"),\n",
        "        \"E\": pd.Categorical([\"test\", \"train\", \"test\", \"train\"]),\n",
        "        \"F\": \"foo\",\n",
        "    }\n",
        ")\n",
        "df2"
      ],
      "metadata": {
        "id": "RkaYOKWt0nNT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df2.dtypes"
      ],
      "metadata": {
        "id": "BCjHrAlu1gIo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Viewing data"
      ],
      "metadata": {
        "id": "ESGt7q_Rzpsb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use `DataFrame.head()` and `DataFrame.tail()` to view the top and bottom rows of the frame respectively:"
      ],
      "metadata": {
        "id": "DnVGCQ-01rbx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "indexes = np.arange(0,20)\n",
        "df = pd.DataFrame(np.random.randn(20, 4), index=indexes, columns=list(\"ABCD\"))\n",
        "df"
      ],
      "metadata": {
        "id": "Hj998PvS11la"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# view few records from top\n",
        "df.head()"
      ],
      "metadata": {
        "id": "a5j88D5WzpGb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# view few records from bottom\n",
        "df.tail()"
      ],
      "metadata": {
        "id": "fwVKL7u22S9A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "`DataFrame.to_numpy()` gives a NumPy representation of the underlying data."
      ],
      "metadata": {
        "id": "Bh1dV3HJ2xDb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# gives 2D np array\n",
        "df.to_numpy()"
      ],
      "metadata": {
        "id": "GRhZ5jfM2wfk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Selection"
      ],
      "metadata": {
        "id": "SMTZX-9ZzxI8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "See the indexing documentation [`Indexing and Selecting Data`](https://pandas.pydata.org/docs/user_guide/indexing.html#indexing) and [`MultiIndex / Advanced Indexing`](https://pandas.pydata.org/docs/user_guide/advanced.html#advanced)."
      ],
      "metadata": {
        "id": "miyvC_L53V4h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "indexes = np.arange(0,20)\n",
        "df = pd.DataFrame(np.random.randn(20, 4), index=indexes, columns=list(\"ABCD\"))\n",
        "df"
      ],
      "metadata": {
        "id": "d_CNwdhpD73W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting"
      ],
      "metadata": {
        "id": "7dsQjdPozN-g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Selecting a single column, which yields a `Series`, equivalent to `df.A`:"
      ],
      "metadata": {
        "id": "FkqON-0P4F5K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df[\"A\"]"
      ],
      "metadata": {
        "id": "hbuInCrs4JYV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Selecting via `[]` (`__getitem__`), which slices the rows:"
      ],
      "metadata": {
        "id": "7ltXX5QI4Wnb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df[1:4]"
      ],
      "metadata": {
        "id": "CHXjhmA94P0_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Selection by label\n"
      ],
      "metadata": {
        "id": "I_phXK4IzUR_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "See more in [Selection by Label](https://pandas.pydata.org/docs/user_guide/indexing.html#indexing-label) using `DataFrame.loc()` or `DataFrame.at()`."
      ],
      "metadata": {
        "id": "jmyh0sMs4xvb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.loc[[2]]"
      ],
      "metadata": {
        "id": "oOrh5xKD5A1i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.loc[1:5, [\"A\", \"B\"]]"
      ],
      "metadata": {
        "id": "m4pr010j5A4x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.loc[2, [\"A\", \"B\"]]"
      ],
      "metadata": {
        "id": "kf_KHxo65QSI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###  Boolean indexing\n",
        "> `df[df['col'] == value]`"
      ],
      "metadata": {
        "id": "8EwEkoidD_cG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Selecting subset of dataframe where colum *A* is greater than 0.*italicised text*"
      ],
      "metadata": {
        "id": "BdY3XDHCERYF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df[df[\"A\"] > 0]"
      ],
      "metadata": {
        "id": "25afVzpQDssx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Selecting subset of dataframe where colum *A* is greater than 0 and then getting only colums *B* and *D*."
      ],
      "metadata": {
        "id": "FhaZWa4jEqH9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df[df[\"A\"] > 0].loc[:,[\"B\", \"D\"]]"
      ],
      "metadata": {
        "id": "UbV6fPqGEa5R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Selection by position"
      ],
      "metadata": {
        "id": "mOLNxbwY34bX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "See more in [Selection by Position](https://pandas.pydata.org/docs/user_guide/indexing.html#indexing-integer) using `DataFrame.iloc()` or `DataFrame.at()`."
      ],
      "metadata": {
        "id": "9vFPHIKU5fKo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.iloc[3:5, 0:2]"
      ],
      "metadata": {
        "id": "vCBiXXOy5m96"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.iloc[[1, 2, 5], [0, 2]]"
      ],
      "metadata": {
        "id": "PsVJfN8z5nK3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df.iloc[1:3, :]"
      ],
      "metadata": {
        "id": "GmGXXFqo5nOE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "More in [**10 minutes to pandas**](https://pandas.pydata.org/docs/user_guide/10min.html) :)"
      ],
      "metadata": {
        "id": "wTfRK2Um6EAc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Excercise 1**:"
      ],
      "metadata": {
        "id": "spGgcIvQ6eU8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   Create an 20-elements *values* array filled with integer values from 0 to 20.\n",
        "*   Create a dataframe with column names *values*, *sqrt*, *square*. Ech column fill with array *values* transformed in a way that corresponds to column name (i.e. column named 'sqrt' should contain square roots of the elements of the *values* array).\n",
        "*   Add a column named *is_even* which mark whether value in column *values* is even or odd.\n",
        "\n"
      ],
      "metadata": {
        "id": "PJxSWM776n0J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Your code goes here"
      ],
      "metadata": {
        "id": "bA_GpNJq9AoP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Excercise 2:"
      ],
      "metadata": {
        "id": "rxgJTak49UzD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "From created dataframe:\n",
        "*   select column *square* and values that are larger than 5.\n",
        "*   then select items where colum *ID* equals *even* ...\n",
        "*   ... and calculate mean of selected values.\n",
        "\n"
      ],
      "metadata": {
        "id": "SDHi7dO29ZIO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Your code goes here"
      ],
      "metadata": {
        "id": "zF6jAfBYBttY"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "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.8.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}