for 루프를 사용하면이 경우 1에서 5까지 루프 인덱스에 어떻게 액세스합니까?

enumerate반복 할 때 요소가있는 색인을 얻는 데 사용하십시오 .

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

그리고 파이썬의 인덱스는 0에서 시작하므로 위와 같이 0에서 4를 얻습니다. 1에서 5까지의 개수를 원하면 다음을 수행하십시오.

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

단일 제어 흐름

당신이 요구하는 것은 다음과 같은 Pythonic과 같습니다.이 언어는 대부분의 저급 언어 프로그래머가 사용할 알고리즘입니다.

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

또는 for-each 루프가없는 언어로 :

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

또는 때로는 파이썬에서 더 일반적으로 (그러나 관용적으로) 발견됩니다.

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

열거 함수 사용

파이썬의 enumerate함수 는 인덱스에 대한 설명을 숨기고 이터 러블을 다른 iterable ( enumerate객체) 로 캡슐화하여 인덱스 의 두 항목 튜플과 원래 iterable이 제공 할 항목을 생성하는 이터 러블을 캡슐화함으로써 시각적 혼란을 줄입니다. 이것은 다음과 같습니다

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

이 코드 샘플은 파이썬의 관용적 코드와 그렇지 않은 코드의 차이점에 대한 표준 예입니다. 관용적 코드는 정교하지만 (복잡하지는 않지만) 파이썬으로, 의도 된 방식으로 작성되었습니다. 관용어는 언어 설계자에 의해 예상됩니다. 즉, 일반적으로이 코드는 더 읽기 쉽고 효율적입니다.

카운트하기

인덱스를 필요로하지 않더라도 반복 횟수 (때로는 원할 경우)가 필요 1하고 최종 숫자는 카운트가됩니다.

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

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

1에서 5까지 원한다고 말했을 때 (인수가 아닌) 요청하려는 것보다 더 많은 것으로 보입니다.

세분화-단계별 설명

이 예제들을 정리하기 위해 인덱스로 반복하고 싶은 아이템리스트가 있다고 가정 해 봅시다.

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

이제이 iterable을 전달하여 열거 객체를 생성합니다.

enumerate_object = enumerate(items) # the enumerate object

이 iterable에서 첫 번째 항목을 가져와 next함수 와 함께 루프에 넣을 수 있습니다.

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

그리고 우리 0는 첫 번째 인덱스와 'a'첫 번째 항목 의 튜플을 얻습니다 .

(0, 'a')

이 두 튜플에서 요소를 추출하기 위해 ” 시퀀스 언 패킹 ” 이라고하는 것을 사용할 수 있습니다 .

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

검사 할 때 index첫 번째 인덱스 0을 item가리키고 첫 번째 항목을 나타냅니다 'a'.

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

결론

• 파이썬 인덱스는 0에서 시작
• 반복 할 때 iterable에서 이러한 인덱스를 얻으려면 enumerate 함수를 사용하십시오.
• 튜플 압축 풀기와 함께 관용적 방식으로 열거를 사용하면 더 읽기 쉽고 유지 관리가 쉬운 코드가 생성됩니다.

이렇게하십시오 :

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

답변

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

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

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

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

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

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

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

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

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