hasNext en iteradores de Python?

Question

¿Los iteradores de Python no tienen un método hasNext?

Answer 1

No, no hay tal método. El final de la iteración está indicado por una excepción. Vea el documentation.

Answer 2

No. El concepto más similar es más probable una StopIteration exception.

Answer 3

creo pitón solo tiene al lado() y de acuerdo con el documento, se produce una excepción es que no hay más elementos.

http://docs.python.org/library/stdtypes.html#iterator-types

Answer 4

hasNext traduce tanto a la StopIteration excepción, por ejemplo:

>>> it = iter("hello") 
>>> it.next() 
'h' 
>>> it.next() 
'e' 
>>> it.next() 
'l' 
>>> it.next() 
'l' 
>>> it.next() 
'o' 
>>> it.next() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
StopIteration 

• StopIteration docs: http://docs.python.org/library/exceptions.html#exceptions.StopIteration
• Algunos artículo sobre iteradores y generador en Python: http://www.ibm.com/developerworks/library/l-pycon.html

Answer 5

Si realmente necesita a has-next funcionalidad (porque simplemente está transcribiendo fielmente un algoritmo de una implementación de referencia en Java, por ejemplo, o porque está escribiendo un prototipo que necesitará debe transcribirse fácilmente a Java cuando esté terminado), es fácil de obtener con una pequeña clase de envoltura. Por ejemplo:

class hn_wrapper(object): 
    def __init__(self, it): 
    self.it = iter(it) 
    self._hasnext = None 
    def __iter__(self): return self 
    def next(self): 
    if self._hasnext: 
     result = self._thenext 
    else: 
     result = next(self.it) 
    self._hasnext = None 
    return result 
    def hasnext(self): 
    if self._hasnext is None: 
     try: self._thenext = next(self.it) 
     except StopIteration: self._hasnext = False 
     else: self._hasnext = True 
    return self._hasnext 

ahora algo así como

x = hn_wrapper('ciao') 
while x.hasnext(): print next(x) 

emite

c 
i 
a 
o 

según sea necesario.

Tenga en cuenta que el uso de next(sel.it) como un built-in requiere Python 2.6 o superior; si está utilizando una versión anterior de Python, use self.it.next() en su lugar (y de manera similar para next(x) en el uso de ejemplo). [[Es razonable pensar que esta nota es redundante, ya que Python 2.6 ha estado presente por más de un año, pero la mayoría de las veces cuando uso las características de Python 2.6 en una respuesta, algunos comentadores u otros se sienten obligados a señalar que son 2.6 características, por lo que estoy tratando de evitar este tipo de comentarios, por una vez ;-)]]

Answer 6

Además de todas las menciones de StopIteration, el pitón bucle "for" simplemente hace lo que quiere:

>>> it = iter("hello") 
>>> for i in it: 
...  print i 
... 
h 
e 
l 
l 
o 

Answer 7

Usted puede tee utilizando el iterador, itertools.tee, y comprobar si hay StopIteration en el iterador juntado con te.

Answer 8

probar el método de __length_hint __() de cualquier objeto iterador:

iter(...).__length_hint__() > 0 

Answer 9

Hay una alternativa a la StopIteration mediante el uso de next(iterator, default_value).

Para exapmle:

>>> a = iter('hi') 
>>> print next(a, None) 
h 
>>> print next(a, None) 
i 
>>> print next(a, None) 
None 

para que pueda detectar por None u otro valor especificado previamente para el final del iterador si no desea que la forma es una excepción.

Answer 10

El caso de uso que me llevan a buscar este es el siguiente

def setfrom(self,f): 
    """Set from iterable f""" 
    fi = iter(f) 
    for i in range(self.n): 
     try: 
      x = next(fi) 
     except StopIteration: 
      fi = iter(f) 
      x = next(fi) 
     self.a[i] = x 

donde está disponible hasNext(), se podría hacer

def setfrom(self,f): 
    """Set from iterable f""" 
    fi = iter(f) 
    for i in range(self.n): 
     if not hasnext(fi): 
      fi = iter(f) # restart 
     self.a[i] = next(fi) 

que para mí es más limpio. Obviamente, puede solucionar los problemas mediante la definición de clases de utilidad, pero lo que sucede es que tiene una proliferación de veintitantas soluciones diferentes casi equivalentes, cada una con sus peculiaridades, y si desea reutilizar el código que utiliza diferentes soluciones, tiene que tener múltiples equivalentes casi equivalentes en su única aplicación, o ir a buscar y reescribir el código para usar el mismo enfoque. La máxima 'hazlo una vez y hazlo bien' falla mucho.

Además, el iterador en sí necesita tener una verificación interna 'hasnext' para ejecutar si necesita generar una excepción. Esta comprobación interna se oculta entonces para que se deba probar tratando de obtener un artículo, capturando la excepción y ejecutando el controlador si se lanza. Esto es innecesario ocultar IMO.

Answer 11

buen enfoque para tales preguntas/problemas es comprobar lo que tenemos en dir (objeto/método/repetidor/tipo/clase/...)

verá que dir(iterator) retorno __length_hint__

y iterator.__length_hint__() es positivo hasta el final de la iteración.

eso es todo.

Answer 12

me gusta esto:

While(True): 
    try: 
     # Do something with the next value 
     iterator.next() 
    except StopIteration: 
     break 

Answer 13

La forma he resuelto mi problema es mantener el recuento del número de objetos repiten a lo largo, hasta el momento. Quería iterar sobre un conjunto usando llamadas a un método de instancia. Como sabía la longitud del conjunto y el número de elementos contados hasta ahora, efectivamente tenía un método hasNext.

Una versión simple de mi código:

class Iterator: 
    # s is a string, say 
    def __init__(self, s): 
     self.s = set(list(s)) 
     self.done = False 
     self.iter = iter(s) 
     self.charCount = 0 

    def next(self): 
     if self.done: 
      return None 
     self.char = next(self.iter) 
     self.charCount += 1 
     self.done = (self.charCount < len(self.s)) 
     return self.char 

    def hasMore(self): 
     return not self.done 

Por supuesto, el ejemplo es uno de juguete, pero se entiende la idea. Esto no funcionará en los casos donde no hay forma de obtener la longitud del iterable, como un generador, etc.