Type Conversion In Python | Implicit & Explicit Types (+Examples)

Type conversion in the Python programming language, also known as data type conversion, is a fundamental concept where one data type is converted into another. It is crucial for various operations and data manipulations in your programs, enabling developers to work effectively with different types of data. In this comprehensive tutorial, we will delve into the intricacies of type conversion in Python, exploring the various techniques, functions, and best practices associated with converting data between different types.

What Is Type Conversion In Python?

As discussed above, type conversion in Python refers to the process of changing the data type of a variable from one type to another. These can be implicit type conversions, i.e., those that are implicitly done by Python interpreter itself, or explicit type conversions, where we externally use functions/ methods to convert the data type.

Type conversion is usually done either to ensure that operations between different data types are performed correctly or to adapt data for specific functions and computations.

General Example: Oranges To Juice

The process of type conversion can be likened to converting oranges to juice. Imagine we have whole oranges, which represent one data type. To make juice, we need to process these oranges, transforming them into a different form—juice, analogous to another data type.

Similarly, in Python, we often need to convert data from one type to another to fit the requirements of our code. This is what type conversion in Python and other programming languages broadly entails.

• For instance, we might convert a string representation of a number into an integer to perform arithmetic operations.
• Just as squeezing oranges transforms them into juice, type conversion functions like int(), float(), or str(), transform data into the types we need for our operations.

Let's look at a simple Python program example illustrating type conversion, both implicit and explicit.

Code:

Output:

datatype of int_num: <class 'int'>
datatype of flo_num: <class 'float'>
Value of new_num: 1003.14
datatype of new_num: <class 'float'>
Value of new_num after explicit conversion: 1003
datatype of new_num after explicit conversion: <class 'int'>

Explanation:

In the above Python example,

1. We start by defining two variables: integer data type variable int_num with a value of 1000 and flo_num with a floating-point value of 3.14.
2. Next, when we add these two variables together, Python performs implicit type conversion, automatically converting the integer int_num into a float so that the addition operation can be performed with both numbers as floats.
3. We store the result of this addition in the variable new_num.
4. Next, we print the data types of initial variables- int_num and flo_num to show that they are integer and float, respectively.
5. After that, we print the value and data type of new_num, which is the sum of int_num and flo_num, resulting in 1003.14 and data type float.
6. Next, we use the int() function to explicitly convert new_num from a float to an integer, which truncates the decimal part, resulting in 1003.
7. Finally, we again print the value and data type of new_num, which is 1003 and int.

Types Of Type Conversion In Python

Type conversion in Python can be categorized into two main types:

1. Implicit Type Conversion
2. Explicit Type Conversion

In the sections ahead, we will discuss the types of type conversion in Python in detail, along with code illustrations.

Implicit Type Conversion In Python

Implicit type conversion, also known as automatic type conversion, occurs when Python automatically changes the data type of a variable during operations to maintain consistency and prevent errors. This type of conversion happens without requiring any explicit instructions from us. For example, if we perform arithmetic operations involving distinct data types, Python will convert the lower precision type to a higher precision type to ensure accurate results.

Key Characteristics Of Implicit Type Conversion In Python:

1. Automatic: Performed by the Python interpreter automatically.
2. No Programmer Input: This does not require explicit commands from the programmer.
3. Type Promotion: Usually promotes to a higher or more inclusive data type.

Example 1: Implicit Conversion From Int To Float

In this code example, we will implicitly convert an integer (Int) to a float (Float).

Code:

Output:

Result: 8.5
Data type of result: <class 'float'>

Explanation:

In the above Python code,

1. We start by assigning the integer value 5 to the variable num_int and the floating-point value 3.5 to the variable num_float.
2. Next, when we add these two variables together, Python automatically performs implicit type conversion, converting the integer num_int into a float so that both numbers are the same type for the addition operation.
3. We then store the outcome of this addition in the variable result and print it to get the value as 8.5.
4. Finally, we use the type() function to display the data type of the result, confirming that it is a floating-point value.

Example 2: Implicit Conversion In Arithmetic Operations

In this code example, we will perform the implicit conversion in arithmetic operations.

Code: 

Output:

Result: 14.25
Data type of result: <class 'float'>

Explanation:

In the above Python code,

