Python uses reference counting for memory management.
The GIL ensures thread safety by:

• Protecting shared memory

• Preventing race conditions

• Simplifying memory management

Good For:

• I/O-bound tasks (network calls, file operations)

• Simpler memory management

• Faster single-threaded performance

Bad For:

• CPU-bound tasks

• Multi-core parallel computation

The Global Interpreter Lock (GIL) ensures that only one thread executes Python bytecode at a time in CPython. This directly affects how multithreading behaves, especially for CPU-bound tasks.

Effect on CPU-Bound Tasks 

For CPU-intensive operations (calculations, loops, data processing):

• Multiple threads cannot run in parallel

• Threads take turns executing

• No true multi-core utilization

Effect on I/O-Bound Tasks

For I/O operations (file reading, network requests, database calls):

• When a thread waits for I/O, it releases the GIL

• Another thread can execute

 Multithreading works well for:

• Web scraping

• API calls

• File handling

• Network communication

Multithreading in Python is achieved using the threading module, which allows multiple threads to run concurrently within the same process.

However, due to the GIL (Global Interpreter Lock) in CPython:

• Threads are best suited for I/O-bound tasks

• Not ideal for CPU-bound parallel computation

Multiprocessing is a technique in Python that allows a program to run multiple processes simultaneously, enabling true parallel execution across multiple CPU cores.

Unlike multithreading, multiprocessing bypasses the GIL (Global Interpreter Lock) because each process has its own separate Python interpreter and memory space.

Why Use Multiprocessing?

• Achieve true parallelism

• Utilize multiple CPU cores

• Improve performance for CPU-bound tasks

Basic Syntax

@decorator_name def function_name(): pass

This is equivalent to:

function_name = decorator_name(function_name)

Python

Copy Code

def my_decorator(func): def wrapper(): print("Before function call") func() print("After function call") return wrapper @my_decorator def greet(): print("Hello!") greet()

Why Decorators Are Used

• Logging

• Authentication

• Timing functions

• Access control

• Caching

• Input validation

Internally, decorators work using:

• First-class functions

• Higher-order functions

• Closures

• Function reassignment

A decorator takes a function as input, wraps it inside another function, and returns the wrapped function.

A closure in Python is a function that:

1. Is defined inside another function

2. Remembers variables from the outer function

3. Even after the outer function has finished execution

A context manager in Python is an object that manages resources automatically using the with statement.

It ensures that:

• Resources are properly acquired

• Resources are properly released

• Cleanup happens even if an exception occurs

Context managers in Python are implemented in two main ways:

1. Using a class with __enter__() and __exit__() methods

2. Using the contextlib module with the @contextmanager decorator

Implementation Using a Class

A context manager class must define:

• __enter__() → Executes when entering the with block

• __exit__() → Executes when exiting the with block

class MyContext: def __enter__(self): print("Entering block") return self def __exit__(self, exc_type, exc_value, traceback): print("Exiting block") return False # Do not suppress exceptions with MyContext(): print("Inside with block") 

Why Metaclasses Are Used

Metaclasses allow you to:

• Modify class creation

• Enforce coding rules

• Automatically register classes

• Inject methods or attributes

• Implement frameworks (like Django ORM)

Method Difference

Normal Class Methods:

• __init__() → Runs when object is created

• __str__(), __repr__(), etc.

Metaclass Methods:

• __new__() → Runs when class is created

• __init__() → Initializes the class

The LEGB rule defines the order in which Python searches for variables when they are referenced in a program.

LEGB stands for:

• L → Local

• E → Enclosing

• G → Global

• B → Built-in

 Why Memory Pooling is Needed

Frequent memory allocation and deallocation from the OS is:

• Slow

• Expensive

• Fragmentation-prone

Reference Counting

Python tracks how many references point to an object.

• When reference count becomes zero, memory is freed immediately.

• Provides fast cleanup.

__new__() Method

• First method called

• Responsible for creating and returning a new instance

• Is a static method

