# 5 Best Ways to Test If Different Sized Data Types Are Not Subtypes of Each Other in Python

Rate this post

π‘ Problem Formulation: When working with Python, it’s not uncommon to encounter data types of varying sizes, such as `int32` versus `int64`. We sometimes need to assert whether these varying sizes indeed represent distinct types and not subtypes of one another. This article explores various methods to confirm that similar-looking data types with different sizes are actually distinct in Python, ensuring more robust code and type checking.

## Method 1: Using `type()` and Comparison

This method involves getting the type of each variable using the `type()` function and then comparing the types directly to see if they are the same. This will work for built-in types where different sizes still mean different types.

Here’s an example:

```a = 100
b = 10000000000
type_a = type(a)
type_b = type(b)
are_same_subtype = type_a == type_b
print(are_same_subtype)
```

Output:

`True`

This code snippet creates two integer variables of potentially different sizes, retrieves their types using the `type()` function, and compares those types directly. This approach is simple but effective when working with built-in types where size does not imply a subtype relationship.

## Method 2: Using the `isinstance()` Function

The `isinstance()` function is useful for checking if an object is an instance of a class or a subclass thereof. While similar data types of different sizes might be instances of a base class, they are not necessarily subtypes of each other.

Here’s an example:

```import numpy as np

array_int32 = np.array([1], dtype=np.int32)
array_int64 = np.array([1], dtype=np.int64)

is_subtype = isinstance(array_int32, np.int64)

print(is_subtype)
```

Output:

`False`

This snippet uses the NumPy library, which includes its own data types, to illustrate checking subtypes with the `isinstance()` function. The example shows that an `int32` array is not a subtype of an `int64` even though they are both integers.

## Method 3: Using `issubclass()`

This method relies on the `issubclass()` function to check if one type is a subclass of another. It’s especially useful when dealing with user-defined classes.

Here’s an example:

```class BaseClass:
pass

class DerivedClass(BaseClass):
pass

print(issubclass(DerivedClass, BaseClass))
print(issubclass(BaseClass, DerivedClass))
```

Output:

`True`
`False`

In this example, we defined a base class and a derived class. Using `issubclass()`, we can see that the derived class is a subclass of the base class, but not vice versa. Though this isn’t directly applicable to built-in data types, it demonstrates subtype relationships clearly.

## Method 4: Using Custom Comparison Functions

For more fine-tuned type checking, one can write custom comparison functions that can consider size or any other property that indicates distinct types.

Here’s an example:

```def are_same_type(obj1, obj2):
return isinstance(obj1, type(obj2)) and isinstance(obj2, type(obj1))

print(are_same_type(10, 10.0))
print(are_same_type(10, 10))
```

Output:

`False`
`True`

The custom function `are_same_type()` checks if two objects are instances of each other’s type. This example illustrates that an integer and a float are recognized as different types, despite both representing numbers.

## Bonus One-Liner Method 5: Using `np.issubdtype()` for NumPy Types

For users of NumPy, the library provides a convenient function `np.issubdtype()` that checks if one data type is a subtype of another within the NumPy type system.

Here’s an example:

```import numpy as np

print(np.issubdtype(np.int32, np.integer))
print(np.issubdtype(np.int32, np.int64))
```

Output:

`True`
`False`

This one-liner demonstrates using NumPy’s own subtype checking utility. While `np.int32` is a subtype of the general `np.integer` class, it is not a subtype of `np.int64`, despite both being integer types.

## Summary/Discussion

• Method 1: Type Comparison. Simple and direct. May not handle complex or custom data types well.
• Method 2: Using `isinstance()`. More accurate for subtype checking. Requires a class or type to check against.
• Method 3: Using `issubclass()`. Best suited for user-defined classes. Not applicable for built-in types without hierarchy.
• Method 4: Custom Comparison Functions. Highly adaptable. Requires additional implementation effort.
• Bonus Method 5: `np.issubdtype()`. Excellent for NumPy types. Specific to NumPy, not applicable outside this context.