1. We begin by defining two variables: float_val with a value of 4.75, and int_val with a value of 3.
2. When we multiply them using the multiplication operator (*), Python automatically converts the integer to a float so that the arithmetic operation can be performed with both numbers as floating-point values.
3. We then store the outcome of this multiplication in the variable result and print its value using the print() function.
4. Finally, we use the type() function to show that the data type of result is a float, which confirms that the implicit type conversion occurred during the multiplication.

Explicit Type Conversion In Python

Explicit type conversion, also known as type casting, requires us to manually convert one data type to another using specific functions or operators. This type of conversion gives us control over how and when the data type change occurs. We use functions like int(), float(), str(), and list() to perform explicit type conversion in Python.

Key Characteristics Of Explicit Type Conversion In Python:

1. Manual: Performed by the programmer using specific commands.
2. Requires Instructions: Needs explicit commands to perform the conversion.
3. Specified Type: Converts data to a specific target data type.

Here is a code example to illustrate explicit type conversion in Python.

Code:

Output:

Converted Integer: 3
Data type of converted integer: <class 'int'>

Explanation:

In the above Python code,

1. We start by defining a variable, num_float, with a float value of 3.75.
2. To convert this float to an integer, we use the int() function, which explicitly changes the float to an integer, and we store this converted value in the variable num_int.
3. Then, we print the value of num_int, which will be 3 because the int() function truncates the decimal part, leaving only the whole number.
4. Finally, we use the type() function to check and display that num_int is of type int, confirming that the explicit type conversion from float to int was successful.

Functions Used For Explicit Data Type Conversion In Python

As mentioned before, we use various functions/ built-in methods to carry out explicit type conversion in Python programs. Below is a table that lists common Python functions used for explicit type conversion:

We will now cover each of these functions used for explicit type conversion in Python in detail with code examples.

Type Conversion In Python With int() Function

The int() function is often used for type conversion in Python as it converts a given value to the integer data type. It returns the integer representation of the input parameter.

Syntax:

int(a, base)

Here,

• a: The number or string to be converted.
• base: An integer representing the base of the number in string form (default is 10).

Code:

Output:

10
10
10

Explanation:

In the above Python code,

1. We start by defining a variable binary_string with the value "1010".
2. Then, we use the int() function to convert this binary string to an integer, with the second argument as 2, indicating the base is binary. We store this converted value in binary_int.
3. Next, we define octal_string with the value "12". Then, using the int() function, we convert this octal string to an integer, with 8 (octal base) as the second argument. We store this converted value in octal_int.
4. Similarly, we define hex_string with the value "A" and use the int() function to convert this hexadecimal string to an integer.
5. Here, the second argument, 16, indicates that the base is hexadecimal, and we store this converted value in hex_int.
6. Finally, we print the values of binary_int, octal_int, and hex_int. All three will output 10 because the binary "1010", octal "12", and hexadecimal "A" all represent the decimal number 10.

Type Conversion In Python With float() Function

The float() function performs type conversion in Python by converting the input value to a floating-point type. It accepts a single parameter, which can be a number or a string representing a numerical value, and returns the corresponding floating-point representation.

Syntax:

float(value)

Here, the value is the number/ data to be converted to a floating-point number. It can be an integer, a floating-point number, or a string representing a numeric value.

Code:

Output:

123.0
123.45

Explanation:

In the above Python code,

1. We start by defining a variable integer_number with an integer value of 123. We also define another variable, string_number, with a string value of "123.45".
2. Then, we use the float() function to convert the integer to a float and store the result in the variable float_from_int.
3. Similarly, we convert the string to a float using the float() function and store the result in the variable float_from_str.
4. Finally, we print the values of float_from_int and float_from_str using the print() function.

Type Conversion In Python With ord() Function

The ord() function performs type conversion in Python by converting a single character into its Unicode code point, which is an integer representation of that character.

Syntax:

ord(char1)

Here,

• ord: The name of the function being called.
• char1: The parameter passed to the function.

Code:

Output:

65
98

Explanation:

In the above Python code, 

1. We define two variables, char_a and char_b, with the character values 'A' and 'b', respectively.
2. Then, we convert these characters to their corresponding ASCII values by using the ord() function.
3. We store the ASCII value of char_a in the variable ascii_a and the ASCII value of char_b in the variable ascii_b.
4. Finally, we print the values of ascii_a and ascii_b.

