小编LeM*_*Miz的帖子

每天,我收到一份文件(更新).我想要做的是插入每个尚不存在的项目.

• 我还想跟踪我第一次插入它们,以及最后一次在更新中看到它们.
• 我不想要有重复的文件.
• 我不想删除以前保存过的文档,但不在我的更新中.
• 95%(估计)的记录每天都未经修改.

我正在使用Python驱动程序(pymongo).

我目前做的是(伪代码):

for each document in update:
      existing_document = collection.find_one(document)
      if not existing_document:
           document['insertion_date'] = now
      else:
           document = existing_document
      document['last_update_date'] = now
      my_collection.save(document)

我的问题是它非常慢(少于100 000条记录需要40分钟,而且我在更新中有数百万条记录).我很确定有内置的东西可以做到这一点,但更新()的文件是mmmhhh ....有点简洁....(http://www.mongodb.org/display/DOCS/Updating)

有人可以建议如何更快地做到这一点？

是否有关于32位和64位平台上Python数据结构的内存大小的参考？

如果没有,这将是很好的在SO上.越详尽越好!那么以下Python结构使用了多少字节(取决于len相关时的内容类型)？

• int
• float
• 参考
• str
• unicode字符串
• tuple
• list
• dict
• set
• array.array
• numpy.array
• deque
• 新式类对象
• 旧式的类对象
• ......以及我忘记的一切!

(对于仅保留对其他对象的引用的容器,我们显然不希望自己计算项目的大小,因为它可能是共享的.)

此外,有没有办法在运行时(递归或不递归)获取对象使用的内存？

我正在寻找有序关联数组的可靠实现,即有序字典.我想要按键的顺序,而不是插入顺序.

更确切地说,我正在寻找一个空间效率的实现int-to-float(或另一个用例的字符串到float)映射结构,其中:

• 有序迭代是O(n)
• 随机访问是O(1)

我想出的最好的方法是粘贴一个字典和一个键列表,保留最后一个用bisect和insert命令.

有更好的想法吗？

我正在寻找一个允许我计算随机微积分的python库,比如我将定义扩散的随机过程的(条件)期望.我看了一下simpy(simpy.sourceforge.net),但它似乎并不能满足我的需求.

这是为了快速原型设计和实验.在java中,我使用了一些成功的(现在不活动的)http://martingale.berlios.de/Martingale.html库.

这个问题本身并不困难,但是有许多非常重要的需要做的事情(有效的内存使用,可变减少技术等等).

理想情况下,我可以写这样的东西(只是说明性的):

def my_diffusion(t, dt, past_values, world, **kwargs):
    W1, W2 = world.correlated_brownians_pair(correlation=kwargs['rho'])
    X = past_values[-1]
    sigma_1 = kwargs['sigma1']
    sigma_2 = kwargs['sigma2']
    dX = kwargs['mu'] * X * dt + sigma_1 * W1 * X * math.sqrt(dt) + sigma_2 * W2 * X * X * math.sqrt(dt)
    return X + dX

X = RandomProcess(diffusion=my_diffusion, x0 = 1.0)
print X.expectancy(T=252, dt = 1./252., N_simul= 50000, world=World(random_generator='sobol'), sigma1 = 0.3, sigma2 = 0.01, rho=-0.1)

有人知道别的东西,而不是例如在numpy中重新实现它吗？

我正在看一下用于流处理的管道3.0包.该教程非常好,非常清楚,除了我无法绕过"zip和merge"部分.

我的目标是结合管道有点像ArrowChoice允许做:

• 我有一个独特的生产者Aither aa
• 我想将第一个管道应用于Left值,将另一个管道应用于Right值
• 然后我想合并结果,并继续管道

+----------+                   +------+ - filterLeft ->  pipe1 -> +------------+ 
| producer | - (Either a a) -> | fork |                           | mergeD (?) |
+----------+                   +------+ - filterRight -> pipe2 -> +------------+

我fork在教程中定义:

fork () = 
    runIdentityP . hoist (runIdentityP . hoist runIdentityP) $ forever $ do
        a <- request ()
        lift $ respond a
        lift $ lift $ respond a

oddOrEven x = if odd x then Left x else …

我有一个成本优化请求,我不知道如何有文献.这有点难以解释,所以我提前为问题的长度道歉.

我正在访问的服务器以这种方式工作:

• 对记录(r1,... rn)和字段(f1,... fp)发出请求
• 你只能要求笛卡尔积(r1,...,rp)x(f1,... fp)
• 与此类请求相关的成本(时间和金钱)与请求的大小相关:

T((r1, ..., rn)x(f1, ..., fp) = a + b * n * p

在不失一般性的情况下(仅通过标准化),我们可以假设b=1成本是:

T((r1, ...,rn)x(f1,...fp)) = a + n * p

• 我只需要请求一对子集(r1, f(r1)), ... (rk, f(rk)),一个来自用户的请求.我的程序充当用户和服务器(外部)之间的中间人.我有很多这样的要求(每天数万).

在图形上,我们可以将其视为一个nxp稀疏矩阵,我想用矩形子矩阵覆盖非零值:

   r1 r2 r3 ... rp
   ------      ___
f1 |x  x|      |x|
f2 |x   |      ---
   ------
f3
..    ______
fn    |x  x|
      ------

有:

• 由于成本不变,子矩阵的数量保持合理
• 所有'x'必须位于子矩阵内
• 由于线性成本,所覆盖的总面积不能太大

我将g命名为我的问题的稀疏系数(所需对的数量超过总可能对​​,g = k / (n * p).我知道系数a.

有一些明显的观察:

• 如果a很小,最好的解决方案是独立请求每个(记录,字段)对,总成本为: …

我想要一个像这样的功能:

unzipState :: (MonadState s m) => m (a, b) -> (m a, m b)

这将采用返回元组的(有状态)计算,并返回两个(从属)计算.

困难当然是从一个或另一个计算中提取值应更新另一个中的状态.

一个有用的(和激励)应用程序是随机monad,表示为

{-# LANGUAGE Rank2types #-}
import qualified System.Random as SR
import Control.Monad.State

type Random a = forall r. (State RandomGen r) => State r a

让我们说你有:

normal :: Random Double
-- implementation skipped

correlateWith :: Double -> Random (Double, Double) -> Random (Double, Double)
correlateWith rho w = do
                        (u, v) <- w
                        return $ (u, p * u + (1 - p …