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

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

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

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

вопрос задан 6.02.2009
Joan Venge
94882 репутация

21 ответов


  • 4582 рейтинг

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

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

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

    Ознакомьтесь с PEP 279 для получения дополнительной информации.

    ответ дан Mike Hordecki, с репутацией 49860, 6.02.2009
  • 533 рейтинг

    Используя цикл 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])
     

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

    Функция Python enumerate уменьшает видимый беспорядок, скрывая учет индексов и инкапсулируя итерабельность в другой итерируемый (объект enumerate ), который дает двухпозиционный кортеж индекса и элемент, который будет предоставлен исходным итерабельным. Это выглядит так:

     for index, item in enumerate(items, start=0):   # default is zero
        print(index, item)
     

    Этот пример кода довольно хорошо представляет собой канонический пример разницы между кодом, который является идиоматическим Python, и кодом, который не является. Идиоматический код сложный (но не сложный) Python, написанный так, как он должен был использоваться. Идиоматический код ожидается разработчиками языка, а это означает, что обычно этот код не просто читабельнее, но и более эффективен.

    Получение счета

    Даже если вам не нужны индексы, когда вы идете, но вам нужно подсчитать итерации (иногда желательно), вы можете начать с 1 а окончательное число будет вашим счетом.

     for index, item in enumerate(items):
        print(index, item)
     

    Кажется, что граф больше того, что вы намерены просить (в отличие от индекса), когда вы сказали, что хотите от 1 до 5.


    Разрушение - пошаговое объяснение

    Чтобы разбить эти примеры, скажем, у нас есть список элементов, которые мы хотим перебрать с помощью индекса:

     for index, item in enumerate(items):
        print(index, item)
     

    Теперь мы передаем эту итерабельность для перечисления, создавая объект перечисления:

     for index, item in enumerate(items):
        print(index, item)
     

    Мы можем вытащить первый элемент из этого итерабельного, который мы получили бы в цикле с функцией for index, item in enumerate(items): print(index, item) :

     for index, item in enumerate(items):
        print(index, item)
     

    И мы видим, что мы получаем кортеж из for index, item in enumerate(items): print(index, item) , первый индекс и for index, item in enumerate(items): print(index, item) , первый элемент:

     for index, item in enumerate(items):
        print(index, item)
     

    мы можем использовать то, что называется « распаковкой последовательности », чтобы извлечь элементы из этого двухкортежа:

     for index, item in enumerate(items):
        print(index, item)
     

    и когда мы проверяем for index, item in enumerate(items): print(index, item) , мы находим, что это относится к первому индексу, 0 и for count, item in enumerate(items, start=1): print(count, item) относится к первому элементу for count, item in enumerate(items, start=1): print(count, item) .

     for count, item in enumerate(items, start=1):
        print(count, item)
     

    Заключение

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

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

     for count, item in enumerate(items, start=1):
        print(count, item)
     
    ответ дан Aaron Hall, с репутацией 153756, 21.01.2015
  • 105 рейтинг

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

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

    Заметка

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

    ответ дан Clayton, с репутацией 3265, 27.05.2014
  • 69 рейтинг
    for i in range(len(ints)):
       print i, ints[i]
    
    ответ дан David Hanak, с репутацией 8514, 6.02.2009
  • 36 рейтинг

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

    ответ дан Charitoo, с репутацией 815, 15.08.2017
  • 21 рейтинг

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

     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)
    >>> 
     
    ответ дан Charlie Martin, с репутацией 89158, 6.02.2009
  • 16 рейтинг

    Я не знаю, является ли следующее 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
     
    ответ дан user2912389, с репутацией 214, 28.10.2013
  • 16 рейтинг

    Самый быстрый способ доступа к индексам списка внутри цикла в 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 является победителем.

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

    ответ дан Andriy Ivaneyko, с репутацией 10302, 4.08.2016
  • 15 рейтинг
     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]) это создаст дополнительный список для этого элемента.

    ответ дан iamjayp, с репутацией 333, 5.02.2015
  • 11 рейтинг

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

     for x in range(0, 5):
     

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

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

     list[index]
     
    ответ дан ytpillai, с репутацией 2058, 25.05.2015
  • 9 рейтинг

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

     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
     
    ответ дан Liam, с репутацией 1942, 25.05.2015
  • 9 рейтинг

    Согласно этой дискуссии: 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
     

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

    ответ дан thinker007, с репутацией 364, 5.05.2012
  • 8 рейтинг

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

     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)
     
    ответ дан Anurag Misra, с репутацией 685, 24.08.2017
  • 3 рейтинг

    Вы также можете попробовать следующее:

     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']
     
    ответ дан Ashok Kumar Jayaraman, с репутацией 518, 7.02.2018
  • 1 рейтинг

    Если бы я повторял 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])
     
    ответ дан Ankur Kothari, с репутацией 45, 4.06.2018
  • 1 рейтинг

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

     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])
     
    ответ дан RIshu, с репутацией 34, 10.06.2018
  • 1 рейтинг

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

    ответ дан killerT2333, с репутацией 945, 30.05.2018
  • 0 рейтинг

    Вы получили ряд ответов, объясняющих 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
     
    ответ дан Gary R., с репутацией 25, 14.02.2018
  • 0 рейтинг

    В вашем вопросе вы пишете «как мне получить доступ к индексу цикла, от 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 для перечисления (). Это просто смещает индекс, вы можете эквивалентно просто добавить число в индекс внутри цикла.

     for n,a in enumerate(alist,start=1):
        print( "%d %d"%(n,a) )
     

    для которого выход

     1 1
    2 2
    3 3
    4 4
    5 5
     
    ответ дан DrM, с репутацией 551, 15.08.2018
  • -1 рейтинг

    Чтобы напечатать кортеж (индекс, значение) в понимании списка с помощью цикла 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)]
     
    ответ дан lola, с репутацией 30, 24.04.2018
  • -1 рейтинг

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

     list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
    for x in list1:
        print('index:', list1.index(x), 'value:', x)
     
    ответ дан Sumit Kumar, с репутацией 49, 24.04.2018