Python Inner Classes - Complete Guide with Examples

What You'll Learn Here

What are inner classes — classes defined inside other classes
Why use them — grouping related classes, encapsulation
Types of inner classes — simple nested, static inner classes
Accessing outer class — how inner classes can access outer class members
Real-world use — practical examples you can use

What are Inner Classes?

An inner class (also called a nested class) is a class defined inside another class. It's a way to group related classes together and keep your code organized.

Think of it like a drawer inside a desk. The desk is the outer class, and the drawer is the inner class. The drawer belongs to the desk and has access to the desk's contents. But from outside, you access the drawer through the desk.

Inner classes are useful when:

You have a class that's only used by another class
You want to keep related classes close together
You want to encapsulate helper classes
You want to logically group classes that belong together

💡 Key concept: Inner classes are defined within the scope of another class. They help organize code and can access the outer class's members.

Why Use Inner Classes?

The Benefits of Inner Classes

Inner classes aren't just a fancy feature — they have real benefits that can make your code cleaner and more maintainable.

# Why Use Inner Classes?

print("=" * 50)
print("WHY USE INNER CLASSES?")
print("=" * 50)

# ============================================================
# WITHOUT INNER CLASSES — Separate Top-Level Classes
# ============================================================

print("\n WITHOUT INNER CLASSES:")

class Node:
    """A node in a linked list"""
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    """A linked list"""
    def __init__(self):
        self.head = None
    
    def add(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node
    
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

# Node class is at the top level — anyone can use it
print("   Problem: Node class is globally accessible")
print("   Problem: Node class is separated from LinkedList")
print("   Problem: Namespace pollution")


# ============================================================
# WITH INNER CLASSES — Grouped Together
# ============================================================

print("\n WITH INNER CLASSES:")

class LinkedListWithInner:
    """A linked list with an inner Node class"""
    
    class Node:
        """Inner class — only used by LinkedList"""
        def __init__(self, data):
            self.data = data
            self.next = None
    
    def __init__(self):
        self.head = None
    
    def add(self, data):
        new_node = self.Node(data)  # Use the inner class
        new_node.next = self.head
        self.head = new_node
    
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

# Node is now INSIDE LinkedList — organized
linked_list = LinkedListWithInner()
linked_list.add(3)
linked_list.add(2)
linked_list.add(1)
linked_list.display()

print("\n Benefits of Inner Classes:")
print("  1. Organization: Node belongs INSIDE LinkedList")
print("  2. Encapsulation: Node is hidden from external use")
print("  3. Readability: Related code is grouped together")
print("  4. Namespace: No global pollution (Node is not at top level)")


# ============================================================
# BENEFITS SUMMARIZED
# ============================================================

print("\n" + "-" * 30)
print("BENEFITS OF INNER CLASSES")
print("-" * 30)
print("""
┌─────────────────────┬────────────────────────────────────────────┐
│ BENEFIT             │ EXPLANATION                               │
├─────────────────────┼────────────────────────────────────────────┤
│ Organization        │ Group related classes together            │
│ Encapsulation       │ Hide implementation details               │
│ Code readability    │ Clearer structure and intent              │
│ Namespace           │ Avoid global namespace pollution          │
│ Logical grouping    │ Classes that belong together stay together│
│ Access to outer     │ Inner classes can access outer members    │
└─────────────────────┴────────────────────────────────────────────┘
""")

Benefits of inner classes:

Organization — keep related classes together
Encapsulation — hide helper classes from external use
Readability — clearer code structure
Namespace — avoid global pollution
Access — inner classes can access outer class members

Quick Check: What's the main benefit of using an inner class? (Answer: It groups related classes together and hides implementation details)

Types of Inner Classes

Simple Inner Classes and Static Inner Classes

In Python, there are two main types of inner classes:

Simple Inner Class — defined inside an outer class, can access outer class instance members
Static Inner Class — defined inside an outer class but doesn't need access to outer instance

The main difference is whether the inner class needs access to the outer class's instance data.

# Types of Inner Classes

print("=" * 50)
print("TYPES OF INNER CLASSES")
print("=" * 50)

# ============================================================
# TYPE 1: SIMPLE INNER CLASS
# ============================================================

print("\n1. SIMPLE INNER CLASS")

class University:
    """Outer class — university"""
    
    def __init__(self, name):
        self.name = name
        self._departments = []
    
    def add_department(self, dept_name):
        """Add a department"""
        dept = self.Department(dept_name, self)
        self._departments.append(dept)
        return dept
    
    def get_departments(self):
        return [dept.name for dept in self._departments]
    
    class Department:
        """Inner class — department belongs to university"""
        
        def __init__(self, name, university):
            self.name = name
            self._university = university  # Reference to outer
            self._courses = []
        
        def add_course(self, course_name):
            self._courses.append(course_name)
        
        def get_courses(self):
            return self._courses
        
        def get_university_name(self):
            """Access outer class through reference"""
            return self._university.name

# Using simple inner class
uni = University("MIT")
dept = uni.add_department("Computer Science")
dept.add_course("Python Programming")
dept.add_course("Data Structures")

print(f"   University: {uni.name}")
print(f"   Departments: {uni.get_departments()}")
print(f"   Courses in CS: {dept.get_courses()}")
print(f"   From inner class: {dept.get_university_name()}")


# ============================================================
# TYPE 2: STATIC INNER CLASS (doesn't need outer instance)
# ============================================================

print("\n2. STATIC INNER CLASS")

class Geometry:
    """Outer class — geometry utilities"""
    
    # Static inner class — doesn't need outer instance
    class Point:
        """A 2D point — independent of Geometry instance"""
        
        def __init__(self, x, y):
            self.x = x
            self.y = y
        
        def distance(self, other):
            import math
            return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
        
        def __repr__(self):
            return f"Point({self.x}, {self.y})"
    
    class Rectangle:
        """A rectangle — independent of Geometry instance"""
        
        def __init__(self, x, y, width, height):
            self.x = x
            self.y = y
            self.width = width
            self.height = height
        
        def area(self):
            return self.width * self.height
        
        def perimeter(self):
            return 2 * (self.width + self.height)

# Using static inner classes — no outer instance needed
p1 = Geometry.Point(0, 0)
p2 = Geometry.Point(3, 4)
rect = Geometry.Rectangle(0, 0, 5, 3)

print(f"   Point 1: {p1}")
print(f"   Point 2: {p2}")
print(f"   Distance: {p1.distance(p2):.2f}")
print(f"   Rectangle area: {rect.area()}")
print(f"   Rectangle perimeter: {rect.perimeter()}")


# ============================================================
# COMPARISON
# ============================================================

print("\n" + "-" * 30)
print("COMPARISON")
print("-" * 30)
print("""
┌──────────────────────┬───────────────────┬──────────────────────────────┐
│ FEATURE              │ SIMPLE INNER      │ STATIC INNER                 │
├──────────────────────┼───────────────────┼──────────────────────────────┤
│ Needs outer instance │ Usually yes       │ No                           │
│ Access to outer      │ Through reference │ No direct access             │
│ Creation             │ Via outer method  │ Directly instantiated        │
│ Use case             │ Helper tied to    │ Utility that groups          │
│                      │ outer instance    │ related functionality        │
│ Example              │ University.Department │ Geometry.Point           │
└──────────────────────┴───────────────────┴──────────────────────────────┘
""")

Types of inner classes:

Simple Inner Class — needs access to outer class instance, created through outer class
Static Inner Class — independent of outer instance, created directly
Simple inner — used when the inner class needs to know about its outer container
Static inner — used for grouping utilities that don't need outer context

Quick Check: What's the difference between a simple inner class and a static inner class? (Answer: A simple inner class needs a reference to the outer instance; a static inner class doesn't)

Accessing Outer Class Members

How Inner Classes Access the Outer Class

One of the key features of inner classes is that they can access the outer class's members. But there's a catch — they need a reference to the outer class instance.

Unlike languages like Java, Python doesn't automatically give inner classes access to the outer instance. You need to pass the outer instance to the inner class explicitly.

# Accessing Outer Class Members

print("=" * 50)
print("ACCESSING OUTER CLASS MEMBERS")
print("=" * 50)

class Car:
    """Outer class — car"""
    
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self._mileage = 0
        self._engine = self.Engine()  # Inner class instance
    
    def drive(self, miles):
        self._mileage += miles
        return f"Drove {miles} miles. Total: {self._mileage}"
    
    def get_engine_status(self):
        return self._engine.get_status()
    
    def get_car_info(self):
        return f"{self.year} {self.make} {self.model}"
    
    class Engine:
        """Inner class — engine belongs to a car"""
        
        def __init__(self):
            self._is_running = False
            self._temperature = 20  # Celsius
        
        def start(self):
            self._is_running = True
            self._temperature = 40
            return "Engine started"
        
        def stop(self):
            self._is_running = False
            self._temperature = 20
            return "Engine stopped"
        
        def get_status(self):
            return f"Running: {self._is_running}, Temp: {self._temperature}°C"


