Understanding Type Conversion and Type Casting in Python

Course: Python Training

Topic: Understanding Type Conversion and Type Casting

Course Link: Python Training Course at JustAcademy

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction to Type Conversion and Type Casting

Python is a dynamically typed programming language, which means that variables do not need explicit type declarations before they are assigned values. Python determines the type of an object at runtime. During program execution, developers frequently need to convert values from one data type to another. This process is known as type conversion or, in common programming terminology, type casting.

For example, a value received through the input() function is returned as a string. If the user enters a number that must be used in a mathematical calculation, the program may need to convert that string into an integer or a floating-point number.

age_text = input("Enter your age: ")
age = int(age_text)

print("Next year, you will be", age + 1)

In this example, age_text contains text, while age contains an integer after conversion. Without the conversion, adding the integer 1 directly to the input string would produce a type-related error.

Why Is Type Conversion Important?

• It allows programs to perform mathematical operations on numeric data.
• It helps process user input correctly.
• It supports data exchange between APIs, databases, files, and applications.
• It enables data cleaning and preparation for analysis.
• It helps convert values into appropriate formats for display and storage.
• It reduces errors caused by incompatible data types.
• It makes programs more flexible when working with different data sources.

2. Learning Objectives

After studying this topic, learners should be able to:

• Explain Python data types and the purpose of type conversion.
• Differentiate implicit type conversion from explicit type conversion.
• Use int(), float(), complex(), str(), and bool().
• Convert between common collection types such as lists, tuples, and sets.
• Understand how numeric conversion affects values and precision.
• Convert user input into appropriate data types.
• Identify common conversion errors and handle them safely.
• Use type() and isinstance() to inspect values.
• Apply type conversion in practical Python programs.
• Follow best practices for reliable and readable code.

3. Understanding Python Data Types

A data type describes the kind of value an object represents and the operations that can be performed on it. Python provides several built-in data types for numeric values, text, logical values, collections, and other purposes.

Checking the Type of a Value

The built-in type() function returns the type of an object. It is useful when learning about data types and debugging conversion problems.

age = 25
price = 99.50
name = "Riya"
is_active = True

print(type(age))
print(type(price))
print(type(name))
print(type(is_active))

Output:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

4. What Is Type Conversion?

Type conversion is the process of changing a value from one data type to another. Depending on how the conversion takes place, it is commonly divided into two categories:

1. Implicit type conversion: Python automatically converts compatible values in certain operations.
2. Explicit type conversion: The programmer requests a conversion using functions such as int(), float(), or str().

For example, Python may convert an integer to a floating-point value when performing arithmetic with a float. However, converting a string such as "42" into an integer usually requires an explicit conversion.

5. Implicit Type Conversion in Python

Implicit type conversion occurs when Python automatically adjusts a value's type during a supported operation. The programmer does not need to call a conversion function explicitly.

Example 1: Integer and Float Addition

integer_value = 10
float_value = 2.5

result = integer_value + float_value

print(result)
print(type(result))

Output:

12.5
<class 'float'>

Python converts the integer operand to a compatible floating-point representation for the arithmetic operation. The result is a float.

Example 2: Integer Division

first_number = 10
second_number = 4

result = first_number / second_number

print(result)
print(type(result))

Output:

2.5
<class 'float'>

In Python, the division operator / produces a floating-point result for ordinary numeric operands, even when both operands are integers.

Example 3: Integer and Complex Number

integer_value = 5
complex_value = 2 + 3j

result = integer_value + complex_value

print(result)
print(type(result))

Output:

(7+3j)
<class 'complex'>

The integer is combined with a complex number, and the result is a complex number.

Important Points About Implicit Conversion

• It occurs automatically in supported operations.
• It is commonly seen in arithmetic involving integers, floats, and complex numbers.
• It does not mean that Python automatically converts every incompatible type.
• Adding a string and an integer directly usually raises a TypeError.
• Implicit conversion should not be confused with the conversion of text into a number.

6. Explicit Type Conversion or Type Casting

Explicit type conversion occurs when the programmer intentionally converts a value using a built-in function or a suitable constructor. It is commonly called type casting in Python tutorials.

For example, int("100") converts a valid integer string into an integer, while float("12.5") converts a numeric string into a floating-point value.

number_text = "100"
number = int(number_text)

