Jak mogę policzyć wystąpienia elementu listy?


1529

W przypadku danego elementu, jak mogę policzyć jego wystąpienia na liście w Pythonie?

Odpowiedzi:


1852

Jeśli chcesz policzyć tylko jeden przedmiot, użyj countmetody:

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

Nie używaj tego, jeśli chcesz policzyć wiele przedmiotów. Wywołanie countw pętli wymaga osobnego przejścia przez listę dla każdego countpołączenia, co może mieć katastrofalny wpływ na wydajność. Jeśli chcesz policzyć wszystkie elementy, a nawet tylko kilka elementów, użyj Counter, jak wyjaśniono w innych odpowiedziach.


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

1744

Użyj, Counterjeśli używasz języka Python 2.7 lub 3.x i chcesz liczbę wystąpień każdego elementu:

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

2
Przekonałem się, że przy użyciu tego dużo (mówiąc o milionach ciągów), jest to bardzo wolne ze względu na jego wywołania isinstance. Jeśli więc masz pewność co do danych, z którymi pracujesz, może być lepiej napisać niestandardową funkcję bez sprawdzania typu i instancji.
Bram Vanroy,

2
@BramVanroy: Jakie isinstancepołączenia? Nawet w przypadku milionów ciągów wywołanie Counterobejmuje tylko jedno isinstancewywołanie, aby sprawdzić, czy jego argumentem jest odwzorowanie. Najprawdopodobniej źle oceniłeś, co jesz przez cały czas.
użytkownik2357112 obsługuje Monikę

Źle zinterpretowałeś, co miałem na myśli: licznik sprawdza typy danych przed utworzeniem licznika. Zajmuje to stosunkowo dużo czasu i jeśli z góry znasz typ swoich danych. Jeśli spojrzysz na metodę aktualizacji Countera, zobaczysz, że musi ona przejść przez trzy instrukcje if przed zrobieniem czegoś. Jeśli często dzwonisz do aktualizacji, szybko się sumuje. Kiedy masz kontrolę nad swoimi danymi i wiesz, że dane wejściowe będą rzeczywiście powtarzalne, możesz pominąć dwie pierwsze kontrole. Jak powiedziałem, zauważyłem to tylko podczas pracy z milionami aktualizacji, więc jest to przypadek skrajny.
Bram Vanroy

2
@BramVanroy: Jeśli wykonujesz miliony aktualizacji, a nie tylko zliczasz miliony ciągów, to inna historia. Wysiłki związane z optymalizacją Counterpolegały na liczeniu dużych iteracji, a nie liczeniu wielu iteracji. Liczenie milionowej iterowalnej iteracji pójdzie szybciej Counterniż przy ręcznej implementacji. Jeśli chcesz zadzwonić updatez wieloma iteratorami, możesz być w stanie przyspieszyć, łącząc je w jeden iterowalny z itertools.chain.
użytkownik2357112 obsługuje Monikę

262

Zliczanie wystąpień jednego elementu na liście

Do zliczania wystąpień tylko jednego elementu listy można użyć count()

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

Liczenie wystąpień wszystkich elementów na liście jest również znane jako „liczenie” listy lub tworzenie licznika liczb.

Zliczanie wszystkich elementów za pomocą count ()

Aby policzyć występowanie elementów w ljednym, wystarczy po prostu skorzystać ze zrozumienia listy i count()metody

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

(lub podobnie ze słownikiem dict((x,l.count(x)) for x in set(l)))

Przykład:

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

Liczenie wszystkich elementów za pomocą Counter ()

Alternatywnie istnieje szybsza Counterklasa z collectionsbiblioteki

Counter(l)

Przykład:

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

O ile szybciej działa Counter?

Sprawdziłem, o ile szybsze Counterjest tworzenie list liczników. Wypróbowałem obie metody z kilkoma wartościami ni wydaje się, że Counterjest to szybsze o stały współczynnik około 2.

Oto skrypt, którego użyłem:

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)

A wynik:

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

32
Counterjest znacznie szybszy dla większych list. Metodą rozumienia listy jest O (n ^ 2), Counterpowinna być O (n).
fhucho

20
Licznik nie jest szybszy o współczynnik 2, Licznik jest szybszy o współczynnik n (O (n ^ 2) vs O (n)).
Martijn Pieters

Przekonałem się, że przy użyciu tego dużo (mówiąc o milionach ciągów), jest to bardzo wolne ze względu na jego wywołania isinstance. Jeśli więc masz pewność co do danych, z którymi pracujesz, może być lepiej napisać niestandardową funkcję bez sprawdzania typu i instancji.
Bram Vanroy,

66

Inny sposób na uzyskanie liczby wystąpień każdego elementu w słowniku:

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

