цикл с переменной "счетчик", установленной в качестве инициализатора, который будет параметром при форматировании строки , как номер позиции. Цикл for обращается к переменной listos, которая является списком. Когда мы обращаемся к списку с помощью «i», «i» форматируется как цена товара {или что-то еще}.

listos = [8,23,45,12,78]
counter = 1
for i in listos :
    print('Item #{} = {}'.format(counter,i))
    counter += 1


output:
Item #1 = 8
Item #2 = 23
Item #3 = 45
Item #4 = 12
Item #5 = 78

Для получения решения можно использовать enumerate и вставлять выражения в строковые литералы.

Это простой способ:

a=[4,5,6,8]
for b, val in enumerate(a):
    print('item #{} = {}'.format(b+1, val))

Вы можете использовать enumerate для итерации по списку и использовать start=1, поскольку по умолчанию он будет равен 0, что означает, что он начнет отсчет с 0.

Вот пример:

for index,val in enumerate(ints,start=1):
     print(f"item #{index} = {val}")

Кроме того, использование f-strings - это быстрый способ получить запрошенный вывод, и он более читабелен, поскольку вы можете напрямую передавать index и val в {} -placeholder.

Вывод:

item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78

Вы можете просто использовать переменную, такую ​​как count, для подсчета количества элементов в списке:

ints = [8, 23, 45, 12, 78]
count = 0
for i in ints:
    count = count + 1
    print('item #{} = {}'.format(count, i))

Используйте enumerate для перебора списка

ints = [8, 23, 45, 12, 78]
for idx,val in enumerate(ints):
    print('item #{} = {}'.format(idx+1, val))

Вывод:

item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78

Простой ответ с использованием цикла while:

arr = [8, 23, 45, 12, 78]
i = 0
while i < len(arr):
    print("Item ", i + 1, " = ", arr[i])
    i += 1

Вывод:

Вот что вы получаете при доступе к индексу в циклах for:

for i in enumerate(items): print(i)

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

for i in enumerate(items):
    print("index/value", i)

Результат:

# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)

for i, val in enumerate(items): print(i, val)

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

for i, val in enumerate(items):
    print("index", i, "for value", val)

Результат:

# index 0 for value 8
# index 1 for value 23
# index 2 for value 45
# index 3 for value 12
# index 4 for value 78

for i, val in enumerate(items): print(i)

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

for i, val in enumerate(items):
    print("index", i)

Результат:

# index 0
# index 1
# index 2
# index 3
# index 4

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

Однако индекс для списка начинается с нуля. Итак, нам нужно знать, действительно ли вам нужен индекс и элемент для каждого элемента в списке, или вам действительно нужны числа, начинающиеся с 1. К счастью, в Python легко сделать либо одно, либо и то, и другое.

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

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 i in ints:
    indx = ints.index(i)
    print(i, indx)

Если бы я повторял nums = [1, 2, 3, 4, 5], я бы сделал

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

Или получите длину как l = len(nums)

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

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

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

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

list2 = [11, 'sumit', 43.21, 'sharma', '44', 'test', 2]
for x in list1:
    print( 'index: ', list2.index(x), 'value:', x )

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

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

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

enumerate возвращает tuple, где первое значение - это индекс, а второе значение - элемент списка по этому индексу.

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

Доступ к индексам и подходы к сравнительному анализу производительности

Самый быстрый способ получить доступ к индексам списка внутри цикла в Python 3.7 - использовать метод перечисления для малых, средних и огромных списков.

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

# Using range
def range_loop(iterable):
    for i in range(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("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 speed for list with 1000 items
measure(range(1000))
# range:  1.161622366
# enumerate:  0.5661940879999996
# manual_indexing:  0.610455682

# Measure speed for list with 100000 items
measure(range(10000))
# range:  11.794482958
# enumerate:  6.197628574000001
# manual_indexing:  6.935181098000001

# Measure speed for list with 10000000 items
measure(range(10000000), number=100)
# range:  121.416859069
# enumerate:  62.718909123
# manual_indexing:  69.59575057400002

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

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

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

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

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

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

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

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

for x in range(0, 5):

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

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

list[index]

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

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

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

Обратите внимание, что индексы Python начинаются с нуля, поэтому вы получите от 0 до 4 с указанным выше. Если вам нужен счет от 1 до 5, сделайте следующее:

count = 0 # in case items is empty and you need it after the loop
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

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

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, и окончательное число будет вашим счетчиком.

count = 0 # in case items is empty
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  # Used to print in python<3.x
   print(index, item) # Mirate print() after 3.x+
   

Согласно этому обсуждению: http://bytes.com/topic/python/answers/464012-objects-list-index

Итерация счетчика циклов

Текущая идиома для перебора индексов использует встроенную функцию range:

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

Цикл по элементам и индексам может быть достигнут либо с помощью старой идиомы, либо с помощью новой встроенной функции zip:

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/

Старомодно:

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

for i in range(len(ints)):
   print(i, ints[i]) # print updated to print() in Python 3.x+