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


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

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

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


2491


источник


Ответы:


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

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

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

Проверять, выписываться PEP 279 для большего.


4321



Используя цикл 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's indexing starts at zero
for item in items:   # Python's 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функция уменьшает визуальный беспорядок, скрывая учет индексов и инкапсулируя итерабельность в другую итерабельную ( 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

Вывод

  • Индексы Python начинаются с нуля
  • Чтобы получить эти индексы из итерации, когда вы перебираете ее, используйте функцию перечисления
  • Использование перечисления в идиоматическом режиме (наряду с распаковкой кортежа) создает код, который является более читабельным и поддерживаемым:

Так сделайте так:

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

490



Это довольно просто начать с 1Кроме как 0:

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

Заметка

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


98



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

60



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


30



Old fashioned way:

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

List comprehension:

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

16



The fastest way to access indexes of list within loop in Python 2.7 is to use the range method for small lists and enumerate method for medium and huge size lists.

Please see different approaches which can be used to iterate over list and access index value and their performance metrics (which I suppose would be useful for you) in code samples below:

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

See performance metrics for each method below:

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

As the result, using range method is the fastest one up to list with 1000 items. For list with size > 10 000 items enumerate is the winner.

Adding some useful links below:


14



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)

This way you can extend a list. Extend means you can add multiple values at a time.

To append this list you have to write the code given below:

ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)

This way you can add a single value at a time. If you write ints.append([1]) so this will create a sub list for this element.


13



I don't know if the following is pythonic or not, but it uses the Python function enumerate and prints the index and the value.

int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)

Output:

0 8
1 23
2 45
3 12
4 78

12



First of all, the indexes will be from 0 to 4. Programming languages start counting from 0; don't forget that or you will come across an index out of bounds exception. All you need in the for loop is a variable counting from 0 to 4 like so:

for x in range(0, 5):

Keep in mind that I wrote 0 to 5 because the loop stops one number before the max. :)

To get the value of an index use

list[index]

10



According to this discussion: http://bytes.com/topic/python/answers/464012-objects-list-index

Loop counter iteration

The current idiom for looping over the indices makes use of the built-in 'range' function:

for i in range(len(sequence)):
    # work with index i

Looping over both elements and indices can be achieved either by the old idiom or by using the new 'zip' built-in function[2]:

for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e

or

for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e

via http://www.python.org/dev/peps/pep-0212/


8