¿Cómo puedo contar las apariciones de un elemento de la lista?

Dado un elemento, ¿cómo puedo contar sus apariciones en una lista en Python?

preguntado el 08 de abril de 10 a las 10:04

27 Respuestas

Si solo desea el recuento de un elemento, use el count método:

>>> [1, 2, 3, 4, 1, 4, 1].count(1)
3

no utilícelo si desea contar varios elementos. Vocación count en un bucle requiere una pasada por separado de la lista para cada count llamada, que puede ser catastrófica para el rendimiento. Si desea contar todos los elementos, o incluso solo varios elementos, utilice Counter, como se explica en las otras respuestas.

respondido 15 nov., 17:21

mylist = [1,7,7,7,3,9,9,9,7,9,10,0] print sorted(set([i for i in mylist if mylist.count(i)>2])) - codificador cpp

Utiliza Counter si está utilizando Python 2.7 o 3.xy desea la cantidad de ocurrencias para cada elemento:

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})

Respondido el 24 de junio de 20 a las 18:06

He descubierto que cuando se usa mucho esto (hablando de millones de cadenas), es muy lento debido a sus llamadas a isinstance. Entonces, si está seguro de los datos con los que está trabajando, podría ser mejor escribir una función personalizada sin verificación de tipo e instancia. - bram vanroy

@BramVanroy: ¿Qué isinstance llamadas? Incluso con millones de cuerdas, llamando Counter solo involucra a uno isinstance llamar, para comprobar si su argumento es un mapeo. Lo más probable es que haya juzgado mal lo que está comiendo todo el tiempo. - user2357112 es compatible con Monica

Usted malinterpretó lo que quise decir: Counter verifica los tipos de sus datos antes de crear el Counter. Esto lleva relativamente mucho tiempo y si conoce el tipo de datos de antemano. Si observa el método de actualización de Counter, verá que tiene que pasar por tres declaraciones if antes de hacer algo. Si llama a update con frecuencia, esto se suma rápidamente. Cuando tiene control sobre sus datos y sabes qué que la entrada será de hecho iterable, entonces puede omitir las dos primeras comprobaciones. Como dije, solo noté esto cuando trabajé con millones de actualizaciones, por lo que es un caso extremo. - bram vanroy

@BramVanroy: si realiza millones de actualizaciones en lugar de simplemente contar millones de cadenas, esa es una historia diferente. El esfuerzo de optimización en Counter se ha dedicado a contar iterables grandes, en lugar de contar muchos iterables. Contar un iterable de un millón de cadenas será más rápido con Counter que con una implementación manual. Si quieres llamar update con muchos iterables, es posible que pueda acelerar las cosas al unirlos en un iterable con itertools.chain. - user2357112 es compatible con Monica

En caso de que quiera ordenar los resultados cómo-ordenar-contador-por-valor-python -> x = Counter({'a':5, 'b':3, 'c':7}) x.most_common() - javi

Contar las apariciones de un elemento en una lista

Para contar las apariciones de un solo elemento de la lista, puede usar count()

>>> l = ["a","b","b"]
>>> l.count("a")
1
>>> l.count("b")
2

Contando las ocurrencias de todos las Los elementos de una lista también se conocen como "contar" una lista o crear un contador de conteo.

Contando todos los elementos con count ()

Para contar las ocurrencias de elementos en l uno puede simplemente usar una lista de comprensión y el count() Método

[[x,l.count(x)] for x in set(l)]

(o similarmente con un diccionario dict((x,l.count(x)) for x in set(l)))

Ejemplo:

>>> l = ["a","b","b"]
>>> [[x,l.count(x)] for x in set(l)]
[['a', 1], ['b', 2]]
>>> dict((x,l.count(x)) for x in set(l))
{'a': 1, 'b': 2}

Contando todos los elementos con Contador ()

Alternativamente, existe el más rápido Counter clase de la collections bibliotecas

Counter(l)

Ejemplo:

>>> l = ["a","b","b"]
>>> from collections import Counter
>>> Counter(l)
Counter({'b': 2, 'a': 1})

¿Cuánto más rápido es Counter?

Comprobé cuanto más rápido Counter es para contar listas. Probé ambos métodos con algunos valores de n y parece que Counter es más rápido por un factor constante de aproximadamente 2.

Aquí está el script que utilicé:

from __future__ import print_function
import timeit

t1=timeit.Timer('Counter(l)', \
                'import random;import string;from collections import Counter;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
                )

