Enhancing Data Structures with Python Magic Methods

Python's "magic methods" (also known as dunder methods, short for double underscore) allow us to imbue our custom classes with behavior that integrates seamlessly with Python's built-in operations and syntax. This challenge focuses on implementing several common magic methods to create a more Pythonic and user-friendly Vector class. By implementing these methods, you'll gain a deeper understanding of how Python's operators work under the hood and how to customize them for your own objects.

Problem Description

You are tasked with creating a Vector class that represents a mathematical vector in a multidimensional space. This class should support common vector operations and provide a more intuitive way to interact with vector objects using Python's standard operators.

Key Requirements:

1. Initialization (__init__): The Vector should be initialized with a list or tuple of numbers representing its components.
2. String Representation (__str__, __repr__):
   • __str__ should provide a user-friendly string representation (e.g., Vector(1, 2, 3)).
   • __repr__ should provide an unambiguous representation that could be used to recreate the object (e.g., Vector([1, 2, 3])).
3. Length (__len__): Implement __len__ to return the number of dimensions of the vector.
4. Equality (__eq__): Implement __eq__ to check if two vectors are equal (i.e., have the same components).
5. Addition (__add__): Implement __add__ to perform vector addition. This operation should only be valid if the vectors have the same dimension.
6. Subtraction (__sub__): Implement __sub__ to perform vector subtraction. This operation should only be valid if the vectors have the same dimension.
7. Scalar Multiplication (__mul__): Implement __mul__ to perform scalar multiplication (multiplying a vector by a scalar number).
8. Indexed Access (__getitem__): Implement __getitem__ to allow accessing individual components of the vector using index notation (e.g., v[0]).

Expected Behavior:

• When creating a Vector, it should store its components.
• Printing a Vector object should use the __str__ method.
• Using repr() on a Vector object should use the __repr__ method.
• Calling len() on a Vector object should return its dimensionality.
• Comparing two Vector objects with == should correctly determine equality.
• Adding or subtracting vectors of the same dimension should result in a new Vector with the summed/subtracted components.
• Multiplying a Vector by a scalar should result in a new Vector with each component scaled.
• Accessing a vector component by index should return the value of that component.

Edge Cases to Consider:

• Vectors with different dimensions during addition or subtraction.
• Attempting to access an index out of bounds.
• Initializing a vector with non-numeric components (though for this challenge, assume valid numeric input).

Examples

Example 1:

v1 = Vector([1, 2, 3])
v2 = Vector([4, 5, 6])

print(v1)
print(repr(v2))
print(len(v1))
print(v1 == Vector([1, 2, 3]))
print(v1 == v2)

Vector(1, 2, 3)
Vector([4, 5, 6])
3
True
False

Explanation: The __str__ method formats v1 as "Vector(1, 2, 3)". The __repr__ method formats v2 as "Vector([4, 5, 6])". len(v1) returns 3 as v1 has 3 components. The equality checks compare v1 with a new vector of the same components (True) and with v2 (False).

Example 2:

v1 = Vector([1, 2, 3])
v2 = Vector([4, 5, 6])

v_sum = v1 + v2
v_diff = v1 - v2
v_scaled = v1 * 2

print(v_sum)
print(v_diff)
print(v_scaled)
print(v1[0])
print(v1[2])

Vector(5, 7, 9)
Vector(-3, -3, -3)
Vector(2, 4, 6)
1
3

Explanation: v1 + v2 performs component-wise addition. v1 - v2 performs component-wise subtraction. v1 * 2 scales each component of v1 by 2. v1[0] and v1[2] access the first and third components respectively.

Example 3: (Handling incompatible operations)

v1 = Vector([1, 2])
v2 = Vector([3, 4, 5])

try:
    result = v1 + v2
except ValueError as e:
    print(e)

try:
    print(v1[5])
except IndexError as e:
    print(e)

Vectors must have the same dimension for addition.
Index out of bounds for vector.

Explanation: Attempting to add v1 and v2 raises a ValueError because they have different dimensions. Accessing v1[5] raises an IndexError because the vector only has 2 dimensions (indices 0 and 1).

Constraints

• The Vector class will be initialized with a list or tuple of numbers (integers or floats).
• All implemented magic methods should return new Vector objects where appropriate (e.g., for addition, subtraction, scalar multiplication) rather than modifying the original object in place.
• Error handling for incompatible dimensions and out-of-bounds indexing is required.

Notes

• Consider how to handle the case where the input to __init__ is empty or not a list/tuple. For this challenge, focus on the magic methods themselves assuming valid input structure.
• Think about the difference between __str__ and __repr__ and when each should be used.
• When implementing arithmetic operations (__add__, __sub__, __mul__), you'll need to create a new Vector object to hold the result.
• You may want to use the isinstance() function to check the type of the operand in binary operations like __add__, __sub__, and __mul__.