Diverging from my data science course and machine learning course articles, where I make personal recommendations, I wanted to see if there's a way to find the best Python courses using data analysis reliably.

This article aims to use similar data and ranking metrics present in the early Google search algorithm.

Out of roughly 3000 offerings, these are the best Python courses according to this analysis:

1. Learn Python by Codecademy
2. Introduction to Python Programming by Udacity
3. Programming for Everybody (Getting Started with Python) by Coursera
4. Introduction to Python for Data Science by Datacamp
5. Complete Python Bootcamp From Zero to Hero in Python by Udemy
6. Introduction to Computer Science and Programming Using Python by Edx
7. An Introduction to Interactive Programming in Python (Part 1) by Coursera
8. Machine Learning with Python by Coursera
9. Intro to TensorFlow for Deep Learning by Udacity
10. Learn to Program: The Fundamentals by Coursera

If you would like to skip the analysis and see course scores, breakdowns, and reviews, click here.

Google-based the early architecture of their search engine on the simple idea that search results could rank web pages according to a PageRank algorithm, which scored web pages based on the quantity and quality of backlinks.

Web pages with many high PageRank backlinks should be more trustworthy. Google's algorithm has become a lot more complex since then, but I thought it would be interesting to apply this logic to Python courses.

If you are new to data analysis or Python, the code in this article might be challenging to follow. Taking one of the intro Python courses above should allow you to understand most of what's written below. This article will give you a glimpse into the various problems Python can solve!

Unfortunately, I don't have the resources to scan the entire Internet for links to courses. To get the required data, I'm using Ahrefs, an SEO analytics software, which crawls the web and stores website data as Google does. To find the top Python courses, I exported data from Ahrefs that corresponds to the Top Pages data from the following platforms:

I chose these platforms because they contain many Python courses, are well-known and trusted providers, and are highly trafficked. If I missed an important platform, please let me know in the comments below so I can update this analysis.

In Ahrefs, I used filters to find relevant course pages by searching for "Python" in the URL or top keyword for the page. Unfortunately, this may have included irrelevant courses while also missing a few courses because (1) it's possible that a Python course doesn't have "Python" in the URL and, (2) a course might not rank in a search engine for keywords containing "Python."

Additionally, I limited the pages to only those that show up in the top 50 search results on Google since I only have a basic Ahrefs plan and can't see data further than that.

Below is a short clip showing the process of finding courses using Ahrefs.

I exported each course platform into separate CSVs, which will need to be filtered even further to exclude certain irrelevant pages. Those filters will be detailed and applied later.

To give you an idea of what these CSVs look like, here's the header and first row of the Coursera CSV:

Here's what each column means:

• # - the row index from Ahrefs (we need to drop this in the next step).
• Traffic (desc), Traffic (Percent %) - this is the search engine traffic to this particular course page, as estimated by Ahrefs. The percentage indicates the share of all website traffic that goes to this specific page.
• # of Keywords - the number of unique keywords for which this page appears in search engines.
• Referring Domains - this is the primary metric of interest. The column states the total number of unique websites that link to the course page.
• URL - the URL of the course page
• Top Keyword, Its Volume - the keyword that gives the most traffic and by how much.
• Position - the position of this course page in search results when looking up the Top Keyword.
• Page URL inside - if the URL was found in one of Google's search features, such as a quote, featured snippet, "People also ask", etc.
• Traffic value - indicates how much the website would have to pay for ads to get the same traffic for the corresponding keyword(s).

We must first combine each CSV into a single data structure to perform an analysis using all platforms. Essentially, all data exploration and manipulation will be done using the pandas library (see our Python pandas tutorial for beginners). So, we'll first import pandas and pathlib, a library that provides tools for working with file paths:

I've named a folder ahrefs-courses to contain the CSVs for each course platform. The folder looks something like this:

We'll use pandas to read and concatenate all CSV data into one DataFrame object.

Below, we get all CSV files from the ahrefs-courses directory, make an empty DataFrame, and concat each file onto the DataFrame. Since each CSV has its own index, we need to reset_index to drop each one and make a new index for the combined dataframe.

Using df.head(1), we can see the first row of the newly combined dataframe. You can already notice a problem: the first course is a search result on Coursera, not an actual course. We'll see in the next section how to further filtering of URLs.

To further filter down the results into actual course pages, we'll need to use a few filters for each platform. I took some time looking through each platform to understand which URL structures corresponded to course pages, and made this dictionary of filters to use:

The goal is to use this dictionary to filter the URL column in the dataframe. The dictionary's key is the platform name, which is also the platform's domain name, and the value is a tuple of requirements for the URL. The tuple contains two lists: (1) URL features to include, and (2) URL features to exclude.

For example, the main URL path for Linkedin Learning courses is linkedin.com/learning/, which we want to include. But we also want to exclude URLs like linkedin.com/learning/topics/. To filter these URLs, we can make sure '/learning/' is in the URL and '/topics/' is not.

To apply these filters to the URL column, I made the following functions:

• apply_filters() - the function that is used directly with df.apply(). Pandas passes each URL from the dataframe into this function, which will return the URL if it meets the criteria or None if it doesn't.
• make_regex() - the apply_filters() function finds the correct platform's filters and passes them to this function to create a regular expression (regex). For example, the regex for Codecademy URL inclusion filters would turn into "/learn/|/courses/", which is regex for find "/learn/" OR "/courses/" in the URL. The default='$^' serves as a placeholder to skip matching if one of the filter lists is empty.

When the URL is filtered out, it's set to None by apply_filters(), allowing us to use dropna() on that column for removal.

