It's probably faster and easier to use numpy.digitize():

import numpy
data = numpy.random.random(100)
bins = numpy.linspace(0, 1, 10)
digitized = numpy.digitize(data, bins)
bin_means = [data[digitized == i].mean() for i in range(1, len(bins))]

An alternative to this is to use numpy.histogram():

bin_means = (numpy.histogram(data, bins, weights=data)[0] /
             numpy.histogram(data, bins)[0])

Try for yourself which one is faster... :)

Just use reshape and then mean(axis=1).

As the simplest possible example:

import numpy as np

data = np.array([4,2,5,6,7,5,4,3,5,7])

print data.reshape(-1, 2).mean(axis=1)

More generally, we'd need to do something like this to drop the last bin when it's not an even multiple:

import numpy as np

width=3
data = np.array([4,2,5,6,7,5,4,3,5,7])

result = data[:(data.size // width) * width].reshape(-1, width).mean(axis=1)

print result

You could use np.apply_along_axis:

x = np.array([range(20), range(1, 21), range(2, 22)])

nbins = 2
>>> np.apply_along_axis(lambda a: np.histogram(a, bins=nbins)[0], 1, x)
array([[10, 10],
       [10, 10],
       [10, 10]])

The main advantage (if any) is that it's slightly shorter, but I wouldn't expect much of a performance gain. It's possibly marginally more efficient in the assembly of the per-row results.

Assuming that your y-values are at the corresponding position, i.e., y[i] = f(x[i]) then you can use numpy.digitize to find the indexes of the bins that the x-values belong to and use those indexes to sum up the corresponding y-values.

From the numpy example (ignore that the values are not within [0; 1]):

>>> x = np.array([0.2, 6.4, 3.0, 1.6])
>>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
>>> inds = np.digitize(x, bins)
>>> inds
array([1, 4, 3, 2])

then sum up the values in y:

>>> aggregate = [y[inds == i].sum() for i in np.unique(inds)]

If you're struggling with creating the bins yourself, look at numpy.linspace.

numpy.linspace(0, 1, num=50, endpoint=True)

We could simply reshape to basically split into rows of such groups and hence sum each row for the desired output, like so -

np.reshape(L,(num_bins,-1)).sum(1)

For arrays with lengths not necessarily divisible by the number of bins -

def sum_groups(L, num_bins):
    n  = len(L)
    grp_len = int(np.ceil(n/float(num_bins)))
    b = int(n%num_bins!=0)
    lim = grp_len*(num_bins-b)
    p0 = np.reshape(L[:lim],(-1,grp_len)).sum(1)

    if b!=0:
        p1 = np.sum(L[lim:])
        return np.r_[p0,p1]
    else:
        return p0

Bringing in np.einsum for cases when the binned summations are within the input array dtype precision -

def sum_groups_einsum(L, num_bins):
    n  = len(L)
    grp_len = int(np.ceil(n/float(num_bins)))
    b = int(n%num_bins!=0)
    lim = grp_len*(num_bins-b)
    p0 = np.einsum('ij->i',np.reshape(L[:lim],(-1,grp_len)))

    if b!=0:
        p1 = np.einsum('i->',L[lim:])
        return np.r_[p0,p1]
    else:
        return p0

Benchmarking

Following closely the OP's timing setup -

In [404]: # Setup
     ...: np.random.seed(0)
     ...: L = np.random.randint(0,high = 6, size = 10000000)
     ...: b = 20

In [405]: %timeit sum_groups(L, num_bins=b)
     ...: %timeit sum_groups_einsum(L, num_bins=b)
     ...: %timeit np.array([t.sum() for t in np.array_split(L, b)])
     ...: %timeit np.add.reduceat(L, np.linspace(0.5, L.size+0.5, b, False, dtype=int))
100 loops, best of 3: 6.2 ms per loop
100 loops, best of 3: 6 ms per loop
100 loops, best of 3: 6.25 ms per loop # @user2699's soln
100 loops, best of 3: 6.19 ms per loop # @Paul Panzer's soln

For the case when the array length is not divisible by the number of bins, let's have few more elements in the input array to achieve the same -

In [406]: # Setup
     ...: np.random.seed(0)
     ...: L = np.random.randint(0,high = 6, size = 10000012)
     ...: b = 20

In [407]: %timeit sum_groups(L, num_bins=b)
     ...: %timeit sum_groups_einsum(L, num_bins=b)
     ...: %timeit np.array([t.sum() for t in np.array_split(L, b)])
     ...: %timeit np.add.reduceat(L, np.linspace(0.5, L.size+0.5, b, False, dtype=int))
100 loops, best of 3: 6.45 ms per loop
100 loops, best of 3: 6.05 ms per loop
100 loops, best of 3: 6.45 ms per loop
100 loops, best of 3: 6.51 ms per loop

Running those again few more times, the first one and the last two had very comparable runtimes and the second one with einsum was tiny bit faster than the rest.

The output of np.histogram actually has 10 bins; the last (right-most) bin includes the greatest element because its right edge is inclusive (unlike for other bins).

The np.digitize method doesn't make such an exception (since its purpose is different) so the largest element(s) of the list get placed into an extra bin. To get the bin assignments that are consistent with histogram, just clamp the output of digitize by the number of bins, using fmin.

A = range(1,94)
bin_count = 10
hist = np.histogram(A, bins=bin_count)
np.fmin(np.digitize(A, hist[1]), bin_count)

Output:

array([ 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,
        2,  2,  3,  3,  3,  3,  3,  3,  3,  3,  3,  4,  4,  4,  4,  4,  4,
        4,  4,  4,  5,  5,  5,  5,  5,  5,  5,  5,  5,  6,  6,  6,  6,  6,
        6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,
        8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10,
       10, 10, 10, 10, 10, 10, 10, 10])