Używając pętli for, jak uzyskać dostęp do indeksu pętli, w tym przypadku od 1 do 5?

Użyj enumerate, aby uzyskać Indeks z elementem podczas iteracji:

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

I zauważ, że indeksy Pythona zaczynają się od zera, więc dostaniesz od 0 do 4 z powyższym. Jeśli chcesz liczyć, od 1 do 5, zrób to:

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

Unidiomatic control flow

To, o co prosisz, to Pythoniczny odpowiednik poniższego, który jest algorytmem większości programistów języki niższego szczebla używałyby:

index = 0            # Python's indexing starts at zero
for item in items:   # Python's for loops are a "for each" loop 
    print(index, item)
    index += 1

Lub w językach, które nie mają pętli for-each:

index = 0
while index < len(items):
    print(index, items[index])
    index += 1

Lub czasami częściej (ale unidiomatycznie) spotykane w Pythonie:

for index in range(len(items)):
    print(index, items[index])

Użyj funkcji Enumerate

Python ' s enumerate funkcja zmniejsza bałagan wizualny, ukrywając księgowanie indeksów i zamykając iterable w innym iterable (obiekt enumerate), który daje krotkę dwu-elementową indeksu i pozycji, którą dostarczy oryginalna iterable. To wygląda tak:

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

Ta próbka kodu jest dość dobrze kanonicznym przykładem różnicy między kodem, który jest idiomatyczny w Pythonie a kodem, który nie jest. Kod idiomatyczny to zaawansowany (ale nie skomplikowany) Python, napisany w sposób, w jaki miał być używany. Kod idiomatyczny jest oczekiwany przez projektantów języka, co oznacza, że zwykle kod ten jest nie tylko bardziej czytelny, ale również bardziej wydajne.

Liczenie

Nawet jeśli nie potrzebujesz indeksów, ale potrzebujesz liczby iteracji (czasami pożądanej), możesz zacząć od 1, a ostateczna liczba będzie twoją liczbą.

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

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

Licznik wydaje się być bardziej tym, o co zamierzasz poprosić (w przeciwieństwie do indeksu), gdy powiedziałeś, że chcesz od 1 do 5.

Breaking it down-wyjaśnienie krok po kroku

Aby podzielić te przykłady, powiedzmy, że mamy listę elementy, które chcemy iterować z indeksem:

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

Teraz przekazujemy to iterowalne do enumerate, tworząc obiekt enumerate:

enumerate_object = enumerate(items) # the enumerate object

Możemy wyciągnąć pierwszy element z tego iterowalnego, który otrzymamy w pętli z next funkcją:

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

I widzimy, że otrzymujemy krotkę 0, pierwszy indeks, i 'a', pierwszy element:

(0, 'a')

Możemy użyć czegoś, co nazywa się " Sekwencja rozpakowywania ", aby wyodrębnić elementy z tego dwie krotki:

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

I kiedy sprawdzamy index, znajdujemy, że odnosi się do pierwszego indeksu, 0, a item odnosi się do pierwszego elementu, 'a'.

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

Podsumowanie

• indeksy Pythona zaczynają się od zera
• aby uzyskać te indeksy z iterowalnego w miarę iteracji, użyj funkcji enumerate
• użycie enumerate w idiomatyczny sposób (wraz z rozpakowywaniem krotki) tworzy kod, który jest bardziej czytelny i możliwy do utrzymania:

So do to:

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

Jest to dość proste, aby rozpocząć go z 1 INNE niż 0:

for index, item in enumerate(iterable, start=1):
   print index, item  # Used to print in python<3.x
   print(index, item) # Mirate print() after 3.x+
   

for i in range(len(ints)):
   print i, ints[i]

Jak to jest normą w Pythonie jest kilka sposobów, aby to zrobić. We wszystkich przykładach Załóżmy: lst = [1, 2, 3, 4, 5]

1. Użycie enumerate (uważane za najbardziej idiomatyczne )

for index, element in enumerate(lst):
    # do the things that need doing here

Jest to również najbezpieczniejsza opcja moim zdaniem, ponieważ szansa wejścia w nieskończoną rekurencję została wyeliminowana. Zarówno pozycja, jak i jej indeks są utrzymywane w zmiennych i nie ma potrzeby pisania dalszego kodu aby uzyskać dostęp do elementu.

2. Tworzenie zmiennej do przechowywania indeksu ( za pomocą for)

for index in range(len(lst)):   # or xrange
    # you will have to write extra code to get the element

3. Tworzenie zmiennej do przechowywania indeksu ( za pomocą while)

index = 0
while index < len(lst):
    # you will have to write extra code to get the element
    index += 1  # escape infinite recursion

4. Zawsze jest inny sposób

Jak wyjaśniono wcześniej, istnieją inne sposoby, aby to zrobić, które nie zostały tutaj wyjaśnione i mogą być nawet stosowane więcej w innych sytuacjach. np używając itertools.chain Z for. Obsługuje zagnieżdżone pętle lepiej niż w innych przykładach.

Dostęp do indeksów i benchmarkingu wydajności podejść

Najszybszym sposobem dostępu do indeksów list w pętli w Pythonie 3.7jest użycie metody enumerate dla małych, średnich i dużych list.

Zobacz różne podejścia , które mogą być używane do iteracji wartości indeksu list i access oraz ich wskaźników wydajności (co przypuszczam, że byłoby dla Ciebie przydatne) w przykładach kodu poniżej:

# Using range
def range_loop(iterable):
    for i in range(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

Zobacz wskaźniki wydajności dla każdego metoda poniżej:

from timeit import timeit

def measure(l, number=10000):
    print("Measure speed for list with %d items" % len(l))
    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 speed for list with 1000 items
measure(range(1000))
# range:  1.161622366
# enumerate:  0.5661940879999996
# manual_indexing:  0.610455682

# Measure speed for list with 100000 items
measure(range(10000))
# range:  11.794482958
# enumerate:  6.197628574000001
# manual_indexing:  6.935181098000001

# Measure speed for list with 10000000 items
measure(range(10000000), number=100)
# range:  121.416859069
# enumerate:  62.718909123
# manual_indexing:  69.59575057400002

W rezultacie użycie metody enumerate jest najszybszą metodą iteracji, gdy potrzebny jest indeks.

Dodanie kilku przydatnych linków poniżej:

• Jaka jest różnica między funkcjami range i xrange w Pythonie 2.X?

• co jest szybsze dla pętli za pomocą enumerate lub dla pętli za pomocą xrange w Pythonie?

• range(len (list)) lub enumerate (lista)?

Old fashioned way:

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

Spis treści:

[ (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)
>>> 

Po pierwsze, indeksy będą wynosić od 0 do 4. Języki programowania zaczynają liczyć od 0; nie zapominaj o tym, bo natkniesz się na wyjątek indeksu poza granicami. Wszystko czego potrzebujesz w pętli for to zmienna licząca od 0 do 4 w ten sposób:

for x in range(0, 5):

Należy pamiętać, że napisałem 0 do 5, ponieważ pętla zatrzymuje jeden numer przed Max. :)

Aby uzyskać wartość indeksu użyj

list[index]

Oto, co otrzymasz, gdy uzyskasz dostęp do indeksu w pętlach for:

for i in enumerate(items): print(i)

items = [8, 23, 45, 12, 78]

for i in enumerate(items):
    print("index/value", i)

Wynik:

# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)

for i, val in enumerate(items): print(i, val)

items = [8, 23, 45, 12, 78]

for i, val in enumerate(items):
    print("index", i, "for value", val)

Wynik:

# index 0 for value 8
# index 1 for value 23
# index 2 for value 45
# index 3 for value 12
# index 4 for value 78

for i, val in enumerate(items): print(i)

items = [8, 23, 45, 12, 78]

for i, val in enumerate(items):
    print("index", i)

Wynik:

# index 0
# index 1
# index 2
# index 3
# index 4

Zgodnie z tą dyskusją: http://bytes.com/topic/python/answers/464012-objects-list-index

Iteracja licznika pętli

Obecny idiom do zapętlania indeksów wykorzystuje wbudowaną funkcję range:

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

Zapętlenie zarówno elementów, jak i indeksów można uzyskać za pomocą starego idiomu lub za pomocą nowej wbudowanej funkcji zip:

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

Lub

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

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

Możesz to zrobić za pomocą tego kodu:

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

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

Użyj tego kodu, jeśli chcesz zresetować wartość indeksu na końcu pętli:

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

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

Najlepszym rozwiązaniem tego problemu jest użycie enumerate wbudowanej funkcji Pythona.
wylicz return tuple
pierwsza wartość to index
druga wartość to element tablicy o tym indeksie

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)

Gdybym miał iterację nums = [1, 2, 3, 4, 5] zrobiłbym

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

Lub uzyskaj długość jako l = len(nums)

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

W twoim pytaniu piszesz "Jak uzyskać dostęp do indeksu pętli, w tym przypadku od 1 do 5?"

Jednak indeks dla listy biegnie od zera. Tak więc musimy wiedzieć, czy to, co naprawdę chcesz, to indeks i pozycja dla każdego elementu na liście, czy naprawdę chcesz liczby zaczynające się od 1. Na szczęście w Pythonie łatwo jest zrobić jedno lub oba.

Najpierw, dla wyjaśnienia, funkcja enumerate iteracyjnie zwraca indeks i odpowiadający mu element dla każdego elementu w lista.

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

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

Wyjście dla powyższego jest wtedy,

0 1
1 2
2 3
3 4
4 5

Zauważ, że indeks działa od 0. Ten rodzaj indeksowania jest powszechny wśród współczesnych języków programowania, w tym Pythona i C. {]}

Jeśli chcesz, aby Twoja pętla obejmowała część listy, możesz użyć standardowej składni Pythona dla części listy. Na przykład, aby zapętlić od drugiego elementu na liście do ostatniego elementu, ale nie włączając go, możesz użyć

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

Zauważ, że po raz kolejny indeks wyjściowy działa od 0,

0 2
1 3
2 4

To prowadzi nas do start=n przełącznika na enumerate(). To po prostu przesuwa indeks, możesz po prostu dodać liczbę do indeksu wewnątrz pętli.

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

Dla których wyjście jest

1 1
2 2
3 3
4 4
5 5

Jeśli na liście nie ma zduplikowanej wartości:

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

Możesz również spróbować tego:

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)

Wyjście To

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

Możesz użyć metody index

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

EDIT Zaznaczone w komentarzu, że ta metoda nie działa, jeśli w ints są duplikaty, metoda poniżej powinna działać dla dowolnych wartości w ints:

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

Lub alternatywnie

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

Jeśli chcesz uzyskać zarówno indeks, jak i wartość w ints jako listę krotek.

Używa metody enumerate w wybranej odpowiedzi na to pytanie, ale ze zrozumieniem listy, dzięki czemu jest szybsza przy mniejszej ilości kodu.

Prosta odpowiedź za pomocą pętli While:

arr = [8, 23, 45, 12, 78]
i = 0
while i < len(arr):
    print("Item ", i + 1, " = ", arr[i])
    i += 1

Wyjście:

Aby wydrukować krotkę (indeks, wartość) w zrozumieniu listy za pomocą pętli for:

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

Wyjście:

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

To służy celowi wystarczająco dobrze:

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