print(number)
print(type(number))

Output:

100
<class 'int'>

Common Explicit Conversion Functions

7. Converting Values to Integers Using int()

The int() function converts supported values into integers. It is commonly used to process numeric strings, whole-number calculations, and user input.

Example 1: String to Integer

number_text = "250"
number = int(number_text)

print(number)
print(type(number))

Output:

250
<class 'int'>

Example 2: Float to Integer

price = 149.99
whole_price = int(price)

print(whole_price)

Output:

149

Converting a float to an integer with int() truncates the fractional part toward zero. It does not round to the nearest integer.

print(int(7.9))
print(int(7.1))
print(int(-7.9))

Output:

7
7
-7

Example 3: Binary String to Integer

binary_value = "1010"
decimal_value = int(binary_value, 2)

print(decimal_value)

Output:

10

The optional second argument specifies the base when converting a string representation of an integer. For example, base 2 represents binary, base 8 represents octal, and base 16 represents hexadecimal.

print(int("17", 8))
print(int("1A", 16))

Output:

15
26

Important Notes About int()

• Valid integer strings such as "25" can be converted successfully.
• A decimal string such as "25.5" cannot be passed directly to int().
• Convert a valid decimal string to a float first if fractional values are expected.
• Using int() on a float discards the fractional portion toward zero.
• Conversion can raise ValueError if the string does not represent a valid integer in the specified base.

8. Converting Values to Floating-Point Numbers Using float()

The float() function converts supported values to floating-point numbers. It is useful when working with prices, measurements, percentages, averages, and other values that can contain fractional parts.

Example 1: Integer to Float

number = 25
decimal_number = float(number)

print(decimal_number)
print(type(decimal_number))

Output:

25.0
<class 'float'>

Example 2: String to Float

price_text = "349.75"
price = float(price_text)

print(price)
print(type(price))

Output:

349.75
<class 'float'>

Example 3: Calculate an Average

total_marks = 257
number_of_subjects = 3

average = float(total_marks) / number_of_subjects

print(round(average, 2))

Output:

85.67

Important Notes About float()

• It can convert valid numeric strings into floating-point values.
• It can represent fractional values such as 12.75.
• Some decimal values cannot be represented exactly in binary floating-point format.
• It accepts special strings such as "inf" and "nan" in supported forms.
• It raises ValueError for invalid numeric strings such as "hello".

9. Converting Values to Complex Numbers Using complex()

A complex number contains a real part and an imaginary part. Python represents the imaginary component using the letter j.

The complex() function can create a complex number from a supported value or from separate real and imaginary components.

Example 1: Integer to Complex

number = 10
complex_number = complex(number)

print(complex_number)

Output:

(10+0j)

Example 2: Real and Imaginary Components

real_part = 5
imaginary_part = 3

value = complex(real_part, imaginary_part)

print(value)
print(value.real)
print(value.imag)

Output:

(5+3j)
5.0
3.0

Example 3: Convert a Complex Number to Another Numeric Type

value = 4 + 2j

# Complex values cannot be directly converted to float or int.
# float(value) raises TypeError.

A complex number cannot be directly converted to an integer or float using int() or float(). If the real component is what the program needs, use value.real explicitly, while ensuring that discarding the imaginary component is appropriate for the task.

10. Converting Values to Strings Using str()

The str() function creates a readable string representation of a value. It is useful when displaying information, combining text with values, preparing messages, and writing data to text files.

Example 1: Integer to String

age = 25
age_text = str(age)

print(age_text)
print(type(age_text))

Output:

25
<class 'str'>

Example 2: Combine Text and Numeric Data

product = "Notebook"
price = 80

message = "The price of " + product + " is " + str(price)
print(message)

Output:

The price of Notebook is 80

Example 3: Format Values With an f-String

student_name = "Aarav"
marks = 92

message = f"{student_name} scored {marks} marks."
print(message)

Output:

Aarav scored 92 marks.

When building messages, f-strings are often clearer than manually converting each value and joining strings with the + operator.

11. Converting Values to Booleans Using bool()

The bool() function converts a value into True or False according to Python's truth-value rules. It is frequently used when checking whether a collection contains elements or whether a value is considered empty.

Example 1: Numeric Values

print(bool(1))
print(bool(0))
print(bool(-5))

