How to determine a Python variable's type?

ID : 472

viewed : 518

Tags : pythontypesunsigned16-bitpython

Top 5 Answer for How to determine a Python variable's type?

vote vote


Use the type() builtin function:

>>> i = 123 >>> type(i) <type 'int'> >>> type(i) is int True >>> i = 123.456 >>> type(i) <type 'float'> >>> type(i) is float True 

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

>>> i = 123 >>> isinstance(i, int) True >>> isinstance(i, (float, str, set, dict)) False 

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

vote vote


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.

Positive integer:

>>> v = 10 >>> type(v) <type 'int'> 

Large positive integer:

>>> v = 100000000000000 >>> type(v) <type 'long'> 

Negative integer:

>>> v = -10 >>> type(v) <type 'int'> 

Literal sequence of characters:

>>> v = 'hi' >>> type(v) <type 'str'> 

Floating point integer:

>>> v = 3.14159 >>> type(v) <type 'float'> 
vote vote


It is so simple. You do it like this.

vote vote


How to determine the variable type in Python?

So if you have a variable, for example:

one = 1 

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

>>> type(one) <type 'int'> 

You can use the __name__ attribute to get the name of the object. (This is one of the few special attributes that you need to use the __dunder__ name to get to - there's not even a method for it in the inspect module.)

>>> type(one).__name__ 'int' 

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. :

>>> one.__class__ 

This is usually the first idea people have when accessing the type of an object in a method - they're already looking for attributes, so type seems weird. For example:

class Foo(object):     def foo(self):         self.__class__ 

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

class Foo(object):     def foo(self):         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:

>>> import sys  >>> format(sys.maxint, '032b') '01111111111111111111111111111111' >>> format(-sys.maxint - 1, '032b') # minimum value, see docs. '-10000000000000000000000000000000' 

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:

>>> sys.float_info sys.floatinfo(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308,  min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15,  mant_dig=53, epsilon=2.2204460492503131e-16, radix=2, rounds=1) 


Don't use __class__, a semantically nonpublic API, to get the type of a variable. Use type instead.

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.

vote vote


print type(variable_name) 

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.


In [9]: var = 123  In [10]: var? Type:       int Base Class: <type 'int'> String Form:    123 Namespace:  Interactive Docstring:     int(x[, base]) -> integer 

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.

Top 3 video Explaining How to determine a Python variable's type?