将列表另存为 python 中的文件(该文件也应该在其他编程语言中被接受)

Question

我有一个 int8 数据类型的三维列表，我想将其保存到 txt 文件中。如何保存文件，以便将值另存为 int8 而不是字符串，这将减小 txt 文件大小。我正在用蟒蛇做

Answer 1

为了节省空间，您需要以二进制格式存储数据。这可以通过泡菜模块来实现。

例如，让我们以二进制和文本格式保存 1000 个整数的列表：

>>> from random import randint
>>> import pickle
>>> l = [randint(0, 100000) for i in range(0, 1000)]
>>> bf = open("out.bin", "wb") # binary file
>>> tf = open("out.txt", "w")  # ASCII file
>>> pickle.dump(l, bf, -1) # write file with highest possible protocol (binary)
>>> for i in l:
...     tf.write(str(i) + " ")
>>> bf.close()
>>> tf.close()

二进制文件的权重为 3.7 kb，而文本文件的权重为 5.8 kb：

$ ls -lh out*
-rw-rw-r-- 1 regis regis 3,7K janv. 18 10:16 out.bin
-rw-rw-r-- 1 regis regis 5,8K janv. 18 10:14 out.txt

如果您的目标是减小文件大小并以不同的语言（或不同的操作系统）读回文件，那么有许多解决方案比序列化为二进制格式更有效。您只是遇到文件压缩问题。在 python 中写入 gzip 压缩文件很容易，从 gzip 压缩文件读取是非常标准的，因此您应该找到目标语言的合适库。

以下是将 128*128*

128 列表写入 gzip 压缩文件的方法：

l = [randint(0, 100000) for _ in range(0, 128*128*128)]
with gzip.open("out.txt.gz", "w") as tfz:
    tfz.write(" ".join([str(i) for i in l]))

这会产生一个 5.5 Mb 的二进制文件，而 pickle 生成的 12 Mb 未压缩文本文件和 7.4 Mb 二进制文件。

Answer 2

根据定义，文件的内容是一个字符串。你可以使用泡菜或json。

import json
data = []
fl = open('myfile', 'wb')
fl.write(json.dumps(data))
fl.close()

当您从python读取文件时，您还必须加载带有json.loads()的json。泡菜的工作方式相同。

编辑：

至于减小尺寸的方法 - 恐怕您将不得不使用某种压缩。如果你需要性能，你可能想看看python-blosc。

Answer 3

如果需要将二进制文件另存为.txt文件，可以使用 Base64 编码。开销约为 33%（三个字节的二进制存储为四个 ASCII 字符），但它将是一个文本文件。

您是否考虑过压缩以减小尺寸？

Answer 4

将数据

写入 csv，然后 gzip 压缩。
在另一端，将其压缩，然后处理数据。
请参阅 python gzip 条目：https：//docs.python.org/2/library/gzip.html

>>> import gzip
>>> import shutil
>>> with open('file.txt', 'rb') as file_input, gzip.open('file.txt.gz', 'wb', 9) as file_output:
...     shutil.copyfileobj(file_input,file_output)
... 

Answer 5

您已经得到了很好的答案，但这是另一个（原始）解决方案，可以最大限度地减少占用空间。

它假设矩阵每个维度中的元素数量是恒定的（例如，由第一个元素的大小决定），并且它适合一个字节（即每个维度少于 256 个元素，但它可以很容易地增加）

import struct
lst=[[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]
g = (bytearray(r) for c in lst for r in c)
with open('mtxints.bin', 'wb') as f:
    # python 2/3
    f.write(struct.pack('@B', len(lst)))
    f.write(struct.pack('@B', len(lst[0])))
    f.write(struct.pack('@B', len(lst[0][0])))
    # python 3 only
    # f.write(bytes([len(lst)]))
    # f.write(bytes([len(lst[0])]))
    # f.write(bytes([len(lst[0][0])]))
    for a in g:
        f.write(a)
print(' saved', lst)
with open('mtxints.bin', 'rb') as f:
    # python 2/3
    x = struct.unpack('@B', f.read(1))[0]
    y = struct.unpack('@B', f.read(1))[0]
    z = struct.unpack('@B', f.read(1))[0]
    # python 3 only
    # x = int.from_bytes(f.read(1), byteorder='big', signed=False)
    # y = int.from_bytes(f.read(1), byteorder='big', signed=False)
    # z = int.from_bytes(f.read(1), byteorder='big', signed=False)
    print('matrix dimensions', x, y, z)
    newlst = []
    for a in range(x):
        newb = []
        for b in range(y):
            c = bytearray(f.read(z))
            newb.append(list(map(int, c)))
        newlst.append(newb)
print('loaded', lst)

产生（在 python2 上，您可能会得到奇怪的打印输出，使用 print 而不使用 () ）

 saved [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
matrix dimensions 2 2 3
loaded [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]

和一个 15 字节的文件：3 个用于标头（每个维度一个），12 个用于内容

mbb@dev:~/SO/py$ ll mtxints.bin 
-rw-rw-r-- 1 mbb mbb 15 gen 18 11:13 mtxints.bin
mbb@dev:~/SO/py$ xxd mtxints.bin
0000000: 0202 0301 0203 0405 0607 0809 0a0b 0c    ...............

基本上，程序将每个维度的大小写入文件头，一次一个。

然后，它使用生成器写入矩阵的内容，该生成器在第二维上迭代，并将第三维的元素作为字节块生成。

从

文件加载矩阵时，它会从标头读取每个维度的大小，并使用这些大小迭代前两个维度，以读取第三个维度内容的正确字节数。

正如我所说，这是一个非常原始的解决方案，针对三维进行硬编码，但你明白了。

请参阅struct.pack/unpack了解更多信息