'for' 루프에서 인덱스 액세스
해야 하나요?for 루우프? 루우프?
xs = [8, 23, 45]
for x in xs:
print("item #{} = {}".format(index, x))
원하는 출력:
item #1 = 8
item #2 = 23
item #3 = 45
내장된 기능을 사용합니다.
for idx, x in enumerate(xs):
print(idx, x)
다음을 통해 수동으로 인덱싱하는 것은 피톤적이지 않습니다.for i in range(len(xs)): x = xs[i]또는 추가 상태 변수를 수동으로 관리합니다.
자세한 내용은 PEP 279를 참조하십시오.
for 루프를 사용하여 루프 인덱스에 액세스하려면 어떻게 해야 합니까?이 경우 1~5 입니다.
enumerate반복할 때 요소를 포함한 인덱스를 가져오려면:
for index, item in enumerate(items):
print(index, item)
그리고 Python의 인덱스는 0부터 시작되므로 위와 같이 하면 0에서 4까지 얻을 수 있습니다.1~5 의 카운트를 실시하는 경우는, 다음과 같이 실시합니다.
count = 0 # in case items is empty and you need it after the loop
for count, item in enumerate(items, start=1):
print(count, item)
비자동 제어 흐름
당신이 요구하는 것은 다음과 같은 피토닉어 대응 알고리즘입니다.이것은 대부분의 하위 언어 프로그래머가 사용하는 알고리즘입니다.
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
또는 각 루프가 없는 언어인 경우:
index = 0 while index < len(items): print(index, items[index]) index += 1
또는 Python에서 자주 볼 수 있습니다(단일 이질적으로).
for index in range(len(items)): print(index, items[index])
열거 함수 사용
Python의 함수는 인덱스에 대한 계정을 숨기고 반복 가능한 것을 다른 반복 가능한 것으로 캡슐화함으로써 시각적 혼란을 줄입니다.enumerate오브젝트)는 원래 반복 가능한 항목과 지수의 두 항목 태플을 산출한다.을 사용하다
for index, item in enumerate(items, start=0): # default is zero
print(index, item)
이 코드 샘플은 Python의 관용 코드와 그렇지 않은 코드 간의 차이를 보여주는 표준적인 예입니다.Idiomatic code는 사용하기 위해 작성된 정교한 Python(복잡하지는 않지만 복잡하지는 않습니다.관용 코드는 언어 설계자에 의해 기대되는데, 이것은 보통 이 코드가 더 읽기 쉬울 뿐만 아니라 더 효율적이라는 것을 의미한다.
카운트를 받다
할 수 있음에도 먼저 할 수 .1그리고 마지막 숫자는 당신의 숫자입니다.
count = 0 # in case items is empty
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']
이제 열거할 수 있는 항목을 전달하고 열거 개체를 만듭니다.
enumerate_object = enumerate(items) # the enumerate object
에서 첫 수 , 이 에서 첫 을 뽑을 수 있습니다.next★★★★
iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)
''이.0 첫 및 " " " "'a'첫 항목 , 「 」입니다.
(0, 'a')
「시퀀스 언팩」이라고 불리는 것을 사용하고, 다음의 2 태플로부터 요소를 추출할 수 있습니다.
index, item = iteration
# 0, 'a' = (0, 'a') # essentially this.
, 「 」를 검사하는 .index색인 과 첫 번째 색인 을 말합니다.item 항목, 첫 번째 입니다.'a'.
>>> print(index)
0
>>> print(item)
a
결론
- Python 인덱스는 0에서 시작합니다.
- 반복할 때 반복 가능한 인덱스에서 이러한 인덱스를 가져오려면 열거 함수를 사용하십시오.
- (태플 언팩과 함께) 관용적인 방법으로 열거를 사용하면 보다 읽기 쉽고 유지보수가 용이한 코드가 생성됩니다.
다음 작업을 수행합니다.
for index, item in enumerate(items, start=0): # Python indexes start at zero
print(index, item)
1 0:
for index, item in enumerate(iterable, start=1):
print index, item # Used to print in python<3.x
print(index, item) # Migrate to print() after 3.x+
for i in range(len(ints)):
print(i, ints[i]) # print updated to print() in Python 3.x+
Python의 표준과 같이, 이것을 하기 위한 몇 가지 방법이 있습니다.에서 다음과 같이 가정합니다.lst = [1, 2, 3, 4, 5]
- 열거 사용(가장 관용적인 것으로 간주됨)
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
- 항상 다른 방법이 있다.
앞에서 설명한 바와 같이, 이 작업을 수행하는 다른 방법은 여기서 설명되지 않았으며, 다른 상황에서는 더 많은 방법이 적용될 수도 있습니다.예를 들어,itertools.chain.네스트된 루프를 다른 예보다 잘 처리합니다.
다음은 for-in 루프를 사용하여 인덱스 및 배열 요소에 액세스하는 방법입니다.
1. 및 (1)의 +=환입니니다다
items = [8, 23, 45, 12, 78]
counter = 0
for value in items:
print(counter, value)
counter += 1
결과:
# 0 8
# 1 23
# 2 45
# 3 12
# 4 78
. (2를 사용한 루프 enumerate()★★★★★★ 。
items = [8, 23, 45, 12, 78]
for i in enumerate(items):
print("index/value", i)
결과:
# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)
3. 사용방법index ★★★★★★★★★★★★★★★★★」value따로따로
items = [8, 23, 45, 12, 78]
for index, value in enumerate(items):
print("index", index, "for value", value)
결과:
# 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
4는 수 요.index이치노
items = [8, 23, 45, 12, 78]
for i, value in enumerate(items, start=1000):
print(i, value)
결과:
# 1000 8
# 1001 23
# 1002 45
# 1003 12
# 1004 78
5. 자동 카운터 증분:range(len(...)).
items = [8, 23, 45, 12, 78]
for i in range(len(items)):
print("Index:", i, "Value:", items[i])
결과:
# ('Index:', 0, 'Value:', 8)
# ('Index:', 1, 'Value:', 23)
# ('Index:', 2, 'Value:', 45)
# ('Index:', 3, 'Value:', 12)
# ('Index:', 4, 'Value:', 78)
6. for-in loop inside 기능을 사용합니다.
items = [8, 23, 45, 12, 78]
def enum(items, start=0):
counter = start
for value in items:
print(counter, value)
counter += 1
enum(items)
결과:
# 0 8
# 1 23
# 2 45
# 3 12
# 4 78
. 7은 수 .whileloopsyslog.syslog..syslog.
items = [8, 23, 45, 12, 78]
counter = 0
while counter < len(items):
print(counter, items[counter])
counter += 1
결과:
# 0 8
# 1 23
# 2 45
# 3 12
# 4 78
8. yield제너레이터 개체를 반환하는 문입니다.
def createGenerator():
items = [8, 23, 45, 12, 78]
for (j, k) in enumerate(items):
yield (j, k)
generator = createGenerator()
for i in generator:
print(i)
결과:
# (0, 8)
# (1, 23)
# (2, 45)
# (3, 12)
# (4, 78)
와 9. for-in 루프가 있는 인라인 lambda.
items = [8, 23, 45, 12, 78]
xerox = lambda upperBound: [(i, items[i]) for i in range(0, upperBound)]
print(xerox(5))
결과:
# [(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]
인덱스에 액세스하여 접근법의 퍼포먼스 벤치마킹
Python 3.7에서 루프 내의 목록 인덱스에 가장 빠르게 액세스하는 방법은 소, 중, 대형 목록에 대해 열거 방법을 사용하는 것입니다.
아래 코드 샘플에서 목록 및 액세스 인덱스 값과 성능 메트릭(사용자에게 유용할 것으로 생각됨)을 반복하기 위해 사용할 수 있는 다양한 접근 방식을 참조하십시오.
# 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
아래 각 방법에 대한 성능 메트릭을 참조하십시오.
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
그 결과,enumeratemethod는 인덱스가 필요할 때 반복하는 가장 빠른 방법입니다.
아래에 몇 가지 유용한 링크를 추가합니다.
구식 방식:
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)
>>>
사용할 수 있습니다.enumerate스트링 리터럴 내에 식을 삽입하여 솔루션을 얻을 수 있습니다.
간단한 방법은 다음과 같습니다.
a=[4,5,6,8]
for b, val in enumerate(a):
print('item #{} = {}'.format(b+1, val))
우선 인덱스는 0에서 4가 됩니다.프로그래밍 언어는 0부터 카운트를 시작합니다.이것을 잊지 말아 주세요.그렇지 않으면 인덱스 아웃오브바운드의 예외가 발생합니다.for 루프에서 필요한 것은 다음과 같이 0 ~4의 변수 카운트뿐입니다.
for x in range(0, 5):
루프가 최대값보다 1개 먼저 정지하기 때문에 0 ~5 라고 쓴 것에 주의해 주세요.:)
인덱스 값을 가져오려면
list[index]
다음 코드를 사용하여 수행할 수 있습니다.
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
루프의 마지막에 인덱스 값을 리셋 할 필요가 있는 경우는, 다음의 코드를 사용합니다.
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
if index >= len(ints)-1:
index = 0
루프 카운터 반복
인덱스를 루핑하기 위한 현재 관용구는 기본 제공 기능을 사용합니다.range기능:
for i in range(len(sequence)):
# Work with index i
요소와 인덱스를 모두 루프하는 것은 오래된 관용구 또는 새로운 관용구를 사용하여 달성할 수 있습니다.zip내장 기능:
for i in range(len(sequence)):
e = sequence[i]
# Work with index i and element e
또는
for i, e in zip(range(len(sequence)), sequence):
# Work with index i and element e
질문에서 "루프 인덱스에 액세스하는 방법, 이 경우 1부터5까지"라고 적습니다.
그러나 목록의 인덱스는 0부터 실행됩니다.따라서 실제로 원하는 것이 목록의 각 항목에 대한 색인 및 항목인지 아니면 1부터 시작하는 숫자를 원하는지 알아야 합니다.다행히 Python에서는 둘 중 하나 또는 둘 다 쉽게 할 수 있습니다.
우선 명확히 하자면enumeratefunction은 목록의 각 항목에 대한 인덱스와 해당 항목을 반복적으로 반환합니다.
alist = [1, 2, 3, 4, 5]
for n, a in enumerate(alist):
print("%d %d" % (n, a))
위의 출력은 다음과 같습니다.
0 1
1 2
2 3
3 4
4 5
인덱스는 0부터 실행됩니다.이러한 종류의 인덱스는 Python과 C를 포함한 현대의 프로그래밍 언어에서 흔히 볼 수 있습니다.
루프를 리스트의 일부에 걸치는 경우는, 리스트의 일부에 표준 Python 구문을 사용할 수 있습니다.예를 들어 목록의 두 번째 항목에서 마지막 항목을 포함하지 않고 루프하려면
for n, a in enumerate(alist[1:-1]):
print("%d %d" % (n, a))
다시 한 번 말씀드리지만 출력 인덱스는 0부터 실행됩니다.
0 2
1 3
2 4
★★★★★★★★★★★★★★★★★★★★★★.start=n로 바꾸다.enumerate()이렇게 하면 인덱스가 오프셋되기 때문에 루프 내의 인덱스에 숫자를 추가할 수 있습니다.
for n, a in enumerate(alist, start=1):
print("%d %d" % (n, a))
그 결과,
1 1
2 2
3 3
4 4
5 5
nums = [1, 2, 3, 4, 5] 수 있다
for i, num in enumerate(nums, start=1):
print(i, num)
또는 다음과 같은 길이를 얻습니다.l = len(nums)
for i in range(l):
print(i+1, nums[i])
목록에 중복된 값이 없는 경우:
for i in ints:
indx = ints.index(i)
print(i, indx)
다음의 조작도 실행할 수 있습니다.
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)
출력은
0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']
.index★★★★
ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]
에서는 이 .ints다음 방법은 의 모든 값에 대해 유효합니다.ints:
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]
또는 다른 방법으로
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]
의 ints튜플 리스트로 사용합니다.
해서 '이렇게 하다'라는 방법을 요.enumerate이 질문에 대한 선택된 답변에 포함되지만 목록 이해력이 있어 코드를 줄이고 더 빠르게 할 수 있습니다.
while 루프를 사용한 간단한 답변:
arr = [8, 23, 45, 12, 78]
i = 0
while i < len(arr):
print("Item ", i + 1, " = ", arr[i])
i += 1
출력:
Item 1 = 8
Item 2 = 23
Item 3 = 45
Item 4 = 12
Item 5 = 78
', 하다, 하다, 하다'와 같은 .count「 」 「 」 、 「 」
ints = [8, 23, 45, 12, 78]
count = 0
for i in ints:
count = count + 1
print('item #{} = {}'.format(count, i))
for 루프를 사용하여 목록 이해로 (인덱스, 값)의 태플을 인쇄하려면 다음 절차를 수행합니다.
ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]
출력:
[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]
하시면 됩니다.range(len(some_list)) 지수를 .
xs = [8, 23, 45]
for i in range(len(xs)):
print("item #{} = {}".format(i + 1, xs[i]))
Python에 된 Python을 합니다.enumerate을 및 각 수
xs = [8, 23, 45]
for idx, val in enumerate(xs, start=1):
print("item #{} = {}".format(idx, val))
다음 코드로 실행할 수 있습니다.
xs = [8, 23, 45]
for x, n in zip(xs, range(1, len(xs)+1)):
print("item #{} = {}".format(n, x))
여기서 range(1, len(x)+1)입니다.출력이 0이 아닌 1부터 시작되어야 할 경우 python이 기본적으로 0부터 숫자를 인덱싱하기 때문에 1부터 시작하여 추정된 총 길이에 1을 추가해야 합니다.
Final Output:
item #1 = 8
item #2 = 23
item #3 = 45
"counter" 변수가 이니셜라이저로 설정된 루프. 문자열 형식에서 항목 번호로 매개 변수가 됩니다.
for 루프는 목록인 listos 변수에 액세스합니다.「i」를 사용해 리스트에 액세스 하면, 「i」는 아이템 가격(또는 그것이 무엇이든)으로 포맷됩니다.
listos = [8, 23, 45, 12, 78]
counter = 1
for i in listos:
print('Item #{} = {}'.format(counter, i))
counter += 1
출력:
Item #1 = 8
Item #2 = 23
Item #3 = 45
Item #4 = 12
Item #5 = 78
이 정도면 충분히 도움이 됩니다.
list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
print('index:', list1.index(x), 'value:', x)
언급URL : https://stackoverflow.com/questions/522563/accessing-the-index-in-for-loops
'programing' 카테고리의 다른 글
| MySQL에서는 그룹 코드당 상위 N에 대한 쿼리가 작동하지만 Maria에서는 결과가 다릅니다.DB (0) | 2022.09.23 |
|---|---|
| MySQL LIKE 절의 사용자 변수 사용 방법 (0) | 2022.09.23 |
| 자바처럼 C#에 shrows 키워드가 있나요? (0) | 2022.09.22 |
| Python 문자열을 공백으로 채우려면 어떻게 해야 하나요? (0) | 2022.09.22 |
| symfony2를 사용하여 form_rest()가 필드를 표시하지 않도록 하려면 어떻게 해야 합니까? (0) | 2022.09.22 |