Ich habe Othello dazu gebracht, Kindern Python3 beizubringen (4)

Lassen Sie uns das Programm des Othello-Spiels erklären

Lassen Sie uns die Funktion verstehen

Funktionen sind ein sehr wichtiges Element in einem Programm. Eine Funktion ist eine Reihe von Aktionen als Funktion.

Zum Beispiel enthält die Funktion "essen" die folgenden Aktionen.

1. Stecken Sie in den Mund
2. Kauen
3. Geschmack
4. Schlucken
5. (Außergewöhnlich, wenn Sie Gefahr fühlen, spucken Sie es aus)

Wenn Sie diese 5-Schritt-Logik jedes Mal schreiben, wenn Sie etwas essen, ist der Code redundant, und wenn es eine Geschichte wie "Sie sollten den Geruch überprüfen" in der Funktion "Essen" gibt, die gesamte Esslogik Es ist schwer, weil ich es reparieren und umdrehen muss. Daher wird derselbe Code, der mehrmals vorkommt, als ** Funktion ** definiert, und der Teil, der Ihre Essgewohnheiten ändert, wird als ** Variable ** übergeben.

Um eine Funktion in Python zu definieren, schreiben Sie: Wenn die als Parameter übergebenen Dinge variabel sind, haben Sie eine "Eat" -Funktion, mit der Sie alles essen können.

def EatFood(food):

Rufen Sie "EatFood (" Curry ")" auf, wenn Sie Curry füttern möchten, und "EatFood (" Udon ")", wenn Sie Udon füttern möchten. Wenn Sie den Wert, den Sie essen möchten, in Klammern übergeben, führt die Funktion, die ihn empfängt, die Funktion aus und gibt sie zurück. Der zu übergebende Wert heißt ** Argument ** und so weiter.

Wenn Sie in der mathematischen Welt "Summe (10,20,30)" ausführen, können Sie 10 + 20 + 30 ausführen und 60 als Gesamtwert zurückgeben, oder wenn Sie "Durchschnitt (70,70,100)" ausführen, Es kann den Durchschnitt von 70, 70, 100 finden und als Ergebnis 80 zurückgeben. In der Welt der Programmierung ist eine Funktion auch ein Block, der die Verarbeitung organisiert. Wenn Sie einen Wert übergeben, wird dieser verarbeitet und zurückgegeben, oder er wird nach dem Betrieb basierend auf einem bestimmten Wert zurückgegeben.

Lassen Sie uns die Klasse verstehen

In der vorherigen (3) haben wir ** Variablen ** erklärt. Und in diesem Kapitel haben wir ** Funktionen ** beschrieben. Nachdem ich etwas über ** Klasse ** gelernt habe, möchte ich als nächstes die Quelle des Othello-Spiels erklären. In der Welt der Programmierung sollte das Wort ** Klasse ** auffallen. Was ist eine ** Klasse **?

In der vorherigen ** Funktion ** haben wir eine Funktion namens EatFood () dargestellt. Wir haben diese als Funktionsblöcke bezeichnet, aber ** Klassen ** ähneln eher Blöcken größerer Blöcke.

Angenommen, Sie erstellen eine ** Klasse ** mit dem Namen "Mensch".

Die menschliche Klasse benötigt die folgenden Elemente:

Wenn Sie tatsächlich Menschen klassifizieren, reicht dies nicht aus, aber die Elemente, aus denen ** Mensch ** besteht, werden als ** Klasse ** als Masse von ** Variablen und Funktionen ** bezeichnet. Ich werde. Wenn Sie es in Python schreiben, sieht es so aus.

class Human:
    #Menschliche Klassenvariablen
    def __init__(self):
        self.sex = None        #Geschlechtsvariable
        self.birthday = None   #Geburtstag
        self.tall = None       #Höhe
        self.weight = None     #Körpergewicht
    #sprechen
    def talk(self, quote):
~~~ Logik ~~~
    #schlafen
    def sleep(self):
