Returning a counter outside of a Python Function

Question

I am trying to build some code and I have defined a function as this to test how a counter works inside of the function:

def errorPrinting(x):
    x += 1
    return x

I then use the function in some conditional logic where I want the counter to increase if the conditions are met.

x = 1

for row in arcpy.SearchCursor(fc):              

    if not row.INCLUSION_TYPE or len(row.TYPE.strip()) == 0:
        errorPrinting(x)
        print x

    elif len(row.TYPE) not in range(2,5):
        errorPrinting(x)
        print x

    elif row.INCLUSION_TYPE.upper() not in [y.upper() for y in TableList]:
        errorPrinting(x)
        print x

I'm still fairly new with using functions, so maybe I am not understanding how to return the value back outside of the function to be used in the next iteration of the for loop. It keeps returning 1 on me. Can anyone show me how to return the x outside of the function after it has been increased by one x+= 1?

Thanks, Mike

Answer 1

You're bit by scope. You may want to check out this link for a quick primer.

You can do something simple and say x = errorPrinting(x) in all cases you call errorPrinting and get what you want. But I think there are better solutions where you'll learn more.

Consider implementing an error logger object that maintains a count for you. Then you can do logger.errorPrinting() and your instance of logger will manage the counter. You may also want to look into python's built in logging facilities.

Answer 2

You're not incrementing your global x, you're incrementing the local paramater that also happens to be named x! (Your parameter to errorPrinting could have been named anything. I'm calling it xLocal.)

As you can see here, x isn't incremented by the function.

>>> def inc(xLocal):
...     xLocal += 1
...     return xLocal
... 
>>> x = 4
>>> inc(x)
5
>>> x
4

You need to reassign the value of x to the return value of the function each time. Like this

x = 1
for row in arcpy.SearchCursor(fc):              

    if not row.INCLUSION_TYPE or len(row.TYPE.strip()) == 0:
        x = errorPrinting(x) # <=== here
        print x

    elif len(row.TYPE) not in range(2,5):
        x = errorPrinting(x) # <=== here
        print x

    elif row.INCLUSION_TYPE.upper() not in [y.upper() for y in TableList]:
        x = errorPrinting(x) # <=== here
        print x

Integral parameters and other primitives aren't normally passed by reference in Python. (Lists, dicts, etc. are. Modifying lists unintentionally is actually a very common mistake in Python.)

Edit: passing by "reference" and "value" isn't really correct to talk about in Python. See this nice question for more details.

So, using my previous example:

>>> x = 4
>>> x = inc(x)
>>> x
5

Note that if this had been parameter that is passed by reference, like a list, this strategy would have worked.

>>> def incList(xList):
...     for i in range(len(xList)):
...         xList[i] += 1
... 
>>> xList
[1]
>>> incList(xList)
>>> xList
[2]

Note that normal, Pythonic syntax:

for i in xList:
    i += 1

would not increment the global value.

Note: If you're looking to keep tabs on a lot of things, I also recommend the logging module that @SB. mentioned. It's super useful and makes debugging large programs a lot easier. You can get time, type of message, etc.

Answer 3

Edited for the OP's benefit, since if functions are a new concept, my earlier comments may be a little hard to follow.

I personally think the nicest way to address this issue is to wrap your related code in an object.

Python is heavily based on the concept of objects, which you can think of as grouping data with functions that operate on that data. An object might represent a thing, or in some cases might just be a convenient way to let a few related functions share some data.

Objects are defined as "classes," which define the type of the object, and then you make "instances," each of which are a separate copy of the grouping of data defined in the class.

class MyPrint(object):

    def __init__(self):
        self.x = 1

    def errorPrinting(self):
        self.x += 1
        return self.x

    def myPrint(self):
        for row in arcpy.SearchCursor(fc):              

            if not row.INCLUSION_TYPE or len(row.TYPE.strip()) == 0:
                self.errorPrinting()
                print self.x

            elif len(row.TYPE) not in range(2,5):
                self.errorPrinting()
                print self.x

            elif row.INCLUSION_TYPE.upper() not in [y.upper() for y in TableList]:
                self.errorPrinting()
                print self.x

p = MyPrint()
p.myPrint()

The functions __init__(self), errorPrinting(self), and myPrint(self), are all called "methods," and they're the operations defined for any object in the class. Calling those functions for one of the class's instance objects automatically sticks a self argument in front of any arguments that contains a reference to the particular instance that the function is called for. self.x refers to a variable that's stored by that instance object, so the functions can share that variable.

What looks like a function call to the class's name:

p = MyPrint()

actually makes a new instance object of class MyPrint, calls MyPrint.__init__(<instance>), where <instance> is the new object, and then assigns the instance to p. Then, calling

p.myprint()

calls MyPrint.myprint(p).

This has a few benefits, in that variables you use this way only last as long as the object is needed, you can have multiple counters for different tasks that are doing the same thing, and scope is all taken care of, plus you're not cluttering up the global namespace or having to pass the value around between your functions.

Answer 4

The simplest fix, though perhaps not the best style:

def errorPrinting():
    global x
    x += 1

Then convert x=errorPrinting(x) to errorPrinting ()

"global x" makes the function use the x defined globally instead of creating one in the scope of the function.

The other examples are good though. Study all of them.