Автоматически создавать большую матрицу из меньших матриц в Python 3

Question

У меня есть несколько меньших матриц, которые я хотел бы объединить в большую матрицу.

Я пытаюсь сделать это с помощью команды hstack в Numpy, но он рассматривает каждую комбинацию как строку, а не матрицы, которые представляет строка. Команда hstack работает нормально, если я ее вручную закодирую.

import numpy as np 
import itertools as it 

sm01 = np.matrix([[1],[1],[1]]) 
sm02 = np.matrix([[2],[2],[2]]) 
sm03 = np.matrix([[3],[3],[3]]) 

Variables = ['sm01','sm02','sm03'] 
Comblst = [''] 
for i in range(0, len(Variables)+1): 
    for subset in it.combinations(Variables, i): 
    a = str(subset).strip('()') 
    Comblst = np.vstack([Comblst,a]) 

var = str(Comblst[6]).strip('[]').strip('""').strip(',').replace("'","") 
var = tuple(var.split(', ')) 
LargeMatrix = np.hstack([var]) 

Answer 1

Я думаю, вы должны построить Conblst с список Append, не vstack.

Comblst = [] 
for 
    for 
     Comblst.append(a) 

Покажите нам, что Comblst и var выглядеть. Я не могу следовать за строительством, просто прочитав код.

И что является результатом hstack.

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

Out[1087]: ['sm01', 'sm02', 'sm03'] 
In [1088]: Comblst 
Out[1088]: 
array([[''], 
     [''], 
     ["'sm01',"], 
     ["'sm02',"], 
     ["'sm03',"], 
     ["'sm01', 'sm02'"], 
     ["'sm01', 'sm03'"], 
     ["'sm02', 'sm03'"], 
     ["'sm01', 'sm02', 'sm03'"]], 
     dtype='<U22') 

In [1090]: var = str(Comblst[6]).strip('[]').strip('""').strip(',').replace("'", 
     ...: "") 
     ...: var = tuple(var.split(', ')) 
     ...: 
In [1091]: var 
Out[1091]: ('sm01', 'sm03') 

In [1092]: np.hstack([var]) 
Out[1092]: 
array(['sm01', 'sm03'], 
     dtype='<U4') 

Это просто куча строковых манипуляций, которые лучше было бы сделано со списками, а не массивы , Но в чем же цель? Вы на самом деле стремитесь производить

In [1093]: np.hstack([sm01, sm03]) 
Out[1093]: 
matrix([[1, 3], 
     [1, 3], 
     [1, 3]]) 

В Python есть очень реальная разница между строками или названиями, и объектами, на которые они ссылаются.

Я подозреваю, что лучше из пути построения Comblst является:

In [1096]: 
     ...: Comblst = [] 
     ...: for i in range(0, len(Variables)+1): 
     ...: for subset in itertools.combinations(Variables, i): 
     ...:  # a = str(subset).strip('()') 
     ...:  Comblst.append(subset) 
     ...:  
     ...:  
In [1097]: Comblst 
Out[1097]: 
[(), 
('sm01',), 
('sm02',), 
('sm03',), 
('sm01', 'sm02'), 
('sm01', 'sm03'), 
('sm02', 'sm03'), 
('sm01', 'sm02', 'sm03')] 

In [1099]: Comblst[5] 
Out[1099]: ('sm01', 'sm03') 

Забудьте о том, чтобы и разделение строк; вместо этого просто собирайте кортежи этих имен.

Но вам не обязательно работать с именами; Вы можете начать с перечнем самих матриц:

In [1101]: Mlist=[sm01, sm02, sm03] 
In [1102]: 
     ...: Comblst = [] 
     ...: for i in range(0, len(Mlist)+1): 
     ...: for subset in itertools.combinations(Mlist, i): 
     ...:  Comblst.append(subset) 
     ...:  
In [1103]: Comblst 
Out[1103]: 
[(), (matrix([[1], 
      [1], 
      [1]]),), (matrix([[2], 
      [2], 
      [2]]),), (matrix([[3], 
      [3], 
      .... 
      [3]]))] 
In [1104]: Comblst[5] 
Out[1104]: 
(matrix([[1], 
     [1], 
     [1]]), matrix([[3], 
     [3], 
     [3]])) 
In [1105]: np.hstack(Comblst[5]) 
Out[1105]: 
matrix([[1, 3], 
     [1, 3], 
     [1, 3]]) 

Или построить список простых числовых кортежей, а индекс с этим

In [1109]: 
     ...: Comblst = [] 
     ...: for i in range(0, len(Mlist)+1): 
     ...: for subset in itertools.combinations(list(range(0, len(Mlist))), i): 
     ...:  Comblst.append(subset) 

In [1110]: Comblst 
Out[1110]: [(), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2)] 
In [1111]: Comblst[5] 
Out[1111]: (0, 2) 
In [1112]: np.hstack([Mlist[i] for i in Comblst[5]]) 
Out[1112]: 
matrix([[1, 3], 
     [1, 3], 
     [1, 3]])