Web scraping in Python with lxml and pandas

Data science and visualization tutorials often begin by referencing an existing dataset. However, it’s often the case that we need or want to create our own dataset. So let’s take a few steps back and think about how we can create one using Python and a few of its popular packages!

import requests
import lxml.html
import pandas as pd

Let’s begin with a quick tour of the packages themselves:

• Requests, a simple HTTP library, and one of the most downloaded Python packages in existence
• lxml, a feature-rich library for processing XML and HTML
• pandas, a powerful data manipulation library with useful structures

None of these packages are esoteric, difficult to use, or difficult to get access to. It’s safe to say that learning about them is a worthwhile investment.

So, let’s bring these tools together and automate the creation of a movie dataset based on the current IMDb Top 1000.

Sourcing the data for Python

Here’s the data from the IMDb Top 1000 list.

By default, we’re presented with 50 movies per page that have been ordered by (ascending) popularity.

With some modifications to our request, we can change it to 200 movies per page that have been ordered by (descending) user rating.

If we visit the page and inspect the source of the movie items, we can see they each appear within div elements with the classes lister-item and mode-advanced.

The XPath to locate these nodes is //div[contains(@class, 'lister-item mode-advanced')].

Using our web inspector, let’s get the XPath for movie features of interest. The idea here is to find points of reference for navigating the HTML document that allow us to extract the data we need. Relative to each movies node above, these are:

• URL: .//h3[@class="lister-item-header"]//a/@href
• Name: .//h3[@class="lister-item-header"]//a/text()
• Thumbnail: .//div[@class="lister-item-image float-left"]//a//img/@loadlate
• Rating: .//div[@class="inline-block ratings-imdb-rating"]//strong/text()
• Genre: .//span[@class="genre"]//text()
• Gross: .//p[@class="sort-num_votes-visible"]//span[last()]/text()

Extracting the data for a single movie

Let’s put our preparation into practice and get the data for the second-place movie, The Shawshank Redemption, into a few variables.

First, we’ll use the requests package to retrieve the HTML source for the first page of 200 movies.

url = "https://www.imdb.com/search/title/?groups=top_1000&sort=user_rating,desc&count=200"
response = requests.get(url)
content = response.content

With that, we’ve retrieved a response to our GET request and stored the content in our content variable. We could check if our response was successful by looking at the response code, where a response code of 200 means everything went OK.

print(response.status_code)
200

Looking good! Next, we’ll parse our HTML content with lxml so that we can start processing it.

---

Over 200k developers use LogRocket to create better digital experiences

Learn more →

---

html = lxml.html.fromstring(content)

We can start using our XPath expressions from earlier to select nodes. Let’s select every parent div element that we know stores the data for our movies.

items = html.xpath("//div[contains(@class, 'lister-item mode-advanced')]")

We should expect 200 movies per page, so let’s double-check if that corresponds to the length of the list we just selected:

print(len(items))
200

Great! Now let’s select the div that contains all of the data for The Shawshank Redemption. We know it placed second in the IMDb Top 1000, so we’ll try indexing the second item.

item = items[1]

Finally, let’s extract the data for every feature we prepared for earlier.

name = item.xpath('.//h3[@class="lister-item-header"]//a/text()')[0]
thumbnail = item.xpath('.//div[@class="lister-item-image float-left"]//a//img/@loadlate')[0]
rating = item.xpath('.//div[@class="inline-block ratings-imdb-rating"]//strong/text()')[0]
genre = item.xpath('.//span[@class="genre"]//text()')[0].strip()
gross = item.xpath('.//p[@class="sort-num_votes-visible"]//span[last()]/text()')[0].strip()
gross = gross if "$" in gross else "N/A"
url = "https://www.imdb.com" + item.xpath('.//h3[@class="lister-item-header"]//a/@href')[0]

To clean the data, some additional wrangling for the features is required:

• url: the paths were relative, so they have been prefixed with the protocol and domain name, https://www.imdb.com
• genre and gross had unwanted whitespace before/after the desired string, so these were stripped out with Python’s .strip()
• gross was not always present, but when it was, it was always in dollars. So, we’ll check for the presence of the $ character and list the gross as not available if it’s missing

Let’s print all these out to see how we did!

print(f"{name=}")
print(f"{thumbnail=}")
print(f"{rating=}")
print(f"{genre=}")
print(f"{gross=}")
print(f"{url=}")

name='The Shawshank Redemption'
thumbnail='https://m.media-amazon.com/images/M/MV5BMDFkYTc0MGEt[email protected]._V1_UX67_CR0,0,67,98_AL_.jpg'
rating='9.3'
genre='Drama'
gross='$28.34M'
url='https://www.imdb.com/title/tt0111161/'

Perfect! We’ve also taken this opportunity to highlight a useful feature of Python f-strings, which allows us to print the expression, the equals sign, and then the evaluated expression!

Automation and creating our DataFrame

We’ve done everything once for a single movie, so let’s move on to automating things for all 1000 of them.

When visiting the IMDB Top 1000 pages above and clicking the Next button, we are taken to this page.