49
wygląda to na jeden z konstruktów, które często wymyślałem w ogniu bitwy, ale będzie on przebiegał przez czasy len (a), co oznacza kwadratową złożoność środowiska wykonawczego (ponieważ każdy bieg ponownie zależy od len (a)).
Nicolas78,

5
czy dyktowanie ((i, a.count (i)) dla i w zestawie (a)) byłoby bardziej poprawne i szybsze?
hugo24,

6
@ hugo24: Trochę, ale w najgorszym przypadku nie będzie asymptotycznie szybszy; zajmie to n * (number of different items)operacje, nie licząc czasu potrzebnego na zbudowanie zestawu. Korzystanie collections.Counterjest naprawdę dużo lepsze.
Clément,

bardzo późno na imprezę, ale nie podąża za kodem, jeśli lista zawiera więcej niż jedno wystąpienie i, ponieważ spróbuje wprowadzić wiele kluczy o tej samej wartości w słowniku. dict((i, a.count(i)) for i in a)
rp1


45

W przypadku danego elementu, jak mogę policzyć jego wystąpienia na liście w Pythonie?

Oto przykładowa lista:

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

list.count

Jest list.countmetoda

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

Działa to dobrze dla każdej listy. Krotki mają również tę metodę:

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

collections.Counter

A potem są kolekcje. Licznik. Możesz zrzucić dowolny iterowalny licznik, a nie tylko listę, a licznik zachowa strukturę danych zliczeń elementów.

Stosowanie:

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

Liczniki oparte są na słownikach Pythona, ich klucze są elementami, więc klucze muszą być możliwe do skrócenia. Zasadniczo są to zestawy, które pozwalają na nadmiarowe elementy.

Dalsze wykorzystanie collections.Counter

Możesz dodać lub odjąć za pomocą iteracji z twojego licznika:

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

Możesz także wykonywać operacje na wielu ustawieniach za pomocą licznika:

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

Dlaczego nie pandy?

Inna odpowiedź sugeruje:

Dlaczego nie skorzystać z pand?

Pandy to popularna biblioteka, ale nie ma jej w standardowej bibliotece. Dodanie go jako wymagania nie jest trywialne.

Istnieją wbudowane rozwiązania dla tego przypadku użycia w samym obiekcie listy, a także w bibliotece standardowej.

Jeśli twój projekt nie wymaga już pand, głupotą byłoby uczynienie go wymogiem tylko dla tej funkcjonalności.


4
Chociaż „dlaczego nie Pandy” jest odpowiednie, prawdopodobnie powinno mu towarzyszyć „kiedy używać NumPy”, tj. W przypadku dużych tablic numerycznych. Decydującym czynnikiem są nie tylko ograniczenia projektu, ale także wydajność pamięci w NumPy, która uwidacznia się w przypadku dużych zbiorów danych.
JPP

Dziękujemy za podanie Pandas / etc jako poważnej zależności. Niektóre z tych pakietów mają negatywne skutki uboczne. Tak więc dodanie tych zasobów do banalnych potrzeb może kosztować dużo czasu i $. Osobiście doświadczyłem, że Numpy i SciPi dodają 30 minut do naszego potoku CI, a prawidłowe buforowanie pakietu zajęło kilka dni. Świetne paczki, ale czasami są ukryte koszty. + 1'd
Marc

36

Porównałem wszystkie sugerowane rozwiązania (i kilka nowych) z perfplot ( mój mały projekt).

Liczenie jednego przedmiotu

Okazuje się, że w przypadku wystarczająco dużych tablic

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

jest nieco szybszy niż inne rozwiązania.

wprowadź opis zdjęcia tutaj

Liczenie wszystkich przedmiotów

Jak ustalono wcześniej ,

numpy.bincount(a)

jest tym, czego chcesz.

wprowadź opis zdjęcia tutaj


Kod do odtworzenia wykresów:

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 () będzie działać tylko w przypadku list z elementami int.
Mukarram Pasha

35

Jeśli chcesz policzyć wszystkie wartości naraz , możesz to zrobić bardzo szybko, używając tablic numpy i bincountw następujący sposób

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

co daje

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

19

Jeśli możesz użyć pandas, to value_countsjest tam na ratunek.

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

Automatycznie sortuje również wynik na podstawie częstotliwości.

Jeśli chcesz, aby wynik znalazł się na liście, wykonaj następujące czynności

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

pandy mają jednak wiele narzutów, więc jest to najwolniejsze rozwiązanie z niewielką ilością danych. stackoverflow.com/a/46195192/125507
endolith

14

Dlaczego nie skorzystać z pand?

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

Wynik:

a    3
d    2
b    1
c    1
dtype: int64

Jeśli szukasz liczby konkretnego elementu, powiedz a , spróbuj:

