我正在开发一个基于 NDB 的 Google App Engine 应用程序，该应用程序需要跟踪大量（约 2000 个）固定位置的日/夜循环。因为纬度和经度永远不会改变，所以我可以使用 PyEphem 之类的东西提前预先计算它们。我正在使用 NDB。在我看来，可能的策略是：
要将一年的日出时间预先计算为日期时间对象，请将它们放入列表中，腌制列表并将其放入 PickleProperty
，但将列表放入 JsonProperty
使用 DateTimeProperty 并设置重复 = True
现在，我想索引下一个日出/日落属性，但可以从列表中弹出并放入它自己的 DateTimeProperty，以便我可以定期使用查询来确定哪些位置已更改为不同的部分的周期。整个列表不需要索引。
有谁知道这三种方法在索引和 CPU 负载方面的相对工作量？重复=真对索引有影响吗？
谢谢，戴夫
对于 2000 个不可变数据点 - 只需在实例启动或首次使用时计算它们，然后将其保存在内存中。这将是最便宜和最快的。
建议“仅在实例启动时计算它们”或“预先计算这些结构并将它们输出到硬编码的 Python 结构”的答案似乎忽略了存储一年的日出所需要的 365 倍乘数，或者如果计算在实例启动时完成。使用 pyEphem，2000 次日出和日落需要两秒多的时间来计算。在源代码中存储 2000 个位置的一年的日出和日落可能会使用超过 20 兆字节。如果数字被有效地腌制，则需要 2*365*2000*8 = 11,680,000 字节。
一种更快更好的方法是建立一个最小二乘模型，用于一个位置的时间与其他位置的时间。这使得使用的总空间减少了大约 70 倍，如下所述。
首先，如果 A 点和 B 点在同一纬度，并且具有相似的高度和地平线参数，那么 A 点的日出相对于 B 点的日出发生在恒定的时间偏移。例如，如果 A 点位于 B 点以西 15 度，则日出发生在A 点比 B 点晚一个小时。其次，如果点 A、B、C 处于同一经度且处于低纬度，则可以相当准确地计算出一个点的日出时间，作为其他两个点的线性组合。在高纬度地区或为了获得更好的精度，可以使用几条时间曲线的线性组合。第三，3月20日春分当天A点的日出时间可以作为归一化点，所以所有的计算都可以归一化到同一个纬度。
下表显示了使用四条时间曲线的线性组合得到什么样的精度结果。对于距赤道最多 46° 的经度，结果保持在大约半秒内。对于 48° 到 60°，结果保持在 5 秒内。在 64° 时，结果可能最多有两分钟的误差，而在 65° 时，最多可能有 6 分钟的误差。但是这些时间对于大多数实际目的来说可能已经足够了。请注意，在 66° 时，下面显示的程序会崩溃，因为它不处理 pyEphem 抛出的异常；“AlwaysUpError: 'Sun' is still above the horizon at 2013/6/14 07:20:15” 即使 66° 位于北极圈下方66.5622° N。
很容易修改程序，以便它使用尽可能多的时间曲线（参见lata = ...程序中的各种语句），提供所需的任何精度，但以存储更多曲线和更多系数为代价。当然，可以改变模型以使用时间曲线的子集；例如，可以存储 10 条曲线，并根据纬度上最接近任何给定目标纬度的 4 条曲线进行计算。然而，对于这个演示程序，这种改进还没有到位。
Lat. 0.0: Error range: -0.000000 to 0.000000 seconds
Lat. 5.0: Error range: -0.370571 to 0.424092 seconds
Lat. 10.0: Error range: -0.486193 to 0.557997 seconds
Lat. 15.0: Error range: -0.414288 to 0.477041 seconds
Lat. 20.0: Error range: -0.213614 to 0.247057 seconds
Lat. 25.0: Error range: -0.065826 to 0.056358 seconds
Lat. 30.0: Error range: -0.382425 to 0.323623 seconds
Lat. 35.0: Error range: -0.585914 to 0.488351 seconds
Lat. 40.0: Error range: -0.490303 to 0.400563 seconds
Lat. 45.0: Error range: -0.164706 to 0.207415 seconds
Lat. 47.0: Error range: -0.590103 to 0.756647 seconds
Lat. 48.0: Error range: -0.852844 to 1.102608 seconds
Lat. 50.0: Error range: -1.478688 to 1.940351 seconds
Lat. 55.0: Error range: -3.342506 to 4.696076 seconds
Lat. 60.0: Error range: -0.000002 to 0.000003 seconds
Lat. 61.0: Error range: -7.012057 to 4.273954 seconds
Lat. 62.0: Error range: -21.374033 to 12.347188 seconds
Lat. 63.0: Error range: -51.872753 to 27.853411 seconds
Lat. 64.0: Error range: -124.000365 to 59.661029 seconds
Lat. 65.0: Error range: -351.425224 to 139.656187 seconds
使用上述方法，对于 2000 个位置中的每一个，您需要存储五个浮点数：3 月 20 日的日出时间和四个时间曲线的四个乘数系数。（前面提到的 70 倍减少是由于每个位置存储 5 个数字，而不是 365 个数字。）对于每个时间曲线，存储 365 个数字，条目i是日出时间与3 月 20 日的时间差。存储 4 条时间曲线占用的空间是存储 2000 条曲线的 1/500，因此曲线存储空间以乘数系数为主。
在我给出使用 scipy.optimize.leastsq 求解系数的程序之前，这里有两个代码片段，可用于在 ipython 解释器中制作准确度表并绘制图表以可视化错误。
import sunrise as sr
for lat in range(0, 65, 5):
sr.lsr(lat, -110, 2013, 4)
以上产生了前面显示的大部分错误表。lsr调用第三个参数，daySkip值 4 使lsr每隔四天（即一年中只有大约 90 天）工作，以加快测试速度。使用sr.lsr(lat, -110, 2013, 1)会产生类似的结果，但需要四倍的时间。
sr.plotData(15,1./(24*3600))
上面告诉sunrise.plotData 绘制所有内容（要近似的日出数据；模型得到的近似值；残差，以秒为单位；以及基数曲线。）
该程序如下所示。请注意，它主要针对北半球经度进行了测试。如果时间曲线足够对称，程序将按原样处理南半球经度；如果误差太大，可以将南半球经度添加到基数曲线中，或者可以更改模型以使用赤道以南的一组单独曲线。请注意，此程序不计算日落。对于日落，添加next_setting(ephem.Sun())与调用类似的previous_rising(ephem.Sun())调用，并存储额外的四个时间曲线。
#!/usr/bin/python
import ephem, numpy, scipy, scipy.optimize
# Make a set of observers (observation points)
def observers(lata, lona):
def makeIter(x):
if hasattr(x, '__iter__'):
return x
return [x]
lata, lona = makeIter(lata), makeIter(lona)
arr = []
for lat in lata:
for lon in lona:
o = ephem.Observer()
o.lat, o.lon, o.elevation, o.temp = str(lat), str(lon), 1400, 0
arr.append(o)
return tuple(arr)
# Make a year of data for an observer, equinox-relative
def riseData(observr, year, skip):
yy = ephem.Date('{} 00:00'.format(year))
rr = numpy.arange(0.0, 366.0, skip)
springEquinox = 78
observr.date = ephem.Date(yy + springEquinox)
seDelta = observr.previous_rising(ephem.Sun()) - yy - springEquinox + 1
for i, day in enumerate(range(0, 366, skip)):
observr.date = ephem.Date(yy + day)
t = observr.previous_rising(ephem.Sun()) - yy - day + 1 - seDelta
rr[i] = t
return numpy.array(rr)
# Make a set of time curves
def makeRarSet(lata, lona, year, daySkip):
rar=[]
for o in observers(lata, lona):
r = riseData(o, year, daySkip)
rar.append(r)
x = numpy.arange(0., 366., daySkip)
return (x, rar)
# data() is an object that stores curves + results
def data(s):
return data.ss[s]
# Initialize data.ss
def setData(lata, lona, year, daySkip):
x, rar = makeRarSet(lata, lona, year, daySkip)
data.ss = rar
# Compute y values from model, given vector x and given params in p
def yModel(x, p):
t = numpy.zeros(len(x))
for i in range(len(p)):
t += p[i] * data(i)
return t
# Compute residuals, given params in p and data in x, y vectors.
# x = independent var, y = dependent = observations
def residuals(p, y, x):
err = y - yModel(x, p)
return err
# Compute least squares result
def lsr(lat, lon, year, daySkip):
latStep = 13.
lata = numpy.arange(0., 66.4, latStep)
lata = [ 88 * (1 - 1.2**-i) for i in range(8)]
l, lata, lstep, ldown = 0, [], 20, 3
l, lata, lstep, ldown = 0, [], 24, 4
while l < 65:
lata.append(l); l += lstep; lstep -= ldown
#print 'lata =', lata
setData(lata, lon, year, daySkip)
x, ya = makeRarSet(lat, lon, year, daySkip)
x, za = makeRarSet(lat, 10+lon, year, daySkip)
data.ss.append(za[0])
y = ya[0]
pini = [(0 if abs(lat-l)>latStep else 0.5) for l in lata]
pars = scipy.optimize.leastsq(residuals, pini, args=(y, x))
data.x, data.y, data.pv = x, y, yModel(x, pars[0])
data.par, data.err = pars, residuals(pars[0], y, x)
#print 'pars[0] = ', pars[0]
variance = numpy.inner(data.err, data.err)/len(y)
#print 'variance:', variance
sec = 1.0/(24*60*60)
emin, emax = min(data.err), max(data.err)
print ('Lat. {:4.1f}: Error range: {:.6f} to {:.6f} seconds'.format(lat, emin/sec, emax/sec))
def plotData(iopt, emul):
import matplotlib.pyplot as plt
plt.clf()
x = data.x
if iopt == 0:
iopt = 15
emul = 1
if iopt & 1:
plt.plot(x, data.y)
plt.plot(x, data.y + 0.001)
plt.plot(x, data.y - 0.001)
if iopt & 2:
plt.plot(x, data.pv)
if iopt & 4:
plt.plot(x, emul*data.err)
if iopt & 8:
for ya in data.ss:
plt.plot(x, ya)
plt.show()
我会说预先计算这些结构并将它们输出到您保存在生成的 python 文件中的硬编码 python 结构中。
作为实例启动的一部分，只需将这些结构读入内存即可。
根据您的描述，没有理由在运行时计算这些值，也没有理由将其存储在数据存储中，因为这有与之相关的成本，以及 RPC 的一些延迟。