Type Conversion In Python With hex() Function

The hex() function performs type conversion in Python by converting an integer number to a lowercase hexadecimal string prefixed with "0x". 

Syntax:

hex(number)

Here,

• number: An integer number to be converted to hexadecimal.
• hex: The hex() function in Python is used to convert an integer number to a lowercase hexadecimal string prefixed with "0x".

Code:

Output:

Hexadecimal representation of 42 : 0x2a
Hexadecimal representation of 3.14 : 0x3
Hexadecimal representation of 10 : 0xa

Explanation:

In the above Python code,

1. We start by defining three variables: num_int with an integer value of 42, num_float with a float value of 3.14, and num_str with a string value of "10".
2. Then, we convert these values to hexadecimal strings using the hex() function.
3. For num_int, we directly pass it to the hex() function and store the result in hex_int.
4. For num_float, we first convert it to an integer using the int() function and then the hex() function to convert it to a hexadecimal string, storing the result in hex_float.
5. Similarly, for num_str, we first convert the string to an integer using the int() function and then convert it to a hexadecimal string, storing the result in hex_str.
6. Finally, we print the hexadecimal representations of num_int, num_float, and num_str. 

Type Conversion In Python With oct() Function

The oct() function performs type conversion in Python by converting an integer number into an octal string representation. It takes an integer as a parameter and returns the corresponding octal string. The function returns a string representing the octal value of the input integer.

Syntax:

oct(number)

Here,

• oct: The oct() function returns a string representing the octal value of the input integer.
• number: An integer that needs to be converted into an octal string.

Code:

Output:

0o10

Explanation:

In the above Python code,

1. We start by defining a variable decimal_number with an integer value of 8.
2. Then, we convert this decimal number to its octal representation using the oct() function and store the result in the variable oct_number.
3. Finally, we print the value of oct_number. 

Type Conversion In Python With tuple() Function

The tuple() function is primarily used for converting a sequence (such as a list, string, or range) into a tuple. It takes a single parameter, which is the sequence to be converted, and returns a tuple containing the elements of the sequence.

Syntax:

tuple(iterable)

Here,

• tuple: The tuple() function in Python is used to convert a sequence (such as a list, string, or range) into a tuple.
• iterable: The sequence (such as a list, string, or range) that will be converted into a tuple.

Code:

Output:

Converted Tuple: (10, 3.14, 'Hello', [1, 2, 3], (4, 5, 6))
Type of converted_tuple: <class 'tuple'>

Explanation:

In the above Python code,

1. We start by defining variables of different types: int_var with an integer value of 10, float_var with a float value of 3.14, str_var with a string value of "Hello", list_var with a list of integers [1, 2, 3], and tuple_var with a tuple of integers (4, 5, 6).
2. Next, we use the tuple() function to convert these variables into a tuple. We pass a list containing all these variables as an argument to tuple(), effectively converting them into a single tuple.
3. We store the resulting tuple in the variable converted_tuple.
4. Finally, we print the value of converted_tuple to see the combined tuple, which will include all the different variables.
5. We also print the type of converted_tuple using the type() function to confirm that it is indeed a tuple.

Type Conversion In Python With set() Function

The set() function is generally used for type conversion in Python as it creates a set data structure. Sets are unordered collections of unique elements. It takes an iterable (such as a list, tuple, string, etc.) as input and returns a set containing the unique elements from the iterable. If no iterable is provided, an empty set is returned. 

Syntax:

set(iterable)

Here,

• set: The name of the function.
• iterable: The parameter that specifies the iterable object from which the set will be created.

Code:

Output:

{1, 2, 3}

Explanation:

In the above Python code,

1. We start by defining a variable list_value with a list of integers: [1, 2, 2, 3].
2. To convert this list into a set, we use the set() function and store the result in the variable set_value.
3. The set() function removes duplicate values and only keeps unique elements.
4. Finally, we print the value of set_value.

Type Conversion In Python With list() Function

The list() function in python is primarily used to convert other iterable data types, such as tuples or strings, into a list. It takes a single parameter, which can be any iterable object, and returns a new list containing the elements of that iterable.

Syntax:

list(iterable)

Here,

