el uso de stacks de python 3 para garantizar que los símbolos coincidan en pares correctos y que los tipos de símbolos coincidan también

def spc(sym): stk1=myStack() stkall=myStack() for i in sym: if i not in stk1: stk1.push(i) else: stkall.push(i) for j in stk1: for k in stkall: if j==k: stk1.pop(j) stkall.pop(k) else: pass if len(stk1) == len(stkall): print("all symbols match") else: print(("these symbols, %s, have no matches")%(stkall)) 

El código de arriba me da este error
“TypeError: el argumento de tipo ‘myStack’ no es iterable”

Pero lo arreglé por la respuesta de @SergeBallesta. Después edité el código para que se vea como ves ahora.

Ahora estoy recibiendo este error:

“return self.container.pop (item) # pop del contenedor, esto se solucionó desde la versión anterior que no era correcta TypeError: el objeto ‘str’ no se puede interpretar como un número entero”

Lo que quiero lograr es que los paréntesis y todos los símbolos estén correctamente equilibrados, ya que no solo cada símbolo de apertura tiene un símbolo de cierre correspondiente, sino que también los tipos de símbolos coinciden.

El código para mi clase de stack está abajo. Por favor ayude a implementar esto usando STACKS

 class myStack: def __init__(self): self.container = [] def isEmpty(self): return self.size() == 0 def push(self, item): self.container.append(item def pop(self, item): return self.container.pop(item) def size(self): return len(self.container) # length of the container def __iter__(self): return iter(self.container) 

Related of "el uso de stacks de python 3 para garantizar que los símbolos coincidan en pares correctos y que los tipos de símbolos coincidan también"

Estas líneas

 if i not in stk1: 

y

 for j in stk1: 

requiere que myStack sea iterable . En Python significa que tendrá un método __iter__ que devuelve un iterador en sus objetos. Como ya tiene un contenedor interno, el método __iter__ puede ser tan simple como:

 class myStack: ... def __iter__(self): return iter(self.container) 

Para realizar la validación de corchetes utilizando una stack, solo necesitamos una stack. Cuando nos encontramos con los soportes de apertura, los colocamos en la stack. Cuando nos encontramos con un soporte de cierre, sacamos el soporte de apertura superior de la stack y comparamos los dos. Si son del mismo tipo de corchete, continuamos, de lo contrario, la cadena no es válida. Si alguna vez intentamos abrir una stack vacía, la cadena no es válida. Si llegamos al final de la cadena sin borrar la stack, la cadena no es válida.

 opening = '[{<(' closing = ']}>)' d = dict(zip(opening, closing)) def validate(s): stack = [] for c in s: if c in opening: stack.append(c) elif c in closing: if not stack: # tried to pop empty stack return False popped = stack.pop() if d[popped] != c: # bracket mismatch return False return not stack