I think the original proposal as well as the answers so far are missing/reproducing what I'd consider as a main default: The proposed solution is much more complicated than the problem would require. We have a specific problem, and its specificities should be 'exploited' in a smart way to provide an elegant, lean solution.
IMHO it is "bloatware" to have so many definitions (list of files, ranks, possible moves...).

The amazon's definition does not require to consider knight moves, it is 100% equivalent to say: it can move like a queen, or go on any other square at distance < 3. This definitely can and should be used if it allows to make the code simple, elegant and/or efficient.

We have two more ingredients: 
* A queen moves along the row or column or diagonal <=> the absolute difference of the row coordinate equals that of the column coordinate.
* The king "shields" us from the amazon if it is exactly in between, i.e., its coordinates are in between our's and the amazon's, and we see both in the same direction, i.e., vectors are colinear, which we can express as ad = bc <=> det [a b; c d] = 0, the rows or columns of the matrix being the directional vectors (delta row, delta col.). 

With that you can translate the problem statement to the following main program which consists in one simple increment statement within a loop over all squares, and a few very simple (one-liner) helper functions:
```
def amazonCheckmate(king: str, amazon: str):
    """Return [c0,c1,c2,c3] where the four components count the number of squares
    on which the black king would be checkmate, in check, stalemate or safe."""
    kc,kr = divmod(int( king ,20)-201, 20) # use base 20, 'a' = digit 10 => col.0,
    ac,ar = divmod(int(amazon,20)-201, 20) #              '1' => row 0.

    def forbidden(r,c): # Forbidden squares: at distance 1 from king.
        return abs(r-kr) < 2 and abs(c-kc) < 2

    def shielded(r,c): # is the enemy king between r,c and ar,ac?
        return (kc-c)*(ar-r)==(kr-r)*(ac-c) and min(c,ac) <= kc <= max(c,ac)\
               and min(r,ar) <= kr <= max(r,ar)
                
    def threatened(r,c): # is square (r,c) threatened by the amazon?
        return (r==ar or c==ac or abs(c-ac)==abs(r-ar)
                or (abs(r-ar) < 3 and abs(c-ac) < 3)) and not shielded(r,c)

    def can_move(r,c): # if black is at r,c, is there a safe square next to it?
        return any(not threatened(rr,cc) and not forbidden(rr,cc)
                   for rr in range(max(r-1,0), min(r+2,8))
                   for cc in range(max(c-1,0), min(c+2,8), 2 if rr == r else 1))
    cnt=[0]*4
    for r in range(7):
        for c in range(7):
            if not forbidden(r,c):
                # 0, 1, 2, 3 <=> checkmate or check only, stalemate or safe
                cnt[ (0 if threatened(r,c) else 2) + can_move(r,c) ] += 1
    return cnt
```