Kaip suskaičiuoti sąrašo elemento įvykius?

Kaip galima suskaičiuoti elementą, kaip galėčiau suskaičiuoti jo įrašą Python sąraše?

1203
08 апр. nustatytas silpnas 08 balandis. 2010-04-08 16:30 '10 - 16.30 val. 2010-04-08 16:30
@ 22 atsakymai

Jei jums reikia tik vieno elemento, naudokite count metodą:

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

Nenaudokite, jei norite suskaičiuoti kelis elementus. Skambučio count kilpoje reikalauja atskiro sąrašo kiekvienam skambučiui, kuris gali būti katastrofiškas našumui. Jei norite suskaičiuoti visus elementus ar net kelis elementus, naudokite Counter , kaip aprašyta kituose atsakymuose.

1543 m
08 апр. Atsakymą pateikė Łukasz 08 balandžio. 2010-04-08 16:31 '10, 16:31, 2010-04-08 16:31

Jei naudojate Python 2.7 arba 3 ir norite, kad kiekvieno elemento įrašų skaičius:

border=0
 >>> from collections import Counter >>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red'] >>> Counter(z) Counter({'blue': 3, 'red': 2, 'yellow': 1}) 
1438
29 апр. atsakymas, kurį pateikė user52028778 Bal 29 2011-04-29 10:44 '11, 10:44, 2011-04-29 10:44

Vieno sąrašo reikšmių skaičiavimas

Jei norite suskaičiuoti tik vieno sąrašo elemento įvykius, galite naudoti count() .

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

Visų sąraše esančių elementų skaičiavimas taip pat žinomas kaip sąrašo „skaičiavimas“ arba skaitiklių skaitiklio sukūrimas.

Skaičiuokite visus elementus su skaičiumi ()

Norėdami suskaičiuoti elementų pasikartojimus l galite naudoti sąrašo supratimą ir count() metodą

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

(arba panašiai su dict((x,l.count(x)) for x in set(l)) )

Pavyzdys:

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

Skaičiuokite visus elementus, naudodami skaitiklį ()

Be to, yra greitesnis klasės Countercollections bibliotekos

 Counter(l) 

Pavyzdys:

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

Kiek greičiau yra skaitiklis?

Patikrinau, kiek greičiau Counter naudojamas skaičiuoti sąrašus. Išbandžiau abu metodus su keliomis n reikšmėmis, ir atrodo, kad Counter greitesnis, pastovus koeficientas yra maždaug 2.

Čia yra naudojamas scenarijus:

 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) 

Ir išvada:

 Counter(): [0.46062711701961234, 0.4022796869976446, 0.3974247490405105] count(): [7.779430688009597, 7.962715800967999, 8.420845870045014] 
210
28 мая '14 в 13:58 2014-05-28 13:58 atsakymą pateikė vartotojo2314737 gegužės 28 d., 14 d., 13:58 2014-05-28 13:58

Kitas būdas gauti kiekvieno elemento įvykių skaičių žodyne:

 dict((i, a.count(i)) for i in a) 
59
21 окт. atsakymas duotas tj80 spalio 21 d. 2011-10-21 01:38 '11 prie 1:38 2011-10-21 01:38

list.count(x) grąžina kartų skaičių x sąraše

žiūrėkite: http://docs.python.org/tutorial/datastructures.html#more-on-lists

41
08 апр. atsakymą pateikė Silfverstrom 08 balandžio. 2010-04-08 16:34 '10, 16:34, 2010-04-08 16:34

Kaip galiu apskaičiuoti elementą Python sąraše?

Čia pateikiamas pavyzdžių sąrašas:

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

list.count

Yra metodas „ list.count

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

Tai puikiai tinka bet kuriam sąrašui. Tuples taip pat turi šį metodą:

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

collections.Counter

Ir tada yra kolekcijų. Skaitiklis Galite atkurti bet kokį iteraciją į skaitiklį, o ne tik į sąrašą, ir skaitiklis išsaugos elementų skaitiklių duomenų struktūrą.

Naudoti:

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

