Как получить доступ к индексу в цикле for, как показано ниже?
ints = [8, 23, 45, 12, 78]
for i in ints:
print('item #{} = {}'.format(???, i))
Я хочу получить этот вывод:
item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78
Когда я перебираю цикл с помощью цикла for, как мне получить доступ к индексу цикла, в данном случае от 1 до 5?
Использование дополнительной переменной состояния, такой как индексная переменная (которую вы обычно используете в таких языках, как C или PHP), считается непитоновым.
Лучший вариант - использовать встроенную функцию enumerate(), доступную как в Python 2, так и в 3:
for idx, val in enumerate(ints):
print(idx, val)
Подробнее о PEP 279.
Используя цикл for, как мне получить доступ к индексу цикла, от 1 до 5 в этом случае?
Используйте enumerate чтобы получить индекс с элементом при повторении:
for index, item in enumerate(items):
print(index, item)
И обратите внимание, что индексы Python начинаются с нуля, поэтому вы получите от 0 до 4 с приведенным выше. Если вы хотите, чтобы счетчик от 1 до 5 сделал это:
for count, item in enumerate(items, start=1):
print(count, item)
То, о чем вы просите, это питонический эквивалент следующего: это алгоритм, который большинство программистов языков более низкого уровня будут использовать:
index = 0 # Python indexing starts at zero for item in items: # Python for loops are a "for each" loop print(index, item) index += 1
Или на языках, для которых нет цикла for:
index = 0 while index < len(items): print(index, items[index]) index += 1
или иногда чаще (но унииоматически), найденный в Python:
for index in range(len(items)): print(index, items[index])
Функция enumerate Python уменьшает видимый беспорядок, скрывая учет индексов и инкапсулируя итерабельность в другой итерируемый (объект enumerate), который дает двухпозиционный кортеж индекса и элемент, который будет предоставлен исходным итерабельным. Это выглядит так:
for index, item in enumerate(items, start=0): # default is zero
print(index, item)
Этот пример кода довольно хорошо представляет собой канонический пример разницы между кодом, который является идиоматическим Python, и кодом, который не является. Идиоматический код сложный (но не сложный) Python, написанный так, как он должен был использоваться. Идиоматический код ожидается разработчиками языка, а это означает, что обычно этот код не просто читабельнее, но и более эффективен.
Даже если вам не нужны индексы, когда вы идете, но вам нужно подсчитать итерации (иногда желательно), вы можете начать с 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']
Теперь мы передаем эту итерабельность для перечисления, создавая объект перечисления:
enumerate_object = enumerate(items) # the enumerate object
Мы можем вытащить первый элемент из этого итерабельного, который мы получили бы в цикле со 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
Так сделайте так:
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
Важный намек, хотя и немного вводящий в заблуждение, так как index будет tuple (idx, item). Хорошо пойти.
for i in range(len(ints)):
print i, ints[i]
Как и в Python, есть несколько способов сделать это. Во всех примерах предположим: lst = [1, 2, 3, 4, 5]
for index, element in enumerate(lst):
# do the things that need doing here
Это также самый безопасный вариант, на мой взгляд, потому что вероятность перехода в бесконечную рекурсию была устранена. Оба элемента и его индекс хранятся в переменных, и нет необходимости писать какой-либо дополнительный код для доступа к элементу.
for)for index in range(len(lst)): # or xrange
# you will have to write extra code to get the element
while)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. Он обрабатывает вложенные циклы лучше, чем другие примеры.
Старомодный способ:
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)
>>>
Самый быстрый способ доступа к индексам списка внутри цикла в Python 2.7 - использовать метод диапазона для небольших списков и перечислить метод для средних и огромных списков размеров.
См. Различные подходы, которые можно использовать для итерации по списку и индексу доступа и их показателям эффективности (которые, я полагаю, будут вам полезны) в примерах кода ниже:
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
Как результат, использование метода range является самым быстрым, чтобы перечислить 1000 элементов. Для списка с размером> 10 000 элементов enumerate победитель.
Добавление некоторых полезных ссылок ниже:
Я не знаю, является ли следующее: pythonic или нет, но он использует функцию Python и enumerate индекс и значение.
int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
print(index, value)
Вывод:
0 8
1 23
2 45
3 12
4 78
ints = [9, 23, 45, 12, 78]
ints.extend([1,2,3,4,5,6,7,8])
for idx, val in enumerate(ints):
print(idx,val)
Таким образом вы можете расширить список. Расширение означает, что вы можете добавлять сразу несколько значений.
Чтобы добавить этот список, вам необходимо написать приведенный ниже код:
ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
print(idx,val)
Таким образом вы можете добавить одно значение за раз. Если вы пишете ints.append([1]), значит, это создаст дополнительный список для этого элемента.
Прежде всего, индексы будут от 0 до 4. Языки программирования начинаются с 0; не забывайте об этом или вы столкнетесь с исключением из исключения исключений. Все, что вам нужно в цикле for, это переменная, считая от 0 до 4 следующим образом:
for x in range(0, 5):
Имейте в виду, что я написал от 0 до 5, потому что цикл останавливает одно число до max.:)
Чтобы получить значение индекса, используйте
list[index]
Согласно этой дискуссии: http://bytes.com/topic/python/answers/464012-objects-list-index
Итерация счетчика циклов
Текущая идиома для зацикливания индексов использует встроенную функцию 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
Вы можете сделать это с помощью этого кода:
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
Используйте этот код, если вам нужно reset значение индекса в конце цикла:
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
if index >= len(ints)-1:
index = 0
Лучшим решением этой проблемы является использование перечисления встроенной функции python.
перечисление возвращает кортеж
первое значение index
второе значение элемента массива при этом индексе
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)
Если бы я nums = [1, 2, 3, 4, 5] я бы сделал
for i, num in enumerate(nums, start=1):
print(i, num)
Или получите длину как l = len(nums)
for i in range(1, l + 1):
print(i, nums[i])
for циклов:
for я in enumerate(items): print(i)
for i, val in enumerate(items): print(i, val)
for i, val in enumerate(items): print(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']
В своем вопросе вы пишете "как мне получить доступ к индексу цикла, от 1 до 5 в этом случае?"
Однако индекс для списка начинается с нуля. Итак, тогда нам нужно знать, действительно ли вам нужен индекс и элемент для каждого элемента в списке, или вы действительно хотите, чтобы числа начинались с 1. К счастью, в Python это легко сделать и тем, и другим.
Во-первых, чтобы уточнить, функция enumerate итеративно возвращает индекс и соответствующий элемент для каждого элемента в списке.
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
Вы можете использовать index метод
ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]
EDIT Выделенный в комментарии, что этот метод не работает, если в 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 в выбранном ответе на этот вопрос, но с пониманием списка, делая его быстрее с меньшим количеством кода.
Это служит цели достаточно хорошо:
list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
print('index:', list1.index(x), 'value:', x)
Чтобы напечатать кортеж (индекс, значение) в понимании списка с помощью цикла 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)]
Это также можно сделать, используя метод index()
for i in ints:
print(ints.index(i), i)
Здесь индексирование начинается с 0. Но если вам нужно запустить его из 1, просто добавьте 1 к методу index() следующим образом
for i in int:
print(int.index(i) + 1, i)
Вы получили ряд ответов, объясняющих enumerate, но если вам нужен только индекс для доступа к совпадающим записям в двух списках, есть еще один способ, который чище и проще в Python 3: zip.
Например, если вы используете индекс, чтобы вытаскивать соответствующие имена для чисел в вашем списке, вы можете сделать это следующим образом:
ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
print("{} - {}".format(name, int)
Это приведет к
8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian