Pues eso, que he actualizado de 9 a 10.04 mi Ubuntu, y me arranca en consola, y cada vez tengo que meter el comando sudo /etc/init.d/gdm start.
   ¿Que hago para que entre directamente en graficos?.
  Saludos : Gaby

   Bueno, pues para ir practicando con python, en entorno grafico GTK, y con bases de datos MySQL, he hecho estos widgets heredados de widgets GTK, para poder manejar tablas MySQL, no esta demasiado comentado, si a alguien le interesa el tema puede consultarme lo que quiera.
   Estoy preparando un programita ejemplo de uso de estos widgets, lo enviare proximamente.
   Tened en cuenta que os hace falta ademas del python, el motor de BD MySQL, GTK2 y las librerias de python para MySQL, mysqldb y para gtk pygtk.
   Ala, saludos : Gaby

#!/usr/bin/env python
 
import pygtk
pygtk.require('2.0')
import gtk
import MySQLdb   
 
 
class Database:
    def __init__(self,database,usuario=None,password=None):
        self.database_nombre=database
 
        self.conectada=False
        if usuario!=None:
            self.mysquser=usuario
        else:            
            self.mysquser='usuario' #podemos poner el valor en la clase si va a ser siempre el mismo
        if password!=None:
            self.mysqpasw=password
        else:
            self.mysqpasw='********' #podemos poner el password por defecto, igual que el usuario
        self.conexion=None
 
    def conectar(self):
        try:
            self.conexion=MySQLdb.connect(host='localhost',user=self.mysquser,passwd=self.mysqpasw,db=self.database_nombre)
            self.conectada=True
            return self.conexion
        except:
            #error, sacamos dialogo y decimos que hagan configuracion
            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                        gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error conectando a base de datos\n Compruebe configuracion\n o MySQL")
            md.run()
            md.destroy()
            return False
 
    def set_dbdatos(self,usuario=None,password=None):
 
        if usuario!=None:
            self.mysquser=usuario
        if password!=None:
            self.mysqpasw=password
 
 
 
 
