{ "cells": [ { "cell_type": "markdown", "metadata": { "toc": true }, "source": [ "

Table of Contents

\n", "
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "
\n", "\n", "Take notice:\n", "\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Week 2: Python and Metro" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A quick geopandas teaser\n", "Following our Python bootcamp last week (was it boring? exhilerating? a bit of both?), let's put that programming knowledge into action, using and creating data that reflects a real urban situation.\n", "\n", "We start by importing a new module `geopandas`. This is a pretty high level geospatial library, widely used by spatial data scientists all over the world. Don't worry about it too much for now, but know that it allows us to import a variety of spatial data formats, and plot them on a map.\n", "\n", "* [geopandas documentation](https://geopandas.readthedocs.io/en/latest/gallery/index.html)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import geopandas as gpd" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Next, we import some data. In this case, it is a [shapefile](https://desktop.arcgis.com/en/arcmap/latest/manage-data/shapefiles/what-is-a-shapefile.htm) I downloaded from the [LA Metro's Developer web portal](https://developer.metro.net/bus-rail-gis-data/). Notice that I am using relative paths to point to where the data is located in. \n", "\n", "* [read_file](https://geopandas.readthedocs.io/en/latest/docs/user_guide/io.html)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "metro = gpd.read_file('data/Stations_All_0715.shp')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "
\n", "\n", "Note that the reason we use `geopandas` instead of `pandas` (other than the fact that we love maps) is that `pandas` cannot read shapefiles, whereas `geopandas` can.\n", " \n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# what's the data type?\n", "type(metro)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# what does the data look like? \n", "metro.head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Ah! Surprise, surprise. Welcome to your first look at a pandas dataframe. We will cover dataframes more extensively in later sessions, but know that a python dataframe is like an excel spreadsheet. \n", "\n", "![image.png](https://media.geeksforgeeks.org/wp-content/uploads/finallpandas.png)\n", "[(source)](https://www.geeksforgeeks.org/python-pandas-dataframe/?ref=lbp)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "The `head()` command shows us the first 5 rows of the dataframe. You can also use `tail()` and `sample()`. Try these commands in the cells below:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# try tail()\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# try sample()\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Pandas Data Types\n", "\n", "Let's look at the data types for each column. You can collectively get all the datatypes for each column in a dataframe using the `dtypes` command." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "metro.dtypes" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "But there is better command that will get you more info. Yes, the `info` command." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# dataframe info\n", "metro.info()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Wait. That looks different from what we have worked on! As it turns out, pandas datatypes are slightly different from the raw python datatypes. Check out the table below:" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Pandas TypeNative Python TypeDescription
objectstringThe most general dtype. Will be assigned to your column if column has mixed types (numbers and strings).
int64intNumeric characters. 64 refers to the memory allocated to hold this character.
float64floatNumeric characters with decimals. If a column contains numbers and NaNs (see below), pandas will default to float64, in case your missing value has a decimal.
datetime64, timedelta[ns]N/A (but see the datetime module in Python’s standard library)Values meant to hold time data. Look into these for time series experiments.
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Data exploration\n", "\n", "Part of data exploration is learning what is in your data. How many rows are there? What are the columns? How many rows represent a particular slice of the data?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# how many rows and columns?\n", "metro.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# what are the columns?\n", "metro.columns.to_list()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Counting unique values in a column\n", "\n", "First, learn how to get values for a single column." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# single column\n", "metro['LINE']" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# another way\n", "metro.LINE" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "
\n", "What are situations when one method is necessary over the other? (i.e. metro['LINE'] vs metro.LINE)\n", "
" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "This returns what is called a python series, a one dimensional array.\n", "![image.png](https://media.geeksforgeeks.org/wp-content/uploads/dataSER-1.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "But what if you want to know how many stations there are for each line?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro['LINE'].value_counts()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# save it as a variable\n", "line_count = metro['LINE'].value_counts()\n", "line_count" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# let's convert the series into a dataframe\n", "line_count = line_count.reset_index()\n", "line_count" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "type(line_count)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Rename columns" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# current columns as a list\n", "line_count.columns.to_list()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "To rename columns, simply give it a list of column names" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "line_count.columns = ['line', 'count']" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "line_count" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### A quick bar plot" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "* [pandas plot](https://pandas.pydata.org/pandas-docs/stable/getting_started/intro_tutorials/04_plotting.html#min-tut-04-plotting)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "line_count.plot()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# give it additional arguments\n", "line_count.plot.bar(x = 'line', y = 'count', title = 'Number of stops per metro line')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# try it yourself. Create different plots using the metro dataframe\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Trimming the data\n", "Oftentimes, we import data and it has too many columns. It is always good practice to elimnate those rows that you are sure you will not use, and keep your data \"clean\" and \"mean.\"\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# output the original data's info\n", "metro.info()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# show a dataframe with a subset of columns\n", "metro[['LINE','LINENUM','STATION','LAT','LONG','geometry']]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Wait, why the double square brackets? `[[...]]`\n", "\n", "The reason for this is that we are feeding the dataframe a list of column names. Another way to do the same thing would be:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# list of desired column names\n", "desired_columns = ['LINE','LINENUM','STATION','LAT','LONG','geometry']\n", "\n", "# subset based on desired columns\n", "metro[desired_columns]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "If you now print the dataframe, what happens?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro.head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "What happened? Why has the dataframe reverted to the original data?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "That's right. In order to preserve your new dataframe, you have to **declare** it as a new variable. And finally, whenever you make a copy of a dataframe, it is **highly recommended** to add the `.copy()` command at the end:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed = metro[desired_columns].copy()\n", "metro_trimmed" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Subsetting/querying/filtering the data\n", "\n", "What if you only want to see a subset of the data? Or create a new table based on a query?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed[metro_trimmed.LINE == 'EXPO']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another way using `.loc`\n", "- https://www.w3resource.com/pandas/dataframe/dataframe-loc.php" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# another way .loc\n", "metro_trimmed.loc[metro_trimmed['LINE'] == 'EXPO']" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# another way .query\n", "metro_trimmed.query(\"LINE == 'EXPO'\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# try it yourself. Query the dataframe for other properties of interest\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Plotting\n", "\n", "We have now imported a shapefile, trimmed it, and created a series of queried subsets. Let's visualize our data. First, simply pass it the `plot()` command to see what it looks like." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed.plot()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "That's great! Very rewarding, with a single command. The reason it is able to plot the station points is because of the `geometry` column that is created from the shapefile. This is a unique geopandas feature." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed.geometry" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### A prettier plot\n", "\n", "You can add additional arguments to make the plot prettier: change the size, add legends, etc." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "metro_trimmed.plot(\n", " figsize=(20,12), #size of the plot (a bit bigger than the default)\n", " column = 'LINE', # column that defines the color of the dots\n", " legend = True, # add a legend \n", " legend_kwds={\n", " 'loc': 'upper right',\n", " 'bbox_to_anchor':(1.3,1)\n", " } # this puts the legend to the side\n", ") " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Mapping with folium" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Now it's time for another module. Everybody, please welcome `folium`. Folium brings leaflet, an open source javascript mapping library into our Python environment, allowing you to create instant interactive maps. Try it:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import folium" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# default folium map\n", "m = folium.Map()\n", "m" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A world map is cool... but let's add arguments to the `folium.map` command. Specifically, we can feed it a center latitude value, a center longitude value, and a default zoom level." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Get average lat/lon's" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# average latitude\n", "latitude = metro_trimmed.LAT.mean()\n", "latitude" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# average longitude\n", "longitude = metro_trimmed.LONG.mean()\n", "longitude" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Folium map with arguments\n", "\n", "Complete the code cell below with arguments to center the map based on the metro coordinates calculated above, and adjust the zoom level accordingly. Refer the [folium documentation](https://python-visualization.github.io/folium/quickstart.html) as necessary." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# complete this code so that the map will show up \n", "# centered based on the average lat/lon calculated above\n", "# adjust the zoom level accordingly\n", "m = folium.Map()\n", "m" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Adding point markers\n", "\n", "How do you add a marker to a folium map?\n", "\n", "* [Folium quickstart](https://python-visualization.github.io/folium/quickstart.html)\n", "\n", "```\n", "folium.Marker([45.3288, -121.6625], popup='Mt. Hood Meadows', tooltip=tooltip).add_to(m)\n", "```" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Since we want to add a marker *for each station* in our dataframe, we do a for loop, and add the marker within the loop." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# first, note how to loop through a dataframe:\n", "for index, row in metro_trimmed.iterrows():\n", " print(row.STATION, row.LAT, row.LONG)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Using the for loop logic above, create a folium marker for each row in the dataframe." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# add the stations\n", "for index, row in metro_trimmed.iterrows():\n", " # add folium marker code\n", "\n", "m" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Color code markers\n", "That's great, but can we color code the markers so that they correspond to their metro lines?\n", "\n", "To do so:\n", "\n", "1. create a new column `color`\n", "1. add a color of choice based on the LINE that each row represents" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# add a new column\n", "metro_trimmed['color'] = ''" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed.head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Find unique values in a column" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# find unique values in the LINE column\n", "metro_trimmed.LINE.unique()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Update column based on a query on another column\n", "We now want to populate the newly created `color` column with values based on the LINE.\n", "\n", "Remember how you used the `loc` command to query the data. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# display rows that match a query\n", "metro_trimmed.loc[metro_trimmed['LINE'] == 'EXPO']" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "The `loc` command has additional functionalities. You can use it to update a field based on a query on *another* field. But first, note that folium accepts only a few named colors, according to their [documentation](https://python-visualization.github.io/folium/modules.html): \n", "\n", "```\n", "[‘red’, ‘blue’, ‘green’, ‘purple’, ‘orange’, ‘darkred’,’lightred’, ‘beige’, ‘darkblue’, ‘darkgreen’, ‘cadetblue’, ‘darkpurple’, ‘white’, ‘pink’, ‘lightblue’, ‘lightgreen’, ‘gray’, ‘black’, ‘lightgray’]\n", "```" ] }, { "attachments": { "image.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Using the `loc` command, we can update the color column for a single LINE:\n", "![image.png](attachment:image.png)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed.loc[metro_trimmed['LINE'] == 'EXPO', 'color'] = 'orange'" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "# check your work\n", "metro_trimmed.loc[metro_trimmed['LINE'] == 'EXPO']" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Now it's your turn. Update the color column for all other metro LINE's in the cell below:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "metro_trimmed.sample(5)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# reset the map (you need to do this to erase previous layers)\n", "m = folium.Map(location=[latitude,longitude], tiles='Stamen Terrain', zoom_start=10)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "# add the stations with color icons\n", "for index, row in metro_trimmed.iterrows():\n", " tooltip_text = row.LINE + ' Line: ' + row.STATION\n", " folium.Marker(\n", " [row.LAT,row.LONG], \n", " popup=row.STATION, \n", " tooltip=tooltip_text,\n", " icon=folium.Icon(color=row.color)\n", " ).add_to(m)\n", "\n", "# show the map\n", "m" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Saving your folium map as an HTML file" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "# save the interactive maps as an html file\n", "m.save('metro.html')" ] } ], "metadata": { "celltoolbar": "Slideshow", "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" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": true, "toc_position": { "height": "757px", "left": "523px", "top": "110px", "width": "384px" }, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }