Inheriting From list vs UserList – Real Python

Creating Listing-Like Courses in Python

The built-in list class is a basic knowledge sort in Python. Lists are helpful in lots of conditions and have tons of sensible use instances. In a few of these use instances, the usual performance of Python listing could also be inadequate, and chances are you’ll have to create customized list-like courses to handle the issue at hand.

You’ll sometimes discover no less than two causes for creating customized list-like courses:

1. Extending the common listing by including new performance
2. Modifying the usual listing’s performance

It’s also possible to face conditions by which you might want to each lengthen and modify the listing’s normal performance.

Relying in your particular wants and talent degree, you need to use a couple of methods to create your individual customized list-like courses. You’ll be able to:

There are a couple of concerns if you’re choosing the suitable technique to make use of. Maintain studying for extra particulars.

Constructing a Listing-Like Class From an Summary Base Class

You’ll be able to create your individual list-like courses by inheriting from an applicable summary base class (ABC), like MutableSequence. This ABC gives generic implementations of most listing strategies aside from .__getitem__(), .__setitem__(), .__delitem__, .__len__(), and .insert(). So, when inheriting from this class, you’ll need to implement these strategies your self.

Writing your individual implementation for all these special methods is a good quantity of labor. It’s error-prone and requires superior information of Python and its data model. It might probably additionally indicate efficiency points since you’ll be writing the strategies in pure Python.

Moreover, suppose you might want to customise the performance of another normal listing methodology, like .append() or .insert(). In that case, you’ll need to override the default implementation and supply an appropriate implementation that fulfills your wants.

The primary benefit of this technique for creating list-like courses is that the mother or father ABC class will provide you with a warning should you miss any required strategies in your customized implementation.

Basically, you need to embrace this technique provided that you want a list-like class that’s essentially totally different from the built-in listing class.

On this tutorial, you’ll deal with creating list-like courses by inheriting from the built-in listing class and the UserList class from the standard-library collections module. These methods appear to be the quickest and most sensible ones.

Inheriting From Python’s Constructed-in listing Class

For a very long time, it was unimaginable to inherit straight from Python sorts applied in C. Python 2.2 fastened this subject. Now you possibly can subclass built-in types, together with listing. This variation has introduced a number of technical benefits to the subclasses as a result of now they:

The primary merchandise on this listing could also be a requirement for C code that expects a Python built-in class. The second merchandise permits you to add new performance on prime of the usual listing conduct. Lastly, the third merchandise will allow you to limit the attributes of a subclass to solely these attributes predefined in .__slots__.

To kick issues off and begin creating customized list-like courses, say that you just want an inventory that routinely shops all its objects as strings. Assuming that your customized listing will retailer numbers as strings solely, you possibly can create the next subclass of listing:

# string_list.py

class StringList(listing):
    def __init__(self, iterable):
        tremendous().__init__(str(merchandise) for merchandise in iterable)

    def __setitem__(self, index, merchandise):
        tremendous().__setitem__(index, str(merchandise))

    def insert(self, index, merchandise):
        tremendous().insert(index, str(merchandise))

    def append(self, merchandise):
        tremendous().append(str(merchandise))

    def lengthen(self, different):
        if isinstance(different, sort(self)):
            tremendous().lengthen(different)
        else:
            tremendous().lengthen(str(merchandise) for merchandise in different)

Your StringList class subclasses listing straight, which implies that it’ll inherit all of the performance of a typical Python listing. Since you need your listing to retailer objects as strings, you might want to modify all of the strategies that add or modify objects within the underlying listing. These strategies embody the next:

• .__init__ initializes all the category’s new cases.
• .__setitem__() permits you to assign a brand new worth to an current merchandise utilizing the merchandise’s index, like in a_list[index] = merchandise.
• .insert() permits you to insert a brand new merchandise at a given place within the underlying listing utilizing the merchandise’s index.
• .append() provides a single new merchandise on the finish of the underlying listing.
• .lengthen() provides a collection of things to the top of the listing.

The opposite strategies that your StringList class inherited from listing work simply tremendous as a result of they don’t add or replace objects in your customized listing.

To make use of StringList in your code, you are able to do one thing like this:

>>> from string_list import StringList

>>> knowledge = StringList([1, 2, 2, 4, 5])
>>> knowledge
['1', '2', '2', '4', '5']

>>> knowledge.append(6)
>>> knowledge
['1', '2', '2', '4', '5', '6']

>>> knowledge.insert(0, 0)
>>> knowledge
['0', '1', '2', '2', '4', '5', '6']

>>> knowledge.lengthen([7, 8, 9])
>>> knowledge
['0', '1', '2', '2', '4', '5', '6', '7', '8', '9']

