In Python, we don’t have to explicitly declare the data type of a variable. Instead, Python automatically assigns the appropriate type based on the assigned value. So, understanding data types is very important as they define what kind of data a variable can hold and what operations we can be performed on it.
In this article, we will explore all the fundamental data types in Python, their usage, and examples to help you learn them easily.
What Are Data Types in Python?
Data types represent different types of values stored in variables. They help in organizing data efficiently and allow Python to interpret operations correctly. Python has several built-in data types that can be broadly classified into the following categories:
- Numeric Types
- Sequence Types
- Set Types
- Mapping Types
- Boolean Type
- Binary Types
- None Type
Let’s go through each of them in detail.
Numeric Data Types
Numeric data types in Python include integers, floating-point numbers, and complex numbers.
Integer (int)
An integer represents whole numbers without a decimal point. It can be positive, negative, or zero.
age = 30 salary = 50000 negative_number = -10 print(type(age)) # Output: <class 'int'>
Floating-Point (float)
A floating-point number (or float) represents real numbers with a decimal point.
pi = 3.14159 temperature = 98.6 percentage = 75.5 print(type(pi)) # Output: <class 'float'>
Complex Number (complex)
Complex numbers consist of a real and an imaginary part, denoted as a + bj where a is the real part, b is the imaginary part, and j is the imaginary unit.
complex_number = 2 + 3j print(complex_number.real) # Output: 2.0 print(complex_number.imag) # Output: 3.0 print(type(complex_number)) # Output: <class 'complex'>
Sequence Data Types
Sequence types allow us storing multiple items in an ordered manner. Example, strings, lists, tuples, and ranges.
String (str)
A string is a collection of characters enclosed within single or double quotes. Strings are immutable, meaning their values cannot be changed after they are created.
name = "John Doe" message = 'Hello, World!' multiline_string = """This is a multiline string.""" print(type(name)) # Output: <class 'str'>
Learn more about strings in Python from here.
List (list)
A list is an ordered, mutable collection that can store different data types.
my_list = [1, 2, 3, "apple", "banana", 3.14] empty_list = [] print(type(my_list)) # Output: <class 'list'>
Learn more about Python lists from here.
Tuple (tuple)
A tuple is similar to a list but immutable (cannot be modified on runtime after creation).
my_tuple = (1, 2, 3, "apple", "banana", 3.14) empty_tuple = () print(type(my_tuple)) # Output: <class 'tuple'>
Learn more about Python tuples from here.
Range (range)
The range function generates an immutable sequence of numbers. It is commonly used for looping.
numbers = range(5) # Represents the sequence 0, 1, 2, 3, 4
numbers_with_step = range(2, 10, 2) # Represents 2, 4, 6, 8
print(type(numbers)) # Output: <class 'range'>
for num in numbers_with_step:
print(num)Set Data Types
A set is an unordered collection of unique elements.
Set (set)
Sets do not allow duplicate values and are useful for mathematical operations like union and intersection.
my_set = {1, 2, 3, 3, 4}
print(type(my_set)) # Output: <class 'set'>
print(my_set) # Output: {1, 2, 3, 4}Learn more about Python set from here.
Frozen Set (frozenset)
A frozenset is an immutable version of a set.
fs = frozenset([1, 2, 3]) print(type(fs)) # Output: <class 'frozenset'>
Mapping Data Type
A mapping data type stores key-value pairs.
Dictionary (dict)
Dictionaries hold data in key-value pairs and are mutable.
my_dict = {"name": "Python", "version": 3.10}
print(type(my_dict)) # Output: <class 'dict'>Learn about Python dictionary from here.
Boolean Data Type
Booleans represent one of two values: True or False.
flag = True print(type(flag)) # Output: <class 'bool'>
Binary Data Types
Binary data types store binary values, such as images, files, etc.
Bytes (bytes)
A bytes object is immutable and stores byte sequences.
b = b"Hello" print(type(b)) # Output: <class 'bytes'>
Bytearray (bytearray)
A mutable version of bytes.
ba = bytearray([65, 66, 67]) print(type(ba)) # Output: <class 'bytearray'>
Memoryview (memoryview)
A memoryview gives direct access to binary data without copying. It is useful when working with large binary objects like files, network data, or memory buffers.
mv = memoryview(b"Python") print(type(mv)) # Output: <class 'memoryview'>
Memoryview allows modifying the underlying binary data when used with bytearray.
ba = bytearray(b"Python")
mv = memoryview(ba)
mv[0] = 80 # Changing 'P' to ASCII 80 ('P')
print(ba) # Output: bytearray(b'Pthon')None Type
The NoneType represents the absence of a value.
x = None print(type(x)) # Output: <class 'NoneType'>
How to Determine Data Types?
You can use the type() function to determine the data type of a variable:
x = 10 print(type(x)) # Output: <class 'int'> y = "Hello" print(type(y)) # Output: <class 'str'> z = [1, 2, 3] print(type(z)) # Output: <class 'list'>
Type Casting (Type Conversion)
Sometimes, you need to convert a value from one data type to another. This is called type casting or type conversion. Python provides several built-in functions for this purpose:
int(): Converts a value to an integer.
x = int(3.14) # x becomes 3
y = int("10") # y becomes 10
print(x,y)float(): Converts a value to a floating-point number.
a = float(5) # a becomes 5.0
b = float("2.5") # b becomes 2.5
print(a,b)str(): Converts a value to a string.
p = str(10) # p becomes "10" q = str(3.14) # q becomes "3.14" print(p,q)
bool(): Converts a value to a boolean.
t = bool(1) # t becomes True
u = bool(0) # u becomes False
v = bool("Hello") # v becomes True
w = bool("") # w becomes False
print(t,u,v,w) # Output: True False True Falselist(): Converts an iterable to a list.
my_string = "abc" my_list = list(my_string) # my_list becomes ['a', 'b', 'c'] my_tuple = (1, 2, 3) my_list_from_tuple = list(my_tuple) # my_list_from_tuple becomes [1,2,3] print(my_list, my_list_from_tuple) # Output: ['a', 'b', 'c'] [1, 2, 3]
tuple(): Converts an iterable to a tuple.
my_list = [1, 2, 3]
my_tuple = tuple(my_list) # my_tuple becomes (1, 2, 3)
my_string = "xyz"
my_tuple_from_string = tuple(my_string) # my_tuple_from_string becomes ('x', 'y', 'z')
print(my_tuple, my_tuple_from_string)
# Output: (1, 2, 3) ('x', 'y', 'z')set(): Converts an iterable to a set.
my_list = [1, 2, 2, 3, 3, 3]
my_set = set(my_list) # my_set becomes {1, 2, 3}
my_string = "hello"
my_set_from_string = set(my_string) # my_set_from_string becomes {'h', 'e', 'l', 'o'}
print(my_set, my_set_from_string)
# {1, 2, 3} {'o', 'l', 'e', 'h'}dict(): Converts a sequence of key-value pairs to a dictionary.
my_pairs = [("a", 1), ("b", 2), ("c", 3)]
my_dict = dict(my_pairs) # my_dict becomes {'a': 1, 'b': 2, 'c': 3}
print(my_dict) 
