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

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

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

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

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

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

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

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 начинаются с нуля
• чтобы получить эти индексы повторяемое, как вы перебирать его, используйте перечислить функции
• использование enumerate идиоматическим способом (вместе с распаковкой кортежа) создает код, который является более читаемым и поддерживаемым:

так же:

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

это довольно просто, чтобы начать его с 1 кроме 0:

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

Примечание

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

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

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

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

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

старинке:

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

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

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

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 (list)) или перечислить(list)?

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

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)

таким образом, вы можете расширить список. Extend означает, что вы можете добавлять несколько значений одновременно.

добавить в этот список вы должны написать код, приведенный ниже:

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

таким образом, вы можете добавить одно значение за раз. Если вы пишете ints.append([1]) таким образом, это создаст дополнительный список для этого элемента.

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

for x in range(0, 5):

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

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

list[index]

согласно этому обсуждению: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/

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

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

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

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)

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

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

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

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]

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

если бы я должен был повторить 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])

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

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

вы получили ряд ответов, объясняющих 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

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

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