Skip to content

Instantly share code, notes, and snippets.

@shohrehsharifib

shohrehsharifib/PY0101EN-5.1_Intro_API.ipynb

Created February 20, 2021 22:51
Show Gist options
  • Save shohrehsharifib/d4b3b0e19d5d810f9184e559c86b39ec to your computer and use it in GitHub Desktop.
Save shohrehsharifib/d4b3b0e19d5d810f9184e559c86b39ec to your computer and use it in GitHub Desktop.
Download ZIP
Created on Skills Network Labs
Display the source blob
Display the rendered blob
Raw
PY0101EN-5.1_Intro_API.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<center>\n",
" <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/Logos/organization_logo/organization_logo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\" />\n",
"</center>\n",
"\n",
"# Application Programming Interface\n",
"\n",
"Estimated time needed: **15** minutes\n",
"\n",
"## Objectives\n",
"\n",
"After completing this lab you will be able to:\n",
"\n",
"- Create and Use APIs in Python\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Introduction\n",
"\n",
"An API lets two pieces of software talk to each other. Just like a function, you don’t have to know how the API works only its inputs and outputs. An essential type of API is a REST API that allows you to access resources via the internet. In this lab, we will review the Pandas Library in the context of an API, we will also review a basic REST API \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Table of Contents\n",
"\n",
"<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
"<li><a href=\"#ref0\">Pandas is an API</a></li>\n",
"<li><a href=\"#ref1\">REST APIs Basics </a></li>\n",
"<li><a href=\"#ref2\">Quiz on Tuples</a></li>\n",
"\n",
"</div>\n",
"\n",
"<hr>\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"!pip install nba_api"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"PandasAPI\">Pandas is an API </h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You will use this function in the lab:\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"def one_dict(list_dict):\n",
" keys=list_dict[0].keys()\n",
" out_dict={key:[] for key in keys}\n",
" for dict_ in list_dict:\n",
" for key, value in dict_.items():\n",
" out_dict[key].append(value)\n",
" return out_dict "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"PandasAPI\">Pandas is an API </h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pandas is actually set of software components , much of which is not even written in Python.\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You create a dictionary, this is just data.\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"dict_={'a':[11,21,31],'b':[12,22,32]}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When you create a Pandas object with the Dataframe constructor in API lingo, this is an \"instance\". The data in the dictionary is passed along to the pandas API. You then use the dataframe to communicate with the API.\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"pandas.core.frame.DataFrame"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df=pd.DataFrame(dict_)\n",
"type(df)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src = \"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%206/images/pandas_api.png\" width = 800, align = \"center\" alt=\"logistic regression block diagram\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When you call the method head the dataframe communicates with the API displaying the first few rows of the dataframe.\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"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>a</th>\n",
" <th>b</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>11</td>\n",
" <td>12</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>21</td>\n",
" <td>22</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>31</td>\n",
" <td>32</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" a b\n",
"0 11 12\n",
"1 21 22\n",
"2 31 32"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When you call the method mean,the API will calculate the mean and return the value.\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"a 21.0\n",
"b 22.0\n",
"dtype: float64"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df.mean()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"ref1\">REST APIs</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<p>Rest API’s function by sending a <b>request</b>, the request is communicated via HTTP message. The HTTP message usually contains a JSON file. This contains instructions for what operation we would like the service or <b>resource</b> to perform. In a similar manner, API returns a <b>response</b>, via an HTTP message, this response is usually contained within a JSON.</p>\n",
"<p>In this lab, we will use the <a href=https://pypi.org/project/nba-api/>NBA API</a> to determine how well the Golden State Warriors performed against the Toronto Raptors. We will use the API do the determined number of points the Golden State Warriors won or lost by for each game. So if the value is three, the Golden State Warriors won by three points. Similarly it the Golden State Warriors lost by two points the result will be negative two. The API is relatively will handle a lot of the details such a Endpoints and Authentication </p>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the nba api to make a request for a specific team, it's quite simple, we don't require a JSON all we require is an id. This information is stored locally in the API we import the module teams \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from nba_api.stats.static import teams\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"#https://pypi.org/project/nba-api/"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The method <code>get_teams()</code> returns a list of dictionaries the dictionary key id has a unique identifier for each team as a value \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nba_teams = teams.get_teams()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The dictionary key id has a unique identifier for each team as a value, let's look at the first three elements of the list:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nba_teams[0:3]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To make things easier, we can convert the dictionary to a table. First, we use the function <code>one dict</code>, to create a dictionary. We use the common keys for each team as the keys, the value is a list; each element of the list corresponds to the values for each team.\n",
"We then convert the dictionary to a dataframe, each row contains the information for a different team.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"dict_nba_team=one_dict(nba_teams)\n",
"df_teams=pd.DataFrame(dict_nba_team)\n",
"df_teams.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Will use the team's nickname to find the unique id, we can see the row that contains the warriors by using the column nickname as follows:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"df_warriors=df_teams[df_teams['nickname']=='Warriors']\n",
"df_warriors"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"we can use the following line of code to access the first column of the dataframe:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"id_warriors=df_warriors[['id']].values[0][0]\n",
"#we now have an integer that can be used to request the Warriors information \n",
"id_warriors"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function \"League Game Finder \" will make an API call, its in the module <code>stats.endpoints</code> \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from nba_api.stats.endpoints import leaguegamefinder"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The parameter <code>team_id_nullable</code> is the unique ID for the warriors. Under the hood, the NBA API is making a HTTP request. \n",
"The information requested is provided and is transmitted via an HTTP response this is assigned to the object <code>gamefinder</code>.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"# Since https://stats.nba.com does not allow api calls from Cloud IPs and Skills Network Labs uses a Cloud IP.\n",
"# The following code is comment out, you can run it on jupyter labs on your own computer.\n",
"# gamefinder = leaguegamefinder.LeagueGameFinder(team_id_nullable=id_warriors)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"we can see the json file by running the following line of code. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Since https://stats.nba.com does not allow api calls from Cloud IPs and Skills Network Labs uses a Cloud IP.\n",
"# The following code is comment out, you can run it on jupyter labs on your own computer.\n",
"# gamefinder.get_json()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The game finder object has a method <code>get_data_frames()</code>, that returns a dataframe. If we view the dataframe, we can see it contains information about all the games the Warriors played. The <code>PLUS_MINUS</code> column contains information on the score, if the value is negative the Warriors lost by that many points, if the value is positive, the warriors one by that amount of points. The column <code>MATCHUP </code>had the team the Warriors were playing, GSW stands for Golden State Warriors and TOR means Toronto Raptors; <code>vs</code> signifies it was a home game and the <code>@ </code>symbol means an away game.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Since https://stats.nba.com does not allow api calls from Cloud IPs and Skills Network Labs uses a Cloud IP.\n",
"# The following code is comment out, you can run it on jupyter labs on your own computer.\n",
"# games = gamefinder.get_data_frames()[0]\n",
"# games.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"you can download the dataframe from the API call for Golden State and run the rest like a video.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"! wget https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Labs/Golden_State.pkl"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"file_name = \"Golden_State.pkl\"\n",
"games = pd.read_pickle(file_name)\n",
"games.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can create two dataframes, one for the games that the Warriors faced the raptors at home and the second for away games.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"games_home=games [games ['MATCHUP']=='GSW vs. TOR']\n",
"games_away=games [games ['MATCHUP']=='GSW @ TOR']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can calculate the mean for the column <code>PLUS_MINUS</code> for the dataframes <code>games_home</code> and <code> games_away</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"games_home.mean()['PLUS_MINUS']"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"games_away.mean()['PLUS_MINUS']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can plot out the <code>PLUS MINUS</code> column for for the dataframes <code>games_home</code> and <code> games_away</code>.\n",
"We see the warriors played better at home.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"fig, ax = plt.subplots()\n",
"\n",
"games_away.plot(x='GAME_DATE',y='PLUS_MINUS', ax=ax)\n",
"games_home.plot(x='GAME_DATE',y='PLUS_MINUS', ax=ax)\n",
"ax.legend([\"away\", \"home\"])\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2>Quiz</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Calculate the mean for the column <code>PTS</code> for the dataframes <code>games_home</code> and <code> games_away</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"games_home.mean()['PTS']\n",
"\n",
"games_away.mean()['PTS']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"games_home.mean()['PTS']\n",
"\n",
"games_away.mean()['PTS']\n",
"\n",
"```\n",
"\n",
"</details>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" <a href=\"https://cloud.ibm.com/catalog/services/watson-studio\"><img src = \"https://ibm.box.com/shared/static/irypdxea2q4th88zu1o1tsd06dya10go.png\" width = 750, align = \"center\"></a>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Authors:\n",
"\n",
" [Joseph Santarcangelo](https://www.linkedin.com/in/joseph-s-50398b136?cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork-19487395&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ&cm_mmc=Email_Newsletter-_-Developer_Ed%2BTech-_-WW_WW-_-SkillsNetwork-Courses-IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork-19487395&cm_mmca1=000026UJ&cm_mmca2=10006555&cm_mmca3=M12345678&cvosrc=email.Newsletter.M12345678&cvo_campaign=000026UJ) \n",
"\n",
"Joseph Santarcangelo has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.\n",
"\n",
"## Change Log\n",
"\n",
"| Date (YYYY-MM-DD) | Version | Changed By | Change Description |\n",
"| ----------------- | ------- | ------------- | ---------------------------------- |\n",
"| 2020-09-09 | 2.1 | Malika Singla | Spell Check |\n",
"| 2020-08-26 | 2.0 | Lavanya | Moved lab to course repo in GitLab |\n",
"| | | | |\n",
"| | | | |\n",
"\n",
"<hr/>\n",
"\n",
"## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python",
"language": "python",
"name": "conda-env-python-py"
},
"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.12"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment