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

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

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

Подробнее смотрите в PEP 279.

с помощью цикла for, как мне попасть в индекс цикла, от 1 до 5 в этом случае?

Используйте перечисление, чтобы получить индекс элемента как перебрать:

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 эквивалентно следующей, которая является алгоритмом большинство программистов низкого уровня языки бы использовать:

индекс = 0 # в Python'ы индексация начинается с нуля по пункту пунктами: # питон's для петли и "каждому" в петлю печать(индекс, элемент) индекс += 1

Или на языках, которые не имеют для каждого цикла:

индекс = 0 В то время как индекс < лен(шт.): печать(индекс, элементы[индекс]) индекс += 1

или иногда чаще (но unidiomatically) нашли в Python:

для индекса в диапазон(лен(шт.)): печать(индекс, элементы[индекс])

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

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

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

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

Получаем граф

Даже если вы Don'т нужна индексы, как вы идете, но вам нужно количество итераций (иногда желательно) можно начать с 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

Мы можем вытащить первый элемент из этого повторяемое, что мы получим в цикле с "Далее" функции:

iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)

И мы видим, мы получаем кортеж 0, первый индекс, и `'Это', Первый пункт:

(0, 'a')

мы можем использовать то, что называется Я как "распаковка последовательности&; для извлечения элементов из этих двух кортежей:

index, item = iteration
#   0,  'a' = (0, 'a') # essentially this.

и когда мы осматриваем индекс, мы находим это относится к первым индексом 0, и вещи относится к первому пункту, 'Это'.

>>> print(index)
0
>>> print(item)
a

Заключение

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

Так что это:

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

[2]: http://python.net/~Гуджер/проекты/команда PyCon/2007/идиоматические/раздаточный материал.индекс-элемент-2-перечислить на

Это'ы довольно просто запустить его от 1 кроме 0:

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

Примечание

Важный намек, хоть немного ввести в заблуждение, поскольку индекс будет Кортеж `(индекс, элемент) здесь. Хороший, чтобы пойти.

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

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

для индекса, элемента перечисления(ЛСТ):

делай то, что нужно делать здесь

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

2. Создаем переменную для хранения индекса (используя по)

для индекса в диапазон(лен(ЛСТ)): # или xrange

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

3. Создаем переменную для хранения индекса (через а)

индекс = 0 в то время как индекс < лен(ЛСТ):

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

индекс += 1 # избежать бесконечной рекурсии

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

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

Старый способ:

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

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

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

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

В результате, используя метод спектр - самый быстрый из них до список с 1000 элементов. Список с размером и GT; 10 000 наименований перечислить является победителем.

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

• https://stackoverflow.com/questions/94935/what-is-the-difference-between-range-and-xrange-functions-in-python-2-x

• https://stackoverflow.com/questions/4852944/what-is-faster-for-loop-using-enumerate-or-for-loop-using-xrange-in-python

• https://stackoverflow.com/questions/11990105/rangelenlist-or-enumeratelist

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

for x in range(0, 5):

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

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

list[index]

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

Счетчик цикла итерации

Нынешние идиомы на циклы по индексам использует встроенный в диапазоне функция:

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

Перебирая обоих элементов и показателей может быть достигнуто либо старой идиомой или с помощью новой молния встроенная функция:

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/

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

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

Здесь's то, что вы получаете, когда вы'индекс считывают В для петли:

для меня в перечисления(предметов): печать(я)`

для меня, Вэл в перечисления(предметов): печать(я, Валь)

для меня, Вэл в перечисления(предметов): печать(я)

Надеюсь, что это помогает.

Если бы мне пришлось перебирать нумс = [1, 2, 3, 4, 5] я бы сделал

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

Или сделать длину по мере того как Л = лен(нумс)

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

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

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

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

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

В вашем вопросе, вы пишите "как мне получить доступ к индексу цикла, от 1 до 5 в этом случае?&ьquot;

Однако индекс для списка выполняется с нуля. Так, то мы должны знать, что вы действительно хотите это индекс и элемент для каждого элемента в списке, или, действительно ли вы хотите числами начиная с 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 `` Это подводит нас к началу=переключатель П для перечисления(). Это просто смещение индекса, вы можете эквивалентно просто добавьте номер индекса внутри цикла.

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

для которых выход `нет 1 1 2 2 3 3 4 4 5 5 ``

Вы можете использовать метод index

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in 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)]

если вы хотите узнать индекс и значение в ИНЦ` в виде списка кортежей.

Он использует метод перечислить в выбранном ответ на этот вопрос, но с пониманием списка, что делает его быстрее, с меньшим количеством кода.

Для печати кортеж (индекс, значение) в понимании списка, используя цикл 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)