You can define a piecewise function for certain intervals by using And function to combine conditions:

from sympy import Symbol, Piecewise, And
x = Symbol('x')
p = Piecewise((3, And(0<=x, x<=5)), (5, x>5))

Here I ensured that the function is defined only for 0 <= x <= 5. For x > 5 the function returns 5 and for x < 0, the function is undefined.

It would be helpful if you give an example of how Piecewise did not do what you wanted. Piecewise will work with And (and intervals expressed with the same):

Are you sure you're running the code you posted? You have misspelt functionleft in the last line and despite the .Piecewise function doc showing it should be called like:

Piecewise( (expr,cond), (expr,cond), ... )

your post shows the third param as a 3-tuple??

I think it has to do with the order in which you supply the conditionals. From sympy.Piecewise doc, "the conditions are evaluated in turn, returning the first that is True.:

 |    Piecewise( (expr,cond), (expr,cond), ... )
 |      - Each argument is a 2-tuple defining an expression and condition
 |      - The conds are evaluated in turn returning the first that is True.
 |        If any of the evaluated conds are not determined explicitly False,
 |        e.g. x < 1, the function is returned in symbolic form.

I find that reshaping the conds like this:

import sympy as sym
import sympy.plotting as sym_plot
sym.init_printing()
x= sym.symbols('x')
f_2 = sym.Piecewise((0, x<=4), (0, x >=6), (1, x<6), (1, x>4))
sym_plot.plot(f_2, (x,-10,10))

...gives me this:

Is this what you're after?

By the way - it's interesting to evaluate f_2 by itself to see how it formulates itself based on the conditionals you give it. Your original code produced an f_2 that evaluated to 1. I tried to shape the conditionals a couple of different ways and evaluated f_2 for each attempt until I got the following based on the formulation of f_2 I've shown above:

⎧0  for x ≥ 6 ∨ x ≤ 4
⎨                    
⎩1      otherwise 

So evaluating it like this gives you a useful way to check that f_2 ends up meaning what you wanted it to mean.

Use a.args[index] will give a corresponding tuple (expr, cond), a.args[index][0] will give the expr, and [1] the cond

You need to tell Piecewise that you want the function to evaluate to zero when outside the bounds, for example:

import sympy as sp

x = sp.Symbol('x')

phi_1 = sp.Piecewise(
    (0, x < 1),
    (0, x > 1.3),
    ( (1.3-x)/0.3, True )
)

print(phi_1.subs(x,1.2)) # 0.333333333333334

print(phi_1.subs(x,1.4)) # 0

Note that this syntax works in 0.7.1 and 0.7.6 -- your code raises an TypeError in 0.7.6 with the "compound conditional" 1 <=x <=1.3

#!/usr/bin/env python
import numpy as np
import matplotlib.pyplot as plt 

def fun (n, x): 
    if n <= x <= n + 1:
        return float(x) - n 
    elif n + 1 <= x <= n + 2:
        return 2.0 - x + n 
    return 0.0 

vfun = np.vectorize(fun)

x = np.linspace(0, 10, 1000)    
y = vfun(3, x)

plt.plot(x, y, '-')
plt.show()