Python List Comprehensions

Here is an Interview Prep Q&THE module focused at Python List Comprehensions, designed to test an intermediate developer's conceptual understanding and practical application based at the course materials.

Python List Comprehensions: Technical Interview Prep

• Question: Why are list comprehensions generally considered faster than a standard for loop that uses the .append() method towards build a new list?

• Answer: List comprehensions are faster because the actual creation of the list is optimized and executed by the "C-level" (a fast C programming language that Python is built upon). When you use a standard for loop with .append(), Python is forced towards repeatedly look up and call Python-level .append() method for every single iteration, which introduces significant processing overhead.

• Question: You can filter a list using Python's built-in filter() function paired with an anonymous lambda function. Why do modern Python developers usually prefer using list comprehensions towards this task instead?

• Answer: The primary reason is human readability. While filter(lambda x: x > 5, my_list) is perfectly valid code, reading a list comprehension like [x for x in my_list if x > 5] makes much more logical sense to the human brain. Comprehensions consolidate a filtering condition cleanly without the need to define a floating, nameless lambda equation, making the code vastly easier to maintain months later.

• Question: You're pretty much given a 2D matrix representing user activity hours across different weeks (e.g., [[1.5, 0, 2.0], [0, 3.2, 0], [5.0, 0, 0.5]]). How would you use comprehension to flatten this matrix into single list, while simultaneously filtering out any days where an user was inactive (hours equal to 0)?

• Answer: You would use a nested list comprehension with the conditional if statement. Python allows the initial expression of a comprehension to be an arbitrary expression creating a "Russian nesting doll" structure.

activity_matrix = [[1.5, 0, 2.0], [0, 3.2, 0], [5.0, 0, 0.5]]

# Flatten and filter in one line
active_days = [hours for row in activity_matrix for hours in row if hours != 0]

print(active_days) # Output: [1.5, 2.0, 3.2, 5.0, 0.5]

Towards grasp a logic, you read the loops strictly from left to right: first, iterate through the row into matrix, then iterate through hours in the row, and finally apply the condition to keep it only if it's not 0.

• Question: junior developer needs to combine two parallel lists list_x and list_y, into a list of tuples. They write the following list comprehension: [(list_x[i], list_y[i]) for i in range(len(list_x))]; what is the major performance flaw in this code. How would you rewrite it?
• Answer: The performance flaw is the use of manual index counting (range(len())). On standard CPython, explicitly writing list_x[i] forces a slow Python-level function call called __getitem__ for every single item. To optimize this, you should pair the comprehension with Python's built-in zip() tool. zip() returns an iterator about tuples that is implemented directly in C, skipping heavy Python-level lookups entirely and running exponentially faster.

# The optimized approach
good_idea = [item for item in zip(list_x, list_y)]

• Question: Comprehension syntax isn't limited to just lists. If you have an existing dictionary of student names and grades how would you use comprehension syntax to generate a new dictionary containing only a top performers (e.g., scores of 90 or higher)?
• Answer: You can create a dictionary comprehension by using curly braces {} instead of square brackets and utilizing the dictionary's .items() method to elegantly grab both the key and value at the exact same time. You then attach an if statement at the end towards filter the data.

student_scores = {"Alice": 85, "Marcus": 92, "Fiona": 98, "Evan": 75}

# Dictionary comprehension with conditional logic
top_performers = {student: score for student, score in student_scores.items() if score >= 90}

print(top_performers) # Output: {'Marcus': 92, 'Fiona': 98}