Ich habe versucht, Othello dazu zu bringen, Kindern Python3 beizubringen (6) Final

Lassen Sie uns die Othello-Klasse Teil 3 erklären

"Untersuchen Sie den Rahmen neben X und Y, der an die Funktion übergeben wurde, und den Rahmen daneben"

Nun, es mag am schwierigsten sein, aber ich werde es erklären. Die Othello-Klassenfunktion ot_next_onepeace (), die ich erläutern werde, ist eine Funktion mit der Funktion ** "Untersuche den Rahmen neben X und Y, der an die Funktion übergeben wurde, und den Rahmen daneben" **. Dieses Wort ist eine sehr wichtige Funktion. Ich werde es noch einmal sagen. Diese Funktion führt nur ** "Untersuchen Sie den Frame neben X und Y, der an die Funktion übergeben wurde, und den Frame daneben" **. Selbst wenn das Raster der Othello-Karte 100x100 beträgt, wird diese Funktion nur ausgeführt ** "Untersuchen Sie den Rahmen neben X und Y, der an die Funktion übergeben wurde, und den Rahmen daneben" **. ist.

Weil es eine "Funktion ist, die Sie sich selbst nennen (rekursive Funktion)"!

Wenn Sie sich entscheiden, dass Sie ein Stück in nicht geringem Maße platzieren können, müssen Sie alle Richtungen umdrehen, die umgedreht werden können. Ist es zu diesem Zweck möglich, in acht Richtungen umzudrehen? Wie weit kannst du es umdrehen? Du musst darüber nachdenken.

Wenn in dieser Funktion beispielsweise ● an einer bestimmten Koordinate platziert wird, werden die X- und Y-Koordinaten, an denen sie platziert sind, und das Schlüsselzeichen in der Richtung, die Sie überprüfen möchten, als Argumente und ** "des X und Y an die Funktion übergeben. Untersuche den nächsten Frame und den Frame daneben "**. (Es ist hartnäckig!)

Der Schlüssel der Wörterbuchvariablen "ot_direction", die die Koordinaten neben den acht Richtungen darstellt, wird als drittes Argument übergeben. Schlüsselzeichenfolgen wie'ul'and'up '. Das Tupple-Array [0], das dieser Schlüsselzeichenfolge entspricht, enthält eine Zahl, die die Hand neben der X-Koordinate darstellt. Wenn Sie nach links schauen, ist -1 enthalten. Es ist 0, wenn es direkt über oder unter ist, +1, wenn es rechts ist, und so weiter. In ähnlicher Weise enthält das Taple-Array [1] eine Zahl, die die Hand neben der Y-Koordinate darstellt. Speichern Sie dieses Taple-Array [0] in einer Variablen namens nx und das Taple-Array [1] in einer Variablen namens ny. Die Methode für den Zugriff auf das Wörterbucharray lautet "ot_direction [Schlüsselzeichen (drittes Argument)] [Index des Tapple-Arrays]". Vergiss diesen Weg nicht. Wenn es nur einen Wert für den Schlüssel gibt, erfolgt der Zugriff mit derselben Zugriffsmethode wie das eindimensionale Array "ot_direction [Schlüsselzeichen (drittes Argument)]". Dieses Mal handelt es sich um ein Tapple-Array für die Schlüsselzeichenfolge, sodass dieselbe Zugriffsmethode wie für das zweidimensionale Array verwendet wird.

        self.ot_direction = { 'ul' : ( -1 , -1 ) ,  #Diagonal oben links
                              'up' : (  0 , -1 ) ,  #Direkt darüber
                              'ur' : ( +1 , -1 ) ,  #Diagonal oben rechts
                              'lt' : ( -1 ,  0 ) ,  #links
                              'rt' : ( +1 ,  0 ) ,  #richtig
                              'dl' : ( -1 , +1 ) ,  #Diagonal unten links
                              'dn' : (  0 , +1 ) ,  #Direkt darunter
                              'dr' : ( +1 , +1 ) }  #Diagonal unten rechts

Die X-Koordinate "ot_x" und die Y-Koordinate "ot_y", in der der Rahmen platziert ist, werden an das erste und zweite Argument dieser Funktion übergeben. Andererseits wird durch Hinzufügen der folgenden nx und ny der Rahmen in der zu durchsuchenden Richtung bestimmt. Wenn Sie die in diesem Argument übergebene X-Koordinate "ot_x" und neben und neben der Y-Koordinate "ot_y" überprüfen, verschieben Sie sie um eins und rufen Sie Ihre Funktion erneut auf. In der Abbildung sieht es so aus.

1. Überprüfen Sie beim ersten Mal den Frame links von X = 6 und Y = 5 und den Frame links davon. (○ und ○!)
2. Diese Funktion verschiebt die von ot_x und ot_y übergebenen Werte gemäß den Anweisungen der Zahlen im Tapple-Array der Wörterbuchvariablen um eins und ruft erneut eine eigene Funktion auf.
3. Die Argumente der Funktion, die zum zweiten Mal aufgerufen wird, sind X = 5, Y = 5. Überprüfen Sie von dort aus den Rahmen links und den Rahmen links. (Es ist ○ und ○ wieder !!)
4. Wiederum verschiebt diese Funktion die von ot_x und ot_y übergebenen Werte gemäß den Anweisungen der Zahlen im Beispielarray der Wörterbuchvariablen um eins und ruft erneut ihre eigene Funktion auf.
5. Die Argumente der Funktion, die zum dritten Mal aufgerufen wird, sind X = 4, Y = 5. Überprüfen Sie von dort aus den Rahmen links und den Rahmen links. (Es ist ○ und ○ wieder !!)
6. Auch diese Funktion verschiebt die von ot_x und ot_y übergebenen Werte gemäß den Anweisungen der Zahlen im Beispielarray der Wörterbuchvariablen um eins und ruft erneut ihre eigene Funktion auf.
7. Die Argumente der Funktion, die zum 4. Mal aufgerufen wird, sind X = 3 und Y = 5. Überprüfen Sie von dort aus den Rahmen links und den Rahmen links. Da ein mit ○ ● fortlaufender Frame angezeigt wird, speichern Sie die schwarze Position in "ot_lastposX" und "ot_lastposY" als Position, an der Sie sie umdrehen können, und diese Funktion endet.

Selbst wenn der Rahmen links und der Rahmen links davon ○○ sind, wird das Ergebnis der Verschiebung um eins und des weiteren Aufrufs nicht zu ○ ● wie in der folgenden Abbildung gezeigt (○ ・)? (Ende mit ○) wird beurteilt, dass es nicht platziert werden kann, und die Funktion endet.

Was denken Sie? Hast du die rekursive Funktion irgendwie verstanden? Um ehrlich zu sein, gibt es nur 8 Quadrate in vertikaler und horizontaler Richtung, so dass es nicht erforderlich ist, ihn zu einer rekursiven Funktion zu machen. Zusätzlich zu der Tatsache, dass der Code wahrscheinlich redundant ist, kann diese Idee angesichts des Punktes, an dem er angewendet werden kann, etwas schwierig sein. Versucht, eine rekursive Funktion zu verwenden.

Abgesehen davon kann es bei dieser Funktion eine Ameise sein, den Rahmen in der angegebenen Richtung in eine Zeichenfolge zu verwandeln und im regulären Ausdruck mit ^ ○ + ● danach zu suchen und ihn zu ersetzen. Ich habe darüber nachgedacht, aber programmatisch hat es keinen Spaß gemacht, also habe ich es fallen lassen.

    #Verarbeitung, um den nächsten Zug auszuführen (einschließlich Verarbeitung, die nicht platziert werden kann)
    def ot_next_onepeace(self,ot_x,ot_y,ot_dir):
        #Wenn die nächste Bewegung in alle Richtungen von Ihrer Position aus die entgegengesetzte Hand und Ihre eigene Hand ist
        nx = self.ot_direction[ot_dir][0]
        ny = self.ot_direction[ot_dir][1]

        #Beurteilung, dass der nächste Zug nicht an erster Stelle stehen kann
        if ( nx < 0 and ot_x == 1 ) or ( ny < 0 and ot_y == 1 ) or ( nx == 1 and ot_x == 8 ) or ( ny == 1 and ot_y == 8 ):
            return -1

        #Holen Sie sich die nächste (links und oben sind von Ihrer Hand aus gesehen in Minusrichtung)
        nextpeace = self.ot_peace(ot_x+nx,ot_y+ny)

        #Urteil, dass Sie es nicht setzen können, wenn die nächste Hand Ihre eigene Hand ist
        if nextpeace == '・' or nextpeace == self.ot_offdef:
            return -1

        #Stellen Sie fest, ob sich nebenan ein Nachbar befindet
        cx = ot_x+(nx*2)
        cy = ot_y+(ny*2)

        #Beurteilt, dass es nicht platziert werden kann, wenn sich kein Nachbar daneben befindet (wenn die Richtung links oder oben ist, beurteilen Sie das linke Ende und das obere Ende)
        if ( nx < 0 and cx == 0 ) or ( nx > 0 and cx == 9 ) or ( ny < 0 and cy == 0 ) or ( ny > 0 and cy == 9 ):
            return -1

        #Ich kann den nächsten bekommen, also suche danach
        nextnextpeace = self.ot_peace(cx,cy)

        if nextnextpeace == '・' :
            return -1         #Ich kann die Benachrichtigung nicht umdrehen

        if nextnextpeace == self.ot_offdef:
            #Notieren Sie die Endposition, die umgedreht werden kann
            self.ot_lastposX = cx
            self.ot_lastposY = cy
            return 1         #Sie können die Benachrichtigung umdrehen

        #Wenn Ihre Hand und Ihre Hand fortfahren, rufen Sie Ihre Funktion erneut auf (rekursiv)
        return self.ot_next_onepeace(ot_x+nx, ot_y+ny, ot_dir)

