Sequence Magic Methods

Introduction

In this tutorial, we will cover the sequence magic methods in Python. These methods allow you to customize the behavior of your own classes when used in different operations, such as getting the length of an object, accessing items, slicing, and iteration.

Length and Containment

Length and containment methods are special methods in Python that allow objects to define their behavior when used with built-in functions or operators such as len(), in, and not in.

Let's start with a simple object. In sequence.py, create a class named MySequence that have an attribute data.

class MySequence:
    def __init__(self, data: list):
        """Initialize a new MySequence object with the given data."""
        self.data = data

__len__

The __len__ magic method is used to define the behavior of the len() function when applied to instances of your class.

    ## ... (previous code in sequence.py)

    def __len__(self) -> int:
        """Return the length of the sequence."""
        return len(self.data)

__contains__

The __contains__ magic method is used to define the behavior of the in and not in operators when applied to instances of your class.

    ## ... (previous code in sequence.py)

    def __contains__(self, item: object) -> bool:
        """Check if the sequence contains the given item."""
        return item in self.data

Example: Using the Length and Containment Methods

Now that we have defined the length and containment methods for our MySequence class, let's see how they work in length_containment_example.py:

from sequence import MySequence

## Create a MySequence object
my_seq = MySequence([1, 2, 3, 4, 5])

## Test the __len__ magic method
print(len(my_seq))  ## Output: 5

## Test the __contains__ magic method
print(3 in my_seq)  ## Output: True
print(3 not in my_seq)  ## Output: False
print(10 in my_seq)  ## Output: False

Then typing the following command in the terminal to execute the script.

python length_containment_example.py

Item Access

Item access methods are special methods in Python that allow objects to define their behavior when accessed using square bracket notation [].

__getitem__

The __getitem__ magic method is used to define the behavior of the square bracket notation for accessing items in instances of your class.

    ## ... (previous code in sequence.py)

    def __getitem__(self, index: int) -> object:
        """Return the item at the given index."""
        return self.data[index]

__setitem__

The __setitem__ magic method is used to define the behavior of the square bracket notation for setting items in instances of your class.

    ## ... (previous code in sequence.py)

    def __setitem__(self, index: int, value: object) -> None:
        """Set the item at the given index to the given value."""
        self.data[index] = value

__delitem__

The __delitem__ magic method is used to define the behavior of the del keyword when applied to instances of your class.

    ## ... (previous code in sequence.py)

    def __delitem__(self, index: int) -> None:
        """Remove the item at the given index."""
        del self.data[index]

Example: Using the Item Access Methods

Now that we have defined the item access methods for our MySequence class, let's see how they work in item_access_example.py:

from sequence import MySequence

## Create a MySequence object
my_seq = MySequence([1, 2, 3, 4, 5])

## Test the __getitem__ magic method
print(my_seq[2])  ## Output: 3

## Test the __setitem__ magic method
my_seq[2] = 9
print(my_seq[2])  ## Output: 9

## Test the __delitem__ magic method
del my_seq[2]
print(len(my_seq))  ## Output: 4
print(my_seq.data)  ## Output: [1, 2, 4, 5]

Then typing the following command in the terminal to execute the script.

python item_access_example.py

Iteration

Iteration methods are special methods in Python that allow objects to define their behavior when used with iteration protocols.

__iter__

The __iter__ magic method is used to define the behavior of the iter() function and the for ... in ... loop when applied to instances of your class.

    ## ... (previous code in sequence.py)

    def __iter__(self):
        """Return an iterator for the sequence."""
        for item in self.data:
            yield item

__reversed__

The __reversed__ magic method is used to define the behavior of the reversed() function when applied to instances of your class.

    ## ... (previous code in sequence.py)

    def __reversed__(self):
        """Return a reversed iterator for the sequence."""
        return reversed(self.data)

Example: Using the Iteration Methods

Now that we have defined the iteration methods for our MySequence class, let's see how they work in iteration_example.py:

from sequence import MySequence

## Create a MySequence object
my_seq = MySequence([1, 2, 3, 4, 5])

## Test the __iter__ magic method
for item in my_seq:
    print(item, end=" ")  ## Output: 1 2 4 5

## Test the __reversed__ magic method
for item in reversed(my_seq):
    print(item, end=" ")  ## Output: 5 4 2 1

Then typing the following command in the terminal to execute the script.

python iteration_example.py

Summary

With the implemented magic methods, our custom MySequence class now behaves similarly to built-in sequence types such as lists and tuples. You can now use it as if it were a native Python sequence.