~~~ Logik ~~~
    #Aufstehen
    def wakeup(self):
~~~ Logik ~~~

Diese menschliche Klasse ist wie eine Blaupause, die einen Menschen definiert, der noch keine Substanz hat. Wenn Sie tatsächlich programmieren, müssen Sie diese Human-Klasse verwenden, um sie zu materialisieren. Dies nennt man Instanziierung. Lassen Sie uns nun Mr. Sazae und Mr. Maso materialisieren (instanziieren).

Sazae= Human()
Sazae.sex = female
Sazae.tall = 159
Sazae.weight = 48
Sazae.talk("Ngagugu")    #Sprich mit Ngagugu

Herr Maso= Human()
Herr Maso.sex = male
Herr Maso.tall = 173
Herr Maso.weight = 70
Herr Maso.talk("Ja? ??")    # Ja? ?? としゃべる

Durch das Erstellen mehrerer Objekte mit derselben Konstruktionszeichnung auf diese Weise wird es möglich, effizienter zu programmieren. Es gibt verschiedene Vorteile der Klassifizierung. Im Othello-Spiel wurde beispielsweise das Othello-Spiel selbst klassifiziert. Wenn Sie es jedoch schöner gestalten, können Sie eine abgeleitete Klasse und eine grafische Othello-Klasse erstellen. In der Programmiersprache Objektorientiert werden Bibliotheken verschiedener Klassen vorbereitet und Klassen veröffentlicht, die von großen Programmierern wie GitHub erstellt wurden. Durch die Verwendung einer solchen Klassenbibliothek ist es möglich, Programme effizient zu erstellen, anstatt alles von Grund auf neu zu erstellen.

Lassen Sie uns die Othello-Klasse erklären (1)

Wie bereits erläutert, ist eine Klasse eine Blaupause, die aus einer Reihe von ** Variablen und Funktionen ** besteht. Die Othello-Klasse wurde als Klasse zum Erstellen von Othello-Spielen erstellt, aber ich möchte erklären, welche Variablen und Funktionen es gibt.

Erstens ist der variable Teil. Die Klasse startet die Deklaration mit class * className *:. Der Teil, in dem der Einzug aus dieser Deklaration herabgesetzt wird, sind alle in der Klasse enthaltenen Elemente. Die Variablen der Klasse werden in der Initialisierungsfunktion def __init __ (self): definiert. (Es gibt verschiedene Möglichkeiten, aber das Erklären der verschiedenen Möglichkeiten wird Sie nur verwirren, sodass Sie sich vorerst daran erinnern können, dass Klassenvariablen in der Initialisierungsfunktion definiert sind * möglicherweise)

class OthelloCls:
    def __init__(self):
        self.ot_bit = list()
        #Grundeinstellung = 4 Othello-Stücke auf das Brett legen
        for i in range(64):
            if i == 27 or i == 36:
                self.ot_bit.append('○')
            elif i == 28 or i == 35:
                self.ot_bit.append('●')
            else:
                self.ot_bit.append('・')
        self.ot_offdef = '●'                       #Welche Wendung
        self.ot_search = '○'                       #Die andere Hand
        #Verwenden eines Wörterbuchs zur Rahmenberechnung neben acht Richtungen
        #Erstellen Sie eine Berechnungstabelle (Richtung ist Schlüssel, berechneter Wert wird von Tupple definiert)
        self.ot_direction = dict()                  #Acht-Wege-Suchtabelle
        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
        #Kündigungsposition, wenn beurteilt wird, dass sie umgedreht werden kann
        self.ot_lastposX = 0                        #Ende X umdrehen
        self.ot_lastposY = 0                        #Ende Y umdrehen

"Array-Variable", die sofort herauskommt

Die Variable, die sofort herauskommt, ist übrigens ein Array. In Python werden Arrays mithilfe einer Klasse namens list definiert. Hier werden Variablen mithilfe der list () -Klasse definiert, um 64 8x8-Arrays zu erstellen. Dies ist das Board von Othello. Wenn wir die Karte von Othello in Variablen konvertieren, verwenden wir manchmal ein zweidimensionales Array, aber ich denke, dass es für Anfänger schwierig ist, das zweidimensionale Array zu verstehen, deshalb habe ich mich für ein gewöhnliches Array entschieden.

