Pythonic code

Python has its own set of idioms and patterns that build on its dynamic typing model and design philosophy from the Zen of Python. The code that uses these idioms and patterns is considered Pythonic code. This code is correct, readable, and aligned with the intended use of the language.

In practice, writing Pythonic code means leveraging the language’s strengths instead of fighting against them. Here are some best practices that you can apply to make your code more Pythonic:

  • Embrace EAFP (Easier to Ask Forgiveness than Permission). Rather than checking every possible precondition up front with an LBYL (Look Before You Leap) style, just try the operation and handle the exception if the code fails. This practice reduces the overhead of repetitive checks, avoids missing checks, prevents certain race conditions, and aligns with Python’s principle: errors should never pass silently.
  • Favor duck typing over strict type checking. Instead of constantly checking types with isinstance() before performing an action, rely on behaviors. If an object behaves like the expected type, then you just use it. This is known as duck typing and can make your code more flexible, extensible, and less tightly coupled to specific data types.
  • Use context managers to manage resources. Instead of manually running setup and teardown stages in resource management, use context managers and the with statement. They ensure that resources, such as files, locks, and network connections, are cleaned up reliably, even in the event of errors.
  • Use comprehensions and generator expressions for data transformation. Comprehensions and generator expressions offer a concise, readable, efficient, and Pythonic way to transform or filter data, compared to manual loops.
  • Lean on common Python idioms and built-ins. Common idioms, such as if __name__ == "__main__" and iteration patterns, features like unpacking, f-strings, and built-ins like enumerate(), zip(), any() or all(), can make code more Pythonic.

To see some of these practices in action, consider the following function, which totals the lengths of a sequence of strings:

🔴 Avoid this:

Python 
>>> def total_length(items):
...     result = 0
...     if isinstance(items, list):
...         for i in range(len(items)):
...             result += len(items[i])
...     return result
...

>>> total_length(["Hello", "Pythonista!"])
16

This function works, but it’s tightly coupled to lists, uses a non-Pythonic iteration pattern, overuses indexing, and relies on isinstance() checks, ignoring other iterable types. It’s also verbose and difficult to understand.

Here’s a more Pythonic version that relies on duck typing, built-ins, and a comprehension:

✅ Favor this:

Python 
>>> def total_length(items):
...     return sum(len(item) for item in items)
...

>>> total_length(["Hello", "Pythonista!"])
16

Now, your function works with any iterable of strings, such as lists, tuples, or custom sequence types. It’s shorter, clearer, and focuses on its high-level intent: * sum the lengths of all input strings*.

LBYL vs EAFP: Preventing or Handling Errors in Python

Tutorial

LBYL vs EAFP: Preventing or Handling Errors in Python

Choose your Python coding style: look before you leap (LBYL) vs easier to ask forgiveness than permission (EAFP). See clear pros, cons, and examples.

intermediate best-practices python

For additional information on related topics, take a look at the following resources:

By Leodanis Pozo Ramos • Updated Feb. 2, 2026
Python Best Practices Share Feedback