[Python-Version] Warum können Sie mit Java keine objektorientierte Entwicklung durchführen?

Überblick

Ich habe "Warum kann man mit Java keine objektorientierte Entwicklung durchführen" für objektorientiertes Umlernen gekauft, aber nur mit Java / Ruby [Offizielles Beispiel](http://gihyo.jp/book/2005/4- 7741-2222-X / support) war nicht da, also habe ich es in Python erstellt. (Bitte verwenden Sie es nur als Referenz. Ich bin auch ein Anfänger.)

Bis zu Lektion 5 (Janken-Programm)

Gesamtverarbeitungsfortschritt

object_janken.py

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

#Instanzgenerierung des Schiedsrichters (Herr Saito)
saito = Judge()

#Generation von Spieler 1 (Mr. Murata)
murata_tactics = RandomTactics()
murata = Player("Herr Murata",murata_tactics)

#Generation von Spieler 2 (Mr. Yamada)
yamada_tactics = StoneOnlyTactics()
yamada = Player("Herr Yamada",yamada_tactics)
# yamada = Player_STONE("Herr Yamada")

#Starten Sie Janken mit Mr. Murata und Mr. Yamada als Spieler
saito.start_janken(murata, yamada)

Spielerklasse

player.py

class Player:

    #Konstante, die Jankens Hand darstellt
    STONE = 0  #Schmiere
    SCISSORS = 1  #Choki
    PAPER = 2  #Par

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

    #Streck Jankens Hand aus.
    def show_hand(self):
        hand = self.tactics.read_tactics()
        return hand

    #Hören Sie den Sieg oder die Niederlage des Schiedsrichters. Wenn es gewinnt, ist das Argument Ergebnis wahr
    def notify_result(self,result):
        if (result):
            self.win_count += 1

    #Beantworten Sie, wie oft Sie gewonnen haben.
    def get_win_count(self):
        return self.win_count

    #Antworte auf deinen Namen.
    def get_name(self):
        return self.name

#Erben Sie die Erstellung von untergeordneten Klassen
class Player_STONE(Player):
    def show_hand(self):
        return self.STONE

Richterklasse

judge.py

class Judge:

    #Starten Sie Janken.
    def start_janken(self, player1, player2):
        #Erkläre den Start von Janken
        print("[Janken starten]\n")

        #Spiele Janken 3 mal
        for cnt in range(3):
            #Zeigen Sie, wie viele Runden
            print("【", (cnt + 1), "Runden]")

            #Schauen Sie sich die Hand des Spielers an, um festzustellen, welche gewinnt.
            winner = self.judge_janken(player1, player2)

            if (winner != None):
                #Show Gewinner
                print("\n", winner.get_name(), "Gewonnen!\n")
                #Kommunizieren Sie die Ergebnisse an die Gewinner
                winner.notify_result(True)
            else:
                #Im Falle eines Unentschieden
                print("\n Es ist ein Unentschieden!\n")

        #Erkläre das Ende von Janken
        print("[Ende von Janken]\n")

        #Bestimmen Sie den endgültigen Gewinner
        final_winner = self.judge_final_winner(player1, player2)
        print(player1.get_win_count(), "gegen", player2.get_win_count(), "damit")
        if (final_winner != None):
            print(final_winner.get_name(), "Ist der Gewinner!\n")
        else:
            print("Es ist eine Zeichnung!\n")

    #Schauen Sie sich die Hand des Spielers an, um festzustellen, welche gewinnt.
    def judge_janken(self,player1, player2):
        winner = None

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

        #Streck die Hand des Spielers aus
        player1hand = player1.show_hand()
        player2hand = player2.show_hand()
        player1hand_name = hand_dict[player1hand]
        player2hand_name = hand_dict[player2hand]

        #Zeigen Sie jede Hand
        print(f"{player1hand_name} vs. {player2hand_name} \n")

        #Wenn Spieler 1 gewinnt
        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

        #Wenn Spieler 2 gewinnt
        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

        #Zeichne wenn keiner(Gibt null zurück)
        return winner

    #Bestimmen Sie den endgültigen Gewinner.
    def judge_final_winner(self,player1, player2):
        final_winner = None

        #Hören Sie sich die Anzahl der Siege an
        player1_win_count = player1.get_win_count()
        player2_win_count = player2.get_win_count()

        #Bestimmen Sie den Gewinner
        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

Strategieklasse

tactics.py

class RandomTactics():

    def read_tactics(self):

        # 0.0 oder mehr 3.Erhalten Sie Zufallszahlen als Brüche kleiner als 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

        #Geben Sie die ermittelte Hand als Rückgabewert zurück
        return hand


#==Ich liebe Goo! Strategieklasse.
class StoneOnlyTactics():

  def read_tactics(self):
    #Stellen Sie sicher, dass Sie eine Gänsehaut löschen
    return Player.STONE

Lektion 6 (Programm zum Entfernen von Bubba)

Kartenklasse

card.py

class Card():

    #Eine Konstante, die einen Joker darstellt
    JOKER = 0
    #Konstante Darstellung des Spatens
    SUIT_SPADE = 1
    #Konstante, die einen Diamanten darstellt
    SUIT_DIAMOND = 2
    #Ständige Vertretung des Clubs
    SUIT_CLUB = 3
    #Konstante, die das Herz darstellt
    SUIT_HEART = 4

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

    def getNumber(self):
        return self.number

    #Überschreiben Sie die toString-Funktion
    def toString(self):

        #Im Fall von JOKER
        if self.suit == 0:
            card_code = "JK"

        #Andere Karten als 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

Handklasse

hand.py

import random as rm

class Hand():

    #Behalten Sie die Kartenklasse als Liste
    def __init__(self,list):
        self.hand = list

    #Füge eine Karte hinzu
    def add_card(self,card):
        self.hand.append(card)

    #Ziehe eine Karte (oben)
    def pick_card(self):
        picked_card = self.hand.pop(0)
        return picked_card

    #Geben Sie die Anzahl der Besitztümer zurück
    def getNumberOfCard(self):
        return len(self.hand)

    #Mische deine Hand
    def shuffle(self):
        #Ziehen Sie zufällig Karten heraus und wiederholen Sie die letzte Zugabe
        number = self.getNumberOfCard()
        for i in range(number):
            pos = int(rm.random() * number)
            picked_card = self.hand.pop(pos)
            self.hand.append(picked_card)

    #Suchen Sie die gleiche Anzahl von Karten und legen Sie sie wieder in das Array ein
    def find_same_number_card(self):

        same_cards = None

        #Holen Sie sich die Nummer der zuletzt hinzugefügten Karte
        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:

                #Wenn dieselbe Karte wie die zuletzt hinzugefügte Karte gefunden wird
                #Speichern Sie die gefundene Kombination in sameCards und verlassen Sie die Schleife
                same_cards = [self.hand.pop(-1),self.hand.pop(index)]
                break

        return same_cards

    #Drücken Sie die Karten in Ihrer Hand als Zeichenfolge aus.
    def toString(self):
        hand_cards = ""
        for card in self.hand:
            hand_cards += card.toString() + " "
        return hand_cards

Tabellenklasse

table.py

class Table():

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

    #Wirf die Karte weg.
    def dispose_card(self,dispose_list):
        for card in dispose_list:
            print(f"{card.toString()}Verlassen")
            self.disposed_cards.append(card)

    #Drücken Sie die abgelegte Karte als Zeichenfolge aus.
    def toString(self):
        disposed_cards = ""
        for card in self.disposed_cards:
            disposed_cards += card.toString() + " "
        return disposed_cards

Spielerklasse

player.py

class Player():

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

    #Nominiere deinen Zug (dein Zug)
    def play(self,next_player):

        #Bitten Sie den nächsten Spieler, seine Hand herauszunehmen
        next_hand = next_player.show_hand()

        #Ziehe eine Karte aus der Hand deines Gegners
        picked_card = next_hand.pick_card()

        #Zeigen Sie das Ergebnis der Subtraktion an
        print(self.name, "：", next_player.name, "Von", picked_card.toString(),"Ich zog\n")

        #Fügen Sie die gezogenen Karten Ihrer Hand hinzu und werfen Sie die gleiche Anzahl Karten ab
        self.deal_card(picked_card)

        #Finden Sie heraus, ob Ihre Hand Null ist
        if self.hand.getNumberOfCard() == 0:
            #Erklären Sie dem Moderator den Aufstieg
            self.master.declare_win(self)
        else:
            #Zeigen Sie Ihre aktuelle Hand
            print(self.name, ": Die verbleibende Hand",self.hand.getNumberOfCard(), "ist\n")

    #Mische deine Hand, um sie zu zeigen
    def show_hand(self):
        if self.hand.getNumberOfCard() == 1:
            self.master.declare_win(self)
        self.hand.shuffle()
        return self.hand

    #Erhalten Sie die Karte
    def receive_card(self,card):
        self.deal_card(card)

    #Wenn Sie dieselbe Karte haben, werfen Sie sie weg
    def deal_card(self,card):

        #Fügen Sie Ihrer Hand eine Karte hinzu
        self.hand.add_card(card)

        #Suchen Sie dieselbe Karte, die Sie gerade hinzugefügt haben
        same_cards = self.hand.find_same_number_card()

        #Wenn dieselbe Kartenkombination vorhanden ist
        if (same_cards != None):
            #Wirf die Karte auf den Tisch
            self.table.dispose_card(same_cards)

    #Gibt den Spielernamen zurück
    def toString(self):
        return self.name

Meisterklasse

master.py

class Master():

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

    def prepare_game(self,hand):
        print("[Karten verteilen]\n")

        #Spielkarten mischen
        hand.shuffle()

        #Holen Sie sich die Anzahl der Spielkarten
        number_of_cards = hand.getNumberOfCard()

        #Holen Sie sich die Anzahl der Spieler
        number_of_players = len(self.player_list)

        for index in range(number_of_cards):

            #Ziehe einen von der Karte
            card = hand.pick_card()

            #Gib jedem Spieler nacheinander Karten
            player = self.player_list[index % number_of_players]
            player.receive_card(card)


    #Starte das Spiel.
    def start_game(self):
        print("\n [Entfernen Sie die Watte]\n")

        #Holen Sie sich die Anzahl der Spieler
        count = 0
        while len(self.player_list) > 1:
            player_index = count % len(self.player_list)
            next_player_index = (count + 1) % len(self.player_list)

            #Erwerb eines bestimmten Spielers
            player = self.player_list[player_index]
            #Holen Sie sich den nächsten Spieler
            next_player = self.player_list[next_player_index]

            #Nominiere einen Spieler
            print("\n", player.name, "Du bist dran--- ({})".format(count), "\n")
            player.play(next_player)
            count += 1

        #Verlasse die Schleife, wenn der Spieler nach oben geht und nur noch eine übrig ist
        print("[Entfernung abgeschlossen]\n")


    #Erkläre den Aufstieg.
    def declare_win(self,winner):
        #Spieler, der aufgestiegen ist
        print(winner.name, "Ist aufgestanden!\n")

        #Entfernen Sie den erhöhten Spieler aus der Liste
        self.player_list.remove(winner)

        #Zeige den Verlierer, wenn nur noch ein Spieler übrig ist
        if len(self.player_list) == 1:
            loser = self.player_list[0]
            print(loser.name, "Ist besiegt!\n")


    #Registrieren Sie die Spieler, die am Spiel teilnehmen werden.
    def register_player(self,player):
        self.player_list.append(player)

Ausführungsprogramm

old_maid.py

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

#Ein lächerliches Programm.


#Generieren Sie 53 Spielkarten.
def create_trump():
    trump = Hand([])

    #Generieren Sie 13 Karten für jeden Ruß
    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))

    #Joker erstellen
    trump.add_card(Card(0, 0))

    return trump

#Moderatoren generieren
master = Master([])

#Felderzeugung
field = Table()

#Spielergenerierung
murata = Player("Murata", Hand([]), master, field)
yamada = Player("Yamada", Hand([]), master, field)
saito = Player("Saito", Hand([]),master, field)

#Registrieren Sie den Spieler als Moderator
master.register_player(murata)
master.register_player(yamada)
master.register_player(saito)

#Spielkarten generieren
trump = create_trump()

#Mach dich bereit für das Spiel
master.prepare_game(trump)

#Starte das Spiel
master.start_game()

Frameworkization (7 Zeilen)

・ Da es übersprungen wurde, wird es weggelassen. Es sind zwei Punkte zu beachten:

Abstrakte Klasse

• Wenn Sie eine abstrakte Klasse mit Python erstellen, müssen Sie ABC (Abstract Base Classes) importieren und die abstrakte Klasse erben. → Referenz: ABC in Python-Abstract-Klassen und Ententypisierung

Wert übergeben

· Muss als Wert übergeben werden, wenn die Tabellenklasse Tabelleninformationen zurückgibt

table.py

class FantanTable(Table):

    #Tabelle mit numpy erstellt
    matrix = np.full((4,13),"..")

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