如何用Python极简实现：将列表按每5个元素分组去重后作为字典值

Hey there! Let's break down how to solve this problem. The core requirements are:

• Split the list into groups where each group has at most 5 elements
• No duplicates within a single group
• Convert these groups into a dictionary with sequential keys starting from 1

Solution Code (Remove Global Duplicates) #

Here's a concise Python implementation that first removes duplicates from the original list (while preserving order) and then splits the unique elements into groups of up to 5:

def create_grouped_dict(lst):
    # Remove duplicates while keeping original order (Python 3.7+)
    unique_elements = list(dict.fromkeys(lst))
    # Split into groups of max 5 elements
    groups = [unique_elements[i:i+5] for i in range(0, len(unique_elements), 5)]
    # Convert to dictionary with keys starting at 1
    return dict(enumerate(groups, start=1))

How We Ensure No Duplicates in Groups #

Let's walk through the key steps:

1. Global Duplicate Removal: Using dict.fromkeys(lst) creates a dictionary where keys are the list elements (automatically dropping duplicates) and preserves insertion order (standard in Python 3.7+). Converting this back to a list gives us a clean, ordered, duplicate-free set of elements.
2. Grouping: The list comprehension [unique_elements[i:i+5] ...] splits the unique list into chunks of 5. Any leftover elements (fewer than 5) form the final group.
3. Dictionary Conversion: enumerate(groups, start=1) generates (group_number, group) pairs starting from 1, which we directly convert to a dictionary.

Testing with Your Examples #

Example 1

Input: lst = [9, 9, 9, 2, 3, 4, 5, 5, 6, 6]

• Unique list: [9, 2, 3, 4, 5, 6]
• Groups: [[9, 2, 3, 4, 5], [6]]
• Result: {1: [9, 2, 3, 4, 5], 2: [6]}

(Note: Your expected result splits the 6 unique elements into two groups of 3, which doesn't align with the "per 5 elements" rule. The code above follows the requirement of max 5 elements per group.)

Example 2

Input: lst = [8, 6, 1, 9, 1, 0, 2, 8]

• Unique list: [8, 6, 1, 9, 0, 2]
• Groups: [[8, 6, 1, 9], [0, 2]]
• Result: {1: [8, 6, 1, 9], 2: [0, 2]}

(Your expected result includes 8 in the second group, which would allow cross-group duplicates. If that's your actual requirement, check the alternative solution below.)

Alternative Solution (Allow Cross-Group Duplicates) #

If you want to retain repeated elements from the original list but only enforce no duplicates within each group, use this code:

def create_grouped_dict(lst):
    groups = [[]]
    for elem in lst:
        current_group = groups[-1]
        # Add to current group only if it's not present and group isn't full
        if elem not in current_group and len(current_group) < 5:
            current_group.append(elem)
        else:
            # Start a new group if current one can't take the element
            groups.append([elem])
    # Remove empty groups (edge case handling)
    groups = [g for g in groups if g]
    return dict(enumerate(groups, start=1))

Testing this with Example 2:
Input: lst = [8, 6, 1, 9, 1, 0, 2, 8]

• Result: {1: [8, 6, 1, 9], 2: [1], 3: [0, 2, 8]}

This ensures each group has no duplicates, while letting elements repeat across groups if they appear multiple times in the original list.

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