Python implements built-in data types, so programmers need to know when to use each one. It’s an object-oriented language: it consists of objects and classes. Each object represents a specific type, and each type is defined by a class. When an instance of an object belonging to a class is created, a new variable is created. The class is considered the type of this variable.
When programming in Python, it’s important to understand the available data types: each has its own methods, attributes, and functionality. In this article, we’ll cover the main data types in Python, their methods, and use cases.
What are data types in Python?
Data types in Python refer to the classification or categorization of data objects based on their characteristics. They determine the type of values that can be stored in variables, as well as the operations that can be performed on these values. Python has several built-in data types. These include numeric types (int, float, complex), string types (str), logical types (bool), and collection types (list, tuple, dict, set). Each data type has its own set of properties, methods, and behaviors that allow programmers to effectively manipulate and process them.
Data types help establish interactions with the Python interpreter. For example, integers can contain integer data, while strings can be used for character data. Entering a value of the wrong type (such as text into an integer variable) can cause a runtime error and ensure that programs are not compromised.
Data types also define the set of operations that can be performed on the data stored in a variable. Integers include addition and subtraction, which can be applied, while strings do not. Manipulation operations involving concatenation of two or more strings do not apply to integer variables. This improves type safety, preventing potential errors in the future.
Basic data types in Python
Data types are divided into mutable and immutable. The former include lists, dictionaries, and sets. Tuples, strings, Booleans, numbers, and floating-point numbers are considered immutable. Let’s look at each type in more detail.
Numeric. Numeric data types are used to represent any numeric value. Python has three main numeric data types: integers, floating-point numbers, and complex numbers.
Integers are called ints. This is a built-in data type. Ints can represent integers of any size without overflow errors: they can be positive, zero, or negative.
# Python Integer
a = 7
y = -1
c = 0
print(a) # Output: 7
print(y) # Output: -1
print(c) # Output: 0
You can perform numerous arithmetic calculations with integers—addition, subtraction, multiplication, division, and raising to powers. Example:
# Multiplication operation *
multiplication = 10 * 2
print(“Multiplication:”, multiplication) # Output: 20
The floating-point data type (float) can be thought of as a tool that provides a good balance between precision and space efficiency. Float uses binary fixed-point arithmetic, so results may differ slightly from those of decimal fixed-point arithmetic. This should be kept in mind, especially when performing high-precision calculations. Float can represent both integers and fractions.
# Python Float
b = 2.47
y = -0.1
k = 5.0
A floating-point number is any number with a decimal point. Example operation:
# Multiplication operation
e = 4.0
f = 2.5
print(e * f) # Output will be 10.0
Complex numbers are widely used in engineering, physics, and mathematics to model real and imaginary components. The numbers take the form a + bj, where a and b are real numbers, and j represents the imaginary unit, defined as the square root of -1.
z1 = 8 + 2j # Creates a complex number 8 + 2j
z2 = -9 – 6j # Creates a complex number -9 – 6j
Python provides addition, subtraction, multiplication, and division of complex numbers:
z2 = complex(3, 2)
z4 = complex(-1, 6)
# Addition Operation
sum_z = z2 + z4 # Result: 3 – 1 + (2 + 6)j = 2 + 8j
Sequence data types. Used to represent collections in a specific order.
Lists are defined using square brackets [] with comma-separated elements. They are a mutable built-in data structure for storing collections of elements. Example:
# List creation
the_list = [1, 2, 4, 5]
# creating a mixed data list
multiple_data_list = [1, ‘hi’, 2.57, False]
print(the_list[0]) # Output: 1
print(multiple_data_list[2]) # Output:2.57
A string, enclosed in single (‘) or double quotation marks (“), is an immutable sequence of characters. It is used to represent text data.
Python provides string indexing, slicing, and concatenation:
# Creating a String with both single and double quotes
single_string = ‘Hello!’
double_string = “Python Programming!”
# Outputting the result
print(single_string[0]) # Output: ‘H’
print(double_string[-1]) # Output: ‘!’
Boolean data type. This data type (bools) contains truth values and forms the basis for logical operations and conditional statements. It has only two possible values: it contains questions and answers in the format “True” and “False.” These values are useful when deciding whether to continue execution or move to another location within a program based on conditions.
is_user_authenticated = True
is_prime_number = False
# Conditional statement (if-else)
if is_user_authenticated:
print(“Welcome back!”)
else:
print(“Please log in.”)
# Logical operators (and, or, not)
is_admin = is_user_authenticated and has_admin_privileges
Other data types. In Python, a tuple is a data structure very similar to a list, but with several important differences. Tuples are immutable. This is useful when you need to store data that shouldn’t change.
Tuples are also commonly used to store related pieces of information, such as the coordinates of a point or the dimensions of an object. Unlike lists, tuples are created by enclosing values in parentheses. For example:
>>> matts_tuple = (‘Matt’, ‘matt@dataquest.io’, ‘www.matt.com’, 37, True)
>>> print(matts_tuple)
In Python, a dict is used to store a collection of key-value pairs.
A dict is widely used in Python for a variety of purposes, including mapping related information, representing a set of data records, and storing configurations.
You can create a dict using curly braces {} or the dict() constructor. A dict does not allow duplicate keys. Assigning a new value to an existing key only replaces the old value associated with that key. Key immutability ensures that keys remain hashable and consistent. Any data type (such as lists, tuples, strings, numbers, and even dictionaries) can be associated with keys in a dictionary.
How to define data types
When creating a variable in Python, you don’t need to specify its type: Python is a dynamically typed language. This means that the variable’s type is determined at runtime based on the value assigned to it. However, in many situations, you need to know the variable’s type. This can be done in several ways.
The type() function tells you what data a variable contains.
a = 5
b = 5.0
c = “Hello, World!”
print(type(a)) # Output: <class ‘int’>
print(type(b)) # Output: <class ‘float’>
print(type(c)) # Output: <class ‘str’>
The isinstance() function allows you to check whether an object belongs to a specific class or a subclass of that class.
a = 5
b = 5.0
print(isinstance(a, int)) # Output: True
print(isinstance(b, float)) # Output: True
Hints. You can use hints to provide complete information about variable types and function return values. They improve code readability and help with static analysis tools.
def add(x: int, y: int) -> int:
return x + y
# Using the function with type hints
result = add(3, 5)
print(result) # Output: 8
# Type hinting with variables
a: int = 10
b: float = 20.5
print(type(a)) # Output: <class ‘int’>
print(type(b)) # Output: <class ‘float’>
Using data types in programs
Data type conversion. In programming, type conversion is the process of transforming data from one type to another. For example, converting int to str.
There are two types of type conversion in Python:
- Implicit Conversion – automatic type conversion;
- Explicit Conversion—manual type conversion.
In certain situations, Python automatically converts one data type to another. This is known as implicit type conversion. In this example, Python facilitates the conversion of a lower data type (integer) to a higher data type (floating-point) to avoid data loss:
integer_number = 123
float_number = 1.23
new_number = integer_number + float_number
# display new value and resulting data type
print(“Value:”,new_number)
print(“Data Type:”,type(new_number))
With explicit type conversion, users convert an object’s data type to the desired data type. Built-in functions such as int(), float(), and str() can be used. This type of conversion is also known as type casting: the user changes the data type of objects.
num_string = ’12’
num_integer = 23
print(“Data type of num_string before Type Casting:”,type(num_string))
# explicit type conversion
num_string = int(num_string)
print(“Data type of num_string after Type Casting:”,type(num_string))
num_sum = num_integer + num_string
print(“Sum:”,num_sum)
print(“Data type of num_sum:”,type(num_sum))
Polymorphism. Certain Python functions can be used with different data types. The len() function is one example of such a function. Python allows it to work with a wide range of data types.
The built-in len() function estimates the length of an object based on its type. If the object is a string, it returns the number of characters. If the object is a list, it returns the number of elements in the list.
mystr = ‘Programming’
print(‘Length of string:’, len(mystr))
mylist = [1, 2, 3, 4, 5]
print(‘Length of list:’, len(mylist))
mydict = {1: ‘One’, 2: ‘Two’}
print(‘Length of dict:’, len(mydict))
Advanced Data Type Concepts
Special Methods. A Python object has several special methods that provide specific behavior. There are two similar special methods that describe the object using a string representation. These are the .__repr__() and .__str__() methods. The .__repr__() method returns a detailed description for the programmer who needs to maintain and debug the code. The .__str__() method returns a simpler description with information for the user of the program. _init__ is an instance method that is responsible for initializing a newly created object. It takes the object as its first argument (self), followed by any additional arguments.
OOP. The four fundamental principles of OOP are encapsulation, inheritance, polymorphism, and abstraction. Encapsulation combines data and methods. Inheritance allows new classes to derive from existing ones. Polymorphism allows objects to be treated as instances of their parent class. Abstraction hides unnecessary code details from the user. It is useful when sensitive parts of the code implementation cannot be disclosed.
Conclusion
Choosing the right data type for variables affects more than just syntax: it also influences the efficiency and maintainability of your code. Descriptive variable names, along with the correct types, improve code readability for you and others. Performance is improved—common operations typically execute faster with certain data types, which are specifically optimized. For example, simple integer arithmetic typically executes faster than floating-point arithmetic because they use fixed points. Data type safety ensures that unnecessary operations cannot be performed in a program, preventing runtime errors.
