For the first question:

A = [ [1,2,3,4,5,6,7,8] for i in range(8)]
n = len(A[0])
x = int(n/2)

TEMP = [[None]*2 for i in range(2)]

for w in range(2):
    for q in range(2):
        TEMP[w][q] = [item[q * x:(q * x) + x] for item in A[w * x:(w * x) + x]]

for w in range(2):
    for q in range(2):
        print("{i}, {j}: {item}".format(i=w, j=q, item=repr(TEMP[w][q])))

You can get the square root of the list's length then split it using a list comprehension. This will work for lists with the length of 4, 9, 16, ...:

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

def split_equal(lst):
    len_ = len(lst)

    # returns emtpy list, if the list has no item.
    if len_ == 0:
        return []
    
    n = int(len_ ** 0.5)
    return [lst[i:i + n] for i in range(0, len_, n)]

output:

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

You could use nested lists instead. One convenient way to construct them is with (nested) list comprehensions, e.g.

n_rows, n_cols = 7, 7

pseudo_array = [[row * n_cols + col for col in range(n_cols)] 
                for row in range(n_rows)]
pseudo_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, 36, 37, 38, 39, 40, 41],
 [42, 43, 44, 45, 46, 47, 48]]

Edit: Note that NumPy arrays have commas too, it's just that they also have their own representation method, so that print() doesn't show the commas. If you want to do something similar for your nested lists, you could define your own printing function, e.g.

def print_array(a):
    """ Take a nested list a and print it like a NumPy array. """
    for i, row in enumerate(a):
        if i == 0:
            first_char = '['
        else: 
            first_char = ' '
        if i == len(a) - 1:
            last_char = ']'
        else: 
            last_char = ''    
        print(first_char + '[' + 
              ' '.join(str(i) for i in row) + ']' + last_char)
        
print_array(pseudo_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 36 37 38 39 40 41]
 [42 43 44 45 46 47 48]]

As you see, it looks almost like a printed NumPy array, only the pretty column alignment isn't implemented yet.

You need to keep track of the current index in your loop.

Essentially you want to turn a list like 0,1,2,3,4,....24 (these are the indices of your initial array, alpha) into:

R1C1, R1C2, R1C3, R1C4, R1C5 R2C1, R2C2... etc

I added the logic to do this the way you are currently doing it:

def createMatrix(rowCount, colCount, dataList):
    mat = []
    for i in range(rowCount):
        rowList = []
        for j in range(colCount):
            # you need to increment through dataList here, like this:
            rowList.append(dataList[rowCount * i + j])
        mat.append(rowList)

    return mat

def main():
    alpha = ['a','b','c','d','e','f','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
    mat = createMatrix(5,5,alpha)
    print (mat)

main()

which then prints out:

[['a', 'b', 'c', 'd', 'e'], ['f', 'h', 'i', 'j', 'k'], ['l', 'm', 'n', 'o', 'p'], ['q', 'r', 's', 't', 'u'], ['v', 'w', 'x', 'y', 'z']]

The reason you were always receiving a,b,c,d,e is because when you write this:

        rowList.append(dataList[j])

what it is effectively doing is it is iterating 0-4 for every row. So basically:

i = 0
rowList.append(dataList[0])
rowList.append(dataList[1])
rowList.append(dataList[2])
rowList.append(dataList[3])
rowList.append(dataList[4])
i = 1
rowList.append(dataList[0]) # should be 5
rowList.append(dataList[1]) # should be 6
rowList.append(dataList[2]) # should be 7
rowList.append(dataList[3]) # should be 8
rowList.append(dataList[4]) # should be 9

etc.

A = [1,2,3,4,5,6]
B = A[:len(A)//2]
C = A[len(A)//2:]

If you want a function:

def split_list(a_list):
    half = len(a_list)//2
    return a_list[:half], a_list[half:]

A = [1,2,3,4,5,6]
B, C = split_list(A)