Output:

True
False
True

Zero is false, while nonzero numeric values are true.

Example 2: Strings

print(bool("Python"))
print(bool(""))
print(bool("False"))

Output:

True
False
True

An important point is that the non-empty string "False" evaluates to True. Python checks whether the string is empty, not whether its text spells a Boolean word.

Example 3: Collections

print(bool([1, 2, 3]))
print(bool([]))
print(bool({"name": "Riya"}))
print(bool({}))

Output:

True
False
True
False

Empty lists, tuples, dictionaries, sets, and strings are false. Non-empty collections are generally true.

Truth-Value Conversion Table

12. Converting Between Collection Types

Python provides constructors such as list(), tuple(), set(), and dict() to create collections from supported input values. The result depends on the input's structure and the rules of the target collection.

12.1 Convert a String to a List

text = "Python"
characters = list(text)

print(characters)

Output:

['P', 'y', 't', 'h', 'o', 'n']

The string is iterable, so each character becomes an element in the resulting list.

12.2 Convert a Tuple to a List

coordinates = (10, 20, 30)
coordinate_list = list(coordinates)

print(coordinate_list)

Output:

[10, 20, 30]

A list is mutable, so elements can be added, removed, or updated after conversion.

12.3 Convert a List to a Tuple

colors = ["red", "green", "blue"]
color_tuple = tuple(colors)

print(color_tuple)

Output:

('red', 'green', 'blue')

A tuple is immutable, so its element references cannot be reassigned through normal item assignment.

12.4 Convert a List to a Set

numbers = [1, 2, 2, 3, 3, 3]
unique_numbers = set(numbers)

print(unique_numbers)

The result contains the unique elements from the list. Sets do not guarantee the same display order as the original list.

Possible output:

{1, 2, 3}

12.5 Convert a Set to a List

unique_values = {10, 20, 30}
values_list = list(unique_values)

print(values_list)

The result is a list of the set's elements. Do not rely on a set's iteration order when a particular ordering is required. Use sorted() if the elements can be ordered and a sorted list is desired.

12.6 Convert Key-Value Pairs to a Dictionary

pairs = [("name", "Asha"), ("age", 24)]
student = dict(pairs)

print(student)

Output:

{'name': 'Asha', 'age': 24}

The input must contain suitable key-value pairs. If a key appears multiple times, the later value replaces the earlier value for that key.

12.7 Convert a List of Integers to a String

numbers = [1, 2, 3, 4]
text_values = [str(number) for number in numbers]

print(text_values)

Output:

['1', '2', '3', '4']

If the goal is to combine the values into one string, use join() after converting the elements to strings.

numbers = [1, 2, 3, 4]
result = ", ".join(str(number) for number in numbers)

print(result)

Output:

1, 2, 3, 4

13. Understanding Type Conversion With input()

The input() function always returns a string. Even when a user enters digits, Python initially treats the entered value as text. Explicit conversion is needed when the program must perform numeric calculations.

Example 1: Add Two Integers

first_number = int(input("Enter the first number: "))
second_number = int(input("Enter the second number: "))

total = first_number + second_number

print("Total:", total)

If the user enters 10 and 20, the output is:

Total: 30

Example 2: Calculate a Product Price With Tax

price = float(input("Enter the product price: "))
tax_rate = 0.18

tax_amount = price * tax_rate
final_price = price + tax_amount

print("Tax amount:", round(tax_amount, 2))
print("Final price:", round(final_price, 2))

This example converts the input into a float so that prices containing fractional values can be processed.

Example 3: Convert Input Into a Boolean Carefully

answer = input("Do you want to continue? (yes/no): ").strip().lower()

if answer == "yes":
    should_continue = True
elif answer == "no":
    should_continue = False
else:
    should_continue = None

print(should_continue)

This approach is safer than using bool(input()) when the user is expected to type a word such as yes or no. Any non-empty string, including "no", evaluates to True with bool().

14. Type Conversion Errors and Exception Handling

Not every value can be converted into every data type. Invalid conversions may raise exceptions, and a robust program should handle expected input errors gracefully.

14.1 ValueError

A ValueError often occurs when the input has the correct general type but an invalid value for the requested conversion.

number_text = "hello"

number = int(number_text)

This code raises a ValueError because "hello" is not a valid integer representation.

