Do you want simpler Python code? You always start a project with the best intentions, a clean codebase, and a nice structure. But over time, there are changes to your apps, and things can get a little messy.
If you can write and maintain clean, simple Python code, then it’ll save you lots of time in the long term. You can spend less time testing, finding bugs, and making changes when your code is well laid out and simple to follow.
In this tutorial you’ll learn:
- How to measure the complexity of Python code and your applications
- How to change your code without breaking it
- What the common issues in Python code that cause extra complexity are and how you can fix them
Throughout this tutorial, I’m going to use the theme of subterranean railway networks to explain complexity because navigating a subway system in a large city can be complicated! Some are well designed, and others seem overly complex.
Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.
Code Complexity in Python
The complexity of an application and its codebase is relative to the task it’s performing. If you’re writing code for NASA’s jet propulsion laboratory (literally rocket science), then it’s going to be complicated.
Note: For a discussion of how to deal with a large Python codebase, check out The Real Python Podcast Episode 160.
The question isn’t so much, “Is my code complicated?” as, “Is my code more complicated than it needs to be?”
The Tokyo railway network is one of the most extensive and complicated in the world. This is partly because Tokyo is a metropolis of over 30 million people, but it’s also because there are 3 networks overlapping each other.
There are the Toei and Tokyo Metro rapid-transport networks as well as the Japan Rail East trains going through Central Tokyo. To even the most experienced traveler, navigating central Tokyo can be mind-bogglingly complicated.
Here is a map of the Tokyo railway network to give you some perspective:
If your code is starting to look a bit like this map, then this is the tutorial for you.
First, we’ll go through 4 metrics of complexity that can give you a scale to measure your relative progress in the mission to make your code simpler:
After you’ve explored the metrics, you’ll learn about a tool called wily to automate calculating those metrics.
Metrics for Measuring Complexity
Much time and research have been put into analyzing the complexity of computer software. Overly complex and unmaintainable applications can have a very real cost.
The complexity of software correlates to the quality. Code that is easy to read and understand is more likely to be updated by developers in the future.
Here are some metrics for programming languages. They apply to many languages, not just Python.
Lines of Code
LOC, or Lines of Code, is the crudest measure of complexity. It is debatable whether there is any direct correlation between the lines of code and the complexity of an application, but the indirect correlation is clear. After all, a program with 5 lines is likely simpler than one with 5 million.
When looking at Python metrics, we try to ignore blank lines and lines containing comments.
Lines of code can be calculated using the wc command on Linux and Mac OS, where file.py is the name of the file you want to measure:
$ wc -l file.py
If you want to add the combined lines in a folder by recursively searching for all .py files, you can combine wc with the find command:
$ find . -name \*.py | xargs wc -l
For Windows, PowerShell offers a word count command in Measure-Object and a recursive file search in Get-ChildItem:
PS C:\> Get-ChildItem -Path *.py -Recurse | Measure-Object –Line
In the response, you will see the total number of lines.
Why are lines of code used to quantify the amount of code in your application? The assumption is that a line of code roughly equates to a statement. Lines is a better measure than characters, which would include whitespace.
In Python, we are encouraged to put a single statement on each line. This example is 9 lines of code:
1x = 5
2value = input("Enter a number: ")
3y = int(value)
4if x < y:
5 print(f"{x} is less than {y}")
6elif x == y:
7 print(f"{x} is equal to {y}")
8else:
9 print(f"{x} is more than {y}")
If you used only lines of code as your measure of complexity, it could encourage the wrong behaviors.
Python code should be easy to read and understand. Taking that last example, you could reduce the number of lines of code to 3:
1x = 5; y = int(input("Enter a number:"))
2equality = "is equal to" if x == y else "is less than" if x < y else "is more than"
3print(f"{x} {equality} {y}")
But the result is hard to read, and PEP 8 has guidelines around maximum line length and line breaking. You can check out How to Write Beautiful Python Code With PEP 8 for more on PEP 8.
This code block uses 2 Python language features to make the code shorter:
- Compound statements: using
; - Chained conditional or ternary statements:
name = value if condition else value if condition2 else value2
We have reduced the number of lines of code but violated one of the fundamental laws of Python:
“Readability counts”
— Tim Peters, Zen of Python
This shortened code is potentially harder to maintain because code maintainers are humans, and this short code is harder to read. We will explore some more advanced and useful metrics for complexity.
Cyclomatic Complexity
Cyclomatic complexity is the measure of how many independent code paths there are through your application. A path is a sequence of statements that the interpreter can follow to get to the end of the application.
One way to think of cyclomatic complexity and code paths is imagine your code is like a railway network.
For a journey, you may need to change trains to reach your destination. The Lisbon Metropolitan railway system in Portugal is simple and easy to navigate. The cyclomatic complexity for any trip is equal to the number of lines you need to travel on:
If you needed to get from Alvalade to Anjos, then you would travel 5 stops on the linha verde (green line):
This trip has a cyclomatic complexity of 1 because you only take 1 train. It’s an easy trip. That train is equivalent in this analogy to a code branch.
If you needed to travel from the Aeroporto (airport) to sample the food in the district of Belém, then it’s a more complicated journey. You would have to change trains at Alameda and Cais do Sodré:
This trip has a cyclomatic complexity of 3, because you take 3 trains. You might be better off taking a taxi!
Seeing as how you’re not navigating Lisbon, but rather writing code, the changes of train line become a branch in execution, like an if statement.
Let’s explore this example:
x = 1
There is only 1 way this code can be executed, so it has a cyclomatic complexity of 1.
If we add a decision, or branch to the code as an if statement, it increases the complexity:
x = 1
if x <