假设我有一个字典，称之为coeffs：
coeffs = {'X1': 0.1, 'X2':0.2, 'X3':0.4, ..., 'Xn':0.09}
如何将值转换为1 x n ndarray？
进入n x m ndarray？
答案 0 :(得分：3)
以下是使用coeffs填充数组的示例，其值列表来自字典键：
In [591]: coeffs = {'X1': 0.1, 'X2':0.2, 'X3':0.4, 'X4':0.09}
In [592]: alist = [[int(k[1:]),v] for k,v in coeffs.items()]
In [593]: alist
Out[593]: [[4, 0.09], [3, 0.4], [1, 0.1], [2, 0.2]]
这里我剥离了初始字符并将其余部分转换为整数。你可以做自己的转换。
现在只需初始化一个空数组，并填入值：
In [594]: X = np.zeros((5,))
In [595]: for k,v in alist: X[k] = v
In [596]: X
Out[596]: array([ 0. , 0.1 , 0.2 , 0.4 , 0.09])
显然我可以使用X = np.zeros((1,5))。除非为每个字典项选择(n,m)，否则n数组没有意义。
只是为了笑，这是从字典中制作数组的另一种方法 - 将键和值放入结构化数组的字段中：
In [613]: X = np.zeros(len(coeffs),dtype=[('keys','S3'),('values',float)])
In [614]: X
Out[614]:
array([(b'', 0.0), (b'', 0.0), (b'', 0.0), (b'', 0.0)],
dtype=[('keys', 'S3'), ('values', '<f8')])
In [615]: for i,(k,v) in enumerate(coeffs.items()):
X[i]=(k,v)
.....:
In [616]: X
Out[616]:
array([(b'X4', 0.09), (b'X3', 0.4), (b'X1', 0.1), (b'X2', 0.2)],
dtype=[('keys', 'S3'), ('values', '<f8')])
In [617]: X['keys']
Out[617]:
array([b'X4', b'X3', b'X1', b'X2'],
dtype='|S3')
In [618]: X['values']
Out[618]: array([ 0.09, 0.4 , 0.1 , 0.2 ])
scipy sparse模块具有稀疏矩阵格式，可将其值存储在字典中，实际上，它是字典的子类。这本词典中的键是(i,j)元组，非零元素的索引。 Sparse具有将这种矩阵快速转换为其他更加计算友好的稀疏格式以及常规密集阵列的工具。
我在其他SO问题中了解到，构建此类矩阵的一种快速方法是使用常规字典update方法复制另一个字典中的值。
受这个问题的@user's 2d版本的启发，这里是如何创建这样一个稀疏矩阵。
从@user's示例coeffs开始：
In [24]: coeffs
Out[24]:
{'Y8': 22,
'Y2': 16,
'Y6': 20,
'X5': 20,
'Y9': 23,
'X2': 17,
...
'Y1': 15,
'X4': 19}
定义一个将X3样式的键转换为(0,3)样式的小函数：
In [25]: def decodekey(akey):
pt1,pt2 = akey[0],akey[1:]
i = {'X':0, 'Y':1}[pt1]
j = int(pt2)
return i,j
....:
将字典理解应用于coeffs（或使用早期Python版本中的常规循环）：
In [26]: coeffs1 = {decodekey(k):v for k,v in coeffs.items()}
In [27]: coeffs1
Out[27]:
{(1, 2): 16,
(0, 1): 16,
(0, 0): 15,
(1, 4): 18,
(1, 5): 19,
...
(0, 8): 23,
(0, 2): 17}
导入sparse并定义一个空的dok矩阵：
In [28]: from scipy import sparse
In [29]: M=sparse.dok_matrix((2,10),dtype=int)
In [30]: M.A
Out[30]:
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
用coeffs1字典值填充它：
In [31]: M.update(coeffs1)
In [33]: M.A # convert to dense array
Out[33]:
array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24],
[14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])
实际上，我不需要使用sparse将coeffs1转换为数组。 (i,j)元组可以直接索引数组，A[(i,j)]与A[i,j]相同。
In [34]: A=np.zeros((2,10),int)
In [35]: for k,v in coeffs1.items():
....: A[k] = v
....:
In [36]: A
Out[36]:
array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24],
[14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])
答案 1 :(得分：1)
n x m数组 @hpaulj's answer假设（正确地）X之后的数字应该是位置。如果你有像
coeffs = {'X1': 3, 'X2' : 5, ..., 'Xn' : 34, 'Y1': 5, 'Y2' : -3, ..., 'Yn': 32}
您可以执行以下操作。给出样本数据，如
{'Y3': 17, 'Y2': 16, 'Y8': 22, 'Y5': 19, 'Y6': 20, 'Y4': 18, 'Y9': 23, 'Y1': 15, 'X8': 23, 'X9': 24, 'Y7': 21, 'Y0': 14, 'X2': 17, 'X3': 18, 'X0': 15, 'X1': 16, 'X6': 21, 'X7': 22, 'X4': 19, 'X5': 20}
创建
a = {}
for i in range(10):
a['X'+str(i)] = 15 + i
for i in range(10):
a['Y'+str(i)] = 14 + i
把它放在一些有序的字典中（效率低，但很容易）
b = {}
for k, v in a.iteritems():
letter = k[0]
index = float(k[1:])
if letter not in b.keys():
b[letter] = {}
b[letter][index] = v
给出
>>> b
{'Y': {0: 14, 1: 15, 2: 16, 3: 17, 4: 18, 5: 19, 6: 20, 7: 21, 8: 22, 9: 23}, 'X': {0: 15, 1: 16, 2: 17, 3: 18, 4: 19, 5: 20, 6: 21, 7: 22, 8: 23, 9: 24}}
找出阵列的目标尺寸。 （这假定所有参数都是相同的长度，并且您给出了所有的值）。
row_length = max(b.values()[0])
row_indices = b.keys()
row_indices.sort()
通过
创建数组X = np.empty((len(b.keys()), max(b.values()[0])))
并插入数据：
for i,row in enumerate(row_indices):
for j in range(row_length):
X[i,j] = b[row][j]
结果
>>> X
array([[ 15., 16., 17., 18., 19., 20., 21., 22., 23.],
[ 14., 15., 16., 17., 18., 19., 20., 21., 22.]])
coeffs.values()是dict值的数组。只需创建一个
np.array(coeffs.values())
通常，当您拥有coeffs之类的对象时，可以输入
help(coeffs)
在解释器中，获取它可以做的全部列表。