There are several ways to get submatrix in numpy:

In [35]: ri = [0,2]
    ...: ci = [2,3]
    ...: a[np.reshape(ri, (-1, 1)), ci]
Out[35]: 
array([[ 2,  3],
       [10, 11]])

In [36]: a[np.ix_(ri, ci)]
Out[36]: 
array([[ 2,  3],
       [10, 11]])

In [37]: s=a[np.ix_(ri, ci)]

In [38]: np.may_share_memory(a, s)
Out[38]: False

note that the submatrix you get is a new copy, not a view of the original mat.

Give np.ix_ a try:

Y[np.ix_([0,3],[0,3])]

This returns your desired result:

In [25]: Y = np.arange(16).reshape(4,4)
In [26]: Y[np.ix_([0,3],[0,3])]
Out[26]:
array([[ 0,  3],
       [12, 15]])

It probably is more useful to work with the transpose of W rather than W itself, both for human-readability and to facilitate writing the code. This means that the entries that affect each S_i are grouped together in one of the inner parentheses of W, i.e. in a row of W rather than a column as you have it now.

Then, S_i = np.array[S[j,:] for j in np.shape(S)[0] if W_T[i,j] == 1], where W_T is the transpose of W. If you need/want to stick with W as is, you need to reverse the indices i and j.

As for the outer loop, you could try to nest this in another similar comprehension without an if statement--however this might be awkward since you aren't actually building one output matrix (the S_i can easily be different dimensions, unless you're somehow guaranteed to have the same number of 1s in every column of W). This in fact raises the question of what you want--a list of these arrays S_i? Otherwise if they are separate variables as you have it written, there's no good way to refer to them in a generalizable way as they don't have indices.

I made some commands to store a matrix and to show the matrix, an element of the matrix, or a submatrix. The elements of the matrix are saved <matrix name>-<y>-<x>, so you could define further commands with that.

Result

Code

\documentclass{article}

\usepackage{etoolbox}
\usepackage{pgffor}
\usepackage{booktabs}

