Hier is een basisvoorbeeld van een Python-webcrawler die voldoet aan jouw specificaties. Het gebruikt de `requests` en `BeautifulSoup` bibliotheken voor het verwerken van webpagina's, en bevat functies voor het beheren van verzoeken, het respecteren van robots.txt, en het instellen van de crawldiepte en bestandstypes. Stap 1: Zorg dat je de benodigde pakketten hebt geïnstalleerd: ```bash pip install requests beautifulsoup4 ``` Stap 2: Het Python-script: ```python import requests from bs4 import BeautifulSoup from urllib.parse import urljoin, urlparse import time import urllib.robotparser # Configuratie MAX_DIEPTE = 2 BESTANDSTYEN = ['text/html', 'application/pdf'] USER_AGENT = 'MyCrawler/1.0' # Headers headers = { 'User-Agent': USER_AGENT } # Set voor gecrawlde URLs gecrawlde_urls = set() def mag_crawlen(url): """ Controleer robots.txt om te zien of we de URL mogen crawlen. """ parsed_url = urlparse(url) robots_url = f"{parsed_url.scheme}://{parsed_url.netloc}/robots.txt" rp = urllib.robotparser.RobotFileParser() try: rp.set_url(robots_url) rp.read() return rp.can_fetch(USER_AGENT, url) except: # Bij fouten in robots.txt, ga ervan uit dat we niet mogen crawlen return False def haal_inhoud(url): """ Haal inhoud van een URL met foutafhandeling en time-out. """ try: response = requests.get(url, headers=headers, timeout=5) response.raise_for_status() content_type = response.headers.get('Content-Type', '').split(';')[0] return response.content, content_type except requests.RequestException: return None, None def crawl(url, diepte): """ Recursieve crawler functie. """ if diepte > MAX_DIEPTE: return if url in gecrawlde_urls: return if not mag_crawlen(url): print(f"Robots.txt blokkeert: {url}") return print(f"Crawlen: {url} (Diepte {diepte})") inhoud, type_inhoud = haal_inhoud(url) if inhoud is None: print(f"Fout bij ophalen: {url}") return # Verwerk HTML-bestanden if type_inhoud == 'text/html': # Hier zou je bijvoorbeeld de inhoud opslaan of parseren # Voorbeeld: parseren en links vinden soup = BeautifulSoup(inhoud, 'html.parser') links = set() for link in soup.find_all('a', href=True): absolute_link = urljoin(url, link['href']) links.add(absolute_link) # Crawlen van gevonden links for link in links: crawl(link, diepte + 1) elif type_inhoud in BESTANDSTYEN: # Bestanden zoals PDF opslaan of verwerken print(f"Bestand gevonden: {url} (Type: {type_inhoud})") # Opslaan code hier indien nodig # Voeg URL toe aan de set van gecrawlde URLs gecrawlde_urls.add(url) # Respecteer een korte pauze om server niet te overladen time.sleep(1) # Startpunt start_url = 'https://voorbeeld.nl' if mag_crawlen(start_url): crawl(start_url, 0) else: print(f"Robots.txt blokkeert de start URL: {start_url}") ``` **Belangrijke tips:** - **Efficiënt verzoekbeheer:** Gebruik `time.sleep()` om de server niet te overladen. Overweeg ook caching of het beperken van de snelheid. - **robots.txt respecteren:** De functie `mag_crawlen()` controleert robots.txt-regels. - **Time-out fouten:** Deze worden afgehandeld door `try-except` blokken in `haal_inhoud()`. - **Maximale diepte:** De parameter `MAX_DIEPTE` bepaalt hoe diep de crawler gaat (hier 2). Je kunt de parameters aanpassen door de variabelen `MAX_DIEPTE`, `BESTANDSTYEN`, en `USER_AGENT` te wijzigen. Voor meer geavanceerde functies zoals het parallel verwerken van verzoeken, gebruik bijvoorbeeld `concurrent.futures` of andere asynchrone methoden.

