Before starting the discussion, please note that everything in Python is an object. Following are the types built into Python:
- None – This type has a single value and there is a single object with this value. This object is accessed through the built-in name
None
. It is used to signify the absence of a value. For example, it is returned from functions that don’t explicitly return anything. Its truth value is false. - NotImplemented – This type has a single value and there is a single object with this value. This object is accessed through the built-in name
NotImplemented
. It’s truth value is true. NotImplemented should be returned by numeric methods(like __eq__(), __lt__(), __add__() etc) if they do not provide implementation for the operands provided. - Ellipsis – This type has a single value and there is a single object with this value. This object is accessed through the literal … or the built-in name
Ellipsis
. Its truth value is true. - numbers.Number – These are created by numeric literals. Numbers are used as input to arithmetic operations the output of which is again numbers. Numeric objects in Python are immutable, i.e. once created their value never changes. In Python there are three types of numbers: integers, floating point numbers and complex numbers.
- numbers.Integral – These represent positive and negative integers. There are two types of integers:
- Integers(‘int’) – These represent numbers in an unlimited range, subject to available virtual memory. Example:
x=1
- Booleans(bool) – These represent the value
True
andFalse
. The Boolean type is a subtype of integer type. Boolean values behave like the values 0 (False) and 1( True) in almost all context except then these are converted to string objects “True” and “False”. Example:x = True
- Integers(‘int’) – These represent numbers in an unlimited range, subject to available virtual memory. Example:
- numbers.Real (float) – These represent machine-level double precision floating point numbers. The range depends on the underlying machine architecture and implementation. Python does not support single precision floating point numbers.
- numbers.Complex (complex) – These represent complex numbers as a pair of machine-level double precision ﬂoating point numbers. The complex numbers have the same conditions and limitations as ﬂoating point numbers. The real and imaginary parts of a complex number z can be retrieved through the read-only attributes z.real and z.imag. Example:
x = 10.5
- numbers.Integral – These represent positive and negative integers. There are two types of integers:
- Sequences – Sequences represent finite ordered sets indexed by non-negative numbers. If the number of elements is n then the indexes in the sequence are from 0 to n-1. Elements of the sequence can be accessed using the notation seq[index] where seq is the sequence and index is the index of the sequence.
- Immutable sequences – An immutable sequence object can not be changed once created. Following are the immutable sequences:
- Strings – A string is a sequence of Unicode code points which can range between U+0000 – U+10FFFF. Python does not have a ‘char’ type. Example:
x = "Hello World"
- Tuples – A tuple is a sequence of objects. It is immutable in nature. Example:
x = (10,21)
- Bytes – A Bytes object is an immutable sequence of 8-bit bytes. The items of the sequence are represented by integers in the range of 0<=x<256.
- Strings – A string is a sequence of Unicode code points which can range between U+0000 – U+10FFFF. Python does not have a ‘char’ type. Example:
- Mutable sequences – Unlike Immutable sequences, mutable sequences can be changed after they are created. Following are mutable sequences:
- Lists – A list is a sequence of objects. It is mutable in nature. A list is represented as a comma separated list within square brackets. Example:
[10, 21]
- Byte Array – A bytearray is a mutable array. It is same like
Bytes
with the only difference it is mutable.
- Lists – A list is a sequence of objects. It is mutable in nature. A list is represented as a comma separated list within square brackets. Example:
- Immutable sequences – An immutable sequence object can not be changed once created. Following are the immutable sequences:
- Sets type – Sets represent unordered, finite set of unique and immutable objects. There are following set types:
- Sets – They represent a mutable set. Sets can be modified. Example –
{"Sunday","Monday","Tuesday"}
- Frozen Sets – These represent an immutable set. Example:
x = frozenset({"Sunday", "Monday", "Tuesday"})
- Sets – They represent a mutable set. Sets can be modified. Example –
- Mappings – A Mapping is usually explained as “key-value” pair. There is a single Mappings type:
- Dictionary – An example of dictionary is
x = {"name" : "John", "age" : 50}
. Here “name” and “age” are keys and “John” and 50 are values mapped to the keys. Dictionaries preserve insertion order.
- Dictionary – An example of dictionary is
There are other types which should be mentioned here.
- Callable types
- User defined functions
- Instance methods
- Generator functions
- Coroutine functions
- Classes
- Class Instances
- Modules
- Custom classes
- Class instances
- I/O objects (file objects)
How to get Data Type of an object in Python
Python is dynamically typed language. The type of the variable is defined when you assign a value to that variable.
You can get the data type of any object by using the type() function:
x = "Hello World" print(type(x)) x = 10 print(type(x))
Output
<class 'str'>
<class 'int'>
To read in detail about the Python data types, please refer Python’s official documentation. That is the most comprehensive source for any topic on Python for us and anyone else.