A PROJECT REPORT

ON

PRICE COMPARISON WEBSITE

USING PYTHON
BY

GUNJAN SHARMA (2101321550032)

UNDER THE GUIDANCE OF

Mr. JAI PRAKASH BHATI

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING,

GREATER NOIDA INSTITUTE OF TECHNOLOGY ENGG.INSTITUTE, GREATER NOIDA

Dr. A.P.J. Abdul Kalam Technical University, Lucknow

December, 2024
 Department of CSE -IOT
Session 2024-2025
Project Completion Certificate
Date: 27/12/2024

This is to certify that Ms. Gujan Sharma bearing Roll No.2201321559007, student of
4thyear CSE-IoT has completed project program (KCS-752) with the Department of
CSE-IoT from 26-Sep-24 to 26-Dec-24.

He worked on the Project Titled “Price Comparison Website Using Python”

under the guidance of Mr. Jai Prakash Bhati.

This project work has not been submitted anywhere for any degree.

Mr. Jai Prakash Bhati Dr. Indradeep Verma

Assistant Professor, CSE-IoT HoD-IoT

 ACKNOWLEDGEMENT

We would like to sincerely thank Mr. Jai Prakash Bhati, our project coordinator, and all of

the professors for their counsel, inspiration, and unwavering support over the course of our

project work. Without their assistance and insightful recommendations, our task would not

have been feasible. We are deeply grateful to our esteemed Department Head, CSE-IoT Dr.

Indradeep Verma, for his counsel and assistance when needed.

We are also appreciative of Dr. Dheeraj Gupta, our director, for providing the resources

we needed to complete our project job effectively. We would like to express our gratitude to all

of our friends for their support and helpful advice throughout this effort. Finally, we have no

words to express our sincere gratitude to our parents who have shown us this world and for

everything they have given to us.

 ABSTRACT

The "Price Comparison Website" is a Python-based application that enables users to compare
prices of various products from multiple online retailers. This system provides an easy-to-use
interface where users can search for products and view their prices from different websites,
helping them make informed purchasing decisions. The application employs web scraping
techniques to gather price data from various sources, displays it in an organized manner, and
allows users to choose the most cost-effective option. This tool can be beneficial for anyone
looking to find the best deal online.
 CONTENTS

1. INTRODUCTION
2. SYSTEM STUDY
2.1 EXISTING SYSTEM
2.2 PROPOSED SYSTEM
3. SYSTEM REQUIREMENTS
3.1 HARDWARE REQUIREMENTS
3.2 SOFTWARE REQUIREMENTS
4. SYSTEM ANALYSIS
4.1 FEASIBILITY STUDY
4.2 TECHNICAL FEASIBILITY
4.3 ECONOMICAL FEASIBILTY
4.4 SOCIAL FEASIBILITY
4.5 BEHAVIOURAL FEASIBILITY
4.6 ABOUT THE PROJECT
5. SYSTEM DESIGN
5.1 MODULE DESCRIPTION
5.2 INPUT DESIGN
5.3 OUTPUT DESIGN
5.4 DATA FLOW DIAGRAM (DFD)
6. IMPLEMENTATION AND SYSTEM TESTING
6.1 IMPLEMENTATION
6.2 SYSTEM TESTING
7. SOURCE CODE
8. OUTPUT SCREENSHOTS
9. CONCLUSION
10. BIBLIOGRAPHY
 1. INTRODUCTION

In the age of e-commerce, online shopping has become an integral part of our daily lives,
offering convenience, variety, and competitive pricing. However, with the increasing number
of online marketplaces, it can be overwhelming for users to determine which platform offers
the best deal for a specific product. The Price Comparison Website, developed using Python,
aims to address this challenge by providing users with a streamlined platform to compare
product prices across various online shopping platforms.
This project employs web scraping techniques to extract real-time pricing and product details
from popular e-commerce websites such as Amazon, Flipkart, and more. By entering the
name of a product, users can instantly view a detailed comparison of its prices across multiple
platforms. This not only helps users make well-informed purchasing decisions but also saves
them significant time and effort that would otherwise be spent manually checking each
website.
The key objectives of this project are:
1. Real-Time Price Comparison: Ensure users have access to up-to-date and accurate
product pricing from different e-commerce platforms.
2. User-Friendly Interface: Simplify the process of searching for products and viewing price
comparisons through an intuitive interface.
3. Efficiency and Accuracy: Utilize Python's robust libraries and frameworks to ensure
efficient data extraction and error handling, maintaining the reliability of the information
presented.
1.2 OBJECTIVE

