J'ai fait Othello pour enseigner Python3 aux enfants (3)
Vous devriez apprendre en regardant le commentaire tout en déplaçant le programme et en regardant le mouvement
Quoi qu'il en soit, le programme fonctionne et c'est Nambo. Il y a aussi pour effet de favoriser la compréhension en jouant avec, donc aujourd'hui je vais publier la source du jeu d'Othello, même si c'est un peu long. Créons ceci en tant que nouveau projet pour PyCharom.
Démarrez PyCharm et créez un "Nouveau projet" dans le menu Fichier. Nommez également le projet ** Othello **.
Après avoir créé le projet, sélectionnez "Nouveau ..." dans le menu Fichier, sélectionnez le fichier Python, nommez-le othello_cui.py, etc. et appuyez sur Entrée pour trouver othello_cui.py dans le volet de projet de gauche. Apparaîtra.
Ensuite, copiez et collez tous les programmes suivants dans othellocui.py.
Une fois que vous avez fait cela, enregistrez votre projet avec CTRL + S (commande + S pour Mac).
Source du jeu Othello
"""
Othello Game
Copyright 2020 (C) by tsFox
"""
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
#contribution
def ot_inputXY(self,otstr):
while True:
myXY = input(otstr)
if myXY == "":
continue
#J'ai ajouté quelques moyens de vérifier dans la section des commentaires!'20/5/30
if myXY.isdigit() and (1 <= int(myXY) <= 8):
return int(myXY)
print("Bubu ~! Entrez 1-8!")
#C'est ton tour
def ot_yourturn(self):
print("{}C'est ta main!".format(self.ot_offdef))
#C'est ton tour
def ot_changeturn(self):
self.ot_offdef = '●' if self.ot_offdef == '○' else '○'
self.ot_search = '●' if self.ot_offdef == '○' else '○'
#Déterminez si c'est fini (changez le tour si vous ne pouvez tout simplement pas mettre votre main)
def ot_checkendofgame(self):
#Il n'y a pas de place pour mettre votre propre main, et vous ne pouvez pas mettre la main de votre adversaire
if 0 > self.ot_canplacemypeace():
self.ot_changeturn()
if 0 > self.ot_canplacemypeace():
bc = myot.ot_bit.count('●')
wc = myot.ot_bit.count('○')
if ( bc - wc ) > 0:
bws = "● Victoire"
elif ( bc - wc ) < 0:
bws = "○ victoire"
else:
bws = "dessiner"
print("{}est. Je vous remercie pour votre travail acharné!".format(bws))
return 1
else:
print("{}Il n'y a pas de place pour le mettre. Cela change au tour de l'adversaire! !!".format(self.ot_search))
return -1
else:
return 0
#Découvrez s'il y a un endroit pour mettre la main
def ot_canplacemypeace(self):
for n in range(64):
if self.ot_bit[n] != '・':
continue
for d in self.ot_direction:
if 1 == self.ot_next_onepeace(int(n%8)+1,int(n/8)+1, d):
return 0
#S'il n'y a pas de place pour en mettre un, je viendrai ici
return -1
#Mettez votre main sur le plateau d'Othello
def ot_place(self, ot_x, ot_y):
ot_change = False
for d in self.ot_direction:
if 1 == self.ot_next_onepeace(ot_x,ot_y,d):
self.ot_peace(ot_x,ot_y,self.ot_offdef)
self.ot_changepeace(ot_x,ot_y,d)
ot_change = True
#Lorsqu'il n'y a pas de direction valide
if not ot_change:
print("{}Impossible de placer".format(self.ot_offdef))
return -1
#Affichez l'écran et changez votre main au tour de l'adversaire
self.ot_display()
self.ot_changeturn()
return 0
#Traitement pour placer le coup suivant (y compris le traitement qui ne peut pas être placé)
def ot_next_onepeace(self,ot_x,ot_y,ot_dir):
#Lorsque le prochain mouvement dans toutes les directions à partir de votre position est la main opposée et votre propre main
nx = self.ot_direction[ot_dir][0]
ny = self.ot_direction[ot_dir][1]
#Jugement que le coup suivant ne peut pas être placé en premier lieu
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
#Obtenez le suivant (la gauche et le haut sont dans la direction négative lorsqu'ils sont vus de votre main)
nextpeace = self.ot_peace(ot_x+nx,ot_y+ny)
#Jugement que vous ne pouvez pas le mettre si la main suivante est votre propre main
if nextpeace == '・' or nextpeace == self.ot_offdef:
return -1
#Déterminez s'il y a un voisin à côté
cx = ot_x+(nx*2)
cy = ot_y+(ny*2)
#Jugé qu'il ne peut pas être placé s'il n'y a pas de voisin à côté (si la direction est à gauche ou en haut, jugez l'extrémité gauche et le haut)
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
#Je peux avoir le suivant, alors cherche
nextnextpeace = self.ot_peace(cx,cy)
if nextnextpeace == '・' :
return -1 #Je ne peux pas le retourner Notification
if nextnextpeace == self.ot_offdef:
#Enregistrez la position finale qui peut être retournée
self.ot_lastposX = cx
self.ot_lastposY = cy
return 1 #Vous pouvez le retourner Notification
#Si votre main et votre main continuent, appelez à nouveau votre fonction (récursif)
return self.ot_next_onepeace(ot_x+nx, ot_y+ny, ot_dir)
#Le processus de retourner votre main
def ot_changepeace(self,ot_x,ot_y,ot_dir):
#Lorsque le prochain mouvement dans toutes les directions à partir de votre position est la main opposée et votre propre main
nx = self.ot_direction[ot_dir][0]
ny = self.ot_direction[ot_dir][1]
#Réécrivez le suivant
nextpeace = self.ot_peace(ot_x+nx,ot_y+ny,self.ot_offdef)
#À côté des coordonnées suivantes
cx = ot_x+(nx*2)
cy = ot_y+(ny*2)
#Fin si la position de basculement est la dernière coordonnée
if cx == self.ot_lastposX and cy == self.ot_lastposY:
return
#Si vous pouvez toujours le retourner, rappelez-vous (récursif)
return self.ot_changepeace(ot_x+nx, ot_y+ny, ot_dir)
#Obtenez la main à la position spécifiée (et réécrivez-la également)
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)]
#Afficher le plateau d'Othello
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('●')))
if __name__ == '__main__':
myot = OthelloCls()
myot.ot_display()
while True:
#Déterminez si le jeu est terminé ou s'il y a un endroit pour mettre votre main
sts = myot.ot_checkendofgame()
if sts == 1: #Jeu terminé
break
elif sts < 0: #Je ne peux pas mettre ma main
continue
#Montrer quel virage
myot.ot_yourturn()
#Entrez les coordonnées X et Y
myx = myot.ot_inputXY("X = ")
myy = myot.ot_inputXY("Y = ")
#Placez votre main aux coordonnées spécifiées
myot.ot_place(myx,myy)
Jouons une fois! !!
Vous pouvez démarrer le programme en sélectionnant Exécuter othello_cui dans le menu Exécuter de PyCharm ou en appuyant sur le triangle vert bouton Exécuter à l'extrême gauche de ʻif name == '__ main__': ʻ dans la source.
Lorsque le programme exécuté comme celui-ci s'affiche en bas de l'écran PyCharm, entrez X (horizontal) 1 à 8 puis Y (vertical) 1 à 8 pour entrer la famille Essayez de jouer contre quelqu'un à Othello.
- [Attention] Le tableau Othello ne sera pas affiché correctement comme indiqué sur la figure à moins que la police utilisée dans les paramètres d'environnement PyCharm soit une police de largeur uniforme. *
Qu'arrive-t-il à l'écran si je fais quelque chose? Après avoir joué au jeu jusqu'à la fin en observant partout, j'aimerais expliquer en détail le contenu du programme de la prochaine fois.
Étudier Python aujourd'hui = Variables
Dans ce chapitre, nous voulons en savoir plus sur les variables Python.
Que sont les variables? Ce n'est pas un "nombre étrange". Considérez-le comme un conteneur qui stocke les différentes valeurs qui se produisent dans votre programme. Par exemple, lors de la cuisson, les ingrédients sont coupés à l'avance et mis dans un bol, et ce bol joue le même rôle qu'une variable. Pour ceux qui cuisinent, mettez soudainement du sel dans une marmite, ajoutez du sucre, ajoutez de la sauce soja, et une fois dans une tasse à mesurer, mettez une demi-cuillère à café de sel, une cuillère à café de sucre, trois cuillères à soupe de sauce soja, etc. Vous le mettez dedans, le goûtez là, puis vous le mettez dans une casserole. Il ne fait aucun doute que vous pouvez considérer cette tasse de pesée comme une variable.
Pensez aux raisons pour lesquelles vous avez besoin de variables. Si vous pensez à la recette, vous pouvez voir que si c'est un programme qui ne fait que du curry pour 3 personnes, ce que vous mettez est décidé, et le montant est également décidé, n'est-ce pas? Mais que faire si vous vouliez créer un programme de création de curry pour autant de personnes que vous le souhaitez? Tout d'abord, le nombre de personnes change à chaque fois, vous devez donc mettre le nombre de personnes spécifié dans la variable. Étant donné que la quantité d'ingrédients tels que les pommes de terre change également, cela doit également être inclus dans la variable. En réalité, si un programme qui peut faire quelque chose est meilleur qu'un programme qui ne fait que du curry, le nombre de types d'ingrédients, le nombre et la quantité d'assaisonnements à ajouter changeront régulièrement. Comprenez-vous que les variables sont indispensables pour un programme? ??
Aujourd'hui, je voudrais expliquer certaines variables.
Variables générales et opérations
Pour les variables générales, la valeur de la variable est bien entendu réinscriptible.
Si vous faites ʻage = 12`, vous affectez la valeur 12 à la variable nommée age. Si cette personne de 12 ans obtient un an l'année prochaine, elle peut ajouter +1 à la valeur de l'âge en écrivant «âge + = 1». C'est ce qu'on appelle ** l'arithmétique **. Les opérateurs suivants peuvent être utilisés pour calculer. De plus, l'opération a une priorité et, sauf indication contraire entre (), l'opération est exécutée selon l'ordre d'apparition et la priorité assignés à l'opérateur.
| opérateur | sens | Priorité de calcul |
|---|---|---|
| + | Ajouter + | 3 |
| - | Tirer- | 3 |
| * | Appel | 2 |
| / | Diviser | 2 |
| // | Division de la troncature | 2 |
| % | Reste | 2 |
| ** | Puissance | 1 |
Les calculs suivants sont effectués par ordre de priorité à partir de la gauche.
temp = 20 * 3 / 10 + 5 * 3
60 / 10 + 15
6 + 15
21
Vous pouvez également spécifier explicitement la priorité de calcul en ajoutant ().
temp = 20 * 3 / (10 + 5) * 3
60 / 15 * 3
4 * 3
12
Une variable appelée un tableau
Il suffit de mettre une seule valeur dans une variable, mais il y a des moments où vous voulez mettre un grand nombre de valeurs dans une variable. Dans de tels cas, utilisez une variable appelée ** array **. Par exemple, si vous voulez avoir 7 jours de jours en lettres,
WeekDay = [ "Monday" , "Tuesday" , "Wednesday" , "Thursday" , "Friday" , "Saturday" , "Sunday" ]
Lors de l'accès à la valeur d'un tableau, spécifiez une valeur numérique appelée indice ou index, telle que WeekDay [0]. Pour l'index, spécifiez 0 pour accéder à la toute première valeur. C'est comme 0 le lundi, 1 le mardi ...
Les tableaux ont l'idée de tableaux multidimensionnels. Dans l'exemple précédent, il s'agit d'un tableau unidimensionnel contenant 7 chaînes de caractères, mais si vous voulez avoir des données de calendrier, par exemple, vous pouvez créer un tableau avec 31 tableaux et 12 chaînes, donc Calendar [12] [ Vous pouvez également créer un tableau à deux dimensions appelé 31] . C'est aussi une bonne idée d'utiliser un tableau multidimensionnel en fonction du programme à créer, mais s'il est trop multidimensionnel, il sera difficile à comprendre, il est donc préférable de se concentrer sur la capacité de comprendre et d'écrire du code propre. Faisons le.
La prochaine fois, j'aimerais en savoir plus sur Tuple et Dictionary, qui sont uniques à Python, tout en expliquant le programme. Tout d'abord, veuillez jouer avec le jeu Othello! !!
c u
<< J'ai créé un Othello pour enseigner Python3 aux enfants (2) J'ai créé Othello pour enseigner Python3 aux enfants (4) >>
Recommended Posts