[Python version] Why can't you do object-oriented development in Java?

Overview

I bought "Why can't you do object-oriented development in Java" for object-oriented re-learning, but only in Java / Ruby [Official sample](http://gihyo.jp/book/2005/4- 7741-2222-X / support) wasn't there, so I created it in Python. (Please use it as a reference only. I am also a beginner.)

Up to Lesson 5 (rock-paper-scissors program)

Overall processing progress

object_janken.py


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

#Instance generation of referee (Mr. Saito)
saito = Judge()

#Generation of player 1 (Mr. Murata)
murata_tactics = RandomTactics()
murata = Player("Mr. Murata",murata_tactics)

#Generation of player 2 (Mr. Yamada)
yamada_tactics = StoneOnlyTactics()
yamada = Player("Mr. Yamada",yamada_tactics)
# yamada = Player_STONE("Mr. Yamada")

#Start rock-paper-scissors with Mr. Murata and Mr. Yamada as players
saito.start_janken(murata, yamada)

Player class

player.py


class Player:

    #Constant representing rock-paper-scissors hand
    STONE = 0  #Goo
    SCISSORS = 1  #Choki
    PAPER = 2  #Par

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

    #Put out the hand of rock-paper-scissors.
    def show_hand(self):
        hand = self.tactics.read_tactics()
        return hand

    #Hear the victory or defeat from the referee. If it wins, the argument result is true
    def notify_result(self,result):
        if (result):
            self.win_count += 1

    #Answer the number of times you have won.
    def get_win_count(self):
        return self.win_count

    #Answer your name.
    def get_name(self):
        return self.name

#Inherit child class creation
class Player_STONE(Player):
    def show_hand(self):
        return self.STONE

Judge class

judge.py


class Judge:

    #Start rock-paper-scissors.
    def start_janken(self, player1, player2):
        #Declare the start of rock-paper-scissors
        print("[Starting rock-paper-scissors]\n")

        #Play rock-paper-scissors 3 times
        for cnt in range(3):
            #Show how many rounds
            print("【", (cnt + 1), "Round]")

            #Look at the player's hand to determine which one wins.
            winner = self.judge_janken(player1, player2)

            if (winner != None):
                #Show winner
                print("\n", winner.get_name(), "Won!\n")
                #Communicate results to winning players
                winner.notify_result(True)
            else:
                #In the case of a draw
                print("\n It's a draw!\n")

        #Declare the end of rock-paper-scissors
        print("[End of rock-paper-scissors]\n")

        #Determine the final winner
        final_winner = self.judge_final_winner(player1, player2)
        print(player1.get_win_count(), "versus", player2.get_win_count(), "so")
        if (final_winner != None):
            print(final_winner.get_name(), "Is the winner!\n")
        else:
            print("It's a draw!\n")

    #Look at the player's hand to determine which one wins.
    def judge_janken(self,player1, player2):
        winner = None

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

        #Put out the player's hand
        player1hand = player1.show_hand()
        player2hand = player2.show_hand()
        player1hand_name = hand_dict[player1hand]
        player2hand_name = hand_dict[player2hand]

        #Show each hand
        print(f"{player1hand_name} vs. {player2hand_name} \n")

        #When player 1 wins
        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

        #When player 2 wins
        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

        #If neither is the case, a draw(Returns nil)
        return winner

    #Determine the final winner.
    def judge_final_winner(self,player1, player2):
        final_winner = None

        #Listen to the number of wins
        player1_win_count = player1.get_win_count()
        player2_win_count = player2.get_win_count()

        #Determine the winner
        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

Strategy class

tactics.py


class RandomTactics():

    def read_tactics(self):

        # 0.0 or more 3.Get a random number as a decimal number less than 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

        #Return the determined hand as a return value
        return hand


#==I love Goo! ”Strategy class.
class StoneOnlyTactics():

  def read_tactics(self):
    #Be sure to put out a goo
    return Player.STONE

Lesson 6 (Old Maid program)

Card class

card.py



class Card():

    #A constant that represents the joker
    JOKER = 0
    #Constant representing spade
    SUIT_SPADE = 1
    #Constant representing a diamond
    SUIT_DIAMOND = 2
    #A constant that represents a club
    SUIT_CLUB = 3
    #Constant representing the heart
    SUIT_HEART = 4

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

    def getNumber(self):
        return self.number

    #Override toString function
    def toString(self):

        #In the case of JOKER
        if self.suit == 0:
            card_code = "JK"

        #Cards other than 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

Hand class

hand.py



import random as rm

class Hand():

    #Keep the card class as a list
    def __init__(self,list):
        self.hand = list

    #Add a card
    def add_card(self,card):
        self.hand.append(card)

    #Draw a card (top)
    def pick_card(self):
        picked_card = self.hand.pop(0)
        return picked_card

    #Return the number of possessions
    def getNumberOfCard(self):
        return len(self.hand)

    #Shuffle your hand
    def shuffle(self):
        #Randomly remove cards and repeat the last addition
        number = self.getNumberOfCard()
        for i in range(number):
            pos = int(rm.random() * number)
            picked_card = self.hand.pop(pos)
            self.hand.append(picked_card)

    #Find the same number of cards and put them back in an array
    def find_same_number_card(self):

        same_cards = None

        #Get the number of the last added card
        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:

                #If the same card as the last added card is found
                #Store the found combination in sameCards and exit the loop
                same_cards = [self.hand.pop(-1),self.hand.pop(index)]
                break

        return same_cards

    #Express the card in your hand as a character string.
    def toString(self):
        hand_cards = ""
        for card in self.hand:
            hand_cards += card.toString() + " "
        return hand_cards

Table class

table.py


class Table():

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

    #Discard the card.
    def dispose_card(self,dispose_list):
        for card in dispose_list:
            print(f"{card.toString()}Abandoned")
            self.disposed_cards.append(card)

    #Express the discarded card as a character string.
    def toString(self):
        disposed_cards = ""
        for card in self.disposed_cards:
            disposed_cards += card.toString() + " "
        return disposed_cards

Player class

player.py



class Player():

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

    #Nominate your turn (your turn)
    def play(self,next_player):

        #Ask the next player to take out his hand
        next_hand = next_player.show_hand()

        #Draw a card from your opponent's hand
        picked_card = next_hand.pick_card()

        #Display the result of subtraction
        print(self.name, ":", next_player.name, "From", picked_card.toString(),"I pulled\n")

        #Add the drawn cards to your hand and discard the same number of cards
        self.deal_card(picked_card)

        #Find out if your hand is zero
        if self.hand.getNumberOfCard() == 0:
            #Declare the rise to the facilitator
            self.master.declare_win(self)
        else:
            #Show your current hand
            print(self.name, ": The remaining hand",self.hand.getNumberOfCard(), "is\n")

    #Shuffle your hand to show
    def show_hand(self):
        if self.hand.getNumberOfCard() == 1:
            self.master.declare_win(self)
        self.hand.shuffle()
        return self.hand

    #Receive the card
    def receive_card(self,card):
        self.deal_card(card)

    #If you have the same card, throw it away
    def deal_card(self,card):

        #Add a card to your hand
        self.hand.add_card(card)

        #Find the same card you just added
        same_cards = self.hand.find_same_number_card()

        #If the same card combination exists
        if (same_cards != None):
            #Discard the card to the table
            self.table.dispose_card(same_cards)

    #Returns the player name
    def toString(self):
        return self.name

Master class

master.py



class Master():

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

    def prepare_game(self,hand):
        print("[Distribute cards]\n")

        #Shuffle playing cards
        hand.shuffle()

        #Get the number of playing cards
        number_of_cards = hand.getNumberOfCard()

        #Get the number of players
        number_of_players = len(self.player_list)

        for index in range(number_of_cards):

            #Draw one from the card
            card = hand.pick_card()

            #Deal cards to each player in turn
            player = self.player_list[index % number_of_players]
            player.receive_card(card)


    #Start the game.
    def start_game(self):
        print("\n [Old Maid will start]\n")

        #Get the number of players
        count = 0
        while len(self.player_list) > 1:
            player_index = count % len(self.player_list)
            next_player_index = (count + 1) % len(self.player_list)

            #Acquiring a designated player
            player = self.player_list[player_index]
            #Get the next player
            next_player = self.player_list[next_player_index]

            #Nominate a player
            print("\n", player.name, "It's your turn--- ({})".format(count), "\n")
            player.play(next_player)
            count += 1

        #Exit the loop when the player goes up and there is only one left
        print("[Old Maid finished]\n")


    #Declare the rise.
    def declare_win(self,winner):
        #Player who went up
        print(winner.name, "Got up!\n")

        #Remove the raised player from the list
        self.player_list.remove(winner)

        #Show loser when there is only one player left
        if len(self.player_list) == 1:
            loser = self.player_list[0]
            print(loser.name, "Is defeated!\n")


    #Register the players who will participate in the game.
    def register_player(self,player):
        self.player_list.append(player)

Execution program

old_maid.py



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

#Old Maid program.


#Generate 53 playing cards.
def create_trump():
    trump = Hand([])

    #Generate 13 cards for each suit
    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))

    #Creating a joker
    trump.add_card(Card(0, 0))

    return trump

