{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# CS237: Pandas Data Analysis Library\n", "\n", "In this document, we will start to learn about the Pandas library for data analysis. Pandas is part of the Anaconda distribution, and there are decent tutorials on most aspects of Pandas; I would recommend the following:\n", "\n", "Pandas Tutorial: http://pandas.pydata.org/pandas-docs/stable/tutorials.html\n", "\n", "Basic functionality: http://pandas.pydata.org/pandas-docs/stable/basics.html\n", "\n", "Indexing and selecting data: http://pandas.pydata.org/pandas-docs/stable/indexing.html\n", "\n", "There are three problems, the first an extended tutorial, and the last two actual problems. You should read through problem 0 carefully, perhaps with a partner, and try all the examples. Problems 1 and 2 are actual activities based on the material in problem 0, you should do these yourself to hand in with the homework." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Imports for homeworks. \n", "\n", "import numpy as np # arrays and functions which operate on array\n", "import matplotlib.pyplot as plt # normal plotting\n", "import pandas as pd # Data input and manipulation\n", "\n", "from numpy.random import random, randint, uniform, choice, shuffle\n", "from collections import Counter\n", "\n", "%matplotlib inline\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem Zero: Basic Pandas data manipulation\n", "\n", "We will first learn how to read data sets from a text or CSV (\"Comma Separated Values\") file, understand the DataFrame data structure, and learn how to extract data from a dataframe; then we will understand how to select rows and columns from a table, and to apply various functions to tables; finally, we will learn how to display histograms of the data. There is a LOT of complexity in all these various aspects of Pandas, but we will learn a \"novice subset\" of the most important features.\n", "\n", "Note: There is a lot of reading and thinking to do in this first problem; when we want you to do something on your own computer, we will indicate it with a **TODO**. There will be nothing to hand in for this problem, but **PLEASE DO NOT SKIP ANY OF THIS**!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Data as Tables\n", "\n", "The basic form of the data sets manipulated in Pandas (and indeed in all modern database systems) is a 2D table of data with rows and columns; for example, here is a data set we will use as an example:\n", "\n", "| Userid | Gender | ClassYear | GPA | Credits | Transfer | AP |\n", "|----------|--------|-----------|------|---------|----------|----|\n", "| sanders | M | U2 | 4.00 | 33 | 0 | 12 |\n", "| clinton | F | U4 | 3.63 | 45 | 71.1 | 8 |\n", "| carson | M | U4 | 3.38 | 113 | 0 | 12 |\n", "| fiorina | F | U2 | 2.21 | 28 | 0 | 0 |\n", "| christie | M | U2 | 3.81 | 33 | 0 | 4 |\n", "| cruz | M | U3 | 3.04 | 56 | 28 | 0 |\n", "| huckabee | M | U4 | 3.20 | 80 | 44 | 24 |\n", "| trump | M | U4 | 2.58 | 66 | 30 | 0 |\n", "| bush | M | U3 | 2.84 | 64 | 0 | 0 |\n", "| rubio | M | U4 | 3.92 | 106 | 3 | 24 |\n", "\n", "This is a hypothetical list of 10 students at BU; each row is an individual student, and each column gives a specific piece of information about that student. Note that each column contains the same kind of data (i.e., the first three columns have strings, and the remaining are floats--we will assume that all numberic data is represented as floating-point), and each column has a header giving a description of the information in that column. Column headers are not absolutely necessary, but we will make this assumption for now.\n", "\n", "**Note on terminology**: In Pandas, a table is called a dataframe; in databases we often call the rows in a table records, the columns are called fields, and the headers are then called field names. This terminology is sometimes used in data analysis." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comma Separated Value (CSV) Files\n", "\n", "A common file format for data stored as text is a CSV file, in which each row is stored on a separate line, with commas between all the fields. The table above would look like this if I opened it with TextEdit on my Mac (there would be a newline \\n at the end of each line; on a Windows machine there would be \\r\\n):\n", "\n", "![](textfile.png)\n", "\n", "This is a file format supported by Excel as well, and you can import it into an Excel spreadsheet or save a spreadsheet as a CSV file:\n", "\n", "![](excel.png)\n", "\n", "If you want to create such a file, the easiest way is probably to start with an Excel spreadsheet and simply save it in .csv format!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Reading and Writing CSV Files in Pandas\n", "\n", "To manipulate such data tables in Python, the best library is Pandas, which you should import as follows:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import pandas as pd # this is already done in the first cell at the top of this notebook" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is an example of reading the csv file `students.csv` from the 237 data repository using a URL. You can also use a local file, but as long as there\n", "are no privacy issues, putting it online makes access easier, and\n", "that is what we will do here. \n", "\n", "If you ask for the value of the dataframe to be printed out, it will add sequential index numbers to each row:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "0 sanders M U2 4.00 33 0.0 12\n", "1 clinton F U4 3.63 45 71.1 8\n", "2 carson M U4 3.38 113 0.0 12\n", "3 fiorina F U2 2.21 28 0.0 0\n", "4 christie F U2 3.81 33 0.0 4\n", "5 cruz M U3 3.04 56 28.0 0\n", "6 huckabee M U4 3.20 80 44.0 24\n", "7 trump M U4 2.58 66 30.0 0\n", "8 bush M U3 2.84 64 0.0 0\n", "9 rubio M U4 3.92 106 3.0 24\n" ] } ], "source": [ "stud = pd.read_csv('https://www.cs.bu.edu/fac/snyder/cs237/Homeworks,%20Labs,%20and%20Code/data/students.csv')\n", "print(stud)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Although we won't need to do this right now, for reference, you can also write out a dataframe to a csv file; the default is to write out the index numbers on each row--in general you want to avoid this. The following command will create an identical file to the one read in, without the pesky index numbers:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "stud.to_csv('temp.csv', encoding='utf-8', index=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO \n", "\n", "Download the file *students.csv*, put it in your work directory, import the pandas library, and (your choice, but a good idea), create a name for your work directory as shown above. Try out the code just shown and open up the file temp.csv which you wrote out to verify that this all works as expected." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Selecting Rows and Columns from the Dataframe using Slices\n", "\n", "Pandas gives you a truly bewildering variety of ways to manipulate dataframes, but first we will only need to think about the basics: selecting rows and columns from the table. This amounts to either selecting rows from the table, or selecting columns from the table (or both).\n", "\n", "The basic ideas here are that we think of the dataframe as a two-dimensional list, where the rows are indexed by numbers and the columns are indexed by column headers, so that\n", "\n", "*rows are selecting by using array slices, e.g., [0:3]*\n", "\n", "and\n", "\n", "*columns are selecting by using a list of column headers, e.g., [ ['Userid','GPA'] ]*\n", "\n", "The double brackets are not a typo! The outer brackets enclose the parameter, which is a list of header names. If there is only a single header name, then you can use a single set of brackets." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "For the following, first try to predict what will happen, and then try it to confirm your understanding:\n", "\n", "- stud[0:3]\n", "- stud[5:]\n", "- stud[:]\n", "- stud[1:7:2]\n", "- stud[::-1]" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "0 sanders M U2 4.00 33 0.0 12\n", "1 clinton F U4 3.63 45 71.1 8\n", "2 carson M U4 3.38 113 0.0 12\n" ] } ], "source": [ "print(stud[0:3])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": false }, "outputs": [], "source": [ "# Try it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So the point here is that selecting rows is really the same as slicing a list." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "For the following, first try to predict what will happen, and then try it to confirm your understanding:\n", "- stud[ ['Userid', 'GPA'] ]\n", "- stud[ ['GPA', 'Gender'] ]\n", "- stud[ ['Credits'] ]\n", "- stud['Credits']\n", "- stud[ ['GPA', 'Userid', 'GPA'] ]" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Try it to comfirm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So, selecting columns is done by giving a list of column headers; just remember the double brackets when you have more than one header.\n", "\n", "You can also combine these two, to get a slice of rows and a selection of columns." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "For the following, first try to predict what will happen, and then try it to confirm your understanding:\n", "- stud[0:3][['GPA','Userid']]\n", "- stud[::-1][['AP','Gender','Credits']]\n", "- stud['GPA'][2:7]\n", "- stud[2:7][['GPA']]\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Try it to confirm" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "Note carefully the last two examples: it does not matter what order you put the selectors in.\n", "\n", "Finally, you would expect that you could do a slice on column names; try this:\n", "\n", "- stud[ ['GPA' : 'AP'] ] # error!\n", "\n", "Nope! In order to do this, you need to use the loc function, and give it two slices separated by a comma." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "For the following, first try to predict what will happen, and then try it to confirm your understanding:\n", "\n", "- stud.loc[ 0:3 , 'GPA':'AP' ]\n", "- stud.loc[:, 'Userid':'GPA']\n", "- stud.loc[2:8, 'GPA':'Userid']\n", "- stud.loc[:5, 'ClassYear': ]\n", "- stud.loc[2:7, 'Userid':'Transfer':2]\n", "- stud.loc[::-1, ::-1]\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Try it to confirm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Selecting Rows and Columns from the Dataframe using Boolean Expressions\n", "\n", "Pandas gives you lots of ways of selecting data, and a particularly useful way of selecting rows is to specify a boolean expression that the row values must satisfy. For example, to select only those rows representing men, we could do this:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "0 sanders M U2 4.00 33 0.0 12\n", "2 carson M U4 3.38 113 0.0 12\n", "5 cruz M U3 3.04 56 28.0 0\n", "6 huckabee M U4 3.20 80 44.0 24\n", "7 trump M U4 2.58 66 30.0 0\n", "8 bush M U3 2.84 64 0.0 0\n", "9 rubio M U4 3.92 106 3.0 24\n" ] } ], "source": [ "men = stud[stud['Gender'] == 'M']\n", "print(men)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and here we select the rows where the Credits are less than the Transfer:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "1 clinton F U4 3.63 45 71.1 8\n" ] } ], "source": [ "lessCredits = stud[stud['Credits'] < stud['Transfer']]\n", "print(lessCredits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "For the following, first try to predict what will happen, and then try it to confirm your understanding:\n", "- stud[ stud['Userid'] >= 'cruz' ]\n", "- stud[ stud['AP'] == 0 ]\n", "- stud[ stud['GPA'] < 3.5 ]" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Try it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To do compound boolean expressions when selecting rows, you have to enclose the expressions in parentheses and use the \"bitwise\" boolean operations ~, &, | (instead of the normal Python not, and, or); here is an example:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "2 carson M U4 3.38 113 0.0 12\n", "5 cruz M U3 3.04 56 28.0 0\n", "6 huckabee M U4 3.20 80 44.0 24\n", "7 trump M U4 2.58 66 30.0 0\n", "8 bush M U3 2.84 64 0.0 0\n" ] } ], "source": [ "menGPA = stud[(stud['Gender'] == 'M')&(stud['GPA'] < 3.5 )]\n", "print(menGPA)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Printing out a Table from a Python Program\n", "\n", "If you are using the console interatively, of course the results of the expressions you type in are automatically displayed. How do you do this in a Python program? Easy:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "2 carson M U4 3.38 113 0.0 12\n", "3 fiorina F U2 2.21 28 0.0 0\n", "5 cruz M U3 3.04 56 28.0 0\n", "6 huckabee M U4 3.20 80 44.0 24\n", "7 trump M U4 2.58 66 30.0 0\n", "8 bush M U3 2.84 64 0.0 0\n" ] } ], "source": [ "print(str( stud[ stud['GPA'] < 3.5 ] ) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Turning a column into a list\n", "\n", "Sometimes you simply want to grab one particular column (say the GPA) into a list, so that you\n", "can manipulate it in Python. This is easy, as you just have to convert a single-column frame into a list:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4.0, 3.63, 3.38, 2.21, 3.81, 3.04, 3.2, 2.58, 2.84, 3.92]\n" ] } ], "source": [ "G = list(stud['GPA'])\n", "print(G)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Turning a row into a list\n", "\n", "Or you want to grab a row or rows into a list. Here is a way to convert the whole data frame into a list of lists:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[['sanders', 'M', 'U2', 4.0, 33, 0.0, 12],\n", " ['clinton', 'F', 'U4', 3.63, 45, 71.1, 8],\n", " ['carson', 'M', 'U4', 3.38, 113, 0.0, 12],\n", " ['fiorina', 'F', 'U2', 2.21, 28, 0.0, 0],\n", " ['christie', 'F', 'U2', 3.81, 33, 0.0, 4],\n", " ['cruz', 'M', 'U3', 3.04, 56, 28.0, 0],\n", " ['huckabee', 'M', 'U4', 3.2, 80, 44.0, 24],\n", " ['trump', 'M', 'U4', 2.58, 66, 30.0, 0],\n", " ['bush', 'M', 'U3', 2.84, 64, 0.0, 0],\n", " ['rubio', 'M', 'U4', 3.92, 106, 3.0, 24]]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stud.values.tolist()" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "You can slice this to get only particular rows, or a single row:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['clinton', 'F', 'U4', 3.63, 45, 71.1, 8]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(stud[1:2].values.tolist())[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Saving your work to a file\n", "\n", "Note that each of these expressions we have explored returns a new dataframe, so that if you wanted to create a new data set derived from an existing set, you could assign an expression to a variable and write it out, e.g.," ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "studrev = stud.loc[::-1, ::-1]\n", "studrev.to_csv(\"studentrev.csv\", index=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "or just combine without bothering with the variable:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "stud.loc[::-1, ::-1].to_csv(\"studentrev.csv\", index=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Both of these would put the file studentrev.csv into my work directory, which I could then import into Excel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions on DataFrames\n", "\n", "Having read in a dataframe, or created a new one using one of the expressions just shown, we can use a variety of functions to explore and organize the data. Most of these are very intuitive, so we will mostly try a bunch of examples, you can easily explore these in the link Basic Fuctionality: http://pandas.pydata.org/pandas-docs/stable/basics.html" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "For the following, which sort the dataframe, first try to predict what will happen, and then try it to confirm your understanding:\n", "\n", "- stud.sort_values('Userid')\n", "- stud.sort_values('Userid', ascending=False)\n", "- stud.sort_values( ['Gender', 'Userid'] )\n", "- stud.sort_values( ['Gender', 'Userid'], ascending=[False,True] )" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Userid Gender ClassYear GPA Credits Transfer AP\n", "8 bush M U3 2.84 64 0.0 0\n", "2 carson M U4 3.38 113 0.0 12\n", "4 christie F U2 3.81 33 0.0 4\n", "1 clinton F U4 3.63 45 71.1 8\n", "5 cruz M U3 3.04 56 28.0 0\n", "3 fiorina F U2 2.21 28 0.0 0\n", "6 huckabee M U4 3.20 80 44.0 24\n", "9 rubio M U4 3.92 106 3.0 24\n", "0 sanders M U2 4.00 33 0.0 12\n", "7 trump M U4 2.58 66 30.0 0\n" ] } ], "source": [ "print(stud.sort_values('Userid'))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Try it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are also many statistical functions which operate mostly on individual columns:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TODO\n", "\n", "Let us assume that we have created a new dataframe\n", "\n", "*st = stud['GPA']*\n", "\n", "First try to predict what will happen, and then try it to confirm your understanding.\n", "\n", "- st.max()\n", "- st.min()\n", "- st.mean()(\n", "- st.median()\n", "- stud['Gender'].mode() # the mode is the most frequent value in the list\n", "- stud['Credits'].sum()\n", "- st.count() * 2 + st.max() # weird, just to show that values can be used any way you want!\n", "- stud[ ['GPA','Credits']].max() # ok, another weird one, it returns the max in each column!" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.0\n" ] } ], "source": [ "st = stud['GPA']\n", "print(st.max())" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "# Try it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Displaying Distributions from DataFrames\n", "\n", "A final function that we should look at is the hist(...) function, which will (as you might expect), produce a graphical display of the histogram for a column of values. It is precisely the same function that we studied in the last lab, except that it takes as its values the data in the column(s) of the dataframe. If you give it a whole dataframe, it will give you histograms of all the numeric columns:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt \n", "\n", "stud.hist(figsize=(10,10))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is usually more useful to consider a single column at a time:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stud['GPA'].hist()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Or you could simply extract the data as a list and then use our usual algorithm for displaying it as a bar chart; note that this works for numeric data (for non-numeric, better to use the method shown above). " ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Counter({0: 10})\n", "[10]\n", "[0]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# or can use a bar chart if convert x axis into numbers.....\n", "S = [ 1 if G[i] == 'M' else 0 for i in range(len(G))]\n", "D = Counter(S) \n", "K = list(D.keys()) \n", "K.sort() \n", "F = [D[k] for k in K] \n", "print(D)\n", "print(F)\n", "print(K)\n", "plt.bar( K, F,width=1.0,edgecolor='k')\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem One\n", "\n", "Download the following file of student data: studentdata.csv and write a function Prob01() which does the following:\n", "\n", "- Print out the mean GPA for men;\n", "- Print out the mean GPA for seniors (U4);\n", "- Print out the 10 individuals with the largest number of credits earned, sorted in descending order by GPA;\n", "- Display a histogram of the GPA of all individuals, with bins for each letter grade, i.e., 0.0, 1.0, 2.0, 2.33, 2.67, 3.0, 3.33, 3.67, and 4.0." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "# Your solution here\n", "# Make sure to run it before submitting it" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Problem One\n", "\n", "(1) GPA of Men is 3.1148\n", "\n", "(2) GPA for Seniors is 3.196\n", "\n", "(3)\n", " Gender ClassYear GPA CreditsEarned TransferCredits APCredits\n", "777 F U4 3.65 159.5 0.0 0\n", "825 M U4 3.63 155.0 0.0 0\n", "1679 M U4 3.37 173.0 0.0 0\n", "1839 F U4 3.32 154.0 0.0 0\n", "2504 M U4 3.12 167.0 0.0 0\n", "2559 M U4 3.10 152.0 0.0 0\n", "3157 F U4 2.89 152.0 0.0 0\n", "3210 M U4 2.87 152.0 0.0 0\n", "3624 M U4 2.64 162.0 0.0 0\n", "4191 F U4 2.06 156.0 4.0 0\n", "\n", "(4)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def Prob1():\n", " print(\"\\nProblem One\")\n", " \n", " Students = pd.read_csv('https://www.cs.bu.edu/fac/snyder/cs237/Homeworks,%20Labs,%20and%20Code/data/studentdata.csv')\n", " \n", " print(\"\\n(1) GPA of Men is \" + str(np.around(Students[Students['Gender'] == 'M']['GPA'].mean(),4)))\n", "\n", " print(\"\\n(2) GPA for Seniors is \" + str(np.around(Students[Students['ClassYear'] == 'U4']['GPA'].mean(),4)))\n", "\n", " print(\"\\n(3)\")\n", "\n", " A3 = (Students.sort_values('CreditsEarned',ascending=False)[0:10]).sort_values('GPA',ascending=False)\n", "\n", " print(str(A3))\n", "\n", " print(\"\\n(4)\")\n", " \n", " plt.title(\"GPA\")\n", " Students['GPA'].hist(bins=[0.0, 1.0, 2.0, 2.33, 2.67, 3.0, 3.33, 3.67,4.0,4.5])\n", " plt.show()\n", " plt.close()\n", " \n", "Prob1()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Problem Two\n", "\n", "Download the following file of heights and weights of 25,000 individuals: biometricdata.csv and write a function Prob02() which does the following:\n", "\n", "- Print out the maximum, minimum, mean, and (unbiased) standard deviation (all functions listed above) for the heights of all individuals;\n", "- Print out the mean height for all individuals weighing more than 130 pounds;\n", "- Print out how many individuals have a height >= 65 inches and <= 70 inches;\n", "- Display a histogram of the heights of all individuals from the minimum to the maximum, where each bin represents 1 inch.\n", "\n", "\n", "When doing your histograms, change the figure size so that they are large enough to see:\n", "\n", "import matplotlib.pyplot as plt # assuming you called the library plt\n", "\n", ".....\n", "\n", "plt.figure(figsize=(10,5)) # this will change size of figure when you call hist(....)\n", "\n", "Students.hist(.....)\n", "\n", "Play around with the parameters 10 and 5 until you like the result.\n", "\n", "Also, I found that when I called hist(...) several times, Pandas would add the new histogram to the old one (in weird colors). To keep them separate, you need to show a histogram and then close it; after a class to hist(....), add these two lines:\n", "\n", "Students['GPA'].hist(.....) \n", "plt.show() \n", "plt.close()" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Problem 2\n", "(1) \n", "\tMax of Heights: 75.1528\n", "\tMin of Heights: 60.2784\n", "\tMean of Heights: 67.9931\n", "\tStd of Heights: 1.9017\n", "\n", "\n", "(2) \n", "\tMean height with weight > 130: 75.1528\n", "\n", "\n", "(3) \n", "\tHow many with 65 <= height <= 70: 19846\n", "\n", "\n", "(4) \n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Your solution\n", "\n", "Bio = pd.read_csv('biometricdata.csv')\n", "\n", "def Prob2():\n", " \n", " print(\"\\nProblem 2\\n(1) \")\n", " \n", " print(\"\\tMax of Heights: \" + str(np.around(Bio['Height'].max(),4)))\n", " print(\"\\tMin of Heights: \" + str(np.around(Bio['Height'].min(),4)))\n", " print(\"\\tMean of Heights: \" + str(np.around(Bio['Height'].mean(),4)))\n", " print(\"\\tStd of Heights: \" + str(np.around(Bio['Height'].std(),4)))\n", " \n", " print(\"\\n\\n(2) \") \n", " print(\"\\tMean height with weight > 130: \" + str((Bio[Bio['Weight'] > 130])['Height'].max()))\n", " \n", " print(\"\\n\\n(3) \") \n", " print(\"\\tHow many with 65 <= height <= 70: \" + str(Bio['Height'][(Bio['Height'] >= 65) & (Bio['Height'] <= 70)].count()))\n", "\n", " print(\"\\n\\n(4) \") \n", " plt.title(\"Height\")\n", " Bio['Height'].hist(bins=[x for x in range(60, 74)])\n", "\n", " \n", " \n", "Prob2()\n", "\n", "Bio['Height'].hist(bins=[x for x in range(int(Bio['Height'].min()), int(Bio['Height'].max() + 2))],edgecolor=\"k\")\n", "\n", "plt.show()\n", "plt.close()" ] } ], "metadata": { "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.7.3" } }, "nbformat": 4, "nbformat_minor": 2 }