Filtering our dataframe looks to have reduced the total number of URLs by about one-half.

In addition to filtering, we'll also filter entire columns since we only need Traffic, Referring Domains, and URL for this analysis.

We need to normalize URLs since the same course could be represented in multiple rows by having a slight URL variation. We will need to merge these where possible.

First, we need to normalize URLs by stripping protocol formats at the start of the URL. This is because http:// or https://, and with or without www. at the start of the URL, are all valid URLs for the same course.

Second, some course URLs represent a chapter or lesson inside the course. We can see an example of this on DataCamp and Linkedin Learning:

We want to strip off the ends to get the root course URL, then merge duplicate rows. Furthermore, we'll strip any paths past two forward slashes (/), not including the protocol, to get to the root course URL.

Here is a function we can apply to the URL column to perform these two normalizers:

The cut_url function will remove the protocol from the front of the URL using regex, split on forward slashes, then join only the first three URL chunks back together.

Using re.sub, which substitutes text, will replace "https://www." with an empty string. Since the URL could be "http" or "https" and may or may not have www., adding a question mark after the "s" and "www." will match all possibilities.

We'll need to apply this function to the URL column, then groupby URL to merge duplicates.

Using .agg('sum') on the groupby, the URL merging summed the Traffic and Referring Domains columns into one row. We have almost halved the number of courses again, but each row should now represent a unique course.

The first thing we might want to know is the number of courses per platform, so we'll first extract the platform's name from the URL and put it in a new column. If we split the URL on periods (.), we'll get a list like ['coursera', 'org/course-title'], where the platform name is at index 0.

Some URLs also have additional subdomains, like language codes. For example, https://ru.coursera.org is a Russian language subdomain on Coursera. We'll need to account for this when getting the platform name by seeing if the split on periods (mentioned above) results in a list longer than two.

We'll apply the following function to the URL column and assigning the result to a new column called Platform.

Since we have the platform name now, let's see how many Python courses we have for each platform.

Below is the code required to make a grouped bar plot, where the left axis is the number of Python courses on each platform, and the right axis is the amount of traffic those courses generate. We first need to make a new dataframe (grouped_df) which is grouped by Platform. Once grouped, we need to aggregate (.agg) the data we're interested in using. Using 'count' on the Platform column will gives us a count of courses on each platform, and using 'sum' on the Traffic column will sum up all traffic for each Platform.

Udemy has significantly more Python-related courses than most other platforms, but Codecademy has the most traffic compared to its smaller number of offerings.

I'm primarily interested in the popularity of a course page, as indicated by the number of unique links it gets. Accordingly, we will first sort by Referring Domains. The PageRank algorithm is more complex than just counting the number of links to a page, but I think this should be an interesting starting point for ranking Python courses.

Let's see the top 20 courses by number of unique referring domains:

Since it's easier to look at plots, let's make a function that plots results in a horizontal bar plot so we can reuse the logic for the rest of the article.

To make sure the bar colors are the same across plots for each unique Platform, we'll first assign each Platform its own color:

Now, we'll create the horizontal bar plot function:

It looks like some non-relevant courses made their way into the top because of keywords frequently with Python. We can filters these out with the upcoming steps.

We can also sort courses by traffic. Ahrefs estimates traffic by looking at keywords, Google positions, and traffic coming from backlinks. Let's look at that now.

It looks like there has been a significant reordering when compare to referring domains, with Codecademy's Python course having a huge lead. Let's see which courses show up in high referring domains and high traffic.

We can filter both of the previous results to show which courses show up in both top lists. I'll expand the maximum results out to 20, so we can see more than just a couple of rows.

This result shows us that only a few records show up in the top referring domains and traffic, all of which are Python courses.

Suppose we use some simple feature engineering to create an interaction term between referring domains and traffic. In that case, it will allow us to rank courses by a single number that considers both features.

To create the interaction term, we'll compute the z-scores of Traffic (desc) and Referring Domains, then create a new column that's the average of the two z-scores.

Luckily, scipy has a z-score function for us. Let's first create a z-score column for traffic and referring domains, then create another column for the interaction term between the two.

First, for the zscore to output a real value, we need to drop any empty values in the two columns:

Now, we can apply the z-score function to the two columns and create an interaction term:

We can now see which Python courses rank the highest according to this z-score interaction term.

We'll use the same horizontal bar plot function as before to visualize the difference in magnitude. Additionally, we'll plot 20 results since some high-ranking courses may not be about Python. We'll need to make a manual filter for the final results.

It appears that Codecademy's Learn Python course has beat out every other course, but Coursera's Machine Learning course is also far ahead of the pack. Unfortunately, since Coursera's course uses Octave instead of Python, it can't be included in the final top results.

From keeping track of the top courses since 2015 for the data science courses and machine learning courses pages, the Python courses shown above do match closely with what I have recommended.

We'll need to filter down these results to Python courses exclusively. Many in the top 20 use another programming language or no language, like in the cryptocurrency course.

After manual filtering, below is the final list of top Python courses according to our interaction term. Additionally, I joined each course to provide my overall impression of the platform and content to understand why it might be ranking so highly.

Using Ahref's traffic and referring domains data, we've found the top ten courses from almost 3000 offerings across the world's largest online course platforms. Since Codecademy's course scored significantly better than any other offering, it's a safe bet to start your Python journey there.

No matter which course you take, make sure to tackle projects as often as possible. Find something you're interested in working on and keep programming until you have something that solves a problem. Show off your solution, use it to help others, and even make a career out of it. Using Python—and programming in general—to create value for yourself and others is a rewarding feedback loop that will keep you working, moving forward, and getting better.