Python: Create a duplicate of an instance of a class
<p>I have an instance 'graph_main' of a class BipartiteGraph which I've defined. All I need now is to keep this instance untouched but create another instance 'graph1' of this class that is identical to 'graph_main'. But for some reason the graph_main also keeps changing while I am not working with it at all. I am new to Python, like couple of weeks new. So if there is relevant documentation that you can point me towards to learn the scope of objects in Python, I will appreicate it.</p>

<p>MWE:</p>

<pre><code>import numpy
import testBipartiteUtils
import random
#These are Bipartite graph parameters
N=30 #No of Bit Nodes
K=10 #No of Check Nodes 
rdeg=2 

graph_main = testBipartiteUtils.BipartGraph([])

for NodeIndex in range(0, K):
    graph_main.addBitNode(NodeIndex)#Adding Bit Node. No edges added

for NodeIndex in range(0, N):
    graph_main.addChkNode(NodeIndex)#Adding Check Node. No edges added

    attachments=random.sample(range(0,K),rdeg) 
    for j in attachments:
        graph_main.addEdge([j,NodeIndex])

for z in range(0,10):
    chan=[]
    for i in range(0,N):
        chan.append(0)

graph1=graph_main **#creating a new object identical to graph_main?**

PeelGraph=testBipartiteUtils.Peeling(graph1,chan)
PeelGraph.zeroStep()
print "graph_main Nodes are-",len(graph_main.BitNodes),len(graph_main.ChkNodes)
print "graph1 Nodes are-",len(graph1.BitNodes),len(graph1.ChkNodes)

del PeelGraph
print "z=",z
</code></pre>

<p>I am providing my Utils file in case someone wants to run it and see but I highly doubt that would  be necessary. So I am expecting an output of constant number of Bit and Check Nodes in graph_main (it is a bipartite graph class) for each simulation since I am not changing it. Here I am assuming graph1=graph_main creates a new object identical to the existing graph_main. Is that correct and my mistake lies elsewhere? </p>

<p>testBipartiteUtils.py</p>

<pre><code>import numpy

 class Edge:

 def __init__(self, n1, n2):
    """Constructor. Takes bit and check node IDs as arguments"""
    self.node1=n1
    self.node2=n2

def getNodes(self):
    """Returns a list containing the bit and check nodes for this edge"""
    return [self.node1, self.node2]

def hasNodes(self, n1, n2):
    """Takes two node IDs. Returns true if the IDs match the two nodes of this edge in that order."""
    if(self.node1==n1 and self.node2==n2):
        return True

    return False


 class BitNode:
""" Basic node class."""

def __init__(self, name):
    """Constructor. Takes a node ID"""
    self.ID=name
    self.neighbors=[]
    self.degree= 0

def addNeighbors(self, nbs):
    """Adds a list of neighbors to the current list. Takes a list of node IDs"""
    for i in range(0, len(nbs)):
        if(not nbs[i] in self.neighbors):
            self.neighbors.append(nbs[i])
            self.degree+=1

def getID(self):
    """Returns node ID"""
    return self.ID

def getNeighbors(self):
    """Returns list of neighbor IDs"""
    return self.neighbors


 class ChkNode:

def __init__(self, name):
    """Constructor. Takes a node ID"""
    self.ID=name
    self.neighbors=[]
    self.chan = int(-1)
    self.degree= 0


def addNeighbors(self, nbs):
    """Adds a list of neighbors to the current list. Takes a list of node IDs"""
    for i in range(0, len(nbs)):
        if(not nbs[i] in self.neighbors):
            self.neighbors.append(nbs[i])
            self.degree+=1

def getID(self):
    """Returns node ID"""
    return self.ID

def getNeighbors(self):
    """Returns list of neighbor IDs"""
    return self.neighbors


 class BipartGraph:
def __init__(self, eds):
    """Constructor. Takes a list of edge primitives, which is a list of two node IDs.
    Iterates through the edges, creates nodes for unique node IDs, and adds all edges and nodes.
    """
    self.size = 0
    self.BitNodes = []
    self.ChkNodes = []
    self.edges = []
    for i in range(0, len(eds)):
        self.addEdge(eds[i])


def containsEdge(self, edgep):
    """Checks for an edge in the graph. Takes an edge primitive, which is a list of two node IDs. First ID is bit node, second ID is of Check node"""
    for e in self.edges:
        if(e.hasNodes(edgep[0], edgep[1])):
            return True


def getBitNode(self, name):
    """Checks if a given Bit Node ID exists in the graph. If not, it creates and adds a Bit Node for the given ID. Returns the Bit Node"""
    for i in range(0, len(self.BitNodes)):
        if(self.BitNodes[i].getID()==name):
            return self.BitNodes[i]
    newNode = BitNode(name)
    self.BitNodes.append(newNode)
    return self.BitNodes[len(self.BitNodes)-1]

def getChkNode(self, name):
    """Checks if a given Chk Node ID exists in the graph. If not, it creates and adds a Chk Node for the given ID. Returns the Chk Node"""
    for i in range(0, len(self.ChkNodes)):
        if(self.ChkNodes[i].getID()==name):
            return self.ChkNodes[i]
    newNode = ChkNode(name)
    self.ChkNodes.append(newNode)
    return self.ChkNodes[len(self.ChkNodes)-1]

def getEdges(self):
    """Returns list of edges"""
    return self.edges

def addBitNode(self, name):
    """Adds a Bit node, based on Bit node ID"""
    newNode = BitNode(name)
    self.BitNodes.append(newNode)

def addChkNode(self, name):
    """Adds a Check node, based on node ID"""
    newNode = ChkNode(name)
    self.ChkNodes.append(newNode)

def addEdge(self, edgep):
    """Adds an edge into the graph, and updates neighbors &amp; degrees of relevant nodes.
    Takes an edge primitive, a list of two node IDs
    """
    if(not self.containsEdge(edgep)):
        no1 = self.getBitNode(edgep[0])
        no2 = self.getChkNode(edgep[1])
        newEdge = Edge(edgep[0], edgep[1])
        self.edges.append(newEdge)
        no1.addNeighbors([no2.getID()])
        no2.addNeighbors([no1.getID()])

 class Peeling:
"""peeling decoder on a Bipartite graph class.
"""
def __init__(self, G,chan):
    """Constructor. Takes a graph and channel output vector as arguments"""
    self.graph=G
    for i in range(0,len(self.graph.ChkNodes)):
        self.graph.ChkNodes[i].chan=chan[i]
    self.deg1Chks=[]

def zeroStep(self):
    self.graph.BitNodes.pop(0)

def peelIter(self):
    self.graph.ChkNodes.pop(0)
</code></pre>