Hier is een Python-webcrawler met de gespecificeerde parameters en begeleiding: ```python import requests from urllib.robotparser import RobotFileParser from urllib.parse import urljoin, urlparse from bs4 import BeautifulSoup import time from collections import deque import logging class WebCrawler: def __init__(self, max_depth=2, file_types=['html'], user_agent='MyCrawler/1.0'): self.max_depth = max_depth self.file_types = [ft.lower() for ft in file_types] self.user_agent = user_agent self.visited = set() self.robot_parsers = {} # Session configureren voor efficiëntie self.session = requests.Session() self.session.headers.update({'User-Agent': user_agent}) # Timeout instellingen self.timeout = 10 self.delay = 1 # Respectvolle delay tussen requests logging.basicConfig(level=logging.INFO) self.logger = logging.getLogger(__name__) def can_fetch(self, url): """Controleer robots.txt beperkingen""" parsed = urlparse(url) base_url = f"{parsed.scheme}://{parsed.netloc}" if base_url not in self.robot_parsers: robot_url = f"{base_url}/robots.txt" parser = RobotFileParser() try: parser.set_url(robot_url) parser.read() self.robot_parsers[base_url] = parser except Exception as e: self.logger.warning(f"Kan robots.txt niet lezen voor {base_url}: {e}") return True # Ga door als robots.txt niet bereikbaar is return self.robot_parsers[base_url].can_fetch(self.user_agent, url) def get_links(self, html_content, base_url): """Extraheer alle links van HTML content""" soup = BeautifulSoup(html_content, 'html.parser') links = [] for link in soup.find_all('a', href=True): full_url = urljoin(base_url, link['href']) links.append(full_url) return links def is_desired_file_type(self, url): """Controleer of URL overeenkomt met gewenste bestandstypes""" parsed = urlparse(url) path = parsed.path.lower() for file_type in self.file_types: if path.endswith(f'.{file_type}') or file_type == 'html' and '/' in path and not '.' in path.split('/')[-1]: return True return False def crawl(self, start_url): """Hoofd crawlfunctie""" queue = deque([(start_url, 0)]) results = [] while queue: url, depth = queue.popleft() if depth > self.max_depth: continue if url in self.visited: continue if not self.can_fetch(url): self.logger.info(f"Geblokkeerd door robots.txt: {url}") continue self.visited.add(url) self.logger.info(f"Crawlen: {url} (diepte: {depth})") try: # Respectvolle delay time.sleep(self.delay) response = self.session.get(url, timeout=self.timeout) response.raise_for_status() # Controleer content type content_type = response.headers.get('content-type', '').lower() if 'text/html' in content_type: # Verzamel HTML content results.append({ 'url': url, 'content': response.text, 'depth': depth }) # Extraheer links voor verdere crawling if depth < self.max_depth: links = self.get_links(response.text, url) for link in links: if link not in self.visited: queue.append((link, depth + 1)) elif any(ft in content_type for ft in self.file_types): # Andere gewenste bestandstypes results.append({ 'url': url, 'content_type': content_type, 'depth': depth }) except requests.exceptions.Timeout: self.logger.error(f"Timeout voor {url}") except requests.exceptions.HTTPError as e: self.logger.error(f"HTTP fout voor {url}: {e}") except requests.exceptions.RequestException as e: self.logger.error(f"Request fout voor {url}: {e}") except Exception as e: self.logger.error(f"Onverwachte fout voor {url}: {e}") return results # Gebruiksvoorbeeld met jouw parameters if __name__ == "__main__": crawler = WebCrawler( max_depth=2, file_types=['html'], user_agent='MyCrawler/1.0' ) start_url = "https://example.com" # Vervang met je start URL results = crawler.crawl(start_url) print(f"Gecrawlde URLs: {len(results)}") for result in results: print(f"URL: {result['url']}, Diepte: {result['depth']}") ``` ## Belangrijke Begeleiding: ### 1. **Efficiënt Request Beheer:** - Gebruik `requests.Session()` voor connection pooling - Implementeer delays tussen requests (`time.sleep()`) - Gebruik timeouts om vastlopende requests te voorkomen - Beperk het aantal gelijktijdige requests ### 2. **Robots.txt Respecteren:** - De `can_fetch()` methode controleert robots.txt automatisch - Slaagt parser resultaten op om herhaalde checks te voorkomen - Ga voorzichtig om met onbereikbare robots.txt bestanden ### 3. **Foutafhandeling:** - Timeouts worden afgevangen met specifieke excepties - HTTP errors (404, 500, etc.) worden netjes afgehandeld - Alle exceptions worden gelogd maar stoppen de crawler niet ### 4. **Aanvullende Verbeteringen:** ```python # Voor productiegebruik voeg toe: # - Rate limiting # - Roterende user agents # - Proxy ondersteuning # - Duplicate content detectie # - Sitemap.xml parsing ``` ### 5. **Installatie Vereisten:** ```bash pip install requests beautifulsoup4 lxml ``` ### 6. **Ethische Overwegingen:** - Crawl alleen publiek toegankelijke content - Respecteer `robots.txt` en `meta robots` tags - Overbelast servers niet met te veel requests - Controleer de terms of service van websites De crawler is nu klaar voor gebruik met jouw gespecificeerde parameters!