[RUBY] [Version Python] Pourquoi ne pouvez-vous pas faire de développement orienté objet avec Java?

Aperçu

J'ai acheté "Pourquoi ne pouvez-vous pas faire de développement orienté objet avec Java" pour un réapprentissage orienté objet, mais uniquement avec Java / Ruby [exemple officiel](http://gihyo.jp/book/2005/4- 7741-2222-X / support) n'était pas là, donc je l'ai créé en Python. (Veuillez l'utiliser comme référence uniquement. Je suis également un débutant.)

Jusqu'à la leçon 5 (programme Janken)

Progression globale du traitement

object_janken.py


from judge import *
from player import *
from tactics import *

#Génération d'instance d'arbitre (M. Saito)
saito = Judge()

#Génération du joueur 1 (M. Murata)
murata_tactics = RandomTactics()
murata = Player("M. Murata",murata_tactics)

#Génération du joueur 2 (M. Yamada)
yamada_tactics = StoneOnlyTactics()
yamada = Player("M. Yamada",yamada_tactics)
# yamada = Player_STONE("M. Yamada")

#Commencez Janken avec M. Murata et M. Yamada comme joueurs
saito.start_janken(murata, yamada)

Classe de joueur

player.py


class Player:

    #Constante représentant la main de Janken
    STONE = 0  #Goo
    SCISSORS = 1  #Choki
    PAPER = 2  #Par

    def __init__(self, name, tactics):
        self.name = name
        self.win_count = 0
        self.tactics = tactics

    #Éteignez la main de Janken.
    def show_hand(self):
        hand = self.tactics.read_tactics()
        return hand

    #Écoutez la victoire ou la défaite de l'arbitre. S'il gagne, le résultat de l'argument est vrai
    def notify_result(self,result):
        if (result):
            self.win_count += 1

    #Répondez au nombre de fois que vous avez gagné.
    def get_win_count(self):
        return self.win_count

    #Répondez à votre nom.
    def get_name(self):
        return self.name

#Hériter de la création de classe enfant
class Player_STONE(Player):
    def show_hand(self):
        return self.STONE

Classe de juge

judge.py


class Judge:

    #Démarrez Janken.
    def start_janken(self, player1, player2):
        #Déclarer le début de Janken
        print("[Démarrage de Janken]\n")

        #Jouez à Janken 3 fois
        for cnt in range(3):
            #Montre combien de tours
            print("【", (cnt + 1), "Rond]")

            #Regardez la main du joueur pour déterminer laquelle gagne.
            winner = self.judge_janken(player1, player2)

            if (winner != None):
                #Gagnant du spectacle
                print("\n", winner.get_name(), "A gagné!\n")
                #Communiquez les résultats aux joueurs gagnants
                winner.notify_result(True)
            else:
                #En cas d'égalité
                print("\n C'est un tirage au sort!\n")

        #Déclarez la fin de Janken
        print("[Fin de Janken]\n")

        #Déterminez le vainqueur final
        final_winner = self.judge_final_winner(player1, player2)
        print(player1.get_win_count(), "contre", player2.get_win_count(), "alors")
        if (final_winner != None):
            print(final_winner.get_name(), "Est le gagnant!\n")
        else:
            print("C'est un tirage au sort!\n")

    #Regardez la main du joueur pour déterminer laquelle gagne.
    def judge_janken(self,player1, player2):
        winner = None

        hand_dict = {0: "STONE",
                     1: "SCISSORS",
                     2: "PAPER"}

        #Sortez la main du joueur
        player1hand = player1.show_hand()
        player2hand = player2.show_hand()
        player1hand_name = hand_dict[player1hand]
        player2hand_name = hand_dict[player2hand]

        #Montrez chaque main
        print(f"{player1hand_name} vs. {player2hand_name} \n")

        #Quand le joueur 1 gagne
        if (player1hand_name == "STONE" and player2hand_name == "SCISSORS") or \
            (player1hand_name == "SCISSORS" and player2hand_name == "PAPER") or \
            (player1hand_name == "PAPER" and player2hand_name == "STONE") :
            winner = player1

        #Quand le joueur 2 gagne
        if (player1hand_name == "STONE" and player2hand_name == "PAPER") or \
            (player1hand_name == "SCISSORS" and player2hand_name == "STONE") or \
            (player1hand_name == "PAPER" and player2hand_name == "SCISSORS") :
            winner = player2

        #Dessiner si ni l'un ni l'autre(Renvoie nul)
        return winner

    #Déterminez le vainqueur final.
    def judge_final_winner(self,player1, player2):
        final_winner = None

        #Écoutez le nombre de victoires
        player1_win_count = player1.get_win_count()
        player2_win_count = player2.get_win_count()

        #Déterminez le gagnant
        if (player1_win_count > player2_win_count):
            final_winner = player1
        elif(player1_win_count < player2_win_count):
            final_winner = player2
        else:
            final_winner = None

        return final_winner

Classe de stratégie

tactics.py


class RandomTactics():

    def read_tactics(self):

        # 0.0 ou plus 3.Obtenez des nombres aléatoires sous forme de fractions inférieures à 0
        random_num = rm.random()* 3.0
        if (random_num < 1.0):
          hand = Player.STONE
        elif (random_num < 2.0):
          hand = Player.SCISSORS
        elif (random_num < 3.0):
          hand = Player.PAPER

        #Renvoie la main déterminée comme valeur de retour
        return hand


#==J'adore Goo! »Classe de stratégie.
class StoneOnlyTactics():

  def read_tactics(self):
    #Assurez-vous de sortir un goo
    return Player.STONE

Leçon 6 (programme de suppression de Bubba)

Classe de carte

card.py



class Card():

    #Une constante représentant un joker
    JOKER = 0
    #Constante représentant la bêche
    SUIT_SPADE = 1
    #Constante représentant un diamant
    SUIT_DIAMOND = 2
    #Constante représentant le club
    SUIT_CLUB = 3
    #Constante représentant le cœur
    SUIT_HEART = 4

    def __init__(self,suit,number):
        self.suit = suit
        self.number = number

    def getNumber(self):
        return self.number

    #Remplacer la fonction toString
    def toString(self):

        #Dans le cas de JOKER
        if self.suit == 0:
            card_code = "JK"

        #Cartes autres que JOKER
        else:
            suit_dict = {"SUIT_SPADE":"S", "SUIT_DIAMOND":"D",
                         "SUIT_CLUB":"C","SUIT_HEART":"H"}
            number_dict = {1:"A", 2:"2", 3:"3", 4:"4", 5:"5",
                           6:"6", 7:"7", 8:"8", 9:"9", 10:"T", 11:"J", 12:"Q", 13:"K"}
            card_code = suit_dict[self.suit] + number_dict[self.number]

        return card_code

Classe de main

hand.py



import random as rm

class Hand():

    #Conservez la classe de cartes sous forme de liste
    def __init__(self,list):
        self.hand = list

    #Ajouter une carte
    def add_card(self,card):
        self.hand.append(card)

    #Piochez une carte (en haut)
    def pick_card(self):
        picked_card = self.hand.pop(0)
        return picked_card

    #Rendre le nombre de biens
    def getNumberOfCard(self):
        return len(self.hand)

    #Mélangez votre main
    def shuffle(self):
        #Retirez les cartes au hasard et répétez le dernier ajout
        number = self.getNumberOfCard()
        for i in range(number):
            pos = int(rm.random() * number)
            picked_card = self.hand.pop(pos)
            self.hand.append(picked_card)

    #Trouvez le même nombre de cartes et remettez-les dans le tableau
    def find_same_number_card(self):

        same_cards = None

        #Obtenez le numéro de la dernière carte ajoutée
        last_added_card = self.hand[-1]
        last_added_card_num = last_added_card.number

        for index in range(len(self.hand)-1):

            card = self.hand[index]
            if card.number == last_added_card_num:

                #Si la même carte que la dernière carte ajoutée est trouvée
                #Stockez la combinaison trouvée dans sameCards et quittez la boucle
                same_cards = [self.hand.pop(-1),self.hand.pop(index)]
                break

        return same_cards

    #Exprimez les cartes de votre main sous forme de chaîne de caractères.
    def toString(self):
        hand_cards = ""
        for card in self.hand:
            hand_cards += card.toString() + " "
        return hand_cards

Classe de table

table.py


class Table():

    def __init__(self):
        self.disposed_cards = []

    #Jetez la carte.
    def dispose_card(self,dispose_list):
        for card in dispose_list:
            print(f"{card.toString()}Abandonné")
            self.disposed_cards.append(card)

    #Exprimez la carte abandonnée sous forme de chaîne de caractères.
    def toString(self):
        disposed_cards = ""
        for card in self.disposed_cards:
            disposed_cards += card.toString() + " "
        return disposed_cards

Classe de joueur

player.py



class Player():

    def __init__(self,name,hand,master,table):
        self.hand = hand
        self.name = name
        self.master = master
        self.table = table

    #Désignez votre tour (votre tour)
    def play(self,next_player):

        #Demandez au joueur suivant de retirer sa main
        next_hand = next_player.show_hand()

        #Piochez une carte de la main de votre adversaire
        picked_card = next_hand.pick_card()

        #Afficher le résultat de la soustraction
        print(self.name, ":", next_player.name, "De", picked_card.toString(),"J'ai tiré\n")

        #Ajoutez les cartes piochées à votre main et défaussez le même nombre de cartes
        self.deal_card(picked_card)

        #Découvrez si votre main est nulle
        if self.hand.getNumberOfCard() == 0:
            #Déclarez la montée au facilitateur
            self.master.declare_win(self)
        else:
            #Montrez votre main actuelle
            print(self.name, ": La main restante",self.hand.getNumberOfCard(), "est\n")

    #Mélangez votre main pour montrer
    def show_hand(self):
        if self.hand.getNumberOfCard() == 1:
            self.master.declare_win(self)
        self.hand.shuffle()
        return self.hand

    #Recevoir la carte
    def receive_card(self,card):
        self.deal_card(card)

    #Si vous avez la même carte, jetez-la
    def deal_card(self,card):

        #Ajoutez une carte à votre main
        self.hand.add_card(card)

        #Trouvez la même carte que vous venez d'ajouter
        same_cards = self.hand.find_same_number_card()

        #Si la même combinaison de cartes existe
        if (same_cards != None):
            #Jeter la carte sur la table
            self.table.dispose_card(same_cards)

    #Renvoie le nom du joueur
    def toString(self):
        return self.name

Cours de maître

master.py



class Master():

    def __init__(self,player_list):
        self.player_list = player_list

    def prepare_game(self,hand):
        print("[Distribuer les cartes]\n")

        #Mélanger les cartes à jouer
        hand.shuffle()

        #Obtenez le nombre de cartes à jouer
        number_of_cards = hand.getNumberOfCard()

        #Obtenez le nombre de joueurs
        number_of_players = len(self.player_list)

        for index in range(number_of_cards):

            #Tirez-en un sur la carte
            card = hand.pick_card()

            #Distribuez les cartes à chaque joueur à tour de rôle
            player = self.player_list[index % number_of_players]
            player.receive_card(card)


    #Commencer le jeu.
    def start_game(self):
        print("\n [Commencer à retirer le molleton]\n")

        #Obtenez le nombre de joueurs
        count = 0
        while len(self.player_list) > 1:
            player_index = count % len(self.player_list)
            next_player_index = (count + 1) % len(self.player_list)

            #Acquérir un joueur désigné
            player = self.player_list[player_index]
            #Obtenez le prochain joueur
            next_player = self.player_list[next_player_index]

            #Nommer un joueur
            print("\n", player.name, "C'est ton tour--- ({})".format(count), "\n")
            player.play(next_player)
            count += 1

        #Quittez la boucle lorsque le lecteur monte et qu'il n'en reste qu'un
        print("[Terminé la suppression]\n")


    #Déclarez la montée.
    def declare_win(self,winner):
        #Joueur qui est monté
        print(winner.name, "Je me suis levé!\n")

        #Retirer le joueur soulevé de la liste
        self.player_list.remove(winner)

        #Afficher le perdant lorsqu'il ne reste qu'un seul joueur
        if len(self.player_list) == 1:
            loser = self.player_list[0]
            print(loser.name, "Est vaincu!\n")


    #Enregistrez les joueurs qui participeront au jeu.
    def register_player(self,player):
        self.player_list.append(player)

Programme d'exécution

old_maid.py



from card import *
from hand import *
from master import *
from player import *
from table import *

#Un programme ridicule.


