Data Types Interview Questions - Python Programming

Python’s built-in data structures are among its most powerful features, enabling fast and flexible coding. Interviewers often assess a candidate's ability to use these structures effectively in both theoretical and practical scenarios.

The most important interview questions on Python data structures: List, Tuple, Set, Dictionary and String.

1. How can you concatenate two lists in Python?

We can concatenate two lists in Python using the +operator or the extend() method.

• Using the + operator:

This creates a new list by joining two lists together.

a = [1, 2, 3]
b = [4, 5, 6]
res = a + b
print(res) 

[1, 2, 3, 4, 5, 6]

• Using the extend() method:

This adds all the elements of the second list to the first list in-place.

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a) 

[1, 2, 3, 4, 5, 6]

2. What is the difference between a Set and Dictionary?

• A Python Set is an unordered collection data type that is iterable, mutable and has no duplicate elements. Python’s set class represents the mathematical notion of a set.
• Syntax: Defined using curly braces {} or the set() function.

my_set = {1, 2, 3}

• Dictionary in Python is an ordered (since Py 3.7) [unordered (Py 3.6 & prior)] collection of data values, used to store data values like a map, which, unlike other Data Types that hold only a single value as an element, Dictionary holds key:value pair. Key-value is provided in the dictionary to make it more optimized.
• Syntax: Defined using curly braces {} with key-value pairs.

my_dict = {"a": 1, "b": 2, "c": 3}

# Set: Only values, no duplicates allowed
my_set = {1, 2, 3, 2, 1}
print("Set:", my_set)  # Output: Set: {1, 2, 3}

# Dictionary: Key-value pairs
my_dict = {"a": 1, "b": 2, "c": 3}
print("Dictionary:", my_dict)  # Output: Dictionary: {'a': 1, 'b': 2, 'c': 3}

# Accessing elements
# Sets: Only iteration
for item in my_set:
    print("Set item:", item)

# Dictionary: Access via keys
print("Value of key 'b':", my_dict["b"])  # Output: 2

3. What are Built-in data types in Python?

The following are the standard or built-in data types in Python:

• Numeric: The numeric data type in Python represents the data that has a numeric value. A numeric value can be an integer, a floating number, a Boolean, or even a complex number.
• Sequence Type: The sequence Data Type in Python is the ordered collection of similar or different data types. There are several sequence types in Python:

1. Python String
2. Python List
3. Python Tuple
4. Python range

• Mapping Types: In Python, hashable data can be mapped to random objects using a mapping object. There is currently only one common mapping type, the dictionary and mapping objects are mutable.

Python Dictionary

• Set Types: In Python, a Set is an unordered collection of data types that is iterable, mutable and has no duplicate elements. The order of elements in a set is undefined though it may consist of various elements.

4. What is the difference between a Mutable datatype and an Immutable data type?

• Mutable data types can be edited i.e., they can change at runtime. Eg: List, Dictionary, etc.
• Immutable data types can not be edited i.e., they can not change at runtime. Eg: String, Tuple, etc.

# Mutable
my_list = [1, 2, 3]
my_list[0] = 99
print(my_list)  # [99, 2, 3]

# Immutable
my_str = "hello"
# my_str[0] = 'H'  # Error: strings are immutable
new_str = "H" + my_str[1:]
print(new_str)  # Hello

5. How is a dictionary different from a list?

A list is an ordered collection of items accessed by their index, while a dictionary is an unordered collection of key-value pairs accessed using unique keys. Lists are ideal for sequential data, whereas dictionaries are better for associative data. For example, a list can store [10, 20, 30], whereas a dictionary can store {"a": 10, "b": 20, "c": 30}.

# List: Accessed by index
fruits = ["apple", "banana", "cherry"]
print(fruits[1])  # banana

# Dictionary: Accessed by key
ages = {"Alice": 25, "Bob": 30}
print(ages["Bob"])  # 30

6. What is the difference between Python Arrays and Lists?

• Arrays (when talking about the array module in Python) are specifically used to store a collection of numeric elements that are all of the same type. This makes them more efficient for storing large amounts of data and performing numerical computations where the type consistency is maintained.
• Syntax: Need to import the array module to use arrays.

Example:

from array import array
arr = array('i', [1, 2, 3, 4])  # Array of integers
for x in arr:
    print(x)

• Lists are more flexible than arrays in that they can hold elements of different types (integers, strings, objects, etc.). They come built-in with Python and do not require importing any additional modules.
• Lists support a variety of operations that can modify the list.

Example:

a = [1, 'hello', 3.14, [1, 2, 3]]
for x in a:
    print(x)

read more about Difference between List and Array in Python

7. Differentiate between List and Tuple?

List:

• Lists are Mutable datatype.
• Lists consume more memory
• The list is better for performing operations, such as insertion and deletion.
• The implication of iterations is Time-consuming

Tuple:

• Tuples are Immutable datatype.
• Tuple consumes less memory as compared to the list
• A Tuple data type is appropriate for accessing the elements
• The implication of iterations is comparatively Faster

import sys

a = [1, 2, 3]
b = (1, 2, 3)

print(sys.getsizeof(a))  # More bytes
print(sys.getsizeof(b))  # Fewer bytes

