Top 112 Python Interview Questions And Answers

Question 1

What are the _built-in types_ available In Python?

Accepted Answer

Common _immutable_ type:

1. numbers: `int()`, `float()`, `complex()`
2. immutable sequences: `str()`, `tuple()`, `frozenset()`, `bytes()`

Common _mutable_ type (almost everything else):

1. mutable sequences: `list()`, `bytearray()`
2. set type: `set()`
3. mapping type: `dict()`
4. classes, class instances
5. etc.

You have to understand that Python represents all its data as objects. Some of these objects like lists and dictionaries are mutable, meaning you can change their content without changing their identity. Other objects like integers, floats, strings and tuples are objects that can not be changed.

Question 2

How do I _modify_ a string?

Accepted Answer

You can’t because strings are _immutable_. In most situations, you should simply construct a new string from the various parts you want to assemble it from. Work with them as lists; turn them into strings only when needed.

```py
>>> s = list("Hello zorld")
>>> s
['H', 'e', 'l', 'l', 'o', ' ', 'z', 'o', 'r', 'l', 'd']
>>> s[6] = 'W'
>>> s
['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
>>> "".join(s)
'Hello World'
```

Question 3

Name some _characteristics_ of Python?

Accepted Answer

Here are a few key points:

*   Python is an **interpreted language**. That means that, unlike languages like C and its variants, Python does not need to be compiled before it is run. Other interpreted languages include _PHP_ and _Ruby_.
*   Python is **dynamically typed**, this means that you don't need to state the types of variables when you declare them or anything like that. You can do things like `x=111` and then `x="I'm a string"` without error
*   Python is well suited to **object orientated programming** in that it allows the definition of classes along with composition and inheritance. Python does not have access specifiers (like C++'s `public`, `private`), the justification for this point is given as "we are all adults here"
*   In Python, **functions are first-class objects**. This means that they can be assigned to variables, returned from other functions and passed into functions. Classes are also first class objects
*   Writing Python code is quick but running it is **often slower than compiled languages**. Fortunately, Python allows the inclusion of C based extensions so bottlenecks can be optimised away and often are. The `numpy` package is a good example of this, it's really quite quick because a lot of the number crunching it does isn't actually done by Python

Question 4

Convert a _Singly Linked List_ to _Circular Linked List_

Accepted Answer

To convert a singly linked list to a circular linked list, we will set the next pointer of the tail node to the head pointer.

*   Create a copy of the head pointer, let's say `temp`.
*   Using a loop, traverse linked list till tail node (last node) using temp pointer.
*   Now set the next pointer of the tail node to head node. `temp->next = head`

Question 5

Name some _benefits_ of Python

Accepted Answer

*   Python is a **dynamic-typed** language. It means that you don’t need to mention the data type of variables during their declaration.
*   Python supports **object-orientated programming** as you can define classes along with the composition and inheritance.
*   **Functions** in Python are like **first-class objects**. It suggests you can assign them to variables, return from other methods and pass them as arguments.
*   Developing using Python is quick but running it is often slower than compiled languages.
*   Python has several usages like web-based applications, test automation, data modeling, big data analytics, and much more.

Question 6

What are _local variables_ and _global variables_ in Python?

Accepted Answer

* **Global Variables**: Variables declared _outside_ a function or in global space are called global variables. These variables can be accessed by any function in the program.
* **Local Variables**: Any variable declared _inside_ a function is known as a local variable. This variable is present in the local space and not in the global space.

Question 7

What are descriptors?

Accepted Answer

Descriptors were introduced to Python way back in version 2.2. They provide the developer with the ability to add managed attributes to objects. The methods needed to create a descriptor are `__get__`, `__set__` and `__delete__`. If you define any of these methods, then you have created a descriptor.

Descriptors power a lot of the magic of Python’s internals. They are what make properties, methods and even the super function work. They are also used to implement the new style classes that were also introduced in Python 2.2.

Question 8

How to implement a _Tree_ data-structure? Provide some code.

Accepted Answer

That is a basic (generic) tree structure that can be used for `String` or any other object:

Question 9

Explain how Insertion Sort works

Accepted Answer

**Insertion Sort** is an _in-place_, _stable_, _comparison-based_ sorting algorithm. The idea is to maintain a sub-list which is always sorted. An element which is to be 'insert'ed in this sorted sub-list, has to find its appropriate place and then it has to be inserted there. Hence the name, **insertion sort**.

Steps on how it works:
* If it is the first element, it is already sorted.
* Pick the next element.
* Compare with all the elements in sorted sub-list.
* Shift all the the elements in sorted sub-list that is greater than the value to be sorted.
* Insert the value.
* Repeat until list is sorted.

**Visualisation:**

![](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)

Question 10

Does Python have a _switch-case_ statement?

Accepted Answer

In Python befor 3.10, we **do not hav**e a switch-case statement. Here, you may write a switch function to use. Else, you may use a set of if-elif-else statements. To implement a function for this, we may use a dictionary.

```py
def switch_demo(argument):
    switcher = {
        1: "January",
        2: "February",
        3: "March",
        4: "April",
        5: "May",
        6: "June",
        7: "July",
        8: "August",
        9: "September",
        10: "October",
        11: "November",
        12: "December"
    }
    print switcher.get(argument, "Invalid month")
```

Python 3.10 (2021) introduced the [`match`\-`case`](https://www.python.org/dev/peps/pep-0634/) statement which provides a first-class implementation of a "switch" for Python. For example:

For example:

```python
def f(x):
    match x:
        case 'a':
            return 1
        case 'b':
            return 2
```

The `match`\-`case` statement is considerably more powerful than this simple example.

Top 112 Python Interview Questions

What are the built-in types available In Python?

How do I modify a string?

Name some characteristics of Python?

What are the rules for local and global variables in Python?

How the string does get converted to a number?

What is Lambda Functions in Python?

Does Python have a switch-case statement?

What are descriptors?

What are local variables and global variables in Python?

Name some benefits of Python

When to use a tuple vs list vs dictionary in Python?

What is Negative Index in Python?

Explain what is Linear (Sequential) Search and when may we use one?

What is a None value?

Is it possible to have static methods in Python?

What is the python with statement designed for?

Explain the UnboundLocalError exception and how to avoid it?

What is Pickling and Unpickling?

What does this stuff mean: *args, **kwargs? Why would we use it?

How can you share global variables across modules?

What is the function of self?

What is the difference between range and xrange functions in Python?

What is a Callable?

What are virtualenvs?

What's the difference between the list methods append() and extend()?

What does an x = y or z assignment do in Python?

How can I create a copy of an object in Python?

What are the Wheels and Eggs? What is the difference?

What are the key differences between Python 2 and 3?

What is the difference between range and xrange? How has this changed over time?

Explain how to use Slicing in Python?

Explain what is Interpolation Search

What is a Jump (or Block) Search?

Explain how does Python memory management work?

Why would you use the pass statement?

What is introspection/reflection and does Python support it?

What are Decorators in Python?

What are the Dunder/Magic/Special methods in Python? Name a few.

Is there a tool to help find bugs or perform static analysis?

What is Monkey Patching and is it ever a good idea?

What's the difference between lists and tuples?

What does the Python nonlocal statement do (in Python 3.0 and later)?

What are immutable objects in Python?

What is the difference between a function decorated with @staticmethod and one decorated with @classmethod?

Why are default values shared between objects?

What is Monkey Patching? How to use it in Python?

Explain how you reverse a generator?

How is memory managed in Python?

What is Cython?

What is the difference between old style and new style classes in Python?

Why aren't Python nested functions called closures?

What is the difference between deep and shallow copy?

Why Python (CPython and others) uses the GIL?

What are metaclasses in Python?

Is it a good idea to use multi-thread to speed your Python code?

What are the advantages of NumPy over regular Python lists?

How to work with transitive dependencies?

What is the purpose of the single underscore _ variable in Python?

Can you explain Closures (as they relate to Python)?

Why are Python's private methods not actually private?

What's the difference between a Python module and a Python package?

What is an alternative to GIL?

What is GIL?

What is MRO in Python? How does it work?

What is the difference between @staticmethod and @classmethod?

How is set() implemented internally?

Why would you use metaclasses?

Why use else in try/except construct in Python?

Describe Python's Garbage Collection mechanism in brief

Why isn't all memory freed when Python exits?

What does Python optimisation (-O or PYTHONOPTIMIZE) do?

Is there any downside to the -O flag apart from missing on the built-in debugging information?

Is there a simple, elegant way to define singletons?

What is a global interpreter lock (GIL) and why is it an issue?

Return the N-th value of the Fibonacci sequence. Solve in O(n) time

Given variables a and b, switch their values so that b has the value of a, and a has the value of b without using an intermediary variable

Implement Pre-order Traversal of Binary Tree using Recursion

Suppose lst is [2, 33, 222, 14, 25]. What is lst[-1]?

Explain how Insertion Sort works

When to use a `tuple` vs `list` vs `dictionary` in Python?

What is a `None` value?

What is the python `with` statement designed for?

Explain the `UnboundLocalError` exception and how to avoid it?

What does this stuff mean: `*args`, `**kwargs`? Why would we use it?

What is the function of `self`?

What is the difference between `range` and `xrange` functions in Python?

What's the difference between the list methods `append()` and `extend()`?

What does an `x = y or z` assignment do in Python?

What are the key differences between Python `2` and `3`?

What is the difference between `range` and `xrange`? How has this changed over time?

Why would you use the `pass` statement?

What's the difference between `lists` and `tuples`?

What does the Python `nonlocal` statement do (in Python 3.0 and later)?

What is the difference between a function decorated with `@staticmethod` and one decorated with `@classmethod`?

What is the purpose of the single underscore `_` variable in Python?

What is the difference between `@staticmethod` and `@classmethod`?

How is `set()` implemented internally?

Why use `else` in `try/except` construct in Python?

What does Python optimisation (`-O` or `PYTHONOPTIMIZE`) do?

Is there any downside to the `-O` flag apart from missing on the built-in debugging information?

Return the N-th value of the Fibonacci sequence. Solve in `O(n)` time

Given variables `a` and `b`, switch their values so that `b` has the value of `a`, and a has the value of `b` without using an intermediary variable

Suppose `lst` is `[2, 33, 222, 14, 25]`. What is `lst[-1]`?

After executing the above code, what is the value of `y`?

Split the Linked List into `k` consecutive linked list "parts"

Display `startNumber` to `endNumber` only from Fibonacci Sequence

Create function that similar to `os.walk`

How to read a `8GB` file in Python?