class Tabla:
 
 
 
    def __init__(self,tabla,basedatos):
	# los errores en valores de datos en el sql, no da error da warning, lo
	# pasamos a error para poder trabajar con try: except:
        import warnings
        warnings.simplefilter("error")
 
        self.database=basedatos
        self.abierta=False
        self.tabla=tabla
        self.datos_tabla=[]
        self.widgets=[]
        self.descripcion_tabla=[]
        self.nombre_campos=[]
        self.tipo_campos=[]
        self.long_campos=[]
        self.num_campos=0
        self.num_lineas=0
        self.tablas_rel=[]
        self.campos_rel=[]
        self.estado='consultar'
        self.linea_actual=[]
        self.indexado=False
        self.indice=''
        self.abrir()
 
 
 
    def abrir(self):
        #abre la tabla
        res=self.abre_tabla()
 
        if res:
                self.datos_tabla=self.cursor.fetchall()
                self.num_lineas=len(self.datos_tabla)
                self.linea_actual=self.datos_tabla[0]
                self.linea_pos=0  
                #num_campos lleva el numero de campos 
                self.num_campos=len(self.cursor.description)
                for i in range(self.num_campos):
                    self.nombre_campos.append(self.cursor.description[i][0])
                    self.tipo_campos.append(self.cursor.description[i][1])
                    self.long_campos.append(self.cursor.description[i][3])
 
        #cerramos la tabla y la base de datos, y trabajamos con los
        #datos en la variable datos_tabla
        self.cierra_tabla()
        return res
 
 
    def abre_tabla(self):
 
        #conectamos la base de datos
        self.conn=self.database.conectar()
        self.cursor=self.conn.cursor()  
 
        if self.database.conectada==True: #True si estamos conectados a la base de datos
            try:
                sql='select * from '+self.tabla
                if self.indexado:
                    sql=sql+' order by '+self.indice
                self.cursor.execute(sql)
                self.abierta=True 
                result=True 
            except:
                #error, sacamos dialogo y decimos que hagan configuracion
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                        gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error abriendo tabla\n Compruebe configuracion\n o MySQL")
                md.run()
                md.destroy()
                result=False
        else:
            #la base de datos no esta conectada
                #error, sacamos dialogo y decimos que hagan configuracion
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                        gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Base de datos no abierta\n Compruebe configuracion\n o MySQL")
                md.run()
                md.destroy()   
                result=False   
        return result
 
    def cierra_tabla(self):
        self.cursor.close()
        self.conn.close()
 
    def set_indice(self,indexado,*indice):
        if indexado:
            self.indexado=True
            self.indice=indice[0]
            self.abrir()
        else:
            self.indexado=False
 
    def set_tabla(self,tabla):
        self.tabla=tabla
        self.abrir()
 
    def adelante(self,widget):
            # una fila adelante en la tabla.
            if self.linea_pos<self.num_lineas-1:
                self.linea_pos+=1
                self.linea_actual=self.datos_tabla[self.linea_pos]
                result=True
                if self.linea_pos==self.num_lineas-1:
                    result=False
                self.actualizar()
            else:
                #hemos alcanzado final tabla
                result=False
            return result
 
    def atras(self,widget):
            #una fila hacia atras, si es la primera, no cambia
            if self.linea_pos>0:
                self.linea_pos-=1
                self.linea_actual=self.datos_tabla[self.linea_pos]
                result=True
                if self.linea_pos==0:
                    result=False                
                self.actualizar()
            else:
                #principio de tabla
                result=False
            return result
 
    def primero(self,widget):
            self.linea_pos=0
            self.linea_actual=self.datos_tabla[self.linea_pos]
            self.actualizar()
            return True
 
    def ultimo(self,widget):
            self.linea_pos=self.num_lineas-1
            self.linea_actual=self.datos_tabla[self.linea_pos]
            self.actualizar()
            return True
 
    def aplica_edicion(self):
        #aqui salvamos los datos editados 
        #primero seleccionamos la fila de la tabla a cambiar
        #los datos sin editar estan en la variable linea_actual[]
        #hacemos el select con todos los campos, pues no sabemos
        #si hay dos lineas con campos iguales.
        #primero abrimos tabla
        #pero antes guardamos el puntero que llevabamos
        linea_antes=self.linea_pos
        self.abre_tabla()
        datos_antes=''
        for i in range(self.num_campos):
            campo=self.nombre_campos[i]
            dato=str(self.linea_actual[i])
            if dato!='' and dato!='None':
                datos_antes=datos_antes+campo+' = "'+dato+'" AND '  
        datos_antes=str(datos_antes[0:len(datos_antes)-4])    
        sql='select * from '+self.tabla+' where '+datos_antes  
        try:
            self.cursor.execute(sql)
        except:
            #error, el registro a modificar tenia valores inconsistentes
            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error en registro\n Debe arreglarlo desde\n Administrador MySQL\n")
            md.run()
            md.destroy() 
            return False
 
        #una vez seleccionada la linea a modificar, comprobamos que es una 
        # y solo una.
        if self.cursor.rowcount != 1:
            #error, sacamos dialogo y decimos que comprueben datos
            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al grabar datos\n Mas de un registro cambiado\n ")
            md.run()
            md.destroy() 
            return False
        else:
            #correcto, anotamos los nuevos valores
            sql='update '+self.tabla+' set '
            for i in range(self.num_campos):
                campo=self.nombre_campos[i]
                dato=self.widgets[i].get_text()
                if dato!='':
                    if i<self.num_campos-1:
                        sql=sql+campo+' = "'+dato+'" , '
                    else:
                        sql=sql+campo+' = "'+dato+'"'
                else:
                    if i<self.num_campos-1:
                        sql=sql+campo+' = NULL, '
                    else:
                        sql=sql+campo+' = NULL'            
            sql=sql+' where '+datos_antes
            try:
                self.cursor.execute(sql)   
                #abrir abre la tabla, carga las datos en variables y cierra tabla
                self.abrir()
                #dejamos en pantalla el registro modificado
                self.linea_pos=linea_antes
 
                #quita el estado de edicion de los widgets
                self.estado_consulta() 
                result=True         
            except:
                #error, sacamos dialogo y decimos que comprueben datos
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al grabar datos\n Compruebe datos \n o Cancele")
                md.run()
                md.destroy() 
                result=False
 
        return result
 
    def aplica_alta(self):
        #anota nuevo registro en la tabla
        #aqui salvamos los datos anotados 
        #primero abrimos tabla
 
        self.abre_tabla()
        #correcto, anotamos los nuevos valores
        sql='insert into '+self.tabla+' values ( '
        vacio=True
        for i in range(self.num_campos):
            dato=self.widgets[i].get_text()
            if dato != '':
                vacio=False
                if i<self.num_campos-1:
                    sql=sql+'"'+dato+'" , '
                else:
                    sql=sql+'"'+dato+'" )'
            else:
                if i<self.num_campos-1:
                    sql=sql+' NULL, '
                else:
                    sql=sql+' NULL )'     
        if vacio:
                #error, sacamos dialogo y decimos que comprueben datos
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"No se puede guardar un\n Registro vacio\n")
                md.run()
                md.destroy() 
                return False     
        try:
            self.cursor.execute(sql) 
            result=True 
            self.abrir()
            self.estado_consulta()            
        except:
            #error, sacamos dialogo y decimos que comprueben datos
            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                    gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al grabar datos\n Compruebe datos \n o Cancele")
            md.run()
            md.destroy()  
            result=False             
        return result
 
 
    def borrar(self):
        #primero seleccionamos la fila de la tabla a borrar
        #los datos estan en la variable linea_actual[]
        #hacemos el select con todos los campos, pues no sabemos
        #si hay dos lineas con campos iguales.
        #primero abrimos tabla
        #pero antes guardamos el puntero que llevabamos
        linea_antes=self.linea_pos
        self.abre_tabla()
        datos_antes=''
        for i in range(self.num_campos):
            campo=self.nombre_campos[i]
            dato=str(self.linea_actual[i])
            if dato!='' and dato!='None':
                datos_antes=datos_antes+campo+' = "'+dato+'" AND '  
        datos_antes=str(datos_antes[0:len(datos_antes)-4])    
        sql='select * from '+self.tabla+' where '+datos_antes  
        try:
            self.cursor.execute(sql)
 
        except:
            #error, el registro a modificar tenia valores inconsistentes
            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error en registro\n Debe arreglarlo desde\n Administrador MySQL\n")
            md.run()
            md.destroy() 
            return False
 
        #una vez seleccionada la linea a borrar, comprobamos que es una 
        # y solo una.
        if self.cursor.rowcount != 1:
            #error, sacamos dialogo y decimos que comprueben datos
            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al borrar registro\n Mas de un registro seleccionado\n ")
            md.run()
            md.destroy() 
            return False
        else:
            #correcto, borramos la linea
            sql='delete from '+self.tabla+' where '+datos_antes
 
            try:
                self.cursor.execute(sql)   
                #abrir abre la tabla, carga las datos en variables y cierra tabla
                self.abrir()
                #dejamos en pantalla el registro modificado
                self.linea_pos=linea_antes
                #quita el estado de edicion de los widgets
                self.estado_consulta() 
                result=True         
            except:
                #error, sacamos dialogo y decimos que comprueben datos
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al borrar registro\n Compruebe datos \n o Cancele")
                md.run()
                md.destroy() 
                result=False
 
        return result
 
    def cancelar(self):
        puntero=self.linea_pos
        self.abrir()
        self.linea_pos=puntero
        self.linea_actual=self.datos_tabla[self.linea_pos]        
        self.actualizar()  
        self.estado_consulta() 
        return
 
    def buscar(self,campo,valor):
        for n in range(self.num_campos):
            if campo==self.nombre_campos[n]:
                campo_index= n
        encontrado=False  
        for n in range(len(self.datos_tabla)):
            if self.datos_tabla[n][campo_index]==valor:
                self.linea_actual=self.datos_tabla[n]
                encontrado=True
                self.actualizar()
                break
        return encontrado
 
    def actualizar(self):
            #isinstance(obj, int) 
            for w in self.widgets:
                w.actualizar_widget() 
            self.actualizar_datos_relacionada()
            return True
 
    def estado_consulta(self):
        #pone los widgets en estado de consulta
        self.estado='consultar'
        for w in self.widgets:
            w.set_editable(False)    
 
    def estado_editar(self):
        #pone los widgets en estado de edicion
        self.estado='editar'
        for w in self.widgets:
            w.set_editable(True)
 
    def estado_alta(self):
        #pone los widgets en alta, en blanco
        self.estado='alta'
        for w in self.widgets:
            w.set_text('')
            w.set_editable(True)
 
    def widget_a_tabla(self,widget,campo):
            self.widgets.append(widget)
            result=-1
            for n in range(self.num_campos):
                if campo==self.nombre_campos[n]:
                    result= n
 
            return result
 
    def relacionar(self,campoprop,tablarel,camporel):
        #relaciona otra tabla con esta, recibe, campo propio
        #tabla esclava a relacionar, y campo de la tabla a relacionar
        result=-1
        for n in range(self.num_campos):
            if campoprop==self.nombre_campos[n]:
                result= n
                self.tablas_rel.append(tablarel)
                self.campos_rel.append(n)
                #envia a la tabla peticionaria, la identidad de esta tabla 
                #y el campo de la peticionaria
                tablarel.relacionada(self,camporel)
        return result   
 
    def relacionada(self,trelacion,camporel): 
        self.camporel=camporel
        self.tablarelacion=trelacion
 
    def actualizar_datos_relacionada(self):
            for t in range(len(self.tablas_rel)):
                dato=self.linea_actual[self.campos_rel[t]]
                tabla=self.tablas_rel[t]
                tabla.actualizar_tabla(dato) 
            return True
    def actualizar_tabla(self,dato):
        self.buscar(self.camporel,dato)
 
 
 
 
