Unlock Hidden Python Powers: 16 Little‑Known Tricks Every Developer Should Know

Introduction

Python is a versatile programming language with a rich ecosystem of libraries, yet many useful tricks remain obscure. Learning these can make coding faster, cleaner, and more powerful.

1. Ternary Operator

The ternary operator is a compact form of an if‑else statement: value_if_true if condition else value_if_false. It reduces multi‑line conditionals to a single line.

a = 5
b = 10
max = a if a > b else b  # 10
print(max)

2. enumerate() Function

enumerate()

adds a counter to any iterable and returns an enumerate object, which is handy when you need both the index and the value during iteration.

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

3. zip() Function

zip()

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

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

4. List Comprehensions

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

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

5. Lambda Functions

Lambda functions are anonymous, single‑expression functions useful for quick, throw‑away operations without defining a full def block.

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

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.

numbers = [1, 2, 3, 0, 4]
print(any(numbers))   # True
print(all(numbers))   # False (because of 0)

7. itertools Module

The itertools module offers advanced iterator tools such as permutations, product, and chain, which are powerful yet often overlooked.

import itertools
numbers = [1, 2, 3]
perms = list(itertools.permutations(numbers))
print(perms)
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

8. Generators

Generators produce values on‑the‑fly using the yield keyword, enabling memory‑efficient iteration and custom iterator creation.

def fibonacci_series(n):
    a, b = 0, 1
    for _ 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

9. Decorators

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

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

10. Variable‑Length Arguments

Use *args to collect positional arguments and **kwargs to collect keyword arguments into tuples and dictionaries, respectively.

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}

11. Dynamic Importing

The importlib module allows modules to be imported programmatically at runtime, based on user input or configuration.

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

12. Dictionary Comprehensions

Dictionary comprehensions create dictionaries in a single, readable line, mirroring list comprehensions.

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

13. Callable Objects

Any object defining a __call__ method can be invoked like a function, turning classes into callable entities.

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

adder = Adder()
result = adder(3, 4)
print(result)  # 7

14. Underscores in Numeric Literals

Underscores can be placed inside numeric literals to improve readability without affecting the value.

num_test = 100_345_405
print(num_test)  # 100345405

15. Merging Dictionaries Quickly

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

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}

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).

cities = ["Munich", "Zurich", "London"]
print(id(cities))
cities.append("Berlin")
print(id(cities))  # same id

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

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

Conclusion

These hidden Python tricks can boost your productivity, make your code more elegant, and deepen your mastery of the language. Happy coding!