Comment puis-je compter les occurrences d'un élément de liste?


1530

Étant donné un élément, comment puis-je compter ses occurrences dans une liste en Python?

Réponses:


1853

Si vous ne souhaitez compter qu'un seul élément, utilisez la countméthode:

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

Ne l' utilisez pas si vous souhaitez compter plusieurs éléments. L'appel counten boucle nécessite un passage distinct sur la liste pour chaque countappel, ce qui peut être catastrophique pour les performances. Si vous souhaitez compter tous les éléments, ou même seulement plusieurs éléments, utilisez Counter, comme expliqué dans les autres réponses.


6
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]))
cpp-coder

1747

A utiliser Countersi vous utilisez Python 2.7 ou 3.x et que vous souhaitez le nombre d'occurrences pour chaque élément:

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

2
J'ai trouvé qu'en utilisant beaucoup cela (en parlant de millions de chaînes), c'est très lent à cause de ses appels à isinstance. Donc, si vous êtes certain des données avec lesquelles vous travaillez, il peut être préférable d'écrire une fonction personnalisée sans vérification de type et d'instance.
Bram Vanroy

2
@BramVanroy: Quels isinstanceappels? Même avec des millions de chaînes, l'appel Counterne comporte qu'un seul isinstanceappel, pour vérifier si son argument est un mappage. Vous avez probablement mal évalué ce que vous mangez tout votre temps.
user2357112 prend en charge Monica

Vous avez mal interprété ce que je voulais dire: Counter vérifie les types de vos données avant de créer le compteur. Cela prend relativement beaucoup de temps et si vous connaissez le type de vos données à l'avance. Si vous regardez la méthode de mise à jour de Counter, vous verrez qu'elle doit passer par trois instructions if avant de faire quelque chose. Si vous appelez fréquemment update, cela s'additionne rapidement. Lorsque vous avez le contrôle sur vos données et que vous savez que l'entrée sera en effet un itérable, vous pouvez ignorer les deux premières vérifications. Comme je l'ai dit, je ne l'ai remarqué qu'en travaillant avec des millions de mises à jour, c'est donc un cas de pointe.
Bram Vanroy

2
@BramVanroy: Si vous effectuez des millions de mises à jour plutôt que de simplement compter des millions de chaînes, c'est une autre histoire. L'effort d'optimisation Countera consisté à compter de grands itérables, plutôt que de compter de nombreux itérables. Compter un million de chaînes itérables ira plus vite Counterqu'avec une implémentation manuelle. Si vous souhaitez appeler updateavec de nombreux itérables, vous pouvez accélérer les choses en les joignant en un seul itérable avec itertools.chain.
user2357112 prend en charge Monica

262

Compter les occurrences d'un élément dans une liste

Pour compter les occurrences d'un seul élément de liste, vous pouvez utiliser count()

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

Le comptage des occurrences de tous les éléments d'une liste est également appelé «comptage» d'une liste ou création d'un compteur de comptage.

Compter tous les éléments avec count ()

Pour compter les occurrences d'éléments en lun, il suffit d'utiliser une compréhension de liste et la count()méthode

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

(ou de 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}

Compter tous les éléments avec Counter ()

Alternativement, il y a la Counterclasse la plus rapide de la collectionsbibliothèque

Counter(l)

Exemple:

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

Combien est plus rapide Counter?

J'ai vérifié à quel point les Counterlistes de comptage sont plus rapides . J'ai essayé les deux méthodes avec quelques valeurs de net il semble que ce Countersoit plus rapide d'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)

Et la sortie:

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

32
Counterest beaucoup plus rapide pour les plus grandes listes. La méthode de compréhension de la liste est O (n ^ 2), Counterdevrait être O (n).
fhucho

20
Le compteur n'est pas plus rapide d'un facteur 2, Counter est plus rapide d'un facteur n (O (n ^ 2) vs O (n)).
Martijn Pieters

J'ai trouvé qu'en utilisant beaucoup cela (en parlant de millions de chaînes), c'est très lent à cause de ses appels à isinstance. Donc, si vous êtes certain des données avec lesquelles vous travaillez, il peut être préférable d'écrire une fonction personnalisée sans vérification de type et d'instance.
Bram Vanroy

66

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)

49
cela ressemble à l'une des constructions que je trouve souvent dans le feu de la bataille, mais elle passera par un temps len (a), ce qui signifie une complexité d'exécution quadratique (car chaque cycle dépend à nouveau de len (a)).
Nicolas78

5
est-ce que dict ((i, a.count (i)) pour i dans l'ensemble (a)) serait plus correct et plus rapide?
hugo24

6
@ hugo24: Un peu, mais ce ne sera pas asymptotiquement plus rapide dans le pire des cas; cela prendra des n * (number of different items)opérations, sans compter le temps qu'il faut pour construire l'ensemble. L'utilisation collections.Counterest vraiment bien meilleure.
Clément

très tard pour le groupe, mais le code suivant ne génère pas d'erreur si une liste contient plusieurs instances de i, car il essaiera d'entrer plusieurs clés de même valeur dans un dictionnaire. dict((i, a.count(i)) for i in a)
rp1


45

Étant donné un élément, comment puis-je compter 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

Voilà la list.countméthode

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

Cela fonctionne bien pour n'importe quelle liste. Les tuples ont également cette méthode:

>>> 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. Vous pouvez vider tout itérable dans un compteur, pas seulement une liste, et le compteur conservera une structure de données des décomptes des éléments.

Usage:

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

Les compteurs sont basés sur des dictionnaires Python, leurs clés sont les éléments, donc les clés doivent être lavables. Ils sont essentiellement comme des ensembles qui autorisent des éléments redondants.

Utilisation ultérieure de collections.Counter

Vous pouvez ajouter ou soustraire avec des itérables de votre compteur:

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

Et vous pouvez également effectuer des opérations multi-ensembles avec le compteur:

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

Pourquoi pas des pandas?

Une autre réponse suggère:

Pourquoi ne pas utiliser des pandas?

Pandas est une bibliothèque commune, mais elle n'est pas dans la bibliothèque standard. L'ajouter en tant qu'exigence n'est pas anodin.

Il existe des solutions intégrées pour ce cas d'utilisation dans l'objet liste lui-même ainsi que dans la bibliothèque standard.

Si votre projet ne nécessite pas déjà de pandas, il serait insensé d'en faire une exigence rien que pour cette fonctionnalité.


4
Bien que "pourquoi pas Pandas" soit approprié, il devrait probablement être accompagné de "quand utiliser NumPy", c'est-à-dire pour les grands tableaux numériques. Le facteur décisif n'est pas seulement les limites du projet, il existe des efficacités de mémoire avec NumPy qui deviennent apparentes avec les mégadonnées.
jpp

Merci d'avoir mentionné Pandas / etc comme une dépendance sérieuse. Certains de ces packages ont des effets secondaires négatifs. Ainsi, l'ajout de ces actifs pour des besoins triviaux peut coûter beaucoup de temps et $. Personnellement, j'ai constaté que Numpy et SciPi ajoutaient 30 minutes à notre pipeline CI et il a fallu des jours pour obtenir la mise en cache du package correctement. Grands forfaits, mais parfois il y a des dépenses cachées. +1
Marc

36

J'ai comparé toutes les solutions suggérées (et quelques nouvelles) avec perfplot (un petit projet à moi).

Compter un article

Pour les tableaux suffisamment grands, il s'avère que

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

est légèrement plus rapide que les autres solutions.

entrez la description de l'image ici

Compter tous les articles

Comme établi précédemment ,

numpy.bincount(a)

c'est ce que tu veux.

entrez la description de l'image ici


Code pour reproduire les parcelles:

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

7
numpy.bincount () ne fonctionnera que pour les listes avec des éléments int.
Mukarram Pasha

35

Si vous voulez compter toutes les valeurs à la fois, vous pouvez le faire très rapidement en utilisant des tableaux numpy et bincountcomme suit

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

qui donne

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

19

Si vous pouvez utiliser pandas, alors value_countsil est là pour le sauvetage.

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

Il trie également automatiquement le résultat en fonction de la fréquence.

Si vous voulez que le résultat soit dans une liste de liste, procédez comme ci-dessous

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

les pandas ont beaucoup de frais généraux, donc c'est la solution la plus lente avec de petites quantités de données. stackoverflow.com/a/46195192/125507
endolith

14

Pourquoi ne pas utiliser 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

Production:

a    3
d    2
b    1
c    1
dtype: int64

Si vous recherchez un décompte d'un élément particulier, dites a , essayez:

my_count['a']

Production:

3

13

J'ai eu ce problème aujourd'hui et j'ai lancé ma propre solution avant de penser à vérifier SO. Cette:

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

est vraiment très lent pour les grandes listes. Ma solution

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

est en fait un peu plus rapide que la solution Counter, du moins pour Python 2.7.


1
Counter trie les entrées alors que la vôtre ne le fait pas, d'où la différence de vitesse (Vrai au moment de la rédaction, je ne sais pas si c'était quand vous avez écrit la réponse. Pourtant, cela pourrait être pertinent pour quelqu'un de faire défiler vers le bas.)
chaosflaws

3
Counter en Python 2 était un peu lent, oui. Il utilise cependant du code optimisé en C pour effectuer le comptage en Python 3, et bat désormais votre boucle avec facilité.
Martijn Pieters

12
# 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)]

2
@plaes: Comment ça? Si par «entreprise», vous voulez dire «documenté» en préparation des annotations Py3k, je suis d'accord.
Wes Turner

1
Ceci est un excellent exemple, car je développe principalement en 2.7, mais je dois avoir des chemins de migration vers 2.4.
Adam Lewis

9

Voici les trois solutions:

Le plus rapide utilise une boucle for et le stocke dans un Dict.

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

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

9

Nombre de tous les éléments avec itertools.groupby()

Une autre possibilité d'obtenir le décompte de tous les éléments de la liste pourrait se faire au moyen de itertools.groupby().

Avec des comptages "en double"

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)

