J'ai fait Othello pour enseigner Python3 aux enfants (4)

Expliquons le programme du jeu Othello

Comprenons la fonction

Les fonctions sont un élément très important dans un programme. Une fonction est un ensemble d'actions en tant que fonction.

Par exemple, la fonction «manger» comprend les actions suivantes.

1. Mettez dans votre bouche
2. Mâchez
3. Goûter
4. Avalez
5. (Extraordinairement si vous ressentez un danger, crachez-le)

Si vous écrivez cette logique en 5 étapes chaque fois que vous mangez quelque chose, le code sera redondant, et s'il y a une histoire comme "vous devriez vérifier l'odeur" dans la fonction "manger", toute la logique de manger C'est dur parce que je dois le réparer et faire demi-tour. Par conséquent, le même code qui apparaît plusieurs fois est défini comme une ** fonction **, et la partie qui change ce que vous mangez est passée comme une ** variable **.

Pour définir une fonction en Python, écrivez: Si les choses passées en paramètres sont variables, vous aurez une fonction "manger" qui vous permettra de tout manger.

def EatFood(food):

Si vous voulez manger du curry, appelez ʻEatFood ("curry") , et si vous voulez nourrir udon, appelez ʻEatFood (" udon "). Si vous passez la valeur que vous voulez manger entre parenthèses, la fonction qui la reçoit exécutera la fonction et retournera. La valeur à transmettre est appelée ** argument ** et ainsi de suite.

