Tworzenie bota do śledzenia cen
Opracują Państwo bota monitorującego ceny produktów w serwisach e-commerce i wysyłającego powiadomienia o obniżkach.
Tworzenie bota do śledzenia cen to bezpłatna lekcja Web Scraping & Bots na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Web Scraping & Bots, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Web Scraping & Bots zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
What's a Price Tracker Bot?
Have you ever wanted to know when a product's price drops? A price tracker bot does exactly that!
It's an automated program that regularly checks the price of items on e-commerce websites.
When it detects a price change, especially a drop, it can notify you.
Bot's Core Tasks
Building a price tracker involves several key steps:
- Fetch: Get the product page content.
- Parse: Extract the price and product details.
- Store: Keep track of the last known price.
- Compare: Check if the current price is lower.
- Notify: Send an alert if a drop is found.
Spotting Product Details
Before we write code, we need to know where the information is on the page.
Using browser developer tools, you'd identify the HTML elements that contain the product's:
- Name
- Current Price
- Product URL
These are crucial for your bot to find the right data.
Getting the Web Page
The first step is to download the web page content. We'll use the requests library for this.
It sends an HTTP GET request to the product URL and retrieves the HTML.
Try running this simple example:
import requests
def fetch_page(url):
try:
response = requests.get(url)
response.raise_for_status() # Check for HTTP errors
return response.text
except requests.exceptions.RequestException as e:
print(f"Error fetching page: {e}")
return None
if __name__ == "__main__":
# Example URL (replace with a real product page for testing)
example_url = "https://example.com/product"
print(f"Fetching content from: {example_url}")
# In a real bot, you'd parse this content
# page_content = fetch_page(example_url)
# if page_content:
# print("Page content fetched successfully (first 200 chars):")
# print(page_content[:200])
# else:
# print("Failed to fetch page content.")
print("Page content fetching logic demonstrated.")Parsing the Price
Once you have the HTML, you'll use a library like BeautifulSoup to parse it and find the price.
Prices often come with currency symbols or extra text, so we'll need to clean the extracted string to get a numeric value.
Here's a snippet to illustrate:
from bs4 import BeautifulSoup
html_doc = """
<html><body>
<span class="product-price">$199.99</span>
<div id="item-name">Cool Gadget</div>
</body></html>
"""
soup = BeautifulSoup(html_doc, 'html.parser')
price_element = soup.find('span', class_='product-price')
if price_element:
price_string = price_element.get_text()
# Clean the string to get a float
cleaned_price = float(price_string.replace('$', '').strip())
print(f"Extracted Price: {cleaned_price}")
else:
print("Price element not found.")Remembering the Price
To track changes, your bot needs to remember the price it last saw. A simple way is to use a file to store this data.
For a basic bot, a JSON file or a simple dictionary in memory can work.
You'll store the product URL and its last known price.
import json
# Example of storing data
product_data = {
"https://example.com/product1": {
"name": "Cool Gadget",
"last_price": 199.99
},
"https://example.com/product2": {
"name": "Awesome Widget",
"last_price": 49.95
}
}
# In a real bot, you'd load/save this from a file
# with open('prices.json', 'w') as f:
# json.dump(product_data, f, indent=2)
print("Product data structure for storage:")
print(json.dumps(product_data, indent=2))Detecting Price Drops
This is the core logic! After fetching and parsing the new price, you compare it with the stored "last price".
If the new price is lower than the stored price, you've found a deal!
You should also update the stored price with the new one for future comparisons.
current_price = 189.99
stored_price = 199.99
product_name = "Cool Gadget"
if current_price < stored_price:
print(f"PRICE DROP ALERT! {product_name} is now ${current_price} (was ${stored_price})")
# Update stored_price = current_price in your data
elif current_price > stored_price:
print(f"Price increased for {product_name}. Current: ${current_price}, Was: ${stored_price}")
# Update stored_price = current_price
else:
print(f"Price for {product_name} remains ${current_price}")Notifying About Deals
Once a price drop is detected, your bot needs to tell you!
For a simple bot, printing a message to the console is enough. For real-world use, you might:
- Send an email
- Push a notification to your phone
- Send a message to a chat app (e.g., Discord, Telegram)
def send_notification(product_name, old_price, new_price):
message = (
f"🚨 Price Drop Alert! 🚨\n"
f"Product: {product_name}\n"
f"Old Price: ${old_price:.2f}\n"
f"New Price: ${new_price:.2f}\n"
f"Check it out now!"
)
print(message)
# In a real app, you'd integrate email/SMS here
if __name__ == "__main__":
send_notification("Awesome Headphones", 250.00, 225.00)Your First Price Tracker
Let's combine these pieces into a basic, runnable price tracker. This example simulates fetching and parsing.
Remember, for a real bot, you'd replace the `mock_fetch_and_parse` with actual requests and BeautifulSoup calls.
import json
import random
# Mock functions for demonstration
def mock_fetch_and_parse(product_url):
# Simulate different prices
if "gadget" in product_url:
return random.choice([199.99, 189.99, 205.00])
return random.choice([49.95, 45.00, 52.00])
def send_notification(product_name, old_price, new_price):
print(f"🚨 Price Drop! {product_name} is now ${new_price:.2f} (was ${old_price:.2f})")
# Main logic
def check_price(product_url, product_name, stored_prices):
current_price = mock_fetch_and_parse(product_url)
last_price = stored_prices.get(product_url)
if last_price is None:
print(f"First check for {product_name}: ${current_price:.2f}")
elif current_price < last_price:
send_notification(product_name, last_price, current_price)
elif current_price > last_price:
print(f"Price for {product_name} increased to ${current_price:.2f}")
else:
print(f"Price for {product_name} remains ${current_price:.2f}")
stored_prices[product_url] = current_price # Update price
if __name__ == "__main__":
# Simulate stored prices (from a file in a real app)
my_tracked_items = {
"https://example.com/gadget": 200.00, # Initial price
"https://example.com/widget": 50.00
}
print("--- First Run ---")
check_price("https://example.com/gadget", "Cool Gadget", my_tracked_items)
check_price("https://example.com/widget", "Awesome Widget", my_tracked_items)
print("\n--- Second Run ---")
check_price("https://example.com/gadget", "Cool Gadget", my_tracked_items)
check_price("https://example.com/widget", "Awesome Widget", my_tracked_items)
print("\nFinal tracked prices:", json.dumps(my_tracked_items, indent=2))Price Logic Check
Consider a price tracker bot. It last recorded a product price of $50.00. On its next run, it fetches the price as $45.00. What should the bot do?
Recap & Next Steps
You've learned the fundamental steps to build a price tracker bot!
- Fetch HTML with
requests. - Parse prices with
BeautifulSoup. - Store prices (e.g., in a JSON file).
- Compare current vs. stored prices.
- Notify on price drops.
Next steps include scheduling your bot to run automatically and exploring more advanced notification methods.
Ucz się Python dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 12
- Lekcje
- 48
Często zadawane pytania
Czy lekcja „Tworzenie bota do śledzenia cen” jest bezpłatna?
Tak — pełny tekst „Tworzenie bota do śledzenia cen” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Web Scraping & Bots, przejdź na CoddyKit PRO. Kurs Web Scraping & Bots zawiera 4 lekcji w sumie.
Co nauczysz się w „Tworzenie bota do śledzenia cen”?
Opracują Państwo bota monitorującego ceny produktów w serwisach e-commerce i wysyłającego powiadomienia o obniżkach. Ćwiczysz Web Scraping & Bots z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Web Scraping & Bots?
Nie wymagamy żadnego doświadczenia. Web Scraping & Bots w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Tworzenie bota do śledzenia cen”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Web Scraping & Bots?
Tak. Każda lekcja Web Scraping & Bots zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Tworzenie bota do śledzenia cen
- Tworzenie monitora mediów społecznościowych
- Wdrażanie botów na platformach chmurowych
- Wysyłanie alertów i powiadomień