شمارش تعداد دفعات هر عنصر در یک لیست با شمارنده پایتون

کسب و کار

در پایتون، تعداد تمام عناصر یک لیست یا تاپل را می توان با استفاده از تابع داخلی len() به دست آورد، و تعداد هر عنصر (تعداد وقوع هر عنصر) را می توان با استفاده از روش count() بدست آورد. .

علاوه بر این، از کلاس Counter مجموعه های کتابخانه استاندارد پایتون می توان برای بدست آوردن عناصر به ترتیب تعداد وقوع استفاده کرد.

در این بخش به موارد زیر می پردازیم

  • تعداد کل عناصر را بشمارید:len()
  • تعداد هر عنصر را بشمارید (تعداد وقوع هر عنصر):count()
  • استفادهcollections.Counter
  • عناصر به ترتیب دفعات وقوع بازیابی می شوند:most_common()
  • تعداد (نوع) عناصر غیر همپوشانی (عناصر منحصر به فرد) را بشمارید.
  • تعداد عناصری را که شرط را برآورده می کنند بشمارید.

علاوه بر این، به عنوان یک مثال عینی، موارد زیر با نمونه کد توضیح داده شده است.

  • تعداد دفعات یک کلمه را در یک رشته می شمارد.
  • تعداد دفعات یک کاراکتر را در یک رشته بشمارید.

نمونه یک لیست است، اما همان پردازش را می توان با تاپل ها انجام داد.

تعداد کل عناصر را بشمارید: len()

برای شمارش تعداد کل عناصر در یک لیست یا تاپل، از تابع داخلی len() استفاده کنید.

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

print(len(l))
# 7

شمارش تعداد هر عنصر (تعداد وقوع هر عنصر): متد count().

برای شمارش تعداد هر عنصر (تعداد وقوع هر عنصر)، از متد count() برای لیست ها، تاپل ها و غیره استفاده کنید.

اگر مقداری که به عنوان عنصر وجود ندارد به عنوان آرگومان ارسال شود، 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

اگر می خواهید تعداد دفعات هر عنصر را به طور همزمان بدست آورید، مجموعه زیر مفید است.

نحوه استفاده از collections.Counter

مجموعه کتابخانه استاندارد پایتون دارای یک کلاس Counter است.

Counter() یک زیر کلاس از نوع دیکشنری dict است که داده ها را به صورت عناصر به عنوان کلید و رخدادها به عنوان مقادیر دارد.

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

همچنین می توانید از روش های نوع دیکشنری مانند keys()، values()، items() و غیره استفاده کنید.

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

این متدها اشیایی از نوع dict_keys و غیره را برمی‌گردانند. اگر می‌خواهید دستور for را اجرا کنید، می‌توان از آن‌ها استفاده کرد. اگر می خواهید آن را به لیست تبدیل کنید، از list() استفاده کنید.

به دست آوردن عناصر به ترتیب فرکانس ظاهر: متد most_common().

شمارنده دارای متد most_common() است که فهرستی از چند تای فرم (عنصر، تعداد رخدادها) مرتب شده بر اساس تعداد رخدادها را برمی گرداند.

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

اگر آرگومان n برای متد most_common() مشخص شود، فقط n عنصر با بیشترین تعداد رخداد برگردانده می شود. اگر حذف شود، تمام عناصر.

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)

تابع داخلی ()zip برای جابجایی یک لیست دو بعدی (در این مورد، لیستی از تاپل ها) و سپس باز کردن و استخراج آن استفاده می شود.

تعداد (نوع) عناصر غیر همپوشانی (عناصر منحصر به فرد) را بشمارید.

برای شمارش تعداد عناصر غیر همپوشانی (عناصر منحصر به فرد) در یک لیست یا چند نوع (چند نوع وجود دارد)، همانطور که در بالا توضیح داده شد از Counter یا set() استفاده کنید.

تعداد عناصر موجود در شی Counter برابر با تعداد عناصر غیر همپوشانی در لیست اصلی است که می توان با len() به دست آورد.

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

print(len(c))
# 3

شما همچنین می توانید از set()، سازنده مجموعه نوع set استفاده کنید، که اگر به شی Counter نیاز نداشته باشید، آسان تر است.

نوع مجموعه یک نوع داده است که عناصر تکراری ندارد. ارسال یک لیست به set() مقادیر تکراری را نادیده می گیرد و یک شی از نوع مجموعه را با مقادیر منحصر به فرد به عنوان عناصر برمی گرداند. تعداد عناصر این نوع توسط len() بدست می آید.

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]

اعمال یک عبارت شرطی برای هر عنصر در نماد درک فهرست، فهرستی را به دست می‌دهد که عناصر آن Boolean Boole (درست، نادرست) هستند. نوع Boolean یک زیر کلاس از نوع عدد صحیح int است، که در آن true به عنوان 1 و false به عنوان 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

اگر می خواهید تعداد مقادیر نادرست (تعداد عناصری که شرط را برآورده نمی کنند) بشمارید، از not استفاده کنید. توجه داشته باشید که > اولویت بیشتری نسبت به عدم دارد (اول محاسبه می شود)، بنابراین پرانتز () در (i < 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

شمارنده برای شمارش بر اساس تعداد دفعات استفاده می شود. آیتم() چند عدد از (عنصر، تعداد رخدادها) را بازیابی می کند و تعداد رخدادها شرط را مشخص می کند.

در زیر نمونه ای از استخراج عناصر با دو یا چند رخداد و شمارش تعداد کل رخدادها آورده شده است. در این مثال، چهار a و دو c وجود دارد که در مجموع شش مورد است.

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 و c وجود دارد.

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

تعداد دفعات یک کلمه را در یک رشته می شمارد.

به عنوان مثال ملموس، بیایید تعداد دفعات یک کلمه را در یک رشته بشماریم.

ابتدا کاماها و نقطه های غیر ضروری را با یک رشته خالی با استفاده از متد ()place جایگزین کنید و سپس آنها را حذف کنید. سپس از متد split() برای ایجاد یک لیست جدا شده با فاصله استفاده کنید.

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

اگر می‌توانید فهرستی بسازید، می‌توانید تعداد دفعاتی که هر کلمه ظاهر می‌شود، انواع کلماتی که ظاهر می‌شوند، و most_common() مجموعه‌ها را دریافت کنید.

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

موارد فوق یک فرآیند بسیار ساده است، بنابراین بهتر است از کتابخانه هایی مانند NLTK برای پردازش پیچیده تر زبان طبیعی استفاده کنید.

همچنین، در مورد متن ژاپنی، نمی توان از split() برای تقسیم متن استفاده کرد زیرا جداسازی کلمات واضحی وجود ندارد. برای مثال می توانید از کتابخانه Janome برای رسیدن به این هدف استفاده کنید.

تعداد دفعات یک کاراکتر را در یک رشته بشمارید.

از آنجایی که رشته ها نیز یک نوع دنباله هستند، می توان از آنها با متد count() استفاده کرد یا به عنوان آرگومان به سازنده collections ارسال کرد.Counter().

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