相关疑难解决方法(0)

例如,存储一百万(32位)整数列表需要多少内存？

alist = range(1000000) # or list(range(1000000)) in Python 3.0

请考虑以下示例:

def main_list(error_type):

    try:
        if error_type == 'runtime':
            raise RuntimeError("list error")
        if error_type == 'valueerror':
            raise ValueError("list error")

    except [RuntimeError, ValueError] as e:
        print str(e)

def main_tuple(error_type):

    try:
        if error_type == 'runtime':
            raise RuntimeError("tuple error")
        if error_type == 'valueerror':
            raise ValueError("tuple error")

    except (RuntimeError, ValueError) as e:
        print str(e)


main_tuple('runtime')
main_tuple('valueerror')

main_list('runtime')
main_list('valueerror')

元组是处理多种异常类型的正确方法.使用多个异常类型的列表不会导致处理.

我想知道为什么Python语法需要多个异常类型的元组.该文件说,它使用一个元组,因此,也许它只是"从来就没有使用列表,而不是一个元组的实现."

对我来说似乎也是合理的,至少在概念上也可以在这种情况下使用列表.

有没有理由为什么Python使用元组而不是列表来处理这种情况？

我试图迭代超过100,000个图像并捕获一些图像功能，并将所得的dataFrame作为pickle文件存储在磁盘上。

不幸的是，由于RAM的限制，我被迫将图像分成20,000个大块并对其进行操作，然后再将结果保存到磁盘上。

在开始循环以处理下一个20,000图像之前，下面编写的代码应该保存20,000图像的结果数据框。

但是-这似乎没有解决我的问题，因为在第一个for循环结束时内存没有从RAM中释放

因此，在处理第50,000条记录时，该程序由于内存不足错误而崩溃。

在将对象保存到磁盘并调用垃圾收集器后，我尝试删除这些对象，但是RAM使用率似乎并未下降。

我想念什么？

#file_list_1 contains 100,000 images
file_list_chunks = list(divide_chunks(file_list_1,20000))
for count,f in enumerate(file_list_chunks):
    # make the Pool of workers
    pool = ThreadPool(64) 
    results = pool.map(get_image_features,f)
    # close the pool and wait for the work to finish 
    list_a, list_b = zip(*results)
    df = pd.DataFrame({'filename':list_a,'image_features':list_b})
    df.to_pickle("PATH_TO_FILE"+str(count)+".pickle")
    del list_a
    del list_b
    del df
    gc.collect()
    pool.close() 
    pool.join()
    print("pool closed")

我想知道为什么numpy.zeros占用这么小的空间？

x = numpy.zeros(200000000)

这不占用任何记忆,

x = numpy.repeat(0,200000000)

占用约1.5GB.numpy.zeros会创建一个空指针数组吗？如果是这样,有没有办法在cython中更改它后将指针设置为空？如果我使用:

x = numpy.zeros(200000000)
x[0:200000000] = 0.0

内存使用率上升.有没有办法改变一个值,然后将其改回原来在python或cython中使用的格式numpy.zeros？

根据redditmetrics.com的数据,Reddit上有超过一百万个子评价.

我写了一个脚本,反复查询这个Reddit API端点,直到所有的subreddit都存储在一个数组中,all_subs:

all_subs = []
for sub in <repeated request here>:
    all_subs.append({"name": display_name, "subscribers": subscriber_count})

该脚本已经运行了近十个小时,大约已经完成了一半(每三个或四个请求就会受到速率限制).当它完成后,我期待一个像这样的数组:

[
    { "name": "AskReddit", "subscribers", 16751677 },
    { "name": "news", "subscribers", 13860169 },
    { "name": "politics", "subscribers", 3350326 },
    ... # plus one million more entries
]

这个列表占用的内存空间大约是多少？

我试图准确/明确地找到Python中两个不同类之间的大小差异.它们都是新的样式类,除了没有定义槽的一个.我已经尝试了很多测试来确定它们的大小差异,但它们总是在内存使用方面完全相同.

到目前为止,我已经尝试了sys.GetSizeOf(obj)和heapy的heap()函数,没有任何积极的结果.测试代码如下:

import sys
from guppy import hpy

class test3(object):
    def __init__(self):
        self.one = 1
        self.two = "two variable"

