The Python Journey – Chapter IV  Type Casting

Type casting in Python refers to the process of converting one data type into another. Python is a dynamically typed language, which means it automatically assigns data types during execution based on the values. However, there are situations where it becomes necessary to convert data types manually to ensure compatibility between operations or data structures. This process can be performed explicitly by the programmer or implicitly by Python. In the previous Chapter we learned how Python conditionals work. In this article, we will explore Python type casting in depth, including its types, methods, and common use cases, with examples to help solidify the concept.

Table of Contents

Chapter IV  Type Casting.

What is Type Casting?.

Implicit Type Conversion.

Explicit Type Conversion (Type Casting)

Type Casting Pitfalls.

Practical Use Cases of Type Casting.

Real-World Examples of Python Type Casting.

What is Type Casting?

Type casting is the act of converting a variable from one data type to another. Python provides built-in functions to perform explicit type casting, allowing the programmer to have control over how and when conversions happen. There are also cases where Python performs implicit type conversion without the programmer’s intervention.

• Implicit Type Conversion: Python automatically converts one data type to another when needed.
• Explicit Type Conversion: The programmer explicitly converts a value from one type to another using built-in functions.

Implicit Type Conversion

Python automatically performs implicit type conversion when it encounters an expression that involves two different data types but can be safely combined. In such cases, Python converts the smaller data type to a larger data type to avoid data loss.

Example:

x = 10        # Integer

y = 3.5       # Float

result = x + y  # Integer (x) is implicitly converted to float

print(result)   # Output: 13.5

print(type(result))  # Output: <class 'float'>

In this example, Python implicitly converts the integer x to a float before performing the addition. This ensures that the result is a float, preserving the decimal precision.

Key Points of Implicit Conversion:

• Python promotes smaller data types to larger data types (e.g., int to float).
• No explicit conversion functions are needed.
• Data integrity is preserved during conversion.

However, implicit conversions may sometimes result in unexpected behaviors when mixing types. In such cases, explicit type casting is necessary.

Explicit Type Conversion (Type Casting)

Explicit type casting occurs when the programmer manually converts a variable from one data type to another using Python’s built-in functions. These include:

• int() – Converts a value to an integer.
• float() – Converts a value to a floating-point number.
• str() – Converts a value to a string.
• list() – Converts a value to a list.
• tuple() – Converts a value to a tuple.
• set() – Converts a value to a set.
• dict() – Converts a value to a dictionary.

Converting to Integer (int())

The int() function is used to convert a value to an integer. It works with floats (by truncating the decimal part) and strings (if the string represents a valid integer).

Example:

# Converting float to integer

x = 5.8

y = int(x)

print(y)  # Output: 5

# Converting string to integer

num_str = "123"

num_int = int(num_str)

print(num_int)  # Output: 123

# Attempting to convert an invalid string

invalid_str = "abc"

# int(invalid_str)  # This will raise a ValueError because "abc" is not a valid integer

In the first example, the float 5.8 is converted to the integer 5, with the decimal portion truncated. In the second example, the string “123” is successfully converted to the integer 123. However, trying to convert an invalid string like “abc” will raise a ValueError.

 Converting to Float (float())

The float() function converts integers and strings to floating-point numbers.

Example:

# Converting integer to float

x = 10

y = float(x)

print(y)  # Output: 10.0

# Converting string to float

num_str = "45.67"

num_float = float(num_str)

print(num_float)  # Output: 45.67

In this example, the integer 10 is converted to the floating-point number 10.0, and the string “45.67” is successfully converted to 45.67 as a float.

Converting to String (str())

The str() function converts different data types like integers, floats, and booleans to strings.

Example:

# Converting integer to string

x = 100

y = str(x)

print(y)  # Output: '100'

print(type(y))  # Output: <class 'str'>

# Converting float to string

z = 3.14

z_str = str(z)

print(z_str)  # Output: '3.14'

Here, the integer 100 is converted to the string ‘100’, and the float 3.14 is converted to the string ‘3.14’. These are useful when concatenating numbers with strings for display purposes.

Converting to List (list())

The list() function converts an iterable, such as a string or tuple, into a list.

Example:

# Converting string to list

s = "hello"

s_list = list(s)

print(s_list)  # Output: ['h', 'e', 'l', 'l', 'o']

# Converting tuple to list

t = (1, 2, 3)

t_list = list(t)

print(t_list)  # Output: [1, 2, 3]

The string “hello” is converted into a list of individual characters, and the tuple (1, 2, 3) is converted into a list [1, 2, 3].

Converting to Tuple (tuple())

The tuple() function converts an iterable, such as a list or string, into a tuple.

Example:

# Converting list to tuple

lst = [1, 2, 3]

lst_tuple = tuple(lst)

print(lst_tuple)  # Output: (1, 2, 3)

# Converting string to tuple

s = "abc"

s_tuple = tuple(s)

print(s_tuple)  # Output: ('a', 'b', 'c')

In this example, a list [1, 2, 3] is converted into a tuple (1, 2, 3), and the string “abc” is converted into a tuple (‘a’, ‘b’, ‘c’).

Converting to Set (set())

The set() function converts an iterable into a set, which is an unordered collection of unique elements.

Example:

# Converting list to set

lst = [1, 2, 2, 3, 3]

lst_set = set(lst)

print(lst_set)  # Output: {1, 2, 3}

# Converting string to set

s = "banana"

s_set = set(s)

print(s_set)  # Output: {'b', 'n', 'a'}

In the first case, duplicate elements in the list are removed when converting to a set. In the second example, the string “banana” is converted to a set of unique characters.

