5 Best Ways to Return a Description for Given Data Type Codes in Python

Rate this post

πŸ’‘ Problem Formulation: When programming in Python, one often needs to identify or confirm the data type of a variable. The problem tackled in this article is how to return a description for given data type code, which involves detecting the data type of a variable and then generating a readable description for it. For example, given the input 123, the desired output would be “int: Represents integers”.

Method 1: Using the type() Function

The type() function in Python returns the data type of a given object, which is the class type of the variable. This method can help users understand the type of variable they are working with in a program.

Here’s an example:

my_var = {'apple': 1, 'banana': 2}
print(type(my_var).__name__ + ': Represents ' + str(type(my_var).__doc__))


dict: Represents dictionaries

This code snippet initializes a dictionary and then uses the type() function to obtain its type. By accessing the __name__ attribute, we get just the type’s name, and __doc__ gives us a built-in description of the data type.

Method 2: Using the isinstance() Function with Descriptions

The isinstance() function checks if an object is an instance of a specific class or a subclass thereof. We can use it to manually check the type and return custom descriptions.

Here’s an example:

def describe_type(obj):
    if isinstance(obj, int):
        return 'int: Represents integers'
    elif isinstance(obj, float):
        return 'float: Represents floating-point numbers'
    elif isinstance(obj, str):
        return 'str: Represents strings'
    elif isinstance(obj, list):
        return 'list: Represents lists'
        return 'Unknown type'



float: Represents floating-point numbers

This function describe_type() uses a series of if-else statements to manually check the type of the passed object and returns a description accordingly.

Method 3: Using the types Module

The types module in Python contains many type names that can be used to check the type of variables. It’s useful for distinguishing between common variable types.

Here’s an example:

import types

def type_description(variable):
    if isinstance(variable, types.BuiltinFunctionType):
        return "Built-in function"
    if isinstance(variable, types.FunctionType):
        return "User-defined function"
    # Add more checks as necessary
    return "Unknown type"



Built-in function

The code defines a function type_description() which uses the types module to compare the variable’s type and return a string describing it.

Method 4: Creating a Custom Class with a Descriptive __str__() Method

A custom class can override the __str__() method to provide a human-readable description of the data type. This approach is particularly useful when you are working with custom data types and you want to provide specific descriptions.

Here’s an example:

class MyInt(int):
    def __str__(self):
        return 'Custom Int: Represents enhanced integers'

custom_int = MyInt(5)


Custom Int: Represents enhanced integers

This code defines a class MyInt that inherits from int. The __str__() method is overridden to return a custom description. When an instance of this class is printed, it displays the custom description.

Bonus One-Liner Method 5: Using getattr() with Type Objects

We can use the getattr() function with type objects to get a property or method. This can be used to fetch the __doc__ attribute for a quick type description.

Here’s an example:

print(getattr(int, '__doc__'))


int(x=0) -> integer
int(x, base=10) -> integer
Convert a number or string to an integer, or return 0 if no arguments are given...

The getattr() function is used to access the __doc__ attribute of the int type, which contains a description of the integer type in Python.


  • Method 1: type() Function. Easy to use. Provides the type name and the official description. However, it’s not customizable.
  • Method 2: isinstance() Function with Descriptions. Allows custom descriptions. Useful for specific type checks. It requires manual updates for new types.
  • Method 3: Using the types Module. More precise than Method 2 for certain types like functions. Not comprehensive for all data types.
  • Method 4: Custom Class with Descriptive __str__(). Highly customizable. Ideal for user-defined types. Overkill for simple built-in types.
  • Method 5: getattr() with Type Objects. Quick one-liner for accessing the type description. Limited to retrieving what’s already defined in the type’s __doc__.