Wenn Sie den Wert der Listenvariablen mit dem Anfangswert füllen möchten, können Sie ihn mit der Funktion append () hinzufügen, aber Sie können ihn auch gleichzeitig mit der Variablendefinition initialisieren, indem Sie wie folgt schreiben. (Da es etwas lang ist, wird es weggelassen)

ot_bit = [ '・' , '・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' , \
'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' ,'・' , \
'○' , '●' , '・' ,'・' ,'・' ,'・' ,'・' ,'・' ]

Andere Arrays als Listen

Es gibt drei Möglichkeiten, ein Array mit Variablen darzustellen. Dies ist ein für Python einzigartiger Dialekt. Umschreibbare Variablen werden auch als ** veränderbar ** bezeichnet, und nicht umschreibbare Variablen werden auch als ** unveränderlich ** bezeichnet. In der folgenden Tabelle werden sie jedoch als "umschreibbar" bezeichnet, da sie schwer zu verstehen sind.

Der einzige Unterschied zwischen dem Listentyp und dem Taple-Typ besteht darin, ob sie umgeschrieben werden können oder nicht, und die anderen Verwendungen sind fast gleich. Wenn es sich um ein Array handelt, auf das nur verwiesen wird, wird empfohlen, den Taple zu verwenden, da die Zugriffsgeschwindigkeit mit dem Tapple schneller ist.

"Wiederholter Satz mit einer festgelegten Anzahl von Malen", der sofort angezeigt wird

Der oben erwähnte Wiederholungssatz erscheint hier. def __init __ (self): enthält die Definition der Variablen und das Programm (Logik), das die Variable initialisiert. Dieses Mal ist die Anzahl der Wiederholungen auf 64 festgelegt. Wenn also die Variable i, die die Anzahl der Wiederholungen speichert, um den Rahmen in den Anfangszustand zu versetzen, bei 64-maliger Wiederholung 27 oder 36 beträgt, ersetzen Sie ○ und i ist 28. Oder, wenn es 35 ist, ersetzen Sie ●, andernfalls ersetzen Sie ・. Dieses Array enthält alle Elemente des 8x8-Quadrats, wobei ○ in dem Teil, in dem der weiße Rahmen platziert ist, ● in dem Teil, in dem der schwarze Rahmen platziert ist, und dem Quadrat, in dem nichts platziert ist. Es wird durch die Regel des Ersetzens von ・ für gemacht. Um einem Array einen Wert hinzuzufügen, verwenden Sie eine Funktion namens append (), um den Wert zu dem von der Listenklasse instanziierten ot_bit hinzuzufügen. Denken Sie daran, eine Funktion namens append () zu verwenden, um einem Array einen Wert hinzuzufügen. Um die Werte im Array anzuzeigen, können Sie mit ot_bit [index] auf eine Zelle verweisen. Sie können den Wert auch aktualisieren, indem Sie ihn durch einen Index wie ot_bit [index] = "●" ersetzen. Zu den Funktionen, mit denen Teile eines Arrays entfernt werden, gehören del (), pop () und remove (). Versuchen Sie jedoch, eine Möglichkeit zu finden, sie zu verwenden, wenn Sie sie tatsächlich benötigen. Ich denke, Sie können mit "Python List Delete" leicht nach dem Suchwort suchen.

Allgemeine Variablen

ot_offdef wird der Rahmen der aktuellen Runde zugewiesen (○ oder ●), und ot_search wird der Rahmen zugewiesen, der nicht die aktuelle Runde ist (○ oder ●). ot_lastposX und ot_lastposY sind Variablen, die sich an den letzten Ort erinnern, an dem gespiegelt werden soll.

Informationen zu Wörterbuchvariablen

