p_18_mini_project.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TBw8g7UfuNaN"
      },
      "source": [
        "# Mini Project\n",
        "\n",
        "## Graphing cities\n",
        "\n",
        "***\n",
        "\n",
        "Ok, so now that we have a sense of how to read from and alter a list in Python, let's see how our knowledge of lists can help us in creating data visualizations in Python.\n",
        "\n",
        ">You can edit this notebook and run all the cells.  If you would like to save the notebook and your work, click on the \"__File__\" menu above and select \"__Save a Copy in Drive__\", then you will be able to make any changes and save them to your Google Drive account.\n",
        "\n",
        "## Working with lists and maps\n",
        "\n",
        "***\n",
        "\n",
        "As we know, lists are used to store a collection of data.  In describing a city, we can use lists to organize our data in all sorts of ways.  For example, here is a list of the top 25 cities to travel to in the world in 2020:\n",
        "\n",
        ">use `shift+enter` to run the cell"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E17y3IjbuNaS"
      },
      "source": [
        "cities = ['Oaxaca', 'Mexico', '17.021886', '-96.784615', 'San Miguel de Allende', 'Mexico', '20.910399', '-100.737493', 'Hoi An', 'Vietnam', '15.883323', '108.340323', 'Chiang Mai', 'Thailand', '18.754378', '98.973933', 'Florence', 'Italy', '43.773492', '11.247146', 'Kyoto', 'Japan', '35.131373', '135.526008', 'Udaipur', 'India', '24.3566124', '73.706713', 'Luang Prabang', 'Laos', '19.863075', '102.215407', 'Ubud', 'Indonesia', '-8.502221', '115.265032', 'Istanbul', 'Turkey', '41.162210', '28.765515', 'Mexico City', 'Mexico', '19.407963', '-99.147823', 'Bangkok', 'China', '13.741712', '100.568078', 'Rome', 'Italy', '41.899323', '12.494508', 'Jaipur', 'India', '26.910191', '75.786958', 'Tokyo', 'Japan', '35.668356', '139.736732', 'Siem Reap', 'Cambodia', '13.382729', '103.890376', 'Lisbon', 'Portugal', '38.762778', '-9.182357', 'Charleston, SC', 'USA', '32.788745', '-80.003739', 'Cuzco', 'Peru', '-13.535684', '-71.964657', 'Porto', 'Portugal', '41.159228', '-8.625023', 'Singapore', 'Singapore', '1.352427', '103.866592', 'New Orleans, LA', 'USA', '29.942969', '-90.085780', 'Seville', 'Spain', '37.387139', '-5.986822', 'Mérida', 'Mexico', '20.963875', '-89.596392', 'Kraków', 'Poland', '50.027269', '19.979097']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9HPHNCx8uNaT"
      },
      "source": [
        "In this list of cities, we can see that each city has a little information about it.  We have the city name first, then the country, and then the location coordinates in the form of latitude and longitude.  We can also see that this is a bit messy, with all of the information packed into a list, it makes it a bit difficult to work with.  Lets get this list into a format that has a little more structure.  \n",
        "\n",
        "We can start by making a list of each of the elements for each list so that for each city we have a list of its atributes.  For example the first city in our list is 'Oaxaca', we can see the details of this city by calling the variable `cities` and using the inidices of the first 4 items.  \n",
        "\n",
        "In the cell below, call the variable `cities` and the range of indices that will show the first 4 elements of the list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fGwS3I3NuNaU"
      },
      "source": [
        "# type your code here\n",
        "# your code should output ['Oaxaca', 'Mexico', '17.021886', '-96.784615']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vlPSI4g-uNaU"
      },
      "source": [
        "The information in this format is a bit messy and difficult to work with. We can begin to get the information into a more managable format by first extracting a list of all of the cities.  We can do this with a for loop.  \n",
        "\n",
        "A for loop iterates through the collection of information, which in our case is a list. below is a basic example of a for loop which we will dive into deeper in another lesson. In the for loop below, we are simply iterating through the list of cities and printing the city out. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [],
        "id": "HrvjA7IeuNaU"
      },
      "source": [
        "# press shift+enter to run the cell and see the output\n",
        "\n",
        "list_of_cities = ['Austin', 'Chicago', 'Denver', 'Houston', 'New York', 'San Francisco', 'Seattle', 'Washington D.C.']\n",
        "\n",
        "for city in list_of_cities:\n",
        "    print(city)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aOpOZnrouNaU"
      },
      "source": [
        "Similar to the loop above, we can iterate through our list of information and extract the city names.  We can do this using a for loop and incrementing our index by 4.  We have provided the code for you for this loop so you =can begin to understand how a for loop works and apply that knowledge to the next loop we use."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [],
        "id": "-o9vLrskuNaV"
      },
      "source": [
        "# press shift+enter to run the code in this cell\n",
        "\n",
        "city_names = []\n",
        "        # this iterates through a range the length of the list `cities` by 4's\n",
        "for element in cities[::4]: \n",
        "    city_names.append(element)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qwfT4PpCuNaV"
      },
      "source": [
        "Let's check to make sure our loop worked.  In the next cell, use the `print()` function to print out our list of `city_names`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EI_getKmuNaV"
      },
      "source": [
        "# print the list of `city_names`\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BveRFlK3uNaV"
      },
      "source": [
        "Now that we have a list of the names of the cities, we can use that list of names to create a list of information for each city. We will do this using a for loop once again. for each city name, we will take the 4 items of information for it and put the information into a list.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [],
        "id": "v7jRju5kuNaW"
      },
      "source": [
        "cities_list = []\n",
        "ind = 0\n",
        "for group in range(len(cities[::4])):\n",
        "   cities_list.append(cities[ind:ind+4])\n",
        "   ind += 4\n",
        "print(cities_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfQdmflMuNaW"
      },
      "source": [
        "Great, now we have a list of lists.  Each index in `cities` will reference the list that will coincide with the index of the city name in our `city_names` list. Let's try to access the information for `'Tokyo'`.\n",
        ">Hint: You can find the index of a value using the `.index()` method. It is used like the following example:\n",
        "```python\n",
        "nums = ['one', 'two', 'three', 'four', 'five']\n",
        "nums.index('three')\n",
        "> 2\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ShIeavWSuNaW"
      },
      "source": [
        "# print the name `'Tokyo'` from `city_names` and the information correspondiong to it from `cities_list` using the `print()` function and the `index()` method\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hiIjcOx-uNaW"
      },
      "source": [
        "Great, it worked!!  Now that we have our data in a format that we can use, let's get to the visualization.\n",
        "\n",
        "For our visualization, we will be plotting the cities on a map using the coordinates in `cities_list`.  The list we have has the latitude `lat` of our cities in the 4th position and the longitude ` longi` in the 3rd position.  We can use a for loop to create individual lists of the latitude and longitude by iterating through `cities_list` and using the `append()` function to add the values to each coordinate list, `lat` and `longi`. In the cell below, write a for loop that will iterate through `cities_list` and for each list, `append` the element at the _index_ you specify to the `lat` list and the element at the _index_ you specify to the `longi` list. \n",
        "\n",
        ">We will need the coordinates to be in a number format and since they all have decimals, we will need to convert them to a `float` data type.  You can do this in the for loop using the `float()` function to convert them.  For example, if you wanted to convert the string `'3.14159'` to a float, you would type the following code: `float('3.14159')`.\n",
        "\n",
        "\n",
        "In the cell below, replace the word \"index\" with the appropriate number to retrieve the correct value from our list for both `lat` and `longi`.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xsxSkDzzuNaX"
      },
      "source": [
        "# here we are creating two empty lists to store the data in\n",
        "lat = []\n",
        "longi = []\n",
        "# this for loop will access each item (i) in the list\n",
        "for i in cities_list:\n",
        "    # here the element of the item (i) with the index you specify \n",
        "    # and is converted to a float and appended to the list 'lat'\n",
        "    lat.append(float(i[index]))\n",
        "    # here the element of the item (i) with the index of [2] \n",
        "    # and is converted to a float and appended to the list 'longi'\n",
        "    longi.append(float(i[index]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cj_ZZCxeuNaX"
      },
      "source": [
        "Great!! Now let's take a look and make sure we have done it correctly.  If we have, we should be able to run the code cell below and get true as the result."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [],
        "id": "ZZ4j28I7uNaX"
      },
      "source": [
        "(float(cities_list[3][3]), float(cities_list[3][2])) == (lat[3], longi[3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2e_keuWzuNaX"
      },
      "source": [
        "Now we can use all of these lists we have created and plot the coordinates on a map.  In the cell below you can see the code for this visualization.  In the Flatiron School Data Science program, you will learn all about the matplotlib library, but for now we have written the code for you so you can see its usefulness."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pOAHVeoAuNaY"
      },
      "source": [
        "# this imports the pyplot library from matplotlib and assigns the alias 'plt' to it so we don't have to type 'pyplot' each time we call it \n",
        "import matplotlib.pyplot as plt\n",
        "# this allows matplotlib to render the images inline in the notebook\n",
        "%matplotlib inline\n",
        "\n",
        "# here we are setting the boundaries for our background image, the map and we use the imread function to read the image in\n",
        "bounds = [min(lat), max(lat), min(longi), max(longi)]\n",
        "background = plt.imread('map1.png')\n",
        "\n",
        "# this is settin gour figure size and telling matplotlib that we will be plotting multiple items on this one figure\n",
        "fig, ax = plt.subplots(figsize=(13,5))\n",
        "# this plots each lat and longi pair as a point on the graph (map)\n",
        "ax.scatter(lat, longi, zorder=1, s=10, c='b', alpha=.8)\n",
        "# this is adding the title to the top of the figure\n",
        "ax.set_title('Plotting City Information')\n",
        "# here we are setting the boundaries for the image background\n",
        "ax.set_xlim(bounds[0],bounds[1])\n",
        "ax.set_ylim(bounds[2],bounds[3])\n",
        "# this is the command to tell matplotlib to render the image with all of the information above\n",
        "ax.imshow(background, zorder=0, extent=bounds, aspect='equal');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "alz2ztMHuNaY"
      },
      "source": [
        "Great!!  If we look at the graph, we can see that each point represents one of our cities and its coordinates.\n",
        "\n",
        "Now we can look at doing some calculations using the information we have created. Let's see how we can find the distance between two points using a function.  In order to calculate the distance, we will first need the formula.  The formula for calculating the distance between two points is as follows:\n",
        "\n",
        ">$\\large(x_2 - x_1)^{2} + (y_2 - y_1)^{2}$\n",
        "\n",
        "we will create a function that takes in the $x_1$, $x_2$, $y_1$, and $y_2$ values and will return the distance between those two points."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JGQnPeLJuNaY"
      },
      "source": [
        "def distance(x1, y1, x2, y2):\n",
        "    \"\"\"\n",
        "    This function takes in the coordinates of two points \n",
        "    and returns the distance between them\n",
        "    \"\"\"\n",
        "    x1 = float(x1)\n",
        "    x2 = float(x2)\n",
        "    y1 = float(y1)\n",
        "    y2 = float(y2)\n",
        "    return (x2 - x1)**2 + (y2 - y1)**2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SDj-6mPeuNaY"
      },
      "source": [
        "Now we can create another function that will take in the names of two cities in our original list and return the distance between the two cities."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IjyEWW3suNaZ"
      },
      "source": [
        "def how_far(city_1, city_2):\n",
        "    first = city_names.index(city_1)\n",
        "    second = city_names.index(city_2)\n",
        "    x1 = cities_list[first][2]\n",
        "    y1 = cities_list[first][3]\n",
        "    x2 = cities_list[second][2]\n",
        "    y2 = cities_list[second][3]\n",
        "    return distance(x1, y1, x2, y2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vzNtQH8huNaZ"
      },
      "source": [
        "Below we can find the distance between two of our points by passing two city names as arguments for the `how_far` function we created. In the cell below, replace each variable with the name of a city from our list.  For example, to finf the distance from _Mexico_ to _Tokyo_, the code would look like this:\n",
        "`how_far('Mexico', 'Tokyo')`.  GHo ahead any try it out on several cities.\n",
        "> This number is not a real distance, it is just to demonstrate how you can use lists in python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_2hKkVSnuNaZ"
      },
      "source": [
        "how_far(first_city, second_city)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bZEMRmFYuNaZ"
      },
      "source": [
        ">*Level Up* - Try to write a function which calculates the real distance between the two cities in miles.  Look for the equation with an internet search and try to apply it to your function. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0JFVT6N5uNaZ"
      },
      "source": [
        "Great! Now we have taken a good look at how we can use lists and apply some techniques using the attributes of the list to organize some information and use that information to make some calculations. Now you can return to the lesson and see what other lessons you can look at."
      ]
    }
  ],
  "metadata": {
    "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.6.9-final"
    },
    "orig_nbformat": 2,
    "kernelspec": {
      "name": "python_defaultSpec_1610472812089",
      "display_name": "Python 3.6.9 64-bit ('learn-env': conda)"
    },
    "colab": {
      "name": "mini_project.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}