Types of Features

# pandas — core data library for tabular work, always imported as pd
import pandas as pd

# numpy — numerical Python, gives us log transform and mathematical ops
import numpy as np

# Realistic housing dataset — 10 rows
housing_df = pd.DataFrame({
    'sqft':         [1200, 2100, 980, 2850, 1450, 1800, 1050, 3100, 880, 5800],
    'house_age':    [46, 19, 61, 6, 33, 23, 49, 9, 36, 4],
    'num_bedrooms': [3, 4, 2, 5, 3, 4, 2, 5, 3, 6],
    'num_floors':   [1, 2, 1, 3, 2, 2, 1, 3, 1, 4],
    'sale_price':   [245000, 410000, 182000, 560000,
                     295000, 348000, 198000, 620000, 230000, 1250000]
})

# .describe() — the fastest full profile of a numerical column
# Key things to look for:
#   mean >> median (50%) = right skew (long tail of high values)
#   max >> 75th percentile = potential outlier worth investigating
print("=== Numerical Profile ===\n")
print(housing_df.describe().round(0).to_string())

# .skew() — measure distributional asymmetry per column
# Rule of thumb: |skew| > 1.0 = highly skewed, consider log transform
print("\n=== Skewness ===\n")
for col in housing_df.columns:
    sk   = housing_df[col].skew()
    note = "  ← log transform recommended" if abs(sk) > 1.0 else ""
    print(f"  {col:<15}  {sk:+.3f}{note}")

import pandas as pd

housing_df = pd.DataFrame({
    'neighbourhood': ['north','east','south','east','north',
                      'west','south','east','north','west'],
    'condition':     ['good','fair','excellent','poor','good',
                      'excellent','fair','poor','good','excellent'],
    'sale_price':    [245000,410000,182000,560000,295000,
                      348000,198000,620000,230000,580000]
})

# NOMINAL encoding — pd.get_dummies() creates one binary column per category
# drop_first=True removes one redundant column (north is implied when east=0 and others=0)
# prefix='nbhd' keeps column names readable when you have many encoded features
nominal_encoded = pd.get_dummies(
    housing_df['neighbourhood'], prefix='nbhd', drop_first=True)

print("Nominal (one-hot) encoding — neighbourhood:\n")
print(pd.concat([housing_df['neighbourhood'], nominal_encoded], axis=1).to_string(index=False))

# ORDINAL encoding — map each label to an integer that reflects its true ranking
# The dictionary order is your explicit statement of the ranking
ordinal_map = {'poor': 0, 'fair': 1, 'good': 2, 'excellent': 3}
housing_df['condition_encoded'] = housing_df['condition'].map(ordinal_map)

print("\nOrdinal encoding — condition:\n")
print(housing_df[['condition','condition_encoded','sale_price']].to_string(index=False))

# Validate: does the ordinal encoding actually track sale price correctly?
print("\nMean sale price by condition rank:")
print(housing_df.groupby('condition_encoded')['sale_price'].mean().round(0).to_string())

import pandas as pd

housing_df = pd.DataFrame({
    'sale_date':  ['2023-01-12','2023-04-03','2022-11-22','2023-06-15',
                   '2022-09-08','2023-03-28','2022-07-14','2023-08-01',
                   '2022-12-05','2023-05-19'],
    'sale_price': [245000,380000,210000,430000,
                   295000,360000,400000,450000,220000,410000]
})

# pd.to_datetime() converts text strings into real datetime64 objects
# pandas cannot extract month or year from a plain string — this step is mandatory
housing_df['sale_date'] = pd.to_datetime(housing_df['sale_date'])

# .dt is the datetime accessor — unlocks all date/time properties on a Series
housing_df['sale_year']    = housing_df['sale_date'].dt.year
housing_df['sale_month']   = housing_df['sale_date'].dt.month
housing_df['sale_quarter'] = housing_df['sale_date'].dt.quarter
housing_df['sale_dow']     = housing_df['sale_date'].dt.dayofweek   # 0=Mon 6=Sun

# Validate each extracted feature — only keep what actually carries signal
print("Correlation with sale_price:\n")
for col in ['sale_year','sale_month','sale_quarter','sale_dow']:
    corr = housing_df[col].corr(housing_df['sale_price'])
    keep = "  ✓ keep" if abs(corr) > 0.3 else "  — weak signal"
    print(f"  {col:<15}  {corr:+.3f}{keep}")

print("\nExtracted datetime features:\n")
print(housing_df[['sale_date','sale_year','sale_month',
                  'sale_quarter','sale_dow','sale_price']].to_string(index=False))

import pandas as pd

housing_df = pd.DataFrame({
    'garage': ['yes','yes','no','yes','no','yes','no','yes','yes','yes'],
    'garden': ['yes','yes','yes','yes','yes','yes','yes','yes','yes','no'],
    'sale_price': [245000,410000,182000,560000,295000,
                   348000,198000,620000,230000,580000]
})

# Check class balance before encoding
# A feature where one value makes up 90%+ of rows rarely adds useful signal
print("Class balance check:\n")
for col in ['garage', 'garden']:
    counts = housing_df[col].value_counts()
    pct    = housing_df[col].value_counts(normalize=True).mul(100).round(1)
    print(f"  {col}:")
    for val in counts.index:
        print(f"    {val:<6}  {counts[val]}  ({pct[val]}%)")
    print()

# Convert yes/no strings to 1/0 integers using comparison + .astype(int)
# (col == 'yes') creates a True/False Series, .astype(int) converts to 1/0
housing_df['has_garage'] = (housing_df['garage'] == 'yes').astype(int)
housing_df['has_garden'] = (housing_df['garden'] == 'yes').astype(int)

# Validate both features
print("Correlation with sale_price:\n")
for col in ['has_garage', 'has_garden']:
    corr = housing_df[col].corr(housing_df['sale_price'])
    print(f"  {col:<15}  {corr:+.3f}")