Data types specify the different sizes and values that can be stored in the variable. For example, Python stores numbers, strings, and a list of values using different data types.
Table of contents
Python is a dynamically typed language; therefore, we do not need to specify the variable’s type while declaring it. Whatever value we assign to the variable based on that data type will be automatically assigned. For example, name = 'Jessa'
here Python will store the name variable as a str
data type.
No matter what value is stored in a variable (object), a variable can be any type like int, float, str, list, set, tuple, dict, bool, etc.
There are mainly four types of basic/primitive data types available in Python
- Numeric: int, float, and complex
- Sequence: String, list, and tuple
- Set
- Dictionary (dict)

To check the data type of variable use the built-in function type()
and isinstance()
.
- The
type()
function returns the data type of the variable - The isinstance() function checks whether an object belongs to a particular class.
In this article, we will learn the following Python data types in detail.
Data type | Description | Example |
---|---|---|
int | To store integer values | n = 20 |
float | To store decimal values | n = 20.75 |
complex | To store complex numbers (real and imaginary part) | n = 10+20j |
str | To store textual/string data | name = 'Jessa' |
bool | To store boolean values | flag = True |
list | To store a sequence of mutable data | l = [3, 'a', 2.5] |
tuple | To store sequence immutable data | t =(2, 'b', 6.4) |
dict | To store key: value pair | d = {1:'J', 2:'E'} |
set | To store unorder and unindexed values | s = {1, 3, 5} |
frozenset | To store immutable version of the set | f_set=frozenset({5,7}) |
range | To generate a sequence of number | numbers = range(10) |
bytes | To store bytes values | b=bytes([5,10,15,11]) |
Str data type
In Python, A string is a sequence of characters enclosed within a single quote or double quote. These characters could be anything like letters, numbers, or special symbols enclosed within double quotation marks. For example, "PYnative"
is a string.
The string type in Python is represented using a str
class.
To work with text or character data in Python, we use Strings. Once a string is created, we can do many operations on it, such as searching inside it, creating a substring from it, and splitting it.
Example
platform = "PYnative"
print(type(platform)) # <class 'str'>
# display string
print(platform) # 'PYnative'
# accessing 2nd character of a string
print(platform[1]) # Y
Note: The string is immutable, i.e., it can not be changed once defined. You need to create a copy of it if you want to modify it. This non-changeable behavior is called immutability.
Example
platform = "PYnative"
# Now let's try to change 2nd character of a string.
platform[0] = 'p'
# Gives TypeError: 'str' object does not support item assignment
Int data type
Python uses the int data type to represent whole integer values. For example, we can use the int data type to store the roll number of a student. The Integer type in Python is represented using a int
class.
You can store positive and negative integer numbers of any length such as 235, -758, 235689741.
We can create an integer variable using the two ways
- Directly assigning an integer value to a variable
- Using a
int()
class.
Example
# store int value
roll_no = 33
# display roll no
print("Roll number is:", roll_no)
# output 33
print(type(roll_no))
# output class 'int'
# store integer using int() class
id = int(25)
print(id) # 25
print(type(id)) # class 'int'
You can also store integer values other than base 10 such as
- Binary (base 2)
- Octal (base 8)
- Hexadecimal numbers (base 16)
Example
# decimal int 16 with base 8
# Prefix with zero + letter o
octal_num = 0o20
print(octal_num) # 16
print(type(octal_num)) # class 'int'
# decimal int 16 with base 16
# Prefix with zero + letter x
hexadecimal_num = 0x10 # decimal equivalent of 21
print(hexadecimal_num) # 16
print(type(hexadecimal_num)) # class 'int'
# decimal int 16 with base 2
# Prefix with zero + letter b
binary_num = 0b10000 # decimal equivalent of 6
print(binary_num) # 16
print(type(binary_num)) # class 'int'
Float data type
To represent floating-point values or decimal values, we can use the float data type. For example, if we want to store the salary, we can use the float type.
The float type in Python is represented using a float
class.
We can create a float variable using the two ways
- Directly assigning a float value to a variable
- Using a
float()
class.
Example
# store a floating-point value
salary = 8000.456
print("Salary is :", salary) # 8000.456
print(type(salary)) # class 'float'
# store a floating-point value using float() class
num = float(54.75)
print(num) # 54.75
print(type(num)) # class 'float'
Floating-point values can be represented using the exponential form, also called scientific notation. The benefit of using the exponential form to represent floating-point values is we can represent large values using less memory.
Example
# exponential float
num1 = 1.22e4
print(num1) # 12200.0
print(type(num1)) # class 'float'
Complex data type
A complex number is a number with a real and an imaginary component represented as a+bj
where a
and b
contain integers or floating-point values.
The complex type is generally used in scientific applications and electrical engineering applications. If we want to declare a complex value, then we can use the a+bj
form. See the following example.
Example
x = 9 + 8j # both value are int type
y = 10 + 4.5j # one int and one float
z = 11.2 + 1.2j # both value are float type
print(type(x)) # class 'complex'>
print(x) # (9+8j)
print(y) # (10+4.5j)
print(z) # (11.2+1.2j)
The real part of the complex number is represented using an integer value. The integer value can be in the form of either decimal, float, binary, or hexadecimal. But the imaginary part should be represented using the decimal form only. If we are trying to represent an imaginary part as binary, hex, or octal, we will get an error.
List data type
The Python List is an ordered collection (also known as a sequence ) of elements. List elements can be accessed, iterated, and removed according to the order they inserted at the creation time.
We use the list data type to represent groups of the element as a single entity. For example: If we want to store all student’s names, we can use list
type.
- The list can contain data of all data types such as
int
,float
,string
- Duplicates elements are allowed in the list
- The list is mutable which means we can modify the value of list elements
We can create a list using the two ways
- By enclosing elements in the square brackets
[]
. - Using a
list()
class.
Example list creation and manipulation
my_list = ["Jessa", "Kelly", 20, 35.75]
# display list
print(my_list) # ['Jessa', 'Kelly', 20, 35.75]
print(type(my_list)) # class 'list'
# Accessing first element of list
print(my_list[0]) # 'Jessa'
# slicing list elements
print(my_list[1:5]) # ['Kelly', 20, 35.75]
# modify 2nd element of a list
my_list[1] = "Emma"
print(my_list[1]) # 'Emma'
# create list using a list class
my_list2 = list(["Jessa", "Kelly", 20, 35.75])
print(my_list2) # ['Jessa', 'Kelly', 20, 35.75]
Tuple data type
Tuples are ordered collections of elements that are unchangeable. The tuple
is the same as the list
, except the tuple is immutable means we can’t modify the tuple once created.
In other words, we can say a tuple is a read-only version of the list.
For example: If you want to store the roll numbers of students that you don’t change, you can use the tuple
data type.
Note: Tuple maintains the insertion order and also, allows us to store duplicate elements.
We can create a tuple using the two ways
- By enclosing elements in the parenthesis ()
- Using a
tuple()
class.
Example Tuple creation and manipulation
# create a tuple
my_tuple = (11, 24, 56, 88, 78)
print(my_tuple) # (11, 24, 56, 88, 78)
print(type(my_tuple)) # class 'tuple'
# Accessing 3rd element of a tuple
print(my_tuple[2]) # 56
# slice a tuple
print(my_tuple[2:7]) # (56, 88, 78)
# create a tuple using a tuple() class
my_tuple2 = tuple((10, 20, 30, 40))
print(my_tuple2) # (10, 20, 30, 40)
Tuple is immutable
A tuple is immutable means once we create a tuple, we can’t modify it
# create a tuple
my_tuple = (11, 24, 56, 88, 78)
# modify 2nd element of tuple
my_tuple[1] = 35
print(my_tuple)
# TypeError: 'tuple' object does not support item assignment
Dict data type
In Python, dictionaries are unordered collections of unique values stored in (Key-Value) pairs. Use a dictionary data type to store data as a key-value pair.
The dictionary type is represented using a dict
class. For example, If you want to store the name and roll number of all students, then you can use the dict
type.
In a dictionary, duplicate keys are not allowed, but the value can be duplicated. If we try to insert a value with a duplicate key, the old value will be replaced with the new value.
Dictionary has some characteristics which are listed below:
- A heterogeneous (i.e.,
str
,list
,tuple
) elements are allowed for both key and value in a dictionary. But An object can be a key in a dictionary if it is hashable. - The dictionary is mutable which means we can modify its items
- Dictionary is unordered so we can’t perform indexing and slicing
We can create a dictionary using the two ways
- By enclosing key and values in the curly brackets
{}
- Using a
dict()
class.
Example dictionary creation and manipulation
# create a dictionary
my_dict = {1: "Smith", 2: "Emma", 3: "Jessa"}
# display dictionary
print(my_dict) # {1: 'Smith', 2: 'Emma', 3: 'Jessa'}
print(type(my_dict)) # class 'dict'
# create a dictionary using a dit class
my_dict = dict({1: "Smith", 2: "Emma", 3: "Jessa"})
# display dictionary
print(my_dict) # {1: 'Smith', 2: 'Emma', 3: 'Jessa'}
print(type(my_dict)) # class 'dict'
# access value using a key name
print(my_dict[1]) # Smith
# change the value of a key
my_dict[1] = "Kelly"
print(my_dict[1]) # Kelly
Set data type
In Python, a set is an unordered collection of data items that are unique. In other words, Python Set is a collection of elements (Or objects) that contains no duplicate elements.
In Python, the Set data type used to represent a group of unique elements as a single entity. For example, If we want to store student ID numbers, we can use the set data type.
The Set data type in Python is represented using a set
class.
We can create a Set using the two ways
- By enclosing values in the curly brackets
{}
- Using a
set()
class.
The set data type has the following characteristics.
- It is mutable which means we can change set items
- Duplicate elements are not allowed
- Heterogeneous (values of all data types) elements are allowed
- Insertion order of elements is not preserved, so we can’t perform indexing on a Set
Example Set creation and manipulation
# create a set using curly brackets{,}
my_set = {100, 25.75, "Jessa"}
print(my_set) # {25.75, 100, 'Jessa'}
print(type(my_set)) # class 'set'
# create a set using set class
my_set = set({100, 25.75, "Jessa"})
print(my_set) # {25.75, 100, 'Jessa'}
print(type(my_set)) # class 'set'
# add element to set
my_set.add(300)
print(my_set) # {25.75, 100, 'Jessa', 300}
# remove element from set
my_set.remove(100)
print(my_set) # {25.75, 'Jessa', 300}
Frozenset
The frozenset
data type is used to create the immutable Set. Once we create a frozenset
, then we can’t perform any changes on it.
Use a frozenset()
class to create a frozenset
.
Example
my_set = {11, 44, 75, 89, 56}
print(type(my_set)) # class 'set'
# creating frozenset
f_set = frozenset(my_set)
print(type(f_set)) # class 'frozenset'
Note: If we try to perform operations like add, remove on frozenset
, you will get an error.
Bool data type
In Python, to represent boolean values (True
and False
) we use the bool
data type. Boolean values are used to evaluate the value of the expression. For example, when we compare two values, the expression is evaluated, and Python returns the boolean True
or False
.
Example
x = 25
y = 20
z = x > y
print(z) # True
print(type(z)) # class 'bool'
Bytes data type
The bytes
data type represents a group of byte numbers just like an array. We use the bytes()
constructor to create bytes type, which also returns a bytes object. Bytes are immutable (Cannot be changed).
Use bytes data type if we want to handle binary data like images, videos, and audio files.
Example
a = [9, 14, 17, 11, 78]
b = bytes(a)
print(type(b)) # class 'bytes'
print(b[0]) # 9
print(b[-1]) # 78
In bytes, allowed values are 0 to 256. If we are trying to use any other values, then we will get a ValueError
.
Example
a = [999, 314, 17, 11, 78] # Gives error range must be in 0 to 256
b = bytes(a)
print(type(b))
# ValueError: bytes must be in range(0, 256)
bytearray
The bytearray
data type same as the bytes
type except bytearray
mutable (we can modify its elements). The bytearray()
constructor returns a bytearray
object.
Example
# create a bytearray
list1 = [9, 17, 11, 78]
b_array = bytearray(list1)
print(b_array)
print(type(b_array)) # class 'bytearray'
# modifying bytearray
b_array[1] = 99
print(b_array[1]) # 99
# iterate bytearray
for i in b_array:
print(i, end=" ") # 9 99 11 78
Range data type
In Python, The built-in function range()
used to generate a sequence of numbers from a start number up to the stop number. For example, If we want to represent the roll number from 1 to 20, we can use the range()
type. By default, it returns an iterator object that we can iterate using a for loop
.
Example
# Generate integer numbers from 10 to 14
numbers = range(10, 15, 1)
print(type(numbers)) # class 'range'
# iterate range using for loop
for i in range(10, 15, 1):
print(i, end=" ")
# Output 10 11 12 13 14
memoryview
The memoryview
is used to create a view of the internal data of an object without copying it. So with the help of memoryview
we can see the same data in a different view.
To do this, we need a buffer protocol. The buffer protocol provides a way to access the internal data of an object. This internal data is a memory array or a buffer.
In Python bytes
and bytearray
are built-in objects that support the buffer protocol. So we can create memoryview
on top of those objects.
Syntax to create a memoryview
memoryview(obj)
Example 1: Creating memoryview
of an object
b_array = b'PYnative'
b_array_view = memoryview(b_array) # creating memory view for bytes objects
print("view object: ", b_array_view)
Output
view object: <memory at 0x0000003396DC6F48>
In the above example, we create memoryview
of b_array
and print the object in memory view format instead of the original object. If we want an object in its original form, we need to collect the object in a container(like a list or tuple). We can also iterate over each element of the given bytes array.
Example 2: Creating and storing in a container
byte_array = b'PYnative' # creating bytes array object
byte_array_view = memoryview(byte_array) # creating memory view for bytes array objects
container = tuple(byte_array_view) # Storing it in container of iterating
for char in container:
print(char, end=" ")
Output
80 89 110 97 116 105 118 101
We can also perform indexing and slicing on memoryview
same like list and tuple object. So it will return ordinal value for characters at the given index
Example 3: Indexing and slicing on memoryview
byte_array = b'PYnative' # creating bytes array object
byte_array_view = memoryview(byte_array) # creating memory view for bytes array objects
print("byte_array_view[0]:", byte_array_view[0]) # indexing
print('Slicing of b_array_view[6:12] is:', bytes(byte_array_view[6:12])) # Slicing
Output
byte_array_view[0]: 80 Slicing of b_array_view[6:12] is: b've'