I would recommend using a generator because

• it allows you to generate sequences of arbitrary length without wasting memory
• one might argue it is "pythonic".

In the following, I will use the Fibonacci sequence as an example because it takes a similar form to your problem.

def fibonacci(a=0, b=1, length=None):
    # Generate a finite or infinite sequence
    num = 0
    while length is None or num < length:
        # Evaluate the next Fibonacci number
        c = a + b
        yield c
        # Advance to the next item in the sequence
        a, b = c, a
        num += 1

Note that a corresponds to your x_n, b corresponds to x_{n-1}, and c corresponds to x_{n+1}. And a simple example:

>>> list(fibonacci(length=10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

If you want to get the sequence into a numpy array

>>> np.fromiter(fibonacci(length=10), int)
array([ 1,  1,  2,  3,  5,  8, 13, 21, 34, 55])

There are bunch of nonlinear function that can be used for the task (some are listed here). Below is a simple exponential function to generate nonlinear array between two numbers. You can control curvature in the function:

import numpy as np

def nonlinspace(start, stop, num):
    linear = np.linspace(0, 1, num)
    my_curvature = 1
    curve = 1 - np.exp(-my_curvature*linear)
    curve = curve/np.max(curve)   #  normalize between 0 and 1
    curve  = curve*(stop - start-1) + start
    return curve

arr = nonlinspace(7, 21, 10)

#rounded result : [ 7., 9.16, 11.1, 12.83, 14.38, 15.77, 17.01, 18.12, 19.11, 20.]

You can use np.add.reduceat and int.bit_length.

Example:

# make example sequence
a = np.arange(100.0)

# form sums
np.add.reduceat(a,(1<<np.arange(a.size.bit_length()))-1)
# array([   0.,    3.,   18.,   84.,  360., 1488., 2997.])

This adds items 0; 1+2; 3+4+5+6; etc. which your example suggests is what you really want.

Given numpy, you could use linspace:

Including the right endpoint (5):

In [46]: import numpy as np
In [47]: np.linspace(0,5,10)
Out[47]: 
array([ 0.        ,  0.55555556,  1.11111111,  1.66666667,  2.22222222,
        2.77777778,  3.33333333,  3.88888889,  4.44444444,  5.        ])

Excluding the right endpoint:

In [48]: np.linspace(0,5,10,endpoint=False)
Out[48]: array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])