13 Lesser‑Known Python Tricks for Cleaner and More Efficient Code

Python is a versatile programming language with a rich ecosystem of libraries and features. This article presents a collection of lesser‑known Python techniques that can simplify code, improve readability, and boost performance.

1. Ternary Operator

The ternary operator provides a compact syntax for an if‑else expression: value_if_true if condition else value_if_false . It enables one‑line conditional assignments.

<code>a = 5
b = 10
max = a if a > b else b  # value_if_true if condition else value_if_false
print(max)  # 10</code>

2. enumerate() Function

enumerate() adds a counter to an iterable and returns pairs of index and value, which is handy when you need to track positions while iterating.

<code>fruits = ['apple', 'banana', 'mango']
for index, fruit in enumerate(fruits):
    print(index, fruit)
# 0 apple
# 1 banana
# 2 mango</code>

3. zip() Function

zip() aggregates elements from multiple iterables into tuples, allowing simultaneous traversal of several sequences.

<code>list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for x, y in zip(list1, list2):
    print(x, y)
# 1 a
# 2 b
# 3 c</code>

4. List Comprehension

List comprehensions create new lists from existing iterables in a single, readable line, often replacing explicit for‑loops.

<code>squared_numbers = [x**2 for x in range(1, 6)]
print(squared_numbers)  # [1, 4, 9, 16, 25]</code>

5. Lambda (Anonymous) Functions

Lambda functions define small, one‑off functions without the def keyword, useful for short operations.

<code>add = lambda x, y: x + y
result = add(3, 4)
print(result)  # 7</code>

6. any() and all() Functions

any() returns True if at least one element of an iterable is truthy; all() returns True only if every element is truthy.

<code>numbers = [1, 2, 3, 0, 4]
print(any(numbers))   # True
print(all(numbers))   # False (0 makes it False)</code>

7. itertools Module

The itertools module offers utilities for efficient iterator handling, such as permutations , product , and chain .

<code>import itertools
numbers = [1, 2, 3]
result = list(itertools.permutations(numbers))
print(result)
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]</code>

8. Generators

Generators produce values lazily using the yield keyword, enabling memory‑efficient iteration.

<code># Using yield to create a generator

def fibonacci_series(n):
    a, b = 0, 1
    for i in range(n):
        yield a
        a, b = b, a + b

for number in fibonacci_series(10):
    print(number)
# 0 1 1 2 3 5 8 13 21 34</code>

9. Decorators

Decorators modify the behavior of functions or classes using the @ syntax, useful for logging, timing, authentication, etc.

<code>def log_function(func):
    def wrapper(*args, **kwargs):
        print(f'Running {func.__name__}')
        result = func(*args, **kwargs)
        print(f'{func.__name__} returned {result}')
        return result
    return wrapper

@log_function
def add(x, y):
    return x + y

print(add(5, 7))
# Running add
# add returned 12
# 12</code>

10. Variable‑Length Arguments (*args, **kwargs)

The * operator expands a sequence into positional arguments, while ** expands a mapping into keyword arguments.

<code>def print_arguments(*args, **kwargs):
    print(args)
    print(kwargs)

print_arguments(1, 2, 3, name='John', age=30)
# (1, 2, 3)
# {'name': 'John', 'age': 30}</code>

11. Dynamic Import (importlib)

Modules can be imported at runtime using importlib.import_module , allowing flexible loading based on user input or configuration.

<code>import importlib
module_name = 'math'
module = importlib.import_module(module_name)
result = module.sqrt(9)
print(result)  # 3.0</code>

12. Dictionary Comprehension

Dictionary comprehensions build dictionaries in a single, readable line, similar to list comprehensions.

<code>squared_numbers = {x: x**2 for x in range(1, 6)}
print(squared_numbers)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}</code>

13. Callable Objects

Any object implementing the __call__ method behaves like a function and can be invoked with parentheses.

<code>class Adder:
    def __call__(self, x, y):
        return x + y

adder = Adder()
result = adder(3, 4)
print(result)  # 7</code>

14. Underscores in Numeric Literals

Underscores improve readability of large numbers without affecting their value.

<code>num_test = 100_345_405
print(num_test)  # 100345405</code>

15. Merging Dictionaries Quickly

Two dictionaries can be merged using the unpacking operator ** in a single expression.

<code>dictionary_one = {"a": 1, "b": 2}
dictionary_two = {"c": 3, "d": 4}
merged = {**dictionary_one, **dictionary_two}
print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}</code>

16. Mutability of Lists, Sets, and Dictionaries

Lists, sets, and dictionaries are mutable; their contents can change without altering the object's identity (memory address).

<code>cities = ["Munich", "Zurich", "London"]
print(id(cities))
cities.append("Berlin")
print(id(cities))  # same id as before

my_set = {1, 2, 3}
print(id(my_set))
my_set.add(4)
print(id(my_set))  # same id as before

thisdict = {"brand": "Ford", "model": "Mustang", "year": 1964}
print(id(thisdict))
thisdict["engine"] = "2500cc"
print(id(thisdict))  # same id as before</code>

By mastering these hidden gems, Python developers can write code that is more concise, readable, and performant.