una - python mostrar lista




Encontrando o índice de um item dada uma lista que o contém em Python (19)

Encontrando o índice de um item dada uma lista que o contém em Python

Para uma lista ["foo", "bar", "baz"] e um item na lista "bar" , qual é a maneira mais limpa de obter seu índice (1) em Python?

Bem, claro, há o método index, que retorna o índice da primeira ocorrência:

>>> l = ["foo", "bar", "baz"]
>>> l.index('bar')
1

Existem alguns problemas com este método:

  • se o valor não estiver na lista, você receberá um ValueError
  • se mais de um valor estiver na lista, você só terá o índice do primeiro

Sem valores

Se o valor pode estar faltando, você precisa pegar o ValueError .

Você pode fazer isso com uma definição reutilizável como esta:

def index(a_list, value):
    try:
        return a_list.index(value)
    except ValueError:
        return None

E usá-lo assim:

>>> print(index(l, 'quux'))
None
>>> print(index(l, 'bar'))
1

E a desvantagem disso é que você provavelmente terá uma verificação para saber se o valor retornado is ou is not nenhum:

result = index(a_list, value)
if result is not None:
    do_something(result)

Mais de um valor na lista

Se você pudesse ter mais ocorrências, você não obterá informações completas com list.index :

>>> l.append('bar')
>>> l
['foo', 'bar', 'baz', 'bar']
>>> l.index('bar')              # nothing at index 3?
1

Você pode enumerar em uma lista os índices de compreensão:

>>> [index for index, v in enumerate(l) if v == 'bar']
[1, 3]
>>> [index for index, v in enumerate(l) if v == 'boink']
[]

Se você não tem ocorrências, pode verificar isso com uma verificação booleana do resultado ou simplesmente não fazer nada se você fizer um loop pelos resultados:

indexes = [index for index, v in enumerate(l) if v == 'boink']
for index in indexes:
    do_something(index)

Melhores dados sobre os pandas

Se você tiver pandas, poderá obter facilmente essas informações com um objeto da série:

>>> import pandas as pd
>>> series = pd.Series(l)
>>> series
0    foo
1    bar
2    baz
3    bar
dtype: object

Uma verificação de comparação retornará uma série de booleanos:

>>> series == 'bar'
0    False
1     True
2    False
3     True
dtype: bool

Passe essa série de booleanos para a série através de notação de subscrito, e você terá apenas os membros correspondentes:

>>> series[series == 'bar']
1    bar
3    bar
dtype: object

Se você quiser apenas os índices, o atributo index retorna uma série de inteiros:

>>> series[series == 'bar'].index
Int64Index([1, 3], dtype='int64')

E se você os quiser em uma lista ou tupla, basta passá-los para o construtor:

>>> list(series[series == 'bar'].index)
[1, 3]

Sim, você poderia usar uma compreensão de lista com enumerar também, mas isso não é tão elegante, na minha opinião - você está fazendo testes de igualdade no Python, em vez de deixar o código interno escrito em C manipulá-lo:

>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]

Isso é um problema XY ?

O problema XY é perguntar sobre sua tentativa de solução, em vez de seu problema real.

Por que você acha que precisa do índice dado um elemento em uma lista?

Se você já conhece o valor, por que você se importa onde está em uma lista?

Se o valor não estiver lá, capturar o ValueError será bastante detalhado - e eu prefiro evitar isso.

Eu geralmente estou iterando sobre a lista de qualquer forma, então eu normalmente vou manter um ponteiro para qualquer informação interessante, obtendo o índice com enumerar.

Se você está digitando dados, provavelmente deveria estar usando pandas - que tem ferramentas muito mais elegantes do que as soluções alternativas do Python que eu mostrei.

Não me lembro de precisar de list.index , eu mesmo. No entanto, examinei a biblioteca padrão do Python e vejo alguns excelentes usos para ela.

Há muitos, muitos usos para ele no idlelib , para a GUI e a análise de texto.

O módulo de keyword usa-o para encontrar marcadores de comentários no módulo para regenerar automaticamente a lista de palavras-chave nele por meio de metaprogramação.

Em Lib / mailbox.py parece estar usando como um mapeamento ordenado:

key_list[key_list.index(old)] = new

e

del key_list[key_list.index(key)]