• Required when subclassing immutable types (int, str, tuple)

.py → Human-readable Python source code

.pyc → Compiled Python bytecode (machine-readable for Python Virtual Machine)

What is a .py File?

• Contains Python source code

• Written by developers

• Editable and readable

• Interpreted by Python

Serialization → Converting an object into a format that can be stored or transmitted

Deserialization → Converting that stored/transmitted data back into an object

Why Serialization is Needed

• Store objects in files

• Send data over network

• Save data to database

• Caching

• Inter-process communication

To handle large files efficiently, avoid loading the entire file into memory.
Instead, use:

• Streaming (line-by-line reading)

• Chunk processing

• Generators

• Buffered I/O

• Memory-efficient libraries

Exceptions are logged using Python’s built-in logging module, typically inside a try-except block using:

• logging.error()

• logging.exception()

• logger.error()

Why Use Logging Instead of print()

• Better debugging

• Log levels

• Stores history

• Supports files, console, remote systems

• Production-ready

What is an Infinite Loop?

An infinite loop occurs when the loop condition never becomes False.

To avoid infinite loops:

• Always define a proper termination condition

• Ensure the loop variable updates correctly

• Use break when necessary

• Add safety checks or timeouts

You can check the memory usage of an object using:

• sys.getsizeof() → Basic size

• __sizeof__() → Internal size

• pympler → Deep memory size

• tracemalloc → Track memory allocations

Why Weak References Are Useful

• Avoid circular reference issues

• Implement caching systems

• Manage large object graphs

• Observer patterns

• Avoid memory leaks

A descriptor is an object that defines how attribute access is handled in Python classes using special methods:

• __get__()

• __set__()

• __delete__()

obj.attribute 

Method Overloading vs Method Overriding

Why Method Overriding is Used

• Customize inherited behavior

• Implement specific logic

• Achieve runtime polymorphism

• Extend functionality

Python supports duck typing through its dynamic typing system, meaning Python cares about what an object can do (its methods/behavior), not what type it is.

What is Duck Typing?

In duck typing:

• No need for inheritance

• No need for explicit interfaces

• Only required behavior matters

To optimize Python code:

1. Measure performance (profiling)

2. Improve algorithms (reduce complexity)

3. Use efficient data structures

4. Minimize unnecessary computations

5. Use built-in functions and libraries

6. Apply concurrency when needed

When to Use Async

 Web servers
 API calls
 Database queries
 File/network operations

Event-driven programming is a programming paradigm where the flow of execution is determined by events, such as:

• User actions (clicks, key presses)

• System events

• Network responses

• Messages or signals

Python handles concurrency using:

Multithreading
Multiprocessing
Asynchronous programming (asyncio)

Each is suitable for different types of tasks.

What is Concurrency?

Concurrency means Managing multiple tasks at the same time.

A coroutine is a special type of function that can:

• Pause its execution

• Yield control back to the caller

• Resume execution later

Internally, Python differs from Java and C++ in terms of:

• Execution model

• Memory management

• Typing system

• Performance

• Compilation process

Why Cython is Used

Python is slower for CPU-heavy tasks because:

• It is dynamically typed

• It runs on a virtual machine

• It has GIL limitations

Cython helps by:

• Converting Python code to C

• Allowing static type declarations

• Reducing Python runtime overhead

Important Internal Components

Common Python performance bottlenecks include:

• Inefficient algorithms

• Excessive loops in Python

• Improper data structures

• Heavy CPU-bound operations

• Blocking I/O

• GIL limitations

• Excessive object creation

• Memory inefficiency

To design scalable Python applications:

• Use modular architecture

• Separate concerns (clean architecture)

• Optimize performance

• Use asynchronous or concurrent processing

• Scale horizontally

• Use caching and load balancing

• Monitor and profile continuously

This promotes:

• Loose coupling

• Better testability

• Cleaner architecture

Production-level Python code should be:

• Clean and readable

• Modular and scalable

• Well-tested

• Secure

• Performant

• Monitored and maintainable