14.2 TypeError

A TypeError can occur when an operation or conversion does not support the supplied type.

number = 10
text = "5"

# This raises TypeError:
# result = number + text

To add the numeric values, convert the text first:

number = 10
text = "5"

result = number + int(text)

print(result)

Output:

15

14.3 Safe Conversion With try and except

user_input = input("Enter a whole number: ")

try:
    number = int(user_input)
    print("Converted value:", number)
except ValueError:
    print("Invalid input. Please enter a whole number.")

The program attempts the conversion. If the input is invalid, the exception handler displays a useful message rather than allowing the program to terminate with an unhandled error.

14.4 Repeated Input Until a Valid Number Is Entered

while True:
    user_input = input("Enter a number: ")

    try:
        number = float(user_input)
        break
    except ValueError:
        print("Please enter a valid numeric value.")

print("Your number is:", number)

This pattern is useful for console applications that must validate input before continuing.

15. Difference Between Type Conversion and Type Casting

In many Python learning materials, the terms type conversion and type casting are used interchangeably. A common teaching distinction is to call automatic conversion implicit conversion and programmer-requested conversion explicit conversion.

16. Type Conversion Versus Rounding

Type conversion and rounding are different operations. Using int() on a float truncates its fractional part toward zero. The round() function rounds a number according to Python's rounding behavior.

number = 8.7

print(int(number))
print(round(number))

Output:

8
9

For negative values, truncation and rounding can produce different results:

number = -8.7

print(int(number))
print(round(number))

Output:

-8
-9

Python's round() uses ties-to-even behavior for exact halfway cases in ordinary built-in numeric rounding. If a business rule requires a particular rounding method, especially for money, choose a suitable approach such as the decimal module rather than assuming int() or round() meets every requirement.

17. Checking Types With isinstance()

The isinstance() function checks whether an object belongs to a specified type or its subclass. It is often more useful than direct type equality when working with class hierarchies.

age = 25
price = 99.5
name = "Riya"

print(isinstance(age, int))
print(isinstance(price, float))
print(isinstance(name, str))

Output:

True
True
True

It can also check against a tuple of types:

value = 12.5

if isinstance(value, (int, float)):
    print("The value is numeric")

Remember that bool is a subclass of int in Python. Therefore, isinstance(True, int) evaluates to True. If a program must distinguish Boolean values from integers, check for that explicitly.

value = True

if isinstance(value, int) and not isinstance(value, bool):
    print("Integer value")
else:
    print("Not an ordinary integer value")

18. Type Conversion in Real-World Applications

18.1 Data Entry Applications

Forms often collect values as text. A program may need to convert age to an integer, salary to a numeric type, or a status selection to a Boolean value before processing the information.

18.2 Data Analysis

Data analysis projects frequently import numbers from CSV files or other sources as text. Converting valid numeric strings into integers or floats allows calculations, filtering, aggregation, and statistical analysis.

sales_text = ["1200.50", "950.00", "1450.75"]
sales = [float(value) for value in sales_text]

total_sales = sum(sales)

print(round(total_sales, 2))

Output:

3601.25

18.3 Web Development and APIs

Web applications receive data from forms and API payloads. Developers must validate the incoming data and convert it into appropriate types before performing calculations or saving it to a database. The expected type depends on the API schema and application requirements.

18.4 Database Applications

Database fields may contain integers, decimals, text, dates, or Boolean-like values. Applications should use compatible Python values and handle invalid data before writing records. Decimal amounts may require the decimal.Decimal type to avoid unexpected floating-point rounding effects.

18.5 File Processing

When reading a text file, the program receives text data. If each line represents a number, conversion may be necessary before calculating totals or averages.

values_text = ["10", "20", "30"]
values = [int(value) for value in values_text]

print(sum(values))
print(sum(values) / len(values))

Output:

60
20.0

19. Best Practices for Type Conversion

