The Global Interpreter Lock (GIL) in CPython ensures that only one thread executes Python bytecode at a time, simplifying memory management but limiting multi-core performance.

Impact:

• Hinders parallelism in CPU-bound tasks, as threads cannot run concurrently.
• Works well for I/O-bound tasks, as threads can switch during I/O waits.
• Workarounds: Use multiprocessing for parallelism or offload heavy computations to GIL-independent libraries like NumPy.

Python manages memory using reference counting and a garbage collector:

1. Reference Counting: Tracks the number of references to an object. When the count drops to zero, the object is deallocated.
2. Garbage Collector: Handles cyclic references (objects referring to each other) that reference counting can't clean up.
3. Memory Allocation: Objects are stored in a private heap managed by Python's memory manager.

Python’s garbage collection mechanisms:

• Reference Counting: Frees memory when an object's references drop to zero.

• Cycle Detection: Identifies and removes cyclic references (objects referencing each other).

• Generational Garbage Collection: Optimizes performance by categorizing objects into generations and collecting younger objects more frequently.

All managed automatically by Python, with manual control available via the gc module.

The difference between shallow copy and deep copy lies in how they duplicate objects:

1. Shallow Copy:
   • Creates a new object.
   • Copies references of the original object's elements.
   • Changes to mutable elements (e.g., lists, dictionaries) affect both copies.
2. Deep Copy:
   • Creates a new object.
   • Recursively copies all elements, including nested objects.
   • Changes to the copy do not affect the original.

Use the copy module in Python for both (copy.copy() for shallow, copy.deepcopy() for deep).

Metaclasses in Python are "classes of classes" used to define how classes behave. They control class creation and can modify or customize classes dynamically.

Uses of Metaclasses:

• Custom Class Behavior: Modify or validate class attributes and methods during creation.

• Code Automation: Automatically add or modify methods, properties, or attributes in classes.

• Enforcing Standards: Ensure all classes follow certain conventions or implement specific methods.

You define a metaclass by subclassing type and use it via the metaclass keyword in class definitions.

Python descriptors manage how attributes are accessed, set, or deleted in a class using special methods:

1. __get__: Called on attribute access.
2. __set__: Called on attribute assignment.
3. __delete__: Called on attribute deletion.

Types:

• Data Descriptors: Implement __get__ and __set__.
• Non-Data Descriptors: Implement only __get__.

Uses:

• Control attribute behavior.
• Reuse code for attribute management.
• Common in Python features like properties and ORM fields.

Here's the difference between @staticmethod, @classmethod, and instance methods:

1. @staticmethod:
   • Does not take self or cls as the first argument.
   • Can be called on the class or instance.
   • Used for utility functions that don’t need access to instance or class data.
2. @classmethod:
   • Takes cls (class) as the first argument, not self.
   • Can modify class state and be called on the class or instance.
3. Instance methods:
   • Takes self (instance) as the first argument.
   • Operates on instance-specific data and can access both instance and class attributes.

In Python:

• is: Compares object identity (whether two variables refer to the same object in memory).
• ==: Compares values (whether the values of two objects are equal).

Example:

Python

a = [1, 2, 3]

b = a

c = [1, 2, 3]

print(a is b)  # True (same object in memory)

print(a == c)  # True (same values)

print(a is c)  # False (different objects in memory)

Coroutines (defined with async def) are used for asynchronous programming, pausing with await and allowing other tasks to run.

Generators (defined with def and yield) are used for lazy iteration, pausing with yield and resuming on subsequent calls.

• Coroutines: Asynchronous tasks (e.g., I/O).

• Generators: Lazy value generation for iteration.

The __slots__ attribute in Python is used to limit the attributes that an object can have. By defining __slots__, you can prevent the creation of the default __dict__ (which stores object attributes), thus saving memory and improving performance.

Significance:

• Memory Efficiency: Reduces memory usage by preventing the dynamic creation of attributes.
• Performance: Faster attribute access due to fixed storage.