The primary objective of a Price Comparison Website is to simplify the shopping experience by
enabling users to compare product prices across multiple e-commerce platforms in real time.
The system leverages Python and web scraping techniques to provide users with accurate,
efficient, and user-friendly access to product pricing and details. Below are the key objectives,
tailored for a price comparison system:

Product Search and Comparison

Allow users to search for products by name or category.
Retrieve and display product information, including price, availability, and seller details,
from various platforms such as Amazon, Flipkart, and more.
Enable users to view detailed comparisons for informed purchasing decisions.

Real-Time Price Updates

Provide users with up-to-date pricing information by scraping data from e-commerce
websites in real time.
Handle dynamic price fluctuations by implementing periodic updates.
Ensure accurate data representation by validating and cleaning scraped data.

Product Filtering and Sorting

Facilitate advanced filtering options for users to narrow their search based on criteria
such as price range, brand, ratings, or discounts.
Allow sorting of products by parameters like lowest price, highest rating, or most
popular.
Secure Data Handling
Protect user search data and preferences using secure storage and encryption
mechanisms.
Ensure compliance with data privacy laws and regulations to build user trust.

Efficiency and Performance

Design a scalable and efficient architecture to handle multiple user requests
simultaneously.
Use optimized Python libraries like Beautiful Soup and Selenium for web scraping to
minimize delays in fetching and presenting data.

Automation of Routine Tasks

Automate scraping processes to periodically update product data without manual
intervention.
Schedule background tasks to refresh outdated product information, ensuring a
seamless user experience.

User-Friendly Interface
Create an intuitive and easy-to-navigate interface, enabling users to input product
queries and view results effortlessly.
Provide a responsive design that works seamlessly across devices, including desktops,
tablets, and mobile phones.

Analytics and Insights

Use data analytics to understand user preferences and trends.
Generate reports on frequently searched products, price trends, and platform
performance to improve the system's functionality.
Integration with External APIs
Integrate APIs from popular e-commerce platforms for faster and more reliable data
retrieval.
Enable integration with payment gateways or coupon websites to provide additional
value to users.

Customization and Flexibility

Allow users to customize their search preferences, such as setting price alerts or adding
favorite products for future reference.
Design the system to adapt to changes in e-commerce platform structures and
technological advancements.

Scalability and Robustness

Build a scalable system capable of handling increased traffic and larger datasets as the
platform grows.
Implement robust error-handling mechanisms to deal with changes in website structures
or connectivity issues during web scraping.

Compliance with Legal Standards

Ensure ethical web scraping practices by adhering to the terms of service of e-commerce
platforms.
Implement measures to respect copyright and intellectual property laws while collecting
and displaying product data.
2. SYSTEM STUDY

2.1 Existing System

The existing system primarily relies on manually searching various online stores for prices, which

can be time-consuming and inefficient. Users have to visit multiple e-commerce websites to

compare prices, leading to a suboptimal shopping experience.

Drawbacks of Existing System:

Time-consuming manual comparison.

Inconsistent and incomplete data.

Lack of real-time updates.

2.2 Proposed System

The proposed system automates the price comparison process by scraping data from

various online stores. This system helps users quickly find the best prices for products

and displays all necessary details in one place, reducing the time spent searching for

products and prices.

Advantages of the Proposed System:

Real-time price updates.

User-friendly interface for searching and comparing products.

Efficient data processing and display.

3. SYSTEM REQUIREMENTS

3.1 Hardware Requirements

Processor: Intel Core i3 or higher.

RAM: 4GB or higher.

Storage: 500GB or higher.

Monitor: Color monitor with 1024x768 resolution or higher.

3.2 Software Requirements

Python 3.x

Libraries: requests, BeautifulSoup, pandas, matplotlib

Operating System: Windows, macOS, or Linux

4. SYSTEM DESIGN

System design is the process of problem-solving and planning for a software solution. For this Price
Comparison Website, the system design includes creating a structured approach to handling data
scraping, processing, and presenting the comparison of prices across multiple e-commerce platforms.

4.1 Module Description

1. Web Scraping Module:

Purpose: To fetch product details such as price, name, and specifications from multiple e-
commerce websites like Amazon, Flipkart, etc.
Responsibilities: Use Python libraries (BeautifulSoup, Selenium, requests) to scrape web
pages and extract relevant data.
2. Data Processing and Comparison Module:
Purpose: To process the scraped data, compare prices, and identify the best deals.
Responsibilities: Clean the scraped data using pandas, compare the prices, and display the
best options.
3. User Interface Module:
Purpose: To provide a GUI for users to interact with the system.
Responsibilities: Collect user inputs (product name), display results (price comparison), and
show relevant details (e.g., product specifications, best price).
4. Database Module (Optional):
Purpose: Store previously searched products, prices, and user preferences.
Responsibilities: Use a local database (e.g., SQLite) to store search history and results for
future reference.
5. Data Visualization Module (Optional):
Purpose: Display graphs and charts showing price trends over time.
Responsibilities: Use matplotlib to visualize price fluctuations or trends for better decision-
making.
5.2 Input Design
The input design is the process of converting the user oriented inputs into the
computer based format. Therefore, the user interface design is very important for any
applications. It defines how the software communicates with in itself to system that
implemented with it and with human who use it. If the interface design is very good,
the user will fall into a software applications.

5.3 Output Design

Computer output is the most important and direct source of information to user efficient,
intelligible output design should improve the system’s relationships with the user and
help in decision making. It provides a means of storage by copying the result for later
reference.

5.4 Data Flow Diagram

A data-flow diagram ( DFD )is a way of representing a flow of a data of a process or a

system. The DFD also provides information about the outputs and inputs of each entity
and the process itself. A data-flow diagram has no control flow, there are no decision
rules and no loops. Specific operations based on the data can be represented by a
flowchart.
Level 0 : Context level diagram
Level 1 : DFD for create member
 IMPLEMENTATION AND TESTING

6.1 Implementation

The implementation phase involves coding the web scraping, data processing, and user

interface modules. Here is a high-level overview of the code flow:

1. Web Scraping: Using BeautifulSoup or Selenium to scrape data from product pages.

2. Data Processing: Using pandas to clean and compare prices.

3. User Interface: Building a simple GUI using Tkinter to allow users to input product

names and view results.

6.2 System Testing

In system testing, the entire system is tested as a whole. The project is run within a Python

development environment (e.g., PyCharm), and the system's functionality is verified from the

user’s perspective. Various test cases are executed, and the results are monitored to ensure

expected behavior. The project will scrape product prices from multiple websites (simulated in

this case), store them in a Linked List, and display the lowest price for the user. This includes

modules for:

1. Web scraping (simulated).

2. Storing data using a Linked List.

3. Comparing prices.

4. Displaying the results.

 SOURCE CODE
pip install requests beautifulsoup4

import requests

from bs4 import BeautifulSoup

import pandas as pd

# Class to store product data (name, price, website, link)

class ProductNode:

def __init__(self, name, price, website, product_link):

self.name = name

self.price = price

self.website = website

self.product_link = product_link

self.next = None # Pointer to the next node in the linked list

class ProductList:

def __init__(self):

self.head = None
def add_product(self, name, price, website, product_link):

new_product = ProductNode(name, price, website, product_link)

if not self.head:

self.head = new_product

else:

current = self.head

while current.next:

current = current.next

current.next = new_product
def display_products(self):

current = self.head

while current:

print(f"Product: {current.name}")

print(f"Price: ${current.price}")

print(f"Website: {current.website}")

print(f"Link: {current.product_link}")

print("------------------------------------")

current = current.next
def get_products_as_dict(self):

product_list = []

current = self.head

while current:

product_list.append({

'Product': current.name,

'Price': current.price,

'Website': current.website,

'Link': current.product_link

})

current = current.next

return product_list
# Scraping function to fetch price details from an e-commerce website

(placeholder)

def fetch_product_price_from_amazon(product_name):

# Sample URL for Amazon search (replace with actual URL)

amazon_url = f"https://www.amazon.com/s?k={product_name.replace(' ',

'+')}"

headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)

AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124

Safari/537.36"} response = requests.get(amazon_url, headers=headers)

 # Parsing HTML content using BeautifulSoup

soup = BeautifulSoup(response.text, 'html.parser')

# Extracting product names and prices (modify based on actual Amazon HTML

structure)

