How's this?

def submatrix(X, i, j):
    return [[elem for x, elem in enumerate(row) if x != i]
            for y, row in enumerate(X) if y != j]

X = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]

print(submatrix(X, 1, 1))

For one, you can use slice objects directly, which helps a bit with both the readability and performance:

r = slice(1,4)
s = slice(2,5)
[LoL[i][s] for i in range(len(LoL))[r]]

And if you just iterate over the list-of-lists directly, you can write that as:

[row[s] for row in LoL[r]]

I would solve it slightly different. a function to read y-number-of-rows then a function to read x-number-of-columns from those rows, which then is your sub.

This would work for any (2D) array / sub-array

Sample:

def read_y_rows(array, rows, offset):
    return array[offset:rows + offset]


def read_x_cols(array, cols, offset):
    return list(row[offset:cols + offset] for row in array)


def get_sub_arrays(array, x_dim_cols, y_dim_rows):
    """
    get 2D sub arrays by x_dim columns and y_dim rows
    from 2D array (list of lists)
    """
    result = []
    for start_row in range(len(array) - y_dim_rows + 1):
        y_rows = read_y_rows(array, y_dim_rows, start_row)
        for start_col in range(len(max(array, key=len)) - x_dim_cols + 1):
            x_columns = read_x_cols(y_rows, x_dim_cols, start_col)
            result.append(x_columns)
    return result

to use it you could do:

M3 = [list(range(5)) for i in range(6)]
sub_arrays = get_sub_arrays(M3, 3, 3) ## this would also work for 2x2 arrays

the sub_arrays is again a list of lists, containing all found subarrays, you could print them like this:

for sub_array in sub_arrays:
    print()
    for row in sub_array:
        print(row)

I know it is a lot more code than above, just wanted to share this code.

If your matrix size is fixed and is divisible by 3 something like this would do the trick:

for i in range(3):
    for j in range(3):
        print(M[i:i+3,j:j+3])

It also works for bigger matrices but it will leave unused elements if it can't index three elements.

Basically I am indexing the matrix M in both axis. For mor info, please, check Numpy docs

Here's a sagetex solution using SAGE, a computer algebra system (CAS). Documentation on some matrix basics is here. The complete documentation for matrices is available in PDF form here. With 685 pages of documentation you'll find SAGE can do most anything you want.

\documentclass{article}
\usepackage{sagetex,amsmath,amsfonts}
\linespread{2.0}
\begin{document}
\begin{sagesilent}
latex.matrix_delimiters(left='[', right=']')
A=matrix([[5,0,0],[0,2,-5],[6,1,-2]])
B = matrix(4,[0..15])
C= B.delete_rows([0,3]).delete_columns([1,2])
D= A.delete_rows([0]).delete_columns([0])
\end{sagesilent}
Consider the matrices below:  \[A=\sage{A} \hspace{2cm} B=\sage{B}\] 

The entry $A_{1,1}=\sage{A[0][0]}$ because SAGE is Python 
based and indices start with $0$. We can create submatrices $C=\sage{C}$ and    $D=\sage{D}$ by 
deleting rows and columns. SAGE can calculate $C \cdot D = \sage{C*D}$ and its  determinant:
\begin{sagesilent}
latex.matrix_delimiters(left='|', right='|')
\end{sagesilent}
$det(C \cdot D)=\sage{C*D}=\sage{det(C*D)}$
\end{document}

The result, running in Cocalc:

The most important thing to remember is that SAGE, which is Python based and gives you access to Python, has a default starting index of 0. So removing the first row and column from your matrix is given by: D= A.delete_rows([0]).delete_columns([0]). What surrounds your matrix in LaTeX are the delimiters, documentation for changing them in SAGE is here. The code latex.matrix_delimiters(left='|', right='|') changed the delimiters so I could show the determinant in LaTeX.

SAGE is not part of LaTeX. The easiest way to get started is with a free Cocalc account.

One solution is to index the rows/columns by slicing/striding. Here's an example where you are extracting every third column/row from the first to last columns (i.e. the first and fourth columns)

In [1]: import numpy as np
In [2]: Y = np.arange(16).reshape(4, 4)
In [3]: Y[0:4:3, 0:4:3]
Out[1]: array([[ 0,  3],
               [12, 15]])

This gives you the output you were looking for.

For more info, check out this page on indexing in NumPy.

Here I have an example program where a 2 loops implementation works and is crystal clear in its intent, a 1 loop implementation works and is, imho, slightly less clear and eventually a 0 (explicit, btw) loops implementation that, alas, is buggy.

My vote goes to the two loops... further, I'd like to be shown what's wrong with my 0 loops attempt

Code

import itertools

def pm(m):
    for row in m: print row

mat = []
n = 8
for i in range(n):
    mat.append(range(i*n, i*n+n))

# this is shorthand for your splitmat function
res = map(lambda (x,y):
          map(lambda z:z[y[0]:y[1]],mat[x[0]:x[1]]),
          itertools.product([(0,n/2),(n/2,n)],repeat=2))
pm(res)

print "\n2 cycles"
mat = []
for i, j in ((0,1),(2,3)):
    for a, b in zip(res[i],res[j]):
        mat.append(a+b)
pm(mat)

print "\n1 cycle"
mat = []
for i, j in ((0,1),(2,3)):
    map(lambda x: mat.append(x[0]+x[1]), zip(res[i],res[j]))
pm(mat)

print "\n0 cycles"
mat =  map(lambda i_j: 
       map(lambda x: x[0]+x[1], zip(res[i_j[0]],res[i_j[1]])), ((0,1),(2,3)))
pm(mat)

Output

[[0, 1, 2, 3], [8, 9, 10, 11], [16, 17, 18, 19], [24, 25, 26, 27]]
[[4, 5, 6, 7], [12, 13, 14, 15], [20, 21, 22, 23], [28, 29, 30, 31]]
[[32, 33, 34, 35], [40, 41, 42, 43], [48, 49, 50, 51], [56, 57, 58, 59]]
[[36, 37, 38, 39], [44, 45, 46, 47], [52, 53, 54, 55], [60, 61, 62, 63]]

2 cicli
[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, 36, 37, 38, 39]
[40, 41, 42, 43, 44, 45, 46, 47]
[48, 49, 50, 51, 52, 53, 54, 55]
[56, 57, 58, 59, 60, 61, 62, 63]

1 ciclo
[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, 36, 37, 38, 39]
[40, 41, 42, 43, 44, 45, 46, 47]
[48, 49, 50, 51, 52, 53, 54, 55]
[56, 57, 58, 59, 60, 61, 62, 63]

0 cicli
[[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, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47], [48, 49, 50, 51, 52, 53, 54, 55], [56, 57, 58, 59, 60, 61, 62, 63]]