Бројање броја појављивања сваког елемента на листи помоћу Питхон-овог бројача

Бусинесс

У Питхон-у, број свих елемената у листи или тупле-у се може добити помоћу уграђене функције лен(), а број сваког елемента (број појављивања сваког елемента) се може добити помоћу методе цоунт() .

Поред тога, класа Цоунтер колекција стандардне библиотеке Питхон може се користити за добијање елемената по редоследу броја појављивања.

У овом одељку ћемо разговарати о следећем

  • Израчунајте укупан број елемената:len()
  • Избројите број сваког елемента (број појављивања сваког елемента):count()
  • Употреба.collections.Counter
  • Елементи се преузимају по редоследу учесталости појављивања:most_common()
  • Пребројите број (тип) елемената који се не преклапају (јединствени елементи).
  • Избројите број елемената који задовољавају услов.

Поред тога, као конкретан пример, следеће је објашњено са примером кода.

  • Броји број појављивања речи у низу.
  • Избројите број појављивања знака у низу.

Узорак је листа, али иста обрада се може обавити са торкама.

Изброј укупан број елемената: лен()

Да бисте пребројали укупан број елемената на листи или тупле, користите уграђену функцију лен().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(len(l))
# 7

Бројање броја сваког елемента (број појављивања сваког елемента): метода цоунт().

Да бисте пребројали број сваког елемента (број појављивања сваког елемента), користите метод цоунт() за листе, торке итд.

Ако се вредност која не постоји као елемент проследи као аргумент, враћа се 0.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

Ако желите да добијете број појављивања сваког елемента одједном, корисна је следећа збирка.

Како користити колекције.Цоунтер

Колекције стандардне библиотеке Питхон-а имају класу Цоунтер.

Цоунтер() је поткласа типа речника дицт, која има податке у облику елемената као кључеве и појављивања као вредности.

import collections

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

Ако је елемент наведен као кључ, може се добити број елемената. Ако је наведена вредност која не постоји као елемент, враћа се 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Такође можете користити методе типа речника као што су кључеви(), вредности(), ставке() итд.

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

Ове методе враћају објекте типа дицт_кеис, итд. Могу се користити као што јесу ако желите да покренете фор наредбу. Ако желите да га конвертујете у листу, користите лист().

Добијање елемената по редоследу учесталости појављивања: метода мост_цоммон().

Бројач има методу мост_цоммон(), која враћа листу торки облика (елемент, број појављивања) сортираних по броју појављивања.

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

Елемент са највећим бројем појављивања може се добити навођењем индекса, као што је [0] за највећи број појављивања и [-1] за најмањи број појављивања. Ако желите да добијете само елементе или само број појављивања, можете даље да одредите индекс.

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

Ако желите да их сортирате по опадајућем броју појављивања, користите исечак са повећањем постављеним на -1.

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

Ако је аргумент н наведен за методу мост_цоммон(), враћа се само н елемената са највећим бројем појављивања. Ако је изостављен, сви елементи.

print(c.most_common(2))
# [('a', 4), ('c', 2)]

Ако желите засебну листу елемената/појава пореданих по броју појављивања, а не по скупу (елемент, број појављивања), можете је разложити на следећи начин

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

Уграђена функција зип() се користи за транспоновање дводимензионалне листе (у овом случају, списак торки), а затим је распакује и издвоји.

Пребројите број (тип) елемената који се не преклапају (јединствени елементи).

Да бисте пребројали колико елемената који се не преклапају (јединствени елементи) постоји у листи или тупле (колико типова има), користите Цоунтер или сет() као што је горе описано.

Број елемената у објекту Цоунтер једнак је броју непоклапајућих елемената у оригиналној листи, који се може добити помоћу лен().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

Такође можете користити сет(), конструктор за сет типа скупа, што је лакше ако вам није потребан објекат Цоунтер.

Тип скупа је тип података који нема дуплиране елементе. Прослеђивање листе у сет() занемарује дупликате вредности и враћа објекат типа скуп са само јединственим вредностима као елементима. Број елемената овог типа добија се помоћу лен().

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

Избројите број елемената који задовољавају услов.

Да бисте пребројали број елемената у листи или тупле који задовољавају одређени услов, користите нотацију разумевања листе или изразе генератора.

Као пример, пребројите број елемената са негативним вредностима за следећу листу бројева

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

Примена условног израза на сваки елемент у нотацији разумевања листе даје листу чији су елементи Боолеан боол (тачно, нетачно). Булов тип боол је поткласа целобројног типа инт, где се труе третира као 1, а нетачно као 0. Због тога се број тачних вредности (број елемената који задовољавају услов) може рачунати израчунавањем суме користећи збир ().

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

Ако заменимо [] у запису за разумевање листе са (), добићемо израз генератора. Нотација за разумевање листе генерише листу свих обрађених елемената, док израз генератора обрађује елементе секвенцијално и стога је ефикаснији у меморији.

Када је израз генератора једини аргумент, () се може изоставити, тако да се може написати као у другом случају.

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

Ако желите да пребројите број лажних вредности (број елемената који не задовољавају услов), користите нот. Имајте на уму да &гт; има већи приоритет него не (прво се израчунава), тако да заграде () у (и &лт; 0) у следећем примеру нису неопходне.

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

Наравно, сами услови се могу мењати.

print(sum(i >= 0 for i in l))
# 6

Неки други примери су приказани у наставку.

Пример добијања броја непарних елемената за листу бројева.

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

Пример услова за листу стрингова.

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

Бројач се користи за бројање на основу броја појављивања. итемс() преузима скуп (елемент, број појављивања), а број појављивања специфицира услов.

Следи пример издвајања елемената са два или више појављивања и бројања укупног броја појављивања. У овом примеру постоје четири а и два ц, укупно шест.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

Следи пример издвајања типова елемената са два или више појављивања и бројања броја појављивања. У овом примеру постоје два типа, а и ц.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

Броји број појављивања речи у низу.

Као конкретан пример, избројимо број појављивања речи у низу.

Прво замените непотребне зарезе и тачке празним низом користећи методу реплаце(), а затим их обришите. Затим користите методу сплит() да направите листу раздвојену размацима.

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

Ако можете да направите листу, можете да добијете колико пута се свака реч појављује, типове речи које се појављују и мост_цоммон() колекција. Бројач да бисте добили реч која се појављује највише пута.

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

Горе наведени процес је веома једноставан, па је боље користити библиотеке као што је НЛТК за сложенију обраду природног језика.

Такође, у случају јапанског текста, сплит() се не може користити за раздвајање текста јер нема јасног раздвајања речи. На пример, можете користити Јаноме библиотеку да бисте то постигли.

Избројите број појављивања знака у низу.

Пошто су стрингови такође тип секвенце, могу се користити са методом цоунт() или прослеђивати као аргумент конструктору колекција.Цоунтер().

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

Пример преузимања првих 5 знакова који се најчешће појављују.

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')