相关疑难解决方法(0)

在我的程序中，我需要存储与许多（我们谈论数十万、数百万）游戏板状态相关的数据。为此，我使用字典。

class BoardState(object):
    def __init__(self, ...):
        # ...
        self.board = [ [ None ] * self.cols for _ in xrange(self.rows) ]

    def __hash__(self):
        board_tuple = tuple([ tuple(row) for row in self.board ])
        return hash(board_tuple)

    # ...

self.board在我的主要用例中，是一个 2D 列表，有 6 行和 7 列。

一开始我dict用BoardState对象索引了。但由于除了将来的查找之外，我不会将BoardState存储的对象dict用于其他目的，因此我注意到我可以通过索引来节省内存hash(board_state)（此版本使用的内存减少了 4 倍）。

BoardState两个不同的对象（内部有不同的boards）在 ing 后产生相同值的可能性有多大hash？

为了澄清一点，这就是我存储和检索值的方式dict：

board_state = BoardState(...)
my_values[hash(board_state)] = { ... }
...
other_val_with_board_state = source_function() …

设置：我在 MS SQL Server 上有一个预处理数据集，大约有 500.000.000 行和 20 列，其中一个是相当长的文本列 (varchar(1300))，相当于 SQL 上大约 35GB 的数据空间数据库。我正在运行 MS SQL Server 的物理机上工作，因此不需要网络流量，并且它有 128GB RAM。MS SQL Server 设置为最多占用 40GB RAM。我想将数据集导入Python以进行进一步处理。假设进行一些深度学习实验，这很重要，因为我需要能够按原样传输文本列。

轶事：为了测试导入代码，我使用了大约 700.000 行的数据集的一个小子样本。运行大约需要 1 分钟，Python 的 RAM 使用量高达 700mb，导入后将变量保存到文件系统的文件大小约为 250mb。据推断，导入完整数据集大约需要 700 分钟，并生成一个 175GB 的文件。这是相当多的，特别是与在 SQL 中复制完整的 31GB 表相比，这最多需要几分钟。我让它运行一天，看看会发生什么，但没有结果。

替代方案：我尝试不使用pandasandsqlalchemy而是pyodbc直接使用，这让我相信问题在于 pyodbc 如何处理数据导入，因为它将查询的数据存储在 rows 对象中，我只能在循环中按行读取，这对我来说似乎效率很低。我不知道是否能以pandas不同sqlalchemy的方式做到这一点。我还尝试不使用单个 select 语句导入完整数据集，而是将其分成许多较小的数据集，这导致小型测试数据集需要 30 分钟而不是 1 分钟来加载。

问题：如何将这个大（但与其他数据库相比不是那么大）的数据集加载到 Python 中？另外，必须有一种方法可以有效地做到这一点？因为它不应该比在 SQL 中复制完整表花费更长的时间，并且它不应该比 SQL 数据库中的表占用更多的空间。我不明白为什么在此过程中数据大小会增加这么多。该解决方案不需要首先将表提取到除 Python 之外的任何其他介质（即没有.csv文件等），尽管使用任何其他 Python …

我在 django、python 中做了一个项目。我想知道 Django 命令以了解我的表的内存大小

我正在尝试使用PyPy运行Python（2.7）脚本，但是遇到以下错误：

TypeError: sys.getsizeof() is not implemented on PyPy.

A memory profiler using this function is most likely to give results
inconsistent with reality on PyPy.  It would be possible to have
sys.getsizeof() return a number (with enough work), but that may or
may not represent how much memory the object uses.  It doesn't even
make really sense to ask how much *one* object uses, in isolation
with the rest of the system.  For example, instances have maps,
which are often …

我有两个 scipy 矩阵“a”和“b”，其中包含布尔值。“a”比“b”大得多：765565 个值，而只有 3 个值。

In\xc2\xa0[211]: a\nOut[211]: <388839x8455 sparse matrix of type '<class 'numpy.bool_'>'\n           with 765565 stored elements in Compressed Sparse Row format>\nIn\xc2\xa0[212]: b\nOut[212]: <5x3 sparse matrix of type '<class 'numpy.bool_'>'\n           with 3 stored elements in Compressed Sparse Row format>\n

