How to Check the Type of Variables in Python

Let’s find out how to check the type of variables using Python’s built-in functions and some other ways with full code examples. You will be able to use these methods to determine which type a variable belongs to. However, the choice of method depends on your specific needs.

Find out How to Check the Type of Variables

Python is a dynamically typed language, which means that the type of a variable is not defined when it is declared, but rather when it is assigned a value. This can make it difficult to track the types of variables in your code, especially in large and complex programs.

There are two built-in functions in Python that can be used to check the type of a variable:

• type(): This function detects the type object of the given variable and returns.
• isinstance(): This function returns True if the variable type matches the type of the instance passed to it, and False otherwise.

Here are Two Built-in Python Functions for Type-checking

About the type() call

The first technique is the type() call that takes a single argument, i.e., a variable whose type you want to check. It returns a type object, which identifies the type of the variable. This fulfills a number of use cases like the following:

• Checking the type of a variable in a conditional statement
• Checking the type of a variable before performing an operation
• Getting the type of a function parameter
• Getting the type of class attribute

About the isinstance() call

The second approach is the function isinstance() that allows you to check if the variable is an instance of a specific type or class. It yields True if the variable is a member of the specified type or class, and False otherwise. This is useful for a variety of tasks, such as:

• Checking the type of a function parameter
• Checking the type of a variable in a conditional statement
• Checking the type of a variable before performing an operation

The isinstance() function is also useful for implementing duck typing in Python. Duck typing is a programming paradigm that allows you to use an object based on its behavior, rather than its type.

Examples Using the isinstance() and type() with Full Code

The following are some examples of how the type() and isinstance() functions can be used to check the type of a variable in different contexts:

Example#1 Firstly, follow the most basic example where the code checks x and y for their types. The variable x is an integer whereas the variable y is a string.

Python code:

# Check the type of a variable
x = 10
print(type(x))

# Output: <class 'int'>

# Check if a variable is an instance of a specific type
y = "Hello"
print(isinstance(y, str))

# Output: True

Example#2 Secondly, the code creates a Python function that checks the type of its parameter by calling the ininstance() method.

Python code:

def my_function(parameter):
  if not isinstance(parameter, int):
    raise TypeError("Parameter must be an integer.")

  # Do something with the parameter

Example#3 Thirdly, our code used a Python if else condition block to identify the type of a variable.

Python code:

# Var type to check
my_var = 10

# Check if my_var is an int
if isinstance(my_var, int):
    print("The var my_var is of int type.")
else:
    print("The var my_var is not of int type.")

Example#4 In the fourth example, our code made use of the Python try-else block to capture and print the error if it comes while checking the variable type.

Python code:

x = 10
y = "Hello"

# Try to add x and y
try:
  sum = x + y
except TypeError:
  print("Cannot add an integer and a string.")

# Output: Cannot add an integer and a string.

Example#5 Here is an example of how to use isinstance() to implement duck typing. In order to learn, you must copy and paste this code into a Python IDE and see how it goes.

class Pet:
  def make_sound(self):
    pass

class Fido(Pet):
  def make_sound(self):
    print("Woof!")

class Whiskers(Pet):
  def make_sound(self):
    print("Meow!")

def make_pet_sound(pet):
  if isinstance(pet, Pet):
    pet.make_sound()
  else:
    raise TypeError("Object is not a pet.")

# Create a Fido and a Whiskers object
fido = Fido()
whiskers = Whiskers()

# Make the Fido and Whiskers object make a sound
make_pet_sound(fido)
make_pet_sound(whiskers)

# Output: Woof!
# Output: Meow!

Thetype() vs isinstance()

You might wonder when to use type() and when to use isinstance(). Here’s the difference:

• Use type() when you need to precisely determine the object’s specific data type. For example, to check if a variable is a list, you would use type(my_variable) == list.
• Use isinstance() when you need to verify whether an object belongs to a particular class or any of a group of classes in a tuple. It’s more flexible for checking inheritance and multiple types.

Using Some 3rd-party Libs for Advanced Type Checking

Sometimes, you may need more advanced type-checking in your program. For instance, checking if a variable is a certain data structure or if it has specific attributes. The 3rd-party libraries like typing, collections, and numpy can be helpful in these cases. Here’s an example using the typing module:

Python code:

from typing import List

my_var = [1, 2, 3]
if isinstance(my_var, List):
    print("my_var is a list")

These libraries provide additional tools for working with data types beyond the built-in functions.

Conclusion

The type() and isinstance() functions are powerful tools for checking the type of variables in Python. By using these functions, you can write more robust and reliable code.

However, Python offers several other ways to check the type of a variable such as by using 3rd-party libraries. Choose the method that best suits your specific use case. Also, always remember to check variable types to ensure your code functions as expected.

Happy Coding!