Python’s versatility and simplicity make it a developer favorite for tasks ranging from web development to data analysis and machine learning. However, mastering Python goes beyond understanding its syntax; it’s about writing efficient, elegant, and readable code. In this article, we’ll cover 10 Python snippets that will help you code like a pro, improving your programming skills and productivity.

1. Operations with sets

Many Pythons support various operations such as union, intersection, and difference.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1 | set2
intersection = set1 & set2
difference = set1 - set2

This snippet demonstrates set operations for combining, finding common elements, and differences between sets.

2. Partial functions

Partial functions allow you to capture a certain number of function arguments and create a new function.

from functools import partial

def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(2))  # Output: 4
print(cube(2))    # Output: 8

This snippet demonstrates how to create specialized functions using partial.

3. Memoization

Memoization is a technique used to cache the results of expensive function calls and reuse them when repeating the same input data.

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(10))  # Output: 55

4. Metaclasses

Metaclasses are classes of classes. They allow you to customize the creation behavior of a Python class.

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
    pass

obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)  # Output: True

5. Concurrency with asyncio

asyncio is a library for writing competitive code using the async/await syntax.

import asyncio

async def greet(name):
    await asyncio.sleep(1)
    print(f"Hello, {name}!")

async def main():
    await asyncio.gather(greet("Alice"), greet("Bob"))

asyncio.run(main())

This snippet demonstrates asynchronous programming using asyncio to greet multiple people at the same time.

6. Data classes

Data classes provide an easy way to create classes to store data.

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(1.5, 2.5)
print(p)  # Output: Point(x=1.5, y=2.5)

This piece of code creates a simple data class to represent a point in 2D space.

7. Decorators with arguments

Decorators can accept arguments, allowing more flexible behavior.

def repeat(num_times):
    def decorator_repeat(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator_repeat

@repeat(num_times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

8. Overloading functions from functools.singledispatch

functools.singledispatch allows you to overload functions based on the type of the first argument.

from functools import singledispatch

@singledispatch
def process(arg):
    print("Default processing:", arg)

@process.register(int)
def _(arg):
    print("Processing an integer:", arg)

@process.register(list)
def _(arg):
    print("Processing a list:", arg)

process(10)       # Output: Processing an integer: 10
process([1, 2, 3])# Output: Processing a list: [1, 2, 3]

9. Asynchronous iterators

Asynchronous iterators allow you to asynchronously iterate over a sequence of data.

async def async_generator():
    for i in range(3):
        yield i
        await asyncio.sleep(1)

async def main():
    async for item in async_generator():
        print(item)

asyncio.run(main())

10. Dynamic access to attributes with getattr

The getattr function returns the attribute value of the specified object in Python.

class MyClass:
    def __init__(self):
        self.x = 10
        self.y = 20

obj = MyClass()
attribute_name = "x"
print(getattr(obj, attribute_name))  # Output: 10

Conclusion

By integrating these additional Python snippets into your coding arsenal, you’ll strengthen your skills and be able to tackle a wide range of programming tasks efficiently and effectively. Experiment with these snippets and integrate them into your code as needed to improve readability, performance, and usability.