#Generating facilitators
master = Master([])

#Field generation
field = Table()

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

#Register player as facilitator
master.register_player(murata)
master.register_player(yamada)
master.register_player(saito)

#Generate playing cards
trump = create_trump()

#Get ready for the game
master.prepare_game(trump)

#Start the game
master.start_game()

Frameworkization (7 rows)

・ Since it was skipped, it is omitted. There are two points to be aware of:

Abstract class

-When creating an abstract class with python, it is necessary to import ABC (Abstract Base Classes) and inherit the abstract class. → Reference: ABC in Python-Abstract Classes and Duck Typing

Pass by value

· Must be passed by value when the table class returns table information

table.py


class FantanTable(Table):

    #Table created with numpy
    matrix = np.full((4,13),"..")

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

Recommended Posts

[Python version] Why can't you do object-oriented development in Java?
Why can't I install matplotlib in python! !!
What to do if you can't use scikit grid search in Python
Why you are interested in motor control in Python
Framework development in Python
Development environment in Python
Slackbot development in Python
% And str.format () in Python. Which one do you use?
What to do when you can't bind CaboCha to Python
What to do if you can't hit the arrow keys in the Python interactive console
If you write TinderBot in Python, she can do it
Python development in Visual Studio 2017
What to do if you can't log in as root
Python development in Visual Studio
What to do if you can't install pyaudio with pip #Python
What to do if you get a minus zero in Python
What to do if you can't use the trash in Lubuntu 18.04.
[Swift / Ruby / Python / Java] Object-oriented programming
[Python] How to do PCA in Python
Web application development memo in python
Do you need a Python re.compile?
Until you put Python in Docker
Self-organizing map in Python NumPy version
I can't install scikit-learn in Python
Python | What you can do with Python
Do something object-oriented in GO language
How many types of Python do you have in Windows 10? I had 5 types.
What to do if you can't find PDO in Laravel or CakePHP
Python --How do you split a list into evenly sized chunks in Python?
What to do if you can't install with pip in babun environment
What happens if you do "import A, B as C" in Python?
Do a non-recursive Euler Tour in Python
How to do R chartr () in Python
Express Python yield in JavaScript or Java
Differences in syntax between Python and Java
I can't debug python scripts in Eclipse
How to check opencv version in python
Prevent double launch in Python (improved version)
[Basics of python basics] Why do __name__ == "__main__"
Do something like Redis transactions in Python
Even if the development language is changed to python3 in Cloud9, version 2 is displayed in python --version
You will be an engineer in 100 days --Day 35 --Python --What you can do with Python
What to do if you get "Python not configured." Using PyDev in Eclipse
[Beginner / Saved version] What you can do by programming language (12 selections such as Ruby / Python / Java / Swift / PHP / Go)