检查numpy输入尺寸的标准方法是什么？

Question

我有一系列特定格式的文本文件。例如，file.txt如下所示，形状类似于50列字母和70行文本：

AAAAAAAAAAAA
BBBBBBBBBBBB
CCCCCCCCCCCC
DDDDDDDDDDDD

我想把下面的内容放入一个numpy数组中，并进行操作。这个数组有一定的维数。形状类似于50列字母，70行文本，例如shape（70,50）。但是，有些文本文件是“缺少字母”。有问题的文件是这样的

^{pr2}$

我想检查是否有“空格”存在，并抛出一个错误。有标准的方法来处理numpy数组吗？在将文本输入数组之前还是之后？在

我可以对多个文件执行此操作吗？也就是说，如果我输入200个文件，最终结果是一个numpy数组形状的(200,70,50)。在

Answer 1

对于大多数不需要的工作numpy。下面的代码将输入文件读入一个列表中，每个元素将是输入文件的一行（去掉尾随的换行符）。然后它创建一个长度相同的列表，每个元素都指示给定的字符串是否没有空格。如果其中任何一个是False，那么您就有问题了，您可以按照自己的意愿来处理这个问题。否则，无空格的条目将被读入字符串类型numpy.ndarray。在

import numpy as np

#read data into list "lines"
with open('input.inp') as f:
    lines = [line.rstrip('\n') for line in f]

#check ones with spaces
nospaces = [not ' ' in line for line in lines]

#throw an error here if you will
if not all(nospaces):
    print('Uh-oh!')

#or just ignore the ones contaning a space and put the rest into an ndarray
goodlines = np.array(lines)[np.array(nospaces)] #the only numpy-specific part

示例input.inp：

^{pr2}$

输出：

In [1131]: run foo.py
Uh-oh!

In [1132]: lines
Out[1132]: 
['asfasf asfasfsa',
 'asffsafsafa',
 'asfafsafs afa',
 'faaffasaff',
 'fasafasffas',
 'afssfafs asafsas']

In [1133]: goodlines
Out[1133]: 
array(['asffsafsafa', 'faaffasaff', 'fasafasffas'], 
      dtype='|S16')

注意，最后的输出是“16字符字符串”类型，因为我们首先将list转换成数组，然后抛出不必要的部分。只需做一些小的工作，您就可以根据自己的喜好定制这个解决方案，而且您的示例似乎还建议您的输入行具有相同的长度（在这种情况下，生成的数组将具有最佳的dtype）。在

Answer 2

我建议您先读取文件，检查空间，如果它通过测试，就可以存储它，以便最终构建数组。如果要丢弃无效数据，或者直接抛出一个错误，那么在数组中使用额外的指令来操作它是没有意义的。在

input_files = ['input0.txt', 'input1.txt', 'input2.txt']
valid_data = []

for i in input_files:
    with open(i, 'r') as f:
        data = f.read()
        if ' ' not in data:
            valid_data.append([list(s) for s in data.split('\n')])
        else:
            print 'Invalid data in file {}. File will be ignored.'.format(i)
result = np.array(valid_data)

当遇到无效文件时，代码将打印警告。如果你真的想抛出一个错误，它将停止整个进程，并且不会构造数组。为此，只需将打印的警告消息替换为

^{pr2}$

请注意，此代码假定所有文本文件具有相同的行数和列数。如果情况并非如此，请说明您希望如何处理。在

---

{cd1>如何在短列表中存储字符串。在

如果您有一个列表列表并将其传递给一个数组，它将为该列表创建一个2D数组。例如

>>> data = [['A', 'A', 'A'], ['B', 'B', 'B']]
>>> np.array(data)
array([['A', 'A', 'A'],
       ['B', 'B', 'B']], 
      dtype='|S1')

在这里，列表的成员数与文件中的行数相同，子列表包含列数据。因此，如果我们得到一个列表列表，其中有每个文件的列表，当我们将其传递给数组时，我们将获得所需的维度。在您的示例中，对于每个文件包含70行和50列的200个文件，我们将得到（200，70，50）。在

当我们一次性读取一个文件的内容时，它们的格式是'AAA\nBBB'，那么我们如何将其转换成[['A', 'A', 'A'], ['B', 'B', 'B']]？在

>>> data = 'AAA\nBBB'
>>> data.split('\n')
['AAA', 'BBB']
>>> [list(s) for s in data.split('\n')]
[['A', 'A', 'A'], ['B', 'B', 'B']]

Answer 3

使用文本行列表模拟文件：

In [401]: txt="""\
AAAAAAAAAAAA
BB BBBBBBBBB
CCCCCCCCCCCC
DDDDDD DDDDD
"""

In [402]: txt=txt.splitlines()

In [403]: txt
Out[403]: ['AAAAAAAAAAAA', 'BB BBBBBBBBB', 'CCCCCCCCCCCC', 'DDDDDD DDDDD']

你怎么把它加载到数组中？我们通常使用loadtxt，但这是针对数据列的

^{pr2}$

没用。在

让我们split在这些行上

In [410]: [x.split() for x in txt]
Out[410]: [['AAAAAAAAAAAA'], ['BB', 'BBBBBBBBB'], ['CCCCCCCCCCCC'], ['DDDDDD', 'DDDDD']]

带有“空白”的行将变成包含1个以上术语的列表

In [411]: [len(x.split())>1 for x in txt]
Out[411]: [False, True, False, True]

所以2行有错误。在

我可以通过list()传递字符串，将txt转换为每列一个字母的数组。这给np.array一个列表列表，长度相同。行尾的空白/空白可能会导致问题。在

In [414]: A=np.array([list(x) for x in txt])

In [415]: A
Out[415]: 
array([['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'],
       ['B', 'B', ' ', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B'],
       ['C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C'],
       ['D', 'D', 'D', 'D', 'D', 'D', ' ', 'D', 'D', 'D', 'D', 'D']], 
      dtype='|S1')

我可以测试这个数组中的' '字符，方法如下：

In [418]: np.any(A==' ',axis=1)
Out[418]: array([False,  True, False,  True], dtype=bool)

如果这些行的长度不同，那么这个array将不是2d，而是包含列表的1d。在

---

正如注释中建议的那样，我可以从整个字符串中创建一个数组，并使用view将它们“分割”成字符。在

带有“非功能”分隔符的loadtxt将创建一个二维数组，如下所示：

In [434]: np.array([[x] for x in txt])
Out[434]: 
array([['AAAAAAAAAAAA'],
       ['BB BBBBBBBBB'],
       ['CCCCCCCCCCCC'],
       ['DDDDDD DDDDD']], 
      dtype='|S12')

然后把它分成几个字符：

In [435]: np.array([[x] for x in txt]).view('S1')
Out[435]: 
array([['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'],
       ['B', 'B', ' ', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B'],
       ['C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C'],
       ['D', 'D', 'D', 'D', 'D', 'D', ' ', 'D', 'D', 'D', 'D', 'D']], 
      dtype='|S1')