Nun, diesmal möchte ich zum Schluss die Wörterbuchvariablen erklären. Eine Wörterbuchvariable ist eine Struktur für ein Array von "key: value". Diesmal musste ich es nicht zu einer Wörterbuchvariablen machen, aber ich habe eine Wörterbuchvariable zum Lernen verwendet.

Wenn Sie in Othello ein Stück an einer bestimmten (X, Y) Koordinate platzieren, können Sie Ihre Hand möglicherweise in acht Richtungen platzieren.

        self.ot_direction = dict()                  #Acht-Wege-Suchtabelle
        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

Diese Tabelle ist ein numerischer Wert dafür, wie sie sich von der Stelle, an der der Rahmen platziert ist, in acht Richtungen bewegt. Im vorigen Kapitel habe ich geschrieben, dass "das Programm in eine Form gebracht werden sollte, die in Worten ausgedrückt werden kann", aber es ist wichtig, es genau in Worte zu fassen, "wie man sich bewegt, wenn ein Rahmen platziert wird". Siehe die Abbildung unten. Wenn Sie einen Frame einfügen, können die Menschen verstehen, dass "Oh, die linke Seite kann umgedreht werden", aber das Programm kann nur in acht Richtungen der Reihe nach angezeigt werden. Wenn es von der Stelle, an der Sie es platziert haben, diagonal nach links oben liegt, suchen Sie nach einer Stelle, die in vertikaler Richtung minus 1 und in horizontaler Richtung minus 1 ist.

In dieser Abbildung sind X = 6 und Y = 5 festgelegt, sodass Sie wie folgt nach ihnen suchen können.

1. Suchen Sie mit X = 5 und Y = 4 nach einem Stück, das umgedreht werden kann.
2. Suchen Sie mit X = 6 und Y = 4 nach einem Stück, das umgedreht werden kann.
3. Suchen Sie mit X = 7 und Y = 4 nach einem Stück, das umgedreht werden kann.
4. Suchen Sie mit X = 7 und Y = 5 nach einem Stück, das umgedreht werden kann.
5. Suchen Sie mit X = 7 und Y = 6 nach einem Stück, das umgedreht werden kann.
6. Suchen Sie mit X = 6 und Y = 6 nach einem Stück, das umgedreht werden kann.
7. Suchen Sie mit X = 5 und Y = 6 nach einem Stück, das umgedreht werden kann.
8. Suchen Sie mit X = 5 und Y = 5 nach einem Stück, das umgedreht werden kann.

Eine Wörterbuchvariable mit dem Namen "ot_direction" ist eine Tabelle, die zeigt, wo Sie anhand der von Ihnen platzierten Koordinaten suchen müssen. ul = UpLeft ist definiert als (-1, -1), ein Taple-Typ, der entweder in vertikaler oder horizontaler Richtung betrachtet werden kann.

Das Obige ist die Erklärung der Variablen in der Othello-Klasse. Wörterbuchvariablen können etwas verwirrend sein, aber ich werde später erklären, wie sie in einem Programm verwendet werden. Es ist also in Ordnung, wenn Sie sich hier nur an das Array key: value erinnern.

Dies ist eine Hausaufgabe, über die Sie nachdenken sollten, bevor Sie zum nächsten Mal gehen. Wie soll das Programm ausdrücken, "ob es einen Rahmen gibt, der umgedreht werden kann"? Zum Beispiel habe ich im Fall einer schwarzen Kurve Teile bei X = 6 und Y = 5 platziert. Wie denken Sie darüber nach, ob Sie es programmgesteuert umdrehen können? Es gibt viele Möglichkeiten, dies zu tun. Wenn Sie es also können, ist das die richtige Antwort. Denken Sie einen Moment nach!

Das nächste Mal möchte ich die Funktionen der Othello-Klasse erläutern.

c u

<< Ich habe ein Othello erstellt, um Kindern Python3 beizubringen (3) Ich habe Othello dazu gebracht, Kindern Python3 beizubringen (5) >>