Casting in Python

• Casting in Python refers to the conversion of a variable's data type into another data type
• Python is an object-oriented language, so it uses classes to define data types, including primitive types
• Casting is useful when you need to perform operations that require specific data types or when you need to represent data in a certain format

Explicit vs. Implicit Casting

• Explicit casting is when you manually convert a data type using built-in functions
• Implicit casting (coercion) is when Python automatically converts data types during certain operations without explicit instructions

Explicit Casting Functions

• int(): Converts a value to an integer data type
  • Can convert a float to an integer by truncating the decimal part
  • Can convert a string to an integer if the string represents a whole number
• float(): Converts a value to a floating-point number
  • Can convert an integer to a float by adding a decimal point and zero
  • Can convert a string to a float if the string represents a valid floating-point number
• str(): Converts a value to a string
  • Can convert integers, floats, and other data types to their string representation
• bool(): Converts a value to a boolean (True or False)
  • Most values are considered True, except for:
    • False
    • None
    • 0 (all numeric zero values)
    • Empty sequences (e.g., '', (), [])
    • Empty mappings (e.g., {})

Integer Casting: int()

• Converting floats to integers truncates the decimal portion, not rounding

• Converting strings to integers is possible only if the string contains a valid integer representation

• Trying to convert a string containing non-numeric characters (other than leading/trailing whitespace) will raise a ValueError

  x = int(2.8)   # x becomes 2
  y = int("3")   # y becomes 3
  z = int("3.5") # Raises ValueError: invalid literal for int() with base 10: '3.5'
  

Float Casting: float()

• Converts integers and strings to floating-point numbers.

• Strings must represent valid numeric values

• Conversion from an integer to a float simply adds a decimal point

  x = float(1)     # x becomes 1.0
  y = float("3")   # y becomes 3.0
  z = float("3.5") # z becomes 3.5
  

String Casting: str()

• Converts almost any data type to its string representation

• Useful for concatenating numbers with strings or displaying values in a readable format

  x = str("s1")   # x becomes 's1'
  y = str(2)     # y becomes '2'
  z = str(3.0)   # z becomes '3.0'
  

Boolean Casting: bool()

• Converts values to True or False

• Determines the truthiness of a value

  bool(False)   # Returns False
  bool(None)    # Returns False
  bool(0)       # Returns False
  bool(1)       # Returns True
  bool("")      # Returns False
  bool("abc")   # Returns True
  bool([1,2,3]) # Returns True
  bool([])      # Returns False
  

Implicit Type Conversion

• Python automatically converts (coerces) one data type to another in certain operations
• Occurs without explicit intervention from the programmer
• Generally happens when performing operations between different numeric types

Rules for Implicit Conversion

• Python tries to avoid loss of information during implicit conversion
• Lower data types are promoted to higher data types to prevent data loss
• boolean values promote to integers

Examples of Implicit Conversion

• Adding an integer and a float: the integer is automatically converted to a float

  num_int = 123
  num_flo = 1.23
  num_new = num_int + num_flo # num_int is implicitly converted to float
  print(num_new)               # Output: 124.23
  print(type(num_new))          # Output: <class 'float'>
  

• In boolean operations, True is treated as 1 and False as 0

  x = 5
  y = True
  z = x + y       # True is implicitly converted to 1
  print(z)        # Output: 6
  print(type(z))   # Output: <class 'int'>
  

Limitations of Implicit Conversion

• Implicit conversion may not always produce the desired results, especially when dealing with strings
• Explicit conversion is often preferred for clarity and control

Error Handling in Casting

• Casting can raise exceptions if the conversion is not possible
• ValueError: Raised when a string cannot be converted to an integer or float
• TypeError: Raised when an inappropriate type is used in an operation

Best Practices for Casting

• Use explicit casting to make code more readable and maintainable
• Handle potential exceptions using try-except blocks
• Ensure the data being converted is in the correct format to avoid errors
• Be mindful of data loss when converting to a lower data type (e.g., float to int)