Python, Avoid overwriting argument to function

Question

I am very new to Python and was surprised to find that this section of my code:

print len(allCommunities[5].boundary)
allCommunities[5].surface = triangularize(allCommunities[5].boundary)
print len(allCommunities[5].boundary)

Outputs this:

1310
2

Below is a function I wrote in Processing (a language like Java) and ported into Python. It does what it is supposed to (triangulate a polygon) but my intention was to pass inBoundary for the function to use but not remove elements from allCommunities[5].boundary.

How should I go about preventing allCommunities[5].boundary from being modified in the function? On a side note, I would appreciate pointers if I am doing something silly otherwise in the function, still getting used to Python.

def triangularize(inBoundary):
    outSurface = []

    index = 0;
    while len(inBoundary) > 2:
        pIndex = (index+len(inBoundary)-1)%len(inBoundary);
        nIndex = (index+1)%len(inBoundary);

        bp = inBoundary[pIndex]
        bi = inBoundary[index]
        bn = inBoundary[nIndex]

        # This assumes the polygon is in clockwise order
        theta = math.atan2(bi.y-bn.y, bi.x-bn.x)-math.atan2(bi.y-bp.y, bi.x-bp.x);
        if theta < 0.0: theta += math.pi*2.0;

        # If bp, bi, and bn describe an "ear" of the polygon
        if theta < math.pi:
            inside = False;

            # Make sure other vertices are not inside the "ear"
            for i in range(len(inBoundary)):
                if i == pIndex or i == index or i == nIndex: continue;

                # Black magic point in triangle expressions
                # http://answers.yahoo.com/question/index?qid=20111103091813AA1jksL
                pi = inBoundary[i]
                ep = (bi.x-bp.x)*(pi.y-bp.y)-(bi.y-bp.y)*(pi.x-bp.x)
                ei = (bn.x-bi.x)*(pi.y-bi.y)-(bn.y-bi.y)*(pi.x-bi.x)
                en = (bp.x-bn.x)*(pi.y-bn.y)-(bp.y-bn.y)*(pi.x-bn.x)

                # This only tests if the point is inside the triangle (no edge / vertex test)
                if (ep < 0 and ei < 0 and en < 0) or (ep > 0 and ei > 0 and en > 0):
                    inside = True;
                    break

            # No vertices in the "ear", add a triangle and remove bi
            if not inside:
                outSurface.append(Triangle(bp, bi, bn))
                inBoundary.pop(index)
        index = (index+1)%len(inBoundary)
    return outSurface

print len(allCommunities[5].boundary)
allCommunities[5].surface = triangularize(allCommunities[5].boundary)
print len(allCommunities[5].boundary)

Related: least astonishment in python, the mutable default argument — Burhan Khalid
– Burhan Khalid, Commented Sep 19, 2013 at 8:00
@BurhanKhalid: Not really. There's no default argument at all here, let alone a mutable one. This is more about Python's call-by-object-reference semantics. — user2357112
– user2357112, Commented Sep 19, 2013 at 8:09

Fred Foo · Accepted Answer · 2013-09-19 07:58:26Z

4

Lists in Python are mutable, and operations such as

inBoundary.pop

modify them. The easy solution is to copy the list inside the function:

def triangularize(inBoundary):
    inBoundary = list(inBoundary)
    # proceed as before

answered Sep 19, 2013 at 7:58

Fred Foo

365k80 gold badges765 silver badges852 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

asimes Over a year ago

There is not a problem with them having the same name?

sberry Over a year ago

@asimes: Nope, that is not a problem.

Fred Foo Over a year ago

@asimes: on the contrary, the name inBoundary will just get re-bound to the new value (the copy), and only inside the function.

asimes Over a year ago

Personally I find that confusing for usage even if having two of the same variable name works

Fred Foo Over a year ago

@asimes: it can be very advantageous to reuse variable names, since you can't accidentally use the "wrong" value anymore (the unvalidated input). I use this idiom all the time in input validation code, and find that it's more robust than inventing a new name.

sberry · Accepted Answer · 2013-09-19 07:58:22Z

3

The easiest thing to do would be to make a copy of the argument coming in:

def triangularize(origBoundary):
    inBoundary = origBoundary[:]

Then the rest of your code can stay the same.

answered Sep 19, 2013 at 7:58

sberry

133k20 gold badges145 silver badges171 bronze badges

Collectives™ on Stack Overflow

Python, Avoid overwriting argument to function

2 Answers 2

5 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related