使用相同类型的所有元素对 Python 列表进行子类化

Question

I'm looking for a way to make a subclass of list where all elements are of the same type. I don't need a fully generic implementation, as described in this answer .

What I'd like is something roughly equivalent to the following code (using typing ):

class NumberParty(list[int]):
    def __str__(self) -> str:
        "🎉".join([str(x) for x in self])

    def total(self) -> int:
        return sum(self)

The reason I want this class instead of using List[int] annotations is that I use the __str__ method described above in multiple places and want to eliminate the copied lines of code.

---

As a bonus question, would it be wise to overload __init__ in something similar to the following code?

__init__(self, *numbers: int):
    self = numbers
__init__(self, nums: Iterable[int]):
    self = list(nums)

The first way would be for directly creating a new NumberParty instance while the second would create one from an existing list or set of integers.

Answer 1

Unless I'm misunderstanding your question, just doing:

from typing import List

class NumberParty(List[int]):
    def __str__(self) -> str:
        return "🎉".join([str(x) for x in self])

    def total(self) -> int:
        return sum(self)

...should just work.

Note that inheriting from List[int] is essentially the same as inheriting from list -- the only difference is that type checkers will understand what your custom class is supposed to contain and verify you're using methods like append(...) in a type safe way.

However, there is no difference at runtime, and you can still freely ignore your type checker and append strs or whatever, just like how you Python lets you append strs to regular lists that are annotated to be of type List[int].

And since this class is a subtype of List[int], code snippets like the below should type check:

def expect_list(x: List[int]) -> None: pass

def expect_number_party(x: NumberParty) -> None: pass

n = NumberParty()

# Both type checks
expect_list(n)
expect_number_party(n)

Regarding your question about overriding __init__ -- you'll need to call the super constructor if you decide to take that route to ensure the class is set up properly.

Answer 2

Idea

I don't know. If I understood what you asked or not

What I got from your question is: You want an Array As Marcos said in comments.

And also adding a whole NumPy library to your dependencies for just an array is overkill.

What you need is to make a list-like object which uses a list for storing things and and a public API and several 'magic functions' for making it work like a list (with the filters you want).

Code

from typing import Iterable, optional


class NumberParty:
    def __init__(self, iterable: optional[Iterable] = ()):
        self._inner = [].extend(iterable)


    def __getitem__(self, item):
        return self._inner[item]


    def __setitem__(self, key, value):
        if not isinstance(value, int):
            raise ValueError("NumberParty only accepts integers")
        self._inner[key] = value


    def __len__(self):
        return len(self._inner)


    def __iter__(self):
        return iter(self._inner)


    def append(self, i: int) -> None:
        if not isinstance(i, int):
            raise ValueError("NumberParty only accepts integers")
        self._inner.append(i)


    def insert(self, index: int, i: int) -> None:
        if not isinstance(i, int):
            raise ValueError("NumberParty only accepts integers")

        self.inner[index] = i


    def extend(self, __iterable: Iterable[int]) -> None:
        # Itering through it to check every value
        for i in __iterable:
            if not isinstance(i, int):
                raise ValueError("NumberParty only accepts integers")
            self.append(i)

Please be careful that this NumberParty is not complete Operations like: + - / % * += -= /= %= *= are not implemented but are implemented in original list (plus several public functions which are not implemented here)

Tip for completing this NumberParty object

This Class can be a wrapper around the list object. Waiting for you to complete it ;)

In case you just want type-checkers to show a warning Michael0x2a answer works.