• list: This is the name of the function being called. In Python, list() is a built-in function used to convert iterable objects into lists.
• iterable: This is the parameter that the list() function takes. It represents the object that you want to convert into a list. It must be an iterable object, such as a string, tuple, or another list.

Code:

Output:

Converted list 1: [10]
Converted list 2: [20]
Converted list 3: [30, 40, 50]
Converted list 4: [60, 70, 80]

Explanation:

In the above Python code,

1. We start by defining four variables of different types: variable1 with an integer value of 10, variable2 with a string value of "20", variable3 with a list of integers [30, 40, 50], and variable4 with a tuple of integers (60, 70, 80).
2. Then we use the list() function in combination with some other function to convert these variables into lists of integers, as follows:
   • We convert variable1 to a list using list literals and store the outcome in variable converted_list1.
   • Using the int() function with list literals, we convert variable2 from string to list and store the outcome in converted_list2.
   • Then, we use the list() function with map() function to convert variables- variable3 and variable4 to Python lists. The outcomes are stored in converted_list3 and converted_list4, respectively.
   • Here, the int() function first converts each element of the tuple to an integer, and then the map() function converts the resulting map object to a list.
3. Finally, we print the values of converted_list1, converted_list2, converted_list3, and converted_list4.

Also Read: How To Convert Python List To String? 8 Ways Explained (+Examples)

Type Conversion In Python With str() Function

The str() function in Python converts the specified value into a string. It takes any data type as input and returns a string representation of that value.

Syntax:

str(value)

Here,

• str: The str() function returns the string representation of the input value.
• value (mandatory): This parameter specifies the value that you want to convert into a string.

Code:

Output:

123

Explanation:

In the above Python code, 

1. We start by defining a variable integer_number containing the integer value 123.
2. Next, we use the str() function to convert the integer value integer_number into a string and store it in the variable string_value.
3. Finally, we use the print() function to display the value of string_value, confirming that the integer value has been converted to a string.

Type Conversion In Python With dict() Function

The dict() function converts iterable objects (like tuples, lists, etc.) into a dictionary by creating a new dictionary object. It can be used for type conversion in Python even without arguments, in which case it returns an empty dictionary. The function can also take another dictionary or an iterable containing key-value pairs as an argument.

Syntax:

dict(iterable)

Here,

• dict(): Name of the function.
• iterable: Optional argument, an iterable object containing key-value pairs.

Code:

Output:

{'a': 10, 'b': 20, 'c': 1, 'd': 30}

Explanation:

In the above Python code,

1. We start by defining a dictionary mixed_data containing values of different types: 'a': '10' (a string), 'b': 20.5 (a float), 'c': True (a boolean), and 'd': '30' (a string).
2. Then, we convert all these values to integers using dictionary comprehension within the dict() function.
3. This comprehension iterates over each key-value pair in mixed_data, converting each value to an integer using the int() function, and then creates a new dictionary with the same keys but with the integer-converted values in variable converted_dict.
4. Finally, we print the converted_dict.

Type Conversion In Python With complex() Function

The complex() function takes two integer-type parameters, real and imag, and converts them into a complex number. Here, the real represents the real part of the complex number and imag represents the imaginary part. If the imag argument is omitted, it defaults to zero.

Syntax:

complex(real[, imag])

Here,

• complex(): This function returns a complex number constructed from its arguments.
• real: Represents the real part of the complex number (can be any numeric type).
• imag: Represents the imaginary part of the complex number (can be any numeric type).

Code:

Output:

(3+5j)

Explanation:

In the above Python code,

1. We start by defining two variables: real_part with an integer value of 3 and imag_part with an integer value of 5.
2. We then create a complex number using the complex() function, passing real_part to integer 3 and imag_part to integer 5 as arguments, respectively.
3. We store the resulting complex number in the variable complex_number.
4. Finally, we print the value of complex_number. 

Type Conversion In Python With chr(number) Function

The chr() function is commonly used for type conversion in Python to convert an integer representing a Unicode code point into its corresponding character.

Syntax:

chr(number)

Here,

• chr(number): This is the syntax of the chr() function.
• number: The parameter representing the Unicode code point to be converted.

Code:

Output:

Integer: A
Hexadecimal: A
Octal: A
Binary: A
Unicode: ☃

Explanation:

In the above Python code: 