class test4(object):
    __slots__ = ('one', 'two')
    def __init__(self):
        self.one = 1
        self.two = "two variable"

test3_obj = test3()
print "Sizeof test3_obj", sys.getsizeof(test3_obj)

test4_obj = test4()
print "Sizeof test4_obj", sys.getsizeof(test4_obj)

arr_test3 = []
arr_test4 = []

for i in range(3000):
    arr_test3.append(test3())
    arr_test4.append(test4())

h = hpy()
print h.heap()

输出:

Sizeof test3_obj 32
Sizeof test4_obj 32

Partition of a set of 34717 …

Run Code Online (Sandbox Code Playgroud)

我想在内存中创建一个包含 10 个最大对象的表，并且具有大小。

R 中的等效函数： 在 R 会话中管理可用内存的技巧

lsos()
#                          Type Size(MB)   Rows Columns
#d2                  data.table 157.8364 281444      74
#d                   data.table  62.2658 816078      11

编辑：@ 9.0 这是我的尝试。

我必须使用globals()，使用gc.get_objects()使我的电脑很慢。我不确定globals()给了我我想要的。 如何在python中获取所有已初始化对象和函数定义的列表？

def lsos(n=10):

    import pandas as pd
    import sys

    all_obj =globals()

    object_name = list(all_obj).copy()
    object_size = [sys.getsizeof(all_obj[x]) for x in object_name]

    d = pd.DataFrame(dict(name = object_name, size = object_size))
    d.sort_values(['size'], ascending=[0],inplace=True)

    return(d.head(n))


v  = list(range(1000))
v2 = list(range(10000))
v3 = list(range(100000))
v4 = v3
lsos()

    # …

我一直在阅读掩码数组文档，但我很困惑 - MaskedArray 与仅维护值数组和布尔掩码有什么不同？有人能给我一个例子，其中 MaskedArrays 更方便，或者性能更高吗？

更新 6/5

为了更具体地说明我的问题，这里是一个如何使用 MaskedArray 的经典示例：

>>>data = np.arange(12).reshape(3, 4)
>>>mask = np.array([[0., 0., 1., 0.],
                    [0., 0., 0., 1.],
                    [0., 1., 0., 0.]])

>>>masked = np.ma.array(data, mask=mask)
>>>masked

masked_array(
  data=[[0, 1, --, 3],
        [4, 5, 6, --],
        [8, --, 10, 11]],
  mask=[[False, False,  True, False],
        [False, False, False,  True],
        [False,  True, False, False]],
  fill_value=999999)

>>>masked.sum(axis=0)

masked_array(data=[12, 6, 16, 14], mask=[False, False, False, False], fill_value=999999)

我可以很容易地以这种方式做同样的事情：

>>>data = np.arange(12).reshape(3, 4).astype(float)
>>>mask = np.array([[0., 0., 1., …

不知何故,我的Python程序在运行时("顶部"命令的VIRT和RES)列占用越来越多的内存.

但是,我非常小心地仔细检查了我的代码,我确信没有内存泄漏(没有使用任何字典,没有全局变量.它只是一个主方法多次调用子方法).

我使用heapy来分析我的内存使用情况

from guppy import hpy;
heap = hpy();
.....
print heap.heap();

每次main方法调用sub方法.令人惊讶的是,它始终提供相同的输出.但内存使用量不断增长.

我想知道我是不是没有使用heapy,或者"top"命令中的VIRT和RES不能真正反映我的代码使用的内存吗？

或者任何人都可以提供更好的方法来追踪Python脚本中的内存使用情况？

非常感谢!

由于蟒蛇list的bytes值：

# actual str values un-important
[
    b'foo',
    b'bar',
    b'baz',
    ...
]

如何将列表分成块，其中每个块的最大内存大小低于某个上限？

例如：如果上限为 7 个字节，那么原始列表将被分解为一个列表列表

[
    [b'foo', b'bar'], # sublist 0
    [b'baz'], # sublist 1
    ...
]

根据列表内容的累积长度，每个子列表最多为 7 个字节。

注意：每个子列表都应该按照原始列表的顺序进行最大程度的打包。在上面的示例中，前 2 个 str 值被分组，因为它是 7 字节限制下的最大可能值。

预先感谢您的考虑和回应。