>>> knowledge[3] = 3
>>> knowledge
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

Your class works as anticipated. It converts all of the enter values into strings on the fly. That’s cool, isn’t it? Whenever you create a brand new occasion of StringList, the category’s initializer takes care of the conversion.

Whenever you append, insert, lengthen, or assign new values to the category’s cases, the strategies that assist every operation will care for the string conversion course of. This fashion, your listing will at all times retailer its objects as string objects.

Subclassing UserList From collections

One other method to create a customized list-like class is to make use of the UserList class from the collections module. This class is a wrapper across the built-in listing sort. It was designed for creating list-like objects again when it wasn’t doable to inherit from the built-in listing class straight.

Despite the fact that the necessity for this class has been partially supplanted by the potential for straight subclassing the built-in listing class, UserList remains to be out there within the standard library, each for comfort and for backward compatibility.

The distinguishing function of UserList is that it provides you entry to its .knowledge attribute, which might facilitate the creation of your customized lists since you don’t want to make use of super() on a regular basis. The .knowledge attribute holds a daily Python listing, which is empty by default.

Right here’s how one can reimplement your StringList class by inheriting from UserList:

# string_list.py

from collections import UserList

class StringList(UserList):
    def __init__(self, iterable):
        tremendous().__init__(str(merchandise) for merchandise in iterable)

    def __setitem__(self, index, merchandise):
        self.knowledge[index] = str(merchandise)

    def insert(self, index, merchandise):
        self.knowledge.insert(index, str(merchandise))

    def append(self, merchandise):
        self.knowledge.append(str(merchandise))

    def lengthen(self, different):
        if isinstance(different, sort(self)):
            self.knowledge.lengthen(different)
        else:
            self.knowledge.lengthen(str(merchandise) for merchandise in different)

On this instance, accessing the .knowledge attribute permits you to code the category in a extra simple manner by utilizing delegation, which implies that the listing in .knowledge takes care of dealing with all of the requests.

Now you nearly don’t have to make use of superior instruments like tremendous(). You simply have to name this operate within the class initializer to stop issues in additional inheritance situations. In the remainder of the strategies, you simply benefit from .knowledge, which holds a daily Python listing. Working with lists is a talent that you just most likely have already got.

This new model works the identical as your first model of StringList. Go forward and run the next code to strive it out:

>>> from string_list import StringList

>>> knowledge = StringList([1, 2, 2, 4, 5])
>>> knowledge
['1', '2', '2', '4', '5']

>>> knowledge.append(6)
>>> knowledge
['1', '2', '2', '4', '5', '6']

>>> knowledge.insert(0, 0)
>>> knowledge
['0', '1', '2', '2', '4', '5', '6']

>>> knowledge.lengthen([7, 8, 9])
>>> knowledge
['0', '1', '2', '2', '4', '5', '6', '7', '8', '9']

>>> knowledge[3] = 3
>>> knowledge
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

Exposing .knowledge is probably the most related function of UserList, as you’ve already realized. This attribute can simplify your courses since you don’t want to make use of tremendous() on a regular basis. You’ll be able to simply benefit from .knowledge and use the acquainted listing interface to work with this attribute.

Coding Listing-Like Courses: Sensible Examples

You already know the right way to use listing and UserList when you might want to create customized list-like courses that add or modify the usual performance of listing.

Admittedly, if you consider making a list-like class, inheriting from listing most likely appears extra pure than inheriting from UserList as a result of Python builders find out about listing. They may not concentrate on the existence of UserList.

You additionally know that the primary distinction between these two courses is that if you inherit from UserList, you’ve got entry to the .knowledge attribute, which is a daily listing which you can manipulate by the usual listing interface. In distinction, inheriting from listing requires superior information about Python’s knowledge mannequin, together with instruments just like the built-in tremendous() operate and a few particular strategies.

Within the following sections, you’ll code a couple of sensible examples utilizing each courses. After writing these examples, you’ll be higher ready to pick out the correct instrument to make use of when you might want to outline customized list-like courses in your code.

# number_list.py

class NumberList(listing):
    def __init__(self, iterable):
        tremendous().__init__(self._validate_number(merchandise) for merchandise in iterable)

    def __setitem__(self, index, merchandise):
        tremendous().__setitem__(index, self._validate_number(merchandise))

    def insert(self, index, merchandise):
        tremendous().insert(index, self._validate_number(merchandise))

    def append(self, merchandise):
        tremendous().append(self._validate_number(merchandise))

    def lengthen(self, different):
        if isinstance(different, sort(self)):
            tremendous().lengthen(different)
        else:
            tremendous().lengthen(self._validate_number(merchandise) for merchandise in different)

    def _validate_number(self, worth):
        if isinstance(worth, (int, float, advanced)):
            return worth
        elevate TypeError(
            f"numeric worth anticipated, acquired sort(worth).__name__"
        )

