我有一个文本文件，看起来像这样:
...
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.
I tried
data1, data2, data3, data4 = np.genfromtxt('data.txt', dtype=None, delimiter='t', unpack=True)
但data2和data3是包含'nan'的列表
给定数据的潜在方法，但不使用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]"
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 0t 1 t 512t 479 t 991',
b'10 t 1t 0 t 706t 280 t 986',
b'15 t 1t 0 t 807t 175 t 982',
b'20 t 1t 0 t 895t 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)
括号可以在多个级别上处理。我不认为两者有什么优势
作为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的好处是它不需要处理或创建数据的新副本，它只是重新解释你访问数据时得到的内容。
这个解决方案的一个缺点是，构建复杂的正则表达式和构建结构化的dtype可能会变得很难看。在这种情况下，你必须保持两者同步