Skaitikliai yra pagrįsti „Python“ žodynais, jų raktai yra elementai, todėl raktai turi būti išjungti. Jie iš esmės yra panašūs į rinkinius, leidžiančius juos atleisti.

Tolesnis collections.Counter

Galite pridėti ar atimti iteracijas iš skaitiklio:

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

Ir galite atlikti kelis veiksmus su skaitiklis:

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

Kodėl gi ne pandas?

Kitas atsakymas rodo:

Kodėl gi ne naudoti pandas?

Pandos yra įprastinė biblioteka, tačiau jos nėra standartinėje bibliotekoje. Pridėjus jį kaip reikalavimą, nėra jokios reikšmės.

Šiuo atveju yra integruoti sprendimai tiek pačiame sąrašo objekte, tiek standartinėje bibliotekoje.

Jei jūsų projektui nereikia pandos, būtų kvaila tai padaryti tik šiai funkcijai.

29
13 апр. Atsakyti Aaron Hall 13 Bal. 2016-04-13 15:50 '16 at 15:50 2016-04-13 15:50

Jei norite iš karto apskaičiuoti visas vertes , galite tai padaryti labai greitai, naudodami „numpy“ ir „ bincount :

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

kuris suteikia

 >>> array([0, 3, 1, 1, 2]) 
28
19 нояб. atsakymą pateikė flonk 19 lapkritis 2013-11-19 13:53 '13, 13:53, 2013-11-19 13:53

Aš palyginau visus siūlomus sprendimus (ir kelis naujus) su perfplot (mano nedideliu projektu).

Vieno elemento skaičiavimas

Pakankamai didelėms matricoms paaiškėja, kad

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

šiek tiek greičiau nei kiti sprendimai.

2019

13 сент. Nico Schlömer atsakymas rugsėjo 13 d 2017-09-13 13:32 '17 13:32 pm 2017-09-13 13:32

Jei galite naudoti „ pandas , tuomet value_counts egzistuoja išgelbėjimui.

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

Jis taip pat automatiškai rūšiuoja rezultatą pagal dažnį.

Jei norite, kad rezultatas būtų rodomas, atlikite šiuos veiksmus.

 >>> pd.Series(a).value_counts().reset_index().values.tolist() [[1, 3], [4, 2], [3, 1], [2, 1]] 
16
17 янв. atsakymą pateikė Thirupathi Thangavel sausio 17 d 2018-01-17 10:56 '18, 10:56 pm 2018-01-17 10:56

Kodėl gi ne naudoti 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 

Išvada:

 a 3 d 2 b 1 c 1 dtype: int64 

Jei ieškote konkretaus elemento skaitiklio, tarkim a, pabandykite:

 my_count['a'] 

Išvada:

 3 
14
17 окт. atsakymas duotas Shoresh 17 okt. 2016-10-17 20:15 '16 at 8:15 pm 2016-10-17 20:15

Šią problemą turėjau šiandien, ir aš padariau savo sprendimą prieš nusprendžiant patikrinti SO. Tai yra:

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

tikrai labai lėtas dideliems sąrašams. Mano sprendimas

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

iš tikrųjų šiek tiek greičiau nei „Counter“ sprendimas, bent jau „Python 2.7“.

11
07 нояб. Atsakymas duotas D Blanc, lapkričio 7 d. 2011-11-07 22:18 '11 10:18 val. 2011-11-07 22:18
14 авг. atsakymas suteiktas Wes Turner 14 rug. 2011-08-14 11:47 '11, 11:47, 2011-08-14 11:47

Jei norite skaičiuoti skirtingų elementų, turinčių bendrą tipą, skaičių:

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

suteikia

3 , ne 6

6
14 авг. atsakymas, pateiktas 14 d. 2011-08-14 18:51 '11 at 18:51 2011-08-14 18:51
 from collections import Counter country=['Uruguay', 'Mexico', 'Uruguay', 'France', 'Mexico'] count_country = Counter(country) output_list= [] for i in count_country: output_list.append([i,count_country[i]]) print output_list 

