Variables stores data and data types control the type of value they can store. This Python tutorial covers all the essential data types in Python. Just to know that Python uses dynamic typing meaning a variable’s type is determined at runtime.
Know Everything about Python Data Types
We have here a very crisp and concise detail on the 8 data types. Please remember these are basic building blocks of Python programming. Hence, you must at least go through the optimal detail provided here.
Boolean Data Type
A Boolean is a data type available in almost every programming language, including Python. It can have two values: True or False, which are constants used for assignment, comparison, and controlling program flow. Here’s a simple example:
condition = False
if condition == True:
print("You can continue with the program.")
else:
print("The program will end here.")While making boolean conditions in Python, we can skip the explicit comparison in our code. And we’ll still get the same behavior.
condition = False
if condition:
print("You can continue with the program.")
else:
print("The program will end here.")The above code will yield the same output as the previous one due to the below statement
if condition:is equivalent to,
if condition == True:Next, an expression in Python can also produce a boolean result.
For example – The expression in a condition block will yield a boolean value. Python creates boolean contexts to evaluate expressions.
Whatever the expression is, Python will use the boolean context to determine its truth value. Since Python has many data types, it operates with its own rules to find the result in a boolean context.
str = "Learn Python"
print( len(str) ) # 12
print( len(str) == 12 ) # True
print( len(str) != 12 ) # FalseIn some cases, the boolean constants “True” and “False” might also act as numbers.
A, B = True + 0, False + 0
print(A, B) # 1 0
print( type(A), type(B) ) # (<class 'int'>, <class 'int'>)It is evident from the above example that True is 1 and the value of False is 0. And they will turn into numbers during arithmetic operations.
Number Data Type in Python
Numbers are one of the most important data types in Python. Unlike many languages that only have integers and floats, Python also supports complex numbers. Learn more about floats in Python and how to work with them.
Here are a few points for you to ponder.
- The numbers in Python are classified using the following keywords: int, float, and complex.
- Python has a built-in function type() to determine the data type of a variable or the value.
- Another built-in function isinstance() is there for testing the type of an object.
- In Python, we can add a “j” or “J” after a number to make it imaginary or complex.
Example.
num = 2
print("The number (", num, ") is of type", type(num))
num = 3.0
print("The number (", num, ") is of type", type(num))
num = 3+5j
print("The number ", num, " is of type", type(num))
print("The number ", num, " is complex number?", isinstance(3+5j, complex))#Output
The number ( 2 ) is of type <class 'int'>
The number ( 3.0 ) is of type <class 'float'>
The number (3+5j) is of type <class 'complex'>
The number (3+5j) is complex number? True- We can create a complex number by using the type as a constructor. See the example below.
print( complex(1.2,5)) #(1.2+5j)- Integers in Python don’t have any size limitation as long as the required memory is available.
num = 1234567890123456789
print( num.bit_length() ) # 61
print( num ) # 1234567890123456789
num=1234567890123456789123456789012345678912345678901234567891234567890123456789
print( num.bit_length() ) # 250
print( num ) # 1234567890123456789123456789012345678912345678901234567891234567890123456789- A float-type number can have precision up to 15 decimal places.
import sys
print( sys.float_info )
# sys.float_info(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.220446049250313e-16, radix=2, rounds=1)
print( sys.float_info.dig ) # 15Python Strings Data Type
In Python, a string is treated as a sequence of characters enclosed in quotes. It can contain letters, numbers, symbols, or spaces. For longer strings spanning multiple lines, Python provides multiline strings, which use triple quotation marks (“”” or ”’) at the start and end.
str = 'A string wrapped in single quotes'
print( str ) # 'A string wrapped in single quotes'
str = "A string enclosed within double quotes"
print( str ) # 'A string enclosed within double quotes'
str = """A multiline string
starts and ends with
a triple quotation mark."""
print( str )
# 'A multiline string\nstarts and ends with\na triple quotation mark.'Also, the strings in Python are immutable. It means the memory will be allocated once and re-used for further operations.
A = 'Python3'
print( id(A) ) # 140186214284656
B = A
print( id(B) ) # 140186214284656You can see the second string shares the same address as the first one does.
Python has two popular versions, namely 2.7 and 3.4. Most programmers around the globe use either of them. The strings in Python 2 are by default non-Unicode (ASCII) but also have support for Unicode.
On the other hand, Python 3 strings are all Unicode (UTF-8).
Strings in Python 2
print(type('Python String')) # <type 'str'>
print(type(u'Python Unicode String')) # <type 'unicode'>Strings in Python 3
print(type('Python String')) # <class 'str'>
print(type(u'Python Unicode String')) # <class 'str'>Python allows you to slice strings using square brackets ([]) to extract a substring. For more details and examples, check out Python string slicing.
str = "Learn Python"
first_5_chars = str[0:5]
print(first_5_chars) # Learn
substr_from_2_to_5 = str[1:5]
print(substr_from_2_to_5) # earn
substr_from_6_to_end = str[6:]
print(substr_from_6_to_end) # ython
last_2_chars = str[-2:]
print(last_2_chars) # on
first_2_chars = str[:2]
print(first_2_chars) # Le
two_chars_before_last = str[-3:-1]
print(two_chars_before_last) # hoBytes Data Type in Python
The byte is an immutable type in Python. It can store a sequence of bytes (each 8-bit) ranging from 0 to 255. We can fetch the value of a single byte by using the index. But we can not modify the value. The following are a few differences between a byte and a string.
- Byte objects contain a sequence of bytes whereas the strings store a sequence of characters.
- The bytes are machine-readable objects whereas the strings are just in human-readable form.
- Bytes are machine-readable and can be directly stored on the disk whereas strings need to be encoded before writing them to the disk.
# Make an empty bytes object (8-bit bytes)
empty_object = bytes(16)
print(type(empty_object)) # <class 'bytes'>
print(empty_object)
# b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'One scenario, where bytes matter is when carrying out I/O operations with buffering enabled. For example, we have a program that continuously receives data over the network. It parses the date after waiting for the message headers and terminators to appear in the stream. It keeps appending the incoming bytes to a buffer.
With Python byte object, it is easy to program the above scenario using the below pseudo code.
buf = b''
while message_not_complete(buf):
buf += read_from_socket()In the later sections of this tutorial, we’ll see the byte-to-string conversion and vice-versa.
Python Lists Data Type
Python list is an ordered sequence, similar to an array but can hold different types of objects. It is very flexible and supports dynamic sizing. The index in a list begins with a zero position. Here are some more points on it.
- A list is a heterogeneous collection of items of varied data types. For example, a list object can store the files in a folder and the employee data in a company, etc.
- Lists in Python are easy to create by placing elements inside square brackets separated by commas.
assorted_list = [True, False, 1, 1.1, 1+2j, 'Learn', b'Python']
first_element = assorted_list[0]
print(first_element) # True
print(assorted_list) # [True, False, 1, 1.1, (1+2j), 'Learn', b'Python']
for item in assorted_list:
print(type(item))
"""
<class 'bool'>
<class 'bool'>
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'bytes'>
"""- List objects are mutable. Python allows modifying a list or its elements via assignments and through the built-in list methods.
simpleton = ['Learn', 'Python', '2']
print( id(simpleton) ) # 56321160
print( simpleton ) # ['Learn', 'Python', '2']
simpleton[2] = '3'
print( id(simpleton) ) # 56321160
print( simpleton ) # ['Learn', 'Python', '3']- Interestingly, a list can contain another list. Such a list is called a nested list in Python.
nested = [[1,1,1], [2,2,2], [3,3,3]]
for items in nested:
for item in items:
print(item, end=' ')
# 1 1 1 2 2 2 3 3 3Tuples Data Type in Python
A Python tuple is a heterogeneous collection of objects separated by commas. It means objects of different data types can co-exist in a tuple. The tuple and a list are somewhat similar as they share the following traits.
- Both objects are a type of ordered sequence.
- Each of them allows indexing and repetition.
- Nesting is permitted.
- They can store values of different types.
Below are some basic Python tuple examples.
# Defining a tuple without any element
pure_tuple = ()
print(pure_tuple) # Output- ()
# Creating a tuple with nested tuples
first_tuple = (3, 5, 7, 9)
second_tuple = ('learn', 'python 3')
nested_tuple = (first_tuple, second_tuple)
print(nested_tuple)
# Creating a tuple with nested tuples
first_tuple = (3, 5, 7, 9)
second_tuple = ('learn', 'python 3')
nested_tuple = (first_tuple, second_tuple)
print(nested_tuple)
# Repetition in tuples
sample_tuple = ('Python 3',)*3
print(sample_tuple)How is a tuple different than the list?
Tuples do differ a bit from the list as they are immutable. Python does not allow to modify a tuple after it is created. We can not add or remove any element later. Instead, Python expects us to create a new one with the updated sequence of elements.
Can a tuple have mutable objects as elements?
Here, comes the surprise. Modifying a tuple is forbidden. But Python doesn’t enforce it for the elements. It means we can update them if they are mutable objects.
Python Set Data Type
A Set is an unordered collection of unique and immutable objects. Its definition starts with enclosing braces { } having its elements separated by commas inside. Amongst all the Python data types, Set supports mathematical operations like union, intersection, symmetric difference, etc.
Python Set is similar to the “Set” in mathematics, hence it can’t have multiple occurrences of the same element.
What makes a Python set better than a list?
Python Set implements a highly optimized way to check whether it holds a specific element. This mechanism is known as a hash table.
To create a set, call the built-in set() function with a sequence or any iterable object.
sample_set = set("Python data types")
print( type(sample_set) ) # <class 'set'>
print( sample_set )
# {'e', 'y', 't', 'o', ' ', 'd', 's', 'P', 'p', 'n', 'h', 'a'}Another simpler way is to specify the elements enclosed in curly braces {}.
another_set = {'red', 'green', 'black'}
print( type(another_set) ) # <class 'set'>
print( another_set) # {'red', 'green', 'black'}What is a Frozen set in Python?
A frozen set is a processed form of the traditional set. It is immutable and only supports methods and operators that execute without altering the frozen set used in the context.
# An empty frozenset
print( frozenset() ) # frozenset()
cities = {"New York City", "Saint Petersburg", "London", "Munich", "Paris"}
fset = frozenset(cities)
print( type(fset) ) # <class 'frozenset'>Read: How to check type of variable in Python
Dictionaries in Python
A dictionary in Python is an unordered collection of key-value pairs. It’s a built-in mapping type in Python where keys map to values. These key-value pairs provide an intuitive way to store data.
What is the need of a dictionary?
Python dictionary solves the problem of managing a large data set. It is designed to be highly optimized for storing and retrieving data.
Python syntax for creating dictionaries uses braces {} where each item appears as a pair of keys and values. The key and value can be of any Python data type.
sample_dict = {'key':'value', 'jan':31, 'feb':28, 'mar':31}
print( type(sample_dict) ) # <class 'dict'>
print( sample_dict )
# {'mar': 31, 'key': 'value', 'jan': 31, 'feb': 28}How do you access dictionary elements with keys?
Dictionaries act like a database. Here, we don’t use a number to get a particular index value as we do with a list. Instead, we replace it with a key and then use the key to fetch its value.
Check: How to search keys in a Python dictionary
sample_dict = {'key':'value', 'jan':31, 'feb':28, 'mar':31}
print( sample_dict['jan'] ) # 31
print( sample_dict['feb'] ) # 28Summary: Different Data Types in Python
This course covered the various Python data types and tried to explain them with examples. You may find all the relevant information here which can be useful for you in developing Python programs.
If you liked this tutorial, share it on your social media. Also, don’t forget to subscribe to our YouTube channel.
To learn Python more comprehensively, check out the following course which is again freely available.
Free Python Course for Beginners
Step-by-step Python course with 80+ tutorials, 20+ quizzes, and 100+ practice exercises.
Enjoy Coding,
TechBeamers