t2=timeit.Timer('[[x,l.count(x)] for x in set(l)]',
                'import random;import string;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]'
                )

print("Counter(): ", t1.repeat(repeat=3,number=10000))
print("count():   ", t2.repeat(repeat=3,number=10000)

Y la salida:

Counter():  [0.46062711701961234, 0.4022796869976446, 0.3974247490405105]
count():    [7.779430688009597, 7.962715800967999, 8.420845870045014]

contestado el 23 de mayo de 17 a las 11:05

Counter is mucho más rápido para listas más grandes. El método de comprensión de la lista es O (n ^ 2), Counter debe ser O (n). - fucho

El contador no es más rápido en un factor de 2, el contador es más rápido en un factor de XNUMX. factor de n (O (n ^ 2) frente a O (n)). - Martijn Pieters ♦

He descubierto que cuando se usa mucho esto (hablando de millones de cadenas), es muy lento debido a sus llamadas a isinstance. Entonces, si está seguro de los datos con los que está trabajando, podría ser mejor escribir una función personalizada sin verificación de tipo e instancia. - bram vanroy

Otra forma de obtener el número de ocurrencias de cada elemento, en un diccionario:

dict((i, a.count(i)) for i in a)

Respondido 31 Jul 15, 13:07

esto parece una de las construcciones que a menudo se me ocurren en el fragor de la batalla, pero se ejecutará a través de len (a) veces, lo que significa complejidad cuadrática en tiempo de ejecución (ya que cada ejecución depende de len (a) nuevamente). - Nicolas78

¿Dict ((i, a.count (i)) for i en el conjunto (a)) sería más correcto y más rápido? - hugo24

@ hugo24: Un poco, pero no será asintóticamente más rápido en el peor de los casos; tomará n * (number of different items) operaciones, sin contar el tiempo que lleva construir el conjunto. Utilizando collections.Counter es mucho mejor. - Clemente

muy tarde para la fiesta, pero el código siguiente no arrojaría un error si una lista contuviera más de una instancia de i, porque intentará ingresar varias claves del mismo valor en un diccionario. dict((i, a.count(i)) for i in a) - rp1

@ rp1 puede probarlo usted mismo y ver que los pares clave-valor posteriores simplemente sobrescriben la entrada anterior para la misma clave, por ejemplo dict([(1, 2), (1, 3)]) devoluciones {1: 3} - xuiqzy

list.count(x) devuelve el número de veces x aparece en una lista

ver: http://docs.python.org/tutorial/datastructures.html#more-on-lists

Respondido el 24 de diciembre de 15 a las 13:12

Dado un elemento, ¿cómo puedo contar sus apariciones en una lista en Python?

Aquí hay una lista de ejemplo:

>>> l = list('aaaaabbbbcccdde')
>>> l
['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e']

list.count

Ahí está el list.count Método

>>> l.count('b')
4

Esto funciona bien para cualquier lista. Las tuplas también tienen este método:

>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6

collections.Counter

Y luego están las colecciones. Contador. Puede volcar cualquier iterable en un contador, no solo en una lista, y el contador conservará una estructura de datos de los recuentos de los elementos.

Uso:

>>> from collections import Counter
>>> c = Counter(l)
>>> c['b']
4

Los contadores se basan en diccionarios de Python, sus claves son los elementos, por lo que las claves deben ser hash. Básicamente son como conjuntos que permiten elementos redundantes en ellos.

Uso adicional de collections.Counter

Puede sumar o restar con iterables de su contador:

>>> c.update(list('bbb'))
>>> c['b']
7
>>> c.subtract(list('bbb'))
>>> c['b']
4

Y también puede realizar operaciones de varios conjuntos con el contador:

>>> c2 = Counter(list('aabbxyz'))
>>> c - c2                   # set difference
Counter({'a': 3, 'c': 3, 'b': 2, 'd': 2, 'e': 1})
>>> c + c2                   # addition of all elements
Counter({'a': 7, 'b': 6, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c | c2                   # set union
Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1})
>>> c & c2                   # set intersection
Counter({'a': 2, 'b': 2})

¿Por qué no pandas?

Otra respuesta sugiere:

¿Por qué no usar pandas?

Pandas es una biblioteca común, pero no está en la biblioteca estándar. Agregarlo como requisito no es trivial.

Hay soluciones integradas para este caso de uso en el objeto de lista en sí, así como en la biblioteca estándar.

Si su proyecto aún no requiere pandas, sería una tontería convertirlo en un requisito solo para esta funcionalidad.

Respondido el 20 de junio de 20 a las 10:06

Si bien "por qué no Pandas" es apropiado, probablemente debería ir acompañado de "cuándo usar NumPy", es decir, para matrices numéricas grandes. El factor decisivo no son solo las limitaciones del proyecto, hay eficiencias de memoria con NumPy que se hacen evidentes con big data. - JPP

Gracias por mencionar Pandas / etc como una dependencia grave. Algunos de estos paquetes tienen efectos secundarios negativos. Por lo tanto, la adición de estos activos para necesidades triviales puede costar mucho tiempo y dólares. Personalmente, he experimentado que Numpy y SciPi agregan 30 minutos a nuestra canalización de CI y tomó días para que el paquete se almacenara en caché correctamente. Grandes paquetes, pero a veces hay gastos ocultos. Hizo +1 - Marc

Si deseas contar todos los valores a la vez puedes hacerlo muy rápido usando matrices numpy y bincount como sigue

import numpy as np
a = np.array([1, 2, 3, 4, 1, 4, 1])
np.bincount(a)

lo que da

>>> array([0, 3, 1, 1, 2])

respondido 19 nov., 13:10

He comparado todas las soluciones sugeridas (y algunas nuevas) con diagrama de rendimiento (un pequeño proyecto mío).

Cálculo una ít

Para matrices lo suficientemente grandes, resulta que

numpy.sum(numpy.array(a) == 1) 

es un poco más rápido que las otras soluciones.

enter image description here

Cálculo todos las artículos

Como se estableció antes,

numpy.bincount(a)

es lo que quieres.

enter image description here


Código para reproducir las parcelas:

from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot


def counter(a):
    return Counter(a)


def count(a):
    return dict((i, a.count(i)) for i in set(a))


def bincount(a):
    return numpy.bincount(a)


def pandas_value_counts(a):
    return pandas.Series(a).value_counts()


def occur_dict(a):
    d = {}
    for i in a:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
    return d


def count_unsorted_list_items(items):
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


def operator_countof(a):
    return dict((i, operator.countOf(a, i)) for i in set(a))


perfplot.show(
    setup=lambda n: list(numpy.random.randint(0, 100, n)),
    n_range=[2**k for k in range(20)],
    kernels=[
        counter, count, bincount, pandas_value_counts, occur_dict,
        count_unsorted_list_items, operator_countof
        ],
    equality_check=None,
    logx=True,
    logy=True,
    )

2.

from collections import Counter
from collections import defaultdict
import numpy
import operator
import pandas
import perfplot


def counter(a):
    return Counter(a)


def count(a):
    return dict((i, a.count(i)) for i in set(a))


def bincount(a):
    return numpy.bincount(a)


def pandas_value_counts(a):
    return pandas.Series(a).value_counts()


def occur_dict(a):
    d = {}
    for i in a:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
    return d


def count_unsorted_list_items(items):
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


def operator_countof(a):
    return dict((i, operator.countOf(a, i)) for i in set(a))


perfplot.show(
    setup=lambda n: list(numpy.random.randint(0, 100, n)),
    n_range=[2**k for k in range(20)],
    kernels=[
        counter, count, bincount, pandas_value_counts, occur_dict,
        count_unsorted_list_items, operator_countof
        ],
    equality_check=None,
    logx=True,
    logy=True,
    )

Respondido el 13 de Septiembre de 17 a las 11:09

numpy.bincount () funcionará solo para listas con elementos int. - Mukarram pachá

Si puedes usar pandas, entonces value_counts está ahí para el rescate.

>>> import pandas as pd
>>> a = [1, 2, 3, 4, 1, 4, 1]
>>> pd.Series(a).value_counts()
1    3
4    2
3    1
2    1
dtype: int64

También clasifica automáticamente el resultado según la frecuencia.

Si desea que el resultado esté en una lista de lista, haga lo siguiente

>>> pd.Series(a).value_counts().reset_index().values.tolist()
[[1, 3], [4, 2], [3, 1], [2, 1]]

Respondido el 31 de enero de 18 a las 10:01

Sin embargo, los pandas tienen muchos gastos generales, por lo que es la solución más lenta con pequeñas cantidades de datos. stackoverflow.com/a/46195192/125507 - endolito

¿Por qué no usar Pandas?

import pandas as pd

l = ['a', 'b', 'c', 'd', 'a', 'd', 'a']

# converting the list to a Series and counting the values
my_count = pd.Series(l).value_counts()
my_count

Salida:

a    3
d    2
b    1
c    1
dtype: int64

Si está buscando un recuento de un elemento en particular, diga a, intentar:

my_count['a']

Salida:

3

respondido 29 nov., 16:21

Tuve este problema hoy y desarrollé mi propia solución antes de pensar en verificar SO. Esto:

dict((i,a.count(i)) for i in a)

es muy, muy lento para listas grandes. Mi solución

def occurDict(items):
    d = {}
    for i in items:
        if i in d:
            d[i] = d[i]+1
        else:
            d[i] = 1
return d

es en realidad un poco más rápido que la solución Counter, al menos para Python 2.7.

respondido 07 nov., 11:19

El contador ordena las entradas mientras que la suya no, de ahí la diferencia de velocidad (es cierto en el momento de escribir este artículo, no estoy seguro de si fue cuando escribió la respuesta. Aún así, podría ser relevante para alguien que se desplaza hacia abajo). defectos del caos

El contador en Python 2 fue un poco lento, sí. Sin embargo, utiliza código optimizado en C para realizar el conteo en Python 3, y ahora supera su ciclo con facilidad. - Martijn Pieters ♦

# Python >= 2.6 (defaultdict) && < 2.7 (Counter, OrderedDict)
from collections import defaultdict
def count_unsorted_list_items(items):
    """
    :param items: iterable of hashable items to count
    :type items: iterable

    :returns: dict of counts like Py2.7 Counter
    :rtype: dict
    """
    counts = defaultdict(int)
    for item in items:
        counts[item] += 1
    return dict(counts)


# Python >= 2.2 (generators)
def count_sorted_list_items(items):
    """
    :param items: sorted iterable of items to count
    :type items: sorted iterable

    :returns: generator of (item, count) tuples
    :rtype: generator
    """
    if not items:
        return
    elif len(items) == 1:
        yield (items[0], 1)
        return
    prev_item = items[0]
    count = 1
    for item in items[1:]:
        if prev_item == item:
            count += 1
        else:
            yield (prev_item, count)
            count = 1
            prev_item = item
    yield (item, count)
    return


import unittest
class TestListCounters(unittest.TestCase):
    def test_count_unsorted_list_items(self):
        D = (
            ([], []),
            ([2], [(2,1)]),
            ([2,2], [(2,2)]),
            ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
            )
        for inp, exp_outp in D:
            counts = count_unsorted_list_items(inp) 
            print inp, exp_outp, counts
            self.assertEqual(counts, dict( exp_outp ))

        inp, exp_outp = UNSORTED_WIN = ([2,2,4,2], [(2,3), (4,1)])
        self.assertEqual(dict( exp_outp ), count_unsorted_list_items(inp) )


    def test_count_sorted_list_items(self):
        D = (
            ([], []),
            ([2], [(2,1)]),
            ([2,2], [(2,2)]),
            ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]),
            )
        for inp, exp_outp in D:
            counts = list( count_sorted_list_items(inp) )
            print inp, exp_outp, counts
            self.assertEqual(counts, exp_outp)

        inp, exp_outp = UNSORTED_FAIL = ([2,2,4,2], [(2,3), (4,1)])
        self.assertEqual(exp_outp, list( count_sorted_list_items(inp) ))
        # ... [(2,2), (4,1), (2,1)]

Respondido 24 Jul 15, 19:07

@plaes: ¿Cómo es eso? Si por "empresarial" te refieres a "documentado" en preparación para las anotaciones de Py3k, estoy de acuerdo. - Wes Turner

Este es un gran ejemplo, ya que estoy desarrollando principalmente en 2.7, pero tengo que tener rutas de migración a 2.4. - Adam Lewis

A continuación se muestran las tres soluciones:

Lo más rápido es usar un bucle for y almacenarlo en un diccionario.

import time
from collections import Counter


def countElement(a):
    g = {}
    for i in a:
        if i in g: 
            g[i] +=1
        else: 
            g[i] =1
    return g


z = [1,1,1,1,2,2,2,2,3,3,4,5,5,234,23,3,12,3,123,12,31,23,13,2,4,23,42,42,34,234,23,42,34,23,423,42,34,23,423,4,234,23,42,34,23,4,23,423,4,23,4]


#Solution 1 - Faster
st = time.monotonic()
for i in range(1000000):
    b = countElement(z)
et = time.monotonic()
print(b)
print('Simple for loop and storing it in dict - Duration: {}'.format(et - st))

#Solution 2 - Fast
st = time.monotonic()
for i in range(1000000):
    a = Counter(z)
et = time.monotonic()
print (a)
print('Using collections.Counter - Duration: {}'.format(et - st))

