A Python question

[C++buntu]

Hi everyone,

I define a little function in Python like this:

def f(t, T):
    if 0 < t < T/2.0:
        value = 1.0
    elif t == T/2.0:
        value = 0.0
    elif T/2.0 < t < float(T):
        value = -1.0
    return value

And when i run this in IPython, I obtain the following error:

---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)

/home/cppbuntu/Desktop/Python/Problems/Chapter 02/<ipython console> in <module>()

/home/cppbuntu/Desktop/Python/Problems/Chapter 02/<ipython console> in f(t, T)

UnboundLocalError: local variable 'value' referenced before assignment

I don't understand...how can the variable 'value' be referenced before assignment in this code?

Thanks for the help.

[tribaal]

Ah, classical mistake

Simply put, if the code passes in no branch, you ask python to return "value" when it has not been defined.

Probably your second "elif" statement should be an "else" statement (so as to catch all cases), or even better, you should declare your "value" variable before entering the conditional part of the code (i.e. before "if").
Assign it to be "None" if you can't think of any sensible default value.

Here's your code, corrected:

def f(t, T):
    value = 0
    if 0 < t < T/2.0:
        value = 1.0
    elif t == T/2.0:
        value = 0.0
    elif T/2.0 < t < float(T): #Maybe if could simply be "else:"?
        value = -1.0

    return value

[Rinzwind]

When variables are assigned inside a function, they are always bound to the function's local namespace. The global namespace is never checked for 'value', hence the error. Your if's misses an else to catch all branches of the if.

damn I lost to tribaal

[Can+~]

elif t == T/2.0: 

Aside from what has been said above, you should NEVER compare floats directly, not in python, not in C/C++, not in Java, never (int and decimal are fine).

Why? Because of the specification of floating point by the IEEE, floats are never accurate, as simple as doing:

>>> 1.1 + 2.0
3.1000000000000001 

Leads to unexpected errors, floats must be used inside ranges.

*edit:
If you care for precision, then use the Decimal module (Fixed point). But it seems that you're working on things related to physics, so stick with float, but test within ranges as I told you before, as computational error are minimal compared to real life measurement errors (unless you count going out of range, overflows, etc)

[C++buntu]

So many thanks to all of you! Good explanations! Very appreciated.

[C++buntu]

So, you test for what?
elif abs(t - T/2.0) < 1e-6:
<statements>
doesn't work either...i need that my function f(t, 2) return the value 0.0 when t = 1.0...

[Can+~]

def feq(a, b, epsylon=0.000001):
    return abs(a - b) < epsylon 

So now:

feq(0.1, 0.10000001) # yields true 

[C++buntu]

Yeah, that's exactly what i've done...

def f(t, T):
    if 0 < t < T/2.0:
        value = 1.0
    elif T/2.0 < t < float(T):
        value = -1.0
    elif abs(t - T/2.0) < 1e-6:
        value = 0.0
    else:
        value = 0.0
    return value

# i know that i can use the numpy module...
# but for this problem, it's supposed that we don't know yet ;)
def makelist(start, stop, inc):
    val = start
    tmp   = []
    while val <= (stop + inc):
        tmp.append(val)
        val += inc
    return tmp
    
for t in makelist(0, 2.5, 0.1):
    print '%5.2f\t%5.2f' % (t, f(t, 2))

The result of this is

 0.00     0.00
 0.10     1.00
 0.20     1.00
 0.30     1.00
 0.40     1.00
 0.50     1.00
 0.60     1.00
 0.70     1.00
 0.80     1.00
 0.90     1.00
 1.00     1.00 # supposed to be 0.0!
 1.10    -1.00
 1.20    -1.00
 1.30    -1.00
 1.40    -1.00
 1.50    -1.00
 1.60    -1.00
 1.70    -1.00
 1.80    -1.00
 1.90    -1.00
 2.00     0.00
 2.10     0.00
 2.20     0.00
 2.30     0.00
 2.40     0.00
 2.50     0.00

What i'm missing?

[WitchCraft]

C++ has a definition for the machine epsilon, you might use that one.

[Arndt]

Yeah, that's exactly what i've done...

def f(t, T):
    if 0 < t < T/2.0:
        value = 1.0
    elif T/2.0 < t < float(T):
        value = -1.0
    elif abs(t - T/2.0) < 1e-6:
        value = 0.0
    else:
        value = 0.0
    return value

# i know that i can use the numpy module...
# but for this problem, it's supposed that we don't know yet ;)
def makelist(start, stop, inc):
    val = start
    tmp   = []
    while val <= (stop + inc):
        tmp.append(val)
        val += inc
    return tmp
    
for t in makelist(0, 2.5, 0.1):
    print '%5.2f\t%5.2f' % (t, f(t, 2))

The result of this is

 0.00     0.00
 0.10     1.00
 0.20     1.00
 0.30     1.00
 0.40     1.00
 0.50     1.00
 0.60     1.00
 0.70     1.00
 0.80     1.00
 0.90     1.00
 1.00     1.00 # supposed to be 0.0!
 1.10    -1.00
 1.20    -1.00
 1.30    -1.00
 1.40    -1.00
 1.50    -1.00
 1.60    -1.00
 1.70    -1.00
 1.80    -1.00
 1.90    -1.00
 2.00     0.00
 2.10     0.00
 2.20     0.00
 2.30     0.00
 2.40     0.00
 2.50     0.00

What i'm missing?

Put a print statement in each branch of f and see which path the execution takes.

(Was this solved? Is it unsolved again?)