En Python, j'ai un ndarray y
qui est imprimé commearray([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
J'essaie de compter combien de 0
s et combien il y a de 1
s dans ce tableau.
Mais quand je tape y.count(0)
ou y.count(1)
, ça dit
numpy.ndarray
l'objet n'a pas d'attributcount
Que devrais-je faire?
python
numpy
multidimensional-array
count
mflowww
la source
la source
numpy.count_nonzero
.Réponses:
Manière non numpy :
Utilisation
collections.Counter
;la source
dict(zip(*numpy.unique(a, return_counts=True)))
collections.Counter
fonctionnait très bienQu'en est-il de l'utilisation
numpy.count_nonzero
, quelque chose commela source
numpy.ndarray
comme OP l'avait demandé à l'origine.Personnellement, je choisirais:
(y == 0).sum()
et(y == 1).sum()
Par exemple
la source
sum( vector==value )
Pour votre cas, vous pouvez également consulter numpy.bincount
la source
Convertissez votre tableau
y
en listel
, puis faitesl.count(1)
etl.count(0)
la source
Si vous savez qu'ils sont justes
0
et1
:vous en donne le nombre.
np.sum(1-y)
donne les zéros.Pour une généralité légère, si vous voulez compter
0
et non pas zéro (mais éventuellement 2 ou 3):donne le nombre de non nul.
Mais si vous avez besoin de quelque chose de plus compliqué, je ne pense pas que numpy fournira une bonne
count
option. Dans ce cas, accédez aux collections:Cela se comporte comme un dicton
la source
Si vous savez exactement quel numéro vous recherchez, vous pouvez utiliser ce qui suit;
retourne combien de fois 2 s'est produit dans votre tableau.
la source
Honnêtement, je trouve qu'il est plus facile de convertir une série pandas ou DataFrame:
Ou ce joli one-liner proposé par Robert Muil:
la source
pd.Series([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]).value_counts()
Personne n'a suggéré d'utiliser
numpy.bincount(input, minlength)
avecminlength = np.size(input)
, mais cela semble être une bonne solution, et certainement la plus rapide :C'est une accélération folle entre
numpy.unique(x, return_counts=True)
etnumpy.bincount(x, minlength=np.max(x))
!la source
np.histogram
ne calcule pas la même chose. Inutile de comparer les trois approches que je propose avec lahistogram
fonction, désolé.bincount
ne fonctionne que pour les entiers, donc cela fonctionne pour le problème de l'OP, mais peut-être pas pour le problème générique décrit dans le titre. Avez-vous également essayé d'utiliserbincount
des tableaux avec de très gros pouces?bincount
est environ quatre fois plus rapide queunique
.Et pour
len(y[y==0])
etlen(y[y==1])
?la source
y.tolist().count(val)
avec val 0 ou 1
Étant donné qu'une liste python a une fonction native
count
, la conversion en liste avant d'utiliser cette fonction est une solution simple.la source
Encore une autre solution simple pourrait être d'utiliser numpy.count_nonzero () :
Ne laissez pas le nom vous induire en erreur, si vous l'utilisez avec le booléen comme dans l'exemple, il fera l'affaire.
la source
Pour compter le nombre d'occurrences, vous pouvez utiliser
np.unique(array, return_counts=True)
:la source
J'utiliserais np.where:
la source
profitez des méthodes offertes par une Série:
la source
Une réponse générale et simple serait:
qui résulterait en ce code complet comme exemple
Maintenant, si MyArray est en plusieurs dimensions et que vous souhaitez compter l'occurrence d'une distribution de valeurs en ligne (= modèle ci-après)
la source
Vous pouvez utiliser la compréhension du dictionnaire pour créer une ligne nette soignée. Pour en savoir plus sur la compréhension du dictionnaire, cliquez ici
Cela créera un dictionnaire avec les valeurs de votre ndarray sous forme de clés et le nombre de valeurs comme valeurs pour les clés respectivement.
Cela fonctionnera chaque fois que vous souhaitez compter les occurrences d'une valeur dans des tableaux de ce format.
la source
Essaye ça:
la source
Cela peut être fait facilement dans la méthode suivante
la source
Puisque votre ndarray ne contient que 0 et 1, vous pouvez utiliser sum () pour obtenir l'occurrence de 1 et len () - sum () pour obtenir l'occurrence de 0.
la source
Vous avez un tableau spécial avec seulement 1 et 0 ici. Donc, une astuce consiste à utiliser
ce qui vous donne le pourcentage de 1 dans votre tableau. Vous pouvez également utiliser
vous donnera le nombre absolu de 1 et 0 dans votre tableau.
la source
Je viens de copier ici le commentaire de Seppo Enarvi qui mérite d'être une bonne réponse
la source
Cela implique une étape de plus, mais une solution plus flexible qui fonctionnerait également pour les tableaux 2D et les filtres plus compliqués consiste à créer un masque booléen, puis à utiliser .sum () sur le masque.
la source
Si vous ne voulez pas utiliser numpy ou un module de collections, vous pouvez utiliser un dictionnaire:
résultat:
Bien sûr, vous pouvez également utiliser une instruction if / else. Je pense que la fonction Counter fait presque la même chose mais c'est plus transparent.
la source
Pour les entrées génériques:
Sortira un décompte:
Et les indices:
la source
ici j'ai quelque chose, à travers lequel vous pouvez compter le nombre d'occurrence d'un nombre particulier: selon votre code
count_of_zero = list (y [y == 0]). count (0)
imprimer (count_of_zero)
// selon la correspondance, il y aura des valeurs booléennes et selon la valeur True, le nombre 0 sera retourné
la source
Si vous êtes intéressé par l'exécution la plus rapide, vous savez à l'avance quelle (s) valeur (s) rechercher, et votre tableau est 1D, ou vous êtes autrement intéressé par le résultat sur le tableau aplati (auquel cas l'entrée de la fonction devrait être
np.flatten(arr)
plutôt que justearr
), alors Numba est votre ami:ou, pour les très grands tableaux où la parallélisation peut être bénéfique:
Analyse comparative de ceux-ci
np.count_nonzero()
(qui a également un problème de création d'un tableau temporaire qui peut être évité) et d'unenp.unique()
solution basée surpour les entrées générées avec:
les tracés suivants sont obtenus (la deuxième rangée de tracés est un zoom sur l'approche la plus rapide):
Montrant que la solution basée sur Numba est sensiblement plus rapide que ses homologues NumPy, et, pour de très grandes entrées, l'approche parallèle est plus rapide que la naïve.
Code complet disponible ici .
la source
si vous avez affaire à de très grands tableaux utilisant des générateurs, cela pourrait être une option. La bonne chose ici, c'est que cette approche fonctionne bien pour les tableaux et les listes et vous n'avez pas besoin de package supplémentaire. En outre, vous n'utilisez pas autant de mémoire.
la source
Numpy a un module pour cela. Juste un petit hack. Mettez votre tableau d'entrée sous forme de bacs.
La sortie est constituée de 2 tableaux. L'un avec les valeurs elles-mêmes, l'autre avec les fréquences correspondantes.
la source
la source