diff --git a/KINGS_COUNTY_HOUSING-Updated 2.pdf b/KINGS_COUNTY_HOUSING-Updated 2.pdf new file mode 100644 index 00000000..bc64d3db Binary files /dev/null and b/KINGS_COUNTY_HOUSING-Updated 2.pdf differ diff --git a/Updated Presentation.pdf b/Updated Presentation.pdf new file mode 100644 index 00000000..f50479b8 Binary files /dev/null and b/Updated Presentation.pdf differ diff --git a/presentation.pdf b/presentation.pdf new file mode 100644 index 00000000..ed038166 Binary files /dev/null and b/presentation.pdf differ diff --git a/student.ipynb b/student.ipynb index d3bb34af..c3e0bb0e 100644 --- a/student.ipynb +++ b/student.ipynb @@ -14,13 +14,2030 @@ "* Blog post URL:\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### IMPORTING OF LIBRARIES" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd # for reading our data\n", + "import numpy as np # for performing calculations\n", + "import seaborn as sns # for visualization\n", + "import matplotlib.pyplot as plt # for visualization\n", + "%matplotlib inline\n", + "\n", + "import scipy.stats as stat # to calculate statistical operations\n", + "\n", + "from statsmodels.formula.api import ols #for creating a model\n", + "\n", + "from sklearn.model_selection import train_test_split # for performing train train_test_split on our data\n", + "from sklearn.linear_model import LinearRegression # making a LinearRegression model\n", + "from sklearn.metrics import mean_squared_error # for calculating error metrics to evaluate our model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### LOADING DATA INTO A DATAFRAME\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "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", + "
iddatepricebedroomsbathroomssqft_livingsqft_lotfloorswaterfrontview...gradesqft_abovesqft_basementyr_builtyr_renovatedzipcodelatlongsqft_living15sqft_lot15
0712930052010/13/2014221900.031.00118056501.0NaNNONE...7 Average11800.019550.09817847.5112-122.25713405650
1641410019212/9/2014538000.032.25257072422.0NONONE...7 Average2170400.019511991.09812547.7210-122.31916907639
256315004002/25/2015180000.021.00770100001.0NONONE...6 Low Average7700.01933NaN9802847.7379-122.23327208062
3248720087512/9/2014604000.043.00196050001.0NONONE...7 Average1050910.019650.09813647.5208-122.39313605000
419544005102/18/2015510000.032.00168080801.0NONONE...8 Good16800.019870.09807447.6168-122.04518007503
\n", + "

5 rows × 21 columns

