Wie man mehrere ELIF-Anweisungen in eine Methode umwandelt (PYTHON)

Question

Ich frage mich, wie ich diese elif-Aussagen in eine Art von Methode zusammenfassen kann. Ich weiß auch nicht, wie ich eine gewählte Koordinate speichern soll, damit ich die umliegenden Koordinaten überprüfen kann. Ich weiß, dass mein Code nooby, aber so bin ich, ich lerne besser beginnend mit dem langen Weg :)

Unten ist, wie werde ich über eine in einem variablen Koordinate zu speichern. (Nicht sicher, dass dies auch der richtige Weg, es noch zu tun ...)

grab = board[x][y] 
if(SjumpX == 'A1'): 
    grab = [0][0] 
elif(SjumpX == 'A2'): 
    grab = [0][1]  
elif(SjumpX == 'A3'): 
    grab = [0][2] 
elif(SjumpX == 'A4'): 
    grab = [0][3] 
elif(SjumpX == 'B1'): 
    grab = [1][0] 
elif(SjumpX == 'B2'): 
    grab = [1][1] 
elif(SjumpX == 'B3'): 
    grab = [1][2] 
elif(SjumpX == 'B4'): 
    grab = [1][3] 
elif(SjumpX == 'C1'): 
    grab = [2][0] 
elif(SjumpX == 'C2'): 
    grab = [2][1] 
elif(SjumpX == 'C3'): 
    grab = [2][2] 
elif(SjumpX == 'C4'): 
    grab = [2][3] 

SjumpX die des Stückes koordinieren ist mein Spieler ergreifen will, und DjumpX ist die des Ziel koordinieren. Meine Logik dahinter ist, wenn der Spieler eine Koordinate eingibt (zB A1 B2 C3 ...), kann ich dann diese Koordinate in der Variablen 'greifer' speichern und dann diese Variable verwenden, um zu testen, ob die Zielkoordinate leer ist, auch wenn die Koordinieren Sie zwischen den beiden ist das ein Gegenspielerstück. Hier

ist der Vorstand:

1 2 3 4 
A - X O X 
B X O - O 
C O X O X 

Dies, wo ich überprüfen, ob die „überspringbare“ Zielkoordinaten leer sind, basierend auf den aktuellen Koordinaten meines ‚greifen‘ variabel. In diesem Fall < 'A3' ==> Greifer = [0] [2]

if((grab[x][y-2] == '-' or grab[x][y+2] == '-' or grab[x-2][y] == '-' or grab[x+2][y] == '-')and 
    (grab[x][y-1] == 'X' or grab[x][y+1] == 'X' or grab[x-1][y] == 'X' or grab[x+1][y] == 'X'): 

Meine Hauptfragen sind:

1- Wie kann ich eine riesige elif Anweisungsliste kondensieren?
2- Was ist das korrekte Format/Verfahren zum Speichern einer Koordinate zur Überprüfung des umgebenden Koordinateninhalts?
3- Wie kann ich meine if-Anweisung verdichten, die prüft, ob die Zielkoordinate leer ist ('-').

Answer 1

Wir Karte machen kann dann verwenden wir den Greifer

dh initialisieren kann,

field_map = {'A1':(0,0),'A2':(0,0)......} 
if SjumpX in field_map.keys(): 
    x,y = field_map[SjumpX] 
    grab = [x][y] 

Ich denke, es

Answer 2

hilft Ich habe zwei Vorschläge:

Erste : Behalte eine Adjazenzliste für die oder eine Matrixdarstellung (diese Antwort hängt von deinem Design ab, Ich persönlich mag adjacency besser Listen)

# Adding only some of the values here 
map = {'A1': ['A2','B1'], 'A2': ['A1','A3', 'B2'], 'B1': ['A1','B2','C1']} 
val_map = {'A1': '-', 'B1': 'X'} 
grab = SjumpX 
# You can also get the values by iterating over the list from next statement 
nearby_ele[grab] = map[grab] 

Zweitens: Speichern Sie die Abbildung von row, col in einem dict{'A1': (0,0), 'A2': (0,1)}. Dict ist eine konstante Zeitsuche, und Sie können die Koordinate schnell dazu bringen, Dinge schnell zu machen. Verwenden Sie eine Matrixdarstellung als

map = {'A1': (0,0), 'A2': (0,1), 'A3': (0,2), 'A4': (0,3), 
     'B1': (1,0), 'B2': (1,1), 'B3': (1,2), 'B4': (1,3), 
     'C1': (2,0), 'C2': (2,1), 'C3': (2,2), 'C4': (2,3), 
     } 
val_map = [['-', 'X', 'O', 'X'], ['X', 'O', '-', 'O'],['O','X','O','X']] 
grab = map[SjumpX] 
nearby_ele[grab] = [(grab[0]-1,grab[1]), (grab[0]+1,grab[1]), 
        (grab[0],grab[1]-1), (grab[0],grab[1]+1)] 

Answer 3

Angenommen, Sie würden den Vorstand der Position entsprechend SjumpX Wert greifen wollen, würde das nach einem einfachen Code für die Aufgabe sein.

grab = board[ord(SjumpX[0]) - 65][int(SjumpX[1]) - 1] 

Dies würde bedeuten, die ersten Buchstaben der SjumpX auf seine ASCII Ordinatenwert (A, B, C, ...) und Umwandlung in Zahlen umzuwandeln (65, 66, 67, ...). Da der Versatz 65 ist, sollten Sie die von Ihnen benötigten Zahlen (0, 1, 2, ...) erhalten

Auf der anderen Seite könnten Sie eine direkte Methode wählen, die von @ khachiks Kommentar vorgeschlagen wurde.

grab = board[{'A':0, 'B':1, 'C':2}[SjumpX[0]]][int(SjumpX[1]) - 1] 

Diese direkt zugewiesen (A, B, C) auf (0, 1, 2), obwohl diese Aussage für größere Bretter länger (D, E, und so weiter) wachsen würde.