it-roy-ru.com

Доступ к индексу в циклах for?

Как получить доступ к самому индексу для списка, подобного следующему?

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

Когда я зацикливаюсь через цикл for, как мне получить доступ к индексу цикла, в данном случае от 1 до 5?

2916
Joan Venge

Использование дополнительной переменной состояния, такой как индексная переменная (которую вы обычно используете в таких языках, как C или PHP), считается непифоническим.

Лучшим вариантом является использование встроенной функции enumerate() , доступной как в Python 2, так и в 3:

for idx, val in enumerate(ints):
    print(idx, val)

Проверьте PEP 279 для более.

5061
Mike Hordecki

Используя цикл 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 контроль потока

То, что вы просите, это 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

или иногда чаще (но неидиоматически) встречается в Python:

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

Используйте функцию перечисления

Функция Python enumerate уменьшает визуальный беспорядок, скрывая учет индексов и инкапсулируя итерируемое в другой итерируемый объект (объект 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)

И мы видим, что мы получаем Tuple из 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 идиоматическим способом (вместе с распаковкой Tuple) создает код, который будет более читабельным и обслуживаемым:

Так что сделайте это:

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

Довольно просто запустить его с 1, отличного от 0:

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

Заметка

Важный совет, хотя и немного вводящий в заблуждение, поскольку index будет Tuple(idx, item) здесь .

118
Clayton
for i in range(len(ints)):
   print i, ints[i]
76
David Hanak

Как правило, в Python есть несколько способов сделать это. Во всех примерах предположим: lst = [1, 2, 3, 4, 5]

1. Использование перечисления ( считается наиболее идиоматическим )

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. Он обрабатывает вложенные циклы лучше, чем другие примеры.

40
Charitoo

Старомодный способ:

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)
>>> 
23
Charlie Martin

Я не знаю, является ли следующее 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
18
user2912389

Самый быстрый способ получить доступ к индексам списка внутри цикла в Python 2.7 - это использовать метод range для небольших списков и метод перечисления для списков среднего и большого размера.

Посмотрите различные подходы, которые можно использовать для перебора списка и доступа к значению индекса и их метрики производительности (которые, я полагаю, будут полезны для вас) в примерах кода ниже:

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 является победителем.

Добавив несколько полезных ссылок ниже:

18
Andriy Ivaneyko
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]), это создаст подсписок для этого элемента.

15
iamjayp

Прежде всего, индексы будут от 0 до 4. Языки программирования начинают считать с 0; не забывайте об этом, иначе вы встретите исключение индекса за пределами границ. Все, что вам нужно в цикле for - это переменная, считающая от 0 до 4, примерно так:

for x in range(0, 5):

Имейте в виду, что я написал от 0 до 5, потому что цикл останавливается на один номер до макс. :)

Чтобы получить значение индекса используйте

list[index]
11
ytpillai

Вы можете сделать это с помощью этого кода:

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
9
Liam

Согласно этой дискуссии: http://bytes.com/topic/python/answers/464012-objects-list-index

Итерация счетчика циклов

Текущая идиома для зацикливания индексов использует встроенную функцию range:

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

через http://www.python.org/dev/peps/pep-0212/

9
thinker007

Лучшее решение этой проблемы - использовать перечислить встроенную функцию Python. 
перечислить return Tuple  
первое значение - индекс  
Вторым значением является элемент массива с этим индексом

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)
8
Anurag Misra

Если в списке нет повторяющихся значений:

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])
6
RIshu

Вот что вы получаете, когда получаете доступ к индексу в циклах for:

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

 enter image description here

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

 enter image description here

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

 enter image description here

Надеюсь это поможет.

4
ARGeo

В вашем вопросе вы пишете "как мне получить доступ к индексу цикла, от 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
3
DrM

Вы также можете попробовать это:

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']
3
Ashok Kumar Jayaraman

Если бы я перебрал nums = [1,2,3,4,5] Я бы сделал

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

Или получите длину как l = len (числа)

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

Вы можете использовать метод 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 в выбранном ответе на этот вопрос, но с пониманием списка, что делает его быстрее с меньшим количеством кода.

1
PyRsquared

Чтобы напечатать Tuple of (index, value) в понимании списка, используя цикл 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)]
0
lola

Это служит цели достаточно хорошо:

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

Это также можно сделать с помощью метода index() 

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

Здесь индексация начинается с 0. Но если вам нужно начать с 1, просто добавьте 1 к методу index() следующим образом

for i in int:
   print(int.index(i) + 1, i)    
0
Loochie