14 Lesser-Known Python Tricks to Write Cleaner, Faster Code

Python is a versatile programming language with a rich ecosystem of libraries and frameworks. Below are fourteen lesser‑known Python tricks that can make your code more elegant, efficient, and easier to maintain.

1. Ternary Operator

The ternary operator provides a compact form of an if‑else statement: value_if_true if condition else value_if_false . It allows you to write conditional logic in a single line.

<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 an enumerate object, which is useful when you need both the index and the value while looping.

<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 each of the iterables into tuples, enabling simultaneous iteration over multiple 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 Comprehensions

List comprehensions provide a concise way to create lists from existing iterables, often replacing multi‑line for‑loops.

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

5. Lambda Functions

Lambda functions are anonymous functions defined with the lambda keyword, useful for short, one‑off 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 the 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 a collection of iterator‑building functions such as chain , product , and permutations .

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

8. Generators

Generators produce values on the fly using the yield keyword, allowing you to create custom iterators without storing the entire sequence in memory.

<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 adding 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. * and ** Argument Unpacking

The * operator expands an iterable into positional arguments, while ** expands a dictionary 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 Imports

Use importlib.import_module() to import a module whose name is determined at runtime.

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

12. Dictionary Comprehensions

Dictionary comprehensions create dictionaries from iterables in a single, readable line.

<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 that implements the __call__ method can be invoked like a function.

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

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

14. Underscore as a Visual Separator in Large Numbers

Underscores improve readability of large numeric literals.

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

15. Quick Dictionary Merging

Merge two dictionaries using the unpacking operator ** .

<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; they can be modified without changing their identity (memory address).

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

# Set example
my_set = {1, 2, 3}
print(id(my_set))
my_set.add(4)
print(id(my_set))

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