1

i have two classes BaseNode and BaseEdge which i can use connect method to connect tow nodes via an edge in these classes.

code

here is my BaseNode:

class BaseNode:
  def __init__(self,edges=[],value=None,edges_limit=math.inf):
    self.edges = edges
    self.value = value
    self.limit = edges_limit
    self.edge_class = BaseEdge
    self.adjs = []

  def get_adjacents(self):
    if not self.edges:
        return []
    for edge in self.edges :
        self.adjs.append(edge.n2)
    return self.adjs

  def get_edges(self):
    return self.edges

  def connect(self,other):
    """
    connect two nodes by connecting an edge between them
    """
    if not isinstance(other,self.__class__):
        raise ValueError(f'Node should be type of {self.__class__.__name__}')
    if len(self.edges) == self.limit :
        raise MaximumEdgeReached(f'maximum edge reached the limit is {self.limit} ')
    e = BaseEdge()
    e.set_nodes(self,other)
    self.edges.append(e)

and BaseEdge class :

class BaseEdge:
  def __init__(self):
    self.n1 = None
    self.n2 = None
    self.node_class = BaseNode

  def get_nodes(self):
    return (self.n1,self.n2,)

  def set_nodes(self,n1,n2):
    a = isinstance(n1,self.node_class)
    b = isinstance(n2,self.node_class)

    if not a and b :
        raise ValueError(f'nodes of this edge should be {self.node_class}')
    self.n1 = n1
    self.n2 = n2

  def connect(self,n1=None,n2=None):
    if not self.n1 and self.n2 :
        self.set_nodes(n1,n2)
    self.n1.edges.append(self)
    self.n2.edges.append(self)

what I've tried?

i have tried to connect nods from both BaseNode and BaseEdge to see the results. nodes supposed to have same edges but 2 problems occurred :

  1. edges attribute of n1 and n2 which are first node and second node, have 2 instances of e which is the edge ! but edges should has 1 instance of BaseEdge
  2. when i create new objects of BaseNode, the edges attribute has same value for them !! .
    >>> n1 = BaseNode()
    >>> n2 = BaseNode()
    >>> e = BaseEdge()
    >>> e.set_nodes(n1,n2)
    >>> e.connect()
    >>> n2.edges
    [<__main__.BaseEdge object at 0x0000000003282BA8>, <__main__.BaseEdge object at 0x0000000003282BA8>]
    >>> n1.edges
    [<__main__.BaseEdge object at 0x0000000003282BA8>, <__main__.BaseEdge object at 0x0000000003282BA8>]
    >>> n3 = BaseNode() #initializing new oject
    >>> n3.edges
    [<__main__.BaseEdge object at 0x0000000003282BA8>, <__main__.BaseEdge object at 0x0000000003282BA8>]

Note : when i use connect method of BaseNode class . it has the same problem too.

BaseNode class is just acting like a monostate class. and its not supposed to be! please help me to solve this problem.

Ali Najafi
  • 85
  • 1
  • 11
  • Because default arguments are evaluated *once* at function definition time, so every time the default `def __init__(self,edges=[],value=None,edges_limit=math.inf):` edges argument is used, you are *using the same list object* – juanpa.arrivillaga Nov 30 '20 at 19:42

1 Answers1

2

This is the old mutable default argument issue -- to avoid typing it all out again I will suggest you read this: https://florimond.dev/blog/articles/2018/08/python-mutable-defaults-are-the-source-of-all-evil/

Essentially, instead of defining a function as such..

def my_function(input_list=[]):
   input_list.append(2)
   ...

You should define it as

def my_function(input_list=None):
   if input_list is None:
      input_list = []

   input_list.append(2)
   ...

This prevents the default argument [] from being re-used in subsequent calls to the function.

wakey
  • 2,283
  • 4
  • 31
  • 58