我有一个包含许多条目的Python列表，我需要使用以下任一项进行缩减采样：
（我需要能够做到两种方式，但一次只能使用一种方式）。
我相信对于最大行数，我可以计算出所需的比例并将其传递给比例缩小器：
def downsample_to_max(self, rows, max_rows):
return downsample_to_proportion(rows, max_rows / float(len(rows)))
...所以我真的只需要一个下采样功能。有什么提示吗？
编辑：该列表包含对象，而不是数值，因此我不需要进行插值。删除对象很好。
SOLUTION：
def downsample_to_proportion(self, rows, proportion):
counter = 0.0
last_counter = None
results = []
for row in rows:
counter += proportion
if int(counter) != last_counter:
results.append(row)
last_counter = int(counter)
return results
感谢。
答案 0 :(得分：6)
您可以使用islice中的itertools：
from itertools import islice
def downsample_to_proportion(rows, proportion=1):
return list(islice(rows, 0, len(rows), int(1/proportion)))
用法：
x = range(1,10)
print downsample_to_proportion(x, 0.3)
# [1, 4, 7]
答案 1 :(得分：3)
如果输入已经是序列类型，则直接使用切片语法会更有效，而不是islice() + list()：
def downsample_to_proportion(rows, proportion):
return rows[::int(1 / proportion)]
答案 2 :(得分：0)
保留一个计数器，再增加第二个值。每次都将其放置，并在该索引处产生值。
答案 3 :(得分：0)
这个解决方案可能对原始海报有点矫枉过正，但我想我会分享我用来解决这个问题和类似问题的代码。
它有点冗长（大约90行），但是如果你经常有这个需求，想要一个易于使用的oneliner，并且需要一个纯Python依赖自由的环境，那么我认为它可能是有用的。
基本上，你唯一需要做的就是将你的列表传递给函数并告诉它你想要新列表的长度，函数将是：
所有内容都收集在一个函数中，因此如果您需要它，只需将其复制并粘贴到您的脚本中即可立即开始使用。
例如，您可能会说：
origlist = [0,None,None,30,None,50,60,70,None,None,100]
resizedlist = ResizeList(testlist, 21)
print(resizedlist)
并获取
[0, 5.00000000001, 9.9999999999900009, 15.0, 20.000000000010001, 24.999999999989999, 30, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70, 75.000000000010004, 79.999999999989996, 85.0, 90.000000000010004, 94.999999999989996, 100]
请注意，由于浮点限制，会出现轻微的不准确之处。另外，我为Python 2.x编写了这个，所以要在Python 3.x上使用它，只需添加一行xrange = range。
这是一个很好的技巧，可以在列表列表中的已定位的子项之间进行插值。因此，例如，您可以轻松地在RGB颜色元组之间进行插值，以创建x nr步的颜色渐变。假设RGB颜色元组的列表为3，并且所需的GRADIENTLENGTH变量为：
crosssections = zip(*rgbtuples)
grad_crosssections = ( ResizeList(spectrum,GRADIENTLENGTH) for spectrum in crosssections )
rgb_gradient = [list(each) for each in zip(*grad_crosssections)]
它可能需要相当多的优化，我不得不进行相当多的实验。如果您觉得可以改进，请随时编辑我的帖子。这是代码：
def ResizeList(rows, newlength, stretchmethod="not specified", gapvalue=None):
"""
Resizes (up or down) and returns a new list of a given size, based on an input list.
- rows: the input list, which can contain any type of value or item (except if using the interpolate stretchmethod which requires floats or ints only)
- newlength: the new length of the output list (if this is the same as the input list then the original list will be returned immediately)
- stretchmethod: if the list is being stretched, this decides how to do it. Valid values are:
- 'interpolate'
- linearly interpolate between the known values (automatically chosen if list contains ints or floats)
- 'duplicate'
- duplicate each value so they occupy a proportional size of the new list (automatically chosen if the list contains non-numbers)
- 'spread'
- drags the original values apart and leaves gaps as defined by the gapvalue option
- gapvalue: a value that will be used as gaps to fill in between the original values when using the 'spread' stretchmethod
"""
#return input as is if no difference in length
if newlength == len(rows):
return rows
#set auto stretchmode
if stretchmethod == "not specified":
if isinstance(rows[0], (int,float)):
stretchmethod = "interpolate"
else:
stretchmethod = "duplicate"
#reduce newlength
newlength -= 1
#assign first value
outlist = [rows[0]]
writinggapsflag = False
if rows[1] == gapvalue:
writinggapsflag = True
relspreadindexgen = (index/float(len(rows)-1) for index in xrange(1,len(rows))) #warning a little hacky by skipping first index cus is assigned auto
relspreadindex = next(relspreadindexgen)
spreadflag = False
gapcount = 0
for outlistindex in xrange(1, newlength):
#relative positions
rel = outlistindex/float(newlength)
relindex = (len(rows)-1) * rel
basenr,decimals = str(relindex).split(".")
relbwindex = float("0."+decimals)
#determine equivalent value
if stretchmethod=="interpolate":
#test for gap
maybecurrelval = rows[int(relindex)]
maybenextrelval = rows[int(relindex)+1]
if maybecurrelval == gapvalue:
#found gapvalue, so skipping and waiting for valid value to interpolate and add to outlist
gapcount += 1
continue
#test whether to interpolate for previous gaps
if gapcount > 0:
#found a valid value after skipping gapvalues so this is where it interpolates all of them from last valid value to this one
startvalue = outlist[-1]
endindex = int(relindex)
endvalue = rows[endindex]
gapstointerpolate = gapcount
allinterpolatedgaps = Resize([startvalue,endvalue],gapstointerpolate+3)
outlist.extend(allinterpolatedgaps[1:-1])
gapcount = 0
writinggapsflag = False
#interpolate value
currelval = rows[int(relindex)]
lookahead = 1
nextrelval = rows[int(relindex)+lookahead]
if nextrelval == gapvalue:
if writinggapsflag:
continue
relbwval = currelval
writinggapsflag = True
else:
relbwval = currelval + (nextrelval - currelval) * relbwindex #basenr pluss interindex percent interpolation of diff to next item
elif stretchmethod=="duplicate":
relbwval = rows[int(round(relindex))] #no interpolation possible, so just copy each time
elif stretchmethod=="spread":
if rel >= relspreadindex:
spreadindex = int(len(rows)*relspreadindex)
relbwval = rows[spreadindex] #spread values further apart so as to leave gaps in between
relspreadindex = next(relspreadindexgen)
else:
relbwval = gapvalue
#assign each value
outlist.append(relbwval)
#assign last value
if gapcount > 0:
#this last value also has to interpolate for previous gaps
startvalue = outlist[-1]
endvalue = rows[-1]
gapstointerpolate = gapcount
allinterpolatedgaps = Resize([startvalue,endvalue],gapstointerpolate+3)
outlist.extend(allinterpolatedgaps[1:-1])
outlist.append(rows[-1])
gapcount = 0
writinggapsflag = False
else:
outlist.append(rows[-1])
return outlist
答案 4 :(得分：0)
random.choices（）无法解决您的问题吗？ 有更多示例可用here
答案 5 :(得分：0)
参考Ignacio Vazquez-Abrams的回答：
从7个可用数字中打印3个数字：
msg_cache = [1, 2, 3, 4, 5, 6]
msg_n = 3
inc = len(msg_cache) / msg_n
inc_total = 0
for _ in range(0, msg_n):
msg_downsampled = msg_cache[math.floor(inc_total)]
print(msg_downsampled)
inc_total += inc
输出：
0
2
4
用于将许多日志消息降采样为较小的子集。