# ============================================================
# EXAMPLE 2: INNER CLASS WITH OUTER REFERENCE
# ============================================================

print("\n1. SIMPLE INNER CLASS (Car.Engine)")

car = Car("Tesla", "Model 3", 2023)
print(f"   {car.get_car_info()}")
print(f"   {car.get_engine_status()}")
print(f"   {car._engine.start()}")
print(f"   {car.get_engine_status()}")
print(f"   {car.drive(50)}")

# The engine is only accessible through the car
# engine = Car.Engine()  # Would work but isn't connected to a car


# ============================================================
# EXAMPLE 3: INNER CLASS WITH OUTER REFERENCE (explicit)
# ============================================================

print("\n2. INNER CLASS WITH EXPLICIT OUTER REFERENCE")

class Employee:
    """Outer class — employee"""
    
    def __init__(self, name, department):
        self.name = name
        self.department = department
        self._projects = []
    
    def add_project(self, name, deadline):
        project = self.Project(name, deadline, self)
        self._projects.append(project)
        return project
    
    def get_projects(self):
        return [p.get_info() for p in self._projects]
    
    class Project:
        """Inner class — project belongs to an employee"""
        
        def __init__(self, name, deadline, employee):
            self.name = name
            self.deadline = deadline
            self._employee = employee  # Explicit reference to outer
            self.status = "pending"
        
        def complete(self):
            self.status = "completed"
            return f"Project '{self.name}' completed by {self._employee.name}"
        
        def get_info(self):
            return f"{self.name} (due: {self.deadline}) - {self.status}"

# Using the inner class
emp = Employee("Alice", "Engineering")
proj = emp.add_project("AI Model", "2024-12-31")

print(f"   Employee: {emp.name}, Dept: {emp.department}")
print(f"   Projects: {emp.get_projects()}")
print(f"   {proj.complete()}")
print(f"   Projects: {emp.get_projects()}")


# ============================================================
# ACCESS PATTERNS
# ============================================================

print("\n" + "-" * 30)
print("ACCESS PATTERNS")
print("-" * 30)

class Outer:
    class_variable = "I'm a class variable"
    
    def __init__(self, value):
        self.value = value
        self._inner = self.InnerWithRef(self)
    
    class InnerNoRef:
        """Inner class without outer reference"""
        def get_outer_value(self):
            # Can't access outer instance members
            return "No access to outer instance"
    
    class InnerWithRef:
        """Inner class with outer reference"""
        def __init__(self, outer):
            self._outer = outer
        
        def get_outer_value(self):
            return self._outer.value
        
        def get_outer_class_var(self):
            return Outer.class_variable

outer = Outer("hello")
no_ref = Outer.InnerNoRef()
with_ref = Outer.InnerWithRef(outer)

print(f"   InnerNoRef: {no_ref.get_outer_value()}")
print(f"   InnerWithRef (instance): {with_ref.get_outer_value()}")
print(f"   InnerWithRef (class var): {with_ref.get_outer_class_var()}")

Accessing outer class key points:

Explicit reference needed — inner class needs a reference to the outer instance
Pass outer instance — typically passed in the constructor
Access through reference — use self._outer.value to access outer data
Class variables — can be accessed directly through the outer class name

Quick Check: How does an inner class access an outer class's instance variables? (Answer: Through a reference to the outer instance passed to the inner class)

Real-World Example

Building a Document Editor

# Real-World Example: Document Editor

import uuid
from datetime import datetime

print("=" * 60)
print("DOCUMENT EDITOR — INNER CLASSES IN ACTION")
print("=" * 60)