1. We start by using the chr() function to convert various types of numeric representations into characters.
2. For int_num, we use chr(65), where 65 is the Unicode code point for the character 'A'. We store this character in int_num and print it.
3. For hex_num, we use chr(0x41), where 0x41 is the hexadecimal representation for the Unicode code point 65, which corresponds to the character 'A'. We store this character in hex_num variable and print it.
4. For oct_num, we use chr(0o101), where 0o101 is the octal representation for the Unicode code point 65, which corresponds to the character 'A'. We store this character in oct_num variable and print it.
5. For binary_num, we use chr(0b1000001), where 0b1000001 is the binary representation for the Unicode code point 65, which corresponds to the character 'A'. We store this character in binary_num variable and print it.
6. For unicode_num, we use chr(9731), where 9731 is the Unicode code point for the character ☃ (Snowman). We store this character in unicode_num variable and print it.

Important Type Conversion Tips In Python

When performing type conversion in Python, you must remember a few key concepts to ensure that the conversion is done effectively. They are as follows:

• Data Loss: Be mindful of potential data loss when converting between different input data types. For example, converting a floating-point number to an integer will truncate the decimal part, potentially leading to a loss of precision. For example: 

float_num = 5.78
int_num = int(float_num)  # Truncates the decimal part
print(int_num)  # Outputs: 5

• Error Handling: Handle exceptions that may occur during type conversion in Python, especially when dealing with user involvement or external data sources. Invalid inputs may raise ValueError or TypeError. For example: 

user_input = "abc"
try:
    num = int(user_input)  # This will raise a ValueError
except ValueError:
    print("Invalid input! Please enter a valid number.")

• Explicit vs. Implicit Conversion: Understand when to use explicit conversion (using built-in functions like int(), float(), etc.) and when Python performs implicit conversion automatically. Note that explicit type conversion in Python provides greater control over the conversion process.

• Contextual Conversion: Consider the context in which the type conversion is performed. For example, converting a string representing a date to a datetime object requires knowledge of the date format.

• Type Checking: Validate data types before performing type conversion in Python, especially when dealing with mixed-type data. You can use isinstance() or type() functions to ensure compatibility.

• Efficiency: Type conversion in Python may have performance implications, especially in large-scale applications. You must minimize unnecessary conversions to improve performance.

• Unicode Handling: When converting between string types in Python (str and bytes), consider Unicode encoding/decoding to handle different character encodings properly. For example:  

text = "hello"
encoded_text = text.encode('utf-8')  # Convert string to bytes using UTF-8 encoding
decoded_text = encoded_text.decode('utf-8')  # Convert bytes back to string
print(decoded_text)  # Outputs: hello

• Immutable vs. Mutable Types: Note the difference in behavior when converting between immutable types (e.g., str, tuple) and mutable types (e.g., list, dict). Such type conversion may involve creating new objects or modifying existing ones.

• Documentation: Document-type conversion operations, especially if they are non-trivial or part of a larger algorithm. Clear documentation helps improve code readability and maintainability. For example: 

# Convert a string to a list of integers
def convert_string_to_list(s):
    """
    Converts a comma-separated string to a list of integers.
    Example:
    convert_string_to_list("1,2,3") -> [1, 2, 3]
    """
    return [int(x) for x in s.split(',')]

• Testing: Test type conversion logic thoroughly, covering different edge cases and input scenarios. Automated testing frameworks can assist in verifying the correctness of conversion functions.

Benefits Of Type Conversion In Python

Type conversion in Python programs comes with a wide range of benefits, including:

• Ensures Compatibility: Type conversion in Python ensures that different data types can be used together in operations. For instance, if you add an integer to a float, Python automatically converts the integer to a float to perform the addition.
• Simplifies Coding: Implicit type conversion reduces the need for explicit type conversion commands in simple scenarios. Python handles the conversion for you, which makes the code cleaner and more concise.
• Enhances Code Flexibility: Type conversion in Python allows for the use of various data types in different operations, providing flexibility in how you handle and manipulate data.
• Supports Diverse Data Types: Python’s type conversion functions support a wide range of data types, including numeric data types, string data types, and more complex structures like lists and tuples. For example: 

float_num = 3.14
int_num = int(float_num) # Convert float to int
print(int_num) # Outputs: 3

• Improves Data Handling: Explicit type casting helps you control how data types are converted, which is essential for accurate calculations, data formatting, and other operations.
• Avoids Errors: Proper use of type conversion in Python prevents type errors that occur when operations are performed on incompatible data types. For example: 

text = "100"
number = 50
result = int(text) + number  # Convert text to int to avoid type mismatch
print(result)  # Outputs: 150

• Supports Complex Operations: Type conversion is used in complex mathematical operations and data manipulations, allowing you to perform calculations and transformations on different data types. For example: 

value = 10
result = value / 3  # Implicitly converts int to float type for division
print(result)  # Outputs: 3.3333333333333335

• Ensures Data Integrity: Explicit type conversion in Python helps maintain data integrity by clearly defining how data types should be converted, which prevents unintentional errors.
• Cross-Domain Usage: Type conversion in Python facilitates the reuse of code across different domains or applications by allowing data to be transformed and adapted to suit specific requirements without rewriting significant portions of code.

Conclusion

Type conversion in Python is a fundamental concept that enables you to transform data from one type to another. It helps ensure compatibility, accuracy, and efficiency in your Python programs. There are two types of type conversion in Python, i.e., implicit and explicit. They allow you to manage data types effectively, in various scenarios such as simple arithmetic operations or complex data transformations.

Whether you’re dealing with data type conversion for user inputs, performing mathematical calculations, or integrating data from various sources, a solid grasp of type conversion principles is essential. Utilizing built-in functions like int(), float(), and str() will help you write more reliable and maintainable Python code.

Frequently Asked Questions

Q. What are primitive and non-primitive data types?

Primitive and non-primitive data types are fundamental concepts in programming that help us understand how data is stored and manipulated.

Primitive data types are the most basic data types provided by a programming language, representing single values.

• Examples include integer data type, float data type, characters, and other larger data types.
• These types are directly supported by the language and typically have a fixed size and operations associated with them.
• For instance, an integer type holds whole numbers, and a float holds decimal numbers.

Non-primitive data types, also known as composite or reference types, are built from primitive types and can hold multiple values or more complex structures.

• Examples include arrays, lists, objects, and strings.
• These types can be manipulated using various methods and can contain collections of primitive data types or other non-primitive types.
• For instance, a string is a sequence of characters, and a list can hold integers, floats, strings, or even other lists.

Q. What is type casting in C language and its types?

In C language, typecasting refers to the process of converting a variable from one data type to another. This is done to ensure that operations involving different types of data are performed correctly or to meet specific requirements of functions and operations. Typecasting is essential for managing data precision and performing arithmetic operations where data types differ.

There are two main types of typecasting in C:

1. Implicit Typecasting (Automatic Type Conversion): This occurs automatically when we perform operations involving different data types. For example, if we add an integer datatype to a float datatype, C will implicitly convert the integer to a float before performing the addition. This typecasting is handled by the compiler to ensure that the operation is carried out with the appropriate data type.

2. Explicit Typecasting (Manual Type Conversion): This requires us to manually convert a variable from one type to another using a typecast operator. For example, to convert a float to an integer, we use (int)float_variable, which truncates the decimal part and keeps only the integer part. Explicit typecasting gives us more control over how the conversion is performed and is used to force data types in scenarios where implicit typecasting might not suffice.

Q. What is the difference between implicit and explicit type conversion in Python?

The main difference between implicit and explicit type conversion in Python lies in how they are performed. The table below highlights the difference between the two types.

Q. Can implicit type conversion lead to errors?

Yes, implicit type conversion in Python can lead to unexpected results or errors if not managed carefully. Since the conversion is done automatically by the interpreter, it may not always produce the desired outcome, especially when dealing with operations that involve different data types.

Q. Why is explicit type conversion important?

Explicit type conversion or type casting in Python is important because it provides more control over the conversion process, ensuring data integrity and avoiding unexpected behaviors. It allows the programmer to specify exactly how and when data types should be converted, leading to more predictable and reliable code.

You might also be interested in reading the following:

1. Fibonacci Series In Python & Nth Term | Generate & Print (+Codes)
2. Swap Two Variables In Python- Different Ways | Codes + Explanation
3. Difference Between C and Python | C or Python - Which One Is Better?
4. Convert Int To String In Python | Learn 6 Methods With Examples
5. How To Reverse A String In Python? 10 Easy Ways With Examples