class DBLabel(gtk.Label):
    #un label enlazado a una tabla y un campo de la misma
    def __init__(self,tabla,campo=None,orden=None,titular=False): 
        #si no nos dan el campo, y se da el orden del campo, 
        #campo=None y orden = n, posicion en la tabla de la columna
        #si titular=True, anteponemos el nombre del campo al label
        gtk.Label.__init__(self)   
        self.tabla=tabla
        self.titular=titular
 
        if campo==None:
            self.campo=self.tabla.nombre_campos[orden]
        else:
            self.campo=campo
 
        res=self.campo_index=tabla.widget_a_tabla(self,self.campo)
        if res==-1:
            #error, campo de tabla no encontrado
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error, campo de tabla \n No existente \n")
                md.run()
                md.destroy() 
        self.titulo=self.campo+' : '                
        self.show()
        self.actualizar_widget()
 
    def set_titulo(self,titulo):
        #pone el nombre que deseemos en titulo, en lugar del nombre del campo
        self.titulo=titulo+' : '
        self.titular=True
 
    def actualizar_widget(self):
 
        texto=self.tabla.linea_actual[self.campo_index]
        if self.titular:
            texto=self.titulo+str(texto)
        self.set_text(str(texto))
 
class DBEntry(gtk.HBox):
    #un label enlazado a una tabla y un campo de la misma
    def __init__(self,tabla,campo=None,orden=None,titular=False): 
        #si no nos dan el campo, y se da el orden del campo, 
        #campo=None y orden = n, posicion en la tabla de la columna
        #si titular=True, anteponemos el nombre del campo al label
        gtk.HBox.__init__(self)   
        self.set_size_request(500,40)
        self.set_homogeneous(False)
        self.entry=gtk.Entry()
        self.entry.set_editable(False)
        self.label=gtk.Label()
        self.pack_start(self.label,False,False,False)
        self.pack_end(self.entry,False,False,False)
        self.entry.show()
        self.label.show()
        self.show()
        self.tabla=tabla
        self.titular=titular
        if campo==None:
            self.campo=self.tabla.nombre_campos[orden]
        else:
            self.campo=campo
        #campo_index lleva el numero de campo en la tabla
        res=self.campo_index=tabla.widget_a_tabla(self,self.campo)
        if res==-1:
            #error, campo de tabla no encontrado
                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error, campo de tabla \n No existente \n")
                md.run()
                md.destroy() 
 
        self.titulo=self.campo+' : '
        #poner anchura adaptada a la del campo
        ancho=tabla.long_campos[self.campo_index]
        self.entry.set_max_length(ancho)
        self.entry.set_width_chars(ancho)
        self.actualizar_widget()
 
    def set_titulo(self,titulo):
        #pone el nombre que deseemos en titulo, en lugar del nombre del campo
        self.titulo=titulo+' : '
        self.titular=True
 
 
    def set_editable(self,estado):
        self.entry.set_editable(estado)
 
    def get_text(self):
        return self.entry.get_text()
 
    def set_text(self,texto):
        self.entry.set_text(texto)
 
    def actualizar_widget(self):
 
        texto=self.tabla.linea_actual[self.campo_index]
        if self.titular:
                self.label.set_text(self.titulo+' : ')
                self.label.set_alignment(0,0.5)  
        self.entry.set_text(str(texto))
 
