What is Monte-Carlo Tree Search (MCTS)?

import numpy as np
from collections import defaultdict
class MCTS():
    def __init__(self, current_node, parent_node=None, parent_node_action=None):
        #The current node
        self.current_node = current_node   
		
        #The parent_node (The parent_node of the root = none) 
        self.parent_node = parent_node 
		
        #The current node siblings
        self.child_nodes = []
        self.parent_node_action = parent_node_action
		
        #The count of visits of the current node.
        self._count_of_visits = 0
		
        self._results = defaultdict(int)
        self._results[1]  = 0
        self._results[-1] = 0
        
		#The list of all possible transitions
        self._unattempted_transitions = None
        self._unattempted_transitions = self.unattempted_transitions()
    def unattempted_transitions(self):
        #Returns the list of unattempted transitions from a given node.
        self._unattempted_transitions = self.current_node.get_allowed_transitions()
        return self._unattempted_transitions
    def q(self):
        #Return the difference of wins - losses
        wins  = self._results[1]
        loses = self._results[-1]
        return wins - loses
    def n(self):
        #Return the number of times each node was visited.
        return self._count_of_visits
    def expand(self):
        #From the present current_node 
		# Determine the next node depending on the carried out action. 
		# Determine the possible child nodes and append them to the child_nodes.
        action     = self._unattempted_transitions.pop()
        next_node  = self.current_node.move(action)
        child_node = MonteCarloTreeSearchNode(
                        	                   next_node
                                             , parent_node=self
                                             , parent_node_action=action
                                             )
        self.child_nodes.append(child_node)
        return child_node     
    def is_terminal_node(self):
        #Check whether the current node is the last tree node.
        return self.current_node.is_last_tree_node()
    def run_simulation(self):
        #From the current current_node a simulation is performed: 
	
        current_simulation = self.current_node
        while not current_simulation.is_last_tree_node():
              possible_moves = current_simulation.get_allowed_transitions()
              action = self.simulation_policy(possible_moves)
              current_simulation = current_simulation.move(action)
        return current_simulation.game_result()
    def backpropagate_results(self, result):
        #The statistics collected for the nodes are updated all way up.
        # The number of visits is incremented by 1 for each node visited.  
		# The corresponding result is incremented by 1 depending on the result parameter.  
        self._count_of_visits += 1
        self._results[result] += 1
        if self.parent_node:
           self.parent_node.backpropagate_results(result)    
    def is_fully_expanded(self):
        #Verify that all the transitions were poped out of the _unattempted_transitions one by one. 
        #When empty (size = zero) -> it is fully expanded.
        return len(self._unattempted_transitions) == 0
    def best_child(self, c_param=0.1):
        #Once fully expanded, this function selects the best child out of the child_nodes array. 
        choices_weights = [(c.q() / c.n()) + c_param * np.sqrt((2 * np.log(self.n()) / c.n())) for c in self.child_nodes]
        return self.child_nodes[np.argmax(choices_weights)]    
    def simulation_policy(self, possible_moves):
        #Select a move randomly out of possible moves. 
        return possible_moves[np.random.randint(len(possible_moves))]
    def _tree_policy(self):
		#Iterate over nodes	
        current_node = self
        while not current_node.is_terminal_node():
            if not current_node.is_fully_expanded():
               return current_node.expand()
            else:
               current_node = current_node.best_child()
        return current_node
    def best_action(self,no_simulation):
        #This function returns the node corresponding to best possible move. 
        for i in range(no_simulation):
            v = self._tree_policy()
            reward = v.run_simulation()
            v.backpropagate_results(reward)
        return self.best_child(c_param=0.1)
def main():
    no_simulation = 100 
    root = MCTS(current_node = initial_current_node)
    selected_node = root.best_action(no_simulation)