Analyzing Selling Price of used Cars using Python

Introduction

Analyzing the selling price of used cars is crucial for both buyers and sellers in the automotive market. By leveraging Python's powerful data analysis libraries, we can uncover key factors influencing car prices and make informed decisions. In this article, we'll walk through the process of analyzing used car prices using Python, focusing on data cleaning, exploratory data analysis (EDA), and visualization techniques.

Step 1: Understanding the Dataset

The dataset we'll be working with contains various attributes of used cars, such as price, brand, color, horsepower, and more. Our objective is to analyze these factors and determine their impact on the selling price. To begin, we'll load the dataset into a Pandas DataFrame and inspect the first few rows:

import pandas as pd

# Load the dataset
df = pd.read_csv('used_cars.csv')

# Display the first few rows
df.head()

Ensure that the dataset is clean and properly formatted before proceeding with the analysis.

Step 2: Data Cleaning

Data cleaning is an essential step in any data analysis process. We'll check for missing values, handle duplicates, and convert categorical variables into numerical representations:

# Check for missing values
df.isnull().sum()

# Drop rows with missing target variable (price)
df = df.dropna(subset=['price'])

# Handle missing values in other columns (e.g., fill with mean or mode)
df['horsepower'].fillna(df['horsepower'].mean(), inplace=True)

# Convert categorical variables to numerical using one-hot encoding
df = pd.get_dummies(df, columns=['fuel_type', 'transmission'], drop_first=True)

By addressing missing values and converting categorical variables, we prepare the dataset for analysis and modeling.

Step 3: Exploratory Data Analysis (EDA)

EDA helps us understand the relationships between variables and identify patterns in the data. We'll visualize the distribution of car prices and examine correlations between features:

import seaborn as sns
import matplotlib.pyplot as plt

# Distribution of car prices
plt.figure(figsize=(10, 6))
sns.histplot(df['price'], bins=30, kde=True)
plt.title('Distribution of Car Prices')
plt.xlabel('Price')
plt.ylabel('Frequency')
plt.show()

# Correlation heatmap
plt.figure(figsize=(10, 6))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Correlation Heatmap')
plt.show()

These visualizations provide insights into the data's distribution and highlight potential relationships between variables.

Step 4: Feature Engineering

Feature engineering involves creating new features that can improve the performance of our predictive models. For instance, we can calculate the age of the car and add it as a new feature:

# Calculate car age
df['car_age'] = 2023 - df['year_of_manufacture']

Additionally, we can normalize numerical features to ensure they are on a similar scale:

from sklearn.preprocessing import StandardScaler

# Normalize numerical features
scaler = StandardScaler()
df[['horsepower', 'curb_weight', 'engine_size']] = scaler.fit_transform(df[['horsepower', 'curb_weight', 'engine_size']])

These transformations help improve the performance and interpretability of machine learning models.

Step 5: Model Building

With the data prepared, we can now build a predictive model to estimate car prices. We'll use a Random Forest Regressor, a robust machine learning algorithm suitable for regression tasks:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

# Define features and target variable
X = df.drop(columns=['price'])
y = df['price']

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Initialize and train the model
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Make predictions
y_pred = model.predict(X_test)

# Evaluate the model
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

The Random Forest Regressor provides a powerful method for predicting car prices based on the features in our dataset.

Step 6: Model Evaluation

To assess the performance of our model, we'll calculate additional evaluation metrics and visualize the predictions:

from sklearn.metrics import r2_score

# Calculate R-squared
r2 = r2_score(y_test, y_pred)
print(f'R-squared: {r2}')

# Plot predicted vs actual prices
plt.figure(figsize=(10, 6))
sns.scatterplot(x=y_test, y=y_pred)
plt.title('Predicted vs Actual Prices')
plt.xlabel('Actual Prices')
plt.ylabel('Predicted Prices')
plt.show()

These evaluations help us understand how well our model is performing and where improvements can be made.

Conclusion

Analyzing the selling price of used cars using Python provides valuable insights into the factors influencing car prices. By following the steps outlined in this article—data cleaning, exploratory data analysis, feature engineering, model building, and evaluation—we can develop a predictive model that assists in making informed decisions in the used car market. Remember, the quality of the data and the features selected play a crucial role in the model's performance.