Scrapy Scraping
Scrapy | A Fast and Powerful Scraping and Web Crawling …
An open source and collaborative framework for extracting the data you need from websites.
In a fast, simple, yet extensible way.
Maintained by
Zyte
(formerly Scrapinghub)
and
many other contributors
Install the latest version of Scrapy
Scrapy 2. 5. 0
pip install scrapy
Terminal•
cat > <
# Deploy the spider to Zyte Scrapy Cloud
shub deploy
# Schedule the spider for execution
shub schedule blogspider
Spider blogspider scheduled, watch it running here:
# Retrieve the scraped data
shub items 26731/1/8
{“title”: “Improved Frontera: Web Crawling at Scale with Python 3 Support”}
{“title”: “How to Crawl the Web Politely with Scrapy”}…
Fast and powerful
write the rules to extract the data and let Scrapy do the rest
Easily extensible
extensible by design, plug new functionality easily without having to touch the core
Portable, Python
written in Python and runs on Linux, Windows, Mac and BSD
Healthy community
– 36. 3k stars, 8. 4k forks and 1. 8k watchers on GitHub
– 5. 1k followers on Twitter
– 14. 7k questions on StackOverflow
Implementing Web Scraping in Python with Scrapy – GeeksforGeeks
Nowadays data is everything and if someone wants to get data from webpages then one way to use an API or implement Web Scraping techniques. In Python, Web scraping can be done easily by using scraping tools like BeautifulSoup. But what if the user is concerned about performance of scraper or need to scrape data overcome this problem, one can make use of MultiThreading/Multiprocessing with BeautifulSoup module and he/she can create spider, which can help to crawl over a website and extract data. In order to save the time one use the help of Scrapy one can:
1. Fetch millions of data efficiently
2. Run it on server
3. Fetching data
4. Run spider in multiple processesScrapy comes with whole new features of creating spider, running it and then saving data easily by scraping it. At first it looks quite confusing but it’s for the ’s talk about the installation, creating a spider and then testing 1: Creating virtual environmentIt is good to create one virtual environment as it isolates the program and doesn’t affect any other programs present in the machine. To create virtual environment first install it by using:sudo apt-get install python3-venvCreate one folder and then activate it:mkdir scrapy-project && cd scrapy-project
python3 -m venv myvenv
If above command gives Error then try this:python3. 5 -m venv myvenvAfter creating virtual environment activate it by using:source myvenv/bin/activate Step 2: Installing Scrapy moduleInstall Scrapy by using:pip install scrapyTo install scrapy for any specific version of python:python3. 5 -m pip install scrapyReplace 3. 5 version with some other version like 3. 6. Step 3: Creating Scrapy projectWhile working with Scrapy, one needs to create scrapy startproject gfgIn Scrapy, always try to create one spider which helps to fetch data, so to create one, move to spider folder and create one python file over there. Create one spider with name python file. Step 4: Creating SpiderMove to the spider folder and create While creating spider, always create one class with unique name and define requirements. First thing is to name the spider by assigning it with name variable and then provide the starting URL through which spider will start crawling. Define some methods which helps to crawl much deeper into that website. For now, let’s scrap all the URL present and store all those scrapyclass ExtractUrls(): name = “extract” def start_requests(self): for url in urls: yield quest(url = url, callback =)Main motive is to get each url and then request it. Fetch all the urls or anchor tags from it. To do this, we need to create one more method parse, to fetch data from the given url. Step 5: Fetching data from given pageBefore writing parse function, test few things like how to fetch any data from given page. To do this make use of scrapy shell. It is just like python interpreter but with the ability to scrape data from the given url. In short, its a python interpreter with Scrapy shell URLNote: Make sure to in the same directory where is present, else it will not shell for fetching data from the given page, use selectors. These selectors can be either from CSS or from Xpath. For now, let’s try to fetch all url by using CSS get anchor tag (‘a’)To extract the data:links = (‘a’). extract()For example, links[0] will show something like this:’GeeksforGeeks‘To get href attribute, use attributes = (‘a::attr(href)’). extract()This will get all the href data which is very useful. Make use of this link and start requesting, let’s create parse method and fetch all the urls and then yield it. Follow that particular URL and fetch more links from that page and this will keep on happening again and again. In short, we are fetching all url present on that, by default, filters those url which has already been visited. So it will not crawl the same url path again. But it’s possible that in two different pages there are two or more than two similar links. For example, in each page, the header link will be available which means that this header link will come in each page request. So try to exclude it by checking parse(self, response): title = (‘title::text’). extract_first() links = (‘a::attr(href)’). extract() for link in links: yield { ‘title’: title, ‘links’: link} if ‘geeksforgeeks’ in link: yield quest(url = link, callback =) Below is the implementation of scraper:import scrapyclass ExtractUrls(): name = “extract” def start_requests(self): for url in urls: yield quest(url = url, callback =) def parse(self, response): title = (‘title::text’). extract() for link in links: yield { ‘title’: title, ‘links’: link} if ‘geeksforgeeks’ in link: yield quest(url = link, callback =) Step 6: In last step, Run the spider and get output in simple json filescrapy crawl NAME_OF_SPIDER -o links. jsonHere, name of spider is “extract” for given example. It will fetch loads of data within few: Note: Scraping any web page is not a legal activity. Don’t perform any scraping operation without permission. Attention geek! Strengthen your foundations with the Python Programming Foundation Course and learn the basics. To begin with, your interview preparations Enhance your Data Structures concepts with the Python DS Course. And to begin with your Machine Learning Journey, join the Machine Learning – Basic Level Course
Web Scraping in Python using Scrapy (with multiple examples)
Overview
This article teaches you web scraping using Scrapy, a library for scraping the web using Python
Learn how to use Python for scraping Reddit & e-commerce websites to collect data
Introduction
The explosion of the internet has been a boon for data science enthusiasts. The variety and quantity of data that is available today through the internet is like a treasure trove of secrets and mysteries waiting to be solved. For example, you are planning to travel – how about scraping a few travel recommendation sites, pull out comments about various do to things and see which property is getting a lot of positive responses from the users! The list of use cases is endless.
Yet, there is no fixed methodology to extract such data and much of it is unstructured and full of noise.
Such conditions make web scraping a necessary technique for a data scientist’s toolkit. As it is rightfully said,
Any content that can be viewed on a webpage can be scraped. Period.
With the same spirit, you will be building different kinds of web scraping systems using Python in this article and will learn some of the challenges and ways to tackle them.
By the end of this article, you would know a framework to scrape the web and would have scrapped multiple websites – let’s go!
Note- We have created a free course for web scraping using BeautifulSoup library. You can check it out here- Introduction to Web Scraping using Python.
Table of Contents
Overview of Scrapy
Write your first Web Scraping code with Scrapy
Set up your system
Scraping Reddit: Fast Experimenting with Scrapy Shell
Writing Custom Scrapy Spiders
Case Studies using Scrapy
Scraping an E-Commerce site
Scraping Techcrunch: Create your own RSS Feed Reader
1. Overview of Scrapy
Scrapy is a Python framework for large scale web scraping. It gives you all the tools you need to efficiently extract data from websites, process them as you want, and store them in your preferred structure and format.
As diverse the internet is, there is no “one size fits all” approach in extracting data from websites. Many a time ad hoc approaches are taken and if you start writing code for every little task you perform, you will eventually end up creating your own scraping framework. Scrapy is that framework.
With Scrapy you don’t need to reinvent the wheel.
Note: There are no specific prerequisites of this article, a basic knowledge of HTML and CSS is preferred. If you still think you need a refresher, do a quick read of this article.
2. Write your first Web Scraping code with Scrapy
We will first quickly take a look at how to setup your system for web scraping and then see how we can build a simple web scraping system for extracting data from Reddit website.
2. 1 Set up your system
Scrapy supports both versions of Python 2 and 3. If you’re using Anaconda, you can install the package from the conda-forge channel, which has up-to-date packages for Linux, Windows and OS X.
To install Scrapy using conda, run:
conda install -c conda-forge scrapy
Alternatively, if you’re on Linux or Mac OSX, you can directly install scrapy by:
pip install scrapy
Note: This article will follow Python 2 with Scrapy.
2. 2 Scraping Reddit: Fast Experimenting with Scrapy Shell
Recently there was a season launch of a prominent TV series (GoTS7) and the social media was on fire, people all around were posting memes, theories, their reactions etc. I had just learned scrapy and was wondering if it can be used to catch a glimpse of people’s reactions?
Scrapy Shell
I love the python shell, it helps me “try out” things before I can implement them in detail. Similarly, scrapy provides a shell of its own that you can use to experiment. To start the scrapy shell in your command line type:
scrapy shell
Woah! Scrapy wrote a bunch of stuff. For now, you don’t need to worry about it. In order to get information from Reddit (about GoT) you will have to first run a crawler on it. A crawler is a program that browses web sites and downloads content. Sometimes crawlers are also referred as spiders.
About Reddit
Reddit is a discussion forum website. It allows users to create “subreddits” for a single topic of discussion. It supports all the features that conventional discussion portals have like creating a post, voting, replying to post, including images and links etc. Reddit also ranks the post based on their votes using a ranking algorithm of its own.
A crawler needs a starting point to start crawling(downloading) content from. Let’s see, on googling “game of thrones Reddit” I found that Reddit has a sub-reddit exclusively for game of thrones at this will be the crawler’s start URL.
To run the crawler in the shell type:
fetch(“)
When you crawl something with scrapy it returns a “response” object that contains the downloaded information. Let’s see what the crawler has downloaded:
view(response)
This command will open the downloaded page in your default browser.
Wow that looks exactly like the website, the crawler has successfully downloaded the entire web page.
Let’s see how does the raw content looks like:
print
That’s a lot of content but not all of it is relevant. Let’s create list of things that need to be extracted:
Title of each post
Number of votes it has
Number of comments
Time of post creation
Extracting title of posts
Scrapy provides ways to extract information from HTML based on css selectors like class, id etc. Let’s find the css selector for title, right click on any post’s title and select “Inspect” or “Inspect Element”:
This will open the the developer tools in your browser:
As it can be seen, the css class “title” is applied to all
tags that have titles. This will helpful in filtering out titles from rest of the content in the response object:
(“”). extract()
Here (.. ) is a function that helps extract content based on css selector passed to it. The ‘. ’ is used with the title because it’s a css. Also you need to use::text to tell your scraper to extract only text content of the matching elements. This is done because scrapy directly returns the matching element along with the HTML code. Look at the following two examples:
Notice how “::text” helped us filter and extract only the text content.
Extracting Vote counts for each post
Now this one is tricky, on inspecting, you get three scores:
The “score” class is applied to all the three so it can’t be used as a unique selector is required. On further inspection, it can be seen that the selector that uniquely matches the vote count that we need is the one that contains both “score” and “unvoted”.
When more than two selectors are required to identify an element, we use them both. Also since both are CSS classes we have to use “. ” with their names. Let’s try it out first by extracting the first element that matches:
(“”). extract_first()
See that the number of votes of the first post is correctly displayed. Note that on Reddit, the votes score is dynamic based on the number of upvotes and downvotes, so it’ll be changing in real time. We will add “::text” to our selector so that we only get the vote value and not the complete vote element. To fetch all the votes:
Note: Scrapy has two functions to extract the content extract() and extract_first().
Dealing with relative time stamps: extracting time of post creation
On inspecting the post it is clear that the “time” element contains the time of the post.
There is a catch here though, this is only the relative time(16 hours ago etc. ) of the post. This doesn’t give any information about the date or time zone the time is in. In case we want to do some analytics, we won’t be able to know by which date do we have to calculate “16 hours ago”. Let’s inspect the time element a little more:
The “title” attribute of time has both the date and the time in UTC. Let’s extract this instead:
(“time::attr(title)”). extract()
The (attributename) is used to get the value of the specified attribute of the matching element.
Extracting Number of comments:
I leave this as a practice assignment for you. If you have any issues, you can post them here: and the community will help you out .
So far:
response – An object that the scrapy crawler returns. This object contains all the information about the downloaded content.
(.. ) – Matches the element with the given CSS selectors.
extract_first(.. ) – Extracts the “first” element that matches the given criteria.
extract(.. ) – Extracts “all” the elements that match the given criteria.
Note: CSS selectors are a very important concept as far as web scraping is considered, you can read more about it here and how to use CSS selectors with scrapy.
2. 3 Writing Custom Spiders
As mentioned above, a spider is a program that downloads content from web sites or a given URL. When extracting data on a larger scale, you would need to write custom spiders for different websites since there is no “one size fits all” approach in web scraping owing to diversity in website designs. You also would need to write code to convert the extracted data to a structured format and store it in a reusable format like CSV, JSON, excel etc. That’s a lot of code to write, luckily scrapy comes with most of these functionality built in.
Creating a scrapy project
Let’s exit the scrapy shell first and create a new scrapy project:
scrapy startproject ourfirstscraper
This will create a folder “ourfirstscraper” with the following structure:
For now, the two most important files are:
– This file contains the settings you set for your project, you’ll be dealing a lot with it.
spiders/ – This folder is where all your custom spiders will be stored. Every time you ask scrapy to run a spider, it will look for it in this folder.
Creating a spider
Let’s change directory into our first scraper and create a basic spider “redditbot”:
scrapy genspider redditbot This will create a new spider “” in your spiders/ folder with a basic template:
Few things to note here:
name: Name of the spider, in this case it is “redditbot”. Naming spiders properly becomes a huge relief when you have to maintain hundreds of spiders.
allowed_domains: An optional list of strings containing domains that this spider is allowed to crawl. Requests for URLs not belonging to the domain names specified in this list won’t be followed.
parse(self, response): This function is called whenever the crawler successfully crawls a URL. Remember the response object from earlier? This is the same response object that is passed to the parse(.. ).
After every successful crawl the parse(.. ) method is called and so that’s where you write your extraction logic. Let’s add the earlier logic wrote earlier to extract titles, time, votes etc. in the parse function:
def parse(self, response):
#Extracting the content using css selectors
titles = (”). extract()
votes = (”). extract()
times = (‘time::attr(title)’). extract()
comments = (‘. comments::text’). extract()
#Give the extracted content row wise
for item in zip(titles, votes, times, comments):
#create a dictionary to store the scraped info
scraped_info = {
‘title’: item[0],
‘vote’: item[1],
‘created_at’: item[2],
‘comments’: item[3], }
#yield or give the scraped info to scrapy
yield scraped_info
Note: Here yield scraped_info does all the magic. This line returns the scraped info(the dictionary of votes, titles, etc. ) to scrapy which in turn processes it and stores it.
Save the file and head back to shell. Run the spider with the following command:
scrapy crawl redditbot
Scrapy would print a lot of stuff on the command line. Let’s focus on the data.
Notice that all the data is downloaded and extracted in a dictionary like object that meticulously has the votes, title, created_at and comments.
Exporting scraped data as a csv
Getting all the data on the command line is nice but as a data scientist, it is preferable to have data in certain formats like CSV, Excel, JSON etc. that can be imported into programs. Scrapy provides this nifty little functionality where you can export the downloaded content in various formats. Many of the popular formats are already supported.
Open the file and add the following code to it:
#Export as CSV Feed
FEED_FORMAT = “csv”
FEED_URI = “”
And run the spider:
This will now export all scraped data in a file Let’s see how the CSV looks:
What happened here:
FEED_FORMAT: The format in which you want the data to be exported. Supported formats are: JSON, JSON lines, XML and CSV.
FEED_URI: The location of the exported file.
There are a plethora of forms that scrapy support for exporting feed if you want to dig deeper you can check here and using css selectors in scrapy.
Now that you have successfully created a system that crawls web content from a link, scrapes(extracts) selective data from it and saves it in an appropriate structured format let’s take the game a notch higher and learn more about web scraping.
3. Case studies using Scrapy
Let’s now look at a few case studies to get more experience of scrapy as a tool and its various functionalities.
The advent of internet and smartphones has been an impetus to the e-commerce industry. With millions of customers and billions of dollars at stake, the market has started seeing the multitude of players. Which in turn has led to rise of e-commerce aggregator platforms which collect and show you the information regarding your products from across multiple portals? For example when planning to buy a smartphone and you would want to see the prices at different platforms at a single place. What does it take to build such an aggregator platform? Here’s my small take on building an e-commerce site scraper.
As a test site, you will scrape ShopClues for 4G-Smartphones
Let’s first generate a basic spider:
scrapy genspider shopclues This is how the shop clues web page looks like:
The following information needs to be extracted from the page:
Product Name
Product price
Product discount
Product image
Extracting image URLs of the product
On careful inspection, it can be seen that the attribute “data-img” of the tag can be used to extract image URLs:
(“img::attr(data-img)”). extract()
Extracting product name from tags
Notice that the “title” attribute of the tag contains the product’s full name:
(“img::attr(title)”). extract()
Similarly, selectors for price(“. p_price”) and discount(“. prd_discount”).
How to download product images?
Scrapy provides reusable images pipelines for downloading files attached to a particular item (for example, when you scrape products and also want to download their images locally).
The Images Pipeline has a few extra functions for processing images. It can:
Convert all downloaded images to a common format (JPG) and mode (RGB)
Thumbnail generation
Check images width/height to make sure they meet a minimum constraint
In order to use the images pipeline to download images, it needs to be enabled in the file. Add the following lines to the file:
ITEM_PIPELINES = {
”: 1}
IMAGES_STORE = ‘tmp/images/’
you are basically telling scrapy to use the ‘Images Pipeline’ and the location for the images should be in the folder ‘tmp/images/. The final spider would now be:
import scrapy
class ShopcluesSpider():
#name of spider
name = ‘shopclues’
#list of allowed domains
allowed_domains = [”]
#starting url
start_urls = [”]
#location of csv file
custom_settings = {
‘FEED_URI’: ‘tmp/’}
#Extract product information
titles = (‘img::attr(title)’). extract()
images = (‘img::attr(data-img)’). extract()
prices = (‘. p_price::text’). extract()
discounts = (‘. prd_discount::text’). extract()
for item in zip(titles, prices, images, discounts):
‘price’: item[1],
‘image_urls’: [item[2])], #Set’s the url for scrapy to download images
‘discount’: item[3]}
A few things to note here:
custom_settings: This is used to set settings of an individual spider. Remember that is for the whole project so here you tell scrapy that the output of this spider should be stored in a CSV file “” that is to be stored in the “tmp” folder.
scraped_info[“image_urls”]: This is the field that scrapy checks for the image’s link. If you set this field with a list of URLs,, scrapy will automatically download and store those images for you.
On running the spider the output can be read from “tmp/”:
You also get the images downloaded. Check the folder “tmp/images/full” and you will see the images:
Also, notice that scrapy automatically adds the download path of the image on your system in the csv:
There you have your own little e-commerce aggregator
If you want to dig in you can read more about scrapy’s Images Pipeline here
Scraping Techcrunch: Creating your own RSS Feed Reader
Techcrunch is one of my favourite blogs that I follow to stay abreast with news about startups and latest technology products. Just like many blogs nowadays TechCrunch gives its own RSS feed here:. One of scrapy’s features is its ability to handle XML data with ease and in this part, you are going to extract data from Techcrunch’s RSS feed.
Create a basic spider:
Scrapy genspider techcrunch
Let’s have a look at the XML, the marked portion is data of interest:
Here are some observations from the page:
Each article is present between
The title of the post is in
Link to the article can be found in tags.
The author name is enclosed between funny looking
Overview of XPath and XML
XPath is a syntax that is used to define XML documents. It can be used to traverse through an XML document. Note that XPath’s follows a hierarchy.
Extracting title of post
Let’s extract the title of the first post. Similar to (.. ), the function (.. ) in scrapy to deal with XPath. The following code should do it:
(“//item/title”). extract_first()
Output:
u’