class Document:
    """Document with inner classes for content and formatting"""
    
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.id = str(uuid.uuid4())[:8]
        self.created = datetime.now()
        self.modified = datetime.now()
        self._sections = []
        self._formatting = self.Formatting()
    
    def add_section(self, title):
        section = self.Section(title, self)
        self._sections.append(section)
        return section
    
    def add_paragraph(self, section_title, content):
        for section in self._sections:
            if section.title == section_title:
                return section.add_paragraph(content)
        return f"Section '{section_title}' not found"
    
    def get_sections(self):
        return [s.get_summary() for s in self._sections]
    
    def get_info(self):
        return {
            "id": self.id,
            "title": self.title,
            "author": self.author,
            "created": self.created.strftime("%Y-%m-%d %H:%M"),
            "modified": self.modified.strftime("%Y-%m-%d %H:%M"),
            "sections": len(self._sections)
        }
    
    class Section:
        """Inner class — section belongs to document"""
        
        def __init__(self, title, document):
            self.title = title
            self._document = document
            self._paragraphs = []
            self._formatting = document._formatting
        
        def add_paragraph(self, content, style="normal"):
            para = self.Paragraph(content, style, self)
            self._paragraphs.append(para)
            self._document.modified = datetime.now()
            return para
        
        def get_summary(self):
            return {
                "title": self.title,
                "paragraphs": len(self._paragraphs),
                "styles": [p.style for p in self._paragraphs]
            }
        
        class Paragraph:
            """Inner-inner class — paragraph belongs to section"""
            
            def __init__(self, content, style, section):
                self.content = content
                self.style = style
                self._section = section
                self._document = section._document
                self.id = str(uuid.uuid4())[:6]
            
            def get_text(self):
                if self.style == "bold":
                    return f"**{self.content}**"
                elif self.style == "italic":
                    return f"*{self.content}*"
                elif self.style == "heading":
                    return f"\n=== {self.content} ==="
                else:
                    return self.content
            
            def change_style(self, new_style):
                self.style = new_style
                self._document.modified = datetime.now()
                return f"Style changed to {new_style}"
    
    class Formatting:
        """Inner class — formatting settings for document"""
        
        def __init__(self):
            self.font = "Arial"
            self.font_size = 12
            self.line_spacing = 1.5
            self.margins = {"top": 1, "bottom": 1, "left": 1, "right": 1}
        
        def set_font(self, font):
            self.font = font
        
        def get_formatting(self):
            return {
                "font": self.font,
                "font_size": self.font_size,
                "line_spacing": self.line_spacing,
                "margins": self.margins
            }

# ============================================================
# DEMONSTRATION
# ============================================================

print("\n1. CREATING A DOCUMENT")
doc = Document("Python Tutorial", "Alice")

print(f"   Document: {doc.title} by {doc.author}")
print(f"   ID: {doc.id}")

print("\n2. ADDING SECTIONS")
section1 = doc.add_section("Introduction")
section2 = doc.add_section("Examples")

print(f"   Sections: {doc.get_sections()}")

print("\n3. ADDING PARAGRAPHS")
p1 = section1.add_paragraph("Python is a powerful language.", "normal")
p2 = section1.add_paragraph("It's great for beginners.", "bold")
p3 = section2.add_paragraph("Here are some examples.", "heading")
p4 = section2.add_paragraph("Example 1: Variables", "italic")

print(f"   Paragraph 1: {p1.get_text()}")
print(f"   Paragraph 2: {p2.get_text()}")
print(f"   Paragraph 3: {p3.get_text()}")
print(f"   Paragraph 4: {p4.get_text()}")

print("\n4. CHANGING STYLES")
print(f"   {p4.change_style('bold')}")
print(f"   Updated: {p4.get_text()}")

print("\n5. DOCUMENT INFO")
info = doc.get_info()
print(f"   {info}")

print("\n6. FORMATTING SETTINGS")
formatting = doc._formatting.get_formatting()
print(f"   {formatting}")

print("\n" + "=" * 60)
print("KEY TAKEAWAYS:")
print("=" * 60)
print("Inner classes organize related code")
print(" Document → Section → Paragraph hierarchy is clear")
print(" Inner classes can access outer members via references")
print(" Encapsulation: implementation details are hidden")
print(" This makes the code more maintainable and readable")

Real-world example key points:

Hierarchical structure — Document → Section → Paragraph
Inner classes — Section and Paragraph are defined inside Document
Access through references — each inner class has a reference to its parent
Encapsulation — formatting, sections, and paragraphs are hidden
Organization — related code is grouped together

Quick Check: What's the advantage of using inner classes in the document editor? (Answer: It creates a clear hierarchy and keeps related classes organized together)

Best Practices

Using Inner Classes Effectively

# Best Practices for Inner Classes

