Category: python interview questions

we can concatenate two tubles using ‘+’ symbol See below example

tuple_odd = (1, 3 , 5)
tuple_even = (2, 4, 6)

tuple_int = tuple_odd + tuple_even

print( tuple_int ) # (1, 3, 5, 2, 4, 6)

A Python decorator is a way to modify or extend the behavior of a function or method without directly changing its code. It is a special kind of function that takes another function as input, adds some functionality to it, and then returns the modified function.

Decorators are often used for things like logging, authentication, timing, or modifying function outputs.

---

How a Decorator Works:

1. A decorator is a function that wraps another function.
2. It takes the original function as an argument.
3. It returns a new function (or sometimes the same function) with the desired modifications.

---

Basic Syntax of a Decorator:

Using the @decorator_name syntax, you can easily apply a decorator to a function.

@decorator_name
def function_to_decorate():
    pass

The line @decorator_name is equivalent to writing:

function_to_decorate = decorator_name(function_to_decorate)

---

Example: Writing and Using a Decorator

Step 1: Write a Decorator

Here’s a simple decorator that adds logging:

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} finished.")
        return result
    return wrapper

Step 2: Apply the Decorator

You can apply the decorator to a function using the @ syntax:

@log_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

Output:

Calling function: say_hello
Hello, Alice!
Function say_hello finished.

---

Why Use Decorators?

1. Code Reusability: Decorators let you reuse logic across multiple functions.
2. Clean Code: Keep the core function logic separate from additional behaviors.
3. DRY Principle: Avoid repetition (Don’t Repeat Yourself).

---

A Practical Example: Timing a Function

Here’s a decorator that measures how long a function takes to run:

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time:.2f} seconds to execute.")
        return result
    return wrapper

@timer_decorator
def compute_square(numbers):
    return [n ** 2 for n in numbers]

compute_square(range(1, 1000000))

---

Decorators with Arguments

If you want your decorator to take arguments, you need to add another level of nesting:

def repeat_decorator(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat_decorator(times=3)
def greet():
    print("Hello!")

greet()

Output:

Hello!
Hello!
Hello!

---

Decorators are an essential feature in Python that can simplify code and add powerful functionality with minimal changes! Let me know if you’d like further clarification or more examples. 😊

Python modules and packages are ways to organize and reuse code, but they serve different purposes. Here’s a detailed breakdown of each and how they differ:

---

What is a Python Module?

• A module is a single file of Python code that contains definitions and statements such as functions, classes, and variables.
• The file must have a .py extension.
• Modules make it easier to organize and reuse code by importing it into other scripts.

Example of a Module:

File: math_utils.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

You can use this module in another script:

import math_utils

result = math_utils.add(3, 5)
print(result)  # Output: 8

---

What is a Python Package?

• A package is a directory that contains multiple modules and a special __init__.py file.
• The __init__.py file (can be empty) marks the directory as a package and allows it to be imported like a module.
• Packages help organize related modules into a single namespace.

Structure of a Package:

math_package/
    __init__.py
    addition.py
    subtraction.py

addition.py:

def add(a, b):
    return a + b

subtraction.py:

def subtract(a, b):
    return a - b

Use the package:

from math_package.addition import add
from math_package.subtraction import subtract

print(add(3, 5))        # Output: 8
print(subtract(10, 4))  # Output: 6

---

Key Differences Between Modules and Packages

Feature	Module	Package
Definition	A single Python file (.py).	A directory containing multiple modules.
Purpose	Organize code into reusable files.	Group related modules into a namespace.
File Structure	A single .py file.	A directory with an __init__.py file.
Import	Import the .py file directly.	Import modules from the package.
Example	import my_module	from my_package import my_module

---

How They Work Together

You can combine packages and modules to structure large projects effectively. For example:

my_project/
    __init__.py
    data_processing/
        __init__.py
        clean.py
        analyze.py
    visualization/
        __init__.py
        plot.py
        export.py

Usage:

from my_project.data_processing.clean import clean_data
from my_project.visualization.plot import create_plot

---

Summary:

• A module is a single .py file containing Python code.
• A package is a collection of modules grouped into a directory with an __init__.py file.
• Modules are ideal for smaller, independent functionalities, while packages are better for organizing related functionality across multiple files.