Python Indentation Error Fix Beginner Debugging Code Utilities

These ready-to-use Python code utilities implement essential python indentation error fix beginner debugging tips through practical scripts and functions. Copy these tools to quickly diagnose and resolve indentation issues in your projects.

Indentation Analysis Tools #

Basic Indentation Detector #

🐍 Try it yourself

def analyze_indentation(code_string):
    """Analyze indentation patterns in Python code string."""
    lines = code_string.split('\n')
    analysis = []
    
    for i, line in enumerate(lines, 1):
        if line.strip():  # Skip empty lines
            leading_space = len(line) - len(line.lstrip())
            # Check for tabs
            has_tabs = '\t' in line[:leading_space]
            # Count spaces and tabs separately
            spaces = line[:leading_space].count(' ')
            tabs = line[:leading_space].count('\t')
            
            analysis.append({
                'line': i,
                'total_indent': leading_space,
                'spaces': spaces,
                'tabs': tabs,
                'mixed': spaces > 0 and tabs > 0,
                'content': line.strip()[:50] + '...' if len(line.strip()) > 50 else line.strip()
            })
    
    return analysis

# Example usage
sample_code = '''def example():
    print("4 spaces")
	print("1 tab character")
    if True:
        print("8 spaces")
	    print("tab + 4 spaces")
'''

analysis = analyze_indentation(sample_code)
for item in analysis:
    print(f"Line {item['line']}: {item['total_indent']} chars "
          f"({item['spaces']} spaces, {item['tabs']} tabs) "
          f"{'[MIXED!]' if item['mixed'] else ''}")

Output:

Click "Run Code" to see the output

Advanced Indentation Validator #

🐍 Try it yourself

def validate_python_indentation(code_string):
    """Comprehensive indentation validation for Python code."""
    lines = code_string.split('\n')
    errors = []
    indentation_stack = [0]  # Track expected indentation levels
    
    for i, line in enumerate(lines, 1):
        stripped = line.strip()
        if not stripped or stripped.startswith('#'):
            continue  # Skip empty lines and comments
        
        current_indent = len(line) - len(line.lstrip())
        
        # Check for mixed tabs and spaces
        leading = line[:current_indent]
        if '\t' in leading and ' ' in leading:
            errors.append(f"Line {i}: Mixed tabs and spaces")
        
        # Check if line should be indented (ends with colon)
        prev_line_idx = i - 2
        while prev_line_idx >= 0 and not lines[prev_line_idx].strip():
            prev_line_idx -= 1
        
        if prev_line_idx >= 0:
            prev_line = lines[prev_line_idx].strip()
            if prev_line.endswith(':'):
                expected_indent = indentation_stack[-1] + 4
                if current_indent <= indentation_stack[-1]:
                    errors.append(f"Line {i}: Expected indentation after colon")
                else:
                    indentation_stack.append(current_indent)
            elif current_indent < indentation_stack[-1]:
                # Unindenting - check if it matches a previous level
                while len(indentation_stack) > 1 and indentation_stack[-1] > current_indent:
                    indentation_stack.pop()
                if current_indent != indentation_stack[-1]:
                    errors.append(f"Line {i}: Unindent doesn't match any outer level")
        
        # Check for proper 4-space increments
        if current_indent > 0 and current_indent % 4 != 0:
            errors.append(f"Line {i}: Indentation should be multiple of 4 spaces")
    
    return errors

# Test the validator
test_code = '''def test_function():
print("Missing proper indentation")
    if True:
        print("Correct indentation")
      print("Wrong unindent level")
    print("Back to correct level")
'''

errors = validate_python_indentation(test_code)
if errors:
    print("Indentation errors found:")
    for error in errors:
        print(f"  {error}")
else:
    print("No indentation errors detected!")

Output:

Click "Run Code" to see the output

Automatic Fixing Utilities #

Tab to Space Converter #

🐍 Try it yourself

def convert_tabs_to_spaces(code_string, tab_size=4):
    """Convert all tabs to spaces in Python code."""
    lines = code_string.split('\n')
    converted_lines = []
    
    for line in lines:
        # Calculate proper indentation
        stripped = line.lstrip()
        if not stripped:
            converted_lines.append('')
            continue
        
        # Count leading tabs and spaces
        leading = line[:len(line) - len(stripped)]
        
        # Convert tabs to equivalent spaces
        spaces_count = 0
        for char in leading:
            if char == '\t':
                # Tab moves to next tab stop
                spaces_count += tab_size - (spaces_count % tab_size)
            else:
                spaces_count += 1
        
        converted_line = ' ' * spaces_count + stripped
        converted_lines.append(converted_line)
    
    return '\n'.join(converted_lines)

# Example usage
mixed_code = """def example():
\tprint("This line has a tab")
    print("This line has 4 spaces")
\t    print("Tab + 4 spaces")
    if True:
\t\tprint("Two tabs")
"""

print("Original code (with tabs):")
print(repr(mixed_code))
print("\nConverted code (spaces only):")
converted = convert_tabs_to_spaces(mixed_code)
print(repr(converted))
print("\nReadable version:")
print(converted)

Output:

Click "Run Code" to see the output

Smart Indentation Fixer #

🐍 Try it yourself

def fix_indentation_errors(code_string):
    """Automatically fix common indentation errors."""
    lines = code_string.split('\n')
    fixed_lines = []
    expected_indent = 0
    
    for i, line in enumerate(lines):
        stripped = line.strip()
        
        # Skip empty lines and comments
        if not stripped or stripped.startswith('#'):
            fixed_lines.append(line)
            continue
        
        # Check if previous line ended with colon
        if i > 0:
            prev_line = lines[i-1].strip()
            if prev_line.endswith(':'):
                expected_indent += 4
        
        # Check for dedenting keywords
        dedent_keywords = ['except', 'elif', 'else', 'finally']
        if any(stripped.startswith(keyword) for keyword in dedent_keywords):
            expected_indent = max(0, expected_indent - 4)
        
        # Check for function/class/if/for/while/try definitions
        if any(stripped.startswith(keyword) for keyword in 
               ['def ', 'class ', 'if ', 'for ', 'while ', 'try:', 'with ']):
            # These should be at current expected level
            pass
        elif stripped.startswith(('return', 'break', 'continue', 'pass')):
            # These might indicate end of a block
            if i < len(lines) - 1:
                next_line = lines[i+1].strip()
                if next_line and not next_line.startswith('#'):
                    # Check if next line is dedented
                    next_indent = len(lines[i+1]) - len(lines[i+1].lstrip())
                    if next_indent < expected_indent:
                        expected_indent = next_indent
        
        # Apply the expected indentation
        fixed_line = ' ' * expected_indent + stripped
        fixed_lines.append(fixed_line)
    
    return '\n'.join(fixed_lines)

# Example usage
broken_code = """def example():
print("Wrong indentation")
if True:
print("Should be indented")
for i in range(3):
print(f"Item {i}")
else:
print("This too")
print("Back to function level")
"""

print("Broken code:")
print(broken_code)
print("\nFixed code:")
fixed = fix_indentation_errors(broken_code)
print(fixed)

Output:

Click "Run Code" to see the output

Debugging Helper Functions #

Indentation Visualizer #

🐍 Try it yourself

def visualize_indentation(code_string, show_spaces=True, show_tabs=True):
    """Create a visual representation of indentation."""
    lines = code_string.split('\n')
    visualized = []
    
    for i, line in enumerate(lines, 1):
        if not line.strip():
            visualized.append(f"{i:2d}: (empty line)")
            continue
        
        leading = line[:len(line) - len(line.lstrip())]
        visual_indent = ""
        
        for char in leading:
            if char == ' ' and show_spaces:
                visual_indent += "·"  # Middle dot for space
            elif char == '\t' and show_tabs:
                visual_indent += "→"  # Arrow for tab
            else:
                visual_indent += char
        
        content = line.lstrip()
        visualized.append(f"{i:2d}: {visual_indent}|{content}")
    
    return '\n'.join(visualized)

# Example usage
sample_code = """def example():
    print("4 spaces")
\tprint("1 tab")
    if True:
        print("8 spaces")
\t    print("tab + 4 spaces")
"""

print("Indentation visualization:")
print("(· = space, → = tab, | = start of code)")
print(visualize_indentation(sample_code))

Output:

Click "Run Code" to see the output

Indentation Statistics #

🐍 Try it yourself

def get_indentation_stats(code_string):
    """Generate comprehensive indentation statistics."""
    lines = code_string.split('\n')
    stats = {
        'total_lines': len(lines),
        'code_lines': 0,
        'max_indent': 0,
        'indent_levels': set(),
        'uses_tabs': False,
        'uses_spaces': False,
        'mixed_lines': 0,
        'inconsistent_levels': []
    }
    
    for i, line in enumerate(lines, 1):
        if line.strip():
            stats['code_lines'] += 1
            leading = line[:len(line) - len(line.lstrip())]
            indent_level = len(leading)
            
            stats['max_indent'] = max(stats['max_indent'], indent_level)
            stats['indent_levels'].add(indent_level)
            
            if '\t' in leading:
                stats['uses_tabs'] = True
            if ' ' in leading:
                stats['uses_spaces'] = True
            if '\t' in leading and ' ' in leading:
                stats['mixed_lines'] += 1
            
            # Check for non-4-space increments
            if indent_level > 0 and indent_level % 4 != 0:
                stats['inconsistent_levels'].append(i)
    
    stats['indent_levels'] = sorted(list(stats['indent_levels']))
    return stats

# Example usage
test_code = """def function():
    print("4 spaces")
      print("6 spaces - inconsistent!")
\tprint("Tab character")
    if True:
        print("8 spaces")
\t    print("Mixed tab and spaces")
"""

stats = get_indentation_stats(test_code)
print("Indentation Statistics:")
print(f"  Total lines: {stats['total_lines']}")
print(f"  Code lines: {stats['code_lines']}")
print(f"  Maximum indent: {stats['max_indent']} characters")
print(f"  Indent levels used: {stats['indent_levels']}")
print(f"  Uses tabs: {stats['uses_tabs']}")
print(f"  Uses spaces: {stats['uses_spaces']}")
print(f"  Lines with mixed tabs/spaces: {stats['mixed_lines']}")
print(f"  Lines with non-4-space indents: {stats['inconsistent_levels']}")

Output:

Click "Run Code" to see the output

File Processing Utilities #

Batch File Indentation Checker #

🐍 Try it yourself

import os

def check_file_indentation(file_content, filename=""):
    """Check indentation in a file and return detailed report."""
    errors = []
    warnings = []
    
    lines = file_content.split('\n')
    
    for i, line in enumerate(lines, 1):
        if not line.strip():
            continue
        
        leading = line[:len(line) - len(line.lstrip())]
        
        # Check for tabs
        if '\t' in leading:
            if ' ' in leading:
                errors.append(f"Line {i}: Mixed tabs and spaces")
            else:
                warnings.append(f"Line {i}: Uses tabs (recommend spaces)")
        
        # Check for non-4-space indentation
        indent_level = len(leading)
        if indent_level > 0 and indent_level % 4 != 0:
            warnings.append(f"Line {i}: {indent_level} spaces (not multiple of 4)")
    
    return {
        'filename': filename,
        'errors': errors,
        'warnings': warnings,
        'clean': len(errors) == 0 and len(warnings) == 0
    }

# Example usage with sample file content
sample_file = '''def main():
    print("Hello world")
      print("6 spaces - warning")
\tprint("Tab character - warning")
    if True:
        print("Proper 8-space indentation")
\t    print("Mixed tab and spaces - error")
'''

report = check_file_indentation(sample_file, "example.py")

print(f"Indentation Report for {report['filename']}:")
print(f"Status: {'✓ Clean' if report['clean'] else '✗ Issues found'}")

if report['errors']:
    print("\nErrors (must fix):")
    for error in report['errors']:
        print(f"  ✗ {error}")

if report['warnings']:
    print("\nWarnings (recommended fixes):")
    for warning in report['warnings']:
        print(f"  ⚠ {warning}")

Output:

Click "Run Code" to see the output

Quick Fix Generator #

🐍 Try it yourself

def generate_quick_fixes(code_string):
    """Generate quick fix suggestions for indentation problems."""
    lines = code_string.split('\n')
    fixes = []
    
    for i, line in enumerate(lines, 1):
        if not line.strip():
            continue
        
        leading = line[:len(line) - len(line.lstrip())]
        
        # Check for mixed tabs and spaces
        if '\t' in leading and ' ' in leading:
            fixed_line = line.expandtabs(4)  # Convert tabs to 4 spaces
            fixes.append({
                'line': i,
                'type': 'mixed_indentation',
                'original': repr(line),
                'fixed': repr(fixed_line),
                'description': 'Convert tabs to spaces'
            })
        
        # Check for tab-only lines
        elif '\t' in leading:
            fixed_line = line.expandtabs(4)
            fixes.append({
                'line': i,
                'type': 'tab_usage',
                'original': repr(line),
                'fixed': repr(fixed_line),
                'description': 'Replace tabs with 4 spaces'
            })
        
        # Check for non-4-space indentation
        elif len(leading) > 0 and len(leading) % 4 != 0:
            # Round to nearest 4-space boundary
            target_indent = round(len(leading) / 4) * 4
            fixed_line = ' ' * target_indent + line.lstrip()
            fixes.append({
                'line': i,
                'type': 'irregular_spacing',
                'original': repr(line),
                'fixed': repr(fixed_line),
                'description': f'Adjust to {target_indent} spaces'
            })
    
    return fixes

# Example usage
problematic_code = """def example():
  print("2 spaces")
    print("6 spaces")
\tprint("tab character")
\t  print("tab + 2 spaces")
      print("8 spaces but irregular")
"""

fixes = generate_quick_fixes(problematic_code)

print("Quick Fix Suggestions:")
for fix in fixes:
    print(f"\nLine {fix['line']} - {fix['description']}:")
    print(f"  Original: {fix['original']}")
    print(f"  Fixed:    {fix['fixed']}")

Output:

Click "Run Code" to see the output

Summary #

These Python indentation error fix beginner debugging utilities provide:

Analysis tools to detect and visualize indentation issues
Automatic converters for tabs to spaces transformation
Validation functions to check Python code compliance
Quick fix generators with specific repair suggestions
Statistics gatherers for comprehensive indentation reporting

Copy these utilities into your development toolkit to quickly diagnose and resolve indentation problems. They implement proven python indentation error fix beginner debugging tips through practical, reusable code.

For comprehensive learning about indentation best practices, see our Python Indentation Q&A.

PyGuide

PyGuide

Python Indentation Error Fix Beginner Debugging Code Utilities

Python Indentation Error Fix Beginner Debugging Code Utilities

Indentation Analysis Tools #

Basic Indentation Detector #

🐍 Try it yourself

Advanced Indentation Validator #

🐍 Try it yourself

Automatic Fixing Utilities #

Tab to Space Converter #

🐍 Try it yourself

Smart Indentation Fixer #

🐍 Try it yourself

Debugging Helper Functions #

Indentation Visualizer #

🐍 Try it yourself

Indentation Statistics #

🐍 Try it yourself

File Processing Utilities #

Batch File Indentation Checker #

🐍 Try it yourself

Quick Fix Generator #

🐍 Try it yourself

Summary #

Related Snippets

Python For Loop Counter Code Examples

Python Enumerate Start at 1: Code Examples and Snippets

Python For Loop Break: Ready-to-Use Code Examples

Python For Loop with Counter: Ready-to-Use Code Examples