Retour

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

Remarquez comment il a combiné les trois premiers en atant que premier groupe, tandis que d'autres groupes asont présents plus bas dans la liste. Cela se produit car la liste d'entrée Ln'a pas été triée. Cela peut parfois être un avantage si les groupes doivent en fait être séparés.

Avec des dénombrements uniques

Si un nombre de groupes unique est souhaité, il suffit de trier la liste d'entrée:

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

Retour

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

Remarque: Pour créer des décomptes uniques, de nombreuses autres réponses fournissent un code plus facile et plus lisible par rapport à la groupbysolution. Mais il est montré ici pour faire un parallèle avec l'exemple de comptage en double.


7

Il a été suggéré d'utiliser le nombre de bits de numpy , mais cela ne fonctionne que pour les tableaux 1d avec des entiers non négatifs . En outre, le tableau résultant peut prêter à confusion (il contient les occurrences des entiers de min à max de la liste d'origine et définit à 0 les entiers manquants).

Une meilleure façon de le faire avec numpy est d'utiliser la fonction unique avec l'attribut return_countsdéfini sur True. Il renvoie un tuple avec un tableau des valeurs uniques et un tableau des occurrences de chaque valeur unique.

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

puis nous pouvons les associer

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

Il fonctionne également avec d'autres types de données et "listes 2D", par exemple

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

6

Pour compter le nombre d'éléments divers ayant un type commun:

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

donne

3 , pas 6


4

Bien que ce soit une question très ancienne, mais comme je n'ai pas trouvé de doublure, 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)

N'utilisez pas de listes de compréhension pour les effets secondaires. Voir: Est-ce Pythonic d'utiliser des compréhensions de liste pour juste des effets secondaires?
Georgy

3

Vous pouvez également utiliser la countOfméthode d'un module intégré operator.

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

1
Comment countOfest mis en œuvre? Comment se compare-t-il au plus évident list.count(qui bénéficie de la mise en œuvre du C)? Y a-t-il des avantages?
Chris_Rands

2

Peut ne pas être le plus efficace, nécessite un laissez-passer supplémentaire pour supprimer les doublons.

Implémentation fonctionnelle:

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

Retour :

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

ou retournez comme dict:

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

Retour :

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

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

Cela renverra le nombre d'occurrences de votre_valeur


1

J'utiliserais filter(), prenons l'exemple de Lukasz:

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

0

si vous voulez un certain nombre d'occurrences pour l'élément particulier:

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

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

3
Bien que ce code puisse répondre à la question, fournir un contexte supplémentaire concernant pourquoi et / ou comment ce code répond à la question améliore sa valeur à long terme.
Alex Riabov

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

ce sera le nombre récursif ou la recherche de l'élément dans la liste même s'il est dans la liste des listes


je ne sais pas pourquoi quelqu'un vient de voter pour une réponse et c'est complètement utile
Mohamed Fathallah
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.