Type Converter

easyFREEVariables & TypesPython BasicsPython Foundations

Problem Statement

Convert values between different Python types.

Background

Python provides built-in functions for type conversion:

int(x) - convert to integer
float(x) - convert to float
str(x) - convert to string
bool(x) - convert to boolean

Your Task

Write a function convert_value(value, target_type) that converts the value to the specified type.

Input

value: Any Python value
target_type: String indicating target type ("int", "float", "str", "bool")

Output Format

Return the converted value, or "Error" if conversion fails.

Example

Input

value = "42", target_type = "int"

Output

Reasoning

Inputs: value is the text "42", two characters (the digits 4 and 2), and target_type is the label "int", naming the kind of value to hand back.
Math: reading those digits as a base-10 numeral gives $4 \times 10^1 + 2 \times 10^0 = 40 + 2 = 42$ , a whole number.
Output: the integer 42. Printed, it looks identical to the input, but it is now a number: adding 1 gives 43, whereas gluing a "1" onto the text would give "421".
The same input with the other targets: as a float it becomes $42.0$ , as a string it stays "42", and as a boolean it is True, because any non-empty text counts as true.
A float like $3.7$ requested as an integer loses its fractional part (it moves toward zero), giving 3, not the rounded 4.
Text that is not a whole-number numeral, such as "abc" or "4.2", cannot become an integer, so the function returns the string "Error" instead of crashing.

Constraints

Handle conversion errors gracefully
target_type will be one of: "int", "float", "str", "bool"

Learn this in

Python FoundationsFoundations

More from Python Foundations

Magic Methodsmedium Inheritance and Polymorphismmedium Basic Class Creationeasy Decorator Implementationmedium Higher-Order Functionsmedium

Concept primer

Background Knowledge

Python is a dynamically typed language, meaning variables don't require explicit type declarations—the interpreter determines types at runtime based on assigned values. This flexibility aids rapid development but can lead to runtime errors from unintended type mismatches. Type conversion (or casting) explicitly changes a value's type using built-in functions like int(), float(), str(), and bool(), enabling operations across types (e.g., converting a string "42" to integer 42 for arithmetic).

These functions handle common conversions safely but raise ValueError or TypeError on invalid inputs (e.g., int("abc") fails). Understanding truthiness is key for bool(): falsy values include False, 0, 0.0, "", None, and empty collections; all others are truthy. This problem builds foundational skills in error handling and conditional logic, essential for robust Python functions.

Algorithm/Approach

Use a mapping-based dispatch pattern: create a dictionary linking target type strings to conversion functions, then attempt the conversion with exception handling. This avoids lengthy if-elif chains, promotes readability, and scales easily. Wrap the attempt in a try-except block to catch conversion failures, returning the result or "Error".

Step-by-Step Strategy

Define the type mapping: Create a dictionary where keys are type strings ("int", "float", etc.) and values are the corresponding functions (int, float, etc.).
Check input validity: Verify target_type exists in the mapping; if not, return "Error".
Attempt conversion: Use try-except to call the mapped function on value.
Handle success/failure: Return the converted value on success; return "Error" on ValueError, TypeError, or other exceptions.
Test edge cases: Consider inputs like None, empty strings, or non-string numerics.

Common Pitfalls

Forgetting exceptions: Not all conversions succeed (e.g., int("3.14") raises ValueError); always use try-except.
Truthy surprises: bool("0") is True (non-empty string), but bool(0) is False—review falsy rules.
Type string mismatches: Inputs may have extra whitespace or wrong case; consider .strip().lower() normalization.
Mutable inputs: Avoid modifying value; conversions create new objects.
Overly broad except: Catch only relevant exceptions (ValueError, TypeError) to avoid masking unrelated errors.

Time & Space Complexity

Time: $O(1)$ average-case—dictionary lookup and function call are constant time, regardless of input size. Space: $O(1)$ —fixed-size dictionary and minimal temporary objects for conversion.

solution.py

Python 3.13

Test results