Python Sayacı ile bir listedeki her öğenin oluşum sayısını sayma

iş

Python’da, bir liste veya demetteki tüm öğelerin sayısı yerleşik işlev len() kullanılarak elde edilebilir ve her öğenin sayısı (her öğenin oluşum sayısı) count() yöntemi kullanılarak elde edilebilir. .

Ek olarak, Python standart kitaplık koleksiyonlarının Counter sınıfı, öğeleri oluşum sayısına göre almak için kullanılabilir.

Bu bölümde, aşağıdakileri tartışacağız

  • Toplam eleman sayısını sayın:len()
  • Her öğenin sayısını sayın (her öğenin oluşum sayısı):count()
  • Kullanımcollections.Counter
  • Öğeler, oluşma sıklık sırasına göre alınır:most_common()
  • Örtüşmeyen öğelerin (benzersiz öğeler) sayısını (tipini) sayın.
  • Koşul sağlayan öğelerin sayısını sayın.

Ayrıca somut bir örnek olarak aşağıda örnek kod ile anlatılmıştır.

  • Bir dizedeki bir kelimenin oluşum sayısını sayar.
  • Bir dizgede bir karakterin oluşum sayısını sayın.

Örnek bir listedir, ancak aynı işleme tuples ile yapılabilir.

Toplam eleman sayısını sayın: len()

Bir listedeki veya demetteki toplam öğe sayısını saymak için yerleşik len() işlevini kullanın.

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

print(len(l))
# 7

Her öğenin sayısını sayma (her öğenin oluşum sayısı): count() yöntemi

Her öğenin sayısını (her öğenin oluşum sayısı) saymak için listeler, demetler vb. için count() yöntemini kullanın.

Öğe olarak var olmayan bir değer bağımsız değişken olarak iletilirse, 0 döndürülür.

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

Bir kerede her öğenin oluşum sayısını almak istiyorsanız, aşağıdaki collection.Counter yararlıdır.

collections.Counter nasıl kullanılır?

Python standart kitaplık koleksiyonlarının bir Counter sınıfı vardır.

Counter(), anahtarlar olarak öğeler ve değerler olarak oluşumlar biçiminde verilere sahip olan sözlük türünün bir alt sınıfıdır.

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

Bir eleman anahtar olarak belirtilirse eleman sayısı elde edilebilir. Öğe olarak mevcut olmayan bir değer belirtilirse, 0 döndürülür.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Anahtarlar(), değerler(), öğeler() vb. gibi sözlük türü yöntemlerini de kullanabilirsiniz.

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

Bu yöntemler, dict_keys vb. türünden nesneler döndürür. Bir for deyimi çalıştırmak istiyorsanız, olduğu gibi kullanılabilirler. Listeye dönüştürmek istiyorsanız list()’i kullanın.

Öğelerin görünüm sıklığı sırasına göre elde edilmesi: most_common() yöntemi

Sayaç, oluşum sayısına göre sıralanmış form demetlerinin (öğe, oluşum sayısı) bir listesini döndüren most_common() yöntemine sahiptir.

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

En yüksek tekrar sayısına sahip öğe, en yüksek tekrar sayısı için [0] ve en düşük tekrar sayısı için [-1] gibi bir indeks belirtilerek elde edilebilir. Yalnızca öğeleri veya yalnızca oluşum sayısını almak istiyorsanız, dizini daha fazla belirtebilirsiniz.

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

Bunları azalan oluşum sayısına göre sıralamak istiyorsanız, artış -1 olarak ayarlanmış dilimi kullanın.

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

Most_common() yöntemi için n bağımsız değişkeni belirtilirse, yalnızca en yüksek tekrar sayısına sahip n öğe döndürülür. Atlanırsa, tüm öğeler.

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

Bir grup (eleman, oluşum sayısı) yerine oluşum sayısına göre sıralanmış ayrı bir öğe/oluşma listesi istiyorsanız, onu aşağıdaki gibi ayrıştırabilirsiniz.

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

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

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

Yerleşik zip() işlevi, iki boyutlu bir listeyi (bu durumda, bir demet listesi) transpoze etmek ve ardından paketi açıp çıkarmak için kullanılır.

Örtüşmeyen öğelerin (benzersiz öğeler) sayısını (tipini) sayın.

Bir listede veya demette kaç tane örtüşmeyen eleman (benzersiz eleman) olduğunu (kaç tip olduğunu) saymak için, yukarıda açıklandığı gibi Counter veya set() kullanın.

Counter nesnesindeki öğelerin sayısı, orijinal listedeki len() ile elde edilebilecek örtüşmeyen öğelerin sayısına eşittir.

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

print(len(c))
# 3

Ayrıca, bir Counter nesnesine ihtiyacınız yoksa daha kolay olan set tipi setin yapıcısı olan set()’i de kullanabilirsiniz.

Küme türü, yinelenen öğeleri olmayan bir veri türüdür. set() öğesine bir liste iletmek, yinelenen değerleri yok sayar ve öğe olarak yalnızca benzersiz değerlere sahip set türünde bir nesne döndürür. Bu tipteki elemanların sayısı len() ile elde edilir.

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

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

Koşul sağlayan öğelerin sayısını sayın.

Belirli bir koşulu karşılayan bir liste veya demetteki öğelerin sayısını saymak için liste anlama gösterimini veya oluşturucu ifadeleri kullanın.

Örnek olarak, aşağıdaki sayı listesi için negatif değerlere sahip öğelerin sayısını sayın.

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

Liste anlama notasyonundaki her öğeye koşullu bir ifade uygulamak, öğeleri Boolean bools (true, false) olan bir liste verir. Boole türü bool, int tamsayı türünün bir alt sınıfıdır; burada true 1 olarak ve false 0 olarak kabul edilir. Bu nedenle, doğru değerlerin sayısı (koşulu karşılayan öğelerin sayısı), toplamı kullanarak toplamı hesaplayarak sayılabilir. ().

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

Liste anlama notasyonundaki []’yi () ile değiştirirsek, bir üreteç ifadesi alırız. Liste anlama gösterimi, işlenen tüm öğelerin bir listesini oluştururken, oluşturucu ifadesi öğeleri sırayla işler ve bu nedenle bellek açısından daha verimlidir.

Jeneratör ifadesi tek argüman olduğunda, () atlanabilir, bu nedenle ikinci durumda olduğu gibi yazılabilir.

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

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

Yanlış değerlerin sayısını (koşulu karşılamayan öğelerin sayısı) saymak istiyorsanız, not’u kullanın. > olmamasından daha yüksek bir önceliğe sahiptir (ilk olarak hesaplanır), bu nedenle aşağıdaki örnekte (i < 0) içindeki parantezler () gerekli değildir.

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

Tabii ki, koşulların kendisi değiştirilebilir.

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

Diğer bazı örnekler aşağıda gösterilmiştir.

Bir sayı listesi için tek öğelerin sayısını alma örneği.

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

Dize listesi için koşul örneği.

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

Sayaç, oluşum sayısına göre saymak için kullanılır. item() bir (eleman, oluşum sayısı) demetini alır ve oluşum sayısı durumu belirtir.

Aşağıdaki, iki veya daha fazla oluşuma sahip öğelerin çıkarılmasına ve toplam oluşum sayısının sayılmasına bir örnektir. Bu örnekte, toplam altı olmak üzere dört a ve iki c vardır.

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

Aşağıdaki, iki veya daha fazla oluşuma sahip eleman türlerinin çıkarılmasına ve oluşum sayısının sayılmasına ilişkin bir örnektir. Bu örnekte, a ve c olmak üzere iki tür vardır.

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

Bir dizedeki bir kelimenin oluşum sayısını sayar.

Somut bir örnek olarak, bir dizgede bir kelimenin oluşum sayısını sayalım.

İlk olarak, replace() yöntemini kullanarak gereksiz virgülleri ve noktaları boş bir dizeyle değiştirin ve ardından bunları silin. Ardından, boşluklarla ayrılmış bir liste oluşturmak için split() yöntemini kullanın.

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

Bir liste yapabilirseniz, her kelimenin kaç kez göründüğünü, görünen kelime türlerini ve koleksiyonların en sık görülen() değerini alabilirsiniz. En çok görünen kelimeyi almak için Sayaç.

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

Yukarıdakiler çok basit bir işlemdir, bu nedenle daha karmaşık doğal dil işleme için NLTK gibi kitaplıkları kullanmak daha iyidir.

Ayrıca, Japonca metin durumunda, net bir sözcük ayrımı olmadığından metni bölmek için split() kullanılamaz. Örneğin, bunu başarmak için Janome kütüphanesini kullanabilirsiniz.

Bir dizgede bir karakterin oluşum sayısını sayın.

Dizeler aynı zamanda bir dizi türü olduğundan, count() yöntemiyle kullanılabilir veya collections.Counter() yapıcısına bir argüman olarak iletilebilir.

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

En sık görülen ilk 5 karakteri alma örneği.

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')
Copied title and URL