class MyClass:

    __slots__ = ['attr1', 'attr2']

obj = MyClass()

obj.attr1 = 10  # Allowed

obj.attr3 = 20  # AttributeError: 'MyClass' object has no attribute 'attr3'

Python handles data serialization using modules like pickle, json, and marshal:

• pickle: Serializes Python objects into byte streams and deserializes them back. Supports complex Python data types.

• Example: pickle.dump(obj, file) to serialize, pickle.load(file) to deserialize.

• json: Serializes data into JSON format, primarily for interoperability with other languages and systems. Supports basic data types (strings, numbers, lists, dicts).

• Example: json.dump(obj, file) to serialize, json.load(file) to deserialize.

• marshal: Used internally by Python to serialize code objects (not typically for general-purpose data serialization).

Serialization enables storing and transmitting Python objects in a standardized format.

Python's abstract base classes (ABCs) are classes that define a common interface and cannot be instantiated directly. They use the abc module and @abstractmethod decorator to enforce that subclasses implement certain methods.

from abc import ABC, abstractmethod

class MyAbstract(ABC):

    @abstractmethod

    def my_method(self):

        pass

Monkey patching in Python is the practice of modifying or extending existing classes or functions at runtime. It allows you to change behavior without altering the original code, commonly used for bug fixes or adding features.

class MyClass:

    def greet(self):

        print("Hello!")

# Monkey patching the greet method

MyClass.greet = lambda self: print("Hello, World!")

obj = MyClass()

obj.greet()  # Output: Hello, World!

• repr(): Returns a string that represents the object, used for debugging.
• str(): Returns a user-friendly string representation of the object.

Context managers in Python manage resources like files or connections using setup and teardown actions. They are used with the with statement to ensure resources are properly handled.

How to implement:

1. Using __enter__ and __exit__ methods.
2. Using contextlib.contextmanager for simpler implementations.

from contextlib import contextmanager

@contextmanager

def my_context():

    print("Entering context")

    yield

    print("Exiting context")

with my_context():

    print("Inside context")

The __call__ method in Python allows an instance of a class to be called like a function. When an object with a __call__ method is called, it executes that method.

Key Points:

• Defines callable behavior for class instances.
• Can accept arguments just like a regular function.

The __call__ method in Python allows an instance of a class to be called like a function. When an object with a __call__ method is called, it executes that method.

class MyClass:

    def __call__(self, x):

        return x * 2

obj = MyClass()

print(obj(5))  # Output: 10

Here, obj is treated like a function due to the __call__ method.

Decorators in Python are functions that modify the behavior of other functions or methods. They take a function as input and return a new function that enhances or changes its behavior.

def decorator(func):

    def wrapper():

        print("Before")

        func()

        print("After")

    return wrapper

@decorator

def greet():

    print("Hello!")

greet()

 The super() function in Python is used to call methods from a parent class in a subclass, enabling access to inherited methods without directly referencing the parent class.

Example:

class Parent:

    def greet(self):

        print("Hello from Parent")

class Child(Parent):

    def greet(self):

        super().greet()  # Calls Parent's greet

        print("Hello from Child")

child = Child()

child.greet()

Output:

Hello from Parent

Hello from Child

Python implements hashing using the __hash__ method, which returns an integer value used to uniquely identify objects in hash-based collections like sets and dictionaries.

Key Points:

• __hash__: Every object that needs to be hashable must implement this method, which returns a fixed-size integer.

1. 1. Immutability: Hashable objects must be immutable (e.g., tuples, strings) because their hash value should remain constant.

• Equality: If two objects are equal (__eq__), they must have the same hash value.

class MyClass:

    def __hash__(self):

        return hash((self.x, self.y))

obj = MyClass(1, 2)

print(hash(obj))

Python's built-in weakref objects allow you to reference objects without preventing them from being garbage collected. This is useful when you want to keep references to objects but don't want those references to affect their lifetime.