Dans le monde mathématique, une fonction ferait sum (10,20,30) pour exécuter 10 + 20 + 30 et retourner un total de 60, ou ʻaverage (70,70,100) `. Il peut trouver la moyenne de 70, 70, 100 et renvoyer 80 en conséquence. Dans le monde de la programmation, une fonction est aussi un bloc qui organise le traitement, et si vous passez une valeur, elle sera traitée et retournée, ou elle sera retournée après avoir fonctionné en fonction d'une valeur.

Comprenons la classe

Dans le précédent (3), nous avons expliqué les ** variables **. Et dans ce chapitre, nous avons décrit les ** fonctions **. Ensuite, après avoir appris ** class **, je voudrais expliquer la source du jeu Othello. Dans le monde de la programmation, le mot ** classe ** devrait être perceptible. Qu'est-ce qu'une ** classe **?

Dans la ** fonction ** précédente, nous avons illustré une fonction appelée EatFood (). Nous en avons parlé comme des morceaux de fonctionnalités, mais les ** classes ** ressemblent plus à des morceaux de gros morceaux.

Par exemple, disons que vous créez une ** classe ** appelée human.

La classe humaine requiert les éléments suivants:

Si vous classez réellement les humains, ce genre de chose ne suffit pas, mais les éléments qui composent ** humain ** sont appelés ** classe ** comme une masse de ** variables et fonctions **. Je vais. Si vous l'écrivez en Python, cela ressemblera à ceci.

class Human:
    #Variables de classe humaine
    def __init__(self):
        self.sex = None        #Variable de genre
        self.birthday = None   #Anniversaire
        self.tall = None       #la taille
        self.weight = None     #poids
    #parler
    def talk(self, quote):
~~~ logique ~~~
    #dormir
    def sleep(self):
~~~ logique ~~~
    #Se lever
    def wakeup(self):
~~~ logique ~~~

Cette classe humaine est comme un plan qui définit un humain qui n'a pas encore de substance. Lors de la programmation, vous devez utiliser cette classe humaine pour la matérialiser. C'est ce qu'on appelle l'instanciation. Maintenant, matérialisons (instancions) M. Sazae et M. Maso.

Sazae= Human()
Sazae.sex = female
Sazae.tall = 159
Sazae.weight = 48
Sazae.talk("Ngagugu")    #Parlez avec ngagugu

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

En créant de cette manière plusieurs entités avec le même dessin de conception, il devient possible de programmer plus efficacement. Il y a plusieurs avantages à classer. Par exemple, dans le jeu Othello, le jeu Othello lui-même a été classé, mais si vous le faites plus joliment, vous pourrez créer une classe dérivée et créer une classe graphique Othello. Dans le langage de programmation appelé orienté objet, des bibliothèques de différentes classes sont préparées et des classes créées par de grands programmeurs tels que GitHub sont publiées. En utilisant une telle bibliothèque de classes, il est possible de créer efficacement des programmes au lieu de tout créer à partir de zéro.

Expliquons la classe d'Othello (1)

Comme expliqué précédemment, une classe est un plan composé d'un ensemble de ** variables et fonctions **. La classe Othello a été créée en tant que classe pour créer des jeux Othello, mais j'aimerais expliquer quels types de variables et de fonctions il existe.

Le premier est la partie variable. La classe commence la déclaration par class * className *:. La partie où le retrait est abaissé à partir de cette déclaration est tous les éléments inclus dans la classe. Les variables de la classe sont définies dans la fonction d'initialisation def __init __ (self):. (Il y a différentes manières, mais expliquer les différentes manières ne fera que vous embrouiller, donc pour l'instant vous pouvez vous rappeler que les variables de classe sont définies dans la fonction d'initialisation * peut-être)

class OthelloCls:
    def __init__(self):
        self.ot_bit = list()
        #Réglage initial = Placer 4 pièces d'Othello sur le plateau
        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 = '●'                       #Quel tour
        self.ot_search = '○'                       #La main opposée
        #Utilisation d'un dictionnaire pour le calcul du cadre à côté de huit directions
        #Créer une table de calcul (la direction est la clé, la valeur calculée est définie par Tupple)
        self.ot_direction = dict()                  #Tableau de recherche à huit voies
        self.ot_direction = { 'ul' : ( -1 , -1 ) ,  #En diagonale au-dessus à gauche
                              'up' : (  0 , -1 ) ,  #Juste au dessus
                              'ur' : ( +1 , -1 ) ,  #En diagonale au-dessus à droite
                              'lt' : ( -1 ,  0 ) ,  #la gauche
                              'rt' : ( +1 ,  0 ) ,  #droite
                              'dl' : ( -1 , +1 ) ,  #En diagonale en dessous à gauche
                              'dn' : (  0 , +1 ) ,  #Directement en dessous
                              'dr' : ( +1 , +1 ) }  #En diagonale en dessous à droite
        #Poste de terminaison lorsqu'il est jugé qu'il peut être retourné
        self.ot_lastposX = 0                        #Retourner la fin X
        self.ot_lastposY = 0                        #Retourner la fin Y

"Variable de tableau" qui sort immédiatement

Au fait, la variable qui sort immédiatement est un tableau. En python, les tableaux sont définis à l'aide d'une classe appelée list. Ici, les variables sont définies à l'aide de la classe list () pour créer 64 tableaux 8x8, qui est la carte d'Othello. Lors de la conversion de la carte d'Othello en variables, nous utilisons parfois un tableau à deux dimensions, mais je pense qu'il est difficile pour les débutants de comprendre le tableau à deux dimensions, j'ai donc décidé d'utiliser un tableau ordinaire.

Si vous souhaitez remplir la valeur de la variable de liste avec la valeur initiale, vous pouvez l'ajouter avec la fonction append (), mais vous pouvez également l'initialiser en même temps que la définition de variable en écrivant comme suit. (Comme il est un peu long, il est omis)

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

Tableaux autres que des listes

Il existe trois façons de représenter un tableau avec des variables, qui est un dialecte unique à Python. Les variables réinscriptibles sont également appelées ** mutables **, et les variables non réinscriptibles sont également appelées ** immuables **, mais elles sont appelées «réinscriptibles» dans le tableau ci-dessous car elles sont difficiles à comprendre.

La seule différence entre le type de liste et le type de taple est de savoir s'ils peuvent être réécrits ou non, et les autres utilisations sont presque les mêmes. S'il s'agit d'un tableau uniquement référencé, il est recommandé d'utiliser le taple car la vitesse d'accès est plus rapide avec le tapple.

"Phrase répétée avec un nombre fixe de fois" qui apparaît immédiatement

La phrase répétitive susmentionnée apparaît ici. def __init __ (self): contient la définition de la variable et le programme (logique) qui initialise la variable. Cette fois, le nombre de répétitions est fixé à 64, donc en se répétant 64 fois, si la variable i qui stocke le nombre de répétitions pour mettre la trame dans l'état initial est 27 ou 36, remplacez ○ et i vaut 28 Ou, s'il est 35, remplacez ●, sinon remplacez ・. Ce tableau contient tous les éléments du carré 8x8, avec ○ dans la partie où le cadre blanc est placé, ● dans la partie où le cadre noir est placé, et le carré où rien n'est placé. Il est fait par la règle de substitution ・ pour. Pour ajouter une valeur à un tableau, utilisez une fonction appelée append () pour ajouter la valeur au ot_bit instancié par la classe list. N'oubliez pas d'utiliser une fonction appelée append () pour ajouter une valeur à un tableau. Pour voir les valeurs du tableau, vous pouvez faire référence à une cellule avec ot_bit [index]. Vous pouvez également mettre à jour la valeur en la remplaçant par un indice tel que ot_bit [index] = "●". Les fonctions qui suppriment des parties d'un tableau incluent del (), pop () et remove (), mais essayez de trouver un moyen de les utiliser lorsque vous en avez réellement besoin. Je pense que vous pouvez facilement rechercher le mot-clé de recherche avec python list delete.

Variables générales

ʻOt_offdef se voit attribuer le cadre du tour en cours (○ ou ●), et ʻot_search se voit attribuer le cadre qui n'est pas le tour actuel (○ ou ●). ʻOt_lastposX et ʻot_lastposY sont des variables pour se souvenir du dernier endroit à retourner.

À propos des variables de dictionnaire

Eh bien, cette fois, je voudrais terminer en expliquant les variables du dictionnaire. Une variable de dictionnaire est une structure pour avoir un tableau de «clé: valeur». Je n'ai pas eu à en faire une variable de dictionnaire cette fois, mais j'ai utilisé une variable de dictionnaire pour étudier.

Dans Othello, si vous placez une pièce à une coordonnée spécifique (X, Y), vous pourrez peut-être placer votre main dans huit directions.

        self.ot_direction = dict()                  #Tableau de recherche à huit voies
        self.ot_direction = { 'ul' : ( -1 , -1 ) ,  #En diagonale au-dessus à gauche
                              'up' : (  0 , -1 ) ,  #Juste au dessus
                              'ur' : ( +1 , -1 ) ,  #En diagonale au-dessus à droite
                              'lt' : ( -1 ,  0 ) ,  #la gauche
                              'rt' : ( +1 ,  0 ) ,  #droite
                              'dl' : ( -1 , +1 ) ,  #En diagonale en dessous à gauche
                              'dn' : (  0 , +1 ) ,  #Directement en dessous
                              'dr' : ( +1 , +1 ) }  #En diagonale en dessous à droite

Ce tableau est une valeur numérique de la façon dont il se déplace dans huit directions à partir de l'endroit où le cadre est placé. Dans le chapitre précédent, j'ai écrit que "le programme doit être mis sous une forme qui peut être exprimée en mots", mais il est important de le mettre en mots exactement "comment se déplacer quand un cadre est placé". Voir la figure ci-dessous. Si vous mettez un cadre, les humains peuvent comprendre que "Oh, le côté gauche peut être retourné", mais le programme ne peut être visualisé que dans huit directions dans l'ordre. S'il est en diagonale par rapport à la partie supérieure gauche de l'endroit où vous l'avez placé, recherchez un endroit qui est moins 1 dans le sens vertical et moins 1 dans le sens horizontal.

Dans cette figure, X = 6 et Y = 5 sont définis, vous pouvez donc les rechercher comme suit.

1. Avec X = 5 et Y = 4, cherchez une pièce qui peut être retournée.
2. Avec X = 6 et Y = 4, cherchez une pièce qui peut être retournée.
3. Avec X = 7 et Y = 4, cherchez une pièce qui peut être retournée.
4. Avec X = 7 et Y = 5, cherchez une pièce qui peut être retournée.
5. Avec X = 7 et Y = 6, cherchez une pièce qui peut être retournée.
6. Avec X = 6 et Y = 6, cherchez une pièce qui peut être retournée.
7. Avec X = 5 et Y = 6, cherchez une pièce qui peut être retournée.
8. Avec X = 5 et Y = 5, cherchez une pièce qui peut être retournée.

Une variable de dictionnaire appelée ʻot_direction` est un tableau qui montre où chercher à partir des coordonnées que vous avez placées. ul = UpLeft est défini comme (-1, -1), qui est respectivement la direction verticale ou la direction horizontale.

Ce qui précède est l'explication des variables de la classe Othello. Les variables de dictionnaire peuvent être un peu déroutantes, mais j'expliquerai plus tard comment les utiliser dans un programme, donc ce n'est pas grave si vous vous souvenez simplement du tableau clé: valeur ici.

C'est un devoir auquel réfléchir avant de passer à la prochaine fois. Comment le programme devrait-il exprimer "s'il y a un cadre qui peut être retourné"? Par exemple, dans le cas d'un virage noir, j'ai placé des pièces à X = 6 et Y = 5. Comment pensez-vous pouvoir le retourner par programme? Il y a plusieurs façons de le faire, donc si vous pouvez le faire, c'est la bonne réponse. Réfléchissez un instant!

La prochaine fois, j'aimerais expliquer les fonctions de classe d'Othello.

c u

<< J'ai créé un Othello pour enseigner Python3 aux enfants (3) J'ai créé Othello pour enseigner Python3 aux enfants (5) >>