Is there a python module to solve linear equations?

Using @Jeremy's example:

from sympy import *
x0, x1 = symbols(['x0', 'x1'])
sol = solve([3 * x0 + x1 - 9, x0 + 2 * x1 - 8], [x0, x1])
print(sol)

output:

{x0: 2, x1: 3}

Using @004 example with slightly different notation:

from sympy import *
x, y = symbols(['x', 'y'])
system = [
    Eq(3*x + 4*y, 7),
    Eq(5*x + 6*y, 8)
]
soln = solve(system, [x, y])
print(soln)

{x: -5, y: 11/2}

Note: Sometimes one may see the following notation for symbols: x, y = symbols('x, y'), which seems to be less pythonic.

You can write a simple function which solves a system of linear equations.

def solve(equations):
     #the constants of a system of linear equations are stored in a list for each equation in the system
     """
     for example the system below:
          2x+9y-3z+7w+8=0
          7x-2y+6z-1w-10=0
          -8x-3y+2z+5w+4=0
          0x+2y+z+w+0=0
     is expressed as the list:
          [[2,9,-3,7,8],[7,-2,6,-1,-10],[-8,-3,2,5,4],[0,2,1,1,0]]
     """
     lists=[] # I failed to name it meaningfully
     for eq in range(len(equations)):
          #print "equations 1", equations
          #find an equation whose first element is not zero and call it index
          index=0
          for i in range(len(equations)):
               if equations[i][0]<>0:
                    index=i;
                    break;
          #print "index "+str(eq)+": ",index
          #for the equation[index] calc the lists next itam  as follows
          lists.append([-1.0*i/equations[index][0] for i in equations[index][1:]])
          #print "list"+str(eq)+": ", lists[-1]
          #remve equation[index] and modify the others
          equations.pop(index)
          for i in equations:
               for j in range(len(lists[-1])):
                    i[j+1]+=i[0]*lists[-1][j]
               i.pop(0)

     lists.reverse()

     answers=[lists[0][0]]
     for i in range(1,len(lists)):
          tmpans=lists[i][-1]
          for j in range(len(lists[i])-1):
               tmpans+=lists[i][j]*answers[-1-j]
          answers.append(tmpans)
     answers.reverse()
     return answers

You can also add constrains (upper bound and lower bound) on x with lsq_linear: scipy.optimize.lsq_linear