Si vous voulez seulement un élément du comte, utilisez le count méthode:
>>>[1,2,3,4,1,4,1].count(1)3
Ne pas utilisez cette option si vous souhaitez compter plusieurs éléments. L'appel de count dans une boucle à part passer au-dessus de la liste pour chaque count appel, qui peut être catastrophique pour la performance. Si vous voulez compter tous les éléments, ou même simplement de plusieurs éléments, utilisez Counter, comme expliqué dans les autres réponses.
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]))
Si vous utilisez Python 2.7 ou 3 et vous souhaitez le nombre d'occurrences pour chaque élément:
>>>from collections importCounter>>> z =['blue','red','blue','yellow','blue','red']>>>Counter(z)Counter({'blue':3,'red':2,'yellow':1})
J'ai constaté que lors de l'utilisation de ce beaucoup (parler des millions de chaînes de caractères) qu'il est très lent à cause de ses appels à isinstance. Donc, si vous êtes certain sur les données que vous travaillez avec, il pourrait être préférable d'écrire une fonction personnalisée sans type et l'instance de contrôle.
Ce isinstance appels? Même avec des millions de chaînes, appelant Counter ne comporte qu'une seule isinstance appel, pour vérifier si son argument est une cartographie. Vous avez probablement sous-estimé ce qui est de manger tout votre temps.
Vous avez mal interprété ce que je voulais dire: Contre-vérifie le type de vos données avant qu'il ne crée le Comptoir. Cela prend relativement beaucoup de temps et si vous connaissez le type de vos données à l'avance. Si vous regardez le Compteur de la méthode de mise à jour, vous verrez qu'il doit passer par trois si-états avant de faire quelque chose. Si vous appelez de mise à jour fréquemment, ce qui ajoute rapidement. Lorsque vous avez le contrôle sur vos données et vous savoir que l'entrée sera en effet un objet iterable, alors vous pouvez sauter les deux premiers contrôles. Comme je l'ai dit, je n'ai remarqué cela lorsque l'on travaille avec des millions de mises à jour donc c'est un cas limite.
Si vous effectuez des millions de mise à jour plutôt qu'un simple comptage des millions de chaînes, c'est une autre histoire. L'effort d'optimisation en Counter a disparu dans le comptage des grandes iterables, plutôt que de compter de nombreux iterables. Comptant plus d'un million de chaîne itérable va aller plus vite avec Counter qu'avec un manuel de mise en œuvre. Si vous voulez l'appeler update avec de nombreux iterables, vous pouvez être en mesure d'accélérer les choses en se joignant à eux dans un objet iterable avec itertools.chain.
Compter les occurrences d'un élément dans une liste
Pour compter les occurrences d'un seul élément de la liste, vous pouvez utiliser count()
>>> l =["a","b","b"]>>> l.count("a")1>>> l.count("b")2
Compter les occurrences de tous éléments dans une liste est également connu comme le "comptage", une liste, ou la création d'un compteur de pointage.
Comptage de tous les éléments avec la fonction count()
Pour compter les occurrences d'éléments dans l on peut simplement utiliser une liste de la compréhension et de la count() méthode
[[x,l.count(x)]for x in set(l)]
(ou même avec un dictionnaire dict((x,l.count(x)) for x in set(l)))
Exemple:
>>> 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}
En comptant tous les articles avec le Compteur()
Sinon, il y a le plus vite Counter classe à partir de la collections bibliothèque
Counter(l)
Exemple:
>>> l =["a","b","b"]>>>from collections importCounter>>>Counter(l)Counter({'b':2,'a':1})
Comment beaucoup plus rapide est Contre?
J'ai vérifié comment beaucoup plus rapide Counter est pour le décompte des listes. J'ai essayé les deux méthodes avec quelques valeurs de n et il semble que Counter est plus rapide par un facteur constant d'environ 2.
Voici le script que j'ai utilisé:
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)
Counter est moyen le plus rapide pour les grandes listes. La liste de compréhension de la méthode est O(n^2), Counter devrait être O(n).
Le compteur n'est pas plus rapide d'un facteur de 2, Counter est plus rapide par un facteur de n (O(n^2) vs O(n)).
count() travaille également sur les cordes, juste dire
J'ai constaté que lors de l'utilisation de ce beaucoup (parler des millions de chaînes de caractères) qu'il est très lent à cause de ses appels à isinstance. Donc, si vous êtes certain sur les données que vous travaillez avec, il pourrait être préférable d'écrire une fonction personnalisée sans type et l'instance de contrôle.
Une autre façon d'obtenir le nombre d'occurrences de chaque élément, dans un dictionnaire:
dict((i, a.count(i))for i in a)
cela ressemble à une des constructions je viens souvent dans la chaleur de la bataille, mais il sera exécuté par l'intermédiaire d'un len(a) temps ce qui signifie quadratique d'exécution de la complexité (comme chaque exécution dépend de la len(encore une fois).
serait-dict((i,une.count(i)) for i in set(a)) est plus juste et plus vite?
Un peu, mais il ne sera pas asymptotiquement plus rapide dans le pire des cas, il faudra n * (number of different items) opérations, sans compter le temps qu'il faut pour construire l'ensemble. À l'aide de collections.Counter est vraiment beaucoup mieux.
Donné un élément, comment puis-je calculer le nombre de ses occurrences dans une liste en Python?
Voici un exemple de liste:
>>> l = list('aaaaabbbbcccdde')>>> l
['a','a','a','a','a','b','b','b','b','c','c','c','d','d','e']
list.count
Il y a le list.count méthode
>>> l.count('b')4
Cela fonctionne très bien pour tout liste de. Des Tuples de cette méthode ainsi:
>>> t = tuple('aabbbffffff')>>> t
('a','a','b','b','b','f','f','f','f','f','f')>>> t.count('f')6
collections.Counter
Et puis il y a les collections.Le compteur. Vous pouvez vider de tout objet iterable dans un Compteur, et pas seulement une liste, et le Compteur de conserver une structure de données de la numération des éléments.
Utilisation:
>>>from collections importCounter>>> c =Counter(l)>>> c['b']4
Compteurs sont basés sur Python dictionnaires, leurs clés sont les éléments, de sorte que les clés doivent être hashable. Ils sont un peu comme des ensembles qui permettent des éléments redondants dans les.
Une plus grande utilisation des collections.Counter
Vous pouvez ajouter ou à soustraire à iterables de votre compteur:
Et vous pouvez le faire multi-ensemble des opérations avec le compteur ainsi:
>>> c2 =Counter(list('aabbxyz'))>>> c - c2 # set differenceCounter({'a':3,'c':3,'b':2,'d':2,'e':1})>>> c + c2 # addition of all elementsCounter({'a':7,'b':6,'c':3,'d':2,'e':1,'y':1,'x':1,'z':1})>>> c | c2 # set unionCounter({'a':5,'b':4,'c':3,'d':2,'e':1,'y':1,'x':1,'z':1})>>> c & c2 # set intersectionCounter({'a':2,'b':2})
Pourquoi ne pas les pandas?
Une autre réponse suggère:
Pourquoi ne pas utiliser les pandas?
Pandas est une bibliothèque commune, mais il n'est pas dans la bibliothèque standard. L'ajout d'une exigence est non-trivial.
Il y a intégré des solutions pour ce cas d'utilisation dans la liste de l'objet lui-même que dans la bibliothèque standard.
Si votre projet n'a pas déjà nécessitent des pandas, il serait stupide d'en faire une obligation, juste pour cette fonctionnalité.
Tandis que "pourquoi pas des Pandas", il doit probablement être accompagnée par "quand utiliser NumPy", c'est à dire pour les grands tableaux numériques. Le facteur décisif n'est pas seulement des limites du projet, il y a de la mémoire de l'efficience avec NumPy, qui se manifestent avec le big data.
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
De sortie:
a 3
d 2
b 1
c 1
dtype: int64
Si vous êtes à la recherche pour le compte d'un élément particulier, dire un, essayez:
J'ai eu ce problème aujourd'hui et roulé ma propre solution avant que je pense à vérifier DONC. Ce:
dict((i,a.count(i))for i in a)
est vraiment, vraiment lent pour les grandes listes. Ma solution
def occurDict(items):
d ={}for i in items:if i in d:
d[i]= d[i]+1else:
d[i]=1return d
est effectivement un peu plus rapide que la solution de Comptoir, au moins pour Python 2.7.
Compteur de trie les entrées, tandis que le vôtre ne pas, d'où la différence de vitesse (Vrai à l'époque de la rédaction, vous ne savez pas si il était quand vous avez écrit la réponse. Encore, il peut être utile pour quelqu'un défilement vers le bas.)
Compteur en Python 2 a été un peu lent sur le côté, oui. Il utilise C-optimisation de code pour effectuer le comptage en Python 3 toutefois, et maintenant les battements de votre boucle avec facilité.
Nombre de tous les éléments avec itertools.groupby()
Antoher possiblité pour obtenir le nombre de tous les éléments dans la liste pourrait être par le biais de itertools.groupby().
Avec "double" compte
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)
Remarquez comment il a combiné les trois premiers a's que le premier groupe, alors que d'autres groupes de a sont présents plus bas dans la liste. Cela se produit parce que la liste d'entrée L n'a pas été trié. Cela peut être un avantage, parfois, si les groupes devraient en fait être séparés.
Avec des nombres uniques
Si unique, le nombre de groupes sont souhaités, de trier la liste d'entrée:
counts =[(i, len(list(c)))for i,c in groupby(sorted(L))]print(counts)
Retourne
[('a',5),('c',1),('d',2),('q',1),('t',1)]
Remarque: Pour la création des nombres uniques, de nombreuses autres réponses fournissent plus facile et plus lisible le code par rapport à la groupby solution. Mais il est montré ici pour tracer une parallèle à la double comptage exemple.
Il a été suggéré d'utiliser numpy est bincount, mais il ne fonctionne que pour les tableaux 1d avec entiers non négatifs. Aussi, le tableau qui en résulte peut être source de confusion (il contient les occurrences des nombres entiers du min au max de la liste d'origine, et met à 0 les entiers manquants).
Une meilleure façon de le faire avec numpy est d'utiliser le unique fonction avec l'attribut return_counts définie sur True. Elle renvoie un tuple avec un tableau de valeurs uniques et un tableau des occurrences de chaque valeur unique.
Plus rapide est d'utiliser une boucle for et de le stocker dans un Dict.
import time
from collections importCounterdef countElement(a):
g ={}for i in a:if i in g:
g[i]+=1else:
g[i]=1return 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))
Résultat
#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}Simplefor loop and storing it in dict -Duration:12.032000000000153
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)
Alors que ce code peut répondre à la question, en fournissant plus de contexte sur le pourquoi et/ou comment ce code répond à la question améliore sa valeur à long terme.
Même si elle est très vieille question, mais comme je n'ai pas trouvé une seule ligne, j'en ai fait une.
# 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)
Si vous voulez seulement un élément du comte, utilisez le
count
méthode:Ne pas utilisez cette option si vous souhaitez compter plusieurs éléments. L'appel de
count
dans une boucle à part passer au-dessus de la liste pour chaquecount
appel, qui peut être catastrophique pour la performance. Si vous voulez compter tous les éléments, ou même simplement de plusieurs éléments, utilisezCounter
, comme expliqué dans les autres réponses.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]))
Si vous utilisez Python 2.7 ou 3 et vous souhaitez le nombre d'occurrences pour chaque élément:
isinstance
. Donc, si vous êtes certain sur les données que vous travaillez avec, il pourrait être préférable d'écrire une fonction personnalisée sans type et l'instance de contrôle.isinstance
appels? Même avec des millions de chaînes, appelantCounter
ne comporte qu'une seuleisinstance
appel, pour vérifier si son argument est une cartographie. Vous avez probablement sous-estimé ce qui est de manger tout votre temps.Counter
a disparu dans le comptage des grandes iterables, plutôt que de compter de nombreux iterables. Comptant plus d'un million de chaîne itérable va aller plus vite avecCounter
qu'avec un manuel de mise en œuvre. Si vous voulez l'appelerupdate
avec de nombreux iterables, vous pouvez être en mesure d'accélérer les choses en se joignant à eux dans un objet iterable avecitertools.chain
.Compter les occurrences d'un élément dans une liste
Pour compter les occurrences d'un seul élément de la liste, vous pouvez utiliser
count()
Compter les occurrences de tous éléments dans une liste est également connu comme le "comptage", une liste, ou la création d'un compteur de pointage.
Comptage de tous les éléments avec la fonction count()
Pour compter les occurrences d'éléments dans
l
on peut simplement utiliser une liste de la compréhension et de lacount()
méthode(ou même avec un dictionnaire
dict((x,l.count(x)) for x in set(l))
)Exemple:
En comptant tous les articles avec le Compteur()
Sinon, il y a le plus vite
Counter
classe à partir de lacollections
bibliothèqueExemple:
Comment beaucoup plus rapide est Contre?
J'ai vérifié comment beaucoup plus rapide
Counter
est pour le décompte des listes. J'ai essayé les deux méthodes avec quelques valeurs den
et il semble queCounter
est plus rapide par un facteur constant d'environ 2.Voici le script que j'ai utilisé:
Et la sortie:
Counter
est moyen le plus rapide pour les grandes listes. La liste de compréhension de la méthode est O(n^2),Counter
devrait être O(n).count()
travaille également sur les cordes, juste direisinstance
. Donc, si vous êtes certain sur les données que vous travaillez avec, il pourrait être préférable d'écrire une fonction personnalisée sans type et l'instance de contrôle.Une autre façon d'obtenir le nombre d'occurrences de chaque élément, dans un dictionnaire:
n * (number of different items)
opérations, sans compter le temps qu'il faut pour construire l'ensemble. À l'aide decollections.Counter
est vraiment beaucoup mieux.list.count(x)
renvoie le nombre de foisx
apparaît dans une listevoir:
http://docs.python.org/tutorial/datastructures.html#more-on-lists
Voici un exemple de liste:
list.count
Il y a le
list.count
méthodeCela fonctionne très bien pour tout liste de. Des Tuples de cette méthode ainsi:
collections.Counter
Et puis il y a les collections.Le compteur. Vous pouvez vider de tout objet iterable dans un Compteur, et pas seulement une liste, et le Compteur de conserver une structure de données de la numération des éléments.
Utilisation:
Compteurs sont basés sur Python dictionnaires, leurs clés sont les éléments, de sorte que les clés doivent être hashable. Ils sont un peu comme des ensembles qui permettent des éléments redondants dans les.
Une plus grande utilisation des
collections.Counter
Vous pouvez ajouter ou à soustraire à iterables de votre compteur:
Et vous pouvez le faire multi-ensemble des opérations avec le compteur ainsi:
Pourquoi ne pas les pandas?
Une autre réponse suggère:
Pandas est une bibliothèque commune, mais il n'est pas dans la bibliothèque standard. L'ajout d'une exigence est non-trivial.
Il y a intégré des solutions pour ce cas d'utilisation dans la liste de l'objet lui-même que dans la bibliothèque standard.
Si votre projet n'a pas déjà nécessitent des pandas, il serait stupide d'en faire une obligation, juste pour cette fonctionnalité.
Si vous voulez compter toutes les valeurs à la fois vous pouvez le faire très rapidement en utilisant des tableaux numpy et
bincount
comme suitqui donne
J'ai comparé toutes les solutions proposées (et quelques nouveaux) avec perfplot (un petit projet de mine).
Comptage un élément
Assez grande pour les tableaux, il s'avère que
est légèrement plus rapide que les autres solutions.
Comptage tous éléments
Comme établi avant,
est ce que vous voulez.
Code de reproduire les parcelles:
2.
Si vous pouvez utiliser
pandas
, puisvalue_counts
est là pour le sauvetage.Il trie automatiquement le résultat basé sur la fréquence.
Si vous voulez être dans une liste de liste, procédez comme ci-dessous
Pourquoi ne pas utiliser les Pandas?
De sortie:
Si vous êtes à la recherche pour le compte d'un élément particulier, dire un, essayez:
De sortie:
J'ai eu ce problème aujourd'hui et roulé ma propre solution avant que je pense à vérifier DONC. Ce:
est vraiment, vraiment lent pour les grandes listes. Ma solution
est effectivement un peu plus rapide que la solution de Comptoir, au moins pour Python 2.7.
Nombre de tous les éléments avec
itertools.groupby()
Antoher possiblité pour obtenir le nombre de tous les éléments dans la liste pourrait être par le biais de
itertools.groupby()
.Avec "double" compte
Retourne
Remarquez comment il a combiné les trois premiers
a
's que le premier groupe, alors que d'autres groupes dea
sont présents plus bas dans la liste. Cela se produit parce que la liste d'entréeL
n'a pas été trié. Cela peut être un avantage, parfois, si les groupes devraient en fait être séparés.Avec des nombres uniques
Si unique, le nombre de groupes sont souhaités, de trier la liste d'entrée:
Retourne
Remarque: Pour la création des nombres uniques, de nombreuses autres réponses fournissent plus facile et plus lisible le code par rapport à la
groupby
solution. Mais il est montré ici pour tracer une parallèle à la double comptage exemple.Pour compter le nombre d'éléments aussi divers ayant un type commun:
donne
3
, pas 6Il a été suggéré d'utiliser numpy est bincount, mais il ne fonctionne que pour les tableaux 1d avec entiers non négatifs. Aussi, le tableau qui en résulte peut être source de confusion (il contient les occurrences des nombres entiers du min au max de la liste d'origine, et met à 0 les entiers manquants).
Une meilleure façon de le faire avec numpy est d'utiliser le unique fonction avec l'attribut
return_counts
définie sur True. Elle renvoie un tuple avec un tableau de valeurs uniques et un tableau des occurrences de chaque valeur unique.et alors nous pouvons paire comme
Il travaille également avec d'autres types de données et "2d listes", par exemple
Ci-dessous sont les trois solutions:
Plus rapide est d'utiliser une boucle for et de le stocker dans un Dict.
Résultat
Vous pouvez également utiliser
countOf
méthode d'un module intégré deoperator
.countOf
est mis en œuvre? Comment se comparent le plus évidentlist.count
(qui bénéficie de C mise en œuvre)? Quels sont les avantages?Peut-être pas la plus efficace, nécessite un supplément de passer pour supprimer les doublons.
Fonctionnel de mise en œuvre :
retourne :
ou de retour comme
dict
:retourne :
Ce sera le retour de la quantité d'occurences de your_value
si vous voulez un certain nombre d'occurrences de l'élément particulier:
Même si elle est très vieille question, mais comme je n'ai pas trouvé une seule ligne, j'en ai fait une.