Bygging av en bot for prissporing
Utvikle en bot som overvåker produktpriser på e-handelsnettsteder og sender varsler når prisene synker.
Bygging av en bot for prissporing er en gratis leksjon i Nettskraping og boter på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Nettskraping og boter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Nettskraping og boter inneholder totalt 4 leksjoner.
Hva er en prisovervåkingsbot?
Har du noen gang ønsket å vite når prisen på et produkt går ned? En prisovervåkingsbot gjør nettopp dette!
Det er et automatisert program som regelmessig sjekker prisen på varer i nettbutikker.
Når boten oppdager en prisendring, særlig et prisfall, kan den varsle deg.
Botens kjerneoppgaver
Å bygge en prisovervåkingsbot innebærer flere viktige trinn:
- Hente: Hent innholdet på produktsiden.
- Tolke: Trekk ut prisen og produktdetaljene.
- Lagre: Hold oversikt over den sist kjente prisen.
- Sammenligne: Kontroller om den nåværende prisen er lavere.
- Varsle: Send et varsel hvis du finner et prisfall.
Finne produktdetaljer
Før vi skriver kode, må vi vite hvor informasjonen finnes på siden.
Ved hjelp av nettleserens utviklerverktøy identifiserer du HTML-elementene som inneholder produktets:
- Navn
- Gjeldende pris
- Produkt-URL
Dette er avgjørende for at boten skal finne de riktige dataene.
Hente nettsiden
Det første trinnet er å laste ned innholdet på nettsiden. Vi bruker biblioteket requests til dette.
Det sender en HTTP GET-forespørsel til produktets URL og henter HTML-koden.
Prøv å kjøre dette enkle eksempelet:
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.")Tolke prisen
Når du har HTML-koden, bruker du et bibliotek som BeautifulSoup til å tolke den og finne prisen.
Priser kommer ofte med valutasymboler eller ekstra tekst, så vi må rense den uttrukne tekststrengen for å få en numerisk verdi.
Her er et kodeutdrag som illustrerer dette:
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.")Huske prisen
For å spore endringer må boten huske prisen den så sist. En enkel løsning er å bruke en fil til å lagre disse dataene.
For en grunnleggende bot kan en JSON-fil eller en enkel ordbok i minnet fungere.
Du lagrer produktets URL og sist kjente pris.
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))Oppdage prisfall
Dette er kjernelogikken! Når du har hentet og tolket den nye prisen, sammenligner du den med den lagrede «last price».
Hvis den nye prisen er lavere enn den lagrede prisen, har du funnet et godt tilbud!
Du bør også oppdatere den lagrede prisen med den nye, slik at den kan brukes i fremtidige sammenligninger.
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}")Varsle om gode tilbud
Når et prisfall oppdages, må boten gi deg beskjed!
For en enkel bot er det nok å skrive ut en melding i konsollen. I praktisk bruk kan du for eksempel:
- Send en e-post
- Sende et pushvarsel til telefonen
- Sende en melding til en chatteapp, for eksempel Discord eller 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)Din første prisovervåkingsbot
La oss sette sammen disse delene til en enkel prisovervåkingsbot som kan kjøres. Dette eksempelet simulerer henting og tolking.
Husk at du i en ekte bot må erstatte `mock_fetch_and_parse` med faktiske kall til requests og BeautifulSoup.
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))Kontroll av prislogikk
Se for deg en prisovervåkingsbot. Den registrerte sist en produktpris på $50.00. Ved neste kjøring henter den prisen $45.00. Hva bør boten gjøre?
Oppsummering og neste trinn
Du har lært de grunnleggende trinnene for å bygge en prisovervåkingsbot!
- Hente HTML med
requests. - Tolke priser med
BeautifulSoup. - Lagre priser, for eksempel i en JSON-fil.
- Sammenligne gjeldende og lagrede priser.
- Varsle ved prisfall.
Som neste trinn kan du planlegge at boten skal kjøre automatisk og utforske mer avanserte varslingsmetoder.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Bygging av en bot for prissporing» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Nettskraping og boter, inkludert «Bygging av en bot for prissporing», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Nettskraping og boter inneholder totalt 4 leksjoner.
Hva lærer jeg i «Bygging av en bot for prissporing»?
Utvikle en bot som overvåker produktpriser på e-handelsnettsteder og sender varsler når prisene synker. Du øver på Nettskraping og boter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Nettskraping og boter?
Ingen tidligere erfaring er nødvendig. Nettskraping og boter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Bygging av en bot for prissporing»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Nettskraping og boter-leksjonen?
Ja. Alle Nettskraping og boter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Bygging av en bot for prissporing
- Opprette en overvåkingsbot for sosiale medier
- Distribuere boter til skyplattformer
- Sende varsler og notifikasjoner