The Zen of Python is a set of golden principles or axioms for the best programming practices in Pythonic style. These guiding principles were first presented by Tim Peters, one of Python's founding contributors, in 1999. They first appear in a mailing list of Python programmers (comp.lang.python/python-list@python.org),
Much of these guidelines are attributed toward the benevolent dictator of life (BDFL)
Note: Benevolent dictator for life (BDFL) is a title given to a small number of open-source software development leaders who retain the final say in disputes or arguments in the community. Guido voluntarily stepped down from the title of Python’s BDFL in 2018.
While programming, these guidelines don't have to be strictly followed. However, these are good programming practices that define the Pythonic way of programming.
These best practices are added into Python language in this.py module as a string object.
How to import this#
These best practices guidelines can be viewed by simply importing the this.py program.
import this in the Python IDE.
import this
Note: A video of Barry Warsaw singing The Zen of Python, which he composed himself, can be found on YouTube.
The 20 golden aphorisms of Zen#
These principles can be grouped into categories. So the order might be a bit different than what is seen in this.py.
Make code readable#
Beautiful is better than ugly.
Focus on simplicity, readability, and elegance. Often, developers are not concerned about the readability while coding. However, Python emphasizes well-thought-out and easy-to-use code. That's what makes Python so popular.
Sparse is better than dense.
Writing one-liner codes that incorporates a lot of functionality may seem alluring to programmers, however, it becomes cumbersome to read. Instead of compressing the code into one line or the minimum number of lines, it's better to keep the code sparse, spanning over multiple lines, for better readability.
Readability counts.
The code should be easy to read. Using appropriate, easy-to-understand names for variables and functions helps. The use of sufficient comments in the code helps any developer who wants to understand and use the code in the future. Making good use of line spacing and indentation helps improve readability.
Example:
Here's a simple example where we have list of numbers. The squares of all numbers are calculated, and then sum of these squared are calculated. There are two implementations of the same problem, one is sparse and the other is dense.
# Sparse example of sum of squares of numbers in the listdef sum_of_squares_sparse(numbers):total = 0for num in numbers:total += num ** 2return total# Dense implementationdef sum_of_squares_dense(numbers):return sum([x ** 2 for x in numbers])
This code is easy to read and understand. It follows The Zen of Python principles, such as:
Sparse is better than dense: In the dense implementation, there are too many things going on in the
returnstatement, making it complex and hard to comprehend. On the other hand, the sparse implementation is easy to follow.Readability counts: The code uses easy-to-understand variable and function names and is formatted cleanly.
Keep it simple#
Simple is better than complex.
If there's a complex problem, break it down into several simpler modules and solve it. For a simple problem, obviously, keep it simple, and don't go looking around for a complex approach.
Complex is better than complicated.
If things can't be made simpler, don't make things complicated. Never make things, solutions, or the code complicated.
Example:
Here's an example of a simple approach to calculating the sum of the first n integers:
# This program calculates the sum of the first n natural numbersn = 10sum = 0for i in range(1, n+1):sum += iprint("The sum of the first", n, "natural numbers is:", sum)
This simple and easy-to-understand code follows several of The Zen of Python principles such as:
Keep it simple: The algorithm to calculate the sum of the first
ninteger is straightforward.Readability counts: The code uses variable names and clean formatting, making it easy to read and understand.
Follow best practices#
Flat is better than nested.
Too much nesting and hierarchy make the code hard to read and understand. The code should be organized as flatly as possible.
Special cases aren't special enough to break the rules.
It's best to follow the standard best practices to develop the algorithm and write the code instead of trying to create a new approach.
Although practicality beats purity.
Well, there is no alternative to experience. If the code is readable and easy to follow, some of the principles may be deviated to serve the purpose of practicality.
Namespaces are one honking great idea -- let's do more of those!
Use namespaces to avoid conflicts while naming the variables. Different namespaces may coexist, but these are isolated from each other. Names in one module do not conflict with the names in another.
Example:
Here's an example of how to follow best practices in Python, making maintainable and robust code:
# This program reads a CSV file and prints out the dataimport csvwith open('data.csv', 'r') as file:reader = csv.reader(file)for row in reader:print(', '.join(row))
The code follows several best practices of Python programming, for example:
Use of a context manager to handle file I/O: The
withstatement is used to close the file after reading is complete. It ensures that resources are released properly after the file has been read.Use of a library to handle CSV parsing: The
csvmodule is used to read and parse the CSV data. It ensures that the data is read correctly.Use of clear and descriptive variable names: The descriptive variable names make the code easy to understand and readable.
Handle Errors#
Explicit is better than implicit.
No prior knowledge should be required for someone who wants to read a program, so keep it as explicit as possible.
Errors should never pass silently.
If there is a silent error, the code returning None or some other error code, should not let it pass silently. That might create some bugs in the future and would be hard to trace back. Instead of a program running with a silent error, it's better if it crashes, and gets fixed it in time.
Remember: As the saying goes, "Seeing a spider in the room isn't scary. It's scary when it disappears."
Unless explicitly silenced.
Some errors or warnings are unavoidable, so make these silent by using the commands to ignore the errors or warnings. However, it should be known where and why these errors or warnings are made silent.
In the face of ambiguity, refuse the temptation to guess.
Always debug instead of making some wild guesses. If the output is not lining up with the solution, instead of making some blind attempts, It's better to understand the problem critically and reach for the right solution.
Example:
Let's look at the following example of calculating the inverse of an integer. Error handling ensures smooth execution of the program.
# This program calculates the inverse of a numbertry:num = float(input("Enter a number: "))inverse = 1.0 / numprint("The inverse of", num, "is:", inverse)except ValueError:print("Error: Input must be a number")except ZeroDivisionError:print("Error: Cannot divide by zero")
To handle the errors gracefully, the program does the following:
Uses a
try-exceptblock to catch errors: The code calculates the inverse of a number within atryblock. It catches possible errors withexceptblocks.Handles specific errors: There could be two specific errors that are handled in two separate
exceptblocks—ValueErrorfor invalid input andZeroDivisionErrorfor division by zero.Prints informative error messages: The code prints informative error messages, making it easy for the user to understand and correct the error.
Concise#
There should be one-- and preferably only one --obvious way to do it.
If there are multiple possible solutions, go for the simplest and most obvious solution, and try not to complicate things.
Although that way may not be obvious at first unless you're
Dutch Guido van Rossumis Dutch
The obvious way may not be that obvious at the first sight. However, an expert (none other than the DutchmanGuido van Rossum himself) may read things between the lines because he knows Python inside out.
Example:
The following example prints the first 10 even numbers in a concise way:
# This program prints the first 10 even numberseven_numbers = [num for num in range(20) if num % 2 == 0]print(even_numbers[:10])
This program follows several of The Zen of Python principles such as:
Simple is better than complex: The code doesn't introduce any unnecessary complexity, keeping it concise and easy to understand.
Readability counts: The code uses appropriate variable names and clean formatting, making it readable and easy to understand.
There should be one-- and preferably only one --obvious way to do it: The code uses list comprehension, which is a Pythonic way to generate lists based on a condition. This is a common way of solving this problem in Python.
Clean code#
Now is better than never.
Follow 'the power of now'. A program should not get into an infinite execution.
Although never is often better than right now.
At times, it is better to wait rather than to quickly jump to the consequences. It's better to wait for the program execution rather than to terminate it early.
Example:
Here's an example that calculates Fibonacci numbers. Notice the code is kept clean and maintainable.
# This program calculates the Fibonacci sequencedef fibonacci(n):"""Return the Fibonacci sequence up to n."""a, b = 0, 1fib_sequence = []while b <= n:fib_sequence.append(b)a, b = b, a + breturn fib_sequence# Example usageresult = fibonacci(100)print(result)
The programming logic ensures the code does not end up in an infinite loop. This example follows several principles of clean code, including:
Use of clear and descriptive names: The function is named
fibonacci, which accurately describes what it does. The variablesa,b, andfib_sequencemake the code easy to understand.Use of docstrings to document functions: The function has a docstring that explains what it does.
Modular approach: The calculation of the Fibonacci sequence is encapsulated in a function, making it modular and easier to maintain.
Clear and concise code: Simple logic calculates the Fibonacci sequence — no complexity, no redundancy.
Easy to explain#
If the implementation is hard to explain, it's a bad idea.
Can it be explained to Joe at the coffee shop? If a developer reads the code in the future, they should easily understand it. If someone can't understand it, that means some of the principles above were not followed.
If the implementation is easy to explain, it may be a good idea.
If other developers can easily get the work, the work is on the right track. The solution may not be optimal or correct, but at least it follows simplicity and readability principles.
Example:
Here's an example that counts the frequency of each word in a file. The code is easy to explain with clear and concise logic:
# This program counts the number of occurrences of each word in a filefrom collections import Counterwith open("text.txt", "r") as file:word_count = Counter(file.read().split())for word, count in word_count.items():print(f"{word}: {count}")
This code is easy to explain because it uses simple logic to count the number of occurrences of each word in a file. It follows several of The Zen of Python principles to keep the code concise and explainable, such as:
Use of the
Counterclass from thecollectionsmodule: This class provides a simple and efficient way to count the number of occurrences of each item in an iterable.Use of a
withstatement to handle file I/O: This ensures that the file is properly closed after reading. This helps keep the code concise and readable.Use of descriptive variable names: The variable
word_countaccurately describes its function. So does the loop variableword.Print an informative message: The code uses an f-string to print out each word and its count in a clear, readable format.
The 20th principle#
Initially, there were 20 principles planned. Wondering where the 20th principle is? It has been left for Guido to fill in, which unfortunately has not been done so far by Guido van Rossum.
Key takeaways#
The Zen of Python emphasizes the importance of readability, simplicity, clarity, consistency, and good coding practices. When learning to code in Python, you should know how to develop a program that is easy to understand, modify, and maintain.
In short, the guiding principles of The Zen of Python can be summarized as follows:
Write code that is easy to read and understand, keeping simplicity, clarity, and explicitness as the main focus.
Handle errors gracefully and provide informative error messages.
Follow established best practices and conventions, and strive for consistency and clarity in your code.
The following courses on Educative platform help developers learn and test their Pythonic way of coding:
Free Resources
