it-swarm-pt.tech

Acessando o índice em loops 'for'?

Como eu acesso o índice em si para uma lista como a seguinte?

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

Quando faço um loop através dele usando um loop for, como eu acesso o índice de loop, de 1 a 5 neste caso?

2916
Joan Venge

Usar uma variável de estado adicional, como uma variável de índice (que você normalmente usaria em linguagens como C ou PHP), é considerada não-Pythonica.

A melhor opção é usar a função interna enumerate() , disponível no Python 2 e 3:

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

Check out PEP 279 para mais.

5061
Mike Hordecki

Usando um loop for, como eu acesso o índice de loop, de 1 a 5 neste caso?

Use enumerate para obter o índice com o elemento à medida que você iterar:

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

E note que os índices do Python começam em zero, então você obteria 0 a 4 com o acima. Se você quiser a contagem, de 1 a 5, faça o seguinte:

for count, item in enumerate(items, start=1):
    print(count, item)

Fluxo de controle unidiomático

O que você está pedindo é o equivalente Pythonico do seguinte, que é o algoritmo que a maioria dos programadores de linguagens de nível inferior usaria:

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

Ou em idiomas que não possuem um loop for-each:

index = 0
while index < len(items):
    print(index, items[index])
    index += 1

ou às vezes mais comumente (mas unidiomaticamente) encontrado no Python:

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

Use a função de enumeração

A função enumerate do Python reduz a confusão visual ocultando a contabilidade para os índices e encapsulando o iterável em outro iterável (um objeto enumerate) que produz uma tupla de dois itens do índice e o item que o iterável original forneceria . Isso parece assim:

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

Este exemplo de código é bastante bem o exemplo canonical da diferença entre o código que é idiomático do Python e o código que não é. O código idiomático é um Python sofisticado (mas não complicado), escrito da maneira que deveria ser usado. O código idiomático é esperado pelos projetistas da linguagem, o que significa que geralmente esse código não é apenas mais legível, mas também mais eficiente.

Obtendo uma contagem

Mesmo se você não precisar de índices, mas precisar de uma contagem das iterações (às vezes desejável), você pode começar com 1 e o número final será sua contagem.

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

print('there were {0} items printed'.format(count))

A contagem parece ser mais o que você pretende pedir (em oposição ao índice) quando você disse que queria de 1 a 5.


Quebrando - uma explicação passo a passo

Para quebrar esses exemplos, digamos que temos uma lista de itens que queremos iterar com um índice:

items = ['a', 'b', 'c', 'd', 'e']

Agora passamos isso iterável para enumerar, criando um objeto enumerado:

enumerate_object = enumerate(items) # the enumerate object

Podemos extrair o primeiro item deste iterável que obteríamos em um loop com a função next:

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

E vemos que temos uma tupla de 0, o primeiro índice e 'a', o primeiro item:

(0, 'a')

podemos usar o que é chamado de " sequence unpacking " para extrair os elementos deste Tuple:

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

e quando inspecionamos index, descobrimos que se refere ao primeiro índice, 0, e item refere-se ao primeiro item, 'a'.

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

Conclusão

  • Índices Python começam em zero
  • Para obter esses índices de um iterável à medida que você os iterar, use a função enumerar
  • Usar enumerar na maneira idiomática (junto com a descompactação da Tuple) cria um código mais legível e sustentável:

Então faça isso:

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

É bem simples iniciá-lo em 1 além de 0:

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

Nota

Dica importante, embora um pouco enganosa desde index será um Tuple(idx, item) aqui. Bom para ir.

118
Clayton
for i in range(len(ints)):
   print i, ints[i]
76
David Hanak

Como é a norma em Python, existem várias maneiras de fazer isso. Em todos os exemplos, suponha: lst = [1, 2, 3, 4, 5]

1. Usando enumerar ( considerado mais idiomático )

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

Esta é também a opção mais segura na minha opinião, porque a chance de entrar em recursão infinita foi eliminada. Tanto o item quanto seu índice são mantidos em variáveis ​​e não há necessidade de escrever qualquer código adicional Para acessar o item.

2. Criando uma variável para manter o índice ( usando for)

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

3. Criando uma variável para manter o índice ( usando while)

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

4. Há sempre um outro caminho

Como explicado anteriormente, existem outras maneiras de fazer isso que não foram explicadas aqui e podem até se aplicar mais em outras situações. por exemplo usando itertools.chain com para. Ele lida com loops aninhados melhor que os outros exemplos.

40
Charitoo

Do modo antigo:

for ix in range(len(ints)):
    print ints[ix]

Compreensão da lista:

[ (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)
>>> 
23
Charlie Martin

Eu não sei se o seguinte é Pythonic ou não, mas ele usa a função Python enumerate e imprime o índice e o valor.

int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)

Saída:

0 8
1 23
2 45
3 12
4 78
18
user2912389

O caminho mais rápido para acessar os índices da lista dentro do loop em Python 2.7 é usar o método range para listas pequenas e enumerate method para listas de tamanho médio e grande.

Por favor, veja different approaches que podem ser usados ​​para iterar sobre a lista e acessar o valor do índice e suas métricas de desempenho (que eu suponho que seria útil para você) nos exemplos de código abaixo:

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

