Pertanyaan Bagaimana cara menghitung kemunculan daftar item?


Mengingat item, bagaimana saya bisa menghitung kejadiannya dalam daftar dengan Python?


1084
2018-04-08 13:30


asal


Jawaban:


Jika Anda hanya menginginkan satu hitungan item, gunakan count metode:

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

Jangan gunakan ini jika Anda ingin menghitung banyak item. Panggilan count dalam satu lingkaran membutuhkan suatu akses terpisah pada daftar untuk setiap count panggilan, yang dapat menjadi malapetaka untuk kinerja. Jika Anda ingin menghitung semua item, atau bahkan hanya beberapa item, gunakan Counter, seperti yang dijelaskan dalam jawaban lainnya.


1425
2018-04-08 13:31



Jika Anda menggunakan Python 2.7 atau 3 dan Anda ingin jumlah kejadian untuk setiap elemen:

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

1359
2018-04-29 07:44



Menghitung kemunculan satu item dalam daftar

Untuk menghitung kejadian hanya satu daftar barang yang dapat Anda gunakan count()

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

Menghitung kejadian semua item dalam daftar juga dikenal sebagai "menghitung" daftar, atau membuat penghitungan penghitungan.

Menghitung semua item dengan hitungan ()

Untuk menghitung kemunculan item dalam l seseorang dapat menggunakan daftar pemahaman dan count() metode

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

(atau serupa dengan kamus dict((x,l.count(x)) for x in set(l)))

Contoh:

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

Menghitung semua item dengan Counter ()

Atau, ada yang lebih cepat Counter kelas dari collections Perpustakaan

Counter(l)

Contoh:

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

Seberapa cepat Counter?

Saya memeriksa seberapa cepatnya Counter adalah untuk menghitung daftar. Saya mencoba kedua metode dengan beberapa nilai n dan tampaknya itu Counter lebih cepat dengan faktor konstan sekitar 2.

Berikut ini skrip yang saya gunakan:

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)

Dan hasilnya:

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

184
2018-05-28 10:58



Cara lain untuk mendapatkan jumlah kemunculan setiap item, dalam kamus:

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

56
2017-10-20 22:38



list.count(x) mengembalikan jumlah berapa kali x muncul dalam daftar

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


40
2018-04-08 13:34



Jika Anda menghendaki hitung semua nilai sekaligus Anda dapat melakukannya dengan sangat cepat menggunakan array numpy dan bincount sebagai berikut

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

pemberian yang mana

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

27
2017-11-19 10:53



Mengingat item, bagaimana saya bisa menghitung kejadiannya dalam daftar dengan Python?

Berikut ini contoh daftar:

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

list.count

Itu ada list.count metode

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

Ini berfungsi dengan baik untuk daftar apa pun. Tuples memiliki metode ini juga:

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

collections.Counter

Dan kemudian ada koleksi. Penghubung. Anda dapat membuang setiap iterable ke Counter, bukan hanya daftar, dan Counter akan mempertahankan struktur data dari jumlah elemen.

Pemakaian:

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

Penghitung didasarkan pada kamus Python, kunci mereka adalah elemen, sehingga kunci harus dapat diprogram. Mereka pada dasarnya seperti set yang memungkinkan elemen redundan ke dalamnya.

Penggunaan lebih lanjut atas collections.Counter

Anda dapat menambah atau mengurangi dengan iterables dari counter Anda:

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

Dan Anda dapat melakukan operasi multi-set dengan counter juga:

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

Kenapa tidak panda?

Jawaban lain menunjukkan:

Mengapa tidak menggunakan panda?

Pandas adalah pustaka umum, tetapi tidak ada di pustaka standar. Menambahkannya sebagai ketergantungan adalah hal yang tidak sepele.

Ada solusi yang dibangun untuk kasus penggunaan ini dalam daftar objek itu sendiri serta di pustaka standar.

Jika proyek Anda belum membutuhkan panda, itu akan menjadi bodoh untuk membuatnya menjadi persyaratan hanya untuk fungsi ini.


23
2018-04-13 12:50



Saya telah membandingkan semua solusi yang disarankan (dan beberapa yang baru) dengan perfplot (proyek kecil saya).

Perhitungan satu barang

Untuk array yang cukup besar, ternyata itu

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

sedikit lebih cepat daripada solusi lainnya.

enter image description here

Perhitungan semua item

Seperti yang ditetapkan sebelumnya,

numpy.bincount(a)

adalah apa yang kamu inginkan.

enter image description here


Kode untuk mereproduksi plot:

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

20
2017-09-13 10:32



Jika Anda bisa menggunakannya pandas, kemudian value_counts ada di sana untuk menyelamatkan.

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

Secara otomatis mengurutkan hasil berdasarkan frekuensi juga.

Jika Anda ingin hasilnya berada dalam daftar daftar, lakukan seperti di bawah ini

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

14
2018-01-17 07:56