Eine Funktion, die nur den Frame eines Gegners in die angegebene Richtung dreht (auch eine rekursive Funktion)

Ja, diese Funktion ist so ziemlich die gleiche wie die vorherige.

Wir versuchen, den Rahmen des Gegners durch Ihren eigenen Rahmen in der im dritten angegebenen Richtung zu ersetzen. Diese Funktion ersetzt jedoch auch nur die Frames neben den als Argumente übergebenen X- und Y-Koordinaten.

Drehen Sie nun eine um und rufen Sie Ihre Funktion erneut auf, indem Sie die von ot_x und ot_y übergebenen Werte gemäß den Anweisungen der Zahlen im Tapple-Array der Wörterbuchvariablen um eins verschieben. Der Prozess endet, wenn die Koordinaten daneben mit ot_lastposX und ot_lastposY übereinstimmen.

    #Der Prozess des Umdrehens Ihrer Hand
    def ot_changepeace(self,ot_x,ot_y,ot_dir):
        #Wenn die nächste Bewegung in alle Richtungen von Ihrer Position aus die entgegengesetzte Hand und Ihre eigene Hand ist
        nx = self.ot_direction[ot_dir][0]
        ny = self.ot_direction[ot_dir][1]
        #Drehen Sie den nächsten um
        nextpeace = self.ot_peace(ot_x+nx,ot_y+ny,self.ot_offdef)

        #Bestimmen Sie, ob der nächste zum nächsten die endgültige Position ist
        cx = ot_x+(nx*2)
        cy = ot_y+(ny*2)

        #Beenden, wenn neben nächster die endgültige Position ist
        if cx == self.ot_lastposX and cy == self.ot_lastposY:
            return
        return self.ot_changepeace(ot_x+nx, ot_y+ny, ot_dir)

Ich werde die letzten beiden Klassenfunktionen erklären und beenden

Obwohl es sich um eine ot_peace () -Funktion handelt, hat diese Funktion zwei Rollen.

1. Gibt den Frame mit den angegebenen Koordinaten als Rückgabewert der Funktion zurück
2. Wenn im dritten Argument ein Frame angegeben wird, wird der Frame mit den angegebenen Koordinaten durch den Argumentframe ersetzt.

Was ich in Python interessant fand, ist, dass Sie Standardwerte für Funktionsargumente angeben und diese Argumente weglassen können. Daher gibt es beim Aufrufen von "ot_peace ()" Fälle, in denen zwei Argumente vorhanden sind, und Fälle, in denen drei Argumente vorhanden sind, und die Verarbeitung ändert sich in Abhängigkeit von den oben genannten Rollen.

Die letzte Othello-Klassenfunktion ist nun die Funktion "ot_display ()", die die Karte anzeigt. Wie eingangs erwähnt, ist diese Funktion für die Anzeige der im ot_bit-Array gespeicherten Daten in 8X8-Quadraten und für die Anzeige der Anzahl von ● und ○ verantwortlich.

   #Holen Sie sich die Hand an die angegebene Position (und schreiben Sie sie auch neu)
    def ot_peace(self,ot_x,ot_y,ot_chr=None):
        if ot_chr != None:
            self.ot_bit[(ot_y - 1) * 8 + (ot_x - 1)] = ot_chr
        return self.ot_bit[(ot_y-1)*8+(ot_x-1)]

    #Zeigen Sie die Tafel von Othello an
    def ot_display(self):
        print("Ｘ① ② ③ ④ ⑤ ⑥ ⑦ ⑧")
        for l in range(1,9):
            print("{}".format(l), end='' )
            for c in range(1,9):
                print(" {}".format(self.ot_bit[(l-1)*8+(c-1)]), end='')
            print()
        print("            ○：{}　●：{}".format(self.ot_bit.count('○'),self.ot_bit.count('●')))

Wie war es? Wird das scheinbar esoterische Programm der Othello-Klasse nicht allmählich bedeutungsvoller? ** Das Gute an diesem Programm ist, dass es vorerst funktioniert **. Der Schritt zur Verbesserung der Programmierung besteht darin, den Quellcode anderer zu lesen und ihn zu ändern, um Elemente hinzuzufügen und damit zu spielen.

Dies ist das Ende der Programmerklärung, aber nach einer Weile werde ich mit PyQt5 ein grafisches Othello-Spiel erstellen und wieder hierher zurückkehren. Bis dahin viel Spaß beim Spielen mit Python! !!

Wir sehen uns wieder! !!

c u

    print("to be continue...")