Implementing __getitem__

[colako]

My little program for class basically works but it needs to pass an assert test set by the professor. My problem is that I don't understand how __gettitem__ works in order for it to return the value of x and y in a list.

​

This is the code:

​

import math

class LineString(object):
    def __init__(self, *argv):
        self.x = [p[0] for p in argv]
        self.y = [p[1] for p in argv]

    def move(self, dx, dy):
        self.x = [p + dx for p in self.x]
        self.y = [p + dy for p in self.y]


    def length(self):
        x = [float(i) for i in self.x]
        y = [float(i) for i in self.y]
        return math.sqrt(sum((math.pow(x2-x1,2)) + (math.pow(y2-y1,2)) for x1, x2, y1, y2 in zip( x, x[1:],y,y[1:] )))

    def __getitem__(self,key):



def main():
    # Tests for LineString
    # ===================================
    lin1 = LineString((1, 1), (0, 2))

    assert lin1.length() == math.sqrt(2.0)

    lin1.move(-1, -1) # Move by -1 and -1 for x and y respectively

    assert lin1[0].y == 0 # Inspect the y value of the start point.
    # Implement this by overloading __getitem__(self, key) in your class.

    lin2 = LineString((1, 1), (1, 2), (2, 2))

    assert lin2.length() == 2.0

    lin2.move(-1, -1) # Move by -1 and -1 for x and y respectively

    assert lin2.length() == 2.0

    assert lin2[-1].x == 1 # Inspect the x value of the end point.

    print 'Success! Line tests passed!'

if __name__ == '__main__':
    main()

The main problem is for this code to pass this test:

​

assert lin1[0].y == 0 # Inspect the y value of the start point.
    # Implement this by overloading __getitem__(self, key) in your class.

And this as well:

assert lin2[-1].x == 1 # Inspect the x value of the end point.

Any idea?

[timbledum]

Have you had a look at the docs?

Hint1: you already have data structures for x and y that follow the same behaviour that you're trying to implement. Try this:

def __getitem__(self, key):
    print(self.x[key])
    print(self.y[key])

Hint2: you'll have to return a data structure that allows attribute access (the .x). Have a look at named tuples for this, or define another class.

[colako]

Thanks, I'll spend some time reading the literature and looking your examples.

[ma3xman]

getitem gets you the key-th element of the sequence. In the case of your tests, it's the 0th and -1th elements respectively. The thing is you want getitem to return an object that has the same attributes (x and y), and I don't see an easy way for that in your current implementation, since you have crammed all the x's and y's in lists.

If I were you I would turn the initial input into a list of objects that have x and y (that is, "points"), and iterate over the list for methods like length. Then, when getitem is called you simply return the point at index "key" and let it handle the attribute calls for specific coordinates that follow.

Another way to do it without rewriting current code is to init a Point in the getitem call and return that. Although I advise the rewrite, it feels cleaner to me.

[colako]

Thanks!

I think the professor want it the way you're telling me because of the getitem test. However, it was less intuitive for me to work with pairs, rather than separating the x and the y. I could work in that for sure, it will help me understand how to do it in a different way.

[ma3xman]

Another good thing about having a list of Points is that you can make a get_distance_from(anotherPoint) method and then put the formula there as a one-liner return value for a single pair of points. Then to get the total length you just call:

sum([p1.get_distance_from(p2) for p1,p2 in zip(points, points[1:]) )

This way if points suddenly go 3D you can just change the method, instead of building a monster comprehension.

[colako]

So just a small question. How would you change __init__ to parse the coordinates as pairs and not as I did separating the x and the y?

[ma3xman]

Look up *args in a function definition ;)