Ex_1_solved.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lK2_p0zu4aQl"
      },
      "source": [
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Humboldt-WI/bads/blob/master/exercises/1_ex_python.ipynb) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRxqDuyH4aQq"
      },
      "source": [
        "# BADS Exercise 1 on Python programming\n",
        "We covered a lot of concepts in the first [tutorial on Python programming](https://github.com/Humboldt-WI/bads/blob/master/tutorials/1_nb_python_intro.ipynb). Solving the exercises allows you to test your familiarity with these concepts.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j3uPOrQP4aQr"
      },
      "source": [
        "## Variables, assignments, and comparisons"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eXWTIsaL4aQr"
      },
      "source": [
        "1. Create two variables $a$ and $b$ and assign values of $3$ and $4.5$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "H40Koua94aQs"
      },
      "outputs": [],
      "source": [
        "a = 3\n",
        "b = 4.5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lAhGgPUc4aQt"
      },
      "source": [
        "2. Query the type of variable $a$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "DOZR7vee4aQt",
        "outputId": "1fc81f70-0fbd-4000-942b-7a39d7990e0f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "type(a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XHBy6gZR4aQu"
      },
      "source": [
        "3. Check whether variable $b$ is a text variable."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "jMtWtfPM4aQu",
        "outputId": "5fe79974-cb7e-4997-97f8-3131ca8d6bcf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "type(b) == str"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xkcpi0hX4aQu"
      },
      "source": [
        "4. Calculate $a^2 + \\frac{1}{b}$, $\\sqrt{a*b}$, and $log_2(a)$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "STtysG2y4aQv",
        "outputId": "907fdb0a-9413-4636-ccda-933fdcffb337",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9.222222222222221"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "a**2 + 1/b"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math \n",
        "math.sqrt(a*b)"
      ],
      "metadata": {
        "id": "z_Z9mm1Y62GV",
        "outputId": "b37b73ab-83ca-45e5-d659-2ef8e398b475",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.6742346141747673"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "math.log2(a)"
      ],
      "metadata": {
        "id": "4RADlI-a62TQ",
        "outputId": "1a338bd1-15c9-4754-a987-87a87cb59ff0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.584962500721156"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IjSf_d8l4aQv"
      },
      "source": [
        "## Matrix algebra\n",
        "Create three additional variables as follows:\n",
        "\n",
        " $$ A = \\left( \\begin{matrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 10 \\end{matrix} \\right) \\quad\n",
        "  B = \\left( \\begin{matrix} 1 & 4 & 7 \\\\ 2 & 5 & 8 \\\\ 3 & 6 & 9 \\end{matrix} \\right)  \\quad\n",
        "  y = \\left( \\begin{matrix} 1 \\\\ 2 \\\\ 3 \\end{matrix} \\right) $$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "cB0n1elP4aQv"
      },
      "outputs": [],
      "source": [
        "# Code to create variables A, B, and y\n",
        "import numpy as np\n",
        "A = np.array(([1, 2, 3], \n",
        "              [4, 5, 6], \n",
        "              [7, 8, 10]))\n",
        "B = np.array(([1, 4, 7], \n",
        "              [2, 5, 8], \n",
        "              [3, 6, 9]))\n",
        "y = np.transpose(np.array([1,2,3]))     \n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(A)\n",
        "print(B)\n",
        "print(y)"
      ],
      "metadata": {
        "id": "0P1vKIf_9AXl",
        "outputId": "b74af7ef-ca91-4b93-da48-47d93e84a2c4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8 10]]\n",
            "[[1 4 7]\n",
            " [2 5 8]\n",
            " [3 6 9]]\n",
            "[1 2 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LD-djbEp4aQw"
      },
      "source": [
        "Perform the following operations. Note that mathematical operators like `*` might not behave in the way you need it. Wasn't there a powerful library for all sorts of numerical computations including classic linear algebra?\n",
        "\n",
        "Calculate  \n",
        "\n",
        "  1. $a*A$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "iOO-euQ-4aQx",
        "outputId": "a3b0252f-8e21-4375-afdf-075c1a56b41d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 3,  6,  9],\n",
              "       [12, 15, 18],\n",
              "       [21, 24, 30]])"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ],
      "source": [
        "a * A"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9cm-5-k44aQx"
      },
      "source": [
        "  2. $A*B$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "KnD5S6Is4aQy",
        "outputId": "4d8176f6-4ba0-4e24-c915-62c10faa41eb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 14,  32,  50],\n",
              "       [ 32,  77, 122],\n",
              "       [ 53, 128, 203]])"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ],
      "source": [
        "np.matmul(A,B)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q3In6tDa4aQy"
      },
      "source": [
        "  3. The inverse of matrix $A$ and store the result in a variable $invA$. Any ideas how to get Python to invert a matrix? Hint: NumPy is your friend.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "qfheNrSv4aQy",
        "outputId": "69dfad90-50b6-4e79-b41a-df05cc9cba8c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8 10]]\n"
          ]
        }
      ],
      "source": [
        "print(A)\n",
        "\n",
        "invA = np.linalg.inv(A)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jz-Yzn3b4aQz"
      },
      "source": [
        "  4. Multiply $A$ and $invA$ and verify that the result is the identity matrix (i.e. only 1s on the diagonal). You'll probably find that it isn't, because computers usually make very small rounding error when handling real numbers. The reason is interesting, but you'll have to look it up if you're interested."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "5euqvMuf4aQz",
        "outputId": "1f98c5b6-1de5-4527-a640-313518dc3b16",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.00000000e+00, 0.00000000e+00, 1.11022302e-16],\n",
              "       [0.00000000e+00, 1.00000000e+00, 2.22044605e-16],\n",
              "       [8.88178420e-16, 0.00000000e+00, 1.00000000e+00]])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ],
      "source": [
        "np.matmul(A,invA)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQv9t1xB4aQz"
      },
      "source": [
        "  5. The transpose of matrix $B$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "NZxOmjCX4aQ0",
        "outputId": "9fe0b967-995a-4ac2-9996-8cf8c9cf1cdc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ],
      "source": [
        "np.transpose(B)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q7HAUjUZ4aQ0"
      },
      "source": [
        "  6. Fill the first row of matrix $B$ with ones"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "_og9cYRE4aQ1",
        "outputId": "827fc9f5-cdd6-4419-d1bb-0180dc5d728e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 1 1]\n",
            " [2 5 8]\n",
            " [3 6 9]]\n"
          ]
        }
      ],
      "source": [
        "B[0,:] = np.ones(3)\n",
        "print(B)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xxTMgymq4aQ1"
      },
      "source": [
        "  7. Calculate the ordinary least squares estimator $\\beta$ (i.e. a standard regression) \n",
        "$$ \\beta = (A^{\\top}A)^{-1}A^{\\top} y $$ Run a web search for \"Python matrix transpose\" to get help on how to transpose a matrix. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "DJ3rdU_k4aQ1",
        "outputId": "c913aafb-5e73-432f-ba34-c272a11a3199",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-3.33333333e-01  6.66666667e-01 -5.68434189e-14]\n"
          ]
        }
      ],
      "source": [
        "A_transpose = np.transpose(A)\n",
        "first = np.matmul(A_transpose, A)\n",
        "second = np.linalg.inv(first)\n",
        "third = np.matmul(A_transpose,y)\n",
        "beta = np.matmul(second,third)\n",
        "print(beta)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ufre1N34aQ1"
      },
      "source": [
        "## Indexing\n",
        "1. Look at values of variables $A$, $B$, and $y$ from the last exercise"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "GteEmfEL4aQ2",
        "outputId": "b4658dba-4f44-405a-e01b-4cbe8fdb3707",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8 10]]\n",
            " \n",
            "[[1 1 1]\n",
            " [2 5 8]\n",
            " [3 6 9]]\n",
            " \n",
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "print(A)\n",
        "print(\" \")\n",
        "print(B)\n",
        "print(\" \")\n",
        "print(y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZD2BCdnT4aQ2"
      },
      "source": [
        "2. Access the second element in the third row of $A$ and the first element in the second row of $B$, and compute their product"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "GLoemv6u4aQ2",
        "outputId": "0e580ef6-7dcf-4ca3-eac0-522421e63b60",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ],
      "source": [
        "A[2,1]*B[1,0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_QuqixFQ4aQ3"
      },
      "source": [
        "3. Multiply the first row of $A$ and the third column of $B$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "oH9FOtJ24aQ4",
        "outputId": "aaaa9220-50ea-4e0f-9067-c3140bd5a034",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "44"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ],
      "source": [
        "np.matmul(A[0,:],B[:,2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o3IvBbUb4aQ4"
      },
      "source": [
        "4. Access the elements of y that are greater than 1 (without looking up their position manually)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "GYxk4MXJ4aQ7",
        "outputId": "a5abb74a-d4d2-43f3-928c-8e381d2bdb22",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ],
      "source": [
        "y[y>1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0HjmJYco4aQ7"
      },
      "source": [
        "5. Access the elements of A in the second column, for which the values in the first column are greater or equal to 4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "Vfo1VJfU4aQ8",
        "outputId": "665c905a-f96e-4b33-8078-828510f55ce4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ],
      "source": [
        "second_column = A[:,1]\n",
        "second_column[second_column>=4]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-jrYidUR4aQ8"
      },
      "source": [
        "6. Access the 4th row of A. If this returns an error message, use Google to investigate the problem and find out what went wrong."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "AO9gAZzV4aQ9",
        "outputId": "0a724a69-93eb-41f0-df36-b325140fb0b2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        }
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-49-1dcf9dabcc1e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\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[0m",
            "\u001b[0;31mIndexError\u001b[0m: index 3 is out of bounds for axis 0 with size 3"
          ]
        }
      ],
      "source": [
        "A[3,:] #there are no 4th row"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d235wHnp4aQ9"
      },
      "source": [
        "## Custom functions\n",
        "For many statistical applications it is practical to standardize variable values. One way to standardize is *centering and scaling*. In simple words, we make the variables comparable by reducing them to the same scale.\n",
        "\n",
        "Start with implementing a custom function. Your function should take an argument **x**. To keep things simple, we expect x to always be a numeric vector (and not text or a matrix, for example). In the body of the function, calculate the mean and standard deviation of **x**. Store the results in variables  **mu** and **std**, respectively. Then for each element in the vector, substract the mean and divide by the standard deviation.\n",
        "$$ x_{new} = \\frac{x-\\mu}{std}$$\n",
        "Make sure your functions **returns** the standardized vector (i.e., $x_new$ in the equation) as result. You might want to import `NumPy` for calculating the mean and standard deviation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "ecNUiI_m4aQ-",
        "outputId": "e5bd70b7-9da2-45d1-cd82-521a2b442107",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "numpy.ndarray"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ],
      "source": [
        "x = np.array([-100,-25,-10,0,10,25,100])\n",
        "def function_x(x):\n",
        "  mu = np.mean(x)\n",
        "  std = np.std(x)\n",
        "  x_new = (x - mu)/std\n",
        "  return(x_new)\n",
        "\n",
        "function_x(x)\n",
        "type(x)\n",
        "type(b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B56Wg57g4aQ-"
      },
      "source": [
        "You should always test your functions. Create a vector **a** with the elements (-100, -25, -10, 0, 10, 25, 100) and check if your function produces the correct result.     "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yVSjzj3z4aQ_"
      },
      "source": [
        "*Optional*: Create a vector **b** with elements (\"1\", \"2\", \"3\") and check the function. Let's include a simple check in the function and give feedback. Before doing any calculations, use `if()` and `type()` to check if the input is a numeric vector. There are many ways to code the condition *x is numeric* in Python. Run a quick web search and use a simple approach. If the input is not numeric, skip the computations and print a message \"input not numeric\"."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "vpdymzeG4aQ_",
        "outputId": "c465cdcb-859c-431e-f414-eda57f40a16a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input not numeric. Received array of type: <U1\n"
          ]
        }
      ],
      "source": [
        "b = np.array([\"1\",\"2\",\"3\"])\n",
        "\n",
        "def function_x(x):\n",
        "\n",
        "  if not np.issubdtype(x.dtype, np.number): \n",
        "      print('Input not numeric. Received array of type:', x.dtype)\n",
        "      return\n",
        "\n",
        "  mu = np.mean(x)\n",
        "  std = np.std(x)\n",
        "  x_new = (x - mu)/std\n",
        "  return(x_new)\n",
        "\n",
        "function_x(b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O5tOOI8y4aQ_"
      },
      "source": [
        "## Data structures \n",
        "Say you want to keep track of the members of the four houses of the famous Hogwarts School of Witchcraft and Wizardry. What might be a suitable data structure? We create a dictionary named **hogwarts** and use the names of the houses as keys. Then, the values associated with those keys could be any type that supports storing a set of strings, i.e., to store the names of house members. Draw on your knowledge of Python dictionaries and lists to implement such a data structure. Populate the dictionary with the following data, and feel free to add more characters if you wish. \n",
        "\n",
        "- Gryffindor: I'm sure you know many members of that house \n",
        "- Hufflepuff: notable members include Newt Scamander, Cedric Diggory and Nymphadora Tonks\n",
        "- Ravenclaw: here we've got, e.g. Luna Lovegood, Gilderoy Lockhart and Filius Flitwick\n",
        "- Slytherin: Draco Malfoy, Vincent Crabbe, Gregory Goyle, and of course the one that must not be named"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "znaTv4004aQ_",
        "outputId": "d27ff40b-fe3c-48a0-bcf6-b5e7c1c95067",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Gryffindor': ['Harry Potter', 'Ron Weasley', 'Hermione Granger'],\n",
              " 'Hufflepuff': ['Newt Scamander', 'Cedric Diggory', 'Nymphadora Tonks'],\n",
              " 'Ravenclaw': ['Luna Lovegood', 'Gilderoy Lockhart', 'Filius Flitwick'],\n",
              " 'Slytherin': ['Draco Malfoy',\n",
              "  'Vincent Crabbe',\n",
              "  'Gregory Goyle',\n",
              "  'Tom Riddle']}"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ],
      "source": [
        "hogwarts = {'Gryffindor': ['Harry Potter', 'Ron Weasley', 'Hermione Granger'],\n",
        "            'Hufflepuff': ['Newt Scamander', 'Cedric Diggory', 'Nymphadora Tonks'],\n",
        "            'Ravenclaw':  ['Luna Lovegood', 'Gilderoy Lockhart', 'Filius Flitwick'],\n",
        "            'Slytherin':  ['Draco Malfoy', 'Vincent Crabbe', 'Gregory Goyle', 'Tom Riddle']\n",
        "            }\n",
        "hogwarts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vs_CVHF-4aRA"
      },
      "source": [
        "Dictionaries are really useful. Still our above data structure is limited. We can only store the name of a witch or wizard. Wouldn't it be cool to be able to store more information, something like her/his favored charm, best friend, pet, etc. \n",
        "\n",
        "Think about how we could realize this functionality. Well, we could create yet another dictionary in which we use a witches's/wizard's name as key and as value some some other data structure in which we can store all the details we like. To our knowledge, the names of witches / wizards are unique in the Harry Potter universe, so that names could serve as (unique) keys; nerd alert. Still a dictionary of dictionaries sounds pretty complicated. In fact, the task we described above is a perfect use case for a custom class. Custom classes  allow us to store any piece of information about a person at one place. Furthermore, they would allow us to implement functions that process this information. So here is your next task:\n",
        "\n",
        "Create a custom class wizard that facilitates storing the following properties\n",
        "- First name\n",
        "- Last name\n",
        "- Pet\n",
        "- Pet name\n",
        "- Patronus shape\n",
        "\n",
        "\n",
        "Also implement a method `tell_pet()`that prints an output of the following format:\n",
        "*\"Harry Potter's owl is called Hedwig.\"* <br> Note how the output makes use of information on the first and last name of the wizard and other pieces of information.\n",
        "\n",
        "Implement one more  method `expecto_patronum()`. Calling that method for Harry would produce the output (print):\n",
        "*\"A stag appears.\"*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "id": "EpIIlV7r4aRA"
      },
      "outputs": [],
      "source": [
        "class wizard():\n",
        "\n",
        "\n",
        "    def __init__(self,        \n",
        "                 first_name,             \n",
        "                 last_name,\n",
        "                 pet            = None,\n",
        "                 pet_name       = None,\n",
        "                 patronus_shape = None): # first and last name have to be specifed; pet and patronus data is set to None by default \n",
        "\n",
        "        # assign attributes\n",
        "        self.first_name     = first_name \n",
        "        self.last_name      = last_name \n",
        "        self.pet            = pet \n",
        "        self.pet_name       = pet_name \n",
        "        self.patronus_shape = patronus_shape \n",
        "\n",
        "        \n",
        "    def tell_pet(self): \n",
        "\n",
        "        '''Method for printing the pet information'''\n",
        "\n",
        "        # there are several ways to print the required statement\n",
        "        # one way is to use the so-called f strings; we will use .format() syntax\n",
        "        print('{} {}\\'s {} is called {}.'.format(self.first_name, self.last_name, self.pet, self.pet_name))\n",
        "        return None\n",
        "\n",
        "\n",
        "    def expecto_patronum(self): \n",
        "\n",
        "        '''Method for summoning a patronum'''\n",
        "\n",
        "        print('A {} appears.'.format(self.patronus_shape))\n",
        "        return None"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gg6MSL_q4aRA"
      },
      "source": [
        "Update your dictionary with schools and their members. Instead of storing a list of names as values, your new dictionary should store a list of instances of the class wizard. Note that you need to create these instances first. So you need to create an instance of class wizard for Harry, another one for Ron, Malfoy, etc. In case your knowledge of the Potter universe is a bit shaky, just invent the data you need. Just in case, [here is a little refresher of the expecto patronum spell](https://www.insider.com/harry-potter-characters-patronus-2018-11)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "id": "5ldWHHpw4aRB"
      },
      "outputs": [],
      "source": [
        "HarryPotter = wizard(first_name     = 'Harry',\n",
        "                     last_name      = 'Potter',\n",
        "                     pet            = 'owl',\n",
        "                     pet_name       = 'Hedwig',\n",
        "                     patronus_shape = 'stag')\n",
        "\n",
        "RonWeasly = wizard(first_name     = 'Ron',\n",
        "                   last_name      = 'Weasley',\n",
        "                   pet            = 'rat',\n",
        "                   pet_name       = 'Scabbers',\n",
        "                   patronus_shape = 'dog')\n",
        "\n",
        "HermioneGranger = wizard(first_name      = 'Hermione',\n",
        "                         last_name       = 'Granger',\n",
        "                         pet             = 'cat',\n",
        "                         pet_name        = 'Crookshanks',\n",
        "                         patronus_shape  = 'otter')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llD_DmLn4aRB"
      },
      "source": [
        "## Well done!!!"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "PyCharm (adams)",
      "language": "python",
      "name": "pycharm-feb95198"
    },
    "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"
    },
    "colab": {
      "name": "1_ex_python.ipynb",
      "provenance": [],
      "toc_visible": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}