Hidden Python Tricks and Useful Functions

Python is a versatile programming language with many libraries; this article presents several lesser‑known Python techniques that can make development more efficient and code more elegant.

1. Ternary Operator

The ternary operator provides a concise one‑line alternative to multi‑line if‑else statements: value_if_true if condition else value_if_false .

<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

The enumerate() function adds a counter to an iterable and returns it as an enumerate object, useful for tracking indices 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

The zip() function aggregates elements from each of the iterables into tuples, allowing 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 Comprehension

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 (Anonymous) Functions

Lambda functions are small, anonymous functions defined with the lambda keyword, useful for one‑off operations without a full def statement.

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

6. any() and all() Functions

The any() function returns True if any element of an iterable is true; all() returns True only if all elements are true.

<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 are iterables that produce values on the fly using the yield keyword, saving memory compared to building full sequences.

<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. *args and **kwargs

Use * to capture variable positional arguments and ** for variable keyword arguments in function definitions.

<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

Modules can be imported dynamically 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)
</code>

12. Dictionary Comprehension

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 defining a __call__ method can be invoked like a function, making classes behave as callables.

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

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

14. Underscores in Large Numbers

Underscores improve readability of large numeric literals.

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

15. Quick Dictionary Merge

Merge two dictionaries efficiently 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; their contents can change without altering the object's identity.

<code>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
</code>