Nested Comprehensions in Python0%

Advanced Structural Pattern Matching with Guards and Class Patterns

Nested Comprehensions in Python

Intermediate14 min read•Updated: 2026-10-01

Nested Comprehensions in Python

When engineering applications that handle tabular records, image pixel arrays, geographical coordinates, or hierarchical JSON datasets, you constantly work with nested data structures.

A Nested Comprehension is a comprehension contained inside another comprehension. It allows you to generate multi-dimensional grids, transpose matrices, and transform deeply nested dictionaries in declarative, high-speed Python.

Real-World Analogy: Indian Railways Multi-Tier Coach Seating Chart

Imagine the reservation chart for an Indian Railways 3-Tier AC coach (B1):

Visual Architecture Blueprint

+-------------------------------------------------------------------------+
|                  RAILWAY COACH BERTH MATRIX GENERATOR                   |
+-------------------------------------------------------------------------+
|                                                                         |
|  Outer Comprehension: [ Coach Compartments 1 to 8 ]                     |
|                               │                                         |
|                               ▼                                         |
|  Inner Comprehension:  [ Berths inside Compartment: Lower, Middle, Upper]|
|                               │                                         |
|                               ▼                                         |
|  Resulting 2D Structure:                                                |
|  [                                                                      |
|    ["Bay 1 - Lower", "Bay 1 - Middle", "Bay 1 - Upper"],                |
|    ["Bay 2 - Lower", "Bay 2 - Middle", "Bay 2 - Upper"],                |
|    ...                                                                  |
|  ]                                                                      |
+-------------------------------------------------------------------------+

Flattening: If the ticket collector wants a single flat scroll of all 72 passengers regardless of compartment, you use a multi-loop flattening comprehension.
Nested Preservation: If the display board on the platform needs to show bays row-by-row, you nest an inner comprehension inside an outer comprehension.

Critical Distinction: Flattening vs Preserving Structure

Developers often confuse two completely different syntax patterns:

Visual Architecture Blueprint

+------------------------------------+------------------------------------+
|  1. Flattening Comprehension       |  2. True Nested Comprehension      |
|     (Results in 1D flat list)      |     (Results in 2D nested list)    |
+------------------------------------+------------------------------------+
|  [val for row in grid for val in r]|  [[val for val in row] for row in g|
|                                    |                                    |
|  Output: [1, 2, 3, 4]              |  Output: [[1, 2], [3, 4]]          |
+------------------------------------+------------------------------------+

The Ordering Rule:

1
In Flattening ([x for sublist in list for x in sublist]):

The loops read left-to-right exactly like nested for statements: outer first, inner second.

1
In True Nested Comprehensions ([[expr for inner] for outer]):

The outer comprehension runs the outer loop, and its expression is an entire enclosed inner comprehension.

Comprehensive Code Examples

1. Generating a 2D Seating Grid

1# Generate a 4x3 seating grid for an executive conference hall in New Delhi
2# Rows: A, B, C, D | Seats: 1, 2, 3
3rows = ["Row-A", "Row-B", "Row-C", "Row-D"]
4seat_numbers = [1, 2, 3]
5 
6# Outer loop iterates over rows; inner loop creates the seat list for that row
7seating_grid = [
8    [f"{r}-Seat{s}" for s in seat_numbers]
9    for r in rows
10]
11 
12print("Conference Hall Seating Grid:")
13for row in seating_grid:
14    print(" ", row)

Expected Output:

1Conference Hall Seating Grid:
['Row-A-Seat1', 'Row-A-Seat2', 'Row-A-Seat3']
['Row-B-Seat1', 'Row-B-Seat2', 'Row-B-Seat3']
['Row-C-Seat1', 'Row-C-Seat2', 'Row-C-Seat3']
['Row-D-Seat1', 'Row-D-Seat2', 'Row-D-Seat3']

2. Matrix Transposition (Swapping Rows and Columns)

Transposing a matrix swaps rows into columns ($M_{ij} \to M_{ji}$). This is a fundamental operation in numerical computing and data analysis.

1# 3x4 Matrix: 3 students across 4 subjects
2# Rows: Students | Columns: [Math, Physics, Chem, CS]
3score_matrix = [
4    [85, 90, 78, 92],  # Student 1
5    [72, 68, 80, 75],  # Student 2
6    [95, 92, 88, 98]   # Student 3
7]
8 
9num_subjects = len(score_matrix[0])  # 4
10 
11# Transpose: Outer loop iterates across subject columns (0 to 3)
12# Inner loop collects scores from each student for that subject
13subject_grouped = [
14    [student_row[col_idx] for student_row in score_matrix]
15    for col_idx in range(num_subjects)
16]
17 
18print("Original (By Student):")
19for r in score_matrix:
20    print(" ", r)
21 
22print("\nTransposed (By Subject):")
23subject_names = ["Math", "Physics", "Chemistry", "Computer Science"]
24for subj, scores in zip(subject_names, subject_grouped):
25    print(f"  {subj:<18}: {scores}")

Expected Output:

1Original (By Student):
[85, 90, 78, 92]
[72, 68, 80, 75]
[95, 92, 88, 98]
5 
6Transposed (By Subject):
Math              : [85, 72, 95]
Physics           : [90, 68, 92]
Chemistry         : [78, 80, 88]
Computer Science  : [92, 75, 98]

3. Nested Dictionary Comprehensions

Hierarchical corporate structures often store departments, employees, and salaries. Nested dictionary comprehensions transform multi-tier mappings effortlessly:

1# Departmental Employee Salaries (in INR Lakhs per annum)
2company_payroll = {
3    "Engineering": {
4        "Amit": 18.5,
5        "Priya": 24.0,
6        "Rohan": 12.0
7    },
8    "Marketing": {
9        "Kavita": 14.0,
10        "Suresh": 9.5
11    },
12    "Human Resources": {
13        "Neha": 11.0,
14        "Vikram": 16.5
15    }
16}
17 
18# Apply a 10% appraisal bonus to employees earning below 15 LPA across all departments
19appraised_payroll = {
20    dept: {
21        emp: round(sal * 1.10, 2) if sal < 15.0 else sal
22        for emp, sal in employees.items()
23    }
24    for dept, employees in company_payroll.items()
25}
26 
27print("Appraised Payroll Structure:")
28for dept, emps in appraised_payroll.items():
29    print(f"  [{dept}]")
30    for emp, sal in emps.items():
31        original = company_payroll[dept][emp]
32        note = " (+10% Bonus!)" if sal > original else ""
33        print(f"    {emp:<10}: ₹{sal:.2f} LPA{note}")

Expected Output:

1Appraised Payroll Structure:
[Engineering]
  Amit      : ₹18.50 LPA
  Priya     : ₹24.00 LPA
  Rohan     : ₹13.20 LPA (+10% Bonus!)
[Marketing]
  Kavita    : ₹15.40 LPA (+10% Bonus!)
  Suresh    : ₹10.45 LPA (+10% Bonus!)
[Human Resources]
  Neha      : ₹12.10 LPA (+10% Bonus!)
  Vikram    : ₹16.50 LPA

4. Selective Multi-Condition Filtering in Nested Lists

1# Coordinate grid with obstacle avoidance
2# Filter grid to find all coordinate points (x, y) where x + y is even and x != y
3grid_points = [
4    (x, y)
5    for x in range(1, 4)
6    for y in range(1, 4)
7    if (x + y) % 2 == 0
8    if x != y
9]
10 
11print("Valid Waypoint Coordinates:", grid_points)

Expected Output:

1Valid Waypoint Coordinates: [(1, 3), (3, 1)]

The Readability Rule: When NOT to Nest Comprehensions

While Python allows arbitrary nesting, deeply nested comprehensions quickly become unreadable write-only code (often termed "comprehension pyramids").

Important Warning

[!CAUTION] The Two-Line Rule (PEP 8 Best Practice): If a nested comprehension spans more than 2 levels of loops or requires more than 3 lines of complex indentation, refactor it into standard helper functions with explicit for loops. Readability always counts more than terseness.

Best Practices & Comparison: Do's and Don'ts

Practice	Bad / Unreadable Pattern	Recommended Gold Standard
Grid Generation	`[[x for x in r] for r in [[y for y in z] for z in w]]` (3+ levels)	Max 2 levels; refactor deeper levels into generator functions
Transposition	Manual indexed nested loops with temporary arrays	`[[row[i] for row in matrix] for i in range(cols)]`
Flattening Syntax	Putting inner loop before outer loop (causes SyntaxError)	Order `for` loops left-to-right matching standard nested loop order
Formatting	Writing nested comprehensions on one giant 150-char line	Format across multiple indented lines for visual hierarchy

Quick Revision Summary Cheat Sheet

2D Grid Generation: [[f(x, y) for y in col_iter] for x in row_iter]
1D Flattening: [item for sublist in matrix for item in sublist]
Transposition: [[row[i] for row in matrix] for i in range(len(matrix[0]))]
Nested Dicts: {outer_k: {inner_k: expr for inner_k, v in inner_d.items()} for outer_k, inner_d in d.items()}
Evaluation Order: Outer comprehension controls outer dimensions; inner comprehension creates each row or nested value.

Practice Challenge

Scenario: Indian Railway Berth Allocation Matrix

In Indian Railways Sleeper coaches, each compartment bay contains 6 berths numbered across 3 tiers:

Lower Berth (LB): Seat numbers where n % 3 == 1
Middle Berth (MB): Seat numbers where n % 3 == 2
Upper Berth (UB): Seat numbers where n % 3 == 0

Given 3 consecutive bays with seat numbers 1 to 18:

1
Divide seats into 3 bays of 6 seats each using a nested comprehension:

Bay 1: Seats 1 to 6
Bay 2: Seats 7 to 12
Bay 3: Seats 13 to 18

1
For each seat number, attach its berth abbreviation ("LB", "MB", or "UB").
2
Print the final 2D coach layout showing each bay row-by-row.

Starter Code

1# Total 3 bays, 6 berths per bay
2total_bays = 3
3berths_per_bay = 6
4 
5# TODO: Construct 2D layout using nested comprehension

Complete Solution

1total_bays = 3
2berths_per_bay = 6
3 
4def get_berth_type(seat_no):
5    rem = seat_no % 3
6    if rem == 1:
7        return "LB"
8    elif rem == 2:
9        return "MB"
10    else:
11        return "UB"
12 
13# Nested comprehension: Outer loop builds bays; inner loop builds labeled berths for that bay
14coach_bays = [
15    [
16        f"Seat {seat_no:02d} ({get_berth_type(seat_no)})"
17        for seat_no in range(bay_idx * berths_per_bay + 1, (bay_idx + 1) * berths_per_bay + 1)
18    ]
19    for bay_idx in range(total_bays)
20]
21 
22print("=== IRCTC Sleeper Coach Berth Layout ===")
23for bay_num, bay_seats in enumerate(coach_bays, start=1):
24    print(f"\n[BAY {bay_num}]")
25    for seat in bay_seats:
26        print(f"  {seat}")

Expected Output

1=== IRCTC Sleeper Coach Berth Layout ===
2 
3[BAY 1]
Seat 01 (LB)
Seat 02 (MB)
Seat 03 (UB)
Seat 04 (LB)
Seat 05 (MB)
Seat 06 (UB)
10 
11[BAY 2]
Seat 07 (LB)
Seat 08 (MB)
Seat 09 (UB)
Seat 10 (LB)
Seat 11 (MB)
Seat 12 (UB)
18 
19[BAY 3]
Seat 13 (LB)
Seat 14 (MB)
Seat 15 (UB)
Seat 16 (LB)
Seat 17 (MB)
Seat 18 (UB)

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What is the difference between [x for row in matrix for x in row] and [[x for x in row] for row in matrix]?

Question 2

What will the following expression evaluate to?

PythonCode Snippet

matrix = [[1, 2], [3, 4]]

transposed = [[row[i] for row in matrix] for i in range(2)]

print(transposed)

Question 3

Given matrix = [[10, 20], [30, 40], [50, 60]], what is the order of execution for [val for row in matrix for val in row]?

Question 4

What is the primary software engineering concern with deeply nested comprehensions (3 or more levels)?

Question 5

What does the following nested dictionary comprehension output?

PythonCode Snippet

grades = {

"Batch-A": {"Aman": 85, "Pooja": 92},

"Batch-B": {"Rohan": 65, "Kavita": 45}

}

passed = {

b: {name: sc for name, sc in students.items() if sc >= 50}

for b, students in grades.items()

}

print(len(passed["Batch-B"]))

🚀 What's Next?

In the next lesson, we will continue your intermediate Python journey with Project: Data Filtering with Comprehensions (1: Advanced Data Types & Comprehensions).

👉 Continue to Next Lesson: Project: Data Filtering with Comprehensions →

Next Lesson

Advanced Structural Pattern Matching with Guards and Class Patterns

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Dictionary Comprehensions	Advanced Structural Pattern Matching with Guards and Class Patterns

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Advanced Structural Pattern Matching with Guards and Class Patterns

Nested Comprehensions in Python

Intermediate14 min read•Updated: 2026-10-01

Study Materials Cheatsheet

Nested Comprehensions in Python

When engineering applications that handle tabular records, image pixel arrays, geographical coordinates, or hierarchical JSON datasets, you constantly work with nested data structures.

Real-World Analogy: Indian Railways Multi-Tier Coach Seating Chart

Imagine the reservation chart for an Indian Railways 3-Tier AC coach (B1):

Visual Architecture Blueprint

+-------------------------------------------------------------------------+
|                  RAILWAY COACH BERTH MATRIX GENERATOR                   |
+-------------------------------------------------------------------------+
|                                                                         |
|  Outer Comprehension: [ Coach Compartments 1 to 8 ]                     |
|                               │                                         |
|                               ▼                                         |
|  Inner Comprehension:  [ Berths inside Compartment: Lower, Middle, Upper]|
|                               │                                         |
|                               ▼                                         |
|  Resulting 2D Structure:                                                |
|  [                                                                      |
|    ["Bay 1 - Lower", "Bay 1 - Middle", "Bay 1 - Upper"],                |
|    ["Bay 2 - Lower", "Bay 2 - Middle", "Bay 2 - Upper"],                |
|    ...                                                                  |
|  ]                                                                      |
+-------------------------------------------------------------------------+

Flattening: If the ticket collector wants a single flat scroll of all 72 passengers regardless of compartment, you use a multi-loop flattening comprehension.
Nested Preservation: If the display board on the platform needs to show bays row-by-row, you nest an inner comprehension inside an outer comprehension.

Critical Distinction: Flattening vs Preserving Structure

Developers often confuse two completely different syntax patterns:

Visual Architecture Blueprint

+------------------------------------+------------------------------------+
|  1. Flattening Comprehension       |  2. True Nested Comprehension      |
|     (Results in 1D flat list)      |     (Results in 2D nested list)    |
+------------------------------------+------------------------------------+
|  [val for row in grid for val in r]|  [[val for val in row] for row in g|
|                                    |                                    |
|  Output: [1, 2, 3, 4]              |  Output: [[1, 2], [3, 4]]          |
+------------------------------------+------------------------------------+

The Ordering Rule:

1
In Flattening ([x for sublist in list for x in sublist]):

The loops read left-to-right exactly like nested for statements: outer first, inner second.

1
In True Nested Comprehensions ([[expr for inner] for outer]):

The outer comprehension runs the outer loop, and its expression is an entire enclosed inner comprehension.

Comprehensive Code Examples

1. Generating a 2D Seating Grid

1# Generate a 4x3 seating grid for an executive conference hall in New Delhi
2# Rows: A, B, C, D | Seats: 1, 2, 3
3rows = ["Row-A", "Row-B", "Row-C", "Row-D"]
4seat_numbers = [1, 2, 3]
5 
6# Outer loop iterates over rows; inner loop creates the seat list for that row
7seating_grid = [
8    [f"{r}-Seat{s}" for s in seat_numbers]
9    for r in rows
10]
11 
12print("Conference Hall Seating Grid:")
13for row in seating_grid:
14    print(" ", row)

Expected Output:

1Conference Hall Seating Grid:
['Row-A-Seat1', 'Row-A-Seat2', 'Row-A-Seat3']
['Row-B-Seat1', 'Row-B-Seat2', 'Row-B-Seat3']
['Row-C-Seat1', 'Row-C-Seat2', 'Row-C-Seat3']
['Row-D-Seat1', 'Row-D-Seat2', 'Row-D-Seat3']

2. Matrix Transposition (Swapping Rows and Columns)

Transposing a matrix swaps rows into columns ($M_{ij} \to M_{ji}$). This is a fundamental operation in numerical computing and data analysis.

1# 3x4 Matrix: 3 students across 4 subjects
2# Rows: Students | Columns: [Math, Physics, Chem, CS]
3score_matrix = [
4    [85, 90, 78, 92],  # Student 1
5    [72, 68, 80, 75],  # Student 2
6    [95, 92, 88, 98]   # Student 3
7]
8 
9num_subjects = len(score_matrix[0])  # 4
10 
11# Transpose: Outer loop iterates across subject columns (0 to 3)
12# Inner loop collects scores from each student for that subject
13subject_grouped = [
14    [student_row[col_idx] for student_row in score_matrix]
15    for col_idx in range(num_subjects)
16]
17 
18print("Original (By Student):")
19for r in score_matrix:
20    print(" ", r)
21 
22print("\nTransposed (By Subject):")
23subject_names = ["Math", "Physics", "Chemistry", "Computer Science"]
24for subj, scores in zip(subject_names, subject_grouped):
25    print(f"  {subj:<18}: {scores}")

Expected Output:

1Original (By Student):
[85, 90, 78, 92]
[72, 68, 80, 75]
[95, 92, 88, 98]
5 
6Transposed (By Subject):
Math              : [85, 72, 95]
Physics           : [90, 68, 92]
Chemistry         : [78, 80, 88]
Computer Science  : [92, 75, 98]

3. Nested Dictionary Comprehensions

Hierarchical corporate structures often store departments, employees, and salaries. Nested dictionary comprehensions transform multi-tier mappings effortlessly:

1# Departmental Employee Salaries (in INR Lakhs per annum)
2company_payroll = {
3    "Engineering": {
4        "Amit": 18.5,
5        "Priya": 24.0,
6        "Rohan": 12.0
7    },
8    "Marketing": {
9        "Kavita": 14.0,
10        "Suresh": 9.5
11    },
12    "Human Resources": {
13        "Neha": 11.0,
14        "Vikram": 16.5
15    }
16}
17 
18# Apply a 10% appraisal bonus to employees earning below 15 LPA across all departments
19appraised_payroll = {
20    dept: {
21        emp: round(sal * 1.10, 2) if sal < 15.0 else sal
22        for emp, sal in employees.items()
23    }
24    for dept, employees in company_payroll.items()
25}
26 
27print("Appraised Payroll Structure:")
28for dept, emps in appraised_payroll.items():
29    print(f"  [{dept}]")
30    for emp, sal in emps.items():
31        original = company_payroll[dept][emp]
32        note = " (+10% Bonus!)" if sal > original else ""
33        print(f"    {emp:<10}: ₹{sal:.2f} LPA{note}")

Expected Output:

1Appraised Payroll Structure:
[Engineering]
  Amit      : ₹18.50 LPA
  Priya     : ₹24.00 LPA
  Rohan     : ₹13.20 LPA (+10% Bonus!)
[Marketing]
  Kavita    : ₹15.40 LPA (+10% Bonus!)
  Suresh    : ₹10.45 LPA (+10% Bonus!)
[Human Resources]
  Neha      : ₹12.10 LPA (+10% Bonus!)
  Vikram    : ₹16.50 LPA

4. Selective Multi-Condition Filtering in Nested Lists

1# Coordinate grid with obstacle avoidance
2# Filter grid to find all coordinate points (x, y) where x + y is even and x != y
3grid_points = [
4    (x, y)
5    for x in range(1, 4)
6    for y in range(1, 4)
7    if (x + y) % 2 == 0
8    if x != y
9]
10 
11print("Valid Waypoint Coordinates:", grid_points)

Expected Output:

1Valid Waypoint Coordinates: [(1, 3), (3, 1)]

The Readability Rule: When NOT to Nest Comprehensions

While Python allows arbitrary nesting, deeply nested comprehensions quickly become unreadable write-only code (often termed "comprehension pyramids").

Important Warning

Best Practices & Comparison: Do's and Don'ts

Practice	Bad / Unreadable Pattern	Recommended Gold Standard
Grid Generation	`[[x for x in r] for r in [[y for y in z] for z in w]]` (3+ levels)	Max 2 levels; refactor deeper levels into generator functions
Transposition	Manual indexed nested loops with temporary arrays	`[[row[i] for row in matrix] for i in range(cols)]`
Flattening Syntax	Putting inner loop before outer loop (causes SyntaxError)	Order `for` loops left-to-right matching standard nested loop order
Formatting	Writing nested comprehensions on one giant 150-char line	Format across multiple indented lines for visual hierarchy

Quick Revision Summary Cheat Sheet

2D Grid Generation: [[f(x, y) for y in col_iter] for x in row_iter]
1D Flattening: [item for sublist in matrix for item in sublist]
Transposition: [[row[i] for row in matrix] for i in range(len(matrix[0]))]
Nested Dicts: {outer_k: {inner_k: expr for inner_k, v in inner_d.items()} for outer_k, inner_d in d.items()}
Evaluation Order: Outer comprehension controls outer dimensions; inner comprehension creates each row or nested value.

Practice Challenge

Scenario: Indian Railway Berth Allocation Matrix

In Indian Railways Sleeper coaches, each compartment bay contains 6 berths numbered across 3 tiers:

Lower Berth (LB): Seat numbers where n % 3 == 1
Middle Berth (MB): Seat numbers where n % 3 == 2
Upper Berth (UB): Seat numbers where n % 3 == 0

Given 3 consecutive bays with seat numbers 1 to 18:

1
Divide seats into 3 bays of 6 seats each using a nested comprehension:

Bay 1: Seats 1 to 6
Bay 2: Seats 7 to 12
Bay 3: Seats 13 to 18

1
For each seat number, attach its berth abbreviation ("LB", "MB", or "UB").
2
Print the final 2D coach layout showing each bay row-by-row.

Starter Code

1# Total 3 bays, 6 berths per bay
2total_bays = 3
3berths_per_bay = 6
4 
5# TODO: Construct 2D layout using nested comprehension

Complete Solution

1total_bays = 3
2berths_per_bay = 6
3 
4def get_berth_type(seat_no):
5    rem = seat_no % 3
6    if rem == 1:
7        return "LB"
8    elif rem == 2:
9        return "MB"
10    else:
11        return "UB"
12 
13# Nested comprehension: Outer loop builds bays; inner loop builds labeled berths for that bay
14coach_bays = [
15    [
16        f"Seat {seat_no:02d} ({get_berth_type(seat_no)})"
17        for seat_no in range(bay_idx * berths_per_bay + 1, (bay_idx + 1) * berths_per_bay + 1)
18    ]
19    for bay_idx in range(total_bays)
20]
21 
22print("=== IRCTC Sleeper Coach Berth Layout ===")
23for bay_num, bay_seats in enumerate(coach_bays, start=1):
24    print(f"\n[BAY {bay_num}]")
25    for seat in bay_seats:
26        print(f"  {seat}")

Expected Output

1=== IRCTC Sleeper Coach Berth Layout ===
2 
3[BAY 1]
Seat 01 (LB)
Seat 02 (MB)
Seat 03 (UB)
Seat 04 (LB)
Seat 05 (MB)
Seat 06 (UB)
10 
11[BAY 2]
Seat 07 (LB)
Seat 08 (MB)
Seat 09 (UB)
Seat 10 (LB)
Seat 11 (MB)
Seat 12 (UB)
18 
19[BAY 3]
Seat 13 (LB)
Seat 14 (MB)
Seat 15 (UB)
Seat 16 (LB)
Seat 17 (MB)
Seat 18 (UB)

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What is the difference between [x for row in matrix for x in row] and [[x for x in row] for row in matrix]?

Question 2

What will the following expression evaluate to?

PythonCode Snippet

matrix = [[1, 2], [3, 4]]

transposed = [[row[i] for row in matrix] for i in range(2)]

print(transposed)

Question 3

Given matrix = [[10, 20], [30, 40], [50, 60]], what is the order of execution for [val for row in matrix for val in row]?

Question 4

What is the primary software engineering concern with deeply nested comprehensions (3 or more levels)?

Question 5

What does the following nested dictionary comprehension output?

PythonCode Snippet

grades = {

"Batch-A": {"Aman": 85, "Pooja": 92},

"Batch-B": {"Rohan": 65, "Kavita": 45}

}

passed = {

b: {name: sc for name, sc in students.items() if sc >= 50}

for b, students in grades.items()

}

print(len(passed["Batch-B"]))

🚀 What's Next?

In the next lesson, we will continue your intermediate Python journey with Project: Data Filtering with Comprehensions (1: Advanced Data Types & Comprehensions).

👉 Continue to Next Lesson: Project: Data Filtering with Comprehensions →

Next Lesson

Advanced Structural Pattern Matching with Guards and Class Patterns

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Dictionary Comprehensions	Advanced Structural Pattern Matching with Guards and Class Patterns

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next