>>> from number_list import NumberList

>>> numbers = NumberList([1.1, 2, 3j])
>>> numbers
[1.1, 2, 3j]

>>> numbers.append("4.2")
Traceback (most up-to-date name final):
    ...
TypeError: numeric worth anticipated, acquired str

>>> numbers.append(4.2)
>>> numbers
[1.1, 2, 3j, 4.2]

>>> numbers.insert(0, "0")
Traceback (most up-to-date name final):
    ...
TypeError: numeric worth anticipated, acquired str

>>> numbers.insert(0, 0)
>>> numbers
[0, 1.1, 2, 3j, 4.2]

>>> numbers.lengthen(["5.3", "6"])
Traceback (most up-to-date name final):
    ...
TypeError: numeric worth anticipated, acquired str

>>> numbers.lengthen([5.3, 6])
>>> numbers
[0, 1.1, 2, 3j, 4.2, 5.3, 6]

# number_list.py

from collections import UserList

class NumberList(UserList):
    def __init__(self, iterable):
        tremendous().__init__(self._validate_number(merchandise) for merchandise in iterable)

    def __setitem__(self, index, merchandise):
        self.knowledge[index] = self._validate_number(merchandise)

    def insert(self, index, merchandise):
        self.knowledge.insert(index, self._validate_number(merchandise))

    def append(self, merchandise):
        self.knowledge.append(self._validate_number(merchandise))

    def lengthen(self, different):
        if isinstance(different, sort(self)):
            self.knowledge.lengthen(different)
        else:
            self.knowledge.lengthen(self._validate_number(merchandise) for merchandise in different)

    def _validate_number(self, worth):
        if isinstance(worth, (int, float, advanced)):
            return worth
        elevate TypeError(
            f"numeric worth anticipated, acquired sort(worth).__name__"
        )

# custom_list.py

class CustomList(listing):
    def be part of(self, separator=" "):
        return separator.be part of(str(merchandise) for merchandise in self)

    def map(self, motion):
        return sort(self)(motion(merchandise) for merchandise in self)

    def filter(self, predicate):
        return sort(self)(merchandise for merchandise in self if predicate(merchandise))

    def for_each(self, func):
        for merchandise in self:
            func(merchandise)

>>> from custom_list import CustomList

>>> phrases = CustomList(
...     [
...         "Hello,",
...         "Pythonista!",
...         "Welcome",
...         "to",
...         "Real",
...         "Python!"
...     ]
... )

>>> phrases.be part of()
'Good day, Pythonista! Welcome to Actual Python!'

>>> phrases.map(str.higher)
['HELLO,', 'PYTHONISTA!', 'WELCOME', 'TO', 'REAL', 'PYTHON!']

>>> phrases.filter(lambda phrase: phrase.startswith("Py"))
['Pythonista!', 'Python!']

>>> phrases.for_each(print)
Good day,
Pythonista!
Welcome
to
Actual
Python!

# custom_list.py

from collections import UserList

class CustomList(UserList):
    def be part of(self, separator=" "):
        return separator.be part of(str(merchandise) for merchandise in self)

    def map(self, motion):
        return sort(self)(motion(merchandise) for merchandise in self)

    def filter(self, predicate):
        return sort(self)(merchandise for merchandise in self if predicate(merchandise))

    def for_each(self, func):
        for merchandise in self:
            func(merchandise)

# custom_list.py

from collections import UserList

class CustomList(UserList):
    def be part of(self, separator=" "):
        return separator.be part of(str(merchandise) for merchandise in self.knowledge)

    def map(self, motion):
        return sort(self)(motion(merchandise) for merchandise in self.knowledge)

    def filter(self, predicate):
        return sort(self)(merchandise for merchandise in self.knowledge if predicate(merchandise))

    def for_each(self, func):
        for merchandise in self.knowledge:
            func(merchandise)

Contemplating Efficiency: listing vs UserList

Up thus far, you’ve realized the right way to create your individual list-like courses by inheriting from both listing or UserList. You additionally know that the one seen distinction between these two courses is that UserList exposes the .knowledge attribute, which might facilitate the coding course of.

On this part, you’ll contemplate a facet that may be necessary on the subject of deciding whether or not to make use of listing or UserList to create your customized list-like courses. That’s efficiency!

To guage if there are efficiency variations between courses that inherit from listing vs UserList, you’ll use the StringList class. Go forward and create a brand new Python file containing the next code:

