This shows a fairly high-performance (although slower than initializing to exact size) way to fill in an array of unknown size in numpy:

data = numpy.zeros( (1, 1) )
N = 0
while True:
    row = ...
    if not row: break
    # assume every row has shape (K,)
    K = row.shape[0]
    if (N >= data.shape[0]):
        # over-expand: any ratio around 1.5-2 should produce good behavior
        data.resize( (N*2, K) )
    if (K >= data.shape[1]):
        # no need to over-expand: presumably less common
        data.resize( (N, K+1) )
    # add row to data
    data[N, 0:K] = row

# slice to size of actual data
data = data[:N, :]

Adapting to your case:

if count > temp.shape[0]:
    temp.resize( (max( temp.shape[0]*2, count+1 ), temp.shape[1]) )
if i > temp.shape[1]:
    temp.resize( (temp.shape[0], max(temp.shape[1]*2, i+1)) )
# now safe to use temp[count, i]

You may also want to keep track of the actual data sizes (max count, max i) and trim the array later.

If you don't know the size before-hand, then don't use a numpy array to accumulate the values. Use a flexible container (e.g. a list) and then convert to a numpy array afterwards.

If you're working with something really large, there's also numpy.fromiter which will behave quite a bit more efficiently, but you'll have to jump through a couple of hoops to use it with >1D arrays.

As an example of the first suggestion, let's say we're creating an array that will always have 10 columns, but we have no way of knowing how many rows there are. We'll use a list to store each row, and then convert to a 2D array at the end:

import numpy as np

data = []

random_val = 1
while random_val > 0.05:
    data.append(np.arange(10))
    random_val = np.random.random()

data = np.array(data)
print data.shape

The structure you have now, with all the data in a single list (list and array mean different things in Python by the way), actually makes it easier to get a column. If your record is of size r_len = 6, and you want col = 3 (the fourth column), you can do

>>> Student.student_array[col::r_len]
[1, 4, 7]

To store a 2D list, though, you need to place each student's information into a separate list in your loop:

current_student = [len(Student.student_array), name, course_name, mark1, mark2, mark3]
Student.student_array.append(current_student)

Notice that you do not need to maintain a separate count this way: the length of the outer list speaks for itself.

To get the data from col = 3 in a 2D array like this, use a comprehension:

>>> [s[col] for s in Student.student_array]
[1, 4, 7]

Keeping related information in an unlabeled format like that is generally a poor idea though. You can either add labels by using a library like pandas, which will maintain proper tables for you, or you can encapsulate each student's info into a small class. You can write your own class, or use something like a namedtuple:

Record = collections.namedtuple('Record', ['id', 'name', 'course', 'mark1', 'mark2', 'mark3'])

...

Student.student_array.append(Record(len(Student.student_array), name, course_name, mark1, mark2, mark3))

You can now extract mark1 for each student instead of a numerical index, which is liable to change and cause a maintenance problem later:

>>> [s.mark1 for s in Student.student_array]
[1, 4, 7]

You can use numpy:

import numpy as np
my_array = np.zeros([height, width])

For example:

>>> np.zeros([3, 5])
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])

Note that if you specifically need integers, you should use the dtype argument

>>> np.zeros([3, 5], dtype=int)
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])

You're technically trying to index an uninitialized array. You have to first initialize the outer list with lists before adding items; Python calls this "list comprehension".

# Creates a list containing 5 lists, each of 8 items, all set to 0
w, h = 8, 5
Matrix = [[0 for x in range(w)] for y in range(h)] 

#You can now add items to the list:

Matrix[0][0] = 1
Matrix[6][0] = 3 # error! range... 
Matrix[0][6] = 3 # valid

Note that the matrix is "y" address major, in other words, the "y index" comes before the "x index".

print Matrix[0][0] # prints 1
x, y = 0, 6 
print Matrix[x][y] # prints 3; be careful with indexing! 

Although you can name them as you wish, I look at it this way to avoid some confusion that could arise with the indexing, if you use "x" for both the inner and outer lists, and want a non-square Matrix.

Build a Python list and convert that to a Numpy array. That takes amortized O(1) time per append + O(n) for the conversion to array, for a total of O(n).

Use with AI    a = []
    for x in y:
        a.append(x)
    a = np.array(a)