We can see the key difference here is the inclusion of a start parameter, which is set to start at 201. This will be the key to automating the retrieval of all 1000 movies, so we will parameterize this in our upcoming loop.

items = []
for start in range(1,1000,200):
    url = f"https://www.imdb.com/search/title/?groups=top_1000&sort=user_rating,desc&count=200&start={start}&ref_=adv_nxt"
    response = requests.get(url)
    content = response.content
    html = lxml.html.fromstring(content)
    items += html.xpath("//div[contains(@class, 'lister-item mode-advanced')]") 

Here, we’ve updated the same code from earlier by placing it in a loop that goes from 1 to 1000 in intervals of 200. This value is fed into the start parameter that we’ve just discovered, and we’ve appended the movies to our items list 200 at a time. Let’s check the length of the list to be sure.

print(len(items))
1000

We’re nearly there! Now for our DataFrame. Let’s start by creating an empty DataFrame with our desired columns.

data = pd.DataFrame(columns=['name', 'thumbnail', 'rating', 'genre', 'gross', 'thumbnail', 'url'])

All that’s left now is to loop through our retrieved movie items and append our data to our DataFrame.

for item in items:
    name = item.xpath('.//h3[@class="lister-item-header"]//a/text()')[0]
    thumbnail = item.xpath('.//div[@class="lister-item-image float-left"]//a//img/@loadlate')[0]
    rating = item.xpath('.//div[@class="inline-block ratings-imdb-rating"]//strong/text()')[0]
    genre = item.xpath('.//span[@class="genre"]//text()')[0].strip()
    gross = item.xpath('.//p[@class="sort-num_votes-visible"]//span[last()]/text()')[0].strip()
    gross = gross if "$" in gross else "N/A"
    url = "https://www.imdb.com" + item.xpath('.//h3[@class="lister-item-header"]//a/@href')[0]


    data = data.append({'name': name, 'thumbnail': thumbnail, 'rating': rating, 'genre': genre, 'gross': gross, 'url': url}, ignore_index=True)

We can see a sample of our newly generated dataset by displaying the first 10 rows.

data.head(10)

All done! It may be useful to save this to a CSV file at this point.

data.to_csv('data.csv')

Analyzing our data

Let’s interrogate our data a little bit. We’ll start with a histogram of the ratings.

data.rating.hist()
<AxesSubplot:>

We could also check out some summary statistics.

data.rating.astype(float).describe()

count    1000.000000
mean        7.968300
std         0.280292
min         7.600000
25%         7.700000
50%         7.900000
75%         8.100000
max         9.500000
Name: rating, dtype: float64

Bonus exercise!

As a bonus, we have some interesting data in the Genre column, which we could use to build a co-occurrence matrix.

We’ll use the itertools package to give us some extra functions for dealing with iterators.

import itertools

Now, let’s wrangle our genres! First, split the genres into lists.

data['genre'] = data['genre'].str.split(",")

Then, clean the data of any whitespace.

for index, row in data.iterrows():
    genre = [x.strip(' ') for x in row.genre]
    row.genre = genre

We’ll build a list of each unique genre and sort them alphabetically:

genres = [st for row in data.genre for st in row]
genres = set(genres)
genres = sorted(genres)

Then, we construct our co-occurrence matrix.

matrix = pd.DataFrame(0, columns=genres, index=genres)

for index, row in data.iterrows():
    if len(row.genre) == 1:
        matrix[row.genre[0]][row.genre[0]] += 1
    else:
        for genre in list(itertools.combinations(row.genre, 2)):
            matrix[genre[0]][genre[1]] += 1
            matrix[genre[1]][genre[0]] += 1

Which, if we’re curious, looks like the following.

matrix

Notice the size: 21 rows × 21 columns

Finally, we will use Plotapi to create an interactive Chord diagram with our data!

from plotapi import Chord

Chord.set_license("your username", "your license key")

Chord(matrix.values.tolist(), genres, colors="movies").show()

Conclusion

There you have it! In this article, we have gone through the journey of dataset creation to visualization. We completed all these steps using Python, and relied entirely on popular and well-maintained packages, lxml and pandas.

Knowing how to create our own dataset from existing sources is exceptionally useful, and it’s sometimes the only option when an API or data dump has not been made available.

From here, we could grow our IMDb dataset by including the actors that starred in each movie, or visit another data source and practice our new data retrieval, processing, and visualization skills there. Here are some examples that use the same techniques: Co-occurrence of Pokemon Types, Co-occurrence of Animal Crossing Villager Species and Personality, and Retrieving JSON with the requests package.

Cut through the noise of traditional error reporting with LogRocket

LogRocket is a digital experience analytics solution that shields you from the hundreds of false-positive errors alerts to just a few truly important items. LogRocket tells you the most impactful bugs and UX issues actually impacting users in your applications.

Then, use session replay with deep technical telemetry to see exactly what the user saw and what caused the problem, as if you were looking over their shoulder.

LogRocket automatically aggregates client side errors, JS exceptions, frontend performance metrics, and user interactions. Then LogRocket uses machine learning to tell you which problems are affecting the most users and provides the context you need to fix it.

Focus on the bugs that matter — try LogRocket today.