Python Data Types: Categorization  and Exploration

Python Data Types: Categorization and Exploration

Unveiling Python's Data Palette: Dive into Types & Exploration

Thank you for your continued support and engagement with our blog. We're exploring the Python Series further, building on our previous post. In our previous blog, we learned about

  1. Python's Introduction

  2. Features and Execution

  3. Python Virtual Machine

  4. Memory Management

  5. Garbage Collection

In this blog, we will delve into an in-depth exploration of Python data types, accompanied by illustrative examples.

Data Types

Data types are categorizations that define the value of a variable or expression in a computer language, specifying operations, memory requirements, and binary storage. They aid in understanding and modifying the variable's values.

Python's data types are divided into various categories, each of which serves a distinct purpose in programming and caters to diverse scenarios

Numeric Data Types in Python: Exploring Integers, Floats, and Complex Numbers

Numeric Types

These data types deal with whole and decimal numbers. The float type supports decimal values, allowing for exact computations. The complex type is used for more sophisticated mathematical operations, expressing integers with real and imaginary components.

Integer (int)

  • Integer data types for whole numbers without a decimal point, such as 5, -10, or 0, are represented. To integer numbers, arithmetic operations such as addition, subtraction, multiplication, and division apply.

  • Define two integer variables a and b, representing whole numbers, and perform basic arithmetic operations, showcasing int data type usage.

      # Define integer variables
      a = 5
      b = -10
      # Perform arithmetic operations
      sum_result = a + b  # -5
      difference_result = a - b  # 15
      product_result = a * b  # -50
      division_result = a / b  # -0.5
      # Print the results
      print("Sum:", sum_result)
      print("Difference:", difference_result)
      print("Product:", product_result)
      print("Division:", division_result)


  • Floating-pointdata types for decimal numbers or in exponential notation, such as 3.14 or -0.01. Floating-point values are used for more precise numerical calculations.

      # Define float variables
      pi = 3.14159
      negative_value = -0.01234
      # Perform calculations involving float values
      circumference = 2 * pi * 5  # Calculate circumference of a circle with radius 5
      area = pi * 5 ** 2  # Calculate area of the circle with radius 5
      distance = 10.5 + 3.75  # Calculate the sum of distances
      # Print the results
      print("Circumference:", circumference)
      print("Area:", area)
      print("Distance:", distance)

    Floating-point variables represent π (pi) and negative decimal values, enabling precise calculations like circumference, area, and distance summation in scientific and engineering applications.


  • Complex numberdata type, consisting of a real and imaginary part.

      # Define a complex number
      z = 2 + 3j
      # Access the real and imaginary parts
      real_part = z.real  # 2.0
      imaginary_part = z.imag  # 3.0
      # Perform arithmetic operations
      addition = z + (1 + 1j)  # (3 + 4j)
      multiplication = z * (1 - 2j)  # (8 - 1j)
      # Conjugate of the complex number
      conjugate = z.conjugate()  # (2 - 3j)
      # Absolute value (magnitude) of the complex number
      magnitude = abs(z)  # 3.605551275463989
      print("Real Part:", real_part)
      print("Imaginary Part:", imaginary_part)
      print("Addition:", addition)
      print("Multiplication:", multiplication)
      print("Conjugate:", conjugate)
      print("Magnitude:", magnitude)

    A complex numberz has real and imaginary components, enabling fundamental arithmetic operations, accessing components, computing conjugates, and determining magnitude, showcasing their versatility in

    mathematical operations.


# Define boolean variables
is_sunny = True
is_raining = False

# Check conditions and perform operations based on boolean values
if is_sunny:
    print("It's a sunny day!")
    print("It's not sunny today.")

if not is_raining:
    print("No need for an umbrella.")
    print("Don't forget your umbrella!")

# Boolean operations
both_conditions = is_sunny and not is_raining  # True and True = True
either_condition = is_sunny or is_raining  # True or False = True

# Printing the results
print("Both Conditions:", both_conditions)
print("Either Condition:", either_condition)

Boolean variables is_sunny and is_raining represent sunny or rainy conditions, controlling program flow and demonstrating operations using operators. Boolean data types are essential for logical conditions and programming branching.

Sequence Types

  1. List: Mutable ordered collections of values.

  2. Tuple: Immutable ordered collections of values.

  3. Range: Represents an immutable sequence of numbers.

  4. String(str): String also belongs to this category, as it is a sequence of characters.

    String (str): String data type for sequences of characters.

  • Character sequences such as "Hello, ByteScrum!" or "Python Series" are represented. Text may be manipulated and concatenated using string data types.

  • Utilize string variables for greeting messages, language names, and text manipulation in programming scenarios. Demonstrate string concatenation, index access, substring extraction, string length, and conversion to uppercase and lowercase.

      # Define string variables
      greeting = "Welcome, ByteScrum!"
      language = "Python Series"
      # Concatenate strings
      message_output = greeting + "learning " + language +" is fun "
      # Welcome,ByteScrum learning Python Series is fun
      # Accessing characters by index
      first_char = greeting[0]  # 'W'
      second_char = greeting[6]  # 'e'
      # Slicing strings
      substring = language[0:3]  # 'Pyt'
      last_three_chars = greeting[-3:]  # 'um!'
      # Length of a string
      greeting_length = len(greeting)  # 19
      # Converting to uppercase and lowercase
      uppercase_greeting = greeting.upper()  # 'WELCOME, BYTESCRUM!'
      lowercase_language = language.lower()  # 'python series'
      # Printing the results
      print("Message Output:", message_output)
      print("First Character:", first_char)
      print("Second Character:", second_char)
      print("Substring:", substring)
      print("Last Three Characters:", last_three_chars)
      print("Length of Greeting:", greeting_length)
      print("Uppercase Greeting:", uppercase_greeting)
      print("Lowercase Language:", lowercase_language)

    List: Mutable ordered collections of values.

  • Lists are powerful data structures in Python that are commonly used for storing and manipulating ordered groups of objects.

  • We've created a list called numbers that contains numerous integer values. We show how to add an element, access elements by index, alter an element, remove an element by value, calculate the length of the list, verify the presence of a value in the list, and use a for loop to iterate over the list.

 # Define a list of numbers
 numbers = [1, 2, 3, 4, 5]

 # Add an element to the end of the list

 # Access elements by index
 second_number = numbers[1]  # 2

 # Modify an element
 numbers[3] = 10

 # Remove an element by value

 # Calculate the length of the list
 list_length = len(numbers)  # 5

 # Check if a value is in the list
 is_in_list = 5 in numbers  # True

 # Iterate through the list
 for num in numbers:

 # Printing the results
 print("Modified List:", numbers)
 print("Second Number:", second_number)
 print("List Length:", list_length)
 print("Is 5 in the List:", is_in_list)

Tuple: Immutable ordered collections of values.

Tuples are similar to lists, except they are immutable, which means that their elements cannot be changed after they are created. They are frequently employed when you want to ensure that the data remains constant during the execution of the application.

  • We've created a tuple called company that has information on a company's name, no_of_year, and experience. We demonstrate indexing tuple members, unpacking a tuple into independent variables, determining tuple length, and concatenating tuples.

      company = ("ByteScrum", 6, "Evolving Dynamics in IT Services")
      # Access elements by index
      name = company[0]  # "ByteScrum"
      no_of_years = company[1]   # 6
      experience = company[2] # "Evolving Dynamics in IT Services"
      # Unpack tuple into variables
      name, no_of_years, experience = company
      # Length of the tuple
      tuple_length = len(company)  # 3
      # Concatenate tuples
      services = ("WebServices", "MobileApps", "Blockchain")
      all_services = company + services  # ("ByteScrum", 6, "Evolving Dynamics in IT Services", "WebServices", "MobileApps", "Blockchain")
      # Printing the results
      print("Name:", name)
      print("No_Of_Years:", no_of_years)
      print("Experience:", experience)
      print("Tuple Length:", tuple_length)
      print("All Services:", all_services)

    Range: Represents an immutable sequence of numbers.

    The range data type is widely used to create numerical sequences, especially where memory economy is critical.

  • We've made a range of numbers ranging from 0 to 4 (exclusive). The range is then converted to a list for visualization reasons, and iteration across the range is demonstrated, computing the sum of numbers in the range, checking for the presence of a number in the range, and determining the length of the range.

      # Create a range of numbers
      numbers_range = range(5)  # Creates a range from 0 to 4
      # Convert the range to a list for visualization
      numbers_list = list(numbers_range)  # [0, 1, 2, 3, 4]
      # Iterate through the range
      for num in numbers_range:
      # Sum of numbers in the range
      sum_of_numbers = sum(numbers_range)  # 10
      # Check if a number is in the range
      is_in_range = 3 in numbers_range  # True
      # Length of the range
      range_length = len(numbers_range)  # 5
      # Printing the results
      print("Range as List:", numbers_list)
      print("Sum of Numbers:", sum_of_numbers)
      print("Is 3 in the Range:", is_in_range)
      print("Range Length:", range_length)

    Set Types

    • Set: Unordered collections of unique values.

    • Frozenset: Immutable version of a set

      Set: Unordered collections of unique values.

      Sets are used to hold collections of unique data, and they are especially effective for eliminating duplicates and performing set-related activities quickly.

    • In this case, we've created a collection called prime_numbers that contains unique prime numbers. We show how to add and remove items, verify the presence of a value in the set, calculate the set's length, execute set operations like intersection, and iterate through the set.

        # Define a set of unique numbers
        prime_numbers = {2, 3, 5, 7, 11}
        # Add an element to the set
        # Remove an element from the set
        # Check if a value is in the set
        is_in_set = 5 in prime_numbers  # True
        # Calculate the length of the set
        set_length = len(prime_numbers)  # 4
        # Perform set operations
        even_numbers = {2, 4, 6, 8, 10}
        intersection = prime_numbers & even_numbers  # {2}
        # Iterate through the set
        for num in prime_numbers:
        # Printing the results
        print("Is 5 in the Set:", is_in_set)
        print("Set Length:", set_length)
        print("Intersection:", intersection

      Frozenset: Immutable version of a set

    • Frozenset is used when you want a set-like collection of values that cannot be modified after creation, ensuring their integrity throughout your program's execution.

    • set named vegetables_set that contains various vegetables. We then use the frozenset() method to transform this set into a frozenset. The outcome is an immutable version of the original set called frozen_vegetables.

    • We demonstrate how to access frozenset items and check for the existence of specified vegetables. When you want a set-like collection of values that cannot be changed once they are created, frozenset is used to ensure their integrity during the execution of your application.

        # Define a regular set of vegetables
        vegetables_set = {"sweetcorn", "peas", "carrots"}
        # Convert the set to a frozenset
        frozen_vegetables = frozenset(vegetables_set)
        # Access elements in the frozenset (same as set)
        is_sweetcorn_in_frozen = "sweetcorn" in frozen_vegetables  # True
        is_carrots_in_frozen = "carrots" in frozen_vegetables  # True
        # Printing the results
        print("Is 'sweetcorn' in Frozen Set:", is_sweetcorn_in_frozen)
        print("Is 'carrots' in Frozen Set:", is_carrots_in_frozen)

      Mapping Type

      Dictionaries: Represents key-value pairs, also known as dictionaries.

    • A mapping type is a data type consisting of key-value pairs, allowing for organized and efficient storage and retrieval of data.

    • In Python, the primary mapping type is a dictionary, which represents structured data and configuration settings.

    • Key-Value Pairs: Keys are unique identifiers used to label and access their associated values, while values are the actual data associated with keys, ranging from integers to lists.

        # Define a dictionary of company information
        company_details = {
        "industry": "Information Technology",
        "founded_year": 2017,
        "employees": "10-50",
        "headquarters": "Lucknow, Uttar Pradesh"
        # Access values using keys
        company_name = company_details["name"]
        company_industry = company_details["industry"]
        founded_year = company_details["founded_year"]
        employee_count = company_details["employees"]
        headquarters_location = company_details["headquarters"]
        # Modify values
        company_details["employees"] = "11-50"
        # Add a new key-value pair
        company_details["website"] = ""
        # Check if a key is in the dictionary
        has_year_key = "founded_year" in company_details
        has_products_key = "products" in company_details
        # Printing the results
        print("Company Name:", company_name)
        print("Industry:", company_industry)
        print("Founded Year:", founded_year)
        print("Employee Count:", employee_count)
        print("Headquarters Location:", headquarters_location)
        print("Updated Company Details:", company_details)
        print("Has 'founded_year' Key:", has_year_key)
        print("Has 'products' Key:", has_products_key)
      • Binary Types

        • Bytes: Immutable sequences of bytes.

        • Bytearray: Mutable sequences of bytes.

        • Memoryview: Used for advanced memory manipulation.

Bytes: Immutable sequences of bytes

In Python, bytes are an immutable data type that represents a series of bytes. Bytes are used to store binary data such as photos, music, and other non-textual data. Because bytes are immutable, their values cannot be modified once they are created.

  • Example: Represents the ASCII-encoded bytes for "Hello"

      data = b'\x48\x65\x6c\x6c\x6f'  # Represents the ASCII-encoded bytes for "Hello"

    Bytearray: Mutable sequences of bytes.

  • Bytearrays are similar to bytes, except they may be changed. This means that the values of individual bytes inside a bytearray can be changed. It is frequently used when binary data must be manipulated in situ, such as when decoding or encoding protocols.

  • Example: Represents the ASCII-encoded bytes for "Hello"

      data = bytearray(b'\x48\x65\x6c\x6c\x6f')
      data[0] = 0x58  # Changes the first byte to represent "X"

    Memoryview: Used for advanced memory manipulation

  • Memoryview is a built-in Python class that allows you to expose an object's buffer interface. It enables you to access an object's internal buffer (such as bytes, bytearray, or other array-like objects) without duplicating its content. This is beneficial for doing memory-efficient operations on huge data collections.

  • Example: Represents the ASCII-encoded bytes for "Hello"

      data = bytearray(b'\x48\x65\x6c\x6c\x6f')
      mem_view = memoryview(data)
      mem_view[1] = 0x75  # Changes the second byte to represent "u"
    bytes, bytearray, and memoryview are required for dealing with binary data and duties such as parsing file formats, processing network packets, and handling other low-level data operations.

    Note: While bytes and bytearray are routinely used, memoryview is more sophisticated and ideal for circumstances where direct access to memory buffers is required.

    None Type

    • NoneType: Represents the absence of a value or a null value.

    • NoneType is a data type in Python that represents the absence of a value or a null value.

    • It's frequently used to signify that a variable or expression, has no relevant data. In other words, assigning the value None to a variable indicates that the variable is not linked to any legitimate object or data.

    • None is commonly used to initialize variables before assigning a real value to them or as a return value for functions that do not explicitly return anything.

            #define a function that doesn't return any value
            def print_greeting(name):
            print(f"Welcome, {name}!")

            #call the function
            result = print _greeting("ByteScrum")

            # the result value is None since the function doesn't have a return statment
            print("Result:", result) #Output: Result: None
            # Assign a variable the value  None to indicate absence of a value
            no_data = None
            #Check if a variable has a value or is None
            if no_data is None:
            print("variable has no data")
            print("Variable has data")

The print_greeting function lacks a return statement, it returns None and the variable no_data is assigned None to indicate absence. The is None check determines if a variable holds the value None.

Python is a versatile programming language that excels in handling data, thanks to its wide range of data types and its organized categorization. These categories include numeric, text, boolean, sequence, set, mapping, binary, and None types. Numeric types handle integers, floats, and complex numbers, while text types enable textual manipulation. Boolean types navigate logic and control flow, while sequence types organize ordered collections. Set types organize unique elements, mapping types for key-value pairs, binary types handle raw data, and None types mark variables devoid of meaningful data. Python's data type categorization helps developers express ideas, build solutions, and manipulate data with finesse and precision.

Stay tuned for upcoming blogs in our Python Series. Subscribe to our updates and share the knowledge with fellow enthusiasts. Explore the depths of Python's data types and harness their power for your programming endeavors.