标签: memory-efficient

我需要一个内存高效的数据结构来存储大约一百万个键 - 值对,其中键是大约80字节的字符串,值是大约200字节的字符串,总键和值大小约为280MB.我还需要通过键有效地查找值,最好是哈希映射.内存开销应该尽可能少,例如对于280MB的有用数据,数据结构不应该使用超过300MB的虚拟内存(包括malloc()开销和其他一切).使用模式如下:我们从一个空的数据结构开始,我们逐渐填充它,从不更改键,也从不改变值的长度.作为一个加号,数据结构可能支持更改值的长度,代价是100%的值开销(意味着对于x值字节,x个字节可能暂时浪费在未使用的缓冲区空间中).

我需要一个纯Python模块,或一个内置的Python模块,或一个C实现,最好是(C)Python绑定.我更喜欢是否可以将整个数据结构序列化到磁盘,并且可以非常快速地将其读回.

为了证明这么小的开销是可能的,我创建了一个带有开放寻址的简单设计,包含1个数据块的4字节指针的125万个元素的哈希表,包含密钥和值长度的数据块作为基础-128 varints.这种设计有一个重要的限制:它不允许在不浪费存储区域的情况下移除或更换线对.根据我的计算,有100万个密钥值对,每个280字节,开销小于3.6%(10 080 000字节).上述限制更加慷慨,它们允许20 000 000字节的开销.

我刚刚找到http://www.pytables.org/,它提供快速访问和内存高效的数据打包.我必须仔细检查它以检查它是否符合我的需要.

我需要一个2位数组,我根本不关心保存内存,但我关心的是最小化缓存未命中和最大化缓存效率.使用bool数组将使用4倍以上的内存,这意味着对于缓存中的每个可用数据块,将有3个未使用.从技术上讲,如果我使用位域,我可以获得3倍更好的缓存一致性.

计划是将其实现为一个字节数组,分为4个相等的位域,并使用div函数来获取整数商和余数,可能在一个时钟中,并使用它们来访问正确的索引和右边位域.

我需要的数组大约是10000个元素,因此它将产生明显更密集的打包数据,使用2个实际位将允许整个数组适合L1缓存,而使用字节数组则不可能.

所以我的问题是,是否有人可以告诉我这是否是一个以性能为导向的任务的好主意,所以我知道是否值得出去实施2位阵列？当然,最好的了解方法是分析,但事先提供的任何信息都可能有用,我们将不胜感激.

在Python 3中,许多返回列表的函数(现在是类)现在返回iterables,最常见的例子是range.在这种情况下,范围在Python 3中是可迭代的,以提高性能和内存效率(因为您不必再​​构建列表).

其他"新" iterables是map,enumerate,zip和字典操作的输出dict.keys(),dict.values()和dict.items().(可能还有更多,但我不知道).

他们中的一些(enumerate和map)通过将它们转换为迭代可能变得更有效.在Python 2.7中,其他人只是创建了已经在内存中的对象列表,因此它们可以提高内存效率.

为什么然后将它们变成可以在每次要对它们进行排序时必须转换为列表的迭代,等等？

我想验证是否

pow(a,b)%b == a

在C中为真,2≤b≤32768(2 ¹⁵)且2≤a≤b,a和b为整数.

但是,直接计算pow(a, b) % bb是一个大数字,这将很快导致C溢出.什么是验证这种情况是否成立的技巧/有效方法？

这个问题是基于找到费马小定理的证人,该定理指出如果这个条件是假的,那么b不是素数.

此外,我在可能的时间也受到限制,它不能太慢(接近或超过2秒).最大卡迈克尔号码,号码b,这不是素数,而且不满足pow(a, b)% b == a与2 <= a <= b(用b <= 32768)是29341.因此,对于检查方法pow(a, b) % b == a具有2 <= a <= 29341不应该太缓慢.

考虑以下简化案例:

