Web scraping with Scrapy: advanced examples

class RedditSpider(scrapy.Spider) :
 name = 'reddit'
 start_urls = [ 'https://www.reddit.com' ]

def parse(self, response) :
    links = response.xpath('//img/@src')
   html = ''

for link in links:
    # Extract the URL text from the element
    url = link.get()
    # Check if the URL contains an image extension
    if any(extension in url for extension in ['.jpg','.gif','.png'])
   and not any(domain in url for domainin                                       ['redditstatic.com','redditmedia.com']):     
    html += '''
     < a href="{url}" target="_blank">
         < img src="{url}" height="33%" width="33%" />
     < /a>
     '''.format(url=url)

# Open an HTML file, save the results
     with open('frontpage.html', 'w') as page:
     page.write(html)

# Close the filepage.close()

We’re simply adding our domain whitelist to an exclusionary any() expression. These statements could be tweaked to read from a separate configuration file, local database, or cache – if need be.

Extracting Amazon price data

If you’re running an ecommerce website, intelligence is key. With Scrapy we can easily automate the process of collecting information about our competitors, our market, or our listings.

For this task, we’ll extract pricing data from search listings on Amazon and use the results to provide some basic insights. If we visit Amazon’s search results page and inspect it, we notice that Amazon stores the price in a series of divs, most notably using a class called 
.a-offscreen. We can formulate a CSS selector that extracts the price off the page:

prices = response.css('.a-price .a-offscreen::text').getall()

With this CSS selector in mind, let’s build ourAmazonSpider.

import scrapy

from re import sub
from decimal import Decimal

def convert_money(money):        return Decimal(sub(r'[^d.]', '', money))

class AmazonSpider(scrapy.Spider):
      name = 'amazon'
      start_urls = [
          'https://www.amazon.com/s?k=paint'
     ]

            def parse(self, response):
          # Find the Amazon price element
          prices = response.css('.a-price. a-offscreen::text').getall()

          # Initialize some counters and stats objects          stats = dict()
          values = []

          for price in prices:
                value = convert_money(price)
                values.append(value)

                      # Sort our values before calculating
          values.sort()

                      # Calculate price statistics
          stats['average_price'] = round(sum(values)/ len(values),2)
          stats['lowest_price'] = values[0]
          stats['highest_price'] = values[-1]
          stats['total_prices'] = len(values)

          print(stats)



A few things to note about our AmazonSpider class: convert_money(): This helper simply converts strings formatted like ‘$45.67’ and casts them to a Python Decimal type which can be used for computations and avoids issues with locale by not including a ‘$’ anywhere in the regular expression .getall(): The .getall() function is a Scrapy function that works similar to the .get() function we used before, but this returns all the extracted values as a list which we can work with. Running the command scrapy runspider amazon.py in the project folder will dump output resembling the following:

{'average_price': Decimal('38.23'),'lowest_price': Decimal('3.63'),'highest_price': Decimal ('689.95'), 'total_prices': 58}

It’s easy to imagine building a dashboard that allows you to store scraped values in a datastore and visualize data as you see fit.

Considerations at Scale

As you build more web crawlers and you continue to follow more advanced scraping workflows you’ll likely notice a few things:

• Site change, now more than ever.

• Getting consistent results across thousands of pages is tricky.

• Performance considerations can be crucial.

Sites change, now more than ever

On occasion, AliExpress for example, will return a login page rather than search listings. Sometimes Amazon will decide to raise a Captcha, or Twitter will return an error. While these errors can sometimes simply be flickers, others will require a complete re-architecture of your web scrapers. Nowadays, modern front-end frameworks are oftentimes pre-compiled for the browser which can mangle class names and ID strings, sometimes a designer or developer will change an HTML class name during a redesign. It’s important that our Scrapy crawlers are resilient, but keep in mind that changes will occur over time.

Getting consistent results across thousands of pages is tricky

Slight variations of user-inputted text can really add up. Think of all of the different spellings and capitalizations you may encounter in just usernames. Pre-processing text, normalizing text, and standardizing text before performing an action or storing the value is best practice before most NLP or ML software processes for best results.

Performance considerations can be crucial

You’ll want to make sure you’re operating at least moderately efficiently before attempting to process 10,000 websites from your laptop one night. As your dataset grows it becomes more and more costly to manipulate it in terms of memory or processing power. In a similar regard, you may want to extract the text from one news article at a time, rather than downloading all 10,000 articles at once. As we’ve seen in this tutorial, performing advanced scraping operations is actually quite easy using Scrapy’s framework. Some advanced next steps might include loading selectors from a database and scraping using very generic Spider classes, or by using proxies or modified user-agents to see if the HTML changes based on location or device type. Scraping in the real world becomes complicated because of all the edge cases, Scrapy provides an easy way to build this logic in Python.

This post is a part of Kite’s new series on Python. You can check out the code from this and other posts on our GitHub repository. Originally posted on Kite here: