上下文无关文法简化软件：循环内字典特定元素删除问题

It looks like you're running into common pitfalls when modifying dictionaries and lists while iterating over them—those counter-based loops get messy fast, especially when elements are being deleted! Let's break down the issues with your current code and fix it with a cleaner, more Pythonic approach that aligns with your three rules.

First, Let's Clarify Your Rules (to make sure we're on the same page) #

From your description and code comments, you want to:

• Keep any production (string or list) where all symbols are in V1 (the set of symbols that derive terminals).
• Delete a string production if it's not in V1; if it's the only production for a non-terminal, remove the entire key-value pair.
• Delete a list production if any symbol in it is not in V1; if it's the only production for a non-terminal, remove the entire key-value pair.

What's Wrong With Your Current Code? #

1. Modifying collections while iterating: Trying to delete elements from derivations or its lists while looping through them can lead to index errors or skipped items (since the length changes mid-loop).
2. Counter logic: Your nested counters don't adjust when elements are deleted, so you might end up checking invalid indices or missing elements.
3. In-place deletion complexity: Handling both key-value deletions and list element deletions in the same loop makes the code hard to follow and debug.

A Cleaner, Pythonic Solution #

Instead of trying to delete elements in-place, we'll filter each non-terminal's productions to keep only the valid ones, then update the dictionary (or remove the key if no valid productions remain). Here's how:

Step 1: Helper Function to Check Valid Productions

First, let's make a helper function to determine if a production should be kept:

def is_production_valid(production, V1):
    if isinstance(production, str):
        # For strings: keep if it's in V1
        return production in V1
    elif isinstance(production, list):
        # For lists: keep only if ALL symbols are in V1
        return all(symbol in V1 for symbol in production)
    else:
        # Handle unexpected types (optional: raise an error if needed)
        return False

Step 2: Process the Dictionary Safely

We'll iterate over a copy of the dictionary's keys (so we can modify the original dict without issues), filter the valid productions for each key, and update or delete the entry:

# Iterate over a copy of the keys to avoid issues when modifying the dict
for non_terminal in list(derivations.keys()):
    all_productions = derivations[non_terminal]
    # Filter to keep only valid productions
    valid_productions = [prod for prod in all_productions if is_production_valid(prod, V1)]
    
    if valid_productions:
        # Update the entry with only valid productions
        derivations[non_terminal] = valid_productions
    else:
        # No valid productions left? Delete the entire key-value pair
        del derivations[non_terminal]

How This Aligns With Your Rules #

• Rule 1: Valid productions (strings in V1, lists with all symbols in V1) are kept in valid_productions.
• Rule 2: Invalid string productions are excluded from valid_productions; if they were the only ones, the key is deleted.
• Rule 3: Invalid list productions (with any symbol not in V1) are excluded; if they were the only ones, the key is deleted.

Why This Works Better #

• No counter mess: List comprehensions handle filtering cleanly without manual index tracking.
• Safe modification: By iterating over a copy of the keys, we avoid runtime errors from changing the dictionary size mid-loop.
• Readability: The logic is explicit—anyone reading the code can see exactly what's being kept and why.

If you need to adjust the logic (e.g., maybe you want to keep a list production even if some symbols are in V1?), let me know, but this should match your stated rules perfectly.

内容的提问来源于stack exchange，提问作者Raul Junior