Key Points:

1. weakref module: Provides tools to create weak references.
2. Weak References: Do not increase the reference count of an object, allowing it to be collected by garbage collection when no strong references exist.
3. Use Cases: Commonly used in caches, registries, or listeners where objects should be automatically removed when no longer needed.

import weakref

class MyClass:

    pass

obj = MyClass()

weak_obj = weakref.ref(obj)

print(weak_obj())  # Accesses the object through the weak reference

Once obj is deleted, weak_obj() will return None.

Method Resolution Order (MRO) in Python determines the order in which classes are searched for methods and attributes, especially in multiple inheritance.

Key Points:

• • Python uses the C3 Linearization algorithm.

• The mro() method or __mro__ attribute shows the MRO.

class D(B, C):

    pass

print(D.mro())  # Prints MRO of D

Output 

[<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>]

The difference between __getattr__ and __getattribute__:

1. __getattribute__: Called for every attribute access, including missing ones.
2. __getattr__: Called only when an attribute is missing.

class MyClass:

 def __getattribute__(self, name):

        return super().__getattribute__(name)  # Called for all attributes

    def __getattr__(self, name):

        return "default"  # Called for missing attributes

obj = MyClass()

Python manages multiple inheritance using the C3 Linearization algorithm to determine the Method Resolution Order (MRO). It ensures a consistent and predictable order for method and attribute lookup.

class D(B, C):

    pass

print(D.mro())  # Shows the method resolution order

This avoids conflicts in method resolution when multiple parent classes are involved.

.pyc files are compiled bytecode versions of Python source files. They improve performance by allowing Python to skip recompiling the source code when the program is run.

• Stored in the __pycache__ folder.
• Automatically generated when a .py file is imported.

• Module: A single file containing Python code, such as functions, classes, or variables.

# math_module.py

def add(a, b):

    return a + b

• Package: A collection of modules, typically in a directory, which can contain subdirectories (sub-packages) and an __init__.py file to define it as a package.

math_package/

    __init__.py

    add_module.py

    subtract_module.py

__main__ allows a Python script to behave as both a reusable module and a standalone script.

Code inside the if __name__ == "__main__": block runs when the script is executed directly, but not when it's imported as a module.

def greet():

    print("Hello!")

if __name__ == "__main__":

    greet()  # Runs only if the script is executed directly

async: Defines a function as asynchronous (coroutine), enabling non-blocking operations.

await: Pauses the coroutine execution until the awaited function completes, allowing other tasks to run during the wait.

import asyncio

async def say_hello():

    await asyncio.sleep(1)  # Simulate async operation

    print("Hello!")

asyncio.run(say_hello())

The futures module provides a high-level interface for asynchronously executing tasks using threads or processes.

It enables concurrent execution of code by submitting tasks to be run asynchronously, simplifying multi-threading or multi-processing.

from concurrent.futures import ThreadPoolExecutor

def square(x):

    return x * x

with ThreadPoolExecutor() as executor:

    result = executor.submit(square, 5)

    print(result.result())  # Output: 25

lru_cache is a decorator that caches the results of expensive function calls.

It stores results in a Least Recently Used (LRU) cache, automatically discarding the least recently used results when the cache exceeds a specified size, improving performance by avoiding redundant computations.

from functools import lru_cache

@lru_cache(maxsize=3)

def expensive_function(x):

    print("Calculating...")

    return x * x

print(expensive_function(5))  # Calculating... 25

print(expensive_function(5))  # Uses cached value: 25

Python 2: Uses except Exception, e: syntax.

Python 3: Uses except Exception as e: syntax.

Other Difference: In Python 3, exceptions are more consistently handled as objects, and BaseException is the base class for all exceptions.

Python 2:

try:

    # code

except Exception, e:

    print(e)

Python 3:

try:

    # code

except Exception as e:

    print(e)