Bonjour bonjour
 
J'ai besoin de traiter un tableau 2 par 2. J'ai donc imaginé l'algo suivant

 
Bon, ça marche mais je me demandais s'il n'y avait pas un moyen plus élégant de faire ça...
 
Autre question: sur un dictionnaire, est-on assuré que les éléments se trouvent dans l'ordre dans lequel ils ont été insérés ???

un truc du genre ?
 

class with_index(object):
    def __init__(self, iterable_object):
        self.obj = iterable_object
 
    def __getitem__(self, index):
        return (index, self.obj[index])
 
 
 
if __name__ == '__main__':
    def run(x):
        for i, o in with_index(x):
            print "%d -> %s" % (i, repr(o))
 
 
    run(['a', 'b', 'c'])
    run((1, 2, 3))
    run('foobar')

 
concernant l'autre question, non, les dictionnaires ne sont pas ordonnés

class with_index(object):
    def __init__(self, iterable_object):
        self.obj = iterable_object
 
    def __getitem__(self, index):
        return (index, self.obj[index])
 
 
 
if __name__ == '__main__':
    def run(x):
        for i, o in with_index(x):
            print "%d -> %s" % (i, repr(o))
 
 
    run(['a', 'b', 'c'])
    run((1, 2, 3))
    run('foobar')

C'est sympa d'avoir répondu si vite mais t'as pas bien compris mon problème...
Ton objet (que je trouve très sympa) renvoie l'index de l'élément et l'élément lui-même. Bon c'est aussi un truc à garder dans un coin mais mon besoin est différent
Moi, j'ai besoin d'un truc qui, si je lui passe "azerty", me renvoie
a, z
z, e
e, r
r, t
t, y
y, a
Mais bon, comme je l'ai dit au début, mon algo le fait. Sauf que je le trouve lourd (récupérer l'index "i" de l'élément en cours pour accéder à l'élément [i+1])...
 

Ok merci. Ca m'embête un peu mais bon, me suffit de rajouter dans mon dico l'ordre de création et faire un tri sur ce critère et pis basta.

bha avec mon objet, tu fait juste un i+1 pour récupérer l'element suivant
 
tu peux aussi te baser sur mon idée et tu obtiens ceci

class by_two(object):
    def __init__(self, iterable_object):
        self.obj = iterable_object
    
    def __getitem__(self, index):
        index2 = (index <> len(self.obj)-1) and (index + 1) or 0
        return (self.obj[index], self.obj[index2])
 
 
if __name__ == '__main__':
    def run(x):
        for o, p in by_two(x):
            print "%s - %s" % (repr(o), repr(p))
 
 
    run(['a', 'b', 'c'])
    run((1, 2, 3))
    run('foobar')

class by_two(object):
    def __init__(self, iterable_object):
        self.obj = iterable_object
    
    def __getitem__(self, index):
        index2 = (index <> len(self.obj)-1) and (index + 1) or 0
        return (self.obj[index], self.obj[index2])
 
 
if __name__ == '__main__':
    def run(x):
        for o, p in by_two(x):
            print "%s - %s" % (repr(o), repr(p))
 
 
    run(['a', 'b', 'c'])
    run((1, 2, 3))
    run('foobar')

 
C'est géant. Tu redéfinis l'opérateur [n] pour qu'il renvoie l'élément [n] et [n + 1]. Trop simple quand on maîtrise !!!    
 
Merci    

Sinon, il est possible de faire ça en utilisant itertools.cycle & zip:

# hop
 
    >>> from itertools import cycle
    >>> items = "azerty"
 
    >>> def cycle1(iterable):
    ...     c = cycle(iterable)
    ...     c.next()
    ...     return c
 
    >>> zip(items, cycle1(items))
    [('a', 'z'), ('z', 'e'), ('e', 'r'), ('r', 't'), ('t', 'y'), ('y', 'a')]
 
    >>> for i, j in zip(items, cycle1(items)):
    ...     print "%s - %s"%(i, j)
    a - z
    z - e
    e - r
    r - t
    t - y
    y - a

(c'est un script doctest valide normalement)

merci pour l'info...

?