How to check type python

How to check type of variable (object) in Python

Table of Contents

Python is not a typed language. What that means is that objects are identified by what they can do rather than what they are. In this tutorial we will learn how to check and print type of variable in Python

Python data are objects

Different inbuilt object types in python

Check type of variable in Python

In Python you can use type() and isinstance() to check and print the type of a variable. We will cover both these functions in detail with examples:

type() function

class type (object)

In this python script type(var) is checking if the value of var is of type integer

Output:

Similarly to check if variable is list type

Output:

Or another method to check type of variable using type()

Output:

To print the variable type we can just call print with type() function

Output:

class type(name, bases, dict)

In this example we create a class and print individual properties:

Output:

Now we can achieve the same and define a class using type(name, bases, dict) function

Output:

isinstance() function

Syntax:

Output returns boolean value:

Similarly in if condition

Output:

isinstance() can accept a tuple of types if you want to check that an object’s type is among those present in the tuple:

Note the second parenthesis, surrounding two value types we pass in. This parenthesis represents a tuple, one of the data structures. Output :

type() vs isinstance()

Both type() and isinstance() function can be used to check and print the type of a variable but the isinstance() built-in function is recommended for testing the type of an object, because it also takes subclasses into account.

Moreover with isinstance() you can also get boolean return value as True or False which can be used as decision making

Conclusion

In this tutorial we learned to check and print the type of a variable in python. We have type() and isinstance() function where both can be used to check variable type where both have their own benefits so you can choose one depending upon your requirement

Lastly I hope this tutorial to learn more about type() and isinstance() function to print type of a variable using Python was helpful. So, let me know your suggestions and feedback using the comment section.

References

Related Posts

Didn’t find what you were looking for? Perform a quick search across GoLinuxCloud

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

For any other feedbacks or questions you can either use the comments section or contact me form.

Thank You for your support!!

How to determine a Python variable’s type?

How do I see the type of a variable? (e.g. unsigned 32 bit)

19 Answers 19

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Use the type() builtin function:

To check if a variable is of a given type, use isinstance :

Note that Python doesn’t have the same types as C/C++, which appears to be your question.

You may be looking for the type() built-in function.

See the examples below, but there’s no «unsigned» type in Python just like Java.

Large positive integer:

Literal sequence of characters:

Floating point integer:

It is so simple. You do it like this.

How to determine the variable type in Python?

So if you have a variable, for example:

You want to know its type?

There are right ways and wrong ways to do just about everything in Python. Here’s the right way:

Use type

Don’t use __class__

In Python, names that start with underscores are semantically not a part of the public API, and it’s a best practice for users to avoid using them. (Except when absolutely necessary.)

Since type gives us the class of the object, we should avoid getting this directly. :

Don’t. Instead, do type(self):

Implementation details of ints and floats

How do I see the type of a variable whether it is unsigned 32 bit, signed 16 bit, etc.?

In Python, these specifics are implementation details. So, in general, we don’t usually worry about this in Python. However, to sate your curiosity.

In Python 2, int is usually a signed integer equal to the implementation’s word width (limited by the system). It’s usually implemented as a long in C. When integers get bigger than this, we usually convert them to Python longs (with unlimited precision, not to be confused with C longs).

For example, in a 32 bit Python 2, we can deduce that int is a signed 32 bit integer:

In Python 3, the old int goes away, and we just use (Python’s) long as int, which has unlimited precision.

We can also get some information about Python’s floats, which are usually implemented as a double in C:

Conclusion

And don’t worry too much about the implementation details of Python. I’ve not had to deal with issues around this myself. You probably won’t either, and if you really do, you should know enough not to be looking to this answer for what to do.

I also highly recommend the IPython interactive interpreter when dealing with questions like this. It lets you type variable_name? and will return a whole list of information about the object including the type and the doc string for the type.

Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string. If the argument is outside the integer range a long object will be returned instead.

One more way using __class__ :

Examples of simple type checking in Python:

It may be little irrelevant. but you can check types of an object with isinstance(object, type) as mentioned here.

This is also reflected in the array module, which can make arrays of these lower-level types:

The maximum integer supported (Python 2’s int ) is given by sys.maxint.

There is also sys.getsizeof, which returns the actual size of the Python object in residual memory:

For float data and precision data, use sys.float_info:

Do you mean in Python or using ctypes?

In the second case, you can use type() :

For more reference on ctypes, an its type, see the official documentation.

Simple, for python 3.4 and above

Python 2.7 and above

It really depends on what level you mean. In Python 2.x, there are two integer types, int (constrained to sys.maxint ) and long (unlimited precision), for historical reasons. In Python code, this shouldn’t make a bit of difference because the interpreter automatically converts to long when a number is too large. If you want to know about the actual data types used in the underlying interpreter, that’s implementation dependent. (CPython’s are located in Objects/intobject.c and Objects/longobject.c.) To find out about the systems types look at cdleary answer for using the struct module.

For python2.x, use

For python3.x, use

You should use the type() function. Like so:

This function will view the type of any variable, whether it’s a list or a class. Check this website for more information: https://www.w3schools.com/python/ref_func_type.asp

Python is a dynamically typed language. A variable, initially created as a string, can be later reassigned to an integer or a float. And the interpreter won’t complain:

To check the type of a variable, you can use either type() or isinstance() built-in function. Let’s see them in action:

Let’s compare both methods performances in python3

type is 40% slower approximately (54.5/39.2 = 1.390).

We could use type(variable) == str instead. It would work, but it’s a bad idea:

Difference between isinstance and type

Speed is not the only difference between these two functions. There is actually an important distinction between how they work:

What does it mean in practice? Let’s say we want to have a custom class that acts as a list but has some additional methods. So we might subclass the list type and add custom functions inside:

But now the type and isinstance return different results if we compare this new class to a list!

We get different results because isinstance checks if my_list is an instance of the list (it’s not) or a subclass of the list (it is because MyAwesomeList is a subclass of the list). If you forget about this difference, it can lead to some subtle bugs in your code.

Conclusions

isinstance is usually the preferred way to compare types. It’s not only faster but also considers inheritance, which is often the desired behavior. In Python, you usually want to check if a given object behaves like a string or a list, not necessarily if it’s exactly a string. So instead of checking for string and all its custom subclasses, you can just use isinstance.

What’s the canonical way to check for type in Python?

How do I check if an object is of a given type, or if it inherits from a given type?

14 Answers 14

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Use isinstance to check if o is an instance of str or any subclass of str :

Another alternative to the above:

See Built-in Functions in the Python Library Reference for relevant information.

Checking for strings in Python 2

For Python 2, this is a better way to check if o is a string:

Alternatively, isinstance accepts a tuple of classes. This will return True if o is an instance of any subclass of any of (str, unicode) :

The most Pythonic way to check the type of an object is. not to check it.

Of course, sometimes these nice abstractions break down and isinstance(obj, cls) is what you need. But use sparingly.

After the question was asked and answered, type hints were added to Python. Type hints in Python allow types to be checked but in a very different way from statically typed languages. Type hints in Python associate the expected types of arguments with functions as runtime accessible data associated with functions and this allows for types to be checked. Example of type hint syntax:

One of these other programs that can be used to find the type error is mypy :

(You might need to install mypy from your package manager. I don’t think it comes with CPython but seems to have some level of «officialness».)

The upside of explicit type checking is that it can catch errors earlier and give clearer error messages than duck typing. The exact requirements of a duck type can only be expressed with external documentation (hopefully it’s thorough and accurate) and errors from incompatible types can occur far from where they originate.

Python’s type hints are meant to offer a compromise where types can be specified and checked but there is no additional cost during usual code execution.

The typing package offers type variables that can be used in type hints to express needed behaviors without requiring particular types. For example, it includes variables such as Iterable and Callable for hints to specify the need for any type with those behaviors.

While type hints are the most Pythonic way to check types, it’s often even more Pythonic to not check types at all and rely on duck typing. Type hints are relatively new and the jury is still out on when they’re the most Pythonic solution. A relatively uncontroversial but very general comparison: Type hints provide a form of documentation that can be enforced, allow code to generate earlier and easier to understand errors, can catch errors that duck typing can’t, and can be checked statically (in an unusual sense but it’s still outside of runtime). On the other hand, duck typing has been the Pythonic way for a long time, doesn’t impose the cognitive overhead of static typing, is less verbose, and will accept all viable types and then some.

How to Check Type of Variable in Python

In this tutorial, we’ll learn about getting and testing the type of variables by using two different ways, and finally, we’ll know the difference between these two ways.

Contents

1. Checking Variable Type With Type() built-in function

what is type()

type() is a python built function that returns the type of objects

syntax

Example 1: Getting the type of variable

As you can see, in the above code we have many different variables,
now let’s get the type of these variables.

If you want to know all types of objects in python, you’ll find it in the final part of the article.

Example 2: checking if the type of variable is a string

let’s say that you want to test or check if a variable is a string, see the code bellow

As you can see, the code works very well, but this is not the best way to do that.
Remember!, if you want to check the type of variable, you should use isinstance() built function.

2. Checking Variable Type With isinstance() built-in function

what is isinstance()

The isinstance() is a built-in function that check the type of object and return True or False

sytnax

example 1: checking variables type

example 2: Doing something after checking variable type

3. When you should use isinstance() and type()

if you want to get type of object use type() function.

if you want to check type of object use isinstance() function

4. Data Types in Python

Related posts

How to put variable in regex pattern in Python

Python: Add Variable to String & Print Using 4 Methods

Python: for x in variable

Python: How to get the type of a variable

How to Properly Check if a Variable is Not Null in Python

Determine the type of an object?

Is there a simple way to determine if a variable is a list, dictionary, or something else?

15 Answers 15

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

There are two built-in functions that help you identify the type of an object. You can use type() if you need the exact type of an object, and isinstance() to check an object’s type against something. Usually, you want to use isinstance() most of the times since it is very robust and also supports type inheritance.

To get the actual type of an object, you use the built-in type() function. Passing an object as the only parameter will return the type object of that object:

This of course also works for custom types:

Note that type() will only return the immediate type of the object, but won’t be able to tell you about type inheritance.

To cover that, you should use the isinstance function. This of course also works for built-in types:

The second parameter of isinstance() also accepts a tuple of types, so it’s possible to check for multiple types at once. isinstance will then return true, if the object is of any of those types: