Nested list doesn't work properly
Question: 
    import re
    def get_number(element):
        re_number = re.match("(\d+\.?\d*)", element)
    
        if re_number:
            return float(re_number.group(1))
        else:
            return 1.0
    
    def getvalues(equation):
        elements = re.findall("([a-z0-9.]+)", equation)
        return [get_number(element) for element in elements]
    
    
    eqn = []
    eqn_no = int(raw_input("Enter the number of equations: "))
    
    for i in range(eqn_no):
        eqn.append(getvalues(str(raw_input("Enter Equation %d: " % (i+1)))))
    print "Main Matrix: "
    for i in range((eqn_no)):
        for j in range((eqn_no+1)):
            print "\t%f" %(eqn[i][j]),
        print
    print
    equation=[]
    equation=eqn
    for k in range((eqn_no-1)):
        for i in range((k+1),eqn_no):
            for j in range((eqn_no+1)):
                if(eqn[i][j]!=0):
                    eqn[i][j]=eqn[i][j]-(eqn[k][j]*(equation[i][k]/eqn[k][k]))
    
    
    
        print "Matrix After %d step: " %(k+1)
        for i in range(eqn_no):
                for j in range((eqn_no+1)):
                    print "\t%f"%(eqn[i][j]),
                    equation[i][j]=eqn[i][j];
    
                print
        print
    

for input:

    
    
    25x+5y+z=106.8
    64x+8y+z=177.2
    144x+12y+z=279.2
    

output is:

    
    
    Main Matrix: 
        25.000000   5.000000    1.000000    106.800000
        64.000000   8.000000    1.000000    177.200000
        144.000000  12.000000   1.000000    279.200000
    
    Matrix After 1 step: 
        25.000000   5.000000    1.000000    106.800000
        0.000000    8.000000    1.000000    177.200000
        0.000000    12.000000   1.000000    279.200000
    
    Matrix After 2 step: 
        25.000000   5.000000    1.000000    106.800000
        0.000000    8.000000    1.000000    177.200000
        0.000000    0.000000    1.000000    279.200000
    

But it should be like

    
    
    Main Matrix: 
        25.000000   5.000000    1.000000    106.800000
        64.000000   8.000000    1.000000    177.200000
        144.000000  12.000000   1.000000    279.200000
    
    Matrix After 1 step: 
        25.000000   5.000000    1.000000    106.800000
        0.000000    -4.80000    -1.56000    -96.208000
        0.000000    -16.8000    -4.76000    -335.968000
    
    Matrix After 2 step: 
        25.000000   5.000000    1.000000    106.800000
        0.000000    -4.80000    -1.56000    -96.208000
        0.000000    0.000000    0.699999    0.759981
    

First of all this is a partial code for solving root of n number of equations
using Naive Guass elemination method. Does anyone have any idea why the hell
on earth is this happening? Why the zero parts are changing and others aren't?
I have done this code in c++ and it works there perfectly but here I'm facing
many problem. Maybe I'm newbie to python. I'm using python 2.7.....


Answer: I think the problem is the assignment `equation = eqn`. Since `eqn` is a list,
it is a mutable and thus passed as a reference, when you assign a mutable, the
variable actually contains a pointer to that object. This means that
`equation` and `eqn` are the same list.

You should

    
    
    from copy import deepcopy
    equation = deepcopy(eqn)
    

You need `deepcopy` instead of `copy` because you have a list of lists, also
the inner list needs to be copied.

