What Are Features?

# pandas — core data manipulation library, always imported as pd
import pandas as pd

# numpy — numerical Python library, imported as np
# used here for np.nan — the standard way to represent a missing value
import numpy as np

# A realistic loan applications dataset — 10 rows, 8 columns
loan_df = pd.DataFrame({
    'application_id':   ['L001','L002','L003','L004','L005',
                         'L006','L007','L008','L009','L010'],
    'application_date': ['2023-01-15','2023-02-03','2023-02-18','2023-03-07',
                         '2023-03-22','2023-04-10','2023-05-01','2023-05-19',
                         '2023-06-08','2023-06-25'],
    'loan_amount':      [150000,320000,85000,500000,210000,
                         175000,430000,95000,280000,360000],
    'annual_income':    [52000,95000,38000,140000,67000,
                         48000,112000,41000,78000,105000],
    'employment_type':  ['employed','self-employed','employed','employed',
                         'unemployed','employed','self-employed',
                         'employed','employed','self-employed'],
    'credit_score':     [720,810,640,890,580,695,775,660,740,820],
    'property_type':    ['apartment','house','apartment','house','apartment',
                         'house','house','apartment','house','apartment'],
    'approved':         [1,1,0,1,0,0,1,0,1,1]   # target: 1=approved, 0=rejected
})

# .dtypes shows the data type pandas assigned to every column
# object = text/string | int64 = integer | float64 = decimal number
print("Column dtypes:\n")
print(loan_df.dtypes)

# A manual audit dictionary — classify every column by its role
# This becomes a shared reference document for the whole team
audit = {
    'application_id':   'IDENTIFIER  — drop before training, no signal',
    'application_date': 'DATETIME    — parse and extract month, quarter, DOW',
    'loan_amount':      'NUMERICAL   — check skew and outliers',
    'annual_income':    'NUMERICAL   — check skew and outliers',
    'employment_type':  'CATEGORICAL — one-hot encode before use',
    'credit_score':     'NUMERICAL   — already on a standard scale',
    'property_type':    'CATEGORICAL — one-hot encode before use',
    'approved':         'TARGET      — predict this, never use as input'
}

print("\nFeature audit:\n")
for col, verdict in audit.items():
    print(f"  {col:<20}  {verdict}")

import pandas as pd

loan_df = pd.DataFrame({
    'loan_amount':   [150000,320000,85000,500000,210000,
                      175000,430000,95000,280000,360000],
    'annual_income': [52000,95000,38000,140000,67000,
                      48000,112000,41000,78000,105000],
    'credit_score':  [720,810,640,890,580,695,775,660,740,820],
    'approved':      [1,1,0,1,0,0,1,0,1,1]
})

# .describe() runs count, mean, std, min, quartiles and max in one shot
# std = standard deviation — measures how spread out values are from the mean
# A large gap between mean and max hints at right skew or outliers
print("Summary statistics:\n")
print(loan_df[['loan_amount','annual_income','credit_score']].describe().round(0))

# .skew() measures distributional asymmetry
# Positive = long right tail (a few very large values pulling the mean up)
# Negative = long left tail
# Rule of thumb: |skew| > 1.0 = highly skewed, consider log transform
print("\nSkewness check:\n")
for col in ['loan_amount', 'annual_income', 'credit_score']:
    sk   = loan_df[col].skew()
    flag = "  ← consider log transform" if abs(sk) > 1.0 else "  ✓ acceptable"
    print(f"  {col:<20}  {sk:+.3f}{flag}")

import pandas as pd

loan_df = pd.DataFrame({
    'employment_type': ['employed','self-employed','employed','employed',
                        'unemployed','employed','self-employed',
                        'employed','employed','self-employed'],
    'approved': [1,1,0,1,0,0,1,0,1,1]
})

# .value_counts() shows category distribution — check for imbalance before encoding
# A category with only 1 row causes problems in train/test splits
print("Category distribution:\n")
print(loan_df['employment_type'].value_counts())

# pd.get_dummies() — pandas built-in one-hot encoder
# Creates one binary column per category (1 = row has that category, 0 = it doesn't)
# prefix='emp' adds a readable prefix to every new column name
# drop_first=True drops one column to avoid the dummy variable trap
#   (if self-employed=0 and unemployed=0, the person must be employed — no third column needed)
encoded = pd.get_dummies(loan_df['employment_type'],
                         prefix='emp',
                         drop_first=True)

result = pd.concat([encoded, loan_df['approved']], axis=1)

print("\nAfter one-hot encoding:\n")
print(result.to_string())

import pandas as pd

loan_df = pd.DataFrame({
    'application_date': ['2023-01-15','2023-02-03','2023-02-18','2023-03-07',
                         '2023-03-22','2023-04-10','2023-05-01','2023-05-19',
                         '2023-06-08','2023-06-25'],
    'approved': [1,1,0,1,0,0,1,0,1,1]
})

# pd.to_datetime() converts text strings into proper datetime64 objects
# Without this step, Python treats '2023-01-15' as plain text — no date maths possible
loan_df['application_date'] = pd.to_datetime(loan_df['application_date'])

# .dt is the datetime accessor — it unlocks all date/time properties on a Series
# Without .dt, calling .month on a column throws an AttributeError
loan_df['app_month']   = loan_df['application_date'].dt.month      # 1=Jan, 12=Dec
loan_df['app_quarter'] = loan_df['application_date'].dt.quarter    # Q1–Q4
loan_df['app_dow']     = loan_df['application_date'].dt.dayofweek  # 0=Mon, 6=Sun
loan_df['app_year']    = loan_df['application_date'].dt.year

# Show extracted features alongside the original and target
print(loan_df[['application_date','app_month','app_quarter',
               'app_dow','app_year','approved']].to_string(index=False))

import pandas as pd

loan_df = pd.DataFrame({
    'description': [
        'stable government job for ten years',
        'running my own consultancy business since 2018',
        'between jobs currently looking for work',
        'senior engineer at large tech company permanent contract',
        'recently made redundant still searching',
        'part time work irregular hours',
        'director of ltd company profitable for five years',
        'temporary contract ending soon',
        'nurse full time NHS permanent',
        'freelance designer multiple clients regular income'
    ],
    'approved': [1,1,0,1,0,0,1,0,1,1]
})

# Basic text feature 1: word count — longer descriptions may indicate more stability
# .str.split() splits each string into a list of words
# .str.len() counts how many words are in that list
loan_df['word_count'] = loan_df['description'].str.split().str.len()

# Basic text feature 2: keyword flags — presence of high-signal words
# .str.contains() returns True/False — .astype(int) converts to 1/0
loan_df['has_permanent'] = loan_df['description'].str.contains(
    'permanent|stable|full time', case=False).astype(int)

loan_df['has_risk_word'] = loan_df['description'].str.contains(
    'redundant|temporary|irregular|searching|between', case=False).astype(int)

# Check whether our new text features correlate with approval
print("Text feature correlations with approved:\n")
for col in ['word_count', 'has_permanent', 'has_risk_word']:
    corr = loan_df[col].corr(loan_df['approved'])
    print(f"  {col:<18}  {corr:+.3f}")

print("\nSample output:\n")
print(loan_df[['description','word_count',
               'has_permanent','has_risk_word','approved']].to_string(index=False))