products = soup.find_all('div', {'class': 's-main-slot'}).find_all('div', {'class': 's-

result-item'})

product_details = []

for product in products:

try:

name = product.find('span', {'class': 'a-text-normal'}).text

price = product.find('span', {'class': 'a-price-whole'}).text

link = "https://www.amazon.com" + product.find('a', {'class': 'a-link-

normal'})['href']

product_details.append((name, price, 'Amazon', link))

except AttributeError:

continue # Skip if any data is missing

return product_details
 # Main function to drive the comparison website

def main():

product_name = input("Enter the product name for price comparison: ")

# Initialize linked list to store product data

product_list = ProductList()

# Fetch product data from different e-commerce websites

amazon_products = fetch_product_price_from_amazon(product_name)

flipkart_products = fetch_product_price_from_flipkart(product_name)

# Add the fetched products to the linked list

for name, price, website, link in amazon_products + flipkart_products:

product_list.add_product(name, price, website, link)

 # Display products in the linked list

print("\nProduct Price Comparison Results:")

product_list.display_products()

# Optionally, convert the linked list data to a pandas DataFrame and display as

a table

products_dict = product_list.get_products_as_dict()

df = pd.DataFrame(products_dict)

print("\nPrice Comparison in Tabular Form:")

print(df)

if __name__ == "__main__":

main()
SCREENSHOT
 RESULT ANALYSIS

Once the website is implemented, it's important to analyze the results in terms of data
accuracy, user engagement, and system performance. Below is an analysis of the
expected results based on the implementation:

1. Accuracy of Price Data

Expected Result: The price comparison system should accurately scrape product prices
from different websites.
Test: Compare the data scraped by the system against manual checks of the product
prices on the respective websites.
Analysis: The system should pull accurate prices, and any discrepancies should be logged
for troubleshooting, ensuring the system is continuously updated.
2. User Interface Usability
Expected Result: The website should provide a clean, intuitive interface where users can
quickly compare prices.
Test: Perform usability tests with different users to identify if the site is easy to navigate
and if they can quickly find the information they need.
Analysis: The website should allow users to input the product name or URL, see a clear
price comparison, and navigate through the results easily. Any feedback regarding the
layout or functionality can help refine the user experience.
3. Real-Time Price Monitoring and Alerts
Expected Result: The system should send timely alerts when there is a price drop for the
products the user is tracking.
Test: Set up a test account and simulate price changes. Check if email alerts are triggered
as expected.
Analysis: Ensure that the alert system is triggered correctly based on predefined
thresholds. Monitor the accuracy and timing of alerts sent to users.
CONCLUSION

The project demonstrates how Python's capabilities can be utilized to solve real-world
problems efficiently. The use of libraries like BeautifulSoup for web scraping, Pandas
for data manipulation, and Flask for creating a dynamic web interface showcases the
versatility of Python in software development. This tool not only simplifies the process
of price comparison but also ensures accuracy and consistency in the data presented
to the users. The modular design ensures scalability, allowing the system to integrate
additional e-commerce platforms in the future. Overall, this project serves as an
excellent example of how programming can improve day-to-day tasks, making them
faster, more accurate, and user-friendly.
FUTURE SCOPE
he future scope of a price comparison website built using Python is influenced by
technological advancements, changing consumer behavior, and evolving market needs.
Below are some potential developments for the future of price comparison websites:

Integration of More E-commerce Platforms: Currently, the website may support

comparisons from a limited set of e-commerce platforms. Future developments can
integrate additional platforms such as niche, regional, and international e-commerce
websites, providing a wider range of price comparisons for consumers..
Real-Time Price Monitoring and Alerts: Future enhancements can include real-time
price monitoring, where users can receive alerts or notifications when prices for a
particular product drop or when a special offer is available.
Incorporation of Machine Learning for Price Prediction: The application of machine
learning models can be leveraged to predict future price trends based on historical
data, helping users decide when to buy a product at the best price.
Mobile Application Development: Developing a mobile version of the price comparison
website will enable users to compare prices on-the-go, making it more accessible and
user-friendly.
User Reviews and Ratings Integration: Future versions of the website could
incorporate user-generated reviews and ratings for products. This feature would allow
users to consider not only the price but also the product quality, reliability, and
feedback from other buyers.
REFERENCE
Beautiful Soup
Richardson, Leonard. Beautiful Soup Documentation. Retrieved from
https://www.crummy.com/software/BeautifulSoup/
Requests
Kenneth Reitz. Requests: HTTP for Humans Documentation. Retrieved from
https://docs.python-requests.org/
Scrapy
Scrapy Development Team. Scrapy Documentation. Retrieved from https://docs.scrapy.org/
Pandas
McKinney, Wes. Pandas Documentation. Retrieved from https://pandas.pydata.org/docs/
NumPy
Harris, Charles R., et al. Array programming with NumPy. Nature, 2020. Retrieved from
https://numpy.org/
Matplotlib
Hunter, John D. Matplotlib: A 2D Graphics Environment. Computing in Science & Engineering,
2007. Retrieved from https://matplotlib.org/stable/contents.html