Python کے کاؤنٹر کے ساتھ فہرست میں ہر عنصر کی موجودگی کی تعداد کو شمار کرنا

کاروبار

Python میں، فہرست میں موجود تمام عناصر کی تعداد یا tuple بلٹ ان فنکشن len() کا استعمال کرتے ہوئے حاصل کی جا سکتی ہے، اور ہر عنصر کی تعداد (ہر عنصر کی موجودگی کی تعداد) کو count() طریقہ استعمال کرتے ہوئے حاصل کیا جا سکتا ہے۔ .

اس کے علاوہ، Python معیاری لائبریری کے مجموعوں کی کاؤنٹر کلاس کو واقعات کی تعداد کے مطابق عناصر حاصل کرنے کے لیے استعمال کیا جا سکتا ہے۔

اس سیکشن میں، ہم مندرجہ ذیل بات کریں گے۔

  • عناصر کی کل تعداد شمار کریں:len()
  • ہر عنصر کی تعداد شمار کریں (ہر عنصر کے واقعات کی تعداد):count()
  • استعمالcollections.Counter
  • عناصر کو وقوع کی تعدد کی ترتیب میں بازیافت کیا جاتا ہے:most_common()
  • غیر متجاوز عناصر (منفرد عناصر) کی تعداد (قسم) شمار کریں۔
  • ان عناصر کی تعداد شمار کریں جو شرط کو پورا کرتے ہیں۔

اس کے علاوہ، ایک ٹھوس مثال کے طور پر، نمونہ کوڈ کے ساتھ مندرجہ ذیل وضاحت کی گئی ہے۔

  • ایک سٹرنگ میں کسی لفظ کی موجودگی کی تعداد کو شمار کرتا ہے۔
  • ایک سٹرنگ میں ایک کردار کے واقعات کی تعداد شمار کریں.

نمونہ ایک فہرست ہے، لیکن ایک ہی پروسیسنگ tuples کے ساتھ کیا جا سکتا ہے.

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

فہرست یا ٹیپل میں عناصر کی کل تعداد شمار کرنے کے لیے، بلٹ ان فنکشن len() استعمال کریں۔

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

اگر آپ ایک ہی وقت میں ہر عنصر کے واقعات کی تعداد حاصل کرنا چاہتے ہیں، تو درج ذیل مجموعہ۔ کاؤنٹر مفید ہے۔

collections.Counter کا استعمال کیسے کریں۔

Python معیاری لائبریری کے مجموعوں میں کاؤنٹر کلاس ہے۔

Counter() ڈکشنری ٹائپ ڈکٹ کا ایک ذیلی طبقہ ہے، جس میں عناصر کی شکل میں ڈیٹا ہوتا ہے بطور کلید اور واقعات بطور قدر۔

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

یہ طریقے dict_keys وغیرہ کی اشیاء کو واپس کرتے ہیں۔ انہیں اس طرح استعمال کیا جا سکتا ہے جیسے آپ اسٹیٹمنٹ کے لیے چلانا چاہتے ہیں۔ اگر آپ اسے فہرست میں تبدیل کرنا چاہتے ہیں تو 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() کا استعمال کریں جیسا کہ اوپر بیان کیا گیا ہے۔

کاؤنٹر آبجیکٹ میں عناصر کی تعداد اصل فہرست میں غیر متجاوز عناصر کی تعداد کے برابر ہے، جو len() کے ساتھ حاصل کی جا سکتی ہے۔

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

print(len(c))
# 3

آپ سیٹ()، سیٹ ٹائپ سیٹ کے لیے کنسٹرکٹر بھی استعمال کر سکتے ہیں، اگر آپ کو کاؤنٹر آبجیکٹ کی ضرورت نہیں ہے تو یہ آسان ہے۔

سیٹ کی قسم ایک ڈیٹا کی قسم ہے جس میں ڈپلیکیٹ عناصر نہیں ہوتے ہیں۔ ایک فہرست کو 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]

فہرست فہمی اشارے میں ہر عنصر پر مشروط اظہار کا اطلاق کرنے سے ایک فہرست حاصل ہوتی ہے جس کے عناصر بولین بول (سچ، غلط) ہوتے ہیں۔ بولین ٹائپ بول انٹیجر ٹائپ int کا ایک ذیلی طبقہ ہے، جہاں سچ کو 1 اور غلط کو 0 سمجھا جاتا ہے۔ لہذا، صحیح قدروں کی تعداد (شرط کو پورا کرنے والے عناصر کی تعداد) کو sum کا استعمال کرتے ہوئے رقم کا حساب لگا کر شمار کیا جا سکتا ہے۔ ()

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

اگر آپ غلط اقدار کی تعداد گننا چاہتے ہیں (عناصر کی تعداد جو شرط کو پورا نہیں کرتے ہیں)، استعمال نہ کریں۔ نوٹ کریں کہ > نہیں سے زیادہ فوقیت رکھتا ہے (اس کا پہلے حساب لگایا جاتا ہے)، اس لیے درج ذیل مثال میں (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’s اور دو c’s ہیں۔

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

ایک سٹرنگ میں کسی لفظ کی موجودگی کی تعداد کو شمار کرتا ہے۔

ایک ٹھوس مثال کے طور پر، آئیے ایک سٹرنگ میں کسی لفظ کی موجودگی کی تعداد شمار کرتے ہیں۔

پہلے غیر ضروری کوما اور پیریڈز کو ریپلیس() طریقہ استعمال کرکے خالی سٹرنگ سے تبدیل کریں، اور پھر انہیں حذف کریں۔ اس کے بعد، اسپیس سے الگ کی گئی فہرست بنانے کے لیے 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 لائبریری کا استعمال کر سکتے ہیں۔

ایک سٹرنگ میں ایک کردار کے واقعات کی تعداد شمار کریں.

چونکہ سٹرنگز بھی ایک ترتیب کی قسم ہیں، ان کو شمار() طریقہ کے ساتھ استعمال کیا جا سکتا ہے یا جمع کرنے والے کے لیے دلیل کے طور پر پاس کیا جا سکتا ہے۔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')
Copied title and URL