# efficiency.py

from collections import UserList

class StringList_list(listing):
    def __init__(self, iterable):
        tremendous().__init__(str(merchandise) for merchandise in iterable)

    def __setitem__(self, index, merchandise):
        tremendous().__setitem__(index, str(merchandise))

    def insert(self, index, merchandise):
        tremendous().insert(index, str(merchandise))

    def append(self, merchandise):
        tremendous().append(str(merchandise))

    def lengthen(self, different):
        if isinstance(different, sort(self)):
            tremendous().lengthen(different)
        else:
            tremendous().lengthen(str(merchandise) for merchandise in different)

class StringList_UserList(UserList):
    def __init__(self, iterable):
        tremendous().__init__(str(merchandise) for merchandise in iterable)

    def __setitem__(self, index, merchandise):
        self.knowledge[index] = str(merchandise)

    def insert(self, index, merchandise):
        self.knowledge.insert(index, str(merchandise))

    def append(self, merchandise):
        self.knowledge.append(str(merchandise))

    def lengthen(self, different):
        if isinstance(different, sort(self)):
            self.knowledge.lengthen(different)
        else:
            self.knowledge.lengthen(str(merchandise) for merchandise in different)

These two courses work the identical. Nonetheless, they’re internally totally different. StringList_list inherits from listing, and its implementation is predicated on tremendous(). In distinction, StringList_UserList inherits from UserList, and its implementation depends on the inner .knowledge attribute.

To check the efficiency of those two courses, you need to start by timing normal listing operations, equivalent to instantiation. Nonetheless, in these examples, each initializers are equal, so they need to carry out the identical.

Measuring the execution time of latest functionalities can also be helpful. For instance, you possibly can examine the execution time of .lengthen(). Go forward and run the next code:

>>> import timeit
>>> from efficiency import StringList_list, StringList_UserList
>>> init_data = vary(10000)

>>> extended_list = StringList_list(init_data)
>>> list_extend = min(
...     timeit.repeat(
...         stmt="extended_list.lengthen(init_data)",
...         quantity=5,
...         repeat=2,
...         globals=globals(),
...     )
... ) * 1e6

>>> extended_user_list = StringList_UserList(init_data)
>>> user_list_extend = min(
...     timeit.repeat(
...         stmt="extended_user_list.lengthen(init_data)",
...         quantity=5,
...         repeat=2,
...         globals=globals(),
...     )
... ) * 1e6

>>> f"StringList_list().lengthen() time: list_extend:.2f μs"
'StringList_list().lengthen() time: 4632.08 μs'

>>> f"StringList_UserList().lengthen() time: user_list_extend:.2f μs"
'StringList_UserList().lengthen() time: 4612.62 μs'

On this efficiency take a look at, you utilize the timeit module together with the min() operate to measure the execution time of a bit of code. The goal code consists of calls to .lengthen() on cases of StringList_list and StringList_UserList utilizing some pattern knowledge.

The efficiency distinction between the category primarily based on listing and the category primarily based on UserList is generally nonexistent on this instance.

Typically, if you create a customized list-like class, you’d count on subclasses of listing to carry out higher than subclasses of UserList. Why? As a result of listing is written in C and optimized for efficiency, whereas UserList is a wrapper class written in pure Python.

Nonetheless, within the above instance, it seems like this assumption isn’t utterly proper. For that reason, to determine which superclass is finest in your particular use case, make certain to run a efficiency take a look at.

Efficiency apart, inheriting from listing is arguably the pure manner in Python, principally as a result of listing is straight out there to Python builders as a built-in class. Moreover, most Python builders will likely be aware of lists and their normal options, which is able to permit them to put in writing list-like courses extra shortly.

In distinction, the UserList class lives within the collections module, that means that you just’ll need to import it if you wish to use it in your code. Moreover, not all Python builders are conscious of the existence of UserList. Nonetheless, UserList can nonetheless be a great tool due to the comfort of accessing the .knowledge attribute, which might facilitate the creation of customized list-like courses.

Conclusion

You’ve now realized the right way to create customized list-like courses with modified and new behaviors. To do that, you’ve subclassed the built-in listing class straight. As a substitute, you’ve additionally inherited from the UserList class, which is out there within the collections module.

Inheriting from listing and subclassing UserList are each appropriate methods for approaching the issue of making your individual list-like courses in Python.

On this tutorial, you realized the right way to:

• Create list-like courses by inheriting from the built-in listing class
• Construct list-like courses by subclassing UserList from the collections module

Now you’re higher ready to create your individual customized lists, permitting you to leverage the complete energy of this handy and commonplace knowledge sort in Python.