#Solution 3 - Slow
st = time.monotonic()
for i in range(1000000):
    g = dict([(i, z.count(i)) for i in set(z)])
et = time.monotonic()
print(g)
print('Using list comprehension - Duration: {}'.format(et - st))

Resultado

#Solution 1 - Faster
{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 234: 3, 23: 10, 12: 2, 123: 1, 31: 1, 13: 1, 42: 5, 34: 4, 423: 3}
Simple for loop and storing it in dict - Duration: 12.032000000000153
#Solution 2 - Fast
Counter({23: 10, 4: 6, 2: 5, 42: 5, 1: 4, 3: 4, 34: 4, 234: 3, 423: 3, 5: 2, 12: 2, 123: 1, 31: 1, 13: 1})
Using collections.Counter - Duration: 15.889999999999418
#Solution 3 - Slow
{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 34: 4, 423: 3, 234: 3, 42: 5, 12: 2, 13: 1, 23: 10, 123: 1, 31: 1}
Using list comprehension - Duration: 33.0

respondido 02 nov., 18:08

En su lugar, use Counter como se menciona en la solución anterior por @ user52028778 - Kishan K.

@KishanK Si ve mi respuesta, también probé con Counter (Solución 2), pero aún así, la Solución1 que usa el bucle se ejecuta más rápido que él. - akasha swain