\def\dmname{}
\newcounter{dmx}
\newcounter{dmy}
\newcommand{\dmlines}[1]{%
    \setcounter{dmx}{0}
    \forcsvlist{\dmelements}{#1}
    \stepcounter{dmy}
}
\newcommand{\dmelements}[1]{%
    \csdef{\dmname-\thedmy-\thedmx}{#1}%
    \stepcounter{dmx}%
}
\newcommand{\definematrix}[2]{%
    % #1 = name
    % #2 = matrix
    \gdef\dmname{#1}%
    \setcounter{dmy}{0}%
    \forcsvlist{\dmlines}{#2}%
    \csxdef{\dmname-w}{\thedmx}%
    \csxdef{\dmname-h}{\thedmy}%
}

\newcommand{\getmatrixelement}[3]{%
    % #1 = name
    % #2 = y
    % #3 = x
    \csuse{#1-#2-#3}%
}

\newcommand{\getsubmatrix}[5]{%
    % #1 = name
    % #2 = y
    % #3 = x
    % #4 = y2
    % #5 = x2
    \def\dmtablecontent{}%
    \foreach \y in {#2, ..., #4} {%
        \foreach \x in {#3, ..., #5} {%
            \xappto\dmtablecontent{\csuse{#1-\y-\x}}%
            \ifnumless{\x}{#5}{%
                \xappto\dmtablecontent{&}%
            }{}%
        }%
        \xappto\dmtablecontent{\\}%
    }%
    %
    \begin{tabular}{*{\the\numexpr#5-#3+1\relax}{c}}%
        \dmtablecontent%
    \end{tabular}%
}

\newcommand{\getmatrixwidth}[1]{%
    % #1 = name
    \csuse{#1-w}%
}

\newcommand{\getmatrixheight}[1]{%
    % #1 = name
    \csuse{#1-h}%
}

\newcommand{\getmatrix}[1]{%
    % #1 = name
    \getsubmatrix{#1}{0}{0}
    {\the\numexpr\getmatrixheight{#1}-1\relax}
    {\the\numexpr\getmatrixwidth{#1}-1\relax}%
}

\newcommand{\getmatrixwithoutrc}[3]{%
    % shows the matrix without the given row and column
    % #1 = name
    % #2 = row
    % #3 = column
    \def\dmtablecontent{}%
    \def\dmymax{\the\numexpr\getmatrixheight{#1}-1\relax}%
    \def\dmxmax{\the\numexpr\getmatrixwidth{#1}-1\relax}%
    \foreach \y in {0, ..., \dmymax} {%
        \ifnumequal{\y}{#2}{}{%
            \foreach \x in {0, ..., \dmxmax} {%
                \ifnumequal{\x}{#3}{}{%
                    \xappto\dmtablecontent{\csuse{#1-\y-\x}}%
                    \ifnumless{\x}{\dmxmax}{%
                        \xappto\dmtablecontent{&}%
                    }{}%
                }%
            }%
            \xappto\dmtablecontent{\\}%
        }%
    }%
    %
    \begin{tabular}{*{\getmatrixwidth{#1}}{c}}
        \dmtablecontent
    \end{tabular}
}

\begin{document}

\definematrix{a}{{1, 2}, {3, 4}}
\definematrix{b}{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}

\renewcommand{\arraystretch}{1.5}
\begin{tabular}{ll}
    \toprule
    \textbf{Result} & \textbf{Command}\\
    \midrule
    & \verb|\definematrix{a}{{1, 2}, {3, 4}}|\\
    & \verb|\definematrix{b}{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}| \\
    $\getmatrixheight{a} \times \getmatrixwidth{a}$ &
    \verb|$\getmatrixheight{a} \times \getmatrixwidth{a}$|
    \\
    \getmatrix{a} &
    \verb|\getmatrix{a}|
    \\
    \getmatrixelement{a}{0}{0} &
    \verb|\getmatrixelement{a}{0}{0}|
    \\
    \getmatrixelement{a}{1}{0} &
    \verb|\getmatrixelement{a}{1}{0}|
    \\
    \getsubmatrix{a}{0}{1}{1}{1} &
    \verb|\getsubmatrix{a}{0}{1}{1}{1}|
    \\
    \getmatrix{b} &
    \verb|\getmatrix{b}|
    \\
    \getsubmatrix{b}{1}{1}{2}{2} &
    \verb|\getsubmatrix{b}{1}{1}{2}{2}|
    \\
    \getmatrixwithoutrc{b}{1}{1} &
    \verb|\getmatrixwithoutrc{b}{1}{1}|
    \\
    \bottomrule
\end{tabular}

\end{document}

Use numpy as follow to create a n x m matrix (assuming input_set is a list)

import numpy as np

input_matrix = np.array(input_set).reshape(n,m)

With A as the input array containing those sub-matrices, you could use some reshaping and permute dimensions with np.transpose, like so -

A.reshape(2,2,3,3).transpose(0,2,1,3).reshape(-1,6)

Explanation -

• Cut the first axis into two parts : A.reshape(2,2,3,3).
• Swap the second and third axes : .transpose(0,2,1,3).
• Finally, reshape to have 6 columns : .reshape(-1,6).

Thus, the solution could be generalized like so -

m,n,r = A.shape
out = A.reshape(-1,2,n,r).transpose(0,2,1,3).reshape(-1,2*r)

Sample run

Let's re-create your A -

In [54]: A = np.arange(36).reshape(-1,3,2,3). transpose(0,2,1,3).reshape(4,3,3)

In [55]: A
Out[55]: 
array([[[ 0,  1,  2],
        [ 6,  7,  8],
        [12, 13, 14]],

       [[ 3,  4,  5],
        [ 9, 10, 11],
        [15, 16, 17]],

       [[18, 19, 20],
        [24, 25, 26],
        [30, 31, 32]],

       [[21, 22, 23],
        [27, 28, 29],
        [33, 34, 35]]])

Then, run our code -

In [56]: A.reshape(2,2,3,3).transpose(0,2,1,3).reshape(-1,6)
Out[56]: 
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])