class Navegador(gtk.HButtonBox):
    def __init__(self,tabla,main=None):
        #conjunto de botones para navegar y actuar sobre la tabla
        gtk.HButtonBox.__init__(self)
        self.main=main
        self.tabla=tabla
        self.estado='consultar'
        self.set_homogeneous(False)
        # METEMOS LOS BOTONES
        self.principio=gtk.Button('<<')
        self.add(self.principio)
        self.principio.connect_object("clicked", self.movimiento, self.principio)
        self.atras=gtk.Button('<')
        self.add(self.atras)
        self.atras.connect_object("clicked", self.movimiento, self.atras)
        self.delante=gtk.Button('>')
        self.add(self.delante)
        self.delante.connect_object("clicked", self.movimiento, self.delante)
        self.fin=gtk.Button('>>')
        self.add(self.fin)
        self.fin.connect_object("clicked", self.movimiento, self.fin)
        self.editar=gtk.Button('Editar')
        self.add(self.editar)
        self.editar.connect_object("clicked", self.control, self.editar)
        self.borrar=gtk.Button('Borrar')
        self.add(self.borrar)
        self.borrar.connect_object("clicked", self.control, self.borrar)
        self.alta=gtk.Button('Alta')
        self.add(self.alta)
        self.alta.connect_object("clicked", self.control, self.alta)
        self.aplicar=gtk.Button('Aplicar')
        self.add(self.aplicar)
        self.aplicar.connect_object("clicked", self.control, self.aplicar)   
        self.cancelar=gtk.Button('Cancelar')
        self.add(self.cancelar)
        self.cancelar.connect_object("clicked", self.control, self.cancelar) 
        if main!=None:
        #crea un toolbar en la ventana que contiene al navegador, 
        #donde representamos el numero de registro visualizado.
            self.lestado=gtk.Label('inicio')  
            labelitem=gtk.ToolItem()
            labelitem.add(self.lestado) 
            self.toolb=gtk.Toolbar()
            self.toolb.insert(labelitem,0)
            main.vbox.pack_start(self.toolb,False,True)  
            self.lestado.show()
            labelitem.show()
            self.toolb.show()  
 
        self.atras.show()
        self.delante.show()
        self.principio.show()
        self.fin.show()
        self.editar.show()
        self.borrar.show()
        self.alta.show()
        self.show()
        self.actualizar_widget()
 
    def actualizar_widget(self):
        if self.tabla.linea_pos==0:
            #primera linea
            inicio=True
            fin=False
        elif self.tabla.linea_pos==len(self.tabla.datos_tabla)-1:
            #ultima linea
            fin=True
            inicio=False
        else: 
            inicio=False
            fin=False  
        if self.tabla.num_lineas==1:
            #solo hay un registro, ni palante ni patras
            inicio=True
            fin=True 
        # oculta los botones que no estan operativos
        if self.estado != 'consultar':
            self.delante.hide()
            self.fin.hide()  
            self.atras.hide()
            self.principio.hide()         
            self.editar.hide()
            self.alta.hide()
            self.borrar.hide()
            self.aplicar.show()
            self.cancelar.show()
            self.cancelar.grab_focus()
            if self.main!=None:
                self.lestado.set_text('Record : '+str(self.tabla.linea_pos)+' estado : '+self.estado)            
        else:
            self.delante.show()
            self.fin.show()
            self.atras.show()
            self.principio.show()       
            self.editar.show()
            self.alta.show()
            self.borrar.show()
            self.aplicar.hide()
            self.cancelar.hide()
 
            if self.main!=None:
                self.lestado.set_text('Record : '+str(self.tabla.linea_pos)) 
            if inicio:
                self.atras.hide()
                self.principio.hide()
                # y anota en el label el numero de record mostrado
                if self.main!=None:
                    self.lestado.set_text('Record : '+str(self.tabla.linea_pos)+' Principio de fichero')            
            if fin:
                self.delante.hide()
                self.fin.hide()
                if self.main!=None:
                    self.lestado.set_text('Record : '+str(self.tabla.linea_pos)+' Fin de fichero')
 
    def movimiento(self,widget):
        if widget==self.delante:
            self.tabla.adelante(widget)
        elif widget==self.atras:
            self.tabla.atras(widget)
        elif widget==self.principio:
            self.tabla.primero(widget)    
        elif widget==self.fin:
            self.tabla.ultimo(widget)  
        self.actualizar_widget()
 
 
    def control(self,widget):
        res=True
        if widget==self.editar:
            self.estado='editar'
            self.tabla.estado_editar()
        elif widget==self.alta:
            self.estado='alta'            
            self.tabla.estado_alta()
        elif widget==self.borrar:
            self.tabla.estado='borrar'
            self.estado='borrar'
        elif widget==self.aplicar:
            if self.estado=='editar':
                #actualiza los datos en la tabla
                res=self.tabla.aplica_edicion()
                if res:
                    self.estado='consultar'
            elif self.estado=='alta':
                res=self.tabla.aplica_alta()
                if res:
                    self.estado='consultar'
            else:
                self.tabla.borrar()
                self.estado='consultar'
 
        elif widget==self.cancelar:
            self.tabla.cancelar()
            self.estado='consultar'
        if res:
            self.actualizar_widget()              
 
 
 
 
 
 