\n", + "
" + ], + "text/plain": [ + " id date price bedrooms bathrooms sqft_living \\\n", + "0 7129300520 10/13/2014 221900.0 3 1.00 1180 \n", + "1 6414100192 12/9/2014 538000.0 3 2.25 2570 \n", + "2 5631500400 2/25/2015 180000.0 2 1.00 770 \n", + "3 2487200875 12/9/2014 604000.0 4 3.00 1960 \n", + "4 1954400510 2/18/2015 510000.0 3 2.00 1680 \n", + "\n", + " sqft_lot floors waterfront view ... grade sqft_above \\\n", + "0 5650 1.0 NaN NONE ... 7 Average 1180 \n", + "1 7242 2.0 NO NONE ... 7 Average 2170 \n", + "2 10000 1.0 NO NONE ... 6 Low Average 770 \n", + "3 5000 1.0 NO NONE ... 7 Average 1050 \n", + "4 8080 1.0 NO NONE ... 8 Good 1680 \n", + "\n", + " sqft_basement yr_built yr_renovated zipcode lat long \\\n", + "0 0.0 1955 0.0 98178 47.5112 -122.257 \n", + "1 400.0 1951 1991.0 98125 47.7210 -122.319 \n", + "2 0.0 1933 NaN 98028 47.7379 -122.233 \n", + "3 910.0 1965 0.0 98136 47.5208 -122.393 \n", + "4 0.0 1987 0.0 98074 47.6168 -122.045 \n", + "\n", + " sqft_living15 sqft_lot15 \n", + "0 1340 5650 \n", + "1 1690 7639 \n", + "2 2720 8062 \n", + "3 1360 5000 \n", + "4 1800 7503 \n", + "\n", + "[5 rows x 21 columns]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kc_data_df = pd.read_csv('data/kc_house_data.csv') # reading our data into a pandas data frame\n", + "kc_data_df.head() # checking the first 5 rows\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets explore our data by creating a function data_summary to show us the info and shape of our data frame" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def data_summary(data):# a function that gives us a brief summary of our data frame\n", + " # Shape of Data\n", + " shape = data.shape\n", + " # Info of Data\n", + " info = data.info() \n", + "\n", + " # Combining the information into a single string\n", + " summary = f\"Dataframe Shape: {shape}\\n\"\n", + " summary += f\"Dataframe Info:\\n{info}\" \n", + "\n", + " return summary\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 21597 entries, 0 to 21596\n", + "Data columns (total 21 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 id 21597 non-null int64 \n", + " 1 date 21597 non-null object \n", + " 2 price 21597 non-null float64\n", + " 3 bedrooms 21597 non-null int64 \n", + " 4 bathrooms 21597 non-null float64\n", + " 5 sqft_living 21597 non-null int64 \n", + " 6 sqft_lot 21597 non-null int64 \n", + " 7 floors 21597 non-null float64\n", + " 8 waterfront 19221 non-null object \n", + " 9 view 21534 non-null object \n", + " 10 condition 21597 non-null object \n", + " 11 grade 21597 non-null object \n", + " 12 sqft_above 21597 non-null int64 \n", + " 13 sqft_basement 21597 non-null object \n", + " 14 yr_built 21597 non-null int64 \n", + " 15 yr_renovated 17755 non-null float64\n", + " 16 zipcode 21597 non-null int64 \n", + " 17 lat 21597 non-null float64\n", + " 18 long 21597 non-null float64\n", + " 19 sqft_living15 21597 non-null int64 \n", + " 20 sqft_lot15 21597 non-null int64 \n", + "dtypes: float64(6), int64(9), object(6)\n", + "memory usage: 3.5+ MB\n" + ] + }, + { + "data": { + "text/plain": [ + "'Dataframe Shape: (21597, 21)\\nDataframe Info:\\nNone'" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_summary(kc_data_df) # using the function to obtain a summary of our dataframe" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DATA CLEANING\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At these stage we will clean our data using the following steps\n", + "\n", + ". **Completeness** (we will check for missing values , how they affect our data set and how we will handle them)\n", + "\n", + ". **Consistency** (we will check for duplicate values and how to handle them)\n", + "\n", + ". **Uniformity** ( we will check the data types as well as our columns naming for uniformity)\n", + "\n", + ". **Validity** (we will handlle irrelevant columns and check for outliers )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### COMPLETENESS" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "id 0\n", + "date 0\n", + "price 0\n", + "bedrooms 0\n", + "bathrooms 0\n", + "sqft_living 0\n", + "sqft_lot 0\n", + "floors 0\n", + "waterfront 2376\n", + "view 63\n", + "condition 0\n", + "grade 0\n", + "sqft_above 0\n", + "sqft_basement 0\n", + "yr_built 0\n", + "yr_renovated 3842\n", + "zipcode 0\n", + "lat 0\n", + "long 0\n", + "sqft_living15 0\n", + "sqft_lot15 0\n", + "dtype: int64" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# checking and summing up our missing values in our data set\n", + "kc_data_df.isnull().sum()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We seem to have missing values in our waterfront(2376),view(63) and yr_renovated(3842). We will have to investigate further" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The column waterfront has 2376 missing values, which is 11.0 % of it's total\n", + "The column view has 63 missing values, which is 0.3 % of it's total\n", + "The column yr_renovated has 3842 missing values, which is 17.8 % of it's total\n" + ] + } + ], + "source": [ + "# lets check for the percentage of missing values in our data set\n", + "for col in kc_data_df.columns: # we are using a for loop to iterate over our data\n", + " if kc_data_df[col].isnull().sum() > 0:\n", + " percentage = (kc_data_df[col].isnull().sum()/len(kc_data_df[col]))*100\n", + " print(\"The column\", col,\"has\",kc_data_df[col].isnull().sum(),\"missing values, which is\", round(percentage, 1),\"% of it's total\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets further check each column with missing values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Waterfront column" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets check for the value count of the unique elements" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Waterfront Column\n", + "\n", + "Number of distinct elements is: 2 \n", + "\n", + "This is the count of unique values:\n", + "NO 19075\n", + "YES 146\n", + "Name: waterfront, dtype: int64 \n", + "\n", + "The unique values:\n", + "[nan 'NO' 'YES'] \n", + "\n", + "Number of missing values: 2376\n" + ] + } + ], + "source": [ + "#checking for unique elements value count\n", + "print(\"The Waterfront Column\\n\")\n", + "\n", + "print(\"Number of distinct elements is:\", kc_data_df['waterfront'].nunique(),\"\\n\")\n", + "\n", + "print(\"This is the count of unique values:\")\n", + "print(kc_data_df['waterfront'].value_counts(),\"\\n\")\n", + "\n", + "print('The unique values:')\n", + "print(kc_data_df['waterfront'].unique(),\"\\n\")\n", + "\n", + "print(\"Number of missing values:\",kc_data_df['waterfront'].isnull().sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The two unique values are YES and NO.NO is the most common value in this column with(19875) entries, whilst YES has just (146). This indicates that the majority of these homes lack a waterfront, hence it seems reasonable to presume that the homes with missing values  lack a waterfront. it is safe to substitute the missing values with NO" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NO 21451\n", + "YES 146\n", + "Name: waterfront, dtype: int64\n", + "['NO' 'YES']\n" + ] + } + ], + "source": [ + "# replacing missing values with 'NO'\n", + "kc_data_df['waterfront'].fillna('NO',inplace=True)\n", + "\n", + "# confirming if the missing values have been replaced\n", + "print(kc_data_df['waterfront'].value_counts())\n", + "print(kc_data_df['waterfront'].unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The change was successful because the number of NO entries increased from 19875 to 21451." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ###### View column" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets create a function to get our unique elements and sum up there value counts" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "def unique_counts(data, column): # creating a function for checking for unique elements and ther counts\n", + " print(\"Number of distinct elements in\", column, \"column:\", data[column].nunique()) # checking for unique elements in the column\n", + "\n", + " value_counts = data[column].value_counts() # counting the value of each unique element\n", + "\n", + " # Use Series.apply with a Lambda Function\n", + " format_lambda = lambda x: f\"{x}: {value_counts[x]} ({value_counts[x] / len(data) * 100:.1f}%)\"\n", + "\n", + " formatted_counts = value_counts.index.map(format_lambda) # it will execute without creating the formatted_counts variable or printing its contents.\n", + " print(formatted_counts)\n", + "\n", + " print(f\"\\nMissing values:\", data[column].isnull().sum()) # combining the information\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of distinct elements in view column: 5\n", + "Index(['NONE: 19422 (89.9%)', 'AVERAGE: 957 (4.4%)', 'GOOD: 508 (2.4%)',\n", + " 'FAIR: 330 (1.5%)', 'EXCELLENT: 317 (1.5%)'],\n", + " dtype='object')\n", + "\n", + "Missing values: 63\n" + ] + } + ], + "source": [ + "unique_counts(kc_data_df,'view')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this column, NONE is the most frequent unique element. This indicates that the 63 missing values are representing homes that don't have a view. Hence I WILL substitute the missing values with NONE." + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NONE 19485\n", + "AVERAGE 957\n", + "GOOD 508\n", + "FAIR 330\n", + "EXCELLENT 317\n", + "Name: view, dtype: int64\n", + "['NONE' 'GOOD' 'EXCELLENT' 'AVERAGE' 'FAIR']\n" + ] + } + ], + "source": [ + "# replacing missing values with 'NONE'\n", + "kc_data_df['view'].fillna('NONE',inplace=True)\n", + "\n", + "# confirming if the missing values have been replaced\n", + "print(kc_data_df['view'].value_counts())\n", + "print(kc_data_df['view'].unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Changes successfully made" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###### Yr_renovated column" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of distinct elements in yr_renovated column: 70\n", + "Index(['0.0: 17011 (78.8%)', '2014.0: 73 (0.3%)', '2003.0: 31 (0.1%)',\n", + " '2013.0: 31 (0.1%)', '2007.0: 30 (0.1%)', '2000.0: 29 (0.1%)',\n", + " '2005.0: 29 (0.1%)', '1990.0: 22 (0.1%)', '2004.0: 22 (0.1%)',\n", + " '2009.0: 21 (0.1%)', '1989.0: 20 (0.1%)', '2006.0: 20 (0.1%)',\n", + " '2002.0: 17 (0.1%)', '1991.0: 16 (0.1%)', '1998.0: 16 (0.1%)',\n", + " '1984.0: 16 (0.1%)', '1999.0: 15 (0.1%)', '2008.0: 15 (0.1%)',\n", + " '2010.0: 15 (0.1%)', '2001.0: 15 (0.1%)', '1983.0: 15 (0.1%)',\n", + " '2015.0: 14 (0.1%)', '1985.0: 14 (0.1%)', '1986.0: 14 (0.1%)',\n", + " '1987.0: 14 (0.1%)', '1994.0: 14 (0.1%)', '1992.0: 13 (0.1%)',\n", + " '1993.0: 12 (0.1%)', '1997.0: 12 (0.1%)', '1995.0: 12 (0.1%)',\n", + " '1996.0: 11 (0.1%)', '1988.0: 11 (0.1%)', '1970.0: 9 (0.0%)',\n", + " '2011.0: 9 (0.0%)', '1980.0: 8 (0.0%)', '1982.0: 8 (0.0%)',\n", + " '2012.0: 8 (0.0%)', '1979.0: 7 (0.0%)', '1977.0: 7 (0.0%)',\n", + " '1968.0: 7 (0.0%)', '1975.0: 5 (0.0%)', '1964.0: 5 (0.0%)',\n", + " '1969.0: 4 (0.0%)', '1963.0: 4 (0.0%)', '1973.0: 4 (0.0%)',\n", + " '1981.0: 4 (0.0%)', '1965.0: 4 (0.0%)', '1978.0: 3 (0.0%)',\n", + " '1960.0: 3 (0.0%)', '1958.0: 3 (0.0%)', '1956.0: 3 (0.0%)',\n", + " '1955.0: 3 (0.0%)', '1945.0: 3 (0.0%)', '1972.0: 3 (0.0%)',\n", + " '1967.0: 2 (0.0%)', '1957.0: 2 (0.0%)', '1940.0: 2 (0.0%)',\n", + " '1974.0: 2 (0.0%)', '1962.0: 2 (0.0%)', '1953.0: 1 (0.0%)',\n", + " '1950.0: 1 (0.0%)', '1934.0: 1 (0.0%)', '1944.0: 1 (0.0%)',\n", + " '1976.0: 1 (0.0%)', '1948.0: 1 (0.0%)', '1946.0: 1 (0.0%)',\n", + " '1959.0: 1 (0.0%)', '1971.0: 1 (0.0%)', '1951.0: 1 (0.0%)',\n", + " '1954.0: 1 (0.0%)'],\n", + " dtype='object')\n", + "\n", + "Missing values: 3842\n" + ] + } + ], + "source": [ + "unique_counts(kc_data_df,'yr_renovated' )# using the unique_count function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " The years span from 1948–2014 and 0.0 is the most frequent value thus we'll replace the missing values with 0.0 because we don't know what 0.0 means based  on this data." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 20853\n", + "2014.0 73\n", + "2003.0 31\n", + "2013.0 31\n", + "2007.0 30\n", + " ... \n", + "1946.0 1\n", + "1959.0 1\n", + "1971.0 1\n", + "1951.0 1\n", + "1954.0 1\n", + "Name: yr_renovated, Length: 70, dtype: int64\n", + "[ 0. 1991. 2002. 2010. 1992. 2013. 1994. 1978. 2005. 2003. 1984. 1954.\n", + " 2014. 2011. 1983. 1945. 1990. 1988. 1977. 1981. 1995. 2000. 1999. 1998.\n", + " 1970. 1989. 2004. 1986. 2007. 1987. 2006. 1985. 2001. 1980. 1971. 1979.\n", + " 1997. 1950. 1969. 1948. 2009. 2015. 1974. 2008. 1968. 2012. 1963. 1951.\n", + " 1962. 1953. 1993. 1996. 1955. 1982. 1956. 1940. 1976. 1946. 1975. 1964.\n", + " 1973. 1957. 1959. 1960. 1967. 1965. 1934. 1972. 1944. 1958.]\n" + ] + } + ], + "source": [ + "# replacing missing values with '0.0'\n", + "kc_data_df['yr_renovated'].fillna(0.0,inplace=True)\n", + "\n", + "# confirming if the missing values have been replaced\n", + "print(kc_data_df['yr_renovated'].value_counts())\n", + "print(kc_data_df['yr_renovated'].unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The changes are made successfully" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "id 0\n", + "date 0\n", + "price 0\n", + "bedrooms 0\n", + "bathrooms 0\n", + "sqft_living 0\n", + "sqft_lot 0\n", + "floors 0\n", + "waterfront 0\n", + "view 0\n", + "condition 0\n", + "grade 0\n", + "sqft_above 0\n", + "sqft_basement 0\n", + "yr_built 0\n", + "yr_renovated 0\n", + "zipcode 0\n", + "lat 0\n", + "long 0\n", + "sqft_living15 0\n", + "sqft_lot15 0\n", + "dtype: int64" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# checking to see if there are any more missing values\n", + "kc_data_df.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No missing values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " #### CONSISTENCY" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Checking for duplicate values\n", + "kc_data_df.duplicated().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are no duplicate values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### UNIFORMITY" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Converting Data Types of Values in Columns from Object to Float**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The sqft_basement values are in objects data type, given that this column has numeric values.  let's try to investigate  the reason why the datatype isn't a float or integer. " + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0 12826\n", + "? 454\n", + "600.0 217\n", + "500.0 209\n", + "700.0 208\n", + " ... \n", + "1880.0 1\n", + "768.0 1\n", + "666.0 1\n", + "1284.0 1\n", + "2050.0 1\n", + "Name: sqft_basement, Length: 304, dtype: int64" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kc_data_df['sqft_basement'].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " These values represented by \"?\" string can be regarded as null values. We will replace the \"?\"  with 0.0, because the majority of the values are at 0.0." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('float64')" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# replacing the ? with 0.0\n", + "kc_data_df['sqft_basement'].replace('?','0.0',inplace=True)\n", + "\n", + "#converting column to data type 'float'\n", + "kc_data_df['sqft_basement'] = kc_data_df['sqft_basement'].astype(float)\n", + "\n", + "#confirming the change \n", + "kc_data_df['sqft_basement'].dtype" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have successfully changed the data type to a float" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **Converting the Date Column to month and year and Creating new Columns month and year**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The month and year the houses were sold are shown in the date column and data can be analysed easily by creating new columns called year and month  from this column, " + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame after splitting date:\n", + " id price bedrooms bathrooms sqft_living sqft_lot floors \\\n", + "0 7129300520 221900.0 3 1.00 1180 5650 1.0 \n", + "1 6414100192 538000.0 3 2.25 2570 7242 2.0 \n", + "2 5631500400 180000.0 2 1.00 770 10000 1.0 \n", + "3 2487200875 604000.0 4 3.00 1960 5000 1.0 \n", + "4 1954400510 510000.0 3 2.00 1680 8080 1.0 \n", + "\n", + " waterfront view condition ... sqft_basement yr_built yr_renovated \\\n", + "0 NO NONE Average ... 0.0 1955 0.0 \n", + "1 NO NONE Average ... 400.0 1951 1991.0 \n", + "2 NO NONE Average ... 0.0 1933 0.0 \n", + "3 NO NONE Very Good ... 910.0 1965 0.0 \n", + "4 NO NONE Average ... 0.0 1987 0.0 \n", + "\n", + " zipcode lat long sqft_living15 sqft_lot15 month_sold year_sold \n", + "0 98178 47.5112 -122.257 1340 5650 10 2014 \n", + "1 98125 47.7210 -122.319 1690 7639 12 2014 \n", + "2 98028 47.7379 -122.233 2720 8062 2 2015 \n", + "3 98136 47.5208 -122.393 1360 5000 12 2014 \n", + "4 98074 47.6168 -122.045 1800 7503 2 2015 \n", + "\n", + "[5 rows x 22 columns]\n" + ] + } + ], + "source": [ + "# Spliting the date into month, day, and year\n", + "date_split = kc_data_df['date'].str.split('/', expand=True)\n", + "\n", + "# Creating new columns for month and year and converting the values to integers\n", + "kc_data_df['month_sold'] = date_split[0].astype(int)\n", + "kc_data_df['year_sold'] = date_split[2].astype(int)\n", + "\n", + "# Droping the original date column\n", + "kc_data_df.drop(columns=['date'], inplace=True)\n", + "\n", + "# Verifying the changes\n", + "print(\"DataFrame after splitting date:\")\n", + "print(kc_data_df.head())\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can seen the two columns have been created and added to our dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### VALIDITY" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "id 5.185851e+09\n", + "price 3.230000e+05\n", + "bedrooms 1.000000e+00\n", + "bathrooms 7.500000e-01\n", + "sqft_living 1.120000e+03\n", + "sqft_lot 5.645000e+03\n", + "floors 1.000000e+00\n", + "sqft_above 1.020000e+03\n", + "sqft_basement 5.500000e+02\n", + "yr_built 4.600000e+01\n", + "yr_renovated 0.000000e+00\n", + "zipcode 8.500000e+01\n", + "lat 2.069000e-01\n", + "long 2.030000e-01\n", + "sqft_living15 8.700000e+02\n", + "sqft_lot15 4.983000e+03\n", + "month_sold 5.000000e+00\n", + "year_sold 1.000000e+00\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "#checking for outliers using intequatrile for each column\n", + "\n", + "Q1 = kc_data_df.quantile(0.25) # First quartile\n", + "Q3 = kc_data_df.quantile(0.75) # Third quartile\n", + "IQR = Q3 - Q1\n", + "\n", + "print(IQR)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we have the above outliers lets visualize them using boxplots to investigate further" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Plotting box plots to visualize our outliers\n", + "# Creating a list of column names excluding non-numeric columns (if any)\n", + "numeric_columns = kc_data_df.select_dtypes(include=['number']).columns\n", + "\n", + "# Seting up the figure and axes\n", + "fig, axes = plt.subplots(nrows=len(numeric_columns), figsize=(10, 6 * len(numeric_columns)))\n", + "\n", + "# Iterating over each numeric column and create a boxplot\n", + "for i, column in enumerate(numeric_columns):\n", + " ax = axes[i] if len(numeric_columns) > 1 else axes # If there's only one numeric column, axes is not a list\n", + " \n", + " # Creating the boxplots\n", + " sns.boxplot(x=kc_data_df[column], ax=ax)\n", + " \n", + " # Seting titles and labels\n", + " ax.set_title(f'Boxplot of {column}')\n", + " ax.set_xlabel(column)\n", + " \n", + "\n", + "plt.tight_layout(pad=3.0) # Adjusting the spacing between subplots\n", + "plt.subplots_adjust(top=0.95) # Adjusting the top margin to accommodate titles \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is a significant amount of outliers in a number of our columns let remove them" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "# Removing the outliers \n", + "# outliers_df_iqr = kc_data_df[~((kc_data_df < (Q1 - 1.5 * IQR)) |(kc_data_df > (Q3 + 1.5 * IQR))).any(axis=1)]\n", + "\n", + "#print(outliers_df_iqr.shape) # The number of rows and columns in the new dataframe" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After we began modelling we chose to undo the removing of outlier since the removal of outliers really affected the performance of our models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Conversion of the bedroom ,zip code and floors feature into a Categorical Feature\n", + "\n", + "Analysing the `bedroom`,'zipcode' and floors features in our dataset we observe that although they are stored in numerical form, they are actually a categorical features." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "# creating a function to change the data type of values of a specific column\n", + "def change_dtype(df, column_name):\n", + " df[column_name] = df[column_name].astype('category')\n", + " new_dtype = df[column_name].dtype\n", + " return new_dtype\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CategoricalDtype(categories=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 33], ordered=False)" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "change_dtype(kc_data_df, 'bedrooms') # changing the bedroom feature into categorical data type" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CategoricalDtype(categories=[1.0, 1.5, 2.0, 2.5, 3.0, 3.5], ordered=False)" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "change_dtype(kc_data_df, 'floors') # changing the floors feature into categorical data type" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CategoricalDtype(categories=[98001, 98002, 98003, 98004, 98005, 98006, 98007, 98008,\n", + " 98010, 98011, 98014, 98019, 98022, 98023, 98024, 98027,\n", + " 98028, 98029, 98030, 98031, 98032, 98033, 98034, 98038,\n", + " 98039, 98040, 98042, 98045, 98052, 98053, 98055, 98056,\n", + " 98058, 98059, 98065, 98070, 98072, 98074, 98075, 98077,\n", + " 98092, 98102, 98103, 98105, 98106, 98107, 98108, 98109,\n", + " 98112, 98115, 98116, 98117, 98118, 98119, 98122, 98125,\n", + " 98126, 98133, 98136, 98144, 98146, 98148, 98155, 98166,\n", + " 98168, 98177, 98178, 98188, 98198, 98199],\n", + " ordered=False)" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "change_dtype(kc_data_df, 'zipcode') # changing the zipcode feature into categorical data type" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### FEATURE ENGINEERING" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets create additional columns to determine the age of a house by getting the differnce between 2015 (that's when the data was last recorded) the reference year and yr_built, and another column age of the house after renovation by also getting the difference between 2015 and yr_renovated \n", + "\n", + "These new columns will help to determine whether the age of built or renovation has an impact on the price of the house" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "# creating a new column 'age_built' showing the age of house since its was built upto 2015\n", + "kc_data_df['age_built'] = 2015 - kc_data_df['yr_built']" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "#creating a new column 'age_renovated'showing the age of a house after renovation\n", + "kc_data_df['age_renovated'] = (2015 - kc_data_df['yr_renovated']).apply(lambda x: 0 if x == 2015 else x)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['id', 'price', 'bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot',\n", + " 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above',\n", + " 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long',\n", + " 'sqft_living15', 'sqft_lot15', 'month_sold', 'year_sold', 'age_built',\n", + " 'age_renovated'],\n", + " dtype='object')" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kc_data_df.columns # checking to see if the two columns have been added" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idpricebedroomsbathroomssqft_livingsqft_lotfloorswaterfrontviewcondition...yr_renovatedzipcodelatlongsqft_living15sqft_lot15month_soldyear_soldage_builtage_renovated
07129300520221900.031.00118056501.0NONONEAverage...0.09817847.5112-122.25713405650102014600.0
16414100192538000.032.25257072422.0NONONEAverage...1991.09812547.7210-122.319169076391220146424.0
25631500400180000.021.00770100001.0NONONEAverage...0.09802847.7379-122.2332720806222015820.0
32487200875604000.043.00196050001.0NONONEVery Good...0.09813647.5208-122.39313605000122014500.0
41954400510510000.032.00168080801.0NONONEAverage...0.09807447.6168-122.0451800750322015280.0
572375503101230000.044.5054201019301.0NONONEAverage...0.09805347.6561-122.005476010193052014140.0
61321400060257500.032.25171568192.0NONONEAverage...0.09800347.3097-122.3272238681962014200.0
72008000270291850.031.50106097111.0NONONEAverage...0.09819847.4095-122.3151650971112015520.0
82414600126229500.031.00178074701.0NONONEAverage...0.09814647.5123-122.3371780811342015550.0
93793500160323000.032.50189065602.0NONONEAverage...0.09803847.3684-122.0312390757032015120.0
\n", + "

