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

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

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

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

  • Петля, пока пользовательский ввод
  • Проблема цикла при повторении через список и удалении повторяющихся элементов
  • Модификация элементов списка в цикле (python)
  • Почему вы должны вызывать .iteritems () при итерации по словарю в python?
  • Поиск второго наименьшего числа с использованием циклов в python
  • Печать при нажатии мыши
  • Что происходит в бесконечных вложенных списках?
  • Эффективный способ переместить список в python
  • Можно сразу добавить несколько списков? (Python)
  • list () использует больше памяти, чем понимание списков
  • Как я могу группировать эквивалентные элементы вместе в списке Python?
  • Отрицательное индексирование в Python
  • 13 Solutions collect form web for “Доступ к индексу в циклах Python for for”

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

    И обратите внимание, что индексы начинаются с нуля, так что вы получите от 0 до 4 с этим. Если вы хотите подсчет, я объясню это ниже.

    Унидиоматический поток управления

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

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

    Вывод

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

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

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

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

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

    Заметка

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

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

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

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

    Я не знаю, является ли следующее pythonic или нет, но он использует функцию Python и перечисляет перечислитель и значение.

     int_list = [8, 23, 45, 12, 78] for index in enumerate(int_list): print index (0, 8) (1, 23) (2, 45) (3, 12) (4, 78) 

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

     for x in range(0, 5): 

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

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

     list[index] 
     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]) это создаст дополнительный список для этого элемента.

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

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

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

    • В чем разница между функциями range и xrange в Python 2.X?

    • Что быстрее для цикла использует перечисление или цикл, используя xrange в Python?

    • диапазон (len (список)) или перечислить (список)?

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

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

     for index, element in enumerate(lst): # do the things that need doing here 

    Это также самый безопасный вариант, на мой взгляд, потому что вероятность перехода в бесконечную рекурсию была устранена. Оба элемента и его индекс хранятся в переменных, и нет необходимости писать какой-либо дополнительный код для доступа к элементу.

    2. Использование индексного метода списка

     for element in lst: index = lst.index(element) # and the rest 

    3. Создание переменной для хранения индекса ( с использованием для )

     for index in range(len(lst)): # or xrange # you will have to write extra code to get the element 

    4. Создание переменной для хранения индекса ( с использованием while )

     index = 0 while index < len(lst): # you will have to write extra code to get the element index += 1 # escape infinite recursion 

    5. Всегда есть другой способ

    Как объяснялось ранее, существуют и другие способы сделать это, которые здесь не были объяснены, и они могут даже применять больше в других ситуациях. например, используя itertools.chain с for. Он обрабатывает вложенные петли лучше, чем другие примеры.

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

     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 

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

     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) 
    Python - лучший язык программирования в мире.