Folosind o suplimentare de variabila de stare, cum ar fi o variabilă index (pe care le-ar folosi în mod normal în limbi, cum ar fi C sau PHP), este considerat non-pythonic.

Cea mai bună opțiune este de a utiliza built-in funcția enumera(), disponibil atât în Python 2 și 3:

for idx, val in enumerate(ints):
    print(idx, val)

Check out PEP 279 pentru mai multe.

Folosind-o pentru buclă, cum nu am acces la bucla index, de la 1 la 5, în acest caz?

Folosesc enumera` pentru a obține indicele cu element ca voi repeta:

for index, item in enumerate(items):
    print(index, item)

Și rețineți că Python's indici începe de la zero, așa că v-ar lua de la 0 la 4 cu cele de mai sus. Dacă vrei să numeri de la 1 la 5, face acest lucru:

for count, item in enumerate(items, start=1):
    print(count, item)

Unidiomatic de control al fluxului

Ceea ce se cere este Pythonic echivalent de următoarele, care este algoritmul de cele mai multe programatori de nivel inferior limbi-ar folosi:

index = 0 # Python's indexarea incepe de la zero pentru element în elemente: # Python's pentru bucle sunt un "pentru fiecare" bucla print(index, element) index += 1

Sau în limbi care nu au un pentru-fiecare bucla:

index = 0 în timp ce indicele < len(elemente): print(index, articole[index]) index += 1

sau, uneori, mai frecvent (dar unidiomatically) a constatat, în Python:

pentru indicele în intervalul(len(elementele)): print(index, articole[index])

Utilizați Enumera Funcția

Python's `enumera funcția reduce dezordine vizuala prin ascunderea de contabilitate pentru indicii, și încapsulare a iterable într-o altă iterable (o enumera obiect) care produce o două-element tuplu de index și elementul original iterable ar oferi. Care arata ca aceasta:

for index, item in enumerate(items, start=0):   # default is zero
    print(index, item)

Acest cod de probă este destul de bine canonice exemplu de diferenta dintre codul care este idiomatice de Python și cod care nu este. Cod Idiomatic este sofisticate (dar nu complicat) Python, scris în modul în care aceasta a fost destinat să fie utilizat. Cod Idiomatic este așteptat de către designeri de limbă, ceea ce înseamnă că, de obicei, acest cod nu este doar mai ușor de citit, dar, de asemenea, mult mai eficient.

Obține un număr

Chiar dacă tu nu't nevoie de indicii ca te duci, dar ai nevoie de un număr de iterații (uneori de dorit), puteți începe cu " 1 " și numărul final va fi conta.

for count, item in enumerate(items, start=1):   # default is zero
    print(item)

print('there were {0} items printed'.format(count))

Contele pare a fi mai mult ceea ce ai de gând să cer (spre deosebire de index) când ai spus că ai vrut de la 1 la 5.

De rupere-l în jos - o pas cu pas explicație

Pentru a sparge aceste exemple jos, spunem că avem o listă de elemente pe care vrem să itera peste, cu un indice:

items = ['a', 'b', 'c', 'd', 'e']

Acum vom trece acest iterable pentru a enumera, creând un enumera obiect:

enumerate_object = enumerate(items) # the enumerate object

Putem scoate primul element din această iterable că ne-ar ajunge într-o buclă cu "next" funcția:

iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)

Și vom vedea vom obține un tuplu de "0", primul indice, și 'un', primul articol:

(0, 'a')

putem folosi ceea ce este menționată ca "secvență despachetarea" pentru a extrage elemente din acest doi-tuplu:

index, item = iteration
#   0,  'a' = (0, 'a') # essentially this.

și când vom inspecta "index", vom găsi că se referă la primul index, 0, și "articol" se referă la primul element, 'un'.

>>> print(index)
0
>>> print(item)
a

Concluzie

• Python indici începe de la zero
• Pentru a obține acești indici de o iterable ca ai repeta peste, utilizați enumera funcția
• Folosind enumera în idiomatice mod (împreună cu tuplu despachetare) creează cod care este mai ușor de citit și întreținut:

Deci, face acest lucru:

for index, item in enumerate(items, start=0):   # Python indexes start at zero
    print(index, item)

L's destul de simplu pentru a începe de la 1, altele decât 0:

for index, item in enumerate(iterable, start=1):
   print index, item

Notă

Important indiciu, deși un pic înșelătoare, deoarece "index" va fi un tuplu` `(idx, element) aici. Bun pentru a merge.

Ca este norma în Python există mai multe moduri de a face acest lucru. În toate exemplele presupune: lst = [1, 2, 3, 4, 5]

1. Folosind enumera (considerat cel mai idiomatice)