Em Lib / http / cookiejar.py, parece ser usado para obter o próximo mês:

mon = MONTHS_LOWER.index(mon.lower())+1

Em Lib / tarfile.py semelhante a distutils para obter uma fatia até um item:

members = members[:members.index(tarinfo)]

Em Lib / pickletools.py:

numtopop = before.index(markobject)

O que esses usos parecem ter em comum é que eles parecem operar em listas de tamanhos restritos (importante por causa do tempo de pesquisa O (n) para list.index ), e eles são usados ​​principalmente na análise (e UI no caso de Ocioso).

Embora existam casos de uso para isso, eles são bastante incomuns. Se você estiver procurando por essa resposta, pergunte-se se o que você está fazendo é o uso mais direto das ferramentas fornecidas pelo idioma para o seu caso de uso.

https://code.i-harness.com

Para uma lista ["foo", "bar", "baz"] e um item na lista "bar" , como obtenho seu índice (1) em Python?


E agora para algo completamente diferente...

... como confirmar a existência do item antes de obter o índice. O bom desta abordagem é que a função sempre retorna uma lista de índices - mesmo que seja uma lista vazia. Ele também funciona com strings.

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    retval = []
    last = 0
    while val in l[last:]:
            i = l[last:].index(val)
            retval.append(last + i)
            last += i + 1   
    return retval

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

Quando colado em uma janela interativa do python:

Python 2.7.6 (v2.7.6:3a1db0d2747e, Nov 10 2013, 00:42:54) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(the_list, val):
...     """Always returns a list containing the indices of val in the_list"""
...     retval = []
...     last = 0
...     while val in the_list[last:]:
...             i = the_list[last:].index(val)
...             retval.append(last + i)
...             last += i + 1   
...     return retval
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

Atualizar

Depois de mais um ano de desenvolvimento de python heads-down, estou um pouco envergonhado com a minha resposta original, então, para esclarecer as coisas, certamente podemos usar o código acima; no entanto, a maneira muito mais idiomática de obter o mesmo comportamento seria usar a compreensão da lista, juntamente com a função enumerate ().

Algo assim:

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    return [index for index, value in enumerate(l) if value == val]

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

Que, quando colado em uma janela interativa de python, produz:

Python 2.7.14 |Anaconda, Inc.| (default, Dec  7 2017, 11:07:58) 
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(l, val):
...     """Always returns a list containing the indices of val in the_list"""
...     return [index for index, value in enumerate(l) if value == val]
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

E agora, depois de analisar essa pergunta e todas as respostas, percebo que isso é exatamente o que a sugeriu em sua resposta anterior . Na época em que inicialmente respondi a essa pergunta, nem vi a resposta porque não entendi. Espero que meu exemplo um pouco mais detalhado ajude a compreensão.

Se a única linha de código acima ainda não faz sentido para você, eu recomendo muito a compreensão da lista do Python do Google e demore alguns minutos para se familiarizar. É apenas um dos muitos recursos poderosos que tornam uma alegria usar o Python para desenvolver código.


Obtendo todas as ocorrências e a posição de um ou mais itens (idênticos) em uma lista

Com enumerate (alist) você pode armazenar o primeiro elemento (n) que é o índice da lista quando o elemento x é igual ao que você procura.

>>> alist = ['foo', 'spam', 'egg', 'foo']
>>> foo_indexes = [n for n,x in enumerate(alist) if x=='foo']
>>> foo_indexes
[0, 3]
>>>

Vamos fazer a nossa função findindex

Essa função pega o item e a lista como argumentos e retorna a posição do item na lista, como vimos antes.

def indexlist(item2find, list_or_string):
  "Returns all indexes of an item in a list or a string"
  return [n for n,item in enumerate(list_or_string) if item==item2find]

print(indexlist("1", "010101010"))

Saída

[1, 3, 5, 7]

Simples

for n, i in enumerate([1, 2, 3, 4, 1]):
    if i == 1:
        print(n)

Saída:

0
4

A maioria das respostas explica como encontrar um único índice , mas seus métodos não retornam vários índices se o item estiver na lista várias vezes. Use enumerate() :

for i, j in enumerate(['foo', 'bar', 'baz']):
    if j == 'bar':
        print(i)

A função index() só retorna a primeira ocorrência, enquanto enumerate() retorna todas as ocorrências.