Išvesties sąrašas:

 [['Mexico', 2], ['France', 1], ['Uruguay', 2]] 
4
28 апр. atsakymą pateikė Aakash Goel 28 balandis. 2017-04-28 13:36 '17, 13:36 pm 2017-04-28 13:36

Taip pat galite naudoti integruoto modulio operator countOf metodą.

 >>> import operator >>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1) 3 
3
18 сент. atsakymas pateikiamas pagal vishes_shell 18 sep . 2016-09-18 23:08 '16 at 23:08 2016-09-18 23:08

Visų elementų skaičiavimas naudojant itertools.groupby()

Kita galimybė gauti visų sąraše esančių elementų gali būti itertools.groupby() .

Su „dublikatais“

 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) 

Grąžina

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

Atkreipkite dėmesį, kaip jis sujungė pirmuosius tris a kaip pirmąją grupę, o kiti - žemiau. Taip yra todėl, kad įvesties sąrašas L nėra surūšiuotas. Kartais tai gali būti naudinga, jei grupės turi būti atskiros.

Unikali suma

Jei jums reikia daug unikalių grupių, tiesiog rūšiuoti įvesties sąrašą:

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

Grąžina

 [('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)] 
3
30 окт. Atsakyti Tim Skov Jacobsen Oct 30 2018-10-30 15:07 '18, 15:07 2018-10-30 15:07

Siūloma naudoti numpy bincount , tačiau ji veikia tik 1d masyvams , turintiems ne neigiamų sveikųjų skaičių. Be to, gautas masyvas gali būti painus (jame pateikiami sveikųjų skaičių atvejai iš minimalaus iki maksimalaus šaltinio sąraše ir nustatomi 0 trūkstamų sveikųjų skaičių).

Geriausias būdas tai padaryti naudojant „numpy“ yra naudoti unikalią funkciją, kurios atributas „ return_counts nustatytas į „True“. Jis grąžina paketą su unikalių verčių masyvu ir kiekvienos unikalios vertės atvejų masyvu.

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

ir tada mes galime juos sujungti

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

Jis taip pat veikia su kitais duomenų tipais ir „2d sąrašais“

 >>> a = [['a', 'b', 'b', 'b'], ['a', 'c', 'c', 'a']] >>> dict(zip(*np.unique(a, return_counts=True))) {'a': 3, 'b': 3, 'c': 2} 
2
22 окт. Atsakymą AndyK pateikė spalio 22 d. 2018-10-22 00:59 '18 0:59 2018-10-22 00:59
 sum([1 for elem in <yourlist> if elem==<your_value>]) 

Tai grąžins jūsų_numatymo įvykių skaičių.

1
23 авг. atsakymas suteiktas whackamadoodle3000 23 rug . 2017-08-23 04:20 '17 ne 4:20 2017-08-23 04:20

Gali būti ne pats efektyviausias, norint pašalinti dublikatus reikia papildomo leidimo.

Funkcinis įgyvendinimas:

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

grąžina:

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

arba grįžti kaip dict :

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

grąžina:

 {'b': 3, 'c': 1, 'a': 2} 
1
01 марта '18 в 13:38 2018-03-01 13:38 atsakymas pateikiamas mėlynu dangumi Kovo 01, 18, 13:38 2018-03-01 13:38
 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) 
0
07 июля '18 в 11:29 2018-07-07 11:29 atsakymas suteikiamas ravi tanwar liepos 07 d. 18 val. 11:29. 2018-07-07 11:29

jei norite, kad tam tikro elemento įvykių skaičius:

 >>> 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]) 
0
29 июня '18 в 17:05 2018-06-29 17:05 atsakymas duotas MR_BLACK birželio 29 d. 18 val

Toliau pateikiami trys sprendimai:

Sparčiausiai naudoja kilpą ir saugo ją „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)) 

Rezultatas

 #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 
0
02 нояб. atsakymą pateikė Akash Swain . 2018-11-02 11:43 '18, 11:43, 2018-11-02 11:43

Kiti klausimai apie „ arba „ Klauskite klausimą“