my_count['a']

Wynik:

3

13

Miałem dzisiaj ten problem i opracowałem własne rozwiązanie, zanim pomyślałem o sprawdzeniu SO. To:

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

jest naprawdę bardzo powolny w przypadku dużych list. Moje rozwiązanie

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

jest w rzeczywistości nieco szybszy niż rozwiązanie Counter, przynajmniej w Pythonie 2.7.


1
Licznik sortuje wpisy, podczas gdy twoje nie, stąd różnica prędkości (Prawda w momencie pisania, nie wiem, czy to było, kiedy napisałeś odpowiedź. Mimo to, może być istotne dla kogoś, kto przewija w dół.)
chaosflaws

3
Licznik w Pythonie 2 był trochę powolny, tak. Jednak używa kodu zoptymalizowanego pod kątem C do liczenia w Pythonie 3, a teraz z łatwością pokonuje twoją pętlę.
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: Jak to możliwe? Jeśli przez „przedsiębiorczość” masz na myśli „udokumentowane” w przygotowaniu do adnotacji Py3k, zgadzam się.
Wes Turner,

1
To świetny przykład, ponieważ rozwijam głównie w wersji 2.7, ale muszę mieć ścieżki migracji do wersji 2.4.
Adam Lewis

9

Poniżej znajdują się trzy rozwiązania:

Najszybszym jest użycie pętli for i przechowywanie jej w 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))

Wynik

#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

Policz wszystkie elementy za pomocą itertools.groupby()

Istnieje również możliwość uzyskania liczby wszystkich elementów na liście za pomocą itertools.groupby().

Liczy się „duplikat”

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)

Zwroty

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

Zauważ, jak połączyło pierwsze trzy ajako pierwszą grupę, podczas gdy inne grupy aznajdują się w dalszej części listy. Dzieje się tak, ponieważ lista wejściowa Lnie została posortowana. Może to być czasem korzystne, jeśli grupy faktycznie powinny być oddzielne.

Z unikalnymi liczbami

Jeśli wymagane są unikalne liczby grup, wystarczy posortować listę danych wejściowych:

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

Zwroty

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

Uwaga: W przypadku tworzenia unikalnych zliczeń wiele innych odpowiedzi zapewnia łatwiejszy i bardziej czytelny kod w porównaniu do groupbyrozwiązania. Ale pokazano tutaj, aby narysować równolegle do duplikatu przykładu zliczania.


7

Sugerowano użycie liczby binarnej numpy , jednak działa ona tylko dla tablic 1d z nieujemnymi liczbami całkowitymi . Również wynikowa tablica może być myląca (zawiera występowanie liczb całkowitych od min do maks. Oryginalnej listy i ustawia na 0 brakujące liczby całkowite).

Lepszym sposobem na zrobienie tego za pomocą numpy jest użycie unikalnej funkcji z atrybutem return_countsustawionym na True. Zwraca krotkę z tablicą unikalnych wartości i tablicą występowania każdej unikalnej wartości.

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

a następnie możemy je sparować jako

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

Działa również z innymi typami danych i „listami 2d”, np

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

6

Aby policzyć liczbę różnych elementów mających wspólny typ:

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

daje

3 , nie 6


4

Chociaż jest to bardzo stare pytanie, ale ponieważ nie znalazłem jednej wkładki, zrobiłem jedną.

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

Nie używaj list ze zrozumieniem dla skutków ubocznych. Zobacz: Czy używanie Pythonic do interpretacji listy jest wykorzystywane tylko do efektów ubocznych?
Georgy

3

Możesz także użyć countOfmetody wbudowanego modułu operator.

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

1
Jak countOfjest wdrażany? Jak wypada w porównaniu z bardziej oczywistymi list.count(jakie korzyści z wdrożenia C)? Czy są jakieś zalety?
Chris_Rands

2

Może nie być najbardziej wydajny, wymaga dodatkowego przejścia, aby usunąć duplikaty.

Wdrożenie funkcjonalne:

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

zwroty :

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

lub wróć jako dict:

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

zwroty :

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


1

Chciałbym skorzystać filter()z przykładu Łukasza:

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

0

jeśli chcesz mieć kilka wystąpień dla danego elementu:

>>> 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
Chociaż ten kod może odpowiedzieć na pytanie, zapewnienie dodatkowego kontekstu dotyczącego tego, dlaczego i / lub jak ten kod odpowiada na pytanie, poprawia jego długoterminową wartość.
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))

spowoduje to rekurencyjne zliczanie lub wyszukiwanie elementu na liście, nawet jeśli jest on na liście list


nie wiem, dlaczego ktoś właśnie głosował na odpowiedź i jest ona całkowicie przydatna
Mohamed Fathallah
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.