Examples from Principles of Zen of Python
Below are some examples of Principles of Zen of Python to deepen your understanding of these fundamentals that Python is based on:
Beautiful is better than ugly.
Ugly Code
def calc(x):
return x*x + 2*x + 1
Beautiful Code
def calculate_quadratic(value):
return value * value + 2 * value + 1
While the first code appears to be shorter, it does not have proper names given to variables and looks more complex than the latter code. This shows us that descriptive names are longer but keep their usage clear.
Explicit is better than implicit.
Implicit
def greeting(name):
return fâHello {name}!â
Explicit
def greeting(name: str) -> str:
âââReturn a greeting message for the given name.âââ
return fâHello, {name}!â
The explicit code is lengthier to write than the implicit one, but it provides comments to give the reader the purpose of the function to avoid confusion.
Simple is better than complex.
Complex
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
Simple
def factorial(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
As you can see, the simpler code uses recursion which is preferred for increased efficiency and avoiding stack overflow-related issues.
Flat is better than nested.
Nested
def process_items(items):
for item in items:
if isinstance(item, int):
if item > 0:
print(f'Processing positive integer: {item}')
Flat
def process_items(items):
for item in items:
if not isinstance(item, int):
continue
if item <= 0:
continue
print(f'Processing positive integer: {item}')
By using continue statement in the second code, the amount of nesting is reduced, making the control flow easier to understand.
Sparse is better than dense
Dense
def add(a,b):return a+b
result=add(5,3)
print(result)
Sparse
def add(a, b):
return a + b
result = add(5, 3)
print(result)
The sparse code has spaces and indentation that make the code simple to grasp in one go.
Errors should not pass silently
def read_file(filename):
try:
with open(filename, 'r') as file:
return file.read()
except FileNotFoundError:
print(f"Error: The file {filename} was not found.")
except Exception as e:
print(f"An error occurred: {e}")
Here explicit code has been written to handle the error where the file needed is not found. Having these blocks makes it easy to spot issues in the code.
It is clear from comparing these examples how code may be improved in terms of elegance, readability, and maintainability by following the Zen of Python principles. For Python developers, these guidelines ensure that their code is clear, simple, and consistent with the Python philosophy in addition to making sure that the code works.
Whatâs the Zen of Python?
Whether you come from a strong programming background or are just a beginner, you must be aware of Python programming language because of its attractive syntax, ease of reading, and simplicity; which most developers use across the globe today. A collection of aphorisms known as âThe Zen of Pythonâ encapsulates one of the fundamental ideas that guide the creation and evolution of the Python programming language. The heart of what makes Python a special and potent programming language is captured in this set of principles, which well-known Python developer Tim Peters wrote.
The Python programming attitude and ethos are embodied in The Zen of Python, which is more than just a set of rules. Upholding simplicity, clarity, and practicality acts as a compass for developers, assisting them in navigating the coding complexity. Weâll explore Pythonâs Zen in this essay.