diff --git a/Assignment 2 koushal.py b/Assignment 2 koushal.py new file mode 100644 index 0000000..2bb9e5b --- /dev/null +++ b/Assignment 2 koushal.py @@ -0,0 +1,1206 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "#%matplotlib notebook\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "import the dataset into a dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdEmployeeNameJobTitleBasePayOvertimePayOtherPayBenefitsTotalPayTotalPayBenefitsYearNotesAgencyStatus
01NATHANIEL FORDGENERAL MANAGER-METROPOLITAN TRANSIT AUTHORITY167411.180.00400184.25NaN567595.43567595.432011NaNSan FranciscoNaN
12GARY JIMENEZCAPTAIN III (POLICE DEPARTMENT)155966.02245131.88137811.38NaN538909.28538909.282011NaNSan FranciscoNaN
23ALBERT PARDINICAPTAIN III (POLICE DEPARTMENT)212739.13106088.1816452.60NaN335279.91335279.912011NaNSan FranciscoNaN
34CHRISTOPHER CHONGWIRE ROPE CABLE MAINTENANCE MECHANIC77916.0056120.71198306.90NaN332343.61332343.612011NaNSan FranciscoNaN
45PATRICK GARDNERDEPUTY CHIEF OF DEPARTMENT,(FIRE DEPARTMENT)134401.609737.00182234.59NaN326373.19326373.192011NaNSan FranciscoNaN
..........................................
148649148650Roy I TilleryCustodian0.000.000.000.00.000.002014NaNSan FranciscoNaN
148650148651Not providedNot providedNaNNaNNaNNaN0.000.002014NaNSan FranciscoNaN
148651148652Not providedNot providedNaNNaNNaNNaN0.000.002014NaNSan FranciscoNaN
148652148653Not providedNot providedNaNNaNNaNNaN0.000.002014NaNSan FranciscoNaN
148653148654Joe LopezCounselor, Log Cabin Ranch0.000.00-618.130.0-618.13-618.132014NaNSan FranciscoNaN
\n", + "

148654 rows × 13 columns

