From 97142f898417dbea3275417cde777710f498a054 Mon Sep 17 00:00:00 2001 From: siddharm Date: Thu, 13 Aug 2020 19:29:52 -0400 Subject: [PATCH] created the stacked line charts --- Language-Date visualizations.ipynb | 784 ++++++++++++++--------------- 1 file changed, 371 insertions(+), 413 deletions(-) diff --git a/Language-Date visualizations.ipynb b/Language-Date visualizations.ipynb index 1834308..91792a3 100644 --- a/Language-Date visualizations.ipynb +++ b/Language-Date visualizations.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 206, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 207, "metadata": {}, "outputs": [ { @@ -26,7 +26,7 @@ "\"\\nfig1, ax1 = plt.subplots()\\nax1.pie(lang[lang.columns[1]], labels=lang[lang.columns[0]], autopct='%1.1f%%',\\n shadow=True, startangle=90)\\nax1.axis('equal')\\n\"" ] }, - "execution_count": 3, + "execution_count": 207, "metadata": {}, "output_type": "execute_result" } @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 208, "metadata": {}, "outputs": [ { @@ -101,7 +101,7 @@ " 1.1000514928489695)" ] }, - "execution_count": 4, + "execution_count": 208, "metadata": {}, "output_type": "execute_result" }, @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 209, "metadata": {}, "outputs": [], "source": [ @@ -177,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 161, + "execution_count": 210, "metadata": {}, "outputs": [ { @@ -200,208 +200,225 @@ "\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", - " \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", + " \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", + " \n", " \n", " \n", "
LanguageYearJavaCC++PythonRubyShell
0Java20080.0000000.5780530.0580890.3613690.0000000.002489
1C20090.0000000.0016070.4176360.5665790.0000000.014178
2C++20100.0000000.0091530.2706740.7161610.0000000.004011
3Python20110.0000000.1391550.0242590.7860910.0000000.050494
4R20120.0178040.4566890.1401290.3338530.0000000.051525
5Fortran20130.2401660.3964100.1659450.1679470.0149560.014577
6Ruby20140.1314480.3736470.1639970.3164730.0000000.014435
7HTML20150.0016000.2194180.2097170.2913590.2695030.008403
8Shell20160.0323610.2059680.2348690.4896170.0155210.021665
9Others20170.0000000.1375360.4250450.2367150.0000030.200702
20180.0007080.1862190.2086670.5708270.0000050.033575
20190.1928660.1363250.1532220.5136840.0000000.003903
2020NaNNaNNaNNaNNaNNaN
\n", "" ], "text/plain": [ - " Language\n", - "0 Java\n", - "1 C\n", - "2 C++\n", - "3 Python\n", - "4 R\n", - "5 Fortran\n", - "6 Ruby\n", - "7 HTML\n", - "8 Shell\n", - "9 Others" + "Year Java C C++ Python Ruby Shell\n", + "2008 0.000000 0.578053 0.058089 0.361369 0.000000 0.002489\n", + "2009 0.000000 0.001607 0.417636 0.566579 0.000000 0.014178\n", + "2010 0.000000 0.009153 0.270674 0.716161 0.000000 0.004011\n", + "2011 0.000000 0.139155 0.024259 0.786091 0.000000 0.050494\n", + "2012 0.017804 0.456689 0.140129 0.333853 0.000000 0.051525\n", + "2013 0.240166 0.396410 0.165945 0.167947 0.014956 0.014577\n", + "2014 0.131448 0.373647 0.163997 0.316473 0.000000 0.014435\n", + "2015 0.001600 0.219418 0.209717 0.291359 0.269503 0.008403\n", + "2016 0.032361 0.205968 0.234869 0.489617 0.015521 0.021665\n", + "2017 0.000000 0.137536 0.425045 0.236715 0.000003 0.200702\n", + "2018 0.000708 0.186219 0.208667 0.570827 0.000005 0.033575\n", + "2019 0.192866 0.136325 0.153222 0.513684 0.000000 0.003903\n", + "2020 NaN NaN NaN NaN NaN NaN" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "trying Java in year 2008\n", - "trying C in year 2008\n", - "trying C++ in year 2008\n", - "trying Python in year 2008\n", - "trying R in year 2008\n", - "trying Fortran in year 2008\n", - "trying Ruby in year 2008\n", - "trying HTML in year 2008\n", - "trying Shell in year 2008\n", - "trying Others in year 2008\n", - "trying Java in year 2009\n", - "trying C in year 2009\n", - "trying C++ in year 2009\n", - "trying Python in year 2009\n", - "trying R in year 2009\n", - "trying Fortran in year 2009\n", - "trying Ruby in year 2009\n", - "trying HTML in year 2009\n", - "trying Shell in year 2009\n", - "trying Others in year 2009\n", - "trying Java in year 2010\n", - "trying C in year 2010\n", - "trying C++ in year 2010\n", - "trying Python in year 2010\n", - "trying R in year 2010\n", - "trying Fortran in year 2010\n", - "trying Ruby in year 2010\n", - "trying HTML in year 2010\n", - "trying Shell in year 2010\n", - "trying Others in year 2010\n", - "trying Java in year 2011\n", - "trying C in year 2011\n", - "trying C++ in year 2011\n", - "trying Python in year 2011\n", - "trying R in year 2011\n", - "trying Fortran in year 2011\n", - "trying Ruby in year 2011\n", - "trying HTML in year 2011\n", - "trying Shell in year 2011\n", - "trying Others in year 2011\n", - "trying Java in year 2012\n", - "trying C in year 2012\n", - "trying C++ in year 2012\n", - "trying Python in year 2012\n", - "trying R in year 2012\n", - "trying Fortran in year 2012\n", - "trying Ruby in year 2012\n", - "trying HTML in year 2012\n", - "trying Shell in year 2012\n", - "trying Others in year 2012\n", - "trying Java in year 2013\n", - "trying C in year 2013\n", - "trying C++ in year 2013\n", - "trying Python in year 2013\n", - "trying R in year 2013\n", - "trying Fortran in year 2013\n", - "trying Ruby in year 2013\n", - "trying HTML in year 2013\n", - "trying Shell in year 2013\n", - "trying Others in year 2013\n", - "trying Java in year 2014\n", - "trying C in year 2014\n", - "trying C++ in year 2014\n", - "trying Python in year 2014\n", - "trying R in year 2014\n", - "trying Fortran in year 2014\n", - "trying Ruby in year 2014\n", - "trying HTML in year 2014\n", - "trying Shell in year 2014\n", - "trying Others in year 2014\n", - "trying Java in year 2015\n", - "trying C in year 2015\n", - "trying C++ in year 2015\n", - "trying Python in year 2015\n", - "trying R in year 2015\n", - "trying Fortran in year 2015\n", - "trying Ruby in year 2015\n", - "trying HTML in year 2015\n", - "trying Shell in year 2015\n", - "trying Others in year 2015\n", - "trying Java in year 2016\n", - "trying C in year 2016\n", - "trying C++ in year 2016\n", - "trying Python in year 2016\n", - "trying R in year 2016\n", - "trying Fortran in year 2016\n", - "trying Ruby in year 2016\n", - "trying HTML in year 2016\n", - "trying Shell in year 2016\n", - "trying Others in year 2016\n", - "trying Java in year 2017\n", - "trying C in year 2017\n", - "trying C++ in year 2017\n", - "trying Python in year 2017\n", - "trying R in year 2017\n", - "trying Fortran in year 2017\n", - "trying Ruby in year 2017\n", - "trying HTML in year 2017\n", - "trying Shell in year 2017\n", - "trying Others in year 2017\n", - "trying Java in year 2018\n", - "trying C in year 2018\n", - "trying C++ in year 2018\n", - "trying Python in year 2018\n", - "trying R in year 2018\n", - "trying Fortran in year 2018\n", - "trying Ruby in year 2018\n", - "trying HTML in year 2018\n", - "trying Shell in year 2018\n", - "trying Others in year 2018\n", - "trying Java in year 2019\n", - "trying C in year 2019\n", - "trying C++ in year 2019\n", - "trying Python in year 2019\n", - "trying R in year 2019\n", - "trying Fortran in year 2019\n", - "trying Ruby in year 2019\n", - "trying HTML in year 2019\n", - "trying Shell in year 2019\n", - "trying Others in year 2019\n", - "trying Java in year 2020\n", - "trying C in year 2020\n", - "trying C++ in year 2020\n", - "trying Python in year 2020\n", - "trying R in year 2020\n", - "trying Fortran in year 2020\n", - "trying Ruby in year 2020\n", - "trying HTML in year 2020\n", - "trying Shell in year 2020\n", - "trying Others in year 2020\n" - ] - }, + } + ], + "source": [ + "#link to how to get stacked area chart\n", + "#https://python-graph-gallery.com/255-percentage-stacked-area-chart/\n", + "\n", + "#x axis - year\n", + "#y axis - percentage of the total\n", + "#for each language, we need an array of languages over years\n", + "\n", + "#let's only take a look at the most popular languages\n", + "\n", + "#each language is a separate row\n", + "#each column is a year, and each cell represents the bytes of that language in that year\n", + "\n", + "repo_years = np.sort(df.repo_year.unique())\n", + "\n", + "#can use either of these, or define your own subset to get different information\n", + "most_bytes_langs = ['Java', 'C', 'C++', 'Python', 'R', 'Fortran', 'Ruby', 'HTML', 'Shell', 'Others']\n", + "language_subset = ['Java', 'C', 'C++', 'Python', 'Ruby', 'Shell']\n", + "\n", + "requested_langs = language_subset\n", + "repo_df = pd.DataFrame({'Language': requested_langs})\n", + "\n", + "def bytes_that_year(row, year):\n", + " #print('trying ' + row['Language'] + ' in year ' + str(year))\n", + " \n", + " if row['Language'] == 'Others':\n", + " #sum up all the non-request_langs bytes\n", + " return df[ ~(df['Language'].isin(requested_langs)) & (df['repo_year'] == year)]['Bytes'].sum()\n", + " lang = row['Language']\n", + " \n", + " try:\n", + " return df[df['repo_year'] == year].groupby('Language').sum().loc[lang]['Bytes']\n", + " except:\n", + " return 0\n", + "\n", + " \n", + "#for each year in repo_years, create a column\n", + "# each cell will be the number of bytes in that year for that language \n", + "\n", + "for year in repo_years:\n", + " #create columns for the total number of bytes\n", + " arr = repo_df.apply (lambda row: bytes_that_year(row, year), axis=1)\n", + " #col_name = str(year) + \" bytes\"\n", + " #repo_df[col_name] = arr\n", + " total_bytes = arr.sum()\n", + " pct_col_name = str(year) #+ \" pct\"\n", + " repo_df[pct_col_name] = arr.divide(total_bytes)\n", + "\n", + "#display(repo_df)\n", + "\n", + "\n", + "#need to get the whole df sideways to make the stackchart easy\n", + "repo_df = repo_df.T\n", + "new_header = repo_df.iloc[0] \n", + "repo_df = repo_df[1:]\n", + "repo_df.columns = new_header\n", + "\n", + "repo_df.columns.name = 'Year'\n", + "repo_df = repo_df.apply(pd.to_numeric, errors='coerce')\n", + "display(repo_df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [ { "data": { "text/html": [ @@ -422,234 +439,152 @@ "\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", + " \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", + " \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", " \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", - " \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", - " \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", "
Language2008 bytes2009 bytes2010 bytes2011 bytes2012 bytes2013 bytes2014 bytes2015 bytes2016 bytes2017 bytes2018 bytes2019 bytes2020 bytesYearJavaCC++PythonRubyShell
0Java0.00.00.00.01401162.042933030.014083813.0296924.02638211.00.02.828600e+041732024.00.020080.0000000.5780530.0580890.3613690.0000000.002489
20090.0000000.0016340.4246160.5593350.0000000.014415
20100.0000000.0181080.7428810.2352320.0000000.003779
20110.0000000.1327690.0248020.7908380.0000000.051591
1C732140.05396.0134128.02912534.035940777.070863794.040033787.040715157.016791222.027935931.07.443884e+061224262.00.020120.0181740.4630170.1359440.3302770.0000000.052587
2C++73573.01402452.03966318.0507749.011027923.029664973.017571170.038915066.019147323.086334220.08.341191e+061376004.00.020130.2452340.3948220.1682730.1615160.0152710.014883
3Python457697.01902611.010494246.016452958.026273713.030022866.033908005.054064633.039915315.048081048.02.281809e+074613109.00.020140.1356500.3842750.1687590.2967890.0000000.014526
4R0.00.00.05473.0131963.0832599.0161349.0230893.086513.0969179.00.000000e+00870358.00.020150.0017230.2145730.2251170.2593760.2902720.008939
5Fortran0.02826100.00.03665668.0106958019.010561397.011857286.059772042.07302514.025221003.03.025633e+074989103.01782.020160.0336680.2128530.2366410.4782050.0161470.022486
6Ruby0.00.00.00.00.02673561.00.050009073.01265301.0522.01.850000e+020.00.020170.0000000.1373410.4123990.2339960.0000030.216262
7HTML0.00.00.03339.07672931.069808148.02625860.0129641.07977816.05191228.01.898321e+060.00.020180.0007250.1896090.2137740.5616290.0000050.034258
8Shell3153.047612.058778.01056847.04054943.02605824.01546652.01559203.01766204.040766099.01.342099e+0635050.00.020190.2556980.1722780.0706550.4989160.0000000.002454
9Others3441.0222938.0817757.03343580.085308437.034670998.050389592.0169066350.0108228261.0138933263.01.107641e+0921152630.02501.02020NaNNaNNaNNaNNaNNaN
\n", "" ], "text/plain": [ - " Language 2008 bytes 2009 bytes 2010 bytes 2011 bytes 2012 bytes \\\n", - "0 Java 0.0 0.0 0.0 0.0 1401162.0 \n", - "1 C 732140.0 5396.0 134128.0 2912534.0 35940777.0 \n", - "2 C++ 73573.0 1402452.0 3966318.0 507749.0 11027923.0 \n", - "3 Python 457697.0 1902611.0 10494246.0 16452958.0 26273713.0 \n", - "4 R 0.0 0.0 0.0 5473.0 131963.0 \n", - "5 Fortran 0.0 2826100.0 0.0 3665668.0 106958019.0 \n", - "6 Ruby 0.0 0.0 0.0 0.0 0.0 \n", - "7 HTML 0.0 0.0 0.0 3339.0 7672931.0 \n", - "8 Shell 3153.0 47612.0 58778.0 1056847.0 4054943.0 \n", - "9 Others 3441.0 222938.0 817757.0 3343580.0 85308437.0 \n", - "\n", - " 2013 bytes 2014 bytes 2015 bytes 2016 bytes 2017 bytes \\\n", - "0 42933030.0 14083813.0 296924.0 2638211.0 0.0 \n", - "1 70863794.0 40033787.0 40715157.0 16791222.0 27935931.0 \n", - "2 29664973.0 17571170.0 38915066.0 19147323.0 86334220.0 \n", - "3 30022866.0 33908005.0 54064633.0 39915315.0 48081048.0 \n", - "4 832599.0 161349.0 230893.0 86513.0 969179.0 \n", - "5 10561397.0 11857286.0 59772042.0 7302514.0 25221003.0 \n", - "6 2673561.0 0.0 50009073.0 1265301.0 522.0 \n", - "7 69808148.0 2625860.0 129641.0 7977816.0 5191228.0 \n", - "8 2605824.0 1546652.0 1559203.0 1766204.0 40766099.0 \n", - "9 34670998.0 50389592.0 169066350.0 108228261.0 138933263.0 \n", - "\n", - " 2018 bytes 2019 bytes 2020 bytes \n", - "0 2.828600e+04 1732024.0 0.0 \n", - "1 7.443884e+06 1224262.0 0.0 \n", - "2 8.341191e+06 1376004.0 0.0 \n", - "3 2.281809e+07 4613109.0 0.0 \n", - "4 0.000000e+00 870358.0 0.0 \n", - "5 3.025633e+07 4989103.0 1782.0 \n", - "6 1.850000e+02 0.0 0.0 \n", - "7 1.898321e+06 0.0 0.0 \n", - "8 1.342099e+06 35050.0 0.0 \n", - "9 1.107641e+09 21152630.0 2501.0 " + "Year Java C C++ Python Ruby Shell\n", + "2008 0.000000 0.578053 0.058089 0.361369 0.000000 0.002489\n", + "2009 0.000000 0.001634 0.424616 0.559335 0.000000 0.014415\n", + "2010 0.000000 0.018108 0.742881 0.235232 0.000000 0.003779\n", + "2011 0.000000 0.132769 0.024802 0.790838 0.000000 0.051591\n", + "2012 0.018174 0.463017 0.135944 0.330277 0.000000 0.052587\n", + "2013 0.245234 0.394822 0.168273 0.161516 0.015271 0.014883\n", + "2014 0.135650 0.384275 0.168759 0.296789 0.000000 0.014526\n", + "2015 0.001723 0.214573 0.225117 0.259376 0.290272 0.008939\n", + "2016 0.033668 0.212853 0.236641 0.478205 0.016147 0.022486\n", + "2017 0.000000 0.137341 0.412399 0.233996 0.000003 0.216262\n", + "2018 0.000725 0.189609 0.213774 0.561629 0.000005 0.034258\n", + "2019 0.255698 0.172278 0.070655 0.498916 0.000000 0.002454\n", + "2020 NaN NaN NaN NaN NaN NaN" ] }, "metadata": {}, @@ -657,36 +592,21 @@ } ], "source": [ - "#link to how to get stacked area chart\n", - "#https://python-graph-gallery.com/255-percentage-stacked-area-chart/\n", - "\n", - "#x axis - year\n", - "#y axis - percentage of the total\n", - "#for each language, we need an array of languages over years\n", - "\n", - "#let's only take a look at the most popular languages\n", - "\n", - "#each language is a separate row\n", - "#each column is a year, and each cell represents the bytes of that language in that year\n", + "#Now, do the same for ascl_year instead of github repo_year\n", + "ascl_years = np.sort(df.ascl_year.unique())\n", "\n", - "top_langs = most['Language']\n", - "#display(top_langs)\n", - "repo_years = np.sort(df.repo_year.unique())\n", + "#drop all the codes where the ascl_year is 0 (they have no ascl-id)\n", + "df = df[df['ascl_year'] != 0]\n", "\n", - "#repo_df = pd.DataFrame({'Language': top_langs})\n", - "most_bytes_langs = ['Java', 'C', 'C++', 'Python', 'R', 'Fortran', 'Ruby', 'HTML', 'Shell', 'Others']\n", - "repo_df = pd.DataFrame({'Language': most_bytes_langs})\n", - "display(repo_df)\n", + "ascl_df = pd.DataFrame({'Language': requested_langs})\n", "\n", - "#for each year in repo_years, create a column\n", - "# each cell will be the number of bytes in that year for that language\n", "\n", - "def bytes_that_year(row, year):\n", - " print('trying ' + row['Language'] + ' in year ' + str(year))\n", + "def bytes_that_year_ascl(row, year):\n", + " #print('trying ' + row['Language'] + ' in year ' + str(year))\n", " \n", " if row['Language'] == 'Others':\n", - " #sum up all the non-most_bytes_langs bytes\n", - " return df[ ~(df['Language'].isin(most_bytes_langs)) & (df['repo_year'] == year)]['Bytes'].sum()\n", + " #sum up all the non-request_langs bytes\n", + " return df[ ~(df['Language'].isin(requested_langs)) & (df['ascl_year'] == year)]['Bytes'].sum()\n", " lang = row['Language']\n", " \n", " try:\n", @@ -696,33 +616,71 @@ "\n", "for year in repo_years:\n", " #create columns for the total number of bytes\n", - " arr = repo_df.apply (lambda row: bytes_that_year(row, year), axis=1)\n", - " col_name = str(year) + \" bytes\"\n", - " repo_df[col_name] = arr\n", - " \n", - " \n", + " arr = ascl_df.apply (lambda row: bytes_that_year_ascl(row, year), axis=1)\n", + " total_bytes = arr.sum()\n", + " pct_col_name = str(year) #+ \" pct\"\n", + " ascl_df[pct_col_name] = arr.divide(total_bytes)\n", "\n", - " \n", - "display(repo_df)\n", - "#display(df[df['repo_year'] == 2019].groupby('Language').sum().loc['C']['Bytes'])" + "ascl_df = ascl_df.T\n", + "new_header = ascl_df.iloc[0] \n", + "ascl_df = ascl_df[1:]\n", + "ascl_df.columns = new_header\n", + "\n", + "ascl_df.columns.name = 'Year'\n", + "ascl_df = ascl_df.apply(pd.to_numeric, errors='coerce')\n", + "display(ascl_df)\n" ] }, { "cell_type": "code", - "execution_count": 159, + "execution_count": 212, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "138933263" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], - "source": [] + "source": [ + "#now, let's create the stacked area chart\n", + "\n", + "plt.stackplot( repo_df.index.values, repo_df.T )\n", + "plt.legend(bbox_to_anchor=(1.25, 1), labels=repo_df.columns)\n", + "plt.margins(0,0)\n", + "plt.title('ASCL Language Data Over the Years (Github Years)')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('% of total language use')\n", + "plt.show()\n", + "\n", + "\n", + "plt.stackplot( ascl_df.index.values, ascl_df.T )\n", + "plt.legend(bbox_to_anchor=(1.25, 1), labels=ascl_df.columns)\n", + "plt.margins(0,0)\n", + "plt.title('ASCL Language Data Over the Years (ASCL Years)')\n", + "plt.xlabel('Year')\n", + "plt.ylabel('% of total language use')\n", + "plt.show()" + ] } ], "metadata": {