Veja as métricas de desempenho para cada método abaixo:

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

Como resultado, usar o método range é o mais rápido para listar com 1000 itens. Para lista com tamanho> 10 000 itens enumerate é o vencedor.

Adicionando alguns links úteis abaixo:

18
Andriy Ivaneyko
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)

Desta forma, você pode estender uma lista. Estender significa que você pode adicionar vários valores por vez.

Para acrescentar esta lista, você deve escrever o código abaixo:

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

Dessa forma, você pode adicionar um único valor por vez. Se você escrever ints.append([1]), isso criará uma sub-lista para este elemento.

15
iamjayp

Em primeiro lugar, os índices serão de 0 a 4. As linguagens de programação começam a contar a partir de 0; não se esqueça disso ou você se deparará com uma exceção de índice fora dos limites. Tudo o que você precisa no loop for é uma variável contando de 0 a 4 da seguinte forma:

for x in range(0, 5):

Tenha em mente que eu escrevi de 0 a 5 porque o loop pára um número antes do máximo. :)

Para obter o valor de um índice, use

list[index]
11
ytpillai

Você pode fazer isso com este código:

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

for value in (ints):
    index +=1
    print index, value

Use este código se você precisar redefinir o valor do índice no final do loop:

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

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0
9
Liam

De acordo com esta discussão: http://bytes.com/topic/python/answers/464012-objects-list-index

Iteração do contador de loop

O idioma atual para fazer o loop sobre os índices faz uso da função 'range' incorporada:

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

Looping sobre ambos os elementos e índices pode ser alcançado pelo idioma antigo ou usando a nova função interna 'Zip' [2]:

for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e

ou

for i, e in Zip(range(len(sequence)), sequence):
    # work with index i and element e

via http://www.python.org/dev/peps/pep-0212/

9
thinker007

A melhor solução para este problema é usar a função python enumerate in-build. 
enumerar retornar Tupla  
primeiro valor é index  
o segundo valor é element do array nesse índice

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)
8
Anurag Misra

Se não houver nenhum valor duplicado na lista:

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

Caso contrário, use enumerate

for counter, value in enumerate(ints):
    print(counter, value)

OU use abaixo:

for counter in range(len(ints)):
    print(counter, ints[counter])
6
RIshu

Veja o que você obtém quando acessa o índice em loops for:

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

enter image description here

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

enter image description here

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

enter image description here

Espero que isto ajude.

4
ARGeo

Em sua pergunta, você escreve "como eu acesso o índice de loop, de 1 a 5 neste caso?"

No entanto, o índice de uma lista é executado a partir de zero. Então, precisamos saber se o que você realmente quer é o índice e o item de cada item de uma lista, ou se você realmente deseja números a partir de 1. Felizmente, em Python é fácil fazer um ou ambos.

Primeiro, para esclarecer, a função enumerar retorna iterativamente o índice e o item correspondente para cada item de uma lista.

alist = [ 1, 2, 3, 4, 5 ]

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

A saída para o acima é então,

0 1
1 2
2 3
3 4
4 5

Observe que o índice é executado a partir de 0. Esse tipo de indexação é comum entre as linguagens de programação modernas, incluindo python e c.

Se você quiser que o seu loop ocupe uma parte da lista, você pode usar a sintaxe padrão do python para uma parte da lista. Por exemplo, para fazer um loop do segundo item em uma lista até, mas não incluindo o último item, você poderia usar

for n,a in enumerate(alist[1:-1]):
    print( "%d %d"%(n,a) )

Observe que, mais uma vez, o índice de saída é executado a partir de 0,

0 2
1 3
2 4

Isso nos leva ao switch start = n para enumerate (). Isso simplesmente compensa o índice, você pode simplesmente adicionar um número ao índice dentro do loop.

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

para o qual a saída é

1 1
2 2
3 3
4 4
5 5
3
DrM

Você também pode tentar isto:

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)

A saída é 

0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']
3
Ashok Kumar Jayaraman

Se eu fosse para iterar nums = [1,2,3,4,5] Eu faria

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

Ou obtenha o comprimento como l = len (nums)

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

Você pode usar o método index

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

EDIT Destacou no comentário que este método não funciona se houver duplicatas em ints, o método abaixo deve funcionar para qualquer valor em ints:

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]

Ou alternativamente

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]

se você deseja obter o índice e o valor em ints como uma lista de tuplas.

Ele usa o método enumerate na resposta selecionada para essa pergunta, mas com a compreensão da lista, tornando-a mais rápida com menos código.

1
PyRsquared

Para imprimir Tupla de (índice, valor) na compreensão da lista usando um loop for:

ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

Saída:

[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]
0
lola

Isso serve bem ao propósito:

list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
    print('index:', list1.index(x), 'value:', x)
0
Sumit Kumar

Isso também pode ser feito usando o método index() 

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

Aqui a indexação começa em 0. Mas, caso você precise iniciá-la a partir de 1, basta adicionar 1 ao método index() da seguinte forma

for i in int:
   print(int.index(i) + 1, i)    
0
Loochie