Python Interview Questions for Experienced with PDF

Some of the main data types in Python are int, float, str, list, tuple, set, and dict. Each one is used for different kinds of information.

While both are used to store collections of items, lists are mutable, meaning they can be changed, while tuples are immutable. This immutability makes tuples faster and more memory-efficient.

List comprehension is a quick way to create lists by writing the logic inside square brackets. It’s simpler and faster than using a loop.

List comprehensions provide a concise way to create lists. For example, squares = [x**2 for x in range(10)] will create a list of square numbers from 0 to 9.

Decorators are functions that modify other functions. They help add extra features to existing code without changing the original function.

Python has an automatic garbage collector that manages memory allocation and deallocation. It uses a combination of reference counting and cycle detection.

The init method initializes a newly created object, while new is responsible for creating the object itself. Normally, you only override init, but sometimes new is useful for custom object creation.

Multiple inheritance allows a class to inherit from more than one base class. It is powerful but can lead to complications like the “diamond problem.” Python uses the C3 Linearization algorithm (Method Resolution Order – MRO) to resolve such issues.

Static methods don’t take self or cls as their first parameter and act like regular functions. Class methods, on the other hand, take cls as the first parameter and can modify class state.

Inheritance allows a class to use properties and methods from another class. This helps reuse code and keep it organized. Check here for more on inheritance in Python.

Method overriding happens when a subclass has a method with the same name as the one in the parent class. It allows the subclass to have its own version of that method.

Dunder methods, like init or str, are special methods used to define the behavior of Python objects. They help in customizing how objects work.

Decorators are functions that modify the behavior of another function or method. They are often used for logging, authentication, or modifying the output of a function. Example:

def my_decorator(func):
    def wrapper():
        print("Something before the function.")
        func()
        print("Something after the function.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

Generators are functions that return items one at a time, which saves memory. They use the yield keyword instead of return.

Context managers are used to properly manage resources like file streams or database connections. The with statement is a common way to implement context managers, ensuring resources are properly closed or released after use.

Python uses a technique called garbage collection to free up memory that is no longer used. It automatically manages memory using reference counting and a garbage collector.

Python uses try-except blocks to manage errors. You put code that might cause an error in a try block, and handle the error in the except block.

Closures happen when an inner function remembers variables from the outer function, even after the outer function has finished executing.

Django is a web framework that helps you build websites quickly and securely. It provides tools for handling things like databases, routing, and security.

Flask is a smaller and simpler framework than Django. It’s more flexible but needs more work to set up. Django comes with many built-in features, while Flask lets you choose what you want to add.

Pandas is a library used for data analysis. It helps you work with large datasets and makes it easy to manipulate and visualize data.

NumPy is a tool in Python for doing math with numbers. It helps you work with arrays and matrices, which are like lists of numbers. People often use NumPy for science and math projects because it makes calculations easier.

You can install libraries using pip and manage them in a requirements.txt file or a virtual environment. Example: pip install requests installs the requests library for handling HTTP requests.

try-except handles exceptions that occur in the try block, while try-finally ensures that the finally block runs no matter what happens in the try block, making it useful for cleanup.

Some common exceptions include IndexError, KeyError, ValueError, TypeError, and AttributeError. Handling these properly ensures your program doesn’t crash unexpectedly.

You can use the built-in pdb module for step-by-step debugging. You can also use IDEs like PyCharm or VS Code, which come with graphical debuggers.

Use the open() function to open a file. Example:

with open('file.txt', 'r') as file:
    content = file.read()

The csv module can be used to read and write CSV files. Alternatively, you can use the pandas library for more advanced operations.

The GIL is a mechanism that prevents multiple threads from running Python code at the same time. It makes multi-threading slower for CPU-bound tasks.

Multithreading in Python allows your program to run several threads at once, which is helpful for tasks like reading files or downloading data from the internet.

Multithreading runs multiple threads in a single process, while multiprocessing runs multiple processes, each with its own memory. Multiprocessing is useful for CPU-heavy tasks.

You can use threading for I/O-bound tasks and multiprocessing for CPU-bound tasks. AsyncIO is another option for non-blocking, I/O-heavy operations.

The asyncio is a library for asynchronous I/O. It lets you write code that can perform tasks concurrently without the complexity of threads.

The async is used to declare asynchronous functions, and await is used to wait for an asynchronous operation to complete. Example:

async def main():
    await asyncio.sleep(1)

Python uses libraries like SQLite or MySQL with Python to connect to databases. You can send SQL commands from your Python code to query and modify the database.

SQLAlchemy is a Python library that helps manage databases using object-relational mapping (ORM). It lets you interact with databases using Python classes instead of raw SQL.

Django has a built-in ORM, so you can define models for your database tables. Django handles the database connection and queries automatically.

The Python unittest is a built-in module for writing and running tests. It helps check if your code works as expected by writing test cases.

A Data Provider in TestNG allows a test method to run multiple times with different sets of data. This helps in testing various scenarios without duplicating code.

Pytest is a popular testing framework in Python. It simplifies writing test cases and has many useful plugins for extending its functionality.

We can use libraries like BeautifulSoup or Scrapy to extract data from websites. Python is often used to gather information from the web and store it for analysis.

Python is popular for machine learning because of libraries like TensorFlow, Keras, and Scikit-learn. These libraries provide pre-built tools to build and train machine learning models.

Python can be used to automate tasks on cloud platforms like AWS or Google Cloud using their SDKs. You can write Python scripts to manage cloud resources, deploy applications, or handle data.

For securing web apps, you can use Django’s built-in security features like CSRF protection, SQL injection prevention, and HTTPS support.

Input validation ensures that only correct data is passed into your program. You can check data types, formats, and ranges to prevent harmful inputs.

Some techniques include using list comprehensions, reducing function calls, using Cython to compile Python code into C, and utilizing built-in libraries like multiprocessing.

The Global Interpreter Lock (GIL) stops more than one native thread from running Python code at the same time. This makes multithreading less effective because even if there are multiple threads, only one can run Python bytecode at a time. However, there are ways to get around this problem. You can use the multiprocessing module, which allows you to create separate processes that can run in parallel.