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

avatar
Joan Venge
6 февраля 2009 в 22:47
2857691
25
4447

Как получить доступ к индексу в цикле for, как показано ниже?

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

Я хочу получить такой результат:

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

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

Источник
plugwash
2 октября 2018 в 16:54
70

Обратите внимание, что индексы в python начинаются с 0, поэтому индексы для вашего примера списка от 0 до 4, а не от 1 до 5

William Martens
23 марта 2021 в 12:42
1

@JoanVenge, это отличный вопрос, который у меня был МНОГО РАЗ. И в приведенном выше комментарии говорится, что он основан на нулевом индексе (так, мы, люди, считаем от 1 до 3 как 1,2,3, но компьютеры считаются как 0,1,2 (поэтому размер 3, например, равен [0,1 , 2] (0 считается как 1)) И ответы на эти вопросы ниже тоже великолепны. Спасибо за это!

Ответы (25)

avatar
Mike Hordecki
6 февраля 2009 в 22:52
7448

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

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

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

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

clozach
31 марта 2018 в 22:16
99

Как указывает ниже Аарон, используйте start = 1, если вы хотите получить 1-5 вместо 0-4.

TheRealChx101
17 октября 2019 в 23:03
6

Не вызывает ли enumerate дополнительных накладных расходов?

Błotosmętek
7 февраля 2020 в 12:18
4

@ TheRealChx101 согласно моим тестам (Python 3.6.3) разница незначительна, а иногда даже в пользу enumerate.

ShadowRanger
6 октября 2020 в 18:19
8

@ TheRealChx101: это меньше, чем накладные расходы на цикл по range и индексацию каждый раз, и ниже, чем ручное отслеживание и обновление индекса отдельно. enumerate с распаковкой сильно оптимизирован (если tuple распакованы по именам, как в приведенном примере, он повторно использует один и тот же tuple каждый цикл, чтобы избежать даже затрат на поиск в фрилистах, он имеет оптимизированный путь кода для когда индекс соответствует ssize_t, который выполняет дешевую математику в регистре, минуя математические операции уровня Python, и избегает индексации list на уровне Python, что дороже, чем вы думаете).

William Martens
12 марта 2021 в 09:39
2

@MikeHordecki Это просто ## гениальный ответ! Спасибо за это! Вопросу 12+ лет, и этот ответ работает безупречно.

user2585501
7 октября 2021 в 00:59
0

Почему в Python нет профессионального синтаксиса цикла для выполнения этой универсальной операции?

bfris
14 октября 2021 в 19:10
1

@ user2585501. Он выполняет: for i in range(5) или for i in range(len(ints)) выполняет универсально распространенную операцию итерации по индексу. Но если вам нужны оба элемента и индекс, enumerate - это очень полезный синтаксис. Я использую это все время.

avatar
LunaticXXD10
5 января 2022 в 15:19
-4

цикл с переменной "счетчик", установленной в качестве инициализатора, который будет параметром при форматировании строки , как номер позиции. Цикл 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
LunaticXXD10
8 января 2022 в 15:25
0

@calculuswhiz цикл while является важным фрагментом кода. инициализатор "счетчик" используется для номера элемента. Об отступах: Парень должен быть достаточно осведомлен о программировании, чтобы отступы имели значение. поэтому после того, как вы сделаете свой специальный атрибут... {копировать вставку}, вы все равно сможете редактировать отступ. И код работает очень хорошо и плавно

General Grievance
9 января 2022 в 22:06
0

@LunaticXXD10 В вашем исходном сообщении, которое вы можете видеть в истории редактирования, counter += 1 был отступ на том же уровне, что и цикл for. В этом случае он обновлялся бы за каждую итерацию цикла for. Здесь он обновляется за каждую итерацию цикла while. Мой вопрос по циклу while остается: зачем использовать цикл while, когда счетчик можно обновить в цикле for? Это хорошо видно в ответе Рахула.

avatar
Kofi
18 декабря 2021 в 16:05
24

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

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

a=[4,5,6,8]
for b, val in enumerate(a):
    print('item #{} = {}'.format(b+1, val))
avatar
Purnima
10 июня 2021 в 04:17
1

Вы можете использовать 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
joanis
10 июня 2021 в 16:22
2

Хотя это правильно отвечает на вопрос, он просто воспроизводит информацию, уже представленную в этом ответе шестилетней давности, получившем большое количество голосов: coderhelper.com/a/28072982/3216427 Если вы пытаетесь добавить новую информацию к этому старому вопросу, пожалуйста, объясните что вы пытаетесь внести, и как этот ответ улучшает информацию, уже найденную здесь.

Purnima
10 июня 2021 в 20:28
0

да, сделал это ... я хотел показать здесь использовать строку f

joanis
10 июня 2021 в 23:05
1

Ах, хорошо, тогда это стоит добавить сюда. Я предлагаю вам добавить вступительное предложение, говорящее об этом. У вас будет меньше шансов получить отрицательные голоса, если вы это сделаете, или ваш ответ будет удален.

showdev
11 июня 2021 в 00:19
0

Для справки см. Что такое печать (f «…»).

avatar
Rahul
9 мая 2021 в 19:19
1

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

ints = [8, 23, 45, 12, 78]
count = 0
for i in ints:
    count = count + 1
    print('item #{} = {}'.format(count, i))
avatar
prashant sachdeva
30 марта 2021 в 17:30
0

Используйте 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
avatar
Amar Kumar
18 апреля 2020 в 20:25
4

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

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

Вывод:

enter image description here

avatar
Andy Jazz
17 января 2019 в 01:07
16

Вот что вы получаете при доступе к индексу в циклах 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
avatar
DrM
15 августа 2018 в 17:52
10

В своем вопросе вы пишете «как мне получить доступ к индексу цикла, от 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
avatar
RIshu
10 июня 2018 в 03:59
6

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

for i in ints:
    indx = ints.index(i)
    print(i, indx)
Stam Kaly
19 декабря 2018 в 14:05
2

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

Boris
20 апреля 2019 в 10:24
4

Первый вариант - O (n²), ужасная идея. Если ваш список состоит из 1000 элементов, это займет буквально в 1000 раз больше времени, чем при использовании enumerate. Вы должны удалить этот ответ.

avatar
Ankur Kothari
4 июня 2018 в 02:10
12

Если бы я повторял 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])
avatar
PyRsquared
30 мая 2018 в 21:34
4

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

