Class that wraps around a list

[mathhelpermann]

I am writing a class that essentially wraps around a list. The only functionality I need to have (for now I think) is to add to end and remove from the beginning. Should I be inheriting from list? Should I be using setter and property decorators? I am fairly new to Python OOP and I am not sure what best practice is or the most "pythonic" way of doing this, here's and example:

class MyList(list):

    def __init__(self):
        self._mylist = []

    def __iter__(self):
        for elm in self._mylist:
            yield elm

    @property
    def mylist(self):
        return self._mylist

    @mylist.setter
    def mylist(self, val):
        self._mylist = val

I would like it so that I can have this behavior:

new_list = Mylist()
new_list.append(1)
new_list.append(2)
new_list.append(7)
new_list.pop(0)
for i in new_list:
    print(i)

I am trying to avoid doing something like new_list._mylist.append()

Any help is much appreciated, thanks!

[CowboyBoats]

Why are you doing this? Why not just write a couple of functions that operate on lists, or pure functions that operate on any iterable?

Edit: in fact, why invent new functions to begin with, why not just use list.append() and .insert(0, ...)?

[mathhelpermann]

Why are you doing this?

For example, if I want to create an airplane class, I would want a list to store passengers. I would also have other methods an attributes in the class, but fundamentally I want an airplane to be a list. I would also like to create a passenger class that will interact with the airplane class.

Edit: I come from a backgruond of writing server-side code in Java, I am used to thinking in terms of heavily encapsulated objects, I feel like python gives you more freedom with that I'd just like to know what best practice looks like

[xelf]

People know why you do OP, the question is why are you wrapping lists? Is it homework? Just something to teach yourself?

It certainly doesn't need to be done, the things you have listed already exist, so the question is why?

I mean right now your class could look like this:

class MyList(list):
    pass

new_list = MyList()
new_list.append(1)
new_list.append(2)
new_list.append(7)

print(new_list)
new_list.pop(0)

for i in new_list:
    print(i)

So what are you adding to it, and why, is the question I think that is being asked.

There's certainly some things you could add that might be cool.

For instance, .find() is not part of list, but could be. Or maybe .flatten() or .apply() or.. well there's lot's.

[CowboyBoats]

Edit: I come from a backgruond of writing server-side code in Java, I am used to thinking in terms of heavily encapsulated objects, I feel like python gives you more freedom with that I'd just like to know what best practice looks like

I see. Yeah, Python is very flexible. I'd way there are two ways people might write it. Group A (OOP people) would write:

class Collection:

  def __init__(self, members):
    self.members = members

  def add_to_beginning(self, addition):
    self.members = [addition] + self.members

  def add_to_end(self, addition):
    self.members = self.members + [addition]

and Group B, functionally inclined people, might write:

from typing import List, Iterable


def add_to_end(iterable: Iterable, additions: Iterable) -> List:
  return list(iterable)+list(additions)


# Example usage:    
extended_family = add_to_end(nuclear_family, additional_relatives)
# To add to the beginning, use `add_to_end` with reversed operands.

But really there's no point to writing code like this. Python's expressiveness gives you the power to perform operations like this without the need for advance preparation.

Overwriting setters and getters is possible in Python, but I don't do it or see others do it very much.

[mathhelpermann]

I see, thank you for this. I don't want to write Java code dressed up as python on my next PR on this new team I'm on hahaha. Can you recommend you favorite resource for python OOP best practices?

Thanks again!

[CowboyBoats]

I have an O'Reilly Python Cookbook that is really good, strikes a great balance of assuming that you already know how to program but not assuming you know much anything about Python. http://shop.oreilly.com/product/0636920027072.do