#Générez 53 cartes à jouer.
def create_trump():
    trump = Hand([])

    #Génère 13 cartes pour chaque suie
    for i in range(13):
        number = i + 1
        trump.add_card(Card("SUIT_CLUB", number))
        trump.add_card(Card("SUIT_DIAMOND", number))
        trump.add_card(Card("SUIT_HEART", number))
        trump.add_card(Card("SUIT_SPADE", number))

    #Créer un joker
    trump.add_card(Card(0, 0))

    return trump

#Générer des facilitateurs
master = Master([])

#Génération de champ
field = Table()

#Génération de joueurs
murata = Player("Murata", Hand([]), master, field)
yamada = Player("Yamada", Hand([]), master, field)
saito = Player("Saito", Hand([]),master, field)

#Enregistrer le joueur comme facilitateur
master.register_player(murata)
master.register_player(yamada)
master.register_player(saito)

#Générer des cartes à jouer
trump = create_trump()

#Préparez-vous pour le jeu
master.prepare_game(trump)

#Commencer le jeu
master.start_game()

Frameworkisation (7 lignes)

・ Comme il a été ignoré, il est omis. Il y a deux points à prendre en compte:

Classe abstraite

-Lors de la création d'une classe abstraite avec python, il est nécessaire d'importer ABC (Abstract Base Classes) et d'hériter de la classe abstraite. → Référence: ABC in Python-Abstract Classes and Duck Typing

Passer par valeur

· Doit être passé par valeur lorsque la classe de table renvoie des informations de table

table.py


class FantanTable(Table):

    #Table créée avec numpy
    matrix = np.full((4,13),"..")

    def getCard(self):
        return self.matrix.copy()

Recommended Posts

[Version Python] Pourquoi ne pouvez-vous pas faire de développement orienté objet avec Java?
Pourquoi ne puis-je pas installer matplotlib avec python! !!
Que faire si vous ne pouvez pas utiliser la recherche de grille de sklearn en Python
Pourquoi vous êtes intéressé par le contrôle moteur en Python
Développement de framework avec Python
Environnement de développement en Python
Développement Slackbot en Python
% Et str.format () en Python. Lequel utilisez-vous?
Si vous écrivez TinderBot en Python, elle peut le faire
Développement Python avec Visual Studio 2017
Que faire si vous ne pouvez pas vous connecter en tant que root
Développement Python avec Visual Studio
Que faire si vous ne pouvez pas installer pyaudio avec pip #Python
Que faire si vous obtenez moins zéro en Python
Que faire si vous ne pouvez pas utiliser la poubelle dans Lubuntu 18.04.
[Swift / Ruby / Python / Java] Programmation orientée objet
[Python] Comment faire PCA avec Python
Avez-vous besoin de Python re.compile?
Jusqu'à ce que vous mettiez Python dans Docker
Carte auto-organisée dans la version Python NumPy
Scikit-learn ne peut pas être installé en Python
Python | Ce que vous pouvez faire avec Python
Faites quelque chose orienté objet dans le langage GO
Combien de types de Python avez-vous dans votre Windows 10? J'avais 5 types.
Que faire si PDO n'est pas trouvé dans Laravel ou CakePHP
Python - Comment diviser une liste en morceaux de taille égale en Python?
Que faire si vous ne pouvez pas installer avec pip dans l'environnement babun
Que se passe-t-il si vous "importez A, B comme C" en Python?
Faites une visite Euler non récursive en Python
Comment faire R chartr () en Python
Rendement Python express en JavaScript ou Java
Différences entre la syntaxe Python et Java
Je ne peux pas déboguer les scripts python dans Eclipse
Comment vérifier la version d'opencv avec python
Empêcher le double lancement en Python (version améliorée)
[Principes de base de Python] Pourquoi __name__ == "__main__"
Faites quelque chose comme les transactions Redis en Python
Même si le langage de développement est changé en python3 dans Cloud9, la version 2 est affichée en python --version
Vous devenez ingénieur en 100 jours - Jour 35 - Python - Ce que vous pouvez faire avec Python
Que faire si vous obtenez «Python non configuré». Utilisation de PyDev dans Eclipse
[Version débutant / enregistrée] Ce que vous pouvez faire avec le langage de programmation (12 sélections telles que Ruby / Python / Java / Swift / PHP / Go)