avatar
lola
24 апреля 2018 в 10:53
2

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

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

list2 = [11, 'sumit', 43.21, 'sharma', '44', 'test', 2]
for x in list1:
    print( 'index: ', list2.index(x), 'value:', x )
Peter Szoldan
15 мая 2018 в 17:17
11

Это не работает, если в списке есть повторяющиеся элементы, поскольку index() будет искать первое вхождение x, не говоря уже о времени O ( n ^ 2 ). чтобы найти каждый элемент.

Sumit Kumar
6 июня 2018 в 10:16
0

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

avatar
Ashok Kumar Jayaraman
7 февраля 2018 в 14:04
6

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

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']
avatar
Anurag Misra
24 августа 2017 в 06:15
11

Лучшее решение этой проблемы - использование встроенной функции 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)
avatar
Charitoo
15 августа 2017 в 02:17
51

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

avatar
Andriy Ivaneyko
4 августа 2016 в 09:49
35

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

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

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

user4805123
4 марта 2017 в 00:08
7

"читаемость на счету" Разница в скорости в небольшом диапазоне <1000 незначительна. Это на 3% медленнее на и без того небольшом временном метрике.

Georgy
22 мая 2019 в 14:20
0

Как насчет обновления ответа на Python 3?

Andriy Ivaneyko
16 июня 2020 в 09:22
0

@Georgy имеет смысл, на python 3.7 enumerate - абсолютный победитель :)

avatar
Liam
25 мая 2015 в 15:26
12

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

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
avatar
ytpillai
25 мая 2015 в 15:08
14

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

for x in range(0, 5):

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

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

list[index]
avatar
Aaron Hall
21 января 2015 в 17:11
1045

Используя цикл 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)
Bergi
22 февраля 2020 в 15:36
1

Работает ли пример « Получение счетчика », когда items пуст?

user12379095
15 мая 2020 в 15:51
0