Contar todos los elementos con itertools.groupby()

Otra posibilidad de obtener el recuento de todos los elementos de la lista podría ser mediante itertools.groupby().

Con recuentos "duplicados"

from itertools import groupby

L = ['a', 'a', 'a', 't', 'q', 'a', 'd', 'a', 'd', 'c']  # Input list

counts = [(i, len(list(c))) for i,c in groupby(L)]      # Create value-count pairs as list of tuples 
print(counts)

Devoluciones

[('a', 3), ('t', 1), ('q', 1), ('a', 1), ('d', 1), ('a', 1), ('d', 1), ('c', 1)]

Observe cómo combinó los tres primeros aes como el primer grupo, mientras que otros grupos de a están presentes más abajo en la lista. Esto sucede porque la lista de entrada L no fue ordenado. A veces, esto puede ser un beneficio si los grupos deberían estar separados.

Con recuentos únicos

Si se desean recuentos de grupos únicos, simplemente ordene la lista de entrada:

counts = [(i, len(list(c))) for i,c in groupby(sorted(L))]
print(counts)

Devoluciones

[('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)]

Nota: Para crear recuentos únicos, muchas de las otras respuestas proporcionan un código más fácil y legible en comparación con el groupby solución. Pero aquí se muestra para dibujar un paralelo al ejemplo de conteo duplicado.

Respondido 25 Abr '19, 19:04

Se sugirió usar numpy's bincount, sin embargo, solo funciona para matrices 1d con enteros no negativos. Además, la matriz resultante puede ser confusa (contiene las ocurrencias de los enteros del mínimo al máximo de la lista original y pone a 0 los enteros faltantes).

Una mejor manera de hacerlo con numpy es usar el único función con el atributo return_counts establecido en Verdadero. Devuelve una tupla con una matriz de valores únicos y una matriz de las apariciones de cada valor único.

# a = [1, 1, 0, 2, 1, 0, 3, 3]
a_uniq, counts = np.unique(a, return_counts=True)  # array([0, 1, 2, 3]), array([2, 3, 1, 2]

y luego podemos emparejarlos como

dict(zip(a_uniq, counts))  # {0: 2, 1: 3, 2: 1, 3: 2}

También funciona con otros tipos de datos y "listas 2d", p. Ej.

>>> a = [['a', 'b', 'b', 'b'], ['a', 'c', 'c', 'a']]
>>> dict(zip(*np.unique(a, return_counts=True)))
{'a': 3, 'b': 3, 'c': 2}

Respondido 21 Oct 18, 23:10

Aunque es una pregunta muy antigua, pero como no encontré una sola línea, hice una.

# original numbers in list
l = [1, 2, 2, 3, 3, 3, 4]

# empty dictionary to hold pair of number and its count
d = {}

# loop through all elements and store count
[ d.update( {i:d.get(i, 0)+1} ) for i in l ]

print(d)

Respondido 04 Jul 19, 07:07

No utilice listas comprensivas para efectos secundarios. Ver: ¿Es Pythonic usar listas de comprensión solo para efectos secundarios? - Georgy

Para contar el número de elementos diversos que tienen un tipo común:

li = ['A0','c5','A8','A2','A5','c2','A3','A9']

print sum(1 for el in li if el[0]=='A' and el[1] in '01234')

da

3 no 6

Respondido 14 ago 11, 16:08

También puedes usar countOf método de un módulo incorporado operator.

>>> import operator
>>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1)
3

Respondido el 18 de Septiembre de 16 a las 21:09

¿Cómo es countOf ¿está implementado? ¿Cómo se compara con lo más obvio? list.count (que se beneficia de la implementación de C)? ¿Hay ventajas? - Chris_Rands

Puede que no sea el más eficiente, requiere una pasada adicional para eliminar duplicados.

Implementación funcional:

arr = np.array(['a','a','b','b','b','c'])
print(set(map(lambda x  : (x , list(arr).count(x)) , arr)))

devoluciones :

{('c', 1), ('b', 3), ('a', 2)}

o regresa como dict :

print(dict(map(lambda x  : (x , list(arr).count(x)) , arr)))

devoluciones :

{'b': 3, 'c': 1, 'a': 2}

respondido 01 mar '18, 10:03

Dada una lista X

 import numpy as np
 X = [1, -1, 1, -1, 1]

El diccionario que muestra i: frecuencia (i) para los elementos de esta lista es:

{i:X.count(i) for i in np.unique(X)}

Salida:

{-1: 2, 1: 3}

Respondido el 19 de Septiembre de 20 a las 02:09

¿Numpy calcula previamente esto de una manera inteligente a medida que se crea la lista? Si no es así, se trata de una O (n ^ 2). - pavel gurkov

yo usaría filter(), tome el ejemplo de Lukasz:

>>> lst = [1, 2, 3, 4, 1, 4, 1]
>>> len(filter(lambda x: x==1, lst))
3

Respondido el 28 de enero de 20 a las 19:01

Esto genera la excepción 'el filtro de objeto no tiene len ()' en Python 3.5 - Yuri Pozniak

En Python 3, debe usar list () para convertir el objeto de filtro en una lista. - IPython

sum([1 for elem in <yourlist> if elem==<your_value>])

Esto devolverá la cantidad de ocurrencias de your_value

Respondido 23 ago 17, 02:08

utilice% timeit para ver qué operación es más eficiente. Las operaciones de recuento de np.array deberían ser más rápidas.

 from collections import Counter
 mylist = [1,7,7,7,3,9,9,9,7,9,10,0] 
 types_counts=Counter(mylist)
 print(types_counts)

Respondido el 31 de enero de 21 a las 15:01

si desea una serie de apariciones para el elemento en particular:

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> single_occurrences = Counter(z)
>>> print(single_occurrences.get("blue"))
3
>>> print(single_occurrences.values())
dict_values([3, 2, 1])

Respondido el 29 de junio de 18 a las 15:06

l2=[1,"feto",["feto",1,["feto"]],['feto',[1,2,3,['feto']]]]
count=0
 def Test(l):   
        global count 
        if len(l)==0:
             return count
        count=l.count("feto")
        for i in l:
             if type(i) is list:
                count+=Test(i)
        return count   
    print(Test(l2))

esto contará recursivamente o buscará el elemento en la lista incluso si está en la lista de listas

Respondido 20 Abr '20, 05:04

No sé por qué alguien simplemente rechaza una respuesta y es completamente útil. Mohamed Fathallah

test = [409.1, 479.0, 340.0, 282.4, 406.0, 300.0, 374.0, 253.3, 195.1, 269.0, 329.3, 250.7, 250.7, 345.3, 379.3, 275.0, 215.2, 300.0]

for i in test:
    print('{} numbers {}'.format(i, test.count(i)))

respondido 16 mar '21, 19:03

def countfrequncyinarray(arr1):
    r=len(arr1)
    return {i:arr1.count(i) for i in range(1,r+1)}
arr1=[4,4,4,4]
a=countfrequncyinarray(arr1)
print(a)

Respondido 07 Jul 18, 09:07

Si bien este código puede responder a la pregunta, proporcionar un contexto adicional sobre por qué y / o cómo este código responde a la pregunta mejora su valor a largo plazo. - alex riabov

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.