10 rows × 24 columns

\n", + "
" + ], + "text/plain": [ + " id price bedrooms bathrooms sqft_living sqft_lot floors \\\n", + "0 7129300520 221900.0 3 1.00 1180 5650 1.0 \n", + "1 6414100192 538000.0 3 2.25 2570 7242 2.0 \n", + "2 5631500400 180000.0 2 1.00 770 10000 1.0 \n", + "3 2487200875 604000.0 4 3.00 1960 5000 1.0 \n", + "4 1954400510 510000.0 3 2.00 1680 8080 1.0 \n", + "5 7237550310 1230000.0 4 4.50 5420 101930 1.0 \n", + "6 1321400060 257500.0 3 2.25 1715 6819 2.0 \n", + "7 2008000270 291850.0 3 1.50 1060 9711 1.0 \n", + "8 2414600126 229500.0 3 1.00 1780 7470 1.0 \n", + "9 3793500160 323000.0 3 2.50 1890 6560 2.0 \n", + "\n", + " waterfront view condition ... yr_renovated zipcode lat long \\\n", + "0 NO NONE Average ... 0.0 98178 47.5112 -122.257 \n", + "1 NO NONE Average ... 1991.0 98125 47.7210 -122.319 \n", + "2 NO NONE Average ... 0.0 98028 47.7379 -122.233 \n", + "3 NO NONE Very Good ... 0.0 98136 47.5208 -122.393 \n", + "4 NO NONE Average ... 0.0 98074 47.6168 -122.045 \n", + "5 NO NONE Average ... 0.0 98053 47.6561 -122.005 \n", + "6 NO NONE Average ... 0.0 98003 47.3097 -122.327 \n", + "7 NO NONE Average ... 0.0 98198 47.4095 -122.315 \n", + "8 NO NONE Average ... 0.0 98146 47.5123 -122.337 \n", + "9 NO NONE Average ... 0.0 98038 47.3684 -122.031 \n", + "\n", + " sqft_living15 sqft_lot15 month_sold year_sold age_built age_renovated \n", + "0 1340 5650 10 2014 60 0.0 \n", + "1 1690 7639 12 2014 64 24.0 \n", + "2 2720 8062 2 2015 82 0.0 \n", + "3 1360 5000 12 2014 50 0.0 \n", + "4 1800 7503 2 2015 28 0.0 \n", + "5 4760 101930 5 2014 14 0.0 \n", + "6 2238 6819 6 2014 20 0.0 \n", + "7 1650 9711 1 2015 52 0.0 \n", + "8 1780 8113 4 2015 55 0.0 \n", + "9 2390 7570 3 2015 12 0.0 \n", + "\n", + "[10 rows x 24 columns]" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kc_data_df.head(10) # viewing the first ten rows of our data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "lets create a new column named season_sold that tell us which at which season was a specific house sold at these will helps us to identify which season had the most sales and whether season determines the price of a house" + ] + }, + { + "cell_type": "code", + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ - "# Your code here - remember to use markdown cells for comments as well!" + "# creating a season dictonary using months in numerical order\n", + "season_dict = {1:'Winter',\n", + " 2:'Winter',\n", + " 3:'Spring',\n", + " 4:'Spring',\n", + " 5:'Spring',\n", + " 6:'Summer',\n", + " 7:'Summer',\n", + " 8:'Summer',\n", + " 9:'Fall',\n", + " 10:'Fall',\n", + " 11:'Fall',\n", + " 12:'Winter'}\n", + "# creating a new column and mapping it to season_dict\n", + "kc_data_df['season_sold'] = kc_data_df['month_sold'].map(season_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "scrolled": false + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idpricebedroomsbathroomssqft_livingsqft_lotfloorswaterfrontviewcondition...zipcodelatlongsqft_living15sqft_lot15month_soldyear_soldage_builtage_renovatedseason_sold
07129300520221900.031.00118056501.0NONONEAverage...9817847.5112-122.25713405650102014600.0Fall
16414100192538000.032.25257072422.0NONONEAverage...9812547.7210-122.319169076391220146424.0Winter
25631500400180000.021.00770100001.0NONONEAverage...9802847.7379-122.2332720806222015820.0Winter
32487200875604000.043.00196050001.0NONONEVery Good...9813647.5208-122.39313605000122014500.0Winter
41954400510510000.032.00168080801.0NONONEAverage...9807447.6168-122.0451800750322015280.0Winter
..................................................................
21592263000018360000.032.50153011313.0NONONEAverage...9810347.6993-122.346153015095201460.0Spring
215936600060120400000.042.50231058132.0NONONEAverage...9814647.5107-122.362183072002201510.0Winter
215941523300141402101.020.75102013502.0NONONEAverage...9814447.5944-122.299102020076201460.0Summer
21595291310100400000.032.50160023882.0NONONEAverage...9802747.5345-122.0691410128712015110.0Winter
215961523300157325000.020.75102010762.0NONONEAverage...9814447.5941-122.2991020135710201470.0Fall
\n", + "

