import itertools
 
#for each item in `seq`, if it equals `value`, replace it with 0.
def blank_all(seq, value):
    return [0 if item == value else item for item in seq]
 
#yields successive sequences such that each sequence has every instance of `value` replaced with zero except for a single instance.
#ex. `blank_all_but_one([1,1,2,1], 1)` yields [1,0,2,0], [0,1,2,0], and [0,0,2,1].
def blank_all_but_one(seq, value):
    for idx, item in enumerate(seq):
        if item == value:
            blanked = blank_all(seq, value)
            blanked[idx] = value
            yield blanked
 
#given a sequence that contains at least one `1` and `-1`, finds all possbile blankings of the sequence that contain at least one `1` and `-1`.
def iter_pairs(seq):
    for a in blank_all_but_one(seq, 1):
        for b in blank_all_but_one(a, -1):
            yield b
 
#flips a matrix so that its rows becomes its columns, and vice versa.
def transposed(matrix):
    return map(list, zip(*matrix))
 
#finds the cartesian product of a generator expression applied to each row of a matrix.
def apply_to_each_row(matrix, func):
    for result in itertools.product(*[list(func(row)) for row in matrix]):
        yield list(result)
 
#same as `apply_to_each_row`, but done in column order instead
def apply_to_each_column(matrix, func):
    for result in apply_to_each_row(transposed(matrix), func):
        yield transposed(result)
 
matrix = [[1,1,-1],
          [1,-1,-1],
          [-1,0,1]]
 
for result in apply_to_each_column(matrix, iter_pairs):
    print result

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