Type Casting in Python

Type casting, or type conversion, is an essential concept in Python programming that allows you to convert one data type to another. This process is useful when you need to perform operations that require a specific data type. In this blog post, we'll explore the different methods of type casting in Python with practical examples to illustrate their use.

 

What is Type Casting?

Type casting is the process of converting a variable from one data type to another. Python provides built-in functions for type casting, which can be categorized into two types:

1. Implicit Casting: Python automatically converts one data type to another.
2. Explicit Casting: The programmer manually converts one data type to another using built-in functions.

 

Implicit Type Casting

Python automatically converts smaller data types to larger data types to prevent data loss. This is known as implicit type casting or coercion.

Example:

# Implicit type casting

num_int = 10

num_float = 3.5

 

# num_int is implicitly converted to float for addition

result = num_int + num_float

print(result)       # Output: 13.5

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

In the above example, num_int is an integer, and num_float is a float. When they are added together, Python automatically converts the integer to a float to perform the operation, resulting in a float.

 

Explicit Type Casting

Explicit type casting requires the use of built-in functions to convert data types. The commonly used functions are:

• int(): Converts a value to an integer.
• float(): Converts a value to a float.
• str(): Converts a value to a string.
• bool(): Converts a value to a boolean.

Converting to Integer (int)

Example:

# Convert float to int

num_float = 3.14

num_int = int(num_float)

print(num_int)       # Output: 3

print(type(num_int)) # Output: <class 'int'>

 

# Convert string to int

num_str = "100"

num_int = int(num_str)

print(num_int)       # Output: 100

print(type(num_int)) # Output: <class 'int'>

 

 

Converting to Float (float)

Example:

# Convert int to float

num_int = 10

num_float = float(num_int)

print(num_float)       # Output: 10.0

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

 

# Convert string to float

num_str = "3.14"

num_float = float(num_str)

print(num_float)       # Output: 3.14

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

 

 

Converting to String (str)

Example:

# Convert int to string

num_int = 10

num_str = str(num_int)

print(num_str)       # Output: "10"

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

 

# Convert float to string

num_float = 3.14

num_str = str(num_float)

print(num_str)       # Output: "3.14"

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

 

 

Converting to Boolean (bool)

Example:

# Convert int to bool

num_int = 1

bool_val = bool(num_int)

print(bool_val)       # Output: True

print(type(bool_val)) # Output: <class 'bool'>

 

# Convert string to bool

str_val = ""

bool_val = bool(str_val)

print(bool_val)       # Output: False

print(type(bool_val)) # Output: <class 'bool'>

 

 

Complex Type Conversions

Python also supports converting more complex data types, such as lists, tuples, sets, and dictionaries.

Converting Between Lists, Tuples, and Sets

Example:

# Convert list to tuple

list_val = [1, 2, 3]

tuple_val = tuple(list_val)

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

print(type(tuple_val)) # Output: <class 'tuple'>

 

# Convert tuple to list

tuple_val = (4, 5, 6)

list_val = list(tuple_val)

print(list_val)       # Output: [4, 5, 6]

print(type(list_val)) # Output: <class 'list'>

 

# Convert list to set

list_val = [1, 2, 3, 1]

set_val = set(list_val)

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

print(type(set_val)) # Output: <class 'set'>

 

 

Converting Between Dictionaries and Lists

Example:

# Convert dictionary keys to list

dict_val = {"a": 1, "b": 2, "c": 3}

keys_list = list(dict_val.keys())

print(keys_list)       # Output: ['a', 'b', 'c']

print(type(keys_list)) # Output: <class 'list'>

 

# Convert dictionary values to list

values_list = list(dict_val.values())

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

print(type(values_list)) # Output: <class 'list'>

 

Final Remarks

Type casting is a powerful feature in Python that allows you to convert variables from one data type to another, enabling more flexible and efficient programming. By mastering both implicit and explicit type casting, you can ensure your Python code handles data effectively and avoids type-related errors.