\n", + "
" + ], + "text/plain": [ + " Id EmployeeName \\\n", + "0 1 NATHANIEL FORD \n", + "1 2 GARY JIMENEZ \n", + "2 3 ALBERT PARDINI \n", + "3 4 CHRISTOPHER CHONG \n", + "4 5 PATRICK GARDNER \n", + "... ... ... \n", + "148649 148650 Roy I Tillery \n", + "148650 148651 Not provided \n", + "148651 148652 Not provided \n", + "148652 148653 Not provided \n", + "148653 148654 Joe Lopez \n", + "\n", + " JobTitle BasePay \\\n", + "0 GENERAL MANAGER-METROPOLITAN TRANSIT AUTHORITY 167411.18 \n", + "1 CAPTAIN III (POLICE DEPARTMENT) 155966.02 \n", + "2 CAPTAIN III (POLICE DEPARTMENT) 212739.13 \n", + "3 WIRE ROPE CABLE MAINTENANCE MECHANIC 77916.00 \n", + "4 DEPUTY CHIEF OF DEPARTMENT,(FIRE DEPARTMENT) 134401.60 \n", + "... ... ... \n", + "148649 Custodian 0.00 \n", + "148650 Not provided NaN \n", + "148651 Not provided NaN \n", + "148652 Not provided NaN \n", + "148653 Counselor, Log Cabin Ranch 0.00 \n", + "\n", + " OvertimePay OtherPay Benefits TotalPay TotalPayBenefits Year \\\n", + "0 0.00 400184.25 NaN 567595.43 567595.43 2011 \n", + "1 245131.88 137811.38 NaN 538909.28 538909.28 2011 \n", + "2 106088.18 16452.60 NaN 335279.91 335279.91 2011 \n", + "3 56120.71 198306.90 NaN 332343.61 332343.61 2011 \n", + "4 9737.00 182234.59 NaN 326373.19 326373.19 2011 \n", + "... ... ... ... ... ... ... \n", + "148649 0.00 0.00 0.0 0.00 0.00 2014 \n", + "148650 NaN NaN NaN 0.00 0.00 2014 \n", + "148651 NaN NaN NaN 0.00 0.00 2014 \n", + "148652 NaN NaN NaN 0.00 0.00 2014 \n", + "148653 0.00 -618.13 0.0 -618.13 -618.13 2014 \n", + "\n", + " Notes Agency Status \n", + "0 NaN San Francisco NaN \n", + "1 NaN San Francisco NaN \n", + "2 NaN San Francisco NaN \n", + "3 NaN San Francisco NaN \n", + "4 NaN San Francisco NaN \n", + "... ... ... ... \n", + "148649 NaN San Francisco NaN \n", + "148650 NaN San Francisco NaN \n", + "148651 NaN San Francisco NaN \n", + "148652 NaN San Francisco NaN \n", + "148653 NaN San Francisco NaN \n", + "\n", + "[148654 rows x 13 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv(\"Salary.csv\")\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "display the column names" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empty DataFrame\n", + "Columns: [Id, EmployeeName, JobTitle, BasePay, OvertimePay, OtherPay, Benefits, TotalPay, TotalPayBenefits, Year, Notes, Agency, Status]\n", + "Index: []\n" + ] + }, + { + "data": { + "text/plain": [ + "Index(['Id', 'EmployeeName', 'JobTitle', 'BasePay', 'OvertimePay', 'OtherPay',\n", + " 'Benefits', 'TotalPay', 'TotalPayBenefits', 'Year', 'Notes', 'Agency',\n", + " 'Status'],\n", + " dtype='object')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = df.columns\n", + "print(df[:0]) # checking the column names in the row 1\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "display the number of rows and cols" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(148654, 13)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "display the dataframe info (types of data in columns and not null values etc.)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 148654 entries, 0 to 148653\n", + "Data columns (total 13 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Id 148654 non-null int64 \n", + " 1 EmployeeName 148654 non-null object \n", + " 2 JobTitle 148654 non-null object \n", + " 3 BasePay 148045 non-null float64\n", + " 4 OvertimePay 148650 non-null float64\n", + " 5 OtherPay 148650 non-null float64\n", + " 6 Benefits 112491 non-null float64\n", + " 7 TotalPay 148654 non-null float64\n", + " 8 TotalPayBenefits 148654 non-null float64\n", + " 9 Year 148654 non-null int64 \n", + " 10 Notes 0 non-null float64\n", + " 11 Agency 148654 non-null object \n", + " 12 Status 0 non-null float64\n", + "dtypes: float64(8), int64(2), object(3)\n", + "memory usage: 14.7+ MB\n" + ] + } + ], + "source": [ + "df.info() # (verbose=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "display stats of the dataframe like count, mean, std, max, 25% etc....." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdBasePayOvertimePayOtherPayBenefitsTotalPayTotalPayBenefitsYearNotesStatus
count148654.000000148045.000000148650.000000148650.000000112491.000000148654.000000148654.000000148654.0000000.00.0
mean74327.50000066325.4488415066.0598863648.76729725007.89315174768.32197293692.5548112012.522643NaNNaN
std42912.85779542764.63549511454.3805598056.60186615402.21585850517.00527462793.5334831.117538NaNNaN
min1.000000-166.010000-0.010000-7058.590000-33.890000-618.130000-618.1300002011.000000NaNNaN
25%37164.25000033588.2000000.0000000.00000011535.39500036168.99500044065.6500002012.000000NaNNaN
50%74327.50000065007.4500000.000000811.27000028628.62000071426.61000092404.0900002013.000000NaNNaN
75%111490.75000094691.0500004658.1750004236.06500035566.855000105839.135000132876.4500002014.000000NaNNaN
max148654.000000319275.010000245131.880000400184.25000096570.660000567595.430000567595.4300002014.000000NaNNaN
\n", + "
" + ], + "text/plain": [ + " Id BasePay OvertimePay OtherPay \\\n", + "count 148654.000000 148045.000000 148650.000000 148650.000000 \n", + "mean 74327.500000 66325.448841 5066.059886 3648.767297 \n", + "std 42912.857795 42764.635495 11454.380559 8056.601866 \n", + "min 1.000000 -166.010000 -0.010000 -7058.590000 \n", + "25% 37164.250000 33588.200000 0.000000 0.000000 \n", + "50% 74327.500000 65007.450000 0.000000 811.270000 \n", + "75% 111490.750000 94691.050000 4658.175000 4236.065000 \n", + "max 148654.000000 319275.010000 245131.880000 400184.250000 \n", + "\n", + " Benefits TotalPay TotalPayBenefits Year Notes \\\n", + "count 112491.000000 148654.000000 148654.000000 148654.000000 0.0 \n", + "mean 25007.893151 74768.321972 93692.554811 2012.522643 NaN \n", + "std 15402.215858 50517.005274 62793.533483 1.117538 NaN \n", + "min -33.890000 -618.130000 -618.130000 2011.000000 NaN \n", + "25% 11535.395000 36168.995000 44065.650000 2012.000000 NaN \n", + "50% 28628.620000 71426.610000 92404.090000 2013.000000 NaN \n", + "75% 35566.855000 105839.135000 132876.450000 2014.000000 NaN \n", + "max 96570.660000 567595.430000 567595.430000 2014.000000 NaN \n", + "\n", + " Status \n", + "count 0.0 \n", + "mean NaN \n", + "std NaN \n", + "min NaN \n", + "25% NaN \n", + "50% NaN \n", + "75% NaN \n", + "max NaN " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe() # statistics - Summary" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "display null values per column" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "BasePay 609\n", + "OvertimePay 4\n", + "OtherPay 4\n", + "Benefits 36163\n", + "Notes 148654\n", + "Status 148654\n", + "dtype: int64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "null_values=df.columns[df.isnull().any()]\n", + "df[null_values].isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "remove columns will all values as NaN" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IdEmployeeNameJobTitleTotalPayTotalPayBenefitsYearAgency
01NATHANIEL FORDGENERAL MANAGER-METROPOLITAN TRANSIT AUTHORITY567595.43567595.432011San Francisco
12GARY JIMENEZCAPTAIN III (POLICE DEPARTMENT)538909.28538909.282011San Francisco
23ALBERT PARDINICAPTAIN III (POLICE DEPARTMENT)335279.91335279.912011San Francisco
34CHRISTOPHER CHONGWIRE ROPE CABLE MAINTENANCE MECHANIC332343.61332343.612011San Francisco
45PATRICK GARDNERDEPUTY CHIEF OF DEPARTMENT,(FIRE DEPARTMENT)326373.19326373.192011San Francisco
........................
148649148650Roy I TilleryCustodian0.000.002014San Francisco
148650148651Not providedNot provided0.000.002014San Francisco
148651148652Not providedNot provided0.000.002014San Francisco
148652148653Not providedNot provided0.000.002014San Francisco
148653148654Joe LopezCounselor, Log Cabin Ranch-618.13-618.132014San Francisco
\n", + "

148654 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " Id EmployeeName \\\n", + "0 1 NATHANIEL FORD \n", + "1 2 GARY JIMENEZ \n", + "2 3 ALBERT PARDINI \n", + "3 4 CHRISTOPHER CHONG \n", + "4 5 PATRICK GARDNER \n", + "... ... ... \n", + "148649 148650 Roy I Tillery \n", + "148650 148651 Not provided \n", + "148651 148652 Not provided \n", + "148652 148653 Not provided \n", + "148653 148654 Joe Lopez \n", + "\n", + " JobTitle TotalPay \\\n", + "0 GENERAL MANAGER-METROPOLITAN TRANSIT AUTHORITY 567595.43 \n", + "1 CAPTAIN III (POLICE DEPARTMENT) 538909.28 \n", + "2 CAPTAIN III (POLICE DEPARTMENT) 335279.91 \n", + "3 WIRE ROPE CABLE MAINTENANCE MECHANIC 332343.61 \n", + "4 DEPUTY CHIEF OF DEPARTMENT,(FIRE DEPARTMENT) 326373.19 \n", + "... ... ... \n", + "148649 Custodian 0.00 \n", + "148650 Not provided 0.00 \n", + "148651 Not provided 0.00 \n", + "148652 Not provided 0.00 \n", + "148653 Counselor, Log Cabin Ranch -618.13 \n", + "\n", + " TotalPayBenefits Year Agency \n", + "0 567595.43 2011 San Francisco \n", + "1 538909.28 2011 San Francisco \n", + "2 335279.91 2011 San Francisco \n", + "3 332343.61 2011 San Francisco \n", + "4 326373.19 2011 San Francisco \n", + "... ... ... ... \n", + "148649 0.00 2014 San Francisco \n", + "148650 0.00 2014 San Francisco \n", + "148651 0.00 2014 San Francisco \n", + "148652 0.00 2014 San Francisco \n", + "148653 -618.13 2014 San Francisco \n", + "\n", + "[148654 rows x 7 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1 = df.dropna(axis=1) # inplace = True\n", + "df1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "display number of unique values in each column" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Id 148654\n", + "EmployeeName 110811\n", + "JobTitle 2159\n", + "BasePay 109489\n", + "OvertimePay 65998\n", + "OtherPay 83225\n", + "Benefits 98465\n", + "TotalPay 138486\n", + "TotalPayBenefits 142098\n", + "Year 4\n", + "Notes 0\n", + "Agency 1\n", + "Status 0\n", + "dtype: int64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df2 = pd.read_csv(\"Salary.csv\")\n", + "df2.nunique()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "mean of total pay of all people based on year" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Year\n", + "2011 71744.103871\n", + "2012 74113.262265\n", + "2013 77611.443142\n", + "2014 75463.918140\n", + "Name: TotalPay, dtype: float64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dftp = df2.groupby('Year').mean()['TotalPay'] #(total pay vs year))\n", + "dftp" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "how many people have 0 overtime pay" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "77321" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df3 = sum(df2[df2['OvertimePay']==0]['Id'].value_counts()==1)\n", + "df3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "max, min, mean, median and other stats of TotalPay of people having 0 OvertimePay" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 77321.000000\n", + "mean 60229.348901\n", + "std 49307.912350\n", + "min -618.130000\n", + "25% 13290.450000\n", + "50% 58158.590000\n", + "75% 91115.090000\n", + "max 567595.430000\n", + "Name: TotalPay, dtype: float64" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Stats = df2.loc[df2['OvertimePay'] == 0]\n", + "Stats['TotalPay'].describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "find Id of that person with max TotalPay you got in previous question" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Id_person = df2.loc[df2['TotalPay'].idxmax()]\n", + "Id_person['Id']\n", + "#df2.groupby(['TotalPay']).max()['Id']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "name of employee with total pay benefits = 87619.78" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12345 REBECCA CHIU\n", + "Name: EmployeeName, dtype: object" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Name_Emp = df1.loc[df1['TotalPayBenefits'] == 87619.78]\n", + "Name_Emp['EmployeeName']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "how many people have BasePay > 150000 and OvertimePay > 100000" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "156" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Total_people = df2[(df2['BasePay'] > 150000) & (df2['OvertimePay'] > 100000)]\n", + "Total_people.size" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "which job title generally has highest average TotalPayBenefits" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "JobTitle ZOO CURATOR\n", + "TotalPayBenefits 436224\n", + "dtype: object" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Job_Title = df2.groupby('JobTitle', as_index = False)['TotalPayBenefits'].mean().max()\n", + "Job_Title" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How many employees are POLICE" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2512" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df2[df2['JobTitle'].str.contains('POLICE')]['JobTitle'].size" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "# How many employees are POLICE\n", + "def police_string(title):\n", + " if 'police' in title.lower().split():\n", + " return True\n", + " else:\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total employees who are Police: 7489\n" + ] + } + ], + "source": [ + "P = sum(df2['JobTitle'].apply(lambda x:police_string(x)))\n", + "print(\"Total employees who are Police: \",P)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/assignment 1 kaushalgopi.ipynb b/assignment 1 kaushalgopi.ipynb new file mode 100644 index 0000000..adb3000 --- /dev/null +++ b/assignment 1 kaushalgopi.ipynb @@ -0,0 +1,795 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy (or Numpy) is a Linear Algebra Library for Python, the reason it is so important for Data Science with Python is that almost all of the libraries in the PyData Ecosystem rely on NumPy as one of their main building blocks.\n", + "\n", + "Numpy is also incredibly fast, as it has bindings to C libraries.\n", + "\n", + "We will only learn the basics of NumPy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**install**\n", + "\n", + " !pip install numpy " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numpy Arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### from python lists" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "numpy.ndarray" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list1= [1,2,3]\n", + "list1_np= np.array(list1)\n", + "type(list1_np)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list1_np" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2],\n", + " [3, 4]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 2_D arrays -> matrix\n", + "matrix1= [[1,2],[3,4]]\n", + "np.array(matrix1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Built-in methods" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# arange() -> (start, end-not included, step)\n", + "# Returns evenly spaced values in an interval\n", + "np.arange(0,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 2, 4, 6, 8])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(0,10,2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### zeros, ones" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0.])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros((3,3))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1.],\n", + " [1., 1., 1.],\n", + " [1., 1., 1.]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.ones((3,3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### eye" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#identity matrix\n", + "np.eye(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Random" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### rand\n", + "It creates array of a given shape and populates it with random values from an uniform distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9644203307125712" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.56373702, 0.5968386 ])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.35541639, 0.36915485, 0.00824921],\n", + " [0.76669309, 0.72633326, 0.31226496],\n", + " [0.95993215, 0.49515244, 0.1119133 ]])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand(3,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "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", + "plt.hist(np.random.rand(20000))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### randn\n", + "returns values from standard normal distribution " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.22599158, 0.01264132, 0.09098834],\n", + " [-0.62689363, 0.33117328, -1.09699203],\n", + " [ 0.2314655 , -0.52813472, -0.65476896]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randn(3,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(np.random.randn(20000))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: seaborn in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (0.10.1)\n", + "Requirement already satisfied: numpy>=1.13.3 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from seaborn) (1.16.2)\n", + "Requirement already satisfied: scipy>=1.0.1 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from seaborn) (1.3.0)\n", + "Requirement already satisfied: matplotlib>=2.1.2 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from seaborn) (3.1.1)\n", + "Requirement already satisfied: pandas>=0.22.0 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from seaborn) (0.24.2)\n", + "Requirement already satisfied: cycler>=0.10 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from matplotlib>=2.1.2->seaborn) (0.10.0)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from matplotlib>=2.1.2->seaborn) (2.4.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from matplotlib>=2.1.2->seaborn) (2.8.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from matplotlib>=2.1.2->seaborn) (1.1.0)\n", + "Requirement already satisfied: pytz>=2011k in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from pandas>=0.22.0->seaborn) (2019.1)\n", + "Requirement already satisfied: six in c:\\users\\lenovo\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from cycler>=0.10->matplotlib>=2.1.2->seaborn) (1.12.0)\n", + "Requirement already satisfied: setuptools in c:\\users\\lenovo\\appdata\\roaming\\python\\python37\\site-packages (from kiwisolver>=1.0.1->matplotlib>=2.1.2->seaborn) (41.0.1)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: You are using pip version 19.1.1, however version 20.2.1 is available.\n", + "You should consider upgrading via the 'python -m pip install --upgrade pip' command.\n" + ] + } + ], + "source": [ + "!pip3 install seaborn" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "sns.distplot(np.random.randn(20000), bins=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Array attributes and methods" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "arr= np.arange(25)\n", + "ranarr= np.random.randint(0,50,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([25, 21, 20, 26, 47, 3, 42, 35, 15, 43])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reshape" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4],\n", + " [ 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14],\n", + " [15, 16, 17, 18, 19],\n", + " [20, 21, 22, 23, 24]])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr.reshape(5,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10,)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[25],\n", + " [21],\n", + " [20],\n", + " [26],\n", + " [47],\n", + " [ 3],\n", + " [42],\n", + " [35],\n", + " [15],\n", + " [43]])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# dimention mismatch error -> reshape(1,-1)\n", + "ranarr.reshape(10,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[25, 21, 20, 26, 47, 3, 42, 35, 15, 43]])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.reshape(1,10) #-> 2-D ---- [[1,2,3,4,]]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([25, 21, 20, 26, 47, 3, 42, 35, 15, 43])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr # 1-D ------ [1,2,3,4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### max, min, argmax, argmin" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "47" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.min()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.argmax()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.argmin()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}