Доступ к индексу в циклах "for"?
Как получить доступ к самому индексу для списка, как показано ниже?
ints = [8, 23, 45, 12, 78]
когда я петлю через него, используя for
цикл, Как получить доступ к индексу цикла, от 1 до 5 в этом случае?
21 ответов
С помощью дополнительной переменной состояния, например индексной переменной (который вы обычно используете в таких языках, как C или PHP), является не подходящие для Python.
лучший вариант-использовать встроенную функцию 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)
Unidiomatic поток управления
то, что вы просите-это подходящие для Python эквивалентно следующему, которое алгоритм, который использовали бы большинство программистов языков нижнего уровня:
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
или иногда чаще (но unidiomatically) нашли в Python:
for index in range(len(items)): print(index, items[index])
используйте функцию перечисления
в Python enumerate
функции уменьшает визуальный беспорядок, скрывая учет индексов, и инкапсулирование iterable в другой iterable (enumerate
object), который дает двухэлементный кортеж индекса и элемент, который будет предоставлен исходной iterable. Это выглядит так:
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
вывод
- индексы Python начинаются с нуля
- чтобы получить эти индексы повторяемое, как вы перебирать его, используйте перечислить функции
- использование enumerate идиоматическим способом (вместе с распаковкой кортежа) создает код, который является более читаемым и поддерживаемым:
так же:
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)
здесь.
Хороший, чтобы пойти.
как это норма в Python есть несколько способов сделать это. Во всех примерах предположим:lst = [1, 2, 3, 4, 5]
1. Использование enumerate (считаются наиболее идиоматические)
for index, element in enumerate(lst):
# do the things that need doing here
это также самый безопасный вариант, на мой взгляд, потому что вероятность перехода в бесконечную рекурсию была устранена. И элемент, и его индекс хранятся в переменных, и нет необходимости писать какой-либо дополнительный код для доступа к элементу.
2. Создание переменной для хранения индекс (используя for
)
for index in range(len(lst)): # or xrange
# you will have to write extra code to get the element
3. Создание переменной для хранения индекса (используя while
)
index = 0
while index < len(lst):
# you will have to write extra code to get the element
index += 1 # escape infinite recursion
4. Всегда есть другой способ
как объяснялось ранее, есть другие способы сделать это, которые не были объяснены здесь, и они могут даже применяться больше в других ситуациях. Эл.г используя 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 использовать метод диапазоне для небольших списков и метод enumerate для средних и огромных списков размер.
см. разные подходы который можно использовать для итерации по значению индекса списка и доступа и их показатели производительности (что, я полагаю, было бы полезно для вас) в примерах кода ниже:
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)
таким образом, вы можете расширить список. Extend означает, что вы можете добавлять несколько значений одновременно.
добавить в этот список вы должны написать код, приведенный ниже:
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, потому что цикл останавливает одно число перед максимальным. :)
чтобы получить значение индекса use
list[index]
согласно этому обсуждению:http://bytes.com/topic/python/answers/464012-objects-list-index
итерация счетчика циклов
текущая идиома для цикла над индексами использует встроенную функцию "диапазон":
for i in range(len(sequence)):
# work with index i
цикл над обоими элементами и индексами может быть достигнут либо старой идиомой, либо с помощью новой встроенной функции " zip " [2]:
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
используйте этот код, если вам нужно сбросить значение индекса в конце цикла:
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
if index >= len(ints)-1:
index = 0
лучшим решением этой проблемы является use перечислить функция python в сборке.
перечислить возвращение кортежа!--3-->
первое значение индекс
второе значение -элемент массива при этом индексе
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)
вы также можете попробовать это:
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
в выбранном ответе на этот вопрос, но со списком понимание, делая его быстрее с меньшим количеством кода.
если бы я должен был повторить nums = [1,2,3,4,5] Я бы сделал
for i, num in enumerate(nums, start = 1):
print(i, num)
или получить длину как l = len (nums)
for i, num in range(1, l + 1):
print(i, nums[i])
если в списке нет повторяющегося значения:
for i in ints:
indx=ints.index(i)
print(i,indx)
вместо того, чтобы использовать enumerate.
for counter, value in enumerate(ints):
print(counter, value)
или используйте ниже:
for counter in range(len(ints)):
print(counter,ints[counter])
вы получили ряд ответов, объясняющих 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
в вас вопрос, вы пишете " как получить доступ к индексу цикла, от 1 до 5 в этом случае?"
однако индекс для списка выполняется от нуля. Итак, нам нужно знать, действительно ли вы хотите индекс и элемент для каждого элемента в списке, или вы действительно хотите числа, начинающиеся с 1. К счастью, в python легко сделать либо то, либо другое.
во-первых, чтобы уточнить, функция перечисления, итеративно возвращает индекс и соответствующий элемент для каждого элемента в списке.
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
для печати кортежа (индекс, значение) в понимании списка с помощью 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)]
это служит цели достаточно хорошо:
list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
print('index:', list1.index(x), 'value:', x)