N-Queens problem

$ python -c 'import q;q.queens(4)'
depth += 1
# Trying to place a queen on rank 1.  Open files on [1, 2, 3, 4].
# Accept square a1.
depth += 1
# Trying to place a queen on rank 2.  Open files on [2, 3, 4].
# a1 attacks b2
# Accept square c2.
depth += 1
# Trying to place a queen on rank 3.  Open files on [2, 4].
# c2 attacks b3
# c2 attacks d3
depth -= 1
# Accept square d2.
depth += 1
# Trying to place a queen on rank 3.  Open files on [2, 3].
# Accept square b3.
depth += 1
# Trying to place a queen on rank 4.  Open files on [3].
# b3 attacks c4
depth -= 1
# a1 attacks c3
depth -= 1
depth -= 1
# Accept square b1.
depth += 1
# Trying to place a queen on rank 2.  Open files on [1, 3, 4].
# b1 attacks a2
# b1 attacks c2
# Accept square d2.
depth += 1
# Trying to place a queen on rank 3.  Open files on [1, 3].
# Accept square a3.
depth += 1
# Trying to place a queen on rank 4.  Open files on [3].
# Accept square c4.
depth += 1
# Solved.  We've placed all 4 queens.
[2, 4, 1, 3]
depth -= 1
depth -= 1
# d2 attacks c3
depth -= 1
depth -= 1
# Accept square c1.
depth += 1
# Trying to place a queen on rank 2.  Open files on [1, 2, 4].
# Accept square a2.
depth += 1
# Trying to place a queen on rank 3.  Open files on [2, 4].
# a2 attacks b3
# Accept square d3.
depth += 1
# Trying to place a queen on rank 4.  Open files on [2].
# Accept square b4.
depth += 1
# Solved.  We've placed all 4 queens.
[3, 1, 4, 2]
depth -= 1
depth -= 1
depth -= 1
# c1 attacks b2
# c1 attacks d2
depth -= 1
# Accept square d1.
depth += 1
# Trying to place a queen on rank 2.  Open files on [1, 2, 3].
# Accept square a2.
depth += 1
# Trying to place a queen on rank 3.  Open files on [2, 3].
# d1 attacks b3
# Accept square c3.
depth += 1
# Trying to place a queen on rank 4.  Open files on [2].
# c3 attacks b4
depth -= 1
depth -= 1
# Accept square b2.
depth += 1
# Trying to place a queen on rank 3.  Open files on [1, 3].
# b2 attacks a3
# b2 attacks c3
depth -= 1
# d1 attacks c2
depth -= 1
depth -= 1

# n queens
# recursion looks like a good choice because
# python saves the backtracking state and the
# stack depth won't be excessive.
# How do you handle solutions that are symmetrically or by rotation the same?

import string

def algebraic(f,r):
    return string.ascii_lowercase[f]+string.digits[r+1]

def adjust(a):
    try:
        return [1+A for A in a]
    except:
        return 1+a

def queens(N,FILES=[]):
    print('depth += 1')
    RANK = len(FILES)
    if N == RANK:
        print("# Solved.  We've placed all %d queens."%N)
        print(adjust(FILES))
    else:
        print('# Trying to place a queen on rank %d.  Open files on %s.'%(adjust(RANK),adjust(set(range(N))-set(FILES))))
        for FILE in set(range(N))-set(FILES):
            for (R,F) in enumerate(FILES):
                if (F==FILE+RANK-R) or (F==FILE-RANK+R):
                    print('# %s attacks %s'%(algebraic(F,R),algebraic(FILE,RANK)))
                    break
            else:
                print('# Accept square %s.'%(algebraic(FILE,RANK)))
                queens(N,FILES+[FILE])
    print('depth -= 1')