• Know the input type: Check whether a value is a string, integer, float, or collection before converting it.
• Validate user input: Do not assume that users always enter valid numbers.
• Handle expected errors: Use try and except for conversions that may fail.
• Avoid unnecessary conversions: Convert values only when required by the operation or application design.
• Be careful with floats: Binary floating-point numbers may not represent every decimal value exactly.
• Do not confuse rounding and truncation: Use the correct operation for the requirement.
• Understand Boolean conversion: A non-empty string such as "False" is truthy.
• Preserve meaningful precision: Do not convert decimal values to integers if the fractional portion is important.
• Inspect types while debugging: Use type() or isinstance() when necessary.
• Use suitable data types: Choose integers for whole counts, floats for general fractional calculations, and Decimal when decimal arithmetic requirements demand it.
• Do not use eval() for ordinary conversion: Functions such as int(), float(), and json.loads() for JSON data are more appropriate and safer for their respective purposes.
• Keep conversion logic readable: Use clear variable names such as price_text and price to show the difference between raw input and converted data.

20. Common Mistakes and How to Fix Them

21. Practical Example: Student Marks Calculator

This example combines input handling, type conversion, arithmetic, and conditional logic to calculate a student's average marks and determine a result.

student_name = input("Enter student name: ")

try:
    mark_one = float(input("Enter marks for subject 1: "))
    mark_two = float(input("Enter marks for subject 2: "))
    mark_three = float(input("Enter marks for subject 3: "))

    marks = [mark_one, mark_two, mark_three]

    if any(mark < 0 or mark > 100 for mark in marks):
        print("Marks must be between 0 and 100.")
    else:
        average = sum(marks) / len(marks)

        if average >= 75:
            result = "Distinction"
        elif average >= 40:
            result = "Pass"
        else:
            result = "Fail"

        print("Student:", student_name)
        print("Average:", round(average, 2))
        print("Result:", result)

except ValueError:
    print("Invalid input. Please enter numeric marks.")

Concepts Demonstrated

• input() collects text from the user.
• float() converts the marks into numeric values.
• sum() calculates the total marks.
• len() determines the number of subjects.
• round() formats the displayed average to two decimal places.
• try and except handle invalid numeric input.
• Conditional statements classify the student's result.

22. Practical Example: Shopping Bill Calculator

This project demonstrates type conversion in a simple shopping application. The program accepts a product price and quantity, calculates the subtotal, applies a discount, and displays the final bill.

try:
    product_name = input("Enter product name: ")
    unit_price = float(input("Enter unit price: "))
    quantity = int(input("Enter quantity: "))

    if unit_price < 0 or quantity < 0:
        print("Price and quantity cannot be negative.")
    else:
        subtotal = unit_price * quantity

        if subtotal >= 5000:
            discount_rate = 0.10
        else:
            discount_rate = 0.05

        discount_amount = subtotal * discount_rate
        final_amount = subtotal - discount_amount

        print("Product:", product_name)
        print("Subtotal:", round(subtotal, 2))
        print("Discount:", round(discount_amount, 2))
        print("Final amount:", round(final_amount, 2))

except ValueError:
    print("Please enter a valid price and whole-number quantity.")

Project Learning Outcomes

• Converting text input into integers and floats.
• Validating numeric values before calculation.
• Using conditional statements to apply business rules.
• Calculating subtotals, discounts, and final amounts.
• Handling invalid input without an unhandled conversion error.

23. Hands-On Exercises

Exercise 1: Convert a String to an Integer

Create a variable containing "125", convert it into an integer, and display its value and type.

Expected solution:

number_text = "125"
number = int(number_text)

print(number)
print(type(number))

Exercise 2: Convert a Float to an Integer

Convert 19.85 into an integer and explain why the result is not rounded to 20.

Expected solution:

value = 19.85
result = int(value)

print(result)

Output: 19. The int() function truncates the fractional part toward zero.

Exercise 3: Convert a List Into a Set

Convert the list [2, 4, 4, 6, 6, 8] into a set and explain what happens to duplicate elements.

Expected solution:

numbers = [2, 4, 4, 6, 6, 8]
unique_numbers = set(numbers)

print(unique_numbers)

Exercise 4: Safely Convert User Input

Ask the user to enter a number and display a message if the input cannot be converted into a float.

Expected solution:

value_text = input("Enter a number: ")

try:
    value = float(value_text)
    print("Converted value:", value)
except ValueError:
    print("The entered value is not a valid number.")

Exercise 5: Calculate an Average

Ask the user for three marks, convert them to floats, calculate the average, and display the answer rounded to two decimal places.

Exercise 6: Convert Numeric Values to Strings