a mi me gusta GTK.
   Saludos : Gaby

Hola algorithm, parece que la recursividad te da un pequeño problema, la iteracion que encuentre el resultado devolvera con return el valor de la raiz, pero he ahi el problema, ¿ a quien le devuelve el valor?, pues a la iteracion anterior que es la que le llamo, y esta se queda con el valor, pues no hay un retorno hacia atras de este resultado.

   una solucion puede ser esta, si te das cuenta la funcion devuelve None o sea nada si no llegamos a la solucion, entonces cuando la solucion se alcance cada iteracion respondera a la anterior con el valor x.

   modifico, no es necesario comprobar la respuesta de las siguientes iteraciones, puesto que no habra respuesta hasta que el resultado sea el esperado.
   Saludos : Gaby

Bueno, aqui va el codigo en python para convertir una expresion infixa, o sea normal, en una con notacion polaca inversa.
                                    

Hola, repasando mensajes por el Foro, he encontrado este post https://foro.elhacker.net/ejercicios/sugerencias-t34838.0.html;msg1229723#msg1229723 de Eliptico, y he recordado los viejos tiempos en los que trabajaba con mi calculadora Hewlett Packard, y la utilización que hacía la misma de la Notación Polaca Inversa, el algoritmo propuesto por Eliptico es la conversion de una expresión dada en notacion infixa a notación prefixa o notacion polaca.
   despues de estar un rato pensando en ella, he estado buscando por la red, y he encontrado este pseudocódigo que sirve para la Notación Polaca Inversa o notación postfixa.
  Lo adjunto y propongo la realización del programa en el lenguaje que deseeis, yo concretamente lo voy a realizar en python, que es el que estoy aprendiendo actualmente.

         Algoritmo para N.P.I. http://es.wikipedia.org/wiki/Algoritmo_shunting_yard