print("=" * 60)
print("BEST PRACTICES FOR INNER CLASSES")
print("=" * 60)

# ============================================================
# 1. USE INNER CLASSES FOR LOGICAL GROUPING
# ============================================================

print("\n1. USE INNER CLASSES FOR LOGICAL GROUPING")

#  DO: Use inner classes when the class is only used by the outer class
class Database:
    class Connection:
        def __init__(self):
            self.is_connected = False
        
        def connect(self):
            self.is_connected = True
    
    def get_connection(self):
        return self.Connection()

#  DON'T: Use inner classes for classes that are used widely
# class Utility:
#     class MathHelper:
#         # This should be a top-level class
#         pass


# ============================================================
# 2. USE STATIC INNER CLASSES WHEN APPROPRIATE
# ============================================================

print("\n2. USE STATIC INNER CLASSES WHEN APPROPRIATE")

class HTTP:
    """HTTP utilities with static inner classes"""
    
    class Request:
        def __init__(self, method, url):
            self.method = method
            self.url = url
        
        def send(self):
            return f"{self.method} {self.url}"
    
    class Response:
        def __init__(self, status, body):
            self.status = status
            self.body = body
        
        def get_info(self):
            return f"Status: {self.status}, Body: {self.body}"

#  DO: Use static inner for independent utilities
request = HTTP.Request("GET", "https://api.example.com")
response = HTTP.Response(200, "Success")
print(f"   Request: {request.send()}")
print(f"   Response: {response.get_info()}")


# ============================================================
# 3. PASS THE OUTER REFERENCE EXPLICITLY
# ============================================================

print("\n3. PASS THE OUTER REFERENCE EXPLICITLY")

class Order:
    def __init__(self, customer):
        self.customer = customer
        self._items = []
    
    def add_item(self, product, quantity):
        item = self.OrderItem(product, quantity, self)
        self._items.append(item)
        return item
    
    class OrderItem:
        def __init__(self, product, quantity, order):
            self.product = product
            self.quantity = quantity
            self._order = order  # Explicit reference
        
        def get_total(self, price):
            return self.quantity * price
        
        def get_order_customer(self):
            return self._order.customer

#  DO: Pass the outer reference explicitly
order = Order("Alice")
item = order.add_item("Laptop", 2)
print(f"   Customer: {item.get_order_customer()}")


# ============================================================
# 4. DON'T OVERUSE INNER CLASSES
# ============================================================

print("\n4. DON'T OVERUSE INNER CLASSES")

#  DON'T: Use inner classes for everything
class Everything:
    class A:
        pass
    class B:
        pass
    class C:
        pass
    # This makes the code hard to read and maintain

#  DO: Use inner classes only when they truly belong together
class PaymentProcessor:
    class Payment:
        pass
    class Refund:
        pass
    # These make sense together


# ============================================================
# 5. KEEP NAMING CLEAR
# ============================================================

print("\n5. KEEP NAMING CLEAR")

#  DO: Use clear, descriptive names
class Library:
    class Book:
        pass
    
    class Member:
        pass

#  DON'T: Use vague names
class Data:
    class Inner:
        pass
    class Another:
        pass


# ============================================================
# 6. SUMMARY
# ============================================================

print("\n" + "=" * 60)
print("INNER CLASSES BEST PRACTICES SUMMARY")
print("=" * 60)
print("""
┌─────────────────────────────┬─────────────────────────────────────────────┐
│ PRACTICE                    │ WHY IT MATTERS                             │
├─────────────────────────────┼─────────────────────────────────────────────┤
│ Use for logical grouping    │ Keep related code together                 │
│                             │                                             │
│ Use static inner for        │ Avoid unnecessary coupling                 │
│ independent utilities       │                                             │
│                             │                                             │
│ Pass outer reference        │ Inner class needs access to outer          │
│ explicitly                  │                                             │
│                             │                                             │
│ Don't overuse               │ Too many inner classes hurt readability    │
│                             │                                             │
│ Keep naming clear           │ Make the relationship obvious              │
│                             │                                             │
│ Use for encapsulation       │ Hide implementation details                │
└─────────────────────────────┴─────────────────────────────────────────────┘

 REMEMBER:
   • Inner classes help organize code
   • Use them when the class belongs INSIDE another class
   • Don't use them just for the sake of using them
   • Clear naming makes the relationship obvious
""")

Best practices summary:

Use for logical grouping — when the class is only used by the outer class
Use static inner when appropriate — for utilities that don't need outer instance
Pass outer reference explicitly — don't rely on magic
Don't overuse — too many inner classes hurt readability
Keep naming clear — make the relationship obvious
Use for encapsulation — hide implementation details

Quick Check: When should you use an inner class? (Answer: When the class is only used by the outer class and logically belongs inside it)

Try It Yourself

Experiment with inner classes in the editor below.

Loading Pyodide... 0%

Python Code Editor

# Python Inner Classes - Practice

print("=" * 50)
print("INNER CLASSES - PRACTICE")
print("=" * 50)

# ============================================================
# 1. SIMPLE INNER CLASS
# ============================================================

print("\n1. SIMPLE INNER CLASS")

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self._chapters = []
    
    def add_chapter(self, title, page_number):
        chapter = self.Chapter(title, page_number, self)
        self._chapters.append(chapter)
        return chapter
    
    def get_chapters(self):
        return [c.get_info() for c in self._chapters]
    
    class Chapter:
        def __init__(self, title, page_number, book):
            self.title = title
            self.page_number = page_number
            self._book = book
        
        def get_info(self):
            return f"Chapter {self.title} (starts on page {self.page_number})"
        
        def get_book_title(self):
            return self._book.title

book = Book("Python Programming", "John Smith")
ch1 = book.add_chapter("Introduction", 1)
ch2 = book.add_chapter("Variables", 25)

print(f"  Book: {book.title} by {book.author}")
print(f"  Chapters: {book.get_chapters()}")
print(f"  From inner: {ch1.get_book_title()}")

# ============================================================
# 2. STATIC INNER CLASS
# ============================================================

print("\n2. STATIC INNER CLASS")

class MathUtils:
    class Calculator:
        @staticmethod
        def add(a, b):
            return a + b
        
        @staticmethod
        def multiply(a, b):
            return a * b
    
    class Converter:
        @staticmethod
        def celsius_to_fahrenheit(c):
            return (c * 9/5) + 32
        
        @staticmethod
        def fahrenheit_to_celsius(f):
            return (f - 32) * 5/9

print(f"  Add: {MathUtils.Calculator.add(5, 3)}")
print(f"  Multiply: {MathUtils.Calculator.multiply(5, 3)}")
print(f"  25°C = {MathUtils.Converter.celsius_to_fahrenheit(25)}°F")

# ============================================================
# 3. NESTED INNER CLASSES
# ============================================================

print("\n3. NESTED INNER CLASSES")

class Company:
    def __init__(self, name):
        self.name = name
        self._departments = []
    
    def add_department(self, name):
        dept = self.Department(name, self)
        self._departments.append(dept)
        return dept
    
    class Department:
        def __init__(self, name, company):
            self.name = name
            self._company = company
            self._employees = []
        
        def add_employee(self, name, role):
            emp = self.Employee(name, role, self)
            self._employees.append(emp)
            return emp
        
        def get_employees(self):
            return [e.get_info() for e in self._employees]
        
        class Employee:
            def __init__(self, name, role, department):
                self.name = name
                self.role = role
                self._department = department
            
            def get_info(self):
                return f"{self.name} ({self.role})"
            
            def get_department_name(self):
                return self._department.name
            
            def get_company_name(self):
                return self._department._company.name

# Using nested inner classes
company = Company("TechCorp")
dept = company.add_department("Engineering")
emp = dept.add_employee("Alice", "Developer")

print(f"  Company: {company.name}")
print(f"  Department: {dept.name}")
print(f"  Employee: {emp.get_info()}")
print(f"  From inner: {emp.get_company_name()} - {emp.get_department_name()}")

# ============================================================
# 4. SUMMARY
# ============================================================

print("\n" + "=" * 50)
print("SUMMARY")
print("=" * 50)
print("""
INNER CLASSES — KEY CONCEPTS

1. Simple Inner Class: Needs outer reference, tied to outer instance
   Example: Book.Chapter

2. Static Inner Class: Independent of outer instance
   Example: MathUtils.Calculator

3. Nested Inner Classes: Inner classes inside inner classes
   Example: Company → Department → Employee

BENEFITS:
• Organization — group related code
• Encapsulation — hide implementation
• Readability — clear relationships

REMEMBER: Use inner classes when they truly belong together!
""")

==================================================
INNER CLASSES - PRACTICE
==================================================

1. SIMPLE INNER CLASS
Book: Python Programming by John Smith
Chapters: ['Chapter Introduction (starts on page 1)', 'Chapter Variables (starts on page 25)']
From inner: Python Programming

2. STATIC INNER CLASS
Add: 8
Multiply: 15
25°C = 77.0°F

3. NESTED INNER CLASSES
Company: TechCorp
Department: Engineering
Employee: Alice (Developer)
From inner: TechCorp - Engineering

🏆

You've Got It!

You now understand inner classes in Python. You know when to use them, how to create them, and how to access outer class members through references.

Quick Quiz

Test what you've learned:

1. What is an inner class in Python?

A) A class that inherits from another class B) A class defined inside another class C) A class with only static methods D) A class that can't be instantiated

2. What's the main benefit of using inner classes?

A) They run faster B) They group related classes together C) They use less memory D) They don't need to be imported

3. How does an inner class access the outer class's instance variables?

A) Automatically, like in Java B) Through a reference to the outer instance C) Through inheritance D) Inner classes can't access outer variables

4. What's a static inner class?

A) An inner class with only static methods B) An inner class that doesn't need the outer instance C) An inner class that can't be instantiated D) An inner class with no methods

5. When should you NOT use an inner class?

A) When the class is only used by the outer class B) When the class belongs logically inside the outer class C) When the class is used by many different parts of the code D) When you want to encapsulate a helper class

Frequently Asked Questions

What is an inner class in Python?

An inner class (or nested class) is a class defined inside another class. It's used to group related classes together and keep the code organized. Inner classes can access the outer class's members through a reference.

How does an inner class access the outer class?

Unlike Java, Python doesn't automatically give inner classes access to the outer instance. You need to pass a reference to the outer instance explicitly, typically through the inner class's constructor.

When should I use an inner class?

Use an inner class when the class is only used by the outer class and logically belongs inside it. Examples include helper classes, iterators, and classes that represent parts of the outer object (like a Book.Chapter).

What's the difference between an inner class and a static inner class?

A regular inner class is tied to an instance of the outer class and needs a reference to it. A static inner class (just a class defined inside another class) doesn't need an outer instance and can be instantiated directly. Static inner classes are used for grouping related utilities.

Can I have nested inner classes (inner classes inside inner classes)?

Yes, you can nest inner classes multiple levels deep. For example, Company → Department → Employee. However, going too deep can make the code hard to read and maintain. Use nesting sparingly.

Should I always use inner classes for helpers?

No. Only use inner classes when the helper is only used by the outer class and logically belongs inside it. If the helper is used by multiple classes, make it a top-level class. Overusing inner classes can make your code less maintainable.

Where to Go From Here

Now that you understand inner classes in Python, check out these related topics:

Previous: Polymorphism Next: OOPS Assignments →

Python

Python: Inner Classes

What are Inner Classes?

Why Use Inner Classes?

The Benefits of Inner Classes

Types of Inner Classes

Simple Inner Classes and Static Inner Classes

Accessing Outer Class Members

How Inner Classes Access the Outer Class

Real-World Example

Building a Document Editor

Best Practices

Using Inner Classes Effectively

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is an inner class in Python?

How does an inner class access the outer class?

When should I use an inner class?

What's the difference between an inner class and a static inner class?

Can I have nested inner classes (inner classes inside inner classes)?

Should I always use inner classes for helpers?

Where to Go From Here

Encapsulation

Classes and Objects

Inheritance

Python

Python: Inner Classes

What are Inner Classes?

Why Use Inner Classes?

The Benefits of Inner Classes

Types of Inner Classes

Simple Inner Classes and Static Inner Classes

Accessing Outer Class Members

How Inner Classes Access the Outer Class

Real-World Example

Building a Document Editor

Best Practices

Using Inner Classes Effectively

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is an inner class in Python? ▼

How does an inner class access the outer class? ▼

When should I use an inner class? ▼

What's the difference between an inner class and a static inner class? ▼

Can I have nested inner classes (inner classes inside inner classes)? ▼

Should I always use inner classes for helpers? ▼

Where to Go From Here

Encapsulation

Classes and Objects

Inheritance

What is an inner class in Python?

How does an inner class access the outer class?

When should I use an inner class?

What's the difference between an inner class and a static inner class?

Can I have nested inner classes (inner classes inside inner classes)?

Should I always use inner classes for helpers?