Python - wie nach dem Zufallsprinzip Instanzen von einer Klasse wählen

Question

ich brauche zufällig zwei Instanzen wählen aus einer Klasse Knoten:

Class node:

Klasse Knoten:

def __init__(self, parent = None, length_to_parent = None, name = None, left = None, right = None, internal = 1, root = 0): 
    self.parent = parent # parent node 
    self.length_to_parent = length_to_parent # length to the parent node 
    self.name = name # name of the node (to-be-defined name if external node(leaf), None if internal node) 
    self.left = left # left child 
    self.right = right # right child 
    self.internal = internal # indicate if the node is an internal node 
    self.root = root 

Ich denke an der Speicherung Alle Instanzen von Knoten in einer Liste verwenden dann random.choose oder random.shuffle, um zwei Knoten aus der Liste zufällig auszuwählen.

Aber ich weiß nicht, wie man Instanzen in einer Liste speichert, aber ... Jedermann bitte helfen !!! Danke

Answer 1

Sie können Instanzen auf einer Liste wie alles andere speichern.

import random 
lst = [] 
new_node = node(parent,length... etc) 

lst.append(new_node) 

# assuming you have > 2 nodes: 
# pick two random nodes, store in another lst 
random_selection = [random.choice(lst) for x in range(2)] 

Gab es etwas Bestimmtes, das Sie fragen?

Answer 2

Ich gehe davon aus, dass dieser "Knoten" von Ihnen Teil eines binären Baumes ist. In diesem Fall können Sie einfach durch Ihren Baum iterieren und Referenzen in einer laufenden Liste speichern.

Etwas entlang der Linien von:

arr = [] 
# Perform tree traversal. 
traverse(root_node, arr) 
# Now, do something here with the list! 

def traverse(node, arr): 
    # Traverse the left subtree 
    if(node.left is not None): 
     traverse(node.left, arr) 
    # Traverse the right subtree 
    if(node.right is not None): 
     traverse(node.right, arr) 
    # Append the node! It can be appended like any other item in the list. 
    arr.append(node) 

sollten Sie in der Lage sein Knoten anhängen (wie alles andere) auf die Liste, und dann Elemente zufällig wählen je nach Bedarf.

Answer 3

Ich würde eine Klassenvariable hinzufügen, die alle Knoten hält (die am Ende des __init__ hinzugefügt werden) und eine Klassenmethode zwei zufällig zu bekommen:

import random 

class Node: 
    node_instances = [] 
    def __init__(self, parent = None, length_to_parent = None, name = None, left = None, right = None, internal = 1, root = 0): 
     self.parent = parent # parent node 
     self.length_to_parent = length_to_parent # length to the parent node 
     self.name = name # name of the node (to-be-defined name if external node(leaf), None if internal node) 
     self.left = left # left child 
     self.right = right # right child 
     self.internal = internal # indicate if the node is an internal node 
     self.root = root 
     Node.node_instances.append(self) 

    @classmethod 
    def get_random_instances(cls): 
     return random.sample(cls.node_instances, 2) 

, die Sie mögen können: