codeIn [Spark]

Python – Type Casting #

1. Introduction to Type Casting #

Type casting is the process of converting one data type into another. In Python, you may need to convert between types when performing operations on different data types or when specific types are required for functions. Python supports both implicit and explicit type casting.

Types of Type Casting in Python #

• Implicit Type Casting: Automatically done by Python without user intervention.
• Explicit Type Casting: Performed manually by the programmer using predefined functions.

---

2. Implicit Type Casting #

In implicit type casting, Python automatically converts one data type to another. This happens when data types are compatible, and Python handles the conversion to avoid data loss or errors.

Example of Implicit Type Casting #

# Implicit Type Casting Example

num_int = 10   # Integer type
num_float = 2.5  # Float type

# Adding integer and float
result = num_int + num_float

print(f"Result: {result}")  # Output: 12.5
print(f"Type of result: {type(result)}")  # Output: <class 'float'>

Explanation:

• num_int is an integer, and num_float is a float.
• Python automatically converts the integer 10 to float 10.0 before performing the addition to prevent data loss.

---

3. Explicit Type Casting #

In explicit type casting, the programmer manually converts one data type into another using Python’s built-in functions. It is necessary when you need more control over the conversions, especially when implicit conversion isn’t possible.

Common Functions for Type Casting in Python: #

• int(): Converts a value to an integer.
• float(): Converts a value to a float.
• str(): Converts a value to a string.
• list(): Converts an iterable (e.g., tuple, string) to a list.
• tuple(): Converts an iterable (e.g., list, string) to a tuple.
• set(): Converts an iterable (e.g., list, string) to a set.

---

3.1. Converting to Integer #

Syntax: #

int(value)

Example: #

# Converting float to integer
num_float = 10.75
num_int = int(num_float)

print(f"Integer value: {num_int}")  # Output: 10
print(f"Type: {type(num_int)}")     # Output: <class 'int'>

Explanation:

• The int() function truncates the decimal part of the float and returns only the integer part.

---

3.2. Converting to Float #

Syntax: #

float(value)

Example: #

# Converting integer to float
num_int = 7
num_float = float(num_int)

print(f"Float value: {num_float}")  # Output: 7.0
print(f"Type: {type(num_float)}")    # Output: <class 'float'>

Explanation:

• The float() function adds a decimal point to the integer value.

---

3.3. Converting to String #

Syntax: #

str(value)

Example: #

# Converting number to string
num_int = 100
num_str = str(num_int)

print(f"String value: {num_str}")  # Output: "100"
print(f"Type: {type(num_str)}")    # Output: <class 'str'>

Explanation:

• The str() function converts numbers (or any data type) into their string representation.

---

3.4. Converting to List #

Syntax: #

list(iterable)

Example: #

# Converting string to list
string = "hello"
string_list = list(string)

print(f"List: {string_list}")  # Output: ['h', 'e', 'l', 'l', 'o']
print(f"Type: {type(string_list)}")  # Output: <class 'list'>

Explanation:

• The list() function converts the iterable (in this case, a string) into a list of its characters.

---

3.5. Converting to Tuple #

Syntax: #

tuple(iterable)

Example: #

# Converting list to tuple
list_data = [1, 2, 3, 4]
tuple_data = tuple(list_data)

print(f"Tuple: {tuple_data}")  # Output: (1, 2, 3, 4)
print(f"Type: {type(tuple_data)}")  # Output: <class 'tuple'>

Explanation:

• The tuple() function converts a list into a tuple, maintaining the same data structure but with immutable properties.

---

3.6. Converting to Set #

Syntax: #

set(iterable)

Example: #

# Converting list to set
list_data = [1, 2, 3, 4, 1, 2]
set_data = set(list_data)

print(f"Set: {set_data}")  # Output: {1, 2, 3, 4}
print(f"Type: {type(set_data)}")  # Output: <class 'set'>

Explanation:

• The set() function converts a list into a set, automatically removing duplicate elements and unordered.

---

4. Complex Type Conversions #

4.1. Converting String to Integer or Float #

If you have a number in string format, you can convert it into an integer or float using int() or float(). The string must represent a valid number; otherwise, Python will raise an error.

Example: #

# Converting string to integer and float
str_num = "42"
num_int = int(str_num)
num_float = float(str_num)

print(f"Integer: {num_int}, Float: {num_float}")
# Output: Integer: 42, Float: 42.0

Note: If the string contains non-numeric characters, it will raise a ValueError.

# Invalid conversion will raise an error
str_num = "42a"
num_int = int(str_num)  # This will raise a ValueError

4.2. Converting List of Strings to Integers #

# Converting list of strings to integers
str_list = ['1', '2', '3', '4']
int_list = [int(i) for i in str_list]

print(f"Integer List: {int_list}")  # Output: [1, 2, 3, 4]

---

5. Handling Invalid Conversions #

While type casting, it’s important to ensure that the value can actually be converted to the desired type. If invalid data is provided, Python will raise an error. Handling these cases using try–except blocks can prevent the program from crashing.

Example of Error Handling: #

# Handling invalid conversions
str_num = "abc"

try:
    num_int = int(str_num)
except ValueError:
    print(f"Cannot convert {str_num} to integer")

---

6. Conclusion #

Python’s type casting allows developers to control how data types are converted, ensuring compatibility between operations and avoiding runtime errors. While implicit conversions are handled by Python automatically, explicit conversions give the programmer control and flexibility.