pentru index, element enumera(lst):

face lucrurile de care este nevoie aici

Acest lucru este, de asemenea, cea mai sigură opțiune, în opinia mea, pentru că șansa de a merge în infinit recursivitate a fost eliminat. Atât elementul și indexul său sunt deținute în variabile și nu este nevoie să scrie orice cod continuare pentru a accesa elementul.

2. Crearea unei variabile să dețină index (folosind "pentru")

pentru index în intervalul(len(lst)): # sau xrange

va trebui să scrie cod suplimentar pentru a obține elementul

3. Crearea unei variabile să dețină index (folosind în timp ce)

index = 0 în timp ce indicele < len(lst):

va trebui să scrie cod suplimentar pentru a obține elementul

index += 1 # scape recursivitate infinită

4. Există întotdeauna un alt mod

   Așa cum sa explicat mai înainte, există și alte modalități de a face acest lucru, care nu au fost explicate aici și se poate aplica chiar mai mult în alte situații. e.g utilizarea `itertools.lanț cu pentru. Acesta se ocupă de bucle imbricate mai bine decât alte exemple.

Modul de modă veche:

for ix in range(len(ints)):
    print ints[ix]

Lista de înțelegere:

[ (ix, ints[ix]) for ix in range(len(ints))]

>>> ints
[1, 2, 3, 4, 5]
>>> for ix in range(len(ints)): print ints[ix]
... 
1
2
3
4
5
>>> [ (ix, ints[ix]) for ix in range(len(ints))]
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> lc = [ (ix, ints[ix]) for ix in range(len(ints))]
>>> for tup in lc:
...     print tup
... 
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
>>> 

Cel mai rapid mod de a accesa indici de listă în buclă în Python 2.7 este de a utiliza gama metoda pentru liste mici și enumera metoda pentru mediu și mare dimensiune liste.

Vă rugăm să consultați abordări diferite care poate fi folosit pentru a itera peste listă și accesează-valoarea indicelui și lor măsurătorile de performanță (care presupun ca ar fi util pentru tine) în mostre de cod de mai jos:

from timeit import timeit

# Using range
def range_loop(iterable):
    for i in range(len(iterable)):
        1 + iterable[i]

# Using xrange
def xrange_loop(iterable):
    for i in xrange(len(iterable)):
        1 + iterable[i]

# Using enumerate
def enumerate_loop(iterable):
    for i, val in enumerate(iterable):
        1 + val

# Manual indexing
def manual_indexing_loop(iterable):
    index = 0
    for item in iterable:
        1 + item
        index += 1

A se vedea indicatorii de performanță pentru fiecare metoda de mai jos:

from timeit import timeit

def measure(l, number=10000):
print "Measure speed for list with %d items" % len(l)
print "xrange: ", timeit(lambda :xrange_loop(l), number=number)
print "range: ", timeit(lambda :range_loop(l), number=number)
print "enumerate: ", timeit(lambda :enumerate_loop(l), number=number)
print "manual_indexing: ", timeit(lambda :manual_indexing_loop(l), number=number)

measure(range(1000))
# Measure speed for list with 1000 items
# xrange:  0.758321046829
# range:  0.701184988022
# enumerate:  0.724966049194
# manual_indexing:  0.894635915756

measure(range(10000))
# Measure speed for list with 100000 items
# xrange:  81.4756360054
# range:  75.0172479153
# enumerate:  74.687623024
# manual_indexing:  91.6308541298

measure(range(10000000), number=100)
# Measure speed for list with 10000000 items
# xrange:  82.267786026
# range:  84.0493988991
# enumerate:  78.0344707966
# manual_indexing:  95.0491430759

Ca urmare, folosind "gama" metodă este cel mai rapid de până la lista cu 1000 de articole. Pentru lista cu dimensiunea > 10 000 de articole enumera este câștigătorul.

Adăugarea unor link-uri utile de mai jos:

• https://stackoverflow.com/questions/94935/what-is-the-difference-between-range-and-xrange-functions-in-python-2-x

• https://stackoverflow.com/questions/4852944/what-is-faster-for-loop-using-enumerate-or-for-loop-using-xrange-in-python

• https://stackoverflow.com/questions/11990105/rangelenlist-or-enumeratelist

Mai întâi de toate, indicii vor fi de la 0 la 4. Limbaje de programare începe numărarea de la 0; don't uitați că sau va veni peste un index out of bounds excepție. Tot ce ai nevoie în bucla for este o variabilă de numărare de la 0 la 4 astfel:

for x in range(0, 5):

Păstrați în minte că am scris de la 0 la 5 pentru că bucla se opreste un număr înainte de max. :)

Pentru a obține valoarea unui indice de utilizare

list[index]

În conformitate cu această discuție: http://bytes.com/topic/python/answers/464012-objects-list-index

Bucla contra repetare

Actualul idiom pentru looping pe indici face uz de built-in "gama" funcția:

for i in range(len(sequence)):
    # work with index i

Looping peste ambele elemente și indicii poate fi realizat fie prin vechiul idiom sau prin utilizarea noilor " zip " built-in funcția:

for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e

sau

for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e

prin http://www.python.org/dev/peps/pep-0212/

Puteți face cu acest cod:

ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value

Utilizați acest cod dacă aveți nevoie pentru a reseta valoarea indicelui la sfârșitul buclei:

ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0

Cel mai bun soluție pentru această problemă este de a utiliza enumera in-build python funcție.
enumera revenirea tuplu
prima valoare este index
a doua valoare este element de matrice la care indicele de

In [1]: ints = [8, 23, 45, 12, 78]

In [2]: for idx, val in enumerate(ints):
   ...:         print(idx, val)
   ...:     
(0, 8)
(1, 23)
(2, 45)
(3, 12)
(4, 78)

Aici's ceea ce veți obține atunci când te're accesarea index în "pentru" bucle:

pentru că în a enumera(elemente): print(i)

pentru că eu, val in enumera(elemente): print(i, val)

pentru că eu, val in enumera(elemente): print(i)

Sper că acest lucru vă ajută.

Dacă am fost pentru a itera nums = [1, 2, 3, 4, 5] mi-ar face

for i, num in enumerate(nums, start=1):
    print(i, num)

Sau pentru a obține lungimea l = len(nums)`

for i in range(1, l + 1):
    print(i, nums[i])

Dacă nu există duplicate valoare din listă:

for i in ints:
    indx = ints.index(i)
    print(i, indx)

Puteți, de asemenea, încercați acest lucru:

data = ['itemA.ABC', 'itemB.defg', 'itemC.drug', 'itemD.ashok']
x = []
for (i, item) in enumerate(data):
      a = (i, str(item).split('.'))
      x.append(a)
for index, value in x:
     print(index, value)

De ieșire este

0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']

În întrebarea dumneavoastră, puteți scrie "cum nu am acces la bucla index, de la 1 la 5, în acest caz?"

Cu toate acestea, indicele pentru o listă ruleaza de la zero. Deci, atunci am nevoie să știu dacă ceea ce vrei de fapt este indicele și element pentru fiecare element într-o listă, sau dacă doriți într-adevăr numere pornind de la 1. Din fericire, în Python, este ușor de a face una sau ambele.

În primul rând, pentru a clarifica, `enumera funcția iterativ se întoarce indicele și elementul corespunzător pentru fiecare element într-o listă.

alist = [1, 2, 3, 4, 5]

for n, a in enumerate(alist):
    print("%d %d" % (n, a))

Ieșire pentru cele de mai sus este apoi, `nimic 0 1 1 2 2 3 3 4 4 5 `` Observați că indicele se execută de la 0. Acest tip de indexare este comun printre limbajele de programare moderne, inclusiv Python și C.

Dacă doriți buclă la interval de o parte din listă, puteți utiliza standard de Python sintaxa pentru o parte din listă. De exemplu, la bucla de la cel de-al doilea element într-o listă până la ultimul element, ai putea folosi

for n, a in enumerate(alist[1:-1]):
    print("%d %d" % (n, a))

Rețineți că, încă o dată, indicele de producție se execută de la 0, nimic 0 2 1 3 2 4 `` Asta ne aduce la start=n comutatorul pentru a enumera()`. Acest lucru pur și simplu compensează index, puteți echivalent pur și simplu adăugați un număr index în interiorul buclei.

for n, a in enumerate(alist, start=1):
    print("%d %d" % (n, a))

pentru care ieșirea este `nimic 1 1 2 2 3 3 4 4 5 5 ``

Puteți utiliza "index" metoda

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]

EDIT Evidențiate în comentariu că această metodă nu funcționează dacă există duplicate în int, metoda de mai jos ar trebui să funcționeze pentru orice valori int:

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]

Sau, alternativ

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]

dacă doriți să obțineți atât index și valoare în int ca o listă de tupluri.

Se folosește metoda de `enumera în selectat răspunsul la această întrebare, dar cu lista de înțelegere, făcându-l mai rapid cu mai puțin cod.

Pentru a imprima tuplu de (index, valoare) în lista de înțelegere, folosind-o pentru buclă:

ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

Ieșire:

[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]

Acest lucru servește scopului destul de bine:

list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
    print('index:', list1.index(x), 'value:', x)