在python中逐行求和两个包含浮点数的文本文件

Question

所以我有 4,000 个大型 gzip 文本文件。由于它们的大小，我需要逐行总结它们。理想情况下（我认为）我想打开一个，然后循环遍历其他 3,999 个，然后简单地将它们的值相加到第一个中。这是我到目前为止所拥有的

with gzip.open('foo1.asc.gz','r') as f:
    for i in xrange(6):  # Header is 6 lines
        f.next()
    line = f.readline()
    foo1=map(float, line.strip().split())
    print foo1

这将返回我需要为 foo1 求和的值；所以输出是一个逗号分隔的浮点数列表（例如，[1.2, 6.0, 9.3...]）。

所以为了清楚起见，如果我对foo2 = [1.2, 6.0...] 做同样的事情，那么我可以将foo1 和foo2 相加得到[2.4, 12.0...]，覆盖foo1。然后继续遍历每一行以覆盖foo1。当然，这需要遍历 4k 文件。

如果有人可以帮助我完成 2 个循环和/或求和运算，我将不胜感激。

* 更新 * 现在使用以下代码：

foo1=[]
with gzip.open('foo1','r') as f:
    skip_header()
    for line in f:
        foo1.append([float(i) for i in line.strip().split()])


with gzip.open('foo2','r') as f:
    skip_header()
    for (i, line) in enumerate(f):
        foo1[i] = [j + float(k) for (j, k) in zip(foo1[i], line.strip().split())]

这可行，但很慢。我的输入大约需要 11 分钟。

Answer 1

以正常的python方式...

您没有遍历这些行...

~ $ cat test.txt 
1.0
2.0
3.0
4.5
5.0
6.0

但是，您可以阅读所有行，然后对其应用浮点数：

>>> with open('test.txt', 'r') as f:
...      lines = f.readlines()
...      foo1=map(float, lines)
...      print foo1
... 
[1.0, 2.0, 3.0, 4.5, 5.0, 6.0]
>>> sum(foo1)
21.5

但是，您应该使用 NumPy！

汇总所有文件的粗略解决方案

import numpy as np

totalsum=0
ListofFiles = ['foo1','foo2']
# from the help of np.loadtxt
# Note that `If the filename extension is .gz or .bz2, the file is first decompressed`
# see the help for that function.
for FileName in ListofFiles:
    totalsum=totalsum+np.sum(np.loadtxt(FileName,skiprows=6))

对来自不同文件的元素求和的解决方案

# use with caution it might hog your memory
import numpy as np

totalsum=0
ListofFiles = ['foo1','foo2']

arrayHolder = np.loadtxt(FileName,skiprows=6)
for idx,FileName in enumerate(ListofFiles[1:]):
    arrayHolder=np.hstack((arrayHolder,np.loadtxt(FileName,skiprows=6)))  
# see documentation for numpy.hstack and my example below.

# now you have a huge numpy array. you can do many things on it
# e.g
# sum each file if the above test.txt had an identical file named test1.txt
np.sum(arrayHolder , axis=0)
# output would be:
array([2.0, 4.0, 6.0, 9.0, 10.0, 12.0])
# sum each ith element accross files
np.sum(arrayHolder , axis=1)

# more extended
In [2]: a=np.array([1.0,2.0,3.0,4.5,5.0,6.0])
In [4]: b=np.array([1.0,2.0,3.0,4.5,5.0,6.0]) 
In [9]: c=np.vstack((a,b))  
In [10]: c
Out[10]:
array([[ 1. , 2. , 3. , 4.5, 5. , 6. ],
[ 1. , 2. , 3. , 4.5, 5. , 6. ]])
In [11]: np.sum(c, axis=0)
Out[11]: array([ 2., 4., 6., 9., 10., 12.])
In [12]: np.sum(c, axis=1)
Out[12]: array([ 21.5, 21.5])

# as I said above this could chocke your memory, so do it gradualy, 
# dont try on all 4000 files at once !

请注意，对于 Pierre 提供的解决方案，此解决方案将运行得更快，因为许多 NumPy 函数是编写的，并且是 C 和优化的。如果您需要在 4000 行上运行，我希望 for 循环会更慢...

Answer 2

您可能必须在内存中保留一个列表，该列表存储您的第一个文件的行。

with gzip.open(...) as f:
    skip_header()
    foo1 = [[float(i) for i in line.strip().split()] for line in f]

• 注意：这里，我们是一次构建列表，这意味着f 的全部内容被加载到内存中。如果文件很大，这可能是一个问题。在这种情况下，只需这样做：

  foo1 = []
  with gzip.open(...) as f:
      skip_header()
      for line in f:
          foo1.append([float(i) for i in line.strip().split()])
  

然后，您可以打开第二个文件，循环其行并将值添加到 foo 的相应条目：

with gzip.open(file2) as f:
    skip_header()
    for (i, line) in enumerate(f):
        foo1[i] = [j + float(k) for (j, k) in zip(foo1[i], line.strip().split())]

应该没有太大问题，除非您的文件中有不同数量的列。

如果您的文件非常大，内存可能是个问题。在这种情况下，您可能希望按块工作：从第一个文件中只读取几百行并将它们存储在一个列表中，然后按照说明进行操作，使用与您在第一个文件中读取的一样多的行，然后重新开始还有几百行……

编辑

考虑到您在编辑中描述的计算时间，这个解决方案显然不是最佳的。您无法将整个文件加载到内存中，因此您必须按块工作。遵循以下工作流程可能会更好：

1. 创建一个空列表foo1。
2. 打开第一个文件，读取给定的行块，将这些行转换为 numpy ndarray 并将此数组附加到 foo1。
3. 对另一行代码重复第二步，直到读完整个输入文件

此时，您应该有一个 foo1 列表，其中包含与您定义的块一样多的条目，每个条目都是一个 numpy 数组。现在

1. 打开第二个文件，读取与步骤 #2 中一样多的行，将这些行转换为 numpy 数组 foo2_tmp
2. 将foo2_tmp添加到foo_1[0]，就地：即做foo_1[0] += foo2_tmp。请记住，foo_1[0] 是您的第一个块，ndarray。
3. 对另一块行重复步骤 5，并更新 foo_1 中的相应条目
4. 重复第 6 步。直到您读取第二个文件
5. 重复步骤 4.-7。第三个文件

Answer 3

这是未经测试的。请注意，尝试一次打开 4,000 个文件句柄可能效率低下（甚至可能不允许），因此一次打开文件的方法是最实用的。下面使用了defaultdict，它允许每个文件中的行数不匹配，但仍然可以对重叠的行数求和。

from itertools import islice
from collections import defaultdict
from glob import iglob

def sum_file(filename, dd):
    file_total = 0.0
    with gzip.open(filename) as fin:
        for lineno, line in enumerate(islice(fin, 6, None)): # skip headers
            row_total = map(float, line.split())                
            dd[lineno] += row_total
            file_total += row_total
    return file_total


dd = defaultdict(float)
for filename in iglob('foo*.asc.gz'):
    print 'processed', filename, 'which had a total of', sum_file(filename, dd)

print 'There were', len(dd), 'rows in total'
for lineno in sorted(dd.keys()):
    print lineno, 'had a total of', dd[lineno]