In Python, arrays are implemented using the array module, which provides a range of methods for working with arrays. More on mindstick.com

I've read on Stackoverflow that in Python Array doubles in size when run of space It's actually not double, but it does increase proportional to the list size (IIRC it's about 12%, though there's some variance at smaller sizes). This does result in the same asymptotics though, so I'll assume doubling in the following description for simplicity. So basically it has to copy all addresses log(n) times. Not quite. Suppose we're appending n items to an empty vector. We will indeed do log(n) resizes, so you might think "Well, resizes are O(n), so log(n) resizes is n log(n) operations, which if we amortize over the n appends we did means n log(n)/n, or log(n) per append". However, there's a flaw in this analysis: we do not copy "all addresses" each of those times. Ie. the copies are not O(n). Sure, the last copy we do will involve copying n items, but the one before it only copied n/2, and so on. So we actually do 1 + 2 + 4 + ... + n copies, which sums to 2n-1. Divide that by n and you get ~2 operations per append - a constant. I assume since it copies addresses, not information We are indeed only copying the pointer, but this doesn't really matter for the complexity analysis. Even if it was copying a large structure, that'd only increase the time by a constant factor. Does that mean that O(1) is the average time complexity? It's the amortized worst case complexity (ie. what happens over a large number of operations). While any one operation can indeed end up doing O(n) operations, there's an important distinction that over a large number of operations, you are guaranteed to only be O(1), which is a distinction just talking about average case wouldn't capture. More on reddit.com

If you're just learning, just use lists. They have essentially the same interface (meaning everything you can do to an array, you can do to a list), and while they are somewhat less performant, if you're just poking around, that's probably not important. If the performance is a consideration, use NumPy. If you want really fine control over exactly how memory is laid out, use a different language. More on reddit.com

The signature of __getitem__ is __getitem__(self, key) which means that the signature of your function is not valid. Since __getitem__ only accepts a single key, and you need to provide row and col to index into your two-dimensional array, you have two choices: bundle up row and col in a tuple (ie as a single value), or if you want to be able to use something like myarray[x][y], you need to think about how that would be implemented. Some clues. Version one, using a tuple: def __getitem__(self, row_col_as_tuple): row = .... ? col = .....? #How would you obtain `row` and `column` from `row_col_as_tuple`? return ?? Version two, allowing list-like access eg myarray[1][2]. Think what this is actually doing; it first calls myarray[1] and then calls [2] on whatever myarray[1] returns. That is, it is actually making two calls to __getitem__, and consequently, whatever object __getitem__ returns, that object itself must be a class that with a __getitem__ method. def __getitem__(self, key): # where `key` in an integer value = self._arr[?] return ?? # Here you have to return a class with a __getitem__ method that has access to `self._arr`. More on reddit.com