lista - python while array loop




Acessando o índice em loops 'for'? (14)

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 um loop com a next função:

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

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

(0, 'a')

podemos usar o que é chamado de " descompactação de seqüência " para extrair os elementos dessa tupla dupla:

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

e quando inspecionamos o index , descobrimos que ele se refere ao primeiro índice, 0, e o 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 de tuplas) cria um código que é mais legível e pode ser mantido:

Então faça isso:

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

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

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

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


É bem simples começar de 1 diferente de 0 :

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

Nota

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


A melhor solução para esse problema é usar enumerar a função python in-build.
enumerar tupla de retorno
primeiro valor é index
segundo valor é o elemento da matriz 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)

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. O item e seu índice são mantidos em variáveis ​​e não há necessidade de escrever nenhum outro código 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 manipula loops aninhados melhor que os outros exemplos.


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

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]

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)

Na 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 quer 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 de 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

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, num in range(1, l + 1):
    print(i, nums[i])

Se não houver nenhum valor duplicado na lista:

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

Em vez disso, use enumerate.

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

OU use abaixo:

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

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

Você pode usar o método de index

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

EDIT Em destaque no comentário que este método não funciona se houver duplicatas no ints , o método abaixo deve funcionar para quaisquer valores 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ê quiser obter o índice e o valor em ints como uma lista de tuplas.

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


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

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






list