Sto usando Python 2.5, voglio un'enumerazione simile (a partire da 1 anziché 0):

[(1, 2000), (2, 2001), (3, 2002), (4, 2003), (5, 2004)]

So che in Python 2.6 puoi fare: h = enumerate (range (2000, 2005), 1) per dare il risultato sopra ma in python2.5 non puoi ...

Utilizzando python2.5:

>>> h = enumerate(range(2000, 2005))
>>> [x for x in h]
[(0, 2000), (1, 2001), (2, 2002), (3, 2003), (4, 2004)]

Qualcuno conosce un modo per ottenere il risultato desiderato in Python 2.5?

Grazie,

Jeff

Come hai già detto, questo è semplice da fare in Python 2.6 o versioni successive:

enumerate(range(2000, 2005), 1)

Python 2.5 e versioni precedenti non supportano il startparametro, quindi è possibile creare due oggetti intervallo e comprimerli:

r = xrange(2000, 2005)
r2 = xrange(1, len(r) + 1)
h = zip(r2, r)
print h

Risultato:

[(1, 2000), (2, 2001), (3, 2002), (4, 2003), (5, 2004)]

Se si desidera creare un generatore anziché un elenco, è possibile utilizzare invece izip .

Solo per metterlo qui per amor dei posteri, in 2.6 è stato aggiunto il parametro "start" per enumerare in questo modo:

enumerate(sequence, start=1)

Facile, basta definire la tua funzione che fa quello che vuoi:

def enum(seq, start=0):
    for i, x in enumerate(seq):
        yield i+start, x

Python 3

Documentazione ufficiale: enumerate(iterable, start=0)

Quindi lo useresti in questo modo:

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Il modo più semplice di fare in Python 2.5 esattamente quello che chiedi:

import itertools as it

... it.izip(it.count(1), xrange(2000, 2005)) ...

Se vuoi un elenco, come sembri, usa zipal posto di it.izip.

(A proposito, come regola generale, il modo migliore per creare un elenco da un generatore o da qualsiasi altra X iterabile non è [x for x in X], ma piuttosto list(X)).

from itertools import count, izip

def enumerate(L, n=0):
    return izip( count(n), L)

# if 2.5 has no count
def count(n=0):
    while True:
        yield n
        n+=1

Adesso h = list(enumerate(xrange(2000, 2005), 1))funziona.

enumerare è banale, quindi lo sta implementando nuovamente per accettare un inizio:

def enumerate(iterable, start = 0):
    n = start
    for i in iterable:
        yield n, i
        n += 1

Nota che questo non rompe il codice usando enumerate senza argomento start. In alternativa, questo oneliner può essere più elegante e forse più veloce, ma rompe altri usi di enumerare:

enumerate = ((index+1, item) for index, item)

Quest'ultima era pura assurdità. @Duncan ha capito bene l'involucro.

>>> list(enumerate(range(1999, 2005)))[1:]
[(1, 2000), (2, 2001), (3, 2002), (4, 2003), (5, 2004)]

h = [(i + 1, x) for i, x in enumerate(xrange(2000, 2005))]

Ok, mi sento un po 'stupido qui ... qual è il motivo per non farlo con qualcosa del genere
[(a+1,b) for (a,b) in enumerate(r)]? Se non funzionerai, nessun problema neanche:

>>> r = range(2000, 2005)
>>> [(a+1,b) for (a,b) in enumerate(r)]
[(1, 2000), (2, 2001), (3, 2002), (4, 2003), (5, 2004)]

>>> enumerate1 = lambda r:((a+1,b) for (a,b) in enumerate(r)) 

>>> list(enumerate1(range(2000,2005)))   # note - generator just like original enumerate()
[(1, 2000), (2, 2001), (3, 2002), (4, 2003), (5, 2004)]

>>> h = enumerate(range(2000, 2005))
>>> [(tup[0]+1, tup[1]) for tup in h]
[(1, 2000), (2, 2001), (3, 2002), (4, 2003), (5, 2004)]

Poiché questo è in qualche modo dettagliato, ti consiglio di scrivere la tua funzione per generalizzarla:

def enumerate_at(xs, start):
    return ((tup[0]+start, tup[1]) for tup in enumerate(xs))

Non so come questi post potrebbero essere resi più complicati di quanto segue:

# Just pass the start argument to enumerate ...
for i,word in enumerate(allWords, 1):
    word2idx[word]=i
    idx2word[i]=word