Converting to Dictionary (dict())

The dict() function is used to convert certain types of data, like a list of key-value pairs or tuples, into a dictionary.

Example:

# Converting list of tuples to dictionary

pairs = [("name", "Alice"), ("age", 25), ("city", "New York")]

d = dict(pairs)

print(d)  # Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Here, a list of tuples is converted into a dictionary where the first element of each tuple serves as a key, and the second element serves as the value.

---

Type Casting Pitfalls

While type casting is a powerful tool, improper use or assumptions about valid conversions can lead to errors. For instance, trying to convert an invalid string to an integer or float will raise a ValueError.

Example:

# Invalid conversion

invalid_str = "abc"

try:

    num = int(invalid_str)

except ValueError:

    print("Cannot convert 'abc' to an integer.")

Here, the ValueError is caught and handled using a try-except block to prevent the program from crashing.

---

Practical Use Cases of Type Casting

Type casting is commonly used when:

• Handling user input: User input is typically read as a string, so you often need to convert it to another data type (e.g., integer or float) for numerical calculations.

age = input("Enter your age: ")  # input returns a string

age = int(age)  # Convert the string to an integer

print("You will be", age + 1, "years old next year.")

• Working with mixed data types: In expressions involving multiple data types, you may need to cast values to ensure compatibility.

x = 10

y = "20"

result = x + int(y)  # Convert string to integer

print(result)  # Output: 30

Python type casting allows you to convert data from one type to another, whether automatically (implicit type conversion) or manually (explicit type conversion). Understanding how and when to apply type casting is essential for handling data correctly, avoiding errors, and ensuring compatibility in operations.

Real-World Examples of Python Type Casting

Type casting in Python refers to converting one data type into another. It’s often required when different types of data need to interact, or when we want to ensure a specific type for certain operations. Below are some real-world scenarios where Python type casting is useful:

---

1. User Input Conversion in a Banking Application

When building a banking or financial application, user inputs are usually accepted as strings (default behavior in Python). However, numerical inputs (e.g., for transactions, account balance, etc.) must be processed as integers or floats. Type casting ensures correct data types for mathematical operations.

Example:

# User input for deposit amount

deposit_amount = input("Enter the deposit amount: ")  # input() returns a string

# Convert to float for precise financial calculations

deposit_amount = float(deposit_amount)

# Updating account balance

current_balance = 1000.75  # existing balance as a float

new_balance = current_balance + deposit_amount

print(f"Updated Balance: {new_balance}")

In this example, the user input needs to be cast to float for accurate balance calculations.

---

2. Data Processing in a CSV File for Sales Data

When working with CSV files (e.g., sales reports), all data is often read as strings by default. If you want to compute total sales or average values, type casting is required to convert these string values into integers or floats.

Example:

import csv

# Reading data from a CSV file

with open('sales_data.csv', mode='r') as file:

    csv_reader = csv.reader(file)

    total_sales = 0

    # Loop through rows (ignoring header)

    for row in list(csv_reader)[1:]:

        sale_value = row[2]  # assuming sale value is in the third column

        # Convert sale value from string to float

        total_sales += float(sale_value)

print(f"Total Sales: {total_sales}")

Here, sales data is cast from string to float to calculate the total sales.

---

3. Sensor Data in IoT Systems

In IoT (Internet of Things) applications, sensors often transmit data as strings, which need to be converted into integers or floats for calculations like average temperature, humidity, or speed.

Example:

# Simulated sensor data

sensor_data = "72.5"  # temperature in Celsius as a string

# Convert to float for accurate mathematical operations

temperature = float(sensor_data)

# Check if the temperature exceeds a threshold

if temperature > 70:

    print("Warning: Temperature too high!")

In this example, casting the sensor data from str to float allows performing comparisons and logical operations.

---

4. Combining Different Data Types in E-commerce

In an e-commerce website, when calculating the total price of items in a shopping cart, you might encounter quantities stored as integers and prices stored as strings. Type casting is needed to ensure that both data types are compatible for multiplication.

Example:

item_price = "29.99"  # price as a string from a database

quantity = 3  # quantity as an integer

# Convert price to float and calculate total cost

total_cost = float(item_price) * quantity

print(f"Total cost: {total_cost}")

Here, casting the price from str to float is necessary to calculate the total cost accurately.

---

5. API Data Parsing in a Weather Application

When fetching data from APIs, numeric values (such as temperatures, humidity, etc.) might be returned as strings. If you want to perform calculations like the difference between current and previous temperatures, type casting is essential.

Example:

# Simulated API response with temperature as a string

api_response = {

    "city": "New York",

    "temperature": "85.3",  # temperature in Fahrenheit as a string

}

# Convert temperature from string to float for further processing

temperature = float(api_response["temperature"])

# Convert Fahrenheit to Celsius

celsius_temperature = (temperature - 32) * 5/9

print(f"Temperature in Celsius: {celsius_temperature:.2f}")

In this scenario, casting the temperature from str to float is required to convert and work with numerical data.

---

Type casting is a crucial aspect of real-world Python programming. It ensures that data is in the correct format for operations like mathematical computations, comparisons, and logical processing. Whether you’re handling user inputs, parsing API data, or processing files, type casting plays an important role in maintaining the correctness and efficiency of applications.

To Sum up:

• Implicit vs. Explicit Conversion: Python automatically converts types where possible but requires explicit casting in some situations.

In the next chapter we would have a look at exceptions and exception handling in python

Good reads

The Python Journey – Chapter III Python Conditionals