但是当我根据内存使用情况检查它们的大小时，我发现它们都只有 56 字节：

In\xc2\xa0[213]: from sys import getsizeof\n          'Size of a: {}. Size of b: {}'.format(getsizeof(a), getsizeof(b))\nOut[213]: 'Size of a: 56. Size of b: 56'\n

为什么这些矩阵的大小相同，而矩阵“a”必须存储比矩阵“b”多 20 万倍的值？

我注意到，Python中数组操作的事实上的标准是通过出色的numpy库实现的。但是，我知道Python标准库有一个array模块，在我看来，它的使用案例与Numpy类似。

在现实世界中，是否有任何array理想的例子比numpy普通的理想list？

根据我的幼稚解释，array它只是用于存储同类数据的高效内存的容器，但却无法提高计算效率。

编辑

出于好奇，我搜索了Github，发现import arrayPython命中186'721，而import numpy命中8'062'678。

但是，我找不到使用的流行存储库array。

在 Pycon2016 上观看 Nina Zahkarenko 的 Python 内存管理演讲（链接）后，似乎 dunder 方法__slots__是一种减少对象大小和加速属性查找的工具。

我的期望是普通类将是最大的，而__slots__/namedtuple方法会节省空间。然而，一个快速的实验sys.getsizeof()似乎表明并非如此：

from collections import namedtuple
from sys import getsizeof

class Rectangle:
   '''A class based Rectangle, with a full __dict__'''
   def __init__(self, x, y, width, height):
      self.x = x
      self.y = y
      self.width = width
      self.height = height

class SlotsRectangle:
   '''A class based Rectangle with __slots__ defined for attributes'''
   __slots__ = ('x', 'y', 'width', 'height')

   def __init__(self, x, y, width, height): …

有没有办法找到当前在内存中的对象，包括它们的名称、它们所在的位置和模块名称等？

我在任务管理器中 main() 方法之前的进程 Python.exe 的内存占用为 15MB。

main 方法完成第一次迭代后，进程 Python.exe 内存大小为 250MB。

我想了解哪些对象仍在内存中，以便我可以删除它们

while True:
 # print current object details
 main() 
 # print current object details

我有以下格式的字典:

演示代码:

>>> import pprint
>>> pprint.pprint(data)
{'lookup': {'F01': '\n.custom1 {\n    background-color: #f5e9dc;\n    padding: 10px;\n    border-radius: 10px;\n    font-family: sans-serif;\n    font-size: 0.9em;\n    margin-top: 1em;\n    }\n.custom2 .style8-rw {\n    font-family: sans-serif;\n    font-weight: bold;\n    color: #F57215;\n    }',
            'F02': '\n.custom1 {\n    background-color: #f5e9dc;\n    padding: 10px;\n    border-radius: 10px;\n    font-family: sans-serif;\n    font-size: 0.9em;\n    margin-top: 1em;\n    }\n.custom2 .style8-rw {\n    font-family: sans-serif;\n    font-weight: bold;\n    color: #F57215;\n    }',
            'F03': '\n.custom1 {\n    background-color: #f5e9dc;\n    padding: 10px;\n    border-radius: 10px;\n    font-family: sans-serif;\n    font-size: 0.9em;\n    margin-top: 1em;\n    }\n.custom2 .style8-rw {\n    font-family: sans-serif;\n    font-weight: bold;\n …

我想区分Python中的32位和64位整数.在C中,我们可以使用int_64和声明变量,这非常简单int_32.但是在Python中我们如何区分32位整数和64位整数？

可能重复:
如何确定Python中对象的大小？

在C,如果我这样做

USHORT x;
ULONG y;
ULONGLONG yy;

printf("%d %d %d\n", sizeof(x), sizeof(y), sizeof(yy))

输出:2 4 8

如果我这样做,我怎么能用Python得到它

valByte = 0x16
valWord = 0x1234
valDWord = 0x12345678
val64Word = 0x1234567887654321

我期望的输出应该是1,2,4,8

谢谢