如何将给定的时间区间分成相等的区间？

Question

给定一个时间段：

a = [20,40]

我需要把它转换成相等的时间段：

a = [[20,30],[30,40]]

我试过这个代码：

v1 = a[0]; v2 = a[1]
d.append(v1)
val = abs(v1-v2)
n = int(val/2)
for i in range(n):
     v1 += n
     d.append(v1)
print d

有没有人能推荐一个代码来实现这个功能，这会很有帮助。

Answer 1

使用这个

import numpy as np

points = np.linspace(20, 40, num=2+1)
intervals = np.array([points[:-1], points[1:]]).transpose()
print(intervals)

就能得到一个 np.array：

[[20. 30.]
 [30. 40.]]

当然，对于

points = np.linspace(10, 40, num=6+1)
intervals = np.array([points[:-1], points[1:]]).transpose()
print(intervals)

我们有

[[10. 15.]
 [15. 20.]
 [20. 25.]
 [25. 30.]
 [30. 35.]
 [35. 40.]]

Answer 2

你可以通过计算一个区间，然后用循环在每次迭代中创建一个元组，来解决第一部分的问题。这样就能得到你想要的结果。

不过，注意到在你的例子中，前一个元组的结束和下一个元组的开始是相同的。如果你不想让它们重叠，那么你需要用类似的逻辑，但在合适的时候加1。

这里有一些代码，第一段是用for循环，第二段是用后测试循环：

def interval_divide(min, max, intervals):
   assert intervals != 0
   interval_size = round((max - min) / intervals)
   result = []
   start = min
   for start in range(min, max, interval_size):
      end = start + interval_size
      result.append([start, end])
   return result

a = [20, 40]
print("1 intervals", interval_divide(a[0], a[1], 1))
print("2 intervals", interval_divide(a[0], a[1], 2))
print("3 intervals", interval_divide(a[0], a[1], 3))
print("4 intervals", interval_divide(a[0], a[1], 4))

def interval_divide2(min, max, intervals):
   assert intervals != 0
   interval_size = round((max - min) / intervals)
   result = []
   start = min
   end = min + interval_size
   while True:
      result.append([start, end])
      start = end + 1
      end = end + interval_size
      if len(result) == intervals:
         break
   return result

print("-----")
print("1 intervals", interval_divide2(a[0], a[1], 1))
print("2 intervals", interval_divide2(a[0], a[1], 2))
print("3 intervals", interval_divide2(a[0], a[1], 3))
print("4 intervals", interval_divide2(a[0], a[1], 4))

结果如下：

$ python3 intervals.py 
1 intervals [[20, 40]]
2 intervals [[20, 30], [30, 40]]
3 intervals [[20, 27], [27, 34], [34, 41]]
4 intervals [[20, 25], [25, 30], [30, 35], [35, 40]]
-----
1 intervals [[20, 40]]
2 intervals [[20, 30], [31, 40]]
3 intervals [[20, 27], [28, 34], [35, 41]]
4 intervals [[20, 25], [26, 30], [31, 35], [36, 40]]

注意，当我们使用三个区间时，结束并没有正确结束。这是因为20不能被3整除，所以不可能让所有区间的大小完全相同。

不过，我们仍然可以通过在计算区间时去掉四舍五入来改进我们的答案（同时保持结果为整数）：

def interval_divide(min, max, intervals):
   assert intervals != 0
   interval_size = (max - min) / intervals
   result = []
   start = min
   end = start + interval_size
   while True:
       result.append([int(start), int(end)])
       start = end
       end = end + interval_size
       if len(result) == intervals:
          break
   return result

def interval_divide2(min, max, intervals):
   assert intervals != 0
   interval_size = (max - min) / intervals
   result = []
   start = min
   end = min + interval_size
   while True:
      result.append([int(start), int(end)])
      start = end + 1
      end = end + interval_size
      if len(result) == intervals:
         break
   return result

新的答案是：

1 intervals [[20, 40]]
2 intervals [[20, 30], [30, 40]]
3 intervals [[20, 26], [26, 33], [33, 40]]
4 intervals [[20, 25], [25, 30], [30, 35], [35, 40]]
-----
1 intervals [[20, 40]]
2 intervals [[20, 30], [31, 40]]
3 intervals [[20, 26], [27, 33], [34, 40]]
4 intervals [[20, 25], [26, 30], [31, 35], [36, 40]]

这三个区间虽然仍然不完全相等，但没有显示小数位的情况下，已经非常接近了。

Answer 3

我可以指出你尝试的几个地方不太对，但我不会直接给你写代码。

for i in range(n):
     v1 += n
     d.append(v1)

记住，在你的例子中，n被设置为10。所以当你写for i in range(n)时，你的循环会执行10次。

而且如果你看看你是怎么把数据加到d里的，这样做并不会把一个小列表加到一个大列表里。这样做只会把所有的数字都加到一个列表里。

我猜这就是你现在得到的结果：[20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]。

根据我说的，再试试吧 :-)