如何在Python中拉伸浮点列表？

Question

I'm working in Python and have a list of hourly values for a day. For simplicity let's say there are only 10 hours in a day.

 [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]

I want to stretch this around the centre-point to 150% to end up with:

 [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0]

Note this is just an example and I will also need to stretch things by amounts that leave fractional amounts in a given hour. For example stretching to 125% would give:

 [0.0, 0.0, 0.5, 1.0, 1.0, 1.0, 1.0, 0.5, 0.0, 0.0]

My first thought for handling the fractional amounts is to multiply the list up by a factor of 10 using np.repeat , apply some method for stretching out the values around the midpoint, then finally split the list into chunks of 10 and take the mean for each hour.

My main issue is the "stretching" part but if the answer also solves the second part so much the better.

Answer 1

I guess, you need something like that:

def stretch(xs, coef):
  # compute new distibution
  oldDist = sum(hours[:len(hours)/2])
  newDist = oldDist * coef

  # generate new list
  def f(x):
    if newDist - x < 0:
      return 0.0
    return min(1.0, newDist - x)

  t = [f(x) for x in range(len(xs)/2)]
  res = list(reversed(t))
  res.extend(t)
  return res

But be careful with odd count of hours.

Answer 2

If I look at the expected output, the algorithm goes something like this:

• start with a list of numbers, values >0.0 indicate working hours
• sum those hours
• compute how many extra hours are requested
• divide those extra hours over both ends of the sequence by prepending or appending half of this at each 'end'

So:

hours     = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]
expansion = 130
extra_hrs = float(sum(hours)) * float(expansion - 100)/100

# find indices of the first and last non-zero hours
# because of floating point can't use "==" for comparison.
hr_idx    = [idx for (idx, value) in enumerate(hours) if value>0.001]

# replace the entries before the first and after the last 
# with half the extra hours
print "Before expansion:",hours
hours[ hr_idx[0]-1 ] = hours[ hr_idx[-1]+1 ] = extra_hrs/2.0
print "After  expansion:",hours

Gives as output:

Before expansion: [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]
After  expansion: [0.0, 0.0, 0.6, 1.0, 1.0, 1.0, 1.0, 0.6, 0.0, 0.0]

Answer 3

This is what I've ended up doing. It's a little ugly as it needs to handle stretch coefficients less than 100%.

def stretch(xs, coef, centre):
    """Scale a list by a coefficient around a point in the list.

    Parameters
    ----------
    xs : list
        Input values.
    coef : float
        Coefficient to scale by.
    centre : int
        Position in the list to use as a centre point.

    Returns
    -------
    list

    """
    grain = 100    
    stretched_array = np.repeat(xs, grain * coef)

    if coef < 1:
        # pad start and end
        total_pad_len = grain * len(xs) - len(stretched_array)
        centre_pos = float(centre) / len(xs)
        start_pad_len = centre_pos * total_pad_len
        end_pad_len = (1 - centre_pos) * total_pad_len
        start_pad = [stretched_array[0]] * int(start_pad_len)
        end_pad = [stretched_array[-1]] * int(end_pad_len)
        stretched_array = np.array(start_pad + list(stretched_array) + end_pad)
    else:
        pivot_point = (len(xs) - centre) * grain * coef
        first = int(pivot_point - (len(xs) * grain)/2)
        last = first + len(xs) * grain
        stretched_array = stretched_array[first:last]

    return [round(chunk.mean(), 2) for chunk in chunks(stretched_array, grain)]


def chunks(iterable, n):
    """
    Yield successive n-sized chunks from iterable.
    Source: http://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks-in-python#answer-312464

    """
    for i in xrange(0, len(iterable), n):
        yield iterable[i:i + n]