lol = [['John','Polak',5,3,7,9],
       ['John','Polak',7,9,2,3],
       ['Mark','Eden' ,0,3,3,1],
       ['Mark','Eden' ,5,1,2,9]]

什么是pythonic和内存+速度有效的方法将这个列表列表转换为基于前两个参数的列表列表列表:

lolol = [[['John','Polak',5,3,7,9],
          ['John','Polak',7,9,2,3]],
         [['Mark','Eden' ,0,3,3,1],
          ['Mark','Eden' ,5,1,2,9]]]

实际上 - 任何其他数据结构也可以,只要我有正确的层次结构.例如,我想到了下面的字典结构,但创建它似乎效率不高,而且内存可能会高于lolol解决方案.

dolol = {('John','Polak'):[[5,3,7,9],[7,9,2,3]],
         ('Mark','Eden') :[[0,3,3,1],[5,1,2,9]]}

我正在开发一个项目,其中我有一组关键字[abc,xyz,klm] `.我还有一堆内容为[1.txt,2.txt,3.txt]的文本文件.

我正在做的是将关键字与文本文件碰撞,以找到关键字出现的行,并且可以多次执行此操作.所以我想存储ID (text file name without .txt), Extracted_Data, Line_Number, Spwaned_Across (keyword may be spread across 2 lines)每次出现.

我决定为每个关键字创建一个表来存储这些数据.

表:abc,xyz,klm

表abc示例数据:

ID Extracted_Data                         Line_Number Spawned_Across
12 MySQL is wonderful. What is 'abc'      34          1

所以我最终得到了每个关键字的表格.在我的项目中,大约有150个关键字,它可以增长.150个表.

我为什么选择这样做？

现在我需要查找关键字是否存在于文件中,我相信将来我会被要求显示文件中的位置或方式.我打算为每个新关键字自动创建一个表,这样我就不必手动创建每个关键字或者包含100列的巨型表.

我做出了正确的决定吗？您的意见非常感谢.

我应该能够在一个可以从0到3的数据结构中存储一个值.所以我需要2位.这个数据结构我将是2 ^ 16个很棒的位置.所以,我想要2 ^ 16*2(位).在C++中,你使用内存中的2位吗？

这可能是一个重复的问题,但我无法找到我正在搜索的内容.如果存在,抱歉重复.

我想知道如果以下部分代码在内存分配方面是相同的.

//first
int n = some_number;
for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++){
        int a = something;
    }
}

//second
int i, j, a;
for(i = 0; i < n; i++){
    for(j = 0; j < n; j++){
        a = something;
    }
}

我想知道,如果java 在第一个代码中分配变量a n ^ 2次和j n次,或者两者仅在第二个代码中分配一次.

我在java中尝试了几次,但结果不一致,就像在一次试验中,第一次是8秒,第二次是9秒,在另一次试验中反过来.所以,我想确定它们是否相等,

谢谢

我有超过6500万个数值存储在文本文件中.我需要计算最大值,最小值,平均值,标准差以及25%,50%和75%的百分位数.

通常我会使用附加的代码,但我需要一种更有效的方法来计算这些指标,因为我无法将所有值p存储在列表中.如何在Python中更有效地计算这些值？

import numpy as np

np.average(obj)
np.min(mylist)
np.max(mylist)
np.std(mylist)
np.percentile(obj, 25)
np.percentile(obj, 50)
np.percentile(obj, 75)

maxx = float('-inf')
minx = float('+inf')
sumz = 0
for index, p in enumerate(open("foo.txt", "r")):
    maxx = max(maxx, float(p))
    minx = min(minx, float(p))
    sumz += float(p)
index += 1
my_max = maxx 
my_min = minx 
my_avg = sumz/index

我正在学习Python,我试图以不同的方式更改列表.例如,如果我有名单这样的名称:

names = ["David", "Jake", "Alex"]

我想在列表中添加名称"Carter",实现这一目标的最有效方法是什么？以下是我可以做的一些事情:

names.append("Carter")

names = names + ["Carter"]

names += ["Carter"]