gracias saster, ya lo he resuelto, pero parece que win vista no funciona bien en este tema, con lo facil que es con linux y openoffice.
   Saludos > Gaby

   A ver si algun alma caritativa que sea experto en patch, me dice que hago mal.


Arranca word, con un dialogo que me dice
 " El nombre del documento o la ruta de acceso no son validos."
Hasta ahi correcto, pues no he indicado el documento, seguimos
Arranca Word diciendo lo mismo,
 " El nombre del documento o la ruta de acceso no son validos."
He probado a cambiar de directorio, cambiandolo al que contiene el documento, resultado el mismo.
En fin, que no se que mas hacer.
El S.O. es Vista Home, el Word 2000.
Logicamente las pruebas en consola son porque a la orden que daba desde Python tambien daba el mismo error.
A ver si algun listo me dice que hago mal.

Sin excepciones puede servirte este

#!/usr/bin/python
#Ecuaciones 2 Grado - by xassiz
 
import math
 
print "\n ---------------------------------------"
print "\n #    Ecuaciones 2 Grado    #"
print "\n #        by xassiz                 #"
print "\n #        and Gaby                #"
print "\n ---------------------------------------\n"
 
a = input("\n a = ")
b = input("\n b = ")
c = input("\n c = ")
if b**2 - 4*a*c < 0 :
    #resultado imaginario 
    r=-b/float(2*a)
    i=(math.sqrt(-(b**2-4*a*c)))/(2*a)
    x=complex(r,i)
    print "\n\a x (+) = "+str(x.real)+'+'+str(x.imag)+"j\n"
    print "\n\a x (-) = "+str(x.real)+'-'+str(x.imag)+"j\n"
else:
    #resultado real
    xmas = (-b + math.sqrt(b**2 - 4*a*c))/(2*a)
    xmenos = (-b - math.sqrt(b**2 - 4*a*c))/(2*a)
 
    print "\n\a x (+) = "+str(xmas)+"\n"
    print "\n\a x (-) = "+str(xmenos)+"\n"
 
raw_input()

Bien, voy a especificar mas mi problema, el modulo que intento instalar el el mysql-python-1.2.3c1, que parece ser segun todas las cosas que he mirado, el correspondiente a python 2.6 y windows.
  El primer problema que me encuentro es que en el fichero site.cnf hace referencia a MySQL 5.0, y yo tengo instalado el5.1, eso se resuelve cambiando el valor en el fichero.
  Empieza a instalar correctamente con setup.py build
  Se para cuando intenta construir la extension _mysql, concretamente me dice que no encuentra el fichero config-win.h, este esta definido en el fichero de C
_mysql.c, y este fichero, junto a otros que tembien estan definidos, no los encuentro en ningun sitio. Abajo os pongo la respuesta del programa cuando empieza a fallar.

building '_mysql' extension
creating build\temp.win32-2.6
creating build\temp.win32-2.6\Release
C:\Program Files\Microsoft Visual Studio 9.0\VC\BIN\cl.exe /c /nologo /Ox /MD /W
3 /GS- /DNDEBUG -Dversion_info=(1,2,3,'beta',2) -D__version__=1.2.3b2 "-IC:\Prog
ram Files\MySQL\MySQL Server 5.1\include" -Ic:\python26\include -Ic:\python26\PC
 /Tc_mysql.c /Fobuild\temp.win32-2.6\Release\_mysql.obj /Zl
_mysql.c
_mysql.c(33) : fatal error C1083: Cannot open include file: 'config-win.h': No s
uch file or directory
error: command '"C:\Program Files\Microsoft Visual Studio 9.0\VC\BIN\cl.exe"' fa
iled with exit status 2


   Bueno, si algun experto en packages de python me puede ayudar le estaria muy agradecido.
   Saludos : Gaby