Convert an integer and a float to strings, then create a message that displays both values.

Exercise 7: Investigate Boolean Conversion

Test the results of bool(0), bool(1), bool(""), bool("False"), and bool([]). Explain why the results differ.

24. Interview Questions and Answers

Q1. What is type conversion in Python?

Answer: Type conversion is the process of changing a value from one data type to another, such as converting a string to an integer or a float to a string.

Q2. What is implicit type conversion?

Answer: Implicit type conversion is performed automatically by Python in supported operations. For example, 10 + 2.5 produces the floating-point result 12.5.

Q3. What is explicit type conversion?

Answer: Explicit type conversion occurs when the programmer requests a conversion using a function such as int(), float(), or str().

Q4. What is the difference between type conversion and type casting?

Answer: In many Python tutorials, the terms are used interchangeably. A common teaching distinction is to use type conversion as the general term and type casting for programmer-requested explicit conversion.

Q5. How do you convert a string to an integer?

Answer: Use int() with a valid integer string, such as int("100"), which returns the integer 100.

Q6. What happens when you convert a float to an integer?

Answer: The int() function truncates the fractional part toward zero. For example, int(9.8) returns 9, and int(-9.8) returns -9.

Q7. How do you convert a string to a float?

Answer: Use float(), such as float("12.75"), which returns 12.75.

Q8. What does bool() do?

Answer: It converts a value into a Boolean truth value. Zero, empty strings, empty collections, and None are false; nonzero numbers and non-empty strings and collections are generally true.

Q9. What is the difference between int() and round()?

Answer: int() truncates the fractional part toward zero, whereas round() rounds a number according to Python's rounding rules.

Q10. What is a ValueError?

Answer: A ValueError commonly occurs when a conversion receives a value that cannot be interpreted in the requested way, such as int("hello").

Q11. Why does input() require conversion for arithmetic?

Answer: The input() function returns a string. If the entered value is meant to be a number, convert it using int() or float() before performing numeric calculations.

Q12. How do you convert a list into a tuple?

Answer: Use tuple(), for example tuple([1, 2, 3]), which produces (1, 2, 3).

Q13. How do you remove duplicates from a list?

Answer: One simple approach is to use set(), such as set([1, 1, 2, 3]). If preserving the original order matters, use an order-preserving method such as list(dict.fromkeys(values)) for hashable elements.

Q14. How can you check the type of a variable?

Answer: Use type(value) to inspect its exact type or isinstance(value, SomeType) to check whether it belongs to a type or its subclass.

Q15. Why should conversion errors be handled?

Answer: Input from users, files, and external systems may contain invalid values. Handling exceptions such as ValueError allows the program to report errors clearly and recover when appropriate.

25. Quick Revision Checklist

• Type conversion changes a value from one data type to another.
• Implicit conversion occurs automatically during supported operations.
• Explicit conversion is requested by the programmer.
• int() converts supported values to integers.
• float() converts supported values to floating-point numbers.
• complex() creates complex numbers.
• str() produces a string representation.
• bool() converts a value according to truth-value rules.
• list(), tuple(), set(), and dict() create collections from suitable inputs.
• input() returns text, so numeric input generally requires conversion.
• int() truncates floats toward zero; it does not round them.
• round() is used when rounding is required.
• type() and isinstance() help inspect types.
• ValueError and TypeError are common conversion-related exceptions.
• try and except can handle expected conversion failures.
• Use appropriate numeric types and preserve required precision.
• Validate user input before relying on converted values.

26. Conclusion

Type conversion and type casting are essential Python concepts that help developers work with different kinds of data. Implicit conversion allows Python to handle certain compatible operations automatically, while explicit conversion gives programmers control over how values are transformed using functions such as int(), float(), str(), and bool().

Understanding how conversion affects values, precision, collections, and user input helps prevent common programming errors. By using suitable data types, validating input, handling conversion exceptions, and practicing with real-world examples, learners can build reliable Python programs and prepare for advanced topics such as file processing, web development, database integration, and data analysis.

27. Further Learning Resources

• Explore the Python Training Course at JustAcademy
• Register for a Python Course Demo
• Visit the JustAcademy Official Website
• Python Official Documentation: Built-in Functions
• Python Official Documentation: Built-in Types
• Python Official Tutorial: Errors and Exceptions