Check order specific data type in tuple in Python

When working with tuples containing mixed data types, you might need to verify that elements appear in a specific order with expected data types. Python's isinstance() method combined with chained conditions provides an effective way to validate tuple structure.

The isinstance() method checks if a given object belongs to a specific data type. Chained conditionals use the and operator to combine multiple conditions, ensuring all must be True for the overall result to be True.

Basic Example

Let's check if a tuple follows the pattern: string, list, integer ?

my_tuple = ('Hi', ['there', 'Will'], 67)

print("The tuple is:")
print(my_tuple)

my_result = (isinstance(my_tuple, tuple) and 
             isinstance(my_tuple[0], str) and 
             isinstance(my_tuple[1], list) and 
             isinstance(my_tuple[2], int))

print("Do all instances match the required data type in the same order?")
print(my_result)

The tuple is:
('Hi', ['there', 'Will'], 67)
Do all instances match the required data type in the same order?
True

Testing with Different Patterns

Here's how the validation works with different tuple structures ?

# Valid pattern: string, list, integer
valid_tuple = ('Hello', [1, 2, 3], 42)

# Invalid pattern: integer first instead of string  
invalid_tuple = (123, ['test'], 'world')

def check_pattern(tpl):
    return (isinstance(tpl, tuple) and 
            len(tpl) == 3 and
            isinstance(tpl[0], str) and 
            isinstance(tpl[1], list) and 
            isinstance(tpl[2], int))

print("Valid tuple:", valid_tuple)
print("Matches pattern:", check_pattern(valid_tuple))

print("\nInvalid tuple:", invalid_tuple)  
print("Matches pattern:", check_pattern(invalid_tuple))

Valid tuple: ('Hello', [1, 2, 3], 42)
Matches pattern: True

Invalid tuple: (123, ['test'], 'world')
Matches pattern: False

Multiple Pattern Validation

You can check multiple tuples against the same pattern using a loop ?

tuples_to_check = [
    ('Python', [1, 2], 100),      # Valid
    (42, ['hello'], 'world'),     # Invalid  
    ('Data', ['a', 'b'], 50),     # Valid
    ('Test', 'not_list', 25)      # Invalid
]

for i, tpl in enumerate(tuples_to_check):
    is_valid = (isinstance(tpl, tuple) and 
                len(tpl) == 3 and
                isinstance(tpl[0], str) and 
                isinstance(tpl[1], list) and 
                isinstance(tpl[2], int))
    
    print(f"Tuple {i+1}: {tpl}")
    print(f"Valid pattern: {is_valid}\n")

Tuple 1: ('Python', [1, 2], 100)
Valid pattern: True

Tuple 2: (42, ['hello'], 'world')
Valid pattern: False

Tuple 3: ('Data', ['a', 'b'], 50)
Valid pattern: True

Tuple 4: ('Test', 'not_list', 25)
Valid pattern: False

How It Works

The validation process checks each condition sequentially:

• isinstance(my_tuple, tuple) − Confirms the object is a tuple
• isinstance(my_tuple[0], str) − Checks first element is a string
• isinstance(my_tuple[1], list) − Checks second element is a list
• isinstance(my_tuple[2], int) − Checks third element is an integer

All conditions must be True for the overall result to be True. If any condition fails, the entire expression returns False.

Conclusion

Using isinstance() with chained conditions provides a clean way to validate tuple structure and data types. This approach ensures data integrity when working with structured tuples in your Python applications.