Como uma compreensão da lista:

[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'bar']

Aqui está também outra pequena solução com itertools.count() (que é praticamente a mesma abordagem que enumerar):

from itertools import izip as zip, count # izip for maximum efficiency
[i for i, j in zip(count(), ['foo', 'bar', 'baz']) if j == 'bar']

Isso é mais eficiente para listas maiores do que usando enumerate() :

$ python -m timeit -s "from itertools import izip as zip, count" "[i for i, j in zip(count(), ['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 174 usec per loop
$ python -m timeit "[i for i, j in enumerate(['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 196 usec per loop

Conforme indicado por @TerryA, muitas respostas discutem como encontrar um índice.

more_itertools é uma biblioteca de terceiros com ferramentas para localizar vários índices dentro de um iterável.

Dado

import more_itertools as mit


iterable = ["foo", "bar", "baz", "ham", "foo", "bar", "baz"]

Código

Encontre índices de múltiplas observações:

list(mit.locate(iterable, lambda x: x == "bar"))
# [1, 5]

Teste vários itens:

list(mit.locate(iterable, lambda x: x in {"bar", "ham"}))
# [1, 3, 5]

Veja também mais opções com more_itertools.locate . Instale via more_itertools .


Encontrando o índice do item x na lista L :

idx = L.index(x) if (x in L) else -1

Existe uma resposta mais funcional para isso.

list(filter(lambda x: x[1]=="bar",enumerate(["foo", "bar", "baz", "bar", "baz", "bar", "a", "b", "c"])))

Forma mais genérica:

def get_index_of(lst, element):
    return list(map(lambda x: x[0],\
       (list(filter(lambda x: x[1]==element, enumerate(lst))))))

Há duas possibilidades se a lista não tiver itens repetidos que você precisa verificar o índice para

 eg: li=[10,20,30] # here need to get index of 20 means
     li.index(20) # will work properly because 20 is not repeated

se a sua repetida significa que lhe dará apenas o primeiro índice

Se você precisa obter todo o índice onde o item está presente significa

eg: li=[10,20,30,20,40, 50, 10] # here need to get index of 20 means its have 2 index (1,3) 

para conseguir que você precisa fazer como

 li=[10,20,30,20,40, 50, 10]
 [i for i, e in enumerate(li) if e == 20]

então você vai ter uma lista de índice como o / p como [1,3]


Outra opção

>>> a = ['red', 'blue', 'green', 'red']
>>> b = 'red'
>>> offset = 0;
>>> indices = list()
>>> for i in range(a.count(b)):
...     indices.append(a.index(b,offset))
...     offset = indices[-1]+1
... 
>>> indices
[0, 3]
>>> 

Para aqueles que vêm de outra língua como eu, talvez com um loop simples seja mais fácil de entender e usar:

mylist = ["foo", "bar", "baz", "bar"]
newlist = enumerate(mylist)
for index, item in newlist:
  if item == "bar":
    print(index, item)

Eu sou grato por Então, o que exatamente faz a enumeração? . Isso me ajudou a entender.


Se você quiser todos os índices, então você pode usar o NumPy :

import numpy as np

array = [1, 2, 1, 3, 4, 5, 1]
item = 1
np_array = np.array(array)
item_index = np.where(np_array==item)
print item_index
# Out: (array([0, 2, 6], dtype=int64),)

É uma solução clara e legível.


Simplesmente você pode ir com

a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']]
b = ['phone', 'lost']

res = [[x[0] for x in a].index(y) for y in b]

Todos os índices com a função zip :

get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]

print get_indexes(2, [1, 2, 3, 4, 5, 6, 3, 2, 3, 2])
print get_indexes('f', 'xsfhhttytffsafweef')

Um problema surgirá se o elemento não estiver na lista. Esta função lida com o problema:

# if element is found it returns index of element else returns None

def find_element_in_list(element, list_element):
    try:
        index_element = list_element.index(element)
        return index_element
    except ValueError:
        return None

Uma variante da resposta do FMc e user7177 dará um dict que pode retornar todos os índices para qualquer entrada:

>>> a = ['foo','bar','baz','bar','any', 'foo', 'much']
>>> l = dict(zip(set(a), map(lambda y: [i for i,z in enumerate(a) if z is y ], set(a))))
>>> l['foo']
[0, 5]
>>> l ['much']
[6]
>>> l
{'baz': [2], 'foo': [0, 5], 'bar': [1, 3], 'any': [4], 'much': [6]}
>>> 

Você também pode usar isso como um forro para obter todos os índices para uma única entrada. Não há garantias de eficiência, embora eu tenha usado set (a) para reduzir o número de vezes que o lambda é chamado.


Vamos dar o nome lst à lista que você tem. Pode-se converter a lista lst para um numpy array . E, em seguida, use numpy.where para obter o índice do item escolhido na lista. A seguir é a maneira em que você irá implementá-lo.

 import numpy as np lst = ["foo", "bar", "baz"] #lst: : 'list' data type lst_np = np.array(lst) #lst_np: 'numpy.ndarray' index = np.where( lst_np == 'bar')[0][0] #index: 'numpy.int64' data type print index 1 

index() retorna o primeiro índice de valor!

| índice(...)
| L.index (valor, [start, [stop]]) -> integer - retorna primeiro índice de valor

def all_indices(value, qlist):
    indices = []
    idx = -1
    while True:
        try:
            idx = qlist.index(value, idx+1)
            indices.append(idx)
        except ValueError:
            break
    return indices

all_indices("foo", ["foo","bar","baz","foo"])

>>> ["foo", "bar", "baz"].index("bar")
1

Referência: Estruturas de Dados> Mais sobre Listas

Advertências seguem

Observe que, embora essa seja talvez a maneira mais clara de responder à pergunta, o index é um componente bastante fraco da API da list , e não me lembro da última vez que a usei com raiva. Tem sido apontado para mim nos comentários que, como essa resposta é fortemente referenciada, ela deve ser mais completa. Algumas ressalvas sobre list.index seguem. Provavelmente vale a pena inicialmente dar uma olhada no docstring para isso:

>>> print(list.index.__doc__)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.

Complexidade de tempo linear no comprimento da lista

Uma chamada de index verifica todos os elementos da lista em ordem, até encontrar uma correspondência. Se sua lista é longa e você não sabe aproximadamente onde a lista ocorre, essa pesquisa pode se tornar um gargalo. Nesse caso, você deve considerar uma estrutura de dados diferente. Note que se você sabe aproximadamente onde encontrar a correspondência, você pode dar uma dica ao index . Por exemplo, neste trecho, l.index(999_999, 999_990, 1_000_000) é aproximadamente cinco ordens de magnitude mais rápido que straight l.index(999_999) , porque o primeiro só precisa pesquisar 10 entradas, enquanto o segundo pesquisa um milhão:

>>> import timeit
>>> timeit.timeit('l.index(999_999)', setup='l = list(range(0, 1_000_000))', number=1000)
9.356267921015387
>>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup='l = list(range(0, 1_000_000))', number=1000)
0.0004404920036904514

Apenas retorna o índice da primeira correspondência para seu argumento

Uma chamada para index pesquisas pela lista em ordem até encontrar uma correspondência e parar por aí. Se você espera precisar de mais índices, use uma compreensão de lista ou expressão de gerador.

>>> [1, 1].index(1)
0
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> next(g)
0
>>> next(g)
2

A maioria dos lugares onde eu já usei index , agora uso uma compreensão de lista ou expressão de gerador porque eles são mais generalizáveis. Então, se você está considerando alcançar o index , dê uma olhada nestes excelentes recursos do Python.

Lança se o elemento não estiver presente na lista

Uma chamada para index resulta em um ValueError se o item não estiver presente.

>>> [1, 1].index(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 2 is not in list

Se o item não estiver presente na lista, você deverá

  1. Verifique primeiro com o item in my_list (abordagem limpa e legível) ou
  2. Embrulhe a chamada de index em um bloco try/except , que ValueError (provavelmente mais rápido, pelo menos quando a lista a pesquisar for longa e o item estiver normalmente presente).

name ="bar"
list = [["foo", 1], ["bar", 2], ["baz", 3]]
new_list=[]
for item in list:
    new_list.append(item[0])
print(new_list)
try:
    location= new_list.index(name)
except:
    location=-1
print (location)

Isso explica se a string não está na lista também, se não estiver na lista, então location = -1





list