21597 rows × 25 columns

\n", + "
" + ], + "text/plain": [ + " id price bedrooms bathrooms sqft_living sqft_lot floors \\\n", + "0 7129300520 221900.0 3 1.00 1180 5650 1.0 \n", + "1 6414100192 538000.0 3 2.25 2570 7242 2.0 \n", + "2 5631500400 180000.0 2 1.00 770 10000 1.0 \n", + "3 2487200875 604000.0 4 3.00 1960 5000 1.0 \n", + "4 1954400510 510000.0 3 2.00 1680 8080 1.0 \n", + "... ... ... ... ... ... ... ... \n", + "21592 263000018 360000.0 3 2.50 1530 1131 3.0 \n", + "21593 6600060120 400000.0 4 2.50 2310 5813 2.0 \n", + "21594 1523300141 402101.0 2 0.75 1020 1350 2.0 \n", + "21595 291310100 400000.0 3 2.50 1600 2388 2.0 \n", + "21596 1523300157 325000.0 2 0.75 1020 1076 2.0 \n", + "\n", + " waterfront view condition ... zipcode lat long \\\n", + "0 NO NONE Average ... 98178 47.5112 -122.257 \n", + "1 NO NONE Average ... 98125 47.7210 -122.319 \n", + "2 NO NONE Average ... 98028 47.7379 -122.233 \n", + "3 NO NONE Very Good ... 98136 47.5208 -122.393 \n", + "4 NO NONE Average ... 98074 47.6168 -122.045 \n", + "... ... ... ... ... ... ... ... \n", + "21592 NO NONE Average ... 98103 47.6993 -122.346 \n", + "21593 NO NONE Average ... 98146 47.5107 -122.362 \n", + "21594 NO NONE Average ... 98144 47.5944 -122.299 \n", + "21595 NO NONE Average ... 98027 47.5345 -122.069 \n", + "21596 NO NONE Average ... 98144 47.5941 -122.299 \n", + "\n", + " sqft_living15 sqft_lot15 month_sold year_sold age_built \\\n", + "0 1340 5650 10 2014 60 \n", + "1 1690 7639 12 2014 64 \n", + "2 2720 8062 2 2015 82 \n", + "3 1360 5000 12 2014 50 \n", + "4 1800 7503 2 2015 28 \n", + "... ... ... ... ... ... \n", + "21592 1530 1509 5 2014 6 \n", + "21593 1830 7200 2 2015 1 \n", + "21594 1020 2007 6 2014 6 \n", + "21595 1410 1287 1 2015 11 \n", + "21596 1020 1357 10 2014 7 \n", + "\n", + " age_renovated season_sold \n", + "0 0.0 Fall \n", + "1 24.0 Winter \n", + "2 0.0 Winter \n", + "3 0.0 Winter \n", + "4 0.0 Winter \n", + "... ... ... \n", + "21592 0.0 Spring \n", + "21593 0.0 Winter \n", + "21594 0.0 Summer \n", + "21595 0.0 Winter \n", + "21596 0.0 Fall \n", + "\n", + "[21597 rows x 25 columns]" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kc_data_df # checking if the new column was added" ] } ], @@ -40,7 +2057,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.8.5" } }, "nbformat": 4,