Assign random numbers in a grid with no duplicates in Python

You just need to create a "baseline" grid, where no two rows or columns are the same. For example, for a grid of size 4x4, the baseline would be:

[[1, 2, 3, 4],
 [4, 1, 2, 3],
 [3, 4, 1, 2],
 [2, 3, 4, 1]]

Then shuffle the rows, then shuffle the columns.

Pure python:

random.shuffle only shuffles the elements of the list you passed. In order to shuffle columns, you will need to transpose the list-of-lists such that the first axis groups columns instead of rows.

import random

def random_grid(size=4):
    r = list(range(1, size+1))
    baseline = [r[-n:] + r[:-n] for n in range(size)]
    random.shuffle(baseline)
    transpose = [list(col) for col in zip(*baseline)]
    random.shuffle(transpose)
    return transpose

Using numpy:

np.random.shuffle only shuffles the first axis, so we transpose the array before shuffling it another time.

import numpy as np

def random_grid(size=4):
    r = list(range(1, size+1))
    baseline = np.array([r[-n:] + r[:-n] for n in range(size)])
    np.random.shuffle(baseline)
    np.random.shuffle(baseline.T)
    return baseline

Now, since you want random numbers between 0 and size, you can just get a grid that is one row and column larger than what you want, subtract one from every element, and discard the extra row and column.

Pure python:

def random_grid_2(size=4):
    rgrid = random_grid(size+1)
    return [[i - 1 for i in row[:-1]] for row in grid[:-1]]

Numpy:

def random_grid_2(size=4):
    rgrid = random_grid(size+1) - 1
    return rgrid[:-1, :-1]

Of course, this approach is less efficient than doing it in random_grid in the first place, when you are creating the grid, but I have kept the two steps separate to help you understand what is happening.

Ok, here's some code that implements my method; more for demonstration than for practical use since, as was said in a comment, it can fail (if there are no choice left, which can happen for the 3 numbers in the bottom right corner of the matrix); this could be addressed by catching the error and restarting the process, but it's not very elegant.

from random import choice

numbers = {0,1,2,3,4}

a=[[],[],[],[]]

for i in range(4):
    for j in range(4):
        available = list(numbers - set(a[i][:j]) - {a[x][j] for x in range(i)})
        a[i].append(choice(available))
        
print(a)

Here's the amended code (with error catching); it will always work, but at the cost of potentially creating several failed matrices before a working one.

from random import choice

numbers = {0,1,2,3,4}

failed = True
while failed:
    a=[[],[],[],[]]
    failed = False
    try:
        for i in range(4):
            for j in range(4):
                available = list(numbers - set(a[i][:j]) - {a[x][j] for x in range(i)})
                a[i].append(choice(available))
    except:
        failed = True
        
print(a)

Pranav showed one great solution. A naive one (which should work in that case) could be generate any matrix and check if it's correct one.

Simple implementation:

from random import sample

def check(matrix, size=4):
    return check_rows(matrix, size) and check_cols(matrix, size)

def check_rows(matrix, size=4):
    return all(len(set(matrix[i])) == size for i in range(size))

def check_cols(matrix, size=4):
    transposed = [[matrix[j][i] for j in range(size)] for i in range(size)]
    return check_rows(transposed, size)

def generate(size=4):
    return [sample(range(5), size) for _ in range(size)]

while True:
    matrix = generate()
    if check(matrix):
        break

print(matrix)