hasNext dans les itérateurs Python?

Les itérateurs Python n'ont-ils pas de hasNextméthode?

Non, une telle méthode n'existe pas. La fin de l'itération est indiquée par une exception. Consultez la documentation .

Il existe une alternative à l' StopIterationutilisation de next(iterator, default_value).

Par exemple:

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

Ainsi, vous pouvez détecter pour Noneou toute autre valeur pré-spécifiée pour la fin de l'itérateur si vous ne voulez pas la manière d'exception.

Si vous avez vraiment besoin d' une has-nextfonctionnalité (parce que vous ne faites que transcrire fidèlement un algorithme à partir d'une implémentation de référence en Java, par exemple, ou parce que vous écrivez un prototype qui devra être facilement transcrit en Java une fois terminé), il est facile de obtenez-le avec une petite classe wrapper. Par exemple:

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

maintenant quelque chose comme

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

émet

c
i
a
o

comme demandé.

Notez que l'utilisation de next(sel.it)comme élément intégré nécessite Python 2.6 ou supérieur; si vous utilisez une ancienne version de Python, utilisez à la self.it.next()place (et de la même manière next(x)dans l'exemple d'utilisation). [[Vous pourriez raisonnablement penser que cette note est redondante, puisque Python 2.6 existe depuis plus d'un an maintenant - mais plus souvent qu'autrement lorsque j'utilise les fonctionnalités de Python 2.6 dans une réponse, certains commentateurs ou autres se sentent obligés de signaler qu'il s'agit de fonctionnalités 2.6, j'essaye donc de prévenir de tels commentaires pour une fois ;-)]]

En plus de toutes les mentions de StopIteration, la boucle Python "for" fait simplement ce que vous voulez:

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

Essayez la méthode __length_hint __ () à partir de n'importe quel objet itérateur:

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

hasNextse traduit quelque peu par l' StopIterationexception, par exemple:

>>> 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

• StopIterationdocs: http://docs.python.org/library/exceptions.html#exceptions.StopIteration
• Un article sur les itérateurs et le générateur en python: http://www.ibm.com/developerworks/library/l-pycon.html

Vous pouvez teel'itérateur à l'aide de, itertools.teeet vérifier StopIterationsur l'itérateur teed.

Non. Le concept le plus similaire est probablement une exception StopIteration.

Je crois que python a juste next () et selon la doc, il lève une exception est qu'il n'y a plus d'éléments.

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

Le cas d'utilisation qui m'a conduit à rechercher ceci est le suivant

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 

où hasnext () est disponible, on pourrait faire

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)

ce qui pour moi est plus propre. De toute évidence, vous pouvez contourner les problèmes en définissant des classes d'utilitaires, mais ce qui se passe alors, c'est que vous avez une prolifération de vingt solutions de contournement presque équivalentes différentes, chacune avec leurs bizarreries, et si vous souhaitez réutiliser du code qui utilise différentes solutions de contournement, vous devez soit avoir plusieurs quasi-équivalents dans votre application unique, ou parcourir et réécrire du code pour utiliser la même approche. La maxime «faites-le une fois et faites-le bien» échoue gravement.

De plus, l'itérateur lui-même a besoin d'une vérification interne 'hasnext' pour s'exécuter pour voir s'il a besoin de lever une exception. Cette vérification interne est ensuite masquée afin qu'elle doive être testée en essayant d'obtenir un élément, en interceptant l'exception et en exécutant le gestionnaire s'il est levé. Il s'agit de cacher l'OMI inutile.

La méthode suggérée est StopIteration . S'il vous plaît voir l'exemple Fibonacci de tutorialspoint

#!usr/bin/python3

import sys
def fibonacci(n): #generator function
   a, b, counter = 0, 1, 0
   while True:
      if (counter > n): 
         return
      yield a
      a, b = b, a + b
      counter += 1
f = fibonacci(5) #f is iterator object

while True:
   try:
      print (next(f), end=" ")
   except StopIteration:
      sys.exit()

La façon dont j'ai résolu mon problème est de garder le décompte du nombre d'objets itérés jusqu'à présent. Je voulais parcourir un ensemble en utilisant des appels à une méthode d'instance. Puisque je connaissais la longueur de l'ensemble et le nombre d'articles comptés jusqu'à présent, j'avais effectivement unhasNext méthode.

Une version simple de mon code:

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

Bien sûr, l'exemple est un jouet, mais vous voyez l'idée. Cela ne fonctionnera pas dans les cas où il n'y a aucun moyen d'obtenir la longueur de l'itérable, comme un générateur, etc.