Я отправляю данные с помощью ajax в представления Django в виде массива в виде двух значений в переменной legData со значениями [1406, 1409]. Если я печатаю на консоли, используя print(legData), вывод будет [1406,1409] . Однако, если я попытаюсь проанализировать отдельные значения списка, например for idx, xLeg in enumerate(legData): print(idx, xLeg), я получу вывод отдельных целых чисел, таких как [, 1, 4, 0, 6 и т. Д., Против индексов 0, 1, 2, 3, 4 и т. Д. (Да, квадратные скобки и запятая также выводятся, как если бы они были частью самих данных ). Что здесь не так?

Aaron Hall
15 мая 2020 в 23:01
0

@ user12379095 у вас, вероятно, есть данные неправильного типа (строка), и вам нужно преобразовать их в фактический список чисел вместо строки. Здесь это несколько не по теме, пожалуйста, удалите свой комментарий и пометьте мой как ненужный, когда вы это увидите.

ShadowRanger
6 октября 2020 в 18:21
1

@Bergi: Не будет, но вы можете просто добавить count = 0 перед циклом, чтобы убедиться, что у него есть значение (и оно правильное, если цикл никогда не присваивается count, поскольку по определению не было элементов).

avatar
A.J.
27 мая 2014 в 10:04
186

Довольно просто запустить его с 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+
   
Antti Haapala
18 марта 2016 в 09:18
11

Вопрос был об индексах списков; поскольку они начинаются с 0, нет особого смысла начинать с другого числа, поскольку индексы будут неправильными (да, OP также сказал, что это неправильно в вопросе). В противном случае вызов переменной, которая является кортежем index, item просто index, как вы заметили, очень вводит в заблуждение. Просто используйте for index, item in enumerate(ints).

hygull
2 января 2018 в 11:31
1

Лучше заключить индекс в пары скобок как (index), он будет работать как на Python версии 2, так и на 3.

pushkin
30 ноября 2018 в 18:24
1

@AnttiHaapala Причина, как я полагаю, в том, что ожидаемый результат вопроса начинается с индекса 1 вместо 0

ShadowRanger
6 октября 2020 в 18:23
0

@hygull: преобразование index в (index) ничего не изменит ни на Py2, ни на Py3. Мне кажется, вы думаете об изменении на print; единственный способ заставить эту работу работать как с Py2, так и с Py3 - это добавить from __future__ import print_function в начало файла, чтобы получить согласованный стиль Py3 print, и изменить print на print(index, item). Или вы читали более раннюю редакцию вопроса, когда index был исходным tuple, не распакованным на два имени, но круглые скобки по-прежнему ничего не меняют, если вы не можете распаковать.

avatar
thinker007
5 мая 2012 в 07:10
13

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

Tadeck
31 марта 2013 в 18:24
24

Это не сработает для перебора генераторов. Просто используйте enumerate ().

TankorSmash
15 августа 2016 в 18:12
0

В настоящее время текущая идиома - это перечисление, а не вызов диапазона.

Jean-François Fabre
20 апреля 2019 в 12:54
0

и это то же самое, что и более старый ответ: coderhelper.com/a/522576/6451573

avatar
Charlie Martin
6 февраля 2009 в 22:52
38

Старомодно:

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)
>>> 
user6734503
29 июля 2018 в 20:57
4

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

user6734503
30 июля 2018 в 13:51
0

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

Ahmad
29 декабря 2020 в 00:15
1

niiice, кое-что c пользователи могут понять

Charlie Martin
29 декабря 2020 в 15:36
1

«Старомодный» на самом деле не означает «неправильный»

William Martens
18 марта 2021 в 11:35
1

@CharlieMartin ЭТО ГЕНИАЛЬНЫЙ ОТВЕТ! Большое спасибо за размещение этого; Это помогло ОЧЕНЬ ! [+10/10]

avatar
David Hanak
6 февраля 2009 в 22:49
112
for i in range(len(ints)):
   print(i, ints[i]) # print updated to print() in Python 3.x+ 
Ben Blank
6 февраля 2009 в 22:52
11

Вероятно, это должно быть xrange для версий до 3.0.

saulspatz
1 августа 2015 в 21:28
53

Вместо этого используйте enumerate

januarvs
15 марта 2017 в 06:31
4

Для Python 2.3, приведенного выше, используйте встроенную функцию enumerate, поскольку она больше Pythonic.

adg
31 марта 2017 в 23:18
1

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

chepner
15 сентября 2017 в 23:15
4

@adg Я не понимаю, как избежать enumerate сохраняет какую-либо логику; вам все равно нужно выбрать, какой объект индексировать с помощью i, нет?

Graham
23 декабря 2018 в 16:33
0

@chepner Если вы просматриваете несколько списков, использование range может иметь смысл. Хотя zip, вероятно, более Pythonic для этих случаев, поэтому использование range все равно будет преждевременной оптимизацией, как упоминается в других комментариях.

naoki fujita
7 мая 2019 в 15:36
0

Это представление полезно, когда я использую numba или cython.

ShadowRanger
6 октября 2020 в 18:27
0

@Graham: Использование range было бы преждевременной пессимизацией, поскольку zip (itertools.izip на Py2) строго лучше для этого случая. О единственном варианте использования для range я знаю, где нет лучшей альтернативы, это повторение перекрывающихся фрагментов последовательности (где вам нужен индекс, но затем используйте его для нарезки, поэтому получение значения с индексом не бесполезно). Вы могли бы заставить его работать без range (и для непоследовательностей) с itertools.tee, но это некрасиво.