Introduction_to_Jupyter_Notebook_assignment.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    },
    "colab": {
      "name": "Introduction_to_Jupyter_Notebook assignment.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dmarinere/10academysolution/blob/master/Introduction_to_Jupyter_Notebook_assignment.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3KXUKa8fruOJ",
        "colab_type": "text"
      },
      "source": [
        "# GET STARTED WITH JUPYTER NOTEBOOK"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DWM4beMs1eKU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd\n",
        "import csv\n",
        "import numpy as np\n",
        "import sqlite3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oq4Me-9gruOL",
        "colab_type": "text"
      },
      "source": [
        "## LEARNING OBJECTIVES\n",
        "* WRITE AND TEST A PYTHON CODE\n",
        "* WHAT IS MARKDOWN?\n",
        "* FORMAT TEXT IN JUPYTER NOTEBOOK WITH MARKDOWN\n",
        "* SECTION HEADERS\n",
        "* LISTS\n",
        "* BOLD AND ITALICIZE\n",
        "* HIGHLIGHT CODE\n",
        "* HORIZONTAL LINES (RULES)\n",
        "* HYPERLINKS\n",
        "* RENDER IMAGES"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_ZHEi8tIruOM",
        "colab_type": "text"
      },
      "source": [
        "### Write and test a python code"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "whTNgTh8ruON",
        "colab_type": "text"
      },
      "source": [
        "In code cells, you can write Python code, then execute the Python code and see the resulting output. An example of a code cell is shown below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZDw8se5gruOO",
        "colab_type": "code",
        "colab": {},
        "outputId": "3f18ece4-cb7c-43c5-c96d-368aeb7ed3e3"
      },
      "source": [
        "a= 2\n",
        "b= 5\n",
        "c= a+b\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3tldfEYOruOX",
        "colab_type": "text"
      },
      "source": [
        "### What is Markdown?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-WXq0XlruOY",
        "colab_type": "text"
      },
      "source": [
        "`Markdown` is a human readable syntax (also referred to as a markup language) for formatting text documents. `Markdown` can be used to produce nicely formatted documents including PDFs and web pages.\n",
        "\n",
        "When you format text using Markdown in a document, it is similar to using the format tools (e.g. bold, heading 1, heading 2) in a word processing tool like Microsoft Word or Google Docs. However, instead of using buttons to apply formatting, you use syntax such as `**this syntax bolds text in markdown**` or `# Here is a heading`.\n",
        "\n",
        "Markdown syntax allows you to format text in many ways, such as making headings, bolding and italicizing words, creating bulleted lists, adding links, formatting mathematical symbols and making tables. These options allow you to format text in visually appealing and organized ways to present your ideas.\n",
        "\n",
        "You can use Markdown to format text in many different tools including GitHub.com, R using RMarkdown, and Jupyter Notebook, which you will learn more about this tutorial."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9JcaKsk_ruOZ",
        "colab_type": "text"
      },
      "source": [
        "### Markdown in Jupyter Notebook"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7M_u5ETTruOa",
        "colab_type": "text"
      },
      "source": [
        "A great benefit of `Jupyter Notebook` is that it allows you to combine both code (e.g. Python) and `Markdown` in one document, so that you can easily document your workflows.\n",
        "\n",
        "A `Jupyter Notebook` file uses cells to organize content, and it can contain both cells that render text written using the `Markdown` syntax as well as cells that contain and run `Python` code.\n",
        "\n",
        "Thus, you can use a combination of `Markdown` and `Python` code cells to organize and document your `Jupyter Notebook` for others to easily read and follow your workflow."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "39NVvL03ruOb",
        "colab_type": "text"
      },
      "source": [
        "### Benefits of Markdown for Data Science\n",
        "\n",
        "Being able to include both `Markdown` and code (e.g. Python) cells in a `Jupyter Notebook` file supports reproducible science by allowing you to:\n",
        "\n",
        "* Document your workflow: You can add text to the document that describes the steps of your processing workflow (e.g. how data is being processed and what results are produced).\n",
        "* Describe your data: You can describe the data that you are using (e.g. source, pre-processing, metadata).\n",
        "* Interpret code outputs: You can add some text that interprets or discusses the outputs.all in one document!\n",
        "\n",
        "When used effectively, Markdown documentation can help anyone who opens your Jupyter Notebook to follow, understand and even reproduce your workflow."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8dYonxuGruOc",
        "colab_type": "text"
      },
      "source": [
        "### Format Text in Jupyter Notebook with Markdown\n",
        "#### Markdown Cells in Jupyter Notebook\n",
        "The following describe how to add new `Markdown` cells to your `Jupyter Notebook` files using Menu tools and Keyboard Shortcuts to create new cells."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-jDH_e78ruOd",
        "colab_type": "text"
      },
      "source": [
        "Function|\tKeyboard Shortcut|\tMenu Tools\n",
        "--------|----------------|--------------|\n",
        "Create new cell|\tEsc + a (above), Esc + b (below)|\tInsert→ Insert Cell Above OR Insert → Insert Cell Below\n",
        "Copy Cell|\tc|\tCopy Key\n",
        "Paste Cell|\tv|\tPaste Key"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2oFoOBakruOe",
        "colab_type": "text"
      },
      "source": [
        "You can also change the default type of the cell by clicking in the cell and selecting a new cell type (e.g. Markdown) in the cell type menu in the toolbar. Furthermore, in a Jupyter Notebook file, you can double-click in any Markdown cell to see the syntax, and then run the cell again to see the Markdown formatting.\n",
        "\n",
        "In the following, you will learn basic Markdown syntax that you can use to format text in Jupyter Notebook files."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yhbTl7vCruOf",
        "colab_type": "text"
      },
      "source": [
        "### Section Headers\n",
        "You can create a heading using the pound (#) sign. For the headers to render properly, there must be a space between the # and the header text.\n",
        "\n",
        "Heading one is denoted using one # sign, heading two is denoted using two ## signs, etc, as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ENuBLak_ruOg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "## Heading Two\n",
        "\n",
        "### Heading Three\n",
        "\n",
        "#### Heading Four"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l1bzgioCruOm",
        "colab_type": "text"
      },
      "source": [
        "Here is a sample of the rendered Markdown:\n",
        "\n",
        "### Heading Three\n",
        "\n",
        "#### Heading Four"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oAKf9Hk_ruOm",
        "colab_type": "text"
      },
      "source": [
        "### Lists\n",
        "You can also use Markdown to create lists using the following syntax:\n",
        "\n",
        "* This is a bullet list\n",
        "* This is a bullet list\n",
        "* This is a bullet list\n",
        "\n",
        "\n",
        "1. And you can also create ordered lists\n",
        "2. by using numbers\n",
        "3. and listing new items in the lists \n",
        "4. on their own lines\n",
        "\n",
        "Notice that you have space between the `*` or `1`. and the text. The space triggers the action to create the list using `Markdown`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XINx9DpVruOn",
        "colab_type": "text"
      },
      "source": [
        "### Bold and Italicize\n",
        "You can also use `**` to bold or `*` to italicize words. To bold and italicize words, the symbols have to be touching the word and have to be repeated before and after the word using the following syntax:\n",
        "\n",
        "*These are italicized words, not a bullet list*\n",
        "**These are bold words, not a bullet list**\n",
        "\n",
        "* **This is a bullet item with bold words**\n",
        "* *This is a bullet item with italicized words*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KdTr-_oCruOq",
        "colab_type": "text"
      },
      "source": [
        "### Highlight Code\n",
        "If you want to highlight a function or some code within a plain text paragraph, you can use one backtick on each side of the text like this:\n",
        "\n",
        "`Here is some code!`\n",
        "\n",
        "The symbol used is the backtick, or grave; not an apostrophe (on most US keyboards, it is on the same key as the tilde (~))."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QCiiLr-CruOr",
        "colab_type": "text"
      },
      "source": [
        "### Horizontal Lines (Rules)\n",
        "You can also create a horizontal line or rule to highlight a block of `Markdown` syntax (similar to the highlighting a block of code using the backticks):\n",
        "\n",
        "***\n",
        "\n",
        "Here is some important text!\n",
        "\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RcOuIRfQruOs",
        "colab_type": "text"
      },
      "source": [
        "### Hyperlinks\n",
        "You can also use HTML in Markdown cells to create hyperlinks to websites using the following syntax:\n",
        "<a href=\"url\" target=\"_blank\">hyperlinked words</a> \n",
        "You can identify the words that will be hyperlinked (i.e. prompt a web page to open when clicked) by replacing hyperlinked words in the example above.\n",
        "For example, the following syntax:\n",
        "the `10academy` website can be found at <a href=\"https://www.10academy.org/\" target=\"_blank\">this link</a>.\n",
        "will render as follows with this link as the hyperlinked words"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qjuyl-Y9ruOt",
        "colab_type": "text"
      },
      "source": [
        "### Render Images\n",
        "You can also use `Markdown` to link to images on the web using the following syntax:\n",
        "![alt text here](url-to-image-here)\n",
        "The alt text is the alternative text that appears if an image fails to load on webpage; it is also used by screen-reading tools to identify the image to users of the screen-reading tools.\n",
        "For example, the following syntax will display the markdown image:\n",
        "![Markdown Logo is here.](https://www.fullstackpython.com/img/logos/markdown.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tc0EzdpDruOu",
        "colab_type": "text"
      },
      "source": [
        "### Local Images Using Relative Computer Paths\n",
        "You can also add images to a `Markdown` cell using relative paths to files in your directory structure using:\n",
        "![alt text here](path-to-image-here)\n",
        "For relative paths (images stored on your computer) to work in `Jupyter Notebook`, you need to place the image in a location on your computer that is RELATIVE to your `.ipynb file`. This is where good file management becomes extremely important.\n",
        "For a simple example of using relative paths, imagine that you have a subdirectory named images in your `jupyter_codes directory` `(i.e. jupyter_codes/images/)`.\n",
        "If your Jupyter Notebook file (.ipynb) is located in root of this directory `(i.e. jupyter_codes/notebook.ipynb)`, and all images that you want to include in your report are located in the images subdirectory `(i.e. jupyter_codes/images/)`, then the path that you would use for each image is:\n",
        "`images/image-name.png`\n",
        "If all of your images are in the images subdirectory, then you will be able to easily find them. This also follows good file management practices because all of the images that you use in your report are contained within your project directory."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_I3G7SeSruOv",
        "colab_type": "text"
      },
      "source": [
        "# Challenge "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WwO81-5nruOw",
        "colab_type": "text"
      },
      "source": [
        "#### Conditional statement: \n",
        "Write a Python program to sum of two given integers. However, if the sum is between 15 to 20 it will return 20."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sS7D1k4lruOw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Try here\n",
        "def addition(num1, num2):\n",
        "    num = num1 + num2\n",
        "    if sum in range(15, 20):\n",
        "        return 20\n",
        "    else:\n",
        "        return num"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4fW_BgKdruO1",
        "colab_type": "text"
      },
      "source": [
        "#### Function:\n",
        "Write a Python function to sum all the numbers in a list. Go to the editor\n",
        "Sample List : (8, 2, 3, 0, 7)\n",
        "Expected Output : 20"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZGAnSipWruO2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Try here\n",
        "# Try here\n",
        "def sumoflist(number):\n",
        "  num= 0\n",
        "  for numbers in number:\n",
        "    num += numbers\n",
        "  return num\n",
        "\n",
        "\n",
        "def listsum(number):\n",
        "  return sum(number)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EurIbqD7ruO6",
        "colab_type": "text"
      },
      "source": [
        "#### Lambda:\n",
        "Write a Python program to extract year, month, date and time using Lambda."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "45gTvbPtruO7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "4d62c377-e14a-4d19-d854-e93eac01cc71"
      },
      "source": [
        "# Try here\n",
        "import datetime\n",
        "today = datetime.datetime.today()\n",
        "year = lambda x: x.year\n",
        "month = lambda x: x.month\n",
        "day = lambda x: x.day\n",
        "time = lambda x: x.time()\n",
        "year(today)\n",
        "print(f\"Year: {year(today)} \\nMonth: {month(today)} \\nDay: {day(today)} \\nTime: {time(today)}\" )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-06-29 17:13:41.966975\n",
            "Year: 2020 \n",
            "Month: 6 \n",
            "Day: 29 \n",
            "Time: 17:13:41.966975\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSVyq2ILruPA",
        "colab_type": "text"
      },
      "source": [
        "#### SQLite Database\n",
        "Write a Python program to create a SQLite database and connect with the database and print the version of the SQLite database. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_bijI9K5ruPB",
        "colab_type": "text"
      },
      "source": [
        "Notes: \n",
        "* conda install -c blaze sqlite3 will install sqlite3 (do it in your anaconda prompt)   \n",
        "* Allows the use of a sqlite database: `import sqlite3` to use the module.\n",
        "* Connection to an existing database or to create:\n",
        "    * con = sqlite3.connect ('myFile.db') : create a connection.\n",
        "    * con.close () : close the connection.\n",
        "    * con.commit () : commits transactions.\n",
        "    * con.rollback () : rollback transactions.\n",
        "* Execution of orders:\n",
        "    * we create a cursor, we execute the order and we close the cursor:\n",
        "    * cur = con.cursor ()\n",
        "    * cur.execute ('create table myTable (x integer, y text)')\n",
        "    * cur.close ()\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p0pmxbsgJHNr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "844ed987-65f9-4d7a-c128-619b6a4dbc20"
      },
      "source": [
        "def create_connection():\n",
        "    \"\"\" create a database connection to a database that resides\n",
        "        in the memory\n",
        "    \"\"\"\n",
        "    conn = None;\n",
        "    try:\n",
        "        conn = sqlite3.connect(':memory:')\n",
        "        print(sqlite3.version)\n",
        "    except Error as e:\n",
        "        print(e)\n",
        "    finally:\n",
        "        if conn:\n",
        "            conn.close()\n",
        "create_connection()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.6.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "szongRUeruPH",
        "colab_type": "text"
      },
      "source": [
        "#### CSV read and write\n",
        "Write a Python program to read a given CSV file having tab delimiter."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vv0zOhPiruPH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 459
        },
        "outputId": "07a0041c-49d1-494f-9398-f62bd1caac9b"
      },
      "source": [
        "# Try here\n",
        "import csv\n",
        "with open('Countries.csv', 'r') as csvfile:\n",
        " data = csv.reader(csvfile)\n",
        " for row in data:\n",
        "   print(''.join(row))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "country_id|country_name|region_id\n",
            "AR|Argentina|2\n",
            "AU|Australia|3\n",
            "BE|Belgium|1\n",
            "BR|Brazil|2\n",
            "CA|Canada|2\n",
            "CH|Switzerland|1\n",
            "CN|China|3\n",
            "DE|Germany|1\n",
            "DK|Denmark|1\n",
            "EG|Egypt|4\n",
            "FR|France|1\n",
            "HK|HongKong|3\n",
            "IL|Israel|4\n",
            "IN|India|3\n",
            "IT|Italy|1\n",
            "JP|Japan|3\n",
            "KW|Kuwait|4\n",
            "MX|Mexico|2\n",
            "NG|Nigeria|4\n",
            "N|Netherlands|1\n",
            "SG|Singapore|3\n",
            "UK|United|Kingdom|1\n",
            "US|United|States|of|America|2\n",
            "ZM|Zambia|4\n",
            "ZW|Zimbabwe|4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JcSHnGZTruPL",
        "colab_type": "text"
      },
      "source": [
        "Write a Python program to write a Python list of lists to a csv file. \n",
        "\n",
        "\n",
        "After writing the CSV file read the CSV file and display the content. \n",
        "* consider these data : data = [[10,'a1', 1], [12,'a2', 3], [14, 'a3', 5], [16, 'a4', 7], [18, 'a5', 9]]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ETnuXvm2Aau",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "970ac234-c6cf-4e7a-dcad-77e3603f3f4b"
      },
      "source": [
        " data = [[10,'a1', 1], [12,'a2', 3], [14, 'a3', 5], [16, 'a4', 7], [18, 'a5', 9]]\n",
        "\n",
        "with open(\"data.csv\", \"w\", newline=\"\") as f:\n",
        "    writer = csv.writer(f)\n",
        "    writer.writerows(data)\n",
        "\n",
        "with open('data.csv','r')as f:\n",
        "  data = csv.reader(f)\n",
        "  for row in data:\n",
        "        print(row)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['10', 'a1', '1']\n",
            "['12', 'a2', '3']\n",
            "['14', 'a3', '5']\n",
            "['16', 'a4', '7']\n",
            "['18', 'a5', '9']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MWDj6vtmruPM",
        "colab_type": "text"
      },
      "source": [
        "#### Numpy\n",
        "Write a NumPy program to get the indices of the sorted elements of a given array.\n",
        "Use student_id = np.array([1023, 5202, 6230, 1671, 1682, 5241, 4532])"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UsILVTS7ruPN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3270c8fb-096c-41d5-8686-e4cf24c155d7"
      },
      "source": [
        "# Try here\n",
        "student_id = np.array([1023, 5202, 6230, 1671, 1682, 5241, 4532])\n",
        "indices = np.argsort(student_id, axis=0)\n",
        "indices"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 3, 4, 6, 1, 5, 2])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "17JMXbmiruPS",
        "colab_type": "text"
      },
      "source": [
        "#### Pandas\n",
        "Write a Pandas program to select the 'name' and 'score' columns from the following DataFrame.\n",
        "Sample Python dictionary data and list labels:\n",
        "* exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "* labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] can serve as index for the dataframe"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "viB5KgjuruPT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "outputId": "fb92fe2e-aa0e-4240-b003-bd0e7fc9e261"
      },
      "source": [
        "# Try here\n",
        "exam_data  = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "        'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "        'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "        'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "data = pd.DataFrame(exam_data, index=labels)\n",
        "data[['name','score']]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>name</th>\n",
              "      <th>score</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>a</th>\n",
              "      <td>Anastasia</td>\n",
              "      <td>12.5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>b</th>\n",
              "      <td>Dima</td>\n",
              "      <td>9.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>c</th>\n",
              "      <td>Katherine</td>\n",
              "      <td>16.5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>d</th>\n",
              "      <td>James</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>e</th>\n",
              "      <td>Emily</td>\n",
              "      <td>9.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>f</th>\n",
              "      <td>Michael</td>\n",
              "      <td>20.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>g</th>\n",
              "      <td>Matthew</td>\n",
              "      <td>14.5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>h</th>\n",
              "      <td>Laura</td>\n",
              "      <td>NaN</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>i</th>\n",
              "      <td>Kevin</td>\n",
              "      <td>8.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>j</th>\n",
              "      <td>Jonas</td>\n",
              "      <td>19.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        name  score\n",
              "a  Anastasia   12.5\n",
              "b       Dima    9.0\n",
              "c  Katherine   16.5\n",
              "d      James    NaN\n",
              "e      Emily    9.0\n",
              "f    Michael   20.0\n",
              "g    Matthew   14.5\n",
              "h      Laura    NaN\n",
              "i      Kevin    8.0\n",
              "j      Jonas   19.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EyS_A29AruPX",
        "colab_type": "text"
      },
      "source": [
        "References: \n",
        "* <a href=\"https://www.w3resource.com/\" target=\"_blank\">w3resource</a>\n",
        "* <a href=\"https://www.python-simple.com/\" target=\"_blank\">python-simple</a>\n",
        "* <a href=\"https://www.earthdatascience.org/\" target=\"_blank\">earthdatascience</a>"
      ]
    }
  ]
}