Question

我有一个看起来像这样的文本文件：

...
5   [0, 1]  [512, 479]  991
10  [1, 0]  [706, 280]  986
15  [1, 0]  [807, 175]  982
20  [1, 0]  [895, 92]   987
...

每列都以制表符分隔，但某些列中有数组。我可以用np.genfromtxt以某种方式导入这些内容吗？

生成的解压缩列表应该是，例如：

data1 = [..., 5, 10, 15, 20, ...]
data2 = [..., [512, 479], [706, 280], ... ] (i.e. a 2D list)
etc.

我试过

data1, data2, data3, data4 = np.genfromtxt('data.txt', dtype=None, delimiter='\t', unpack=True)

但data2和data3是包含'nan'的列表。

Answer 1

给定数据的潜在方法，但不使用numpy：

import ast

data1, data2, data3, data4 = [],[],[],[]

for l in open('data.txt'):
    data = l.split('\t')

    data1.append(int(data[0]))
    data2.append(ast.literal_eval(data[1]))
    data3.append(ast.literal_eval(data[2]))
    data4.append(int(data[3]))

print 'data1', data1
print 'data2', data2
print 'data3', data3
print 'data4', data4

给出

"data1 [5, 10, 15, 20]"
"data2 [[0, 1], [1, 0], [1, 0], [1, 0]]"
"data3 [[512, 479], [706, 280], [807, 175], [895, 92]]"
"data4 [991, 986, 982, 987]"

Answer 2

csv文件中的括号无论你怎么看它都是笨拙的。默认的csv结构是2d - 行和统一列。括号添加了嵌套级别。但是这些列是制表符分隔的事实，而嵌套的块是逗号分隔的，这使得它更容易。

您的评论代码是（添加换行符）

datastr = data[i][1][1:-1].split(',') 
dataarray = [] 
for j in range(0, len(datastr)): 
     dataarray.append(int(datastr[j])) 
data2.append(dataarray)

我认为data[i]看起来像（在制表符分割后）：

['5', '[0, 1]', '[512, 479]',  '991']

因此，对于'[0,1]'你剥离[]，拆分其余部分，并将该列表重新放到data2。

这当然看起来是一种可行的方法。 genfromtxt会处理括号或引号。 csv读者可以处理引用的文字，并可能会将[]视为引号。但除此之外，我认为'[]`必须像你一样处理某种字符串处理。

请记住genfromtxt只读取行，解析它们，并在主列表中收集结果列表。然后它将该列表转换为最后的数组。因此，逐行逐行，逐字符串解析并不逊色。

=============

将您的样本作为文本文件：

 In [173]: txt=b"""
 ...: 5  \t [0, 1] \t [512, 479] \t 991
 ...: 10 \t [1, 0] \t [706, 280] \t 986
 ...: 15 \t [1, 0] \t [807, 175] \t 982
 ...: 20 \t [1, 0] \t [895, 92]  \t 987"""

使用genfromtxt进行简单dtype=None来电：

In [186]: data = np.genfromtxt(txt.splitlines(), dtype=None, delimiter='\t', autostrip=True)

结果是带有整数和字符串字段的结构化数组：

In [187]: data
Out[187]: 
array([(5, b'[0, 1]', b'[512, 479]', 991),
       (10, b'[1, 0]', b'[706, 280]', 986),
       (15, b'[1, 0]', b'[807, 175]', 982),
       (20, b'[1, 0]', b'[895, 92]', 987)], 
      dtype=[('f0', '<i4'), ('f1', 'S6'), ('f2', 'S10'), ('f3', '<i4')])

按名称

访问字段

In [188]: data['f0']
Out[188]: array([ 5, 10, 15, 20])
In [189]: data['f1']
Out[189]: 
array([b'[0, 1]', b'[1, 0]', b'[1, 0]', b'[1, 0]'], 
      dtype='|S6')

如果我们可以处理[]，那么您的数据可以很好地表示为具有复合dtype的结构化数组

In [191]: dt=np.dtype('i,2i,2i,i')
In [192]: np.ones((3,),dtype=dt)
Out[192]: 
array([(1, [1, 1], [1, 1], 1), (1, [1, 1], [1, 1], 1),
       (1, [1, 1], [1, 1], 1)], 
      dtype=[('f0', '<i4'), ('f1', '<i4', (2,)), ('f2', '<i4', (2,)), ('f3', '<i4')])

其中'f1'字段是（3,2）数组。

一种方法是通过过滤掉额外字符的函数传递文本/文件。 genfromtxt适用于任何能够一次为其提供线条的内容。

def afilter(txt):
    for line in txt.splitlines():
        line=line.replace(b'[', b' ').replace(b']', b'').replace(b',' ,b'\t')
        yield line

这个生成器剥离[]并替换带有制表符的，实际上生成一个扁平的csv文件

In [205]: list(afilter(txt))
Out[205]: 
[b'',
 b'5  \t  0\t 1  \t  512\t 479  \t 991',
 b'10 \t  1\t 0  \t  706\t 280  \t 986',
 b'15 \t  1\t 0  \t  807\t 175  \t 982',
 b'20 \t  1\t 0  \t  895\t 92   \t 987']

带有genfromtxt的

dtype=None将生成一个包含6列的数组。

In [209]: data=np.genfromtxt(afilter(txt),delimiter='\t',dtype=None)
In [210]: data
Out[210]: 
array([[  5,   0,   1, 512, 479, 991],
       [ 10,   1,   0, 706, 280, 986],
       [ 15,   1,   0, 807, 175, 982],
       [ 20,   1,   0, 895,  92, 987]])
In [211]: data.shape
Out[211]: (4, 6)

但如果我给它上面定义的dt dtype，我得到一个结构化数组：

In [206]: data=np.genfromtxt(afilter(txt),delimiter='\t',dtype=dt)
In [207]: data
Out[207]: 
array([(5, [0, 1], [512, 479], 991), (10, [1, 0], [706, 280], 986),
       (15, [1, 0], [807, 175], 982), (20, [1, 0], [895, 92], 987)], 
      dtype=[('f0', '<i4'), ('f1', '<i4', (2,)), ('f2', '<i4', (2,)), ('f3', '<i4')])
In [208]: data['f1']
Out[208]: 
array([[0, 1],
       [1, 0],
       [1, 0],
       [1, 0]], dtype=int32)

括号可以在几个层面处理。我不认为一方面有很多优势。

Answer 3

作为genfromtxt的替代方案，您可以尝试fromregex。你基本上在正则表达式组和numpy结构化dtype的字段之间建立了一个类比。

在这个例子中，我解析出所有数字而不用担心它们是单个数字还是数组。然后我切换到一个dtype，指定哪些列有数组。

import numpy as np

# regular expression that will extract 6 numbers from each line
re = 6 * r"(\d+)\D*"

# dtype for a single number
dt_num = np.int

# structured dtype of 6 numbers
dt = 6 * [('', dt_num)]

# parse the file
a = np.fromregex("data.txt", re, dt)

# change to a more descriptive structured dtype
a.dtype = [
  ('data1', dt_num),
  ('data2', dt_num, (2,)),
  ('data3', dt_num, (2,)),
  ('data4', dt_num)
]

print(a['data1'])
print(a['data2'])
print(a['data3'])
print(a['data4'])

关于切换numpy数组的dtype的好处是它不必处理或创建数据的新副本，它只是重新解释了访问数据时得到的结果。

此解决方案的一个缺点是构建复杂的正则表达式和构建结构化的dtypes会变得很难看。在这种情况下，你必须让两者保持同步。

Python导入文本数组与Numpy

3 个答案: