构建价格追踪机器人
开发一个监控电商网站商品价格并在降价时发送通知的机器人。
构建价格追踪机器人 是 CoddyKit 上的免费 Web Scraping & Bots 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Web Scraping & Bots 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Web Scraping & Bots 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
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.
常见问题解答
「构建价格追踪机器人」课时是免费的吗？
是的 — 「构建价格追踪机器人」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Web Scraping & Bots 课程的其余内容，请升级到 CoddyKit PRO。 Web Scraping & Bots 课程共包含 4 节课。
「构建价格追踪机器人」这节课中我会学到什么？
开发一个监控电商网站商品价格并在降价时发送通知的机器人。 你通过在浏览器中直接运行的动手代码来练习 Web Scraping & Bots，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Web Scraping & Bots 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Web Scraping & Bots 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。
「构建价格追踪机器人」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Web Scraping & Bots 课中编写并运行代码吗？
能。每节 Web Scraping & Bots 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。
此课程中的所有课时
- 构建价格追踪机器人
- 创建社交媒体监测器
- 将机器人部署到云平台
- 发送警报与通知