Use tuple when data should not change and performance matters.

8. Why do tuple and list behave differently when used as dictionary keys?

Theoretical Explanation:

• Dictionary keys must be hashable.
• list is mutable and not hashable, can’t be a dict key.
• tuple is immutable and hashable, valid dict key.

Code Example: copy is comparatively slower.

d = {}
d[(1, 2)] = "ok"  
# d[[1, 2]] = "fail"  # TypeError: unhashable type: 'list'

Both look similar, but mutability affects their behavior in key-based data structures.

9. Which sorting technique is used by sort() and sorted() functions of python?

Python uses the Tim Sort algorithm for sorting. It’s a stable sorting whose worst case is O(N log N). It’s a hybrid sorting algorithm, derived from merge sort and insertion sort, designed to perform well on many kinds of real-world data.

10. Explain Python Sets with examples of their operations and typical use cases.

A set is an unordered collection of unique items, defined using curly braces {} or the set() constructor.

Duplicate Elimination:

s = {1, 2, 2, 3}
print(s)  # → {1, 2, 3}

Operations:

a = {1, 2, 3}
b = {3, 4, 5}

a.union(b)         # {1, 2, 3, 4, 5}
a.intersection(b)  # {3}
a.difference(b)    # {1, 2}

a.add(6)           # adds an element
a.discard(2) 
print("a:")# removes if exists; no error if not
for x in a:
    print(x)
print("b:")
for x in a:
    print(x)

Use Cases:

• Removing duplicates from a list
• Fast membership testing
• Performing set algebra (e.g., finding common items)

Sets are ideal for mathematical operations and ensuring uniqueness.

11. Describe Python Strings, their immutability and common operations.

A string is an immutable, ordered sequence of Unicode characters. Defined using single (') or double (") quotes.

Common Operations:

# code
print("GFG")
text = "hello world"

text[0]           # 'h' (indexing)
text[0:5]         # 'hello' (slicing)
text.upper()      # 'HELLO WORLD'
text.split()      # ['hello', 'world']
"-".join(["a", "b"])  # 'a-b'
text.replace("world", "Python")  # 'hello Python'
text.find("o")    # returns index of first 'o'

f-Strings (formatted strings):

name = "Bob"
age = 25
print(f"Name: {name}, Age: {age}")  # 'Name: Bob, Age: 25'

Immutability:

Once a string is created, its contents cannot be changed. Operations that modify a string return a new string.

s = "abc"
s[0] = "z"  # This give TypeError

Strings are crucial for text processing, data parsing and user interaction.

12. What happens when you use mutable data types as default arguments in functions?

Theoretical Explanation:

• Default values in Python are evaluated once at function definition time.
• If you use a mutable object (like a list), it retains state across calls.

Code Example:

def add_item(item, lst=[]):
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]  Unexpected

Fix:

def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

13. What is the difference between int("5") and int("5.0") in Python?

Theoretical Explanation:

• int("5") works because it's a valid integer string.
• int("5.0") raises a ValueError because it’s a float in string form, not a valid int literal.

Code Example:

print(int("5"))     
print(int(float("5.0"))) 
# print(int("5.0"))  # ValueError

"5.0" and "5" are both integers, but string parsing rules are strict, "5.0" must be converted to float first.

14. Why is list unhashable, but tuple hashable? Can a tuple be unhashable too?

Explanation:

• Lists are mutable, can’t be hashed (used as keys in dict)
• Tuples are immutable, hashable, but only if all their elements are hashable

Code:

hash((1, 2))       # works
# hash([1, 2])     # TypeError

# Tuple with list inside → not hashable
t = (1, [2, 3])
# hash(t)          #  Error

Even a tuple can be unhashable if it contains a mutable object like a list.

15. Why is dict key order preserved in modern Python versions?

Explanation:

• Since Python 3.7+, dictionaries preserve insertion order
• Not guaranteed in older versions

Code:

d = {'x': 1, 'y': 2, 'z': 3}
print(d)  # Ordered as inserted in 3.7+

This helps implement LRU caches, ordered configs, etc., using built-in dict.

16. What is the output of "a" * 0 and [] * 3 and why?

Explanation:

• "a" * 0 -> '' (empty string)
• [] * 3 -> [] (empty list)
• Multiplying by zero returns empty container of same type

Code:

print("a" * 0)   # ''
print([] * 3)    # []
print([1] * 3)   # [1, 1, 1]

17. Why does modifying one row in a 2D list affect all rows?

Explanation: Using [[0]*3]*3 copies the same inner list reference, changing one row changes all.

Code:

a = [[0]*3]*3
a[0][0] = 99
print(a)  # All rows' first elements become 99

Fix:

a = [[0]*3 for _ in range(3)]
print(a)

18. Can you sort a dictionary by values? Return it as a new dict?

Explanation: Yes, using sorted() with key=lambda.

Code:

d = {'a': 3, 'b': 1, 'c': 2}
sorted_dict = dict(sorted(d.items(), key=lambda x: x[1]))
print(sorted_dict)  # {'b': 1, 'c': 2, 'a': 3}

Important for ranking systems, frequency analysis, etc.