From dae8401b1d998d84c6b226a78ec2c93803c9e41b Mon Sep 17 00:00:00 2001 From: discdiver Date: Thu, 30 Apr 2020 23:14:16 -0400 Subject: [PATCH 1/6] update python notebook example to use more common pandas methods and built in plotting option --- api-guide/ids-api-guide-python-2.ipynb | 749 +++++++++++++++++++------ 1 file changed, 592 insertions(+), 157 deletions(-) diff --git a/api-guide/ids-api-guide-python-2.ipynb b/api-guide/ids-api-guide-python-2.ipynb index e1e5c82..5b9d214 100644 --- a/api-guide/ids-api-guide-python-2.ipynb +++ b/api-guide/ids-api-guide-python-2.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "# Accessing International Debt Statistics (IDS) through World Bank Data API\n", - "## Part 2 - Get and explore data\n", + "## Part 2 - Retrieve, explore, and visualize data\n", "### *Python 3*" ] }, @@ -13,7 +13,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Date: 04/15/2020
\n", + "Date: 04/15/2020, Updated 04/30/2020\n", + "\n", "[Data source](https://datacatalog.worldbank.org/dataset/international-debt-statistics)
\n", "[Developer Information](https://datahelpdesk.worldbank.org/knowledgebase/topics/125589-developer-information)
\n", "[GitHub](https://github.com/worldbank/debt-data/tree/master/api-guide)" @@ -43,25 +44,21 @@ "- [numpy](https://www.numpy.org/): Data analysis\n", "- [datetime](https://docs.python.org/3.5/library/datetime.html): Parsing dates\n", "- [wbdata](https://wbdata.readthedocs.io/en/latest/#): World Bank Data API wrapper\n", - "- [plotly](https://plot.ly/python/): Data visualization\n", "\n", "Then, open up your preferred mode of writing Python. This could be in a [Jupyter Notebook](https://jupyter.org/) using [Jupyter Lab](https://blog.jupyter.org/jupyterlab-is-ready-for-users-5a6f039b8906), using a code editor (like Atom or Visual Studio) + command line, or just from the command line. Now follow the rest of the steps below to retreive and analyze the World Bank data." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 95, "metadata": {}, "outputs": [], "source": [ - "# Importing packages\n", + "# Import packages\n", "import pandas as pd\n", "import numpy as np\n", "import datetime\n", - "import wbdata\n", - "import plotly.express as px\n", - "import plotly.io as pio\n", - "pio.renderers.default = \"notebook\" # use \"pio.renderers\" to see the default renderer" + "import wbdata" ] }, { @@ -86,11 +83,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "# Selecting the indicator\n", + "# Select the indicator\n", "indicatorSelection = {\"DT.DOD.DLXF.CD\":\"ExternalDebtStock\"}" ] }, @@ -122,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -135,12 +132,12 @@ "metadata": {}, "source": [ "#### Time\n", - "Here you will select the time frame for your data series. The format for the date is year, month, day. We are selecting data from 2009 to 2018." + "Select the time frame for your data series. The format for the date is year, month, day. We are selecting data from 2009 through 2018." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -158,16 +155,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " id name\n", - "---- -----------------------------\n", - " 6 International Debt Statistics\n" + "6\tInternational Debt Statistics\n" ] } ], @@ -186,18 +181,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this step, we will retrieve the data using the World Bank Data API call. The package \"wbdata,\" created by Oliver Sherouse, can request information from the World Bank database as a dictionary containing full metadata or as a pandas DataFrame. In this example, we will request the data, with the parameters outlined above, as a pandas DataFrame." + "In this step, we will retrieve the data using the World Bank Data API call. The package [wbdata](https://wbdata.readthedocs.io/en/stable/) created by Oliver Sherouse, can request information from the World Bank database as a dictionary containing full metadata or as a pandas DataFrame. In this example, we will request the data, with the parameters outlined above, as a pandas DataFrame." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 115, "metadata": {}, "outputs": [], "source": [ "# Making the API call and assigning the resulting DataFrame to \"EXD\"\n", "EXD = wbdata.get_dataframe(indicatorSelection,\n", - " source=IDS,\n", + " # source=IDS, # Jeff says had to uncomment\n", " country = locationSelection, \n", " data_date = timeSelection, \n", " convert_date = False)" @@ -207,31 +202,98 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "If you want a quick preview of your freshly retrieved DataFrame, you can print the first 5 lines" + "For a quick preview of your freshly retrieved DataFrame, let's print the first 5 lines with the `.head()` method." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 116, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " ExternalDebtStock\n", - "country date \n", - "East Asia & Pacific (excluding high income) 2018 1.391850e+12\n", - " 2017 1.285327e+12\n", - " 2016 1.172696e+12\n", - " 2015 1.036149e+12\n", - " 2014 1.040363e+12\n" - ] + "data": { + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ExternalDebtStock
countrydate
East Asia & Pacific (excluding high income)20181.404732e+12
20171.287079e+12
20161.170963e+12
20151.037230e+12
20141.039942e+12
\n", + "
" + ], + "text/plain": [ + " ExternalDebtStock\n", + "country date \n", + "East Asia & Pacific (excluding high income) 2018 1.404732e+12\n", + " 2017 1.287079e+12\n", + " 2016 1.170963e+12\n", + " 2015 1.037230e+12\n", + " 2014 1.039942e+12" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "# Print the first 5 lines of the DataFrame\n", - "print(EXD.head())" + "EXD.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "# Make a copy of our DataFrame so we don't need to call the API again if we want to fix something.\n", + "EXD_df = EXD.copy()" ] }, { @@ -256,35 +318,214 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 118, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrydateExternalDebtStock
0East Asia & Pacific (excluding high income)20181.404732e+12
1East Asia & Pacific (excluding high income)20171.287079e+12
2East Asia & Pacific (excluding high income)20161.170963e+12
3East Asia & Pacific (excluding high income)20151.037230e+12
4East Asia & Pacific (excluding high income)20141.039942e+12
\n", + "
" + ], + "text/plain": [ + " country date ExternalDebtStock\n", + "0 East Asia & Pacific (excluding high income) 2018 1.404732e+12\n", + "1 East Asia & Pacific (excluding high income) 2017 1.287079e+12\n", + "2 East Asia & Pacific (excluding high income) 2016 1.170963e+12\n", + "3 East Asia & Pacific (excluding high income) 2015 1.037230e+12\n", + "4 East Asia & Pacific (excluding high income) 2014 1.039942e+12" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "EXD_df = EXD_df.reset_index()\n", + "EXD_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 60 entries, 0 to 59\n", + "Data columns (total 3 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 country 60 non-null object \n", + " 1 date 60 non-null object \n", + " 2 ExternalDebtStock 60 non-null float64\n", + "dtypes: float64(1), object(2)\n", + "memory usage: 1.5+ KB\n" + ] + } + ], "source": [ - "# Reshape the data\n", - "EXDreshaped = pd.DataFrame(EXD.to_records())" + "EXD_df.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The data for the long-term external debt stock is currently in units. To improve a table's or chart's readability, convert the units to billions and round the number to 0 decimal places. To do this, create a function called \"formatNum\" that you can then run on your DataFrame." + "The data for the long-term external debt stock is currently in units. To improve a table's or chart's readability, let's convert the units to billions and round the number to 0 decimal places. " ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 120, "metadata": {}, "outputs": [], "source": [ - "# Creating a function that will change units to billions and round to 0 decimal places\n", - "def formatNum(x):\n", - " y = x/1000000000\n", - " z = round(y)\n", - " return(z)\n", - "\n", - "# Running the function on the desired data column\n", - "EXDreshaped.ExternalDebtStock = formatNum(EXDreshaped.ExternalDebtStock)" + "# Change units to billions and round to 0 decimal places\n", + "EXD_df['ExternalDebtStock'] = round(EXD_df['ExternalDebtStock']/1_000_000_000, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrydateExternalDebtStock
0East Asia & Pacific (excluding high income)20181405.0
1East Asia & Pacific (excluding high income)20171287.0
2East Asia & Pacific (excluding high income)20161171.0
3East Asia & Pacific (excluding high income)20151037.0
4East Asia & Pacific (excluding high income)20141040.0
\n", + "
" + ], + "text/plain": [ + " country date ExternalDebtStock\n", + "0 East Asia & Pacific (excluding high income) 2018 1405.0\n", + "1 East Asia & Pacific (excluding high income) 2017 1287.0\n", + "2 East Asia & Pacific (excluding high income) 2016 1171.0\n", + "3 East Asia & Pacific (excluding high income) 2015 1037.0\n", + "4 East Asia & Pacific (excluding high income) 2014 1040.0" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "EXD_df.head()" ] }, { @@ -296,25 +537,116 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 122, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RegionYearExternalDebtStock
0East Asia & Pacific (excluding high income)20181405.0
1East Asia & Pacific (excluding high income)20171287.0
2East Asia & Pacific (excluding high income)20161171.0
3East Asia & Pacific (excluding high income)20151037.0
4East Asia & Pacific (excluding high income)20141040.0
\n", + "
" + ], + "text/plain": [ + " Region Year ExternalDebtStock\n", + "0 East Asia & Pacific (excluding high income) 2018 1405.0\n", + "1 East Asia & Pacific (excluding high income) 2017 1287.0\n", + "2 East Asia & Pacific (excluding high income) 2016 1171.0\n", + "3 East Asia & Pacific (excluding high income) 2015 1037.0\n", + "4 East Asia & Pacific (excluding high income) 2014 1040.0" + ] + }, + "execution_count": 122, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Renaming column headers\n", - "EXDclean = EXDreshaped.rename(index=str, columns={\n", - " \"date\":\"Year\",\n", - " \"country\":\"Region\",\n", - "})" + "# Rename column headers\n", + "EXD_df.columns=['Region', 'Year', 'ExternalDebtStock']\n", + "EXD_df.head()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 123, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Sub-Saharan Africa 10\n", + "South Asia 10\n", + "Middle East & North Africa 10\n", + "East Asia & Pacific 10\n", + "Europe & Central Asia 10\n", + "Latin America & Caribbean 10\n", + "Name: Region, dtype: int64" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Remove the \"(excluding high income)\" from each of the region names\n", - "EXDclean[\"Region\"] = EXDclean[\"Region\"].str.replace(\"excluding high income\",\"\").str.replace(\")\",\"\").str.replace(\"(\",\"\")" + "# Remove \"(excluding high income)\" from each of the region names\n", + "EXD_df[\"Region\"] = EXD_df[\"Region\"].str.replace(\"\\(excluding high income\\)\",\"\")\n", + "EXD_df['Region'].value_counts()" ] }, { @@ -326,135 +658,238 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 124, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " Region Year ExternalDebtStock\n", - "0 East Asia & Pacific 2018 1392.0\n", - "1 East Asia & Pacific 2017 1285.0\n", - "2 East Asia & Pacific 2016 1173.0\n", - "3 East Asia & Pacific 2015 1036.0\n", - "4 East Asia & Pacific 2014 1040.0\n" - ] + "data": { + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RegionYearExternalDebtStock
0East Asia & Pacific20181405.0
1East Asia & Pacific20171287.0
2East Asia & Pacific20161171.0
3East Asia & Pacific20151037.0
4East Asia & Pacific20141040.0
\n", + "
" + ], + "text/plain": [ + " Region Year ExternalDebtStock\n", + "0 East Asia & Pacific 2018 1405.0\n", + "1 East Asia & Pacific 2017 1287.0\n", + "2 East Asia & Pacific 2016 1171.0\n", + "3 East Asia & Pacific 2015 1037.0\n", + "4 East Asia & Pacific 2014 1040.0" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "print(EXDclean.head())" + "EXD_df.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Data Visualization\n", - "\n", - "Now use the package \"plotly\" to create a basic line graph of the regional trends in long-term external debt stock." + "Make the `Year` column the index and make it a datetime dtype." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 125, "metadata": {}, "outputs": [ { "data": { "text/html": [ - " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RegionYearExternalDebtStock
Year
2009-01-01Latin America & Caribbean2009747.0
2009-01-01South Asia2009293.0
2009-01-01Middle East & North Africa2009142.0
2009-01-01Europe & Central Asia2009950.0
2009-01-01East Asia & Pacific2009494.0
\n", + "
" + ], + "text/plain": [ + " Region Year ExternalDebtStock\n", + "Year \n", + "2009-01-01 Latin America & Caribbean 2009 747.0\n", + "2009-01-01 South Asia 2009 293.0\n", + "2009-01-01 Middle East & North Africa 2009 142.0\n", + "2009-01-01 Europe & Central Asia 2009 950.0\n", + "2009-01-01 East Asia & Pacific 2009 494.0" ] }, + "execution_count": 125, "metadata": {}, - "output_type": "display_data" - }, + "output_type": "execute_result" + } + ], + "source": [ + "EXD_df.index = pd.to_datetime(EXD_df['Year'])\n", + "EXD_df = EXD_df.sort_index()\n", + "EXD_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Data Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make a basic line graph with pandas (using Matplotlib as the backend plotting engine). " + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [ { "data": { - "text/html": [ - "
\n", - " \n", - " \n", - "
\n", - " \n", - "
" + "image/png": "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\n", + "text/plain": [ + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "# Defining the data source\n", - "source = EXDclean\n", + "EXD_df.groupby('Region')['ExternalDebtStock'].plot(\n", + " kind='line', \n", + " legend='Region',\n", + " figsize=(10, 8),\n", + " title=\"Regional Long-term External Debt Stock (excluding High-Income countries)(USD billion)\"\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary \n", "\n", - "# Creating the chart\n", - "chart = px.line(EXDclean, \n", - " x=\"Year\",\n", - " y=\"ExternalDebtStock\",\n", - " color=\"Region\",\n", - " title=\"Regional Long-term External Debt Stock (excluding High-Income countries)(USD billion)\")\n", - "chart.update_layout(\n", - " plot_bgcolor=\"white\")\n", + "You've seen how to retrieve data from the World Bank API and use it to make a visualization! \n", "\n", - "# Displaying the chart\n", - "chart" + "We can't wait to see what interesting insights you can uncover with data from World Bank! 🌍" ] } ], @@ -474,9 +909,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.7.7" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From f464b06484b2a920538dcf1fb2db84725b28f5d6 Mon Sep 17 00:00:00 2001 From: discdiver Date: Thu, 30 Apr 2020 23:24:20 -0400 Subject: [PATCH 2/6] remove source argument from api call so that is doesn't error --- api-guide/ids-api-guide-python-2.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/api-guide/ids-api-guide-python-2.ipynb b/api-guide/ids-api-guide-python-2.ipynb index 5b9d214..814d7af 100644 --- a/api-guide/ids-api-guide-python-2.ipynb +++ b/api-guide/ids-api-guide-python-2.ipynb @@ -192,7 +192,6 @@ "source": [ "# Making the API call and assigning the resulting DataFrame to \"EXD\"\n", "EXD = wbdata.get_dataframe(indicatorSelection,\n", - " # source=IDS, # Jeff says had to uncomment\n", " country = locationSelection, \n", " data_date = timeSelection, \n", " convert_date = False)" From 204ba2c71d1533f339733ffce7ccf43ce8196d6c Mon Sep 17 00:00:00 2001 From: discdiver Date: Fri, 1 May 2020 07:30:01 -0400 Subject: [PATCH 3/6] add package versions and edit setup --- api-guide/ids-api-guide-python-2.ipynb | 43 ++++++++++++++++++++------ 1 file changed, 34 insertions(+), 9 deletions(-) diff --git a/api-guide/ids-api-guide-python-2.ipynb b/api-guide/ids-api-guide-python-2.ipynb index 814d7af..3db050a 100644 --- a/api-guide/ids-api-guide-python-2.ipynb +++ b/api-guide/ids-api-guide-python-2.ipynb @@ -13,7 +13,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Date: 04/15/2020, Updated 04/30/2020\n", + "Date: 04/15/2020, Updated 05/01/2020\n", "\n", "[Data source](https://datacatalog.worldbank.org/dataset/international-debt-statistics)
\n", "[Developer Information](https://datahelpdesk.worldbank.org/knowledgebase/topics/125589-developer-information)
\n", @@ -28,10 +28,10 @@ "\n", "The following code in this guide will show step-by-step how to:\n", "\n", - "1. Setup up your environment with the needed packages\n", - "2. Input your data specifications (as selected in [Part 1](https://worldbank.github.io/debt-data/api-guide/ids-api-guide-python-1.html))\n", - "3. Use the World Bank Data API call to return the specified data\n", - "4. Explore the data through basic descriptive analysis and create a pretty chart." + "1. Setup up your environment with the needed packages.\n", + "2. Input your data specifications, as selected in [Part 1](https://worldbank.github.io/debt-data/api-guide/ids-api-guide-python-1.html).\n", + "3. Use the World Bank Data API to return the specified data\n", + "4. Explore the data through basic descriptive analysis and create a chart." ] }, { @@ -40,27 +40,52 @@ "source": [ "## 1. Setup\n", "To start, make sure you have the following packages installed on your machine. If you aren't familiar with how to install a Python package, visit each of the linked packages below for instructions.\n", + "\n", "- [pandas](https://pandas.pydata.org/): Data analysis\n", "- [numpy](https://www.numpy.org/): Data analysis\n", "- [datetime](https://docs.python.org/3.5/library/datetime.html): Parsing dates\n", "- [wbdata](https://wbdata.readthedocs.io/en/latest/#): World Bank Data API wrapper\n", "\n", - "Then, open up your preferred mode of writing Python. This could be in a [Jupyter Notebook](https://jupyter.org/) using [Jupyter Lab](https://blog.jupyter.org/jupyterlab-is-ready-for-users-5a6f039b8906), using a code editor (like Atom or Visual Studio) + command line, or just from the command line. Now follow the rest of the steps below to retreive and analyze the World Bank data." + "Then, open your preferred mode of writing Python. This could be in a [Jupyter notebook](https://jupyter.org/) with or without [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) or in a code editor or IDE such as [Atom](https://atom.io/), [Visual Studio](https://visualstudio.microsoft.com/), or [PyCharm](https://www.jetbrains.com/pycharm/). \n", + "\n", + "Next, follow the rest of the steps below to retrieve and visualize the World Bank data." ] }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 143, "metadata": {}, "outputs": [], "source": [ "# Import packages\n", - "import pandas as pd\n", - "import numpy as np\n", "import datetime\n", + "import pandas as pd \n", + "import numpy as np\n", "import wbdata" ] }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pandas version: 1.0.3\n", + "NumPy version: 1.18.1\n", + "wbdata version: 0.2.7\n" + ] + } + ], + "source": [ + "# Package versions used in most recent code update (for compatibility)\n", + "print(f\"pandas version: {pd.__version__}\")\n", + "print(f\"NumPy version: {np.__version__}\")\n", + "print(f\"wbdata version: {wbdata.__version__}\")" + ] + }, { "cell_type": "markdown", "metadata": {}, From 105a75f9821774d889bd5c31442e47b2fb8df505 Mon Sep 17 00:00:00 2001 From: discdiver Date: Fri, 1 May 2020 07:51:02 -0400 Subject: [PATCH 4/6] improve readability with edits and switching order --- api-guide/ids-api-guide-python-2.ipynb | 462 +++++++++++++++++-------- 1 file changed, 324 insertions(+), 138 deletions(-) diff --git a/api-guide/ids-api-guide-python-2.ipynb b/api-guide/ids-api-guide-python-2.ipynb index 3db050a..d393495 100644 --- a/api-guide/ids-api-guide-python-2.ipynb +++ b/api-guide/ids-api-guide-python-2.ipynb @@ -48,12 +48,12 @@ "\n", "Then, open your preferred mode of writing Python. This could be in a [Jupyter notebook](https://jupyter.org/) with or without [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) or in a code editor or IDE such as [Atom](https://atom.io/), [Visual Studio](https://visualstudio.microsoft.com/), or [PyCharm](https://www.jetbrains.com/pycharm/). \n", "\n", - "Next, follow the rest of the steps below to retrieve and visualize the World Bank data." + "Next, follow the steps below to retrieve and visualize the World Bank data." ] }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -108,11 +108,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "# Select the indicator\n", "indicatorSelection = {\"DT.DOD.DLXF.CD\":\"ExternalDebtStock\"}" ] }, @@ -144,11 +143,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "# Select the countries or regions\n", "locationSelection = [\"ECA\",\"SSA\",\"SAS\",\"LAC\",\"MNA\",\"EAP\"]" ] }, @@ -162,11 +160,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "# Selecting the time frame\n", "timeSelection = (datetime.datetime(2009, 1, 1), datetime.datetime(2018, 12, 31))" ] }, @@ -180,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -206,16 +203,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this step, we will retrieve the data using the World Bank Data API call. The package [wbdata](https://wbdata.readthedocs.io/en/stable/) created by Oliver Sherouse, can request information from the World Bank database as a dictionary containing full metadata or as a pandas DataFrame. In this example, we will request the data, with the parameters outlined above, as a pandas DataFrame." + "In this step, we will retrieve the data using the World Bank Data API call. \n", + "\n", + "The package [wbdata](https://wbdata.readthedocs.io/en/stable/) created by Oliver Sherouse, can request information from the World Bank database as a dictionary containing full metadata or as a pandas DataFrame. \n", + "\n", + "In this example, we will request the data, with the parameters outlined above, and save it as a pandas DataFrame named `EXD`." ] }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "# Making the API call and assigning the resulting DataFrame to \"EXD\"\n", "EXD = wbdata.get_dataframe(indicatorSelection,\n", " country = locationSelection, \n", " data_date = timeSelection, \n", @@ -231,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -300,23 +300,28 @@ " 2014 1.039942e+12" ] }, - "execution_count": 116, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Print the first 5 lines of the DataFrame\n", "EXD.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make a copy of our DataFrame so we don't need to call the API again if we want to fix something." + ] + }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "# Make a copy of our DataFrame so we don't need to call the API again if we want to fix something.\n", "EXD_df = EXD.copy()" ] }, @@ -337,12 +342,19 @@ "metadata": {}, "source": [ "#### Data Cleaning\n", - "As you saw in the preview of the data in section 3, the DataFrame's format needs to be cleaned up. We want to reshape the data. This will get it ready to present in a table or in a visualization." + "As you saw in the preview of the data in section 3, the DataFrame's format needs to be cleaned up. We want to reshape the data by moving the hierarchical index into the columns and make the `date` column the index. These changes will make the data ready to present in a table or in a visualization." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's move the index into the columns first." ] }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -415,19 +427,26 @@ "4 East Asia & Pacific (excluding high income) 2014 1.039942e+12" ] }, - "execution_count": 118, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "EXD_df = EXD_df.reset_index()\n", - "EXD_df.head()" + "EXD_cleaned = EXD_df.reset_index()\n", + "EXD_cleaned.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Basic statistics" ] }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -448,29 +467,12 @@ } ], "source": [ - "EXD_df.info()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The data for the long-term external debt stock is currently in units. To improve a table's or chart's readability, let's convert the units to billions and round the number to 0 decimal places. " + "EXD_cleaned.info()" ] }, { "cell_type": "code", - "execution_count": 120, - "metadata": {}, - "outputs": [], - "source": [ - "# Change units to billions and round to 0 decimal places\n", - "EXD_df['ExternalDebtStock'] = round(EXD_df['ExternalDebtStock']/1_000_000_000, 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 121, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -501,67 +503,109 @@ " \n", " \n", " \n", - " 0\n", - " East Asia & Pacific (excluding high income)\n", - " 2018\n", - " 1405.0\n", + " count\n", + " 60\n", + " 60\n", + " 6.000000e+01\n", " \n", " \n", - " 1\n", - " East Asia & Pacific (excluding high income)\n", - " 2017\n", - " 1287.0\n", + " unique\n", + " 6\n", + " 10\n", + " NaN\n", " \n", " \n", - " 2\n", - " East Asia & Pacific (excluding high income)\n", - " 2016\n", - " 1171.0\n", + " top\n", + " Sub-Saharan Africa (excluding high income)\n", + " 2015\n", + " NaN\n", " \n", " \n", - " 3\n", - " East Asia & Pacific (excluding high income)\n", - " 2015\n", - " 1037.0\n", + " freq\n", + " 10\n", + " 6\n", + " NaN\n", " \n", " \n", - " 4\n", - " East Asia & Pacific (excluding high income)\n", - " 2014\n", - " 1040.0\n", + " mean\n", + " NaN\n", + " NaN\n", + " 7.196861e+11\n", + " \n", + " \n", + " std\n", + " NaN\n", + " NaN\n", + " 4.553943e+11\n", + " \n", + " \n", + " min\n", + " NaN\n", + " NaN\n", + " 1.417278e+11\n", + " \n", + " \n", + " 25%\n", + " NaN\n", + " NaN\n", + " 3.166273e+11\n", + " \n", + " \n", + " 50%\n", + " NaN\n", + " NaN\n", + " 5.567326e+11\n", + " \n", + " \n", + " 75%\n", + " NaN\n", + " NaN\n", + " 1.177590e+12\n", + " \n", + " \n", + " max\n", + " NaN\n", + " NaN\n", + " 1.534062e+12\n", " \n", " \n", "\n", "" ], "text/plain": [ - " country date ExternalDebtStock\n", - "0 East Asia & Pacific (excluding high income) 2018 1405.0\n", - "1 East Asia & Pacific (excluding high income) 2017 1287.0\n", - "2 East Asia & Pacific (excluding high income) 2016 1171.0\n", - "3 East Asia & Pacific (excluding high income) 2015 1037.0\n", - "4 East Asia & Pacific (excluding high income) 2014 1040.0" + " country date ExternalDebtStock\n", + "count 60 60 6.000000e+01\n", + "unique 6 10 NaN\n", + "top Sub-Saharan Africa (excluding high income) 2015 NaN\n", + "freq 10 6 NaN\n", + "mean NaN NaN 7.196861e+11\n", + "std NaN NaN 4.553943e+11\n", + "min NaN NaN 1.417278e+11\n", + "25% NaN NaN 3.166273e+11\n", + "50% NaN NaN 5.567326e+11\n", + "75% NaN NaN 1.177590e+12\n", + "max NaN NaN 1.534062e+12" ] }, - "execution_count": 121, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "EXD_df.head()" + "EXD_cleaned.describe(include='all')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "These next two sections of code will clean up the naming of headers and regions. First, it will rename the column headers. Second, it will remove the redundant \"(excluding high income)\" from the region names. We can instead include that information in the title of the chart." + "Let's improve the column names." ] }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -595,31 +639,31 @@ " 0\n", " East Asia & Pacific (excluding high income)\n", " 2018\n", - " 1405.0\n", + " 1.404732e+12\n", " \n", " \n", " 1\n", " East Asia & Pacific (excluding high income)\n", " 2017\n", - " 1287.0\n", + " 1.287079e+12\n", " \n", " \n", " 2\n", " East Asia & Pacific (excluding high income)\n", " 2016\n", - " 1171.0\n", + " 1.170963e+12\n", " \n", " \n", " 3\n", " East Asia & Pacific (excluding high income)\n", " 2015\n", - " 1037.0\n", + " 1.037230e+12\n", " \n", " \n", " 4\n", " East Asia & Pacific (excluding high income)\n", " 2014\n", - " 1040.0\n", + " 1.039942e+12\n", " \n", " \n", "\n", @@ -627,62 +671,150 @@ ], "text/plain": [ " Region Year ExternalDebtStock\n", - "0 East Asia & Pacific (excluding high income) 2018 1405.0\n", - "1 East Asia & Pacific (excluding high income) 2017 1287.0\n", - "2 East Asia & Pacific (excluding high income) 2016 1171.0\n", - "3 East Asia & Pacific (excluding high income) 2015 1037.0\n", - "4 East Asia & Pacific (excluding high income) 2014 1040.0" + "0 East Asia & Pacific (excluding high income) 2018 1.404732e+12\n", + "1 East Asia & Pacific (excluding high income) 2017 1.287079e+12\n", + "2 East Asia & Pacific (excluding high income) 2016 1.170963e+12\n", + "3 East Asia & Pacific (excluding high income) 2015 1.037230e+12\n", + "4 East Asia & Pacific (excluding high income) 2014 1.039942e+12" ] }, - "execution_count": 122, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Rename column headers\n", - "EXD_df.columns=['Region', 'Year', 'ExternalDebtStock']\n", - "EXD_df.head()" + "EXD_cleaned.columns=['Region', 'Year', 'ExternalDebtStock']\n", + "EXD_cleaned.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make the `Year` column the index, make it a datetime dtype, and sort it. This will improve the appearance of the DataFrame and make it possible to use pandas plotting methods to visualize the data in a line chart later." ] }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RegionYearExternalDebtStock
Year
2009-01-01Latin America & Caribbean (excluding high income)20097.469656e+11
2009-01-01South Asia20092.933071e+11
2009-01-01Middle East & North Africa (excluding high inc...20091.417278e+11
2009-01-01Europe & Central Asia (excluding high income)20099.504303e+11
2009-01-01East Asia & Pacific (excluding high income)20094.944027e+11
\n", + "
" + ], "text/plain": [ - "Sub-Saharan Africa 10\n", - "South Asia 10\n", - "Middle East & North Africa 10\n", - "East Asia & Pacific 10\n", - "Europe & Central Asia 10\n", - "Latin America & Caribbean 10\n", - "Name: Region, dtype: int64" + " Region Year \\\n", + "Year \n", + "2009-01-01 Latin America & Caribbean (excluding high income) 2009 \n", + "2009-01-01 South Asia 2009 \n", + "2009-01-01 Middle East & North Africa (excluding high inc... 2009 \n", + "2009-01-01 Europe & Central Asia (excluding high income) 2009 \n", + "2009-01-01 East Asia & Pacific (excluding high income) 2009 \n", + "\n", + " ExternalDebtStock \n", + "Year \n", + "2009-01-01 7.469656e+11 \n", + "2009-01-01 2.933071e+11 \n", + "2009-01-01 1.417278e+11 \n", + "2009-01-01 9.504303e+11 \n", + "2009-01-01 4.944027e+11 " ] }, - "execution_count": 123, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Remove \"(excluding high income)\" from each of the region names\n", - "EXD_df[\"Region\"] = EXD_df[\"Region\"].str.replace(\"\\(excluding high income\\)\",\"\")\n", - "EXD_df['Region'].value_counts()" + "EXD_cleaned.index = pd.to_datetime(EXD_cleaned['Year'])\n", + "EXD_cleaned = EXD_cleaned.sort_index()\n", + "EXD_cleaned.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now our data should be ready to present in a table or visualize in a chart. Let's take a look at the first five lines again so we can compare the cleaned up data to the raw output in section 3." + "The data for the long-term external debt stock is currently in units. To improve readability, let's convert the units to billions and round the number to 0 decimal places. " ] }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "EXD_cleaned['ExternalDebtStock'] = round(EXD_cleaned['ExternalDebtStock']/1_000_000_000, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -710,70 +842,119 @@ " Year\n", " ExternalDebtStock\n", " \n", + " \n", + " Year\n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", - " 0\n", - " East Asia & Pacific\n", - " 2018\n", - " 1405.0\n", + " 2009-01-01\n", + " Latin America & Caribbean (excluding high income)\n", + " 2009\n", + " 747.0\n", " \n", " \n", - " 1\n", - " East Asia & Pacific\n", - " 2017\n", - " 1287.0\n", + " 2009-01-01\n", + " South Asia\n", + " 2009\n", + " 293.0\n", " \n", " \n", - " 2\n", - " East Asia & Pacific\n", - " 2016\n", - " 1171.0\n", + " 2009-01-01\n", + " Middle East & North Africa (excluding high inc...\n", + " 2009\n", + " 142.0\n", " \n", " \n", - " 3\n", - " East Asia & Pacific\n", - " 2015\n", - " 1037.0\n", + " 2009-01-01\n", + " Europe & Central Asia (excluding high income)\n", + " 2009\n", + " 950.0\n", " \n", " \n", - " 4\n", - " East Asia & Pacific\n", - " 2014\n", - " 1040.0\n", + " 2009-01-01\n", + " East Asia & Pacific (excluding high income)\n", + " 2009\n", + " 494.0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Region Year ExternalDebtStock\n", - "0 East Asia & Pacific 2018 1405.0\n", - "1 East Asia & Pacific 2017 1287.0\n", - "2 East Asia & Pacific 2016 1171.0\n", - "3 East Asia & Pacific 2015 1037.0\n", - "4 East Asia & Pacific 2014 1040.0" + " Region Year \\\n", + "Year \n", + "2009-01-01 Latin America & Caribbean (excluding high income) 2009 \n", + "2009-01-01 South Asia 2009 \n", + "2009-01-01 Middle East & North Africa (excluding high inc... 2009 \n", + "2009-01-01 Europe & Central Asia (excluding high income) 2009 \n", + "2009-01-01 East Asia & Pacific (excluding high income) 2009 \n", + "\n", + " ExternalDebtStock \n", + "Year \n", + "2009-01-01 747.0 \n", + "2009-01-01 293.0 \n", + "2009-01-01 142.0 \n", + "2009-01-01 950.0 \n", + "2009-01-01 494.0 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "EXD_cleaned.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's remove the redundant \"(excluding high income)\" from the region names. We can include that information in the title of the chart instead." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Middle East & North Africa 10\n", + "East Asia & Pacific 10\n", + "Europe & Central Asia 10\n", + "Latin America & Caribbean 10\n", + "South Asia 10\n", + "Sub-Saharan Africa 10\n", + "Name: Region, dtype: int64" ] }, - "execution_count": 124, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "EXD_df.head()" + "EXD_cleaned[\"Region\"] = EXD_cleaned[\"Region\"].str.replace(\"\\(excluding high income\\)\",\"\")\n", + "EXD_cleaned['Region'].value_counts()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Make the `Year` column the index and make it a datetime dtype." + "Now our data should be ready to present in a table or visualize in a chart. Let's take a look at the first five rows again so we can compare the cleaned up data to the raw output in section 3." ] }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -853,15 +1034,13 @@ "2009-01-01 East Asia & Pacific 2009 494.0" ] }, - "execution_count": 125, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "EXD_df.index = pd.to_datetime(EXD_df['Year'])\n", - "EXD_df = EXD_df.sort_index()\n", - "EXD_df.head()" + "EXD_cleaned.head()" ] }, { @@ -880,7 +1059,7 @@ }, { "cell_type": "code", - "execution_count": 139, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -897,7 +1076,7 @@ } ], "source": [ - "EXD_df.groupby('Region')['ExternalDebtStock'].plot(\n", + "EXD_cleaned.groupby('Region')['ExternalDebtStock'].plot(\n", " kind='line', \n", " legend='Region',\n", " figsize=(10, 8),\n", @@ -905,6 +1084,13 @@ ");" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feel free to explore the data by modifying the chart or making your own!" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -913,7 +1099,7 @@ "\n", "You've seen how to retrieve data from the World Bank API and use it to make a visualization! \n", "\n", - "We can't wait to see what interesting insights you can uncover with data from World Bank! 🌍" + "We can't wait to see what interesting insights you uncover with data from World Bank! 🌍" ] } ], From 9c4552b74b9922eb4325a3c6ecbcab448fd37d49 Mon Sep 17 00:00:00 2001 From: discdiver Date: Fri, 1 May 2020 07:54:20 -0400 Subject: [PATCH 5/6] create .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6bed033 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*.ipynb_checkpoints/ \ No newline at end of file From f6235a9506c5ae1bebda1bffd2e0d2388e34dad1 Mon Sep 17 00:00:00 2001 From: discdiver Date: Fri, 1 May 2020 07:59:55 -0400 Subject: [PATCH 6/6] create html version of second python notebook --- api-guide/ids-api-guide-python-2.html | 1020 ++++++++++++++++++++----- 1 file changed, 815 insertions(+), 205 deletions(-) diff --git a/api-guide/ids-api-guide-python-2.html b/api-guide/ids-api-guide-python-2.html index 9854e5f..6ea55ad 100644 --- a/api-guide/ids-api-guide-python-2.html +++ b/api-guide/ids-api-guide-python-2.html @@ -13017,45 +13017,6 @@ .highlight .vm { color: #19177C } /* Name.Variable.Magic */ .highlight .il { color: #666666 } /* Literal.Number.Integer.Long */ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ExternalDebtStock
countrydate
East Asia & Pacific (excluding high income)20181.404732e+12
20171.287079e+12
20161.170963e+12
20151.037230e+12
20141.039942e+12
+ + + + + + + + + +
+
+
+

Let's make a copy of our DataFrame so we don't need to call the API again if we want to fix something.

+ +
+
+
+
In [9]:
+
+
+
EXD_df = EXD.copy()
+
+
@@ -13415,96 +13470,484 @@

4. Explore the data!
-

Data Cleaning

As you saw in the preview of the data in section 3, the DataFrame's format needs to be cleaned up. We want to reshape the data. This will get it ready to present in a table or in a visualization.

+

Data Cleaning

As you saw in the preview of the data in section 3, the DataFrame's format needs to be cleaned up. We want to reshape the data by moving the hierarchical index into the columns and make the date column the index. These changes will make the data ready to present in a table or in a visualization.

+ +
+
+

+
+
+
+

Let's move the index into the columns first.

-
In [8]:
+
In [10]:
-
# Reshape the data
-EXDreshaped = pd.DataFrame(EXD.to_records())
+
EXD_cleaned = EXD_df.reset_index()
+EXD_cleaned.head()
 
+
+
+ + +
+ +
Out[10]:
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
countrydateExternalDebtStock
0East Asia & Pacific (excluding high income)20181.404732e+12
1East Asia & Pacific (excluding high income)20171.287079e+12
2East Asia & Pacific (excluding high income)20161.170963e+12
3East Asia & Pacific (excluding high income)20151.037230e+12
4East Asia & Pacific (excluding high income)20141.039942e+12
+
+
+ +
+ +
+
+
-

The data for the long-term external debt stock is currently in units. To improve a table's or chart's readability, convert the units to billions and round the number to 0 decimal places. To do this, create a function called "formatNum" that you can then run on your DataFrame.

+

Basic statistics

+
+
+
+
+
+
In [11]:
+
+
+
EXD_cleaned.info()
+
+
+
+ +
+
+ + +
+ +
+ + +
+
<class 'pandas.core.frame.DataFrame'>
+RangeIndex: 60 entries, 0 to 59
+Data columns (total 3 columns):
+ #   Column             Non-Null Count  Dtype  
+---  ------             --------------  -----  
+ 0   country            60 non-null     object 
+ 1   date               60 non-null     object 
+ 2   ExternalDebtStock  60 non-null     float64
+dtypes: float64(1), object(2)
+memory usage: 1.5+ KB
+
+
+
+
+
+
-
In [9]:
+
In [12]:
-
# Creating a function that will change units to billions and round to 0 decimal places
-def formatNum(x):
-    y = x/1000000000
-    z = round(y)
-    return(z)
-
-# Running the function on the desired data column
-EXDreshaped.ExternalDebtStock = formatNum(EXDreshaped.ExternalDebtStock)
+
EXD_cleaned.describe(include='all')
 
+
+
+ + +
+ +
Out[12]:
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
countrydateExternalDebtStock
count60606.000000e+01
unique610NaN
topSub-Saharan Africa (excluding high income)2015NaN
freq106NaN
meanNaNNaN7.196861e+11
stdNaNNaN4.553943e+11
minNaNNaN1.417278e+11
25%NaNNaN3.166273e+11
50%NaNNaN5.567326e+11
75%NaNNaN1.177590e+12
maxNaNNaN1.534062e+12
+
+
+ +
+ +
+
+
-

These next two sections of code will clean up the naming of headers and regions. First, it will rename the column headers. Second, it will remove the redundant "(excluding high income)" from the region names. We can instead include that information in the title of the chart.

+

Let's improve the column names.

-
In [10]:
+
In [13]:
-
# Renaming column headers
-EXDclean = EXDreshaped.rename(index=str, columns={
-    "date":"Year",
-    "country":"Region",
-})
+
EXD_cleaned.columns=['Region', 'Year', 'ExternalDebtStock']
+EXD_cleaned.head()
 
+
+
+ + +
+ +
Out[13]:
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
RegionYearExternalDebtStock
0East Asia & Pacific (excluding high income)20181.404732e+12
1East Asia & Pacific (excluding high income)20171.287079e+12
2East Asia & Pacific (excluding high income)20161.170963e+12
3East Asia & Pacific (excluding high income)20151.037230e+12
4East Asia & Pacific (excluding high income)20141.039942e+12
+
+
+ +
+ +
+
+ +
+
+
+
+

Make the Year column the index, make it a datetime dtype, and sort it. This will improve the appearance of the DataFrame and make it possible to use pandas plotting methods to visualize the data in a line chart later.

+ +
+
-
In [15]:
+
In [14]:
-
# Remove the "(excluding high income)" from each of the region names
-EXDclean["Region"] = EXDclean["Region"].str.replace("excluding high income","").str.replace(")","").str.replace("(","")
+
EXD_cleaned.index = pd.to_datetime(EXD_cleaned['Year'])
+EXD_cleaned = EXD_cleaned.sort_index()
+EXD_cleaned.head()
 
+
+
+ + +
+ +
Out[14]:
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
RegionYearExternalDebtStock
Year
2009-01-01Latin America & Caribbean (excluding high income)20097.469656e+11
2009-01-01South Asia20092.933071e+11
2009-01-01Middle East & North Africa (excluding high inc...20091.417278e+11
2009-01-01Europe & Central Asia (excluding high income)20099.504303e+11
2009-01-01East Asia & Pacific (excluding high income)20094.944027e+11
+
+
+ +
+ +
+
+
-

Now our data should be ready to present in a table or visualize in a chart. Let's take a look at the first five lines again so we can compare the cleaned up data to the raw output in section 3.

+

The data for the long-term external debt stock is currently in units. To improve readability, let's convert the units to billions and round the number to 0 decimal places.

@@ -13514,7 +13957,20 @@

Data CleaningIn [20]:

-
print(EXDclean.head())
+
EXD_cleaned['ExternalDebtStock'] = round(EXD_cleaned['ExternalDebtStock']/1_000_000_000, 0)
+
+ +
+
+
+ +
+
-
In [13]:
+
In [17]:
-
# Defining the data source
-source = EXDclean
-
-# Creating the chart
-chart = px.line(EXDclean, 
-                x="Year",
-                y="ExternalDebtStock",
-                color="Region",
-                title="Regional Long-term External Debt Stock (excluding High-Income countries)(USD billion)")
-chart.update_layout(
-                plot_bgcolor="white")
-
-# Displaying the chart
-chart
+
EXD_cleaned["Region"] = EXD_cleaned["Region"].str.replace("\(excluding high income\)","")
+EXD_cleaned['Region'].value_counts()
 
@@ -13584,92 +14086,200 @@

Data Visualization -
+
Out[17]:
-
- - + +
+
Middle East & North Africa     10
+East Asia & Pacific            10
+Europe & Central Asia          10
+Latin America & Caribbean      10
+South Asia                     10
+Sub-Saharan Africa             10
+Name: Region, dtype: int64
+
+ +
+ +

+
+
+
+
+
+

Now our data should be ready to present in a table or visualize in a chart. Let's take a look at the first five rows again so we can compare the cleaned up data to the raw output in section 3.

+ +
+
+
+
+
+
In [18]:
+
+
+
EXD_cleaned.head()
+
+
+
+ +
+
+
-
+
Out[18]:
-
+
- - -
- -
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
RegionYearExternalDebtStock
Year
2009-01-01Latin America & Caribbean2009747.0
2009-01-01South Asia2009293.0
2009-01-01Middle East & North Africa2009142.0
2009-01-01Europe & Central Asia2009950.0
2009-01-01East Asia & Pacific2009494.0
+
+
+
+
+
+
+
+
+
+

Let's make a basic line graph with pandas (using Matplotlib as the backend plotting engine).

+
+
+
+
+
+
In [19]:
+
+
+
EXD_cleaned.groupby('Region')['ExternalDebtStock'].plot(
+    kind='line', 
+    legend='Region',
+    figsize=(10, 8),
+    title="Regional Long-term External Debt Stock (excluding High-Income countries)(USD billion)"
+);
+
+ +
+
+
+ +
+
+ + +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
+

Feel free to explore the data by modifying the chart or making your own!

+ +
+
+
+
+
+
+

Summary

You've seen how to retrieve data from the World Bank API and use it to make a visualization!

+

We can't wait to see what interesting insights you uncover with data from World Bank! 🌍

+ +
+