如何重排含三列表的元组为扁平列表并支持重复传入原函数处理？

Let's get your reorder function to output that flat one-dimensional list you want, and make sure it plays nicely with your dealList function for repeated processing. Here's how to do it step by step:

First, Fix the Existing Issues in Your Code #

Your current reorder has a couple of small problems blocking your goal:

• You’re calling dealList(list) inside the function, but you already receive the pre-processed sortedarrangement as an argument—no need to re-run dealList here.
• You’re using input() to get card_column, but the function is supposed to use the inputcolumn parameter passed to it.
• You’re returning a tuple of lists instead of a single flattened list.

Modified reorder Function #

Here's the updated code that fixes all these points and delivers exactly what you need:

def dealList(input_list):
    # Renamed parameter to avoid shadowing Python's built-in `list` type
    a, b, c = input_list[::3], input_list[1::3], input_list[2::3]
    # Take first 7 elements of each list
    a = a[:7]
    b = b[:7]
    c = c[:7]
    return (a, b, c)

def reorder(sortedarrangement, inputcolumn):
    # Unpack the tuple from dealList directly
    a, b, c = sortedarrangement
    
    # Choose the order based on inputcolumn and flatten into one list
    if inputcolumn == 1:
        flat_list = b + a + c
    elif inputcolumn == 2:
        flat_list = a + b + c
    elif inputcolumn == 3:
        flat_list = a + c + b
    else:
        # Default to original order if input is invalid
        flat_list = a + b + c
    
    return flat_list

How It Works #

1. Unpack the Tuple: We take the sortedarrangement tuple (from dealList) and split it into a, b, c just like you did before.
2. Concatenate Lists: Instead of creating a new tuple (b,a,c), we use the + operator to stitch the lists together into a single one-dimensional list.
3. Return the Flat List: This output is a regular list, so you can pass it straight back into dealList for repeated processing—perfect for your use case.

Test It with Your Example #

Let's use the sample output from dealList to verify:

# Sample tuple from your dealList example
sample_output = (['D6', 'HJ', 'H7', 'H9', 'H8', 'S10', 'C2'], 
                 ['D9', 'D3', 'DQ', 'S9', 'C6', 'C4', 'D7'], 
                 ['S4', 'CJ', 'H5', 'H3', 'C5', 'CQ', 'H6'])

# Call reorder with inputcolumn=1
result = reorder(sample_output, 1)
print(result)

This will output exactly the flat list you want:

['D9', 'D3', 'DQ', 'S9', 'C6', 'C4', 'D7', 'D6', 'HJ', 'H7', 'H9', 'H8', 'S10', 'C2', 'S4', 'CJ', 'H5', 'H3', 'C5', 'CQ', 'H6']

Bonus: More Flexible Version (Optional) #

If you might add more order options later, you can use a dictionary to map input values to list orders—it's cleaner and easier to extend:

def reorder(sortedarrangement, inputcolumn):
    a, b, c = sortedarrangement
    # Map inputcolumn values to list orders
    order_options = {
        1: [b, a, c],
        2: [a, b, c],
        3: [a, c, b]
    }
    # Get the selected order (default to original if input is invalid)
    selected_order = order_options.get(inputcolumn, [a, b, c])
    # Flatten the selected lists into one
    flat_list = []
    for lst in selected_order:
        flat_list.extend(lst)
    return flat_list

This version works the same way, but adding new order rules is just a matter of adding a new key-value pair to order_options.

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