סופר Python – מונה אוספי Python

המחלקה Counter בפייתון היא חלק מהמודול Collections. Counter היא מחלקת משנה של Dictionary ומשמשת לעקוב אחר הרכיבים והכמות שלהם.

קאונטר בפייתון

Counter היא אוסף בלתי מסודר שבו הרכיבים מאוחסנים כמפתחות ב־Dict והכמות שלהם כערך של ה־dict. כמות הרכיבים ב־Counter יכולה להיות מספרים שלמים חיוביים, אפס או שליליים. עם זאת, אין מגבלה על המפתחות והערכים שלו. למרות שהערכים מיועדים להיות מספרים, אנחנו יכולים גם לאחסן עצם אחר בתוכו.

יצירת אובייקט Counter בפייתון

אנחנו יכולים ליצור Counter ריק או להתחיל עם ערכים ראשוניים כלשהם.

from collections import Counter

# Counter ריק
counter = Counter()
print(counter)  # Counter()

# Counter עם ערכים ראשוניים
counter = Counter(['a', 'a', 'b'])
print(counter)  # Counter({'a': 2, 'b': 1})

counter = Counter(a=2, b=3, c=1)
print(counter)  # Counter({'b': 3, 'a': 2, 'c': 1})

אנחנו יכולים גם להשתמש בכל Iterable כפרמטר ליצירת אובייקט Counter. לכן מחרוזת סדורה ו־רשימה יכולות גם לשמש ליצירת אובייקט Counter.

# Iterable as argument for Counter
counter = Counter('abc')
print(counter)  # Counter({'a': 1, 'b': 1, 'c': 1})

# List as argument to Counter
words_list = ['Cat', 'Dog', 'Horse', 'Dog']
counter = Counter(words_list)
print(counter)  # Counter({'Dog': 2, 'Cat': 1, 'Horse': 1})

# Dictionary as argument to Counter
word_count_dict = {'Dog': 2, 'Cat': 1, 'Horse': 1}
counter = Counter(word_count_dict)
print(counter)  # Counter({'Dog': 2, 'Cat': 1, 'Horse': 1})

כפי שציינתי למעלה, אנו יכולים להשתמש גם בנתונים שאינם מספריים כערכי count, אך זה יפגע במטרת ה-class Counter.

# Counter עובד גם עם לא מספרים
special_counter = Counter(name='Pankaj', age=20)
print(special_counter)  # Counter({'name': 'Pankaj', 'age': 20})

שיטות Counter ב-Python

בואו נבחן שיטות ב-class Counter וכמה פעולות נוספות שאנו יכולים לבצע עליו.

קבלת ספירת איברים

# קבלת ספירה
counter = Counter({'Dog': 2, 'Cat': 1, 'Horse': 1})
countDog = counter['Dog']
print(countDog)  # 2

אם ננסה לקבל את מספר המופעים של מפתח שאינו קיים, הוא יחזיר 0 ולא יזרוק שגיאת KeyError.

# קבלת ספירה גם עבור מפתח שאינו קיים, אינה גורמת ל-KeyError
print(counter['Unicorn'])  # 0

הגדרת ספירת איברים

אנו יכולים גם להגדיר את ספירת המופעים של איבר קיים ב-counter. אם האיבר אינו קיים, הוא יתווסף ל-counter.

counter = Counter({'Dog': 2, 'Cat': 1, 'Horse': 1})
# הגדרת ספירה
counter['Horse'] = 0
print(counter)  # Counter({'Dog': 2, 'Cat': 1, 'Horse': 0})

# הגדרת ספירה for non-existing key, adds to Counter
counter['Unicorn'] = 1
print(counter)  # Counter({'Dog': 2, 'Cat': 1, 'Unicorn': 1, 'Horse': 0})

מחיקת איבר מתוך Counter

ניתן להשתמש ב־del כדי למחוק איבר מתוך אובייקט ה־counter.

# מחיקת איבר מתוך Counter
del counter['Unicorn']
print(counter)  # Counter({'Dog': 2, 'Cat': 1, 'Horse': 0})

elements()

שיטה זו מחזירה את רשימת האיברים ב־counter. מחזירים רק איברים עם מונים חיוביים.

counter = Counter({'Dog': 2, 'Cat': -1, 'Horse': 0})

# elements()
elements = counter.elements()  # doesn't return elements with count 0 or less
for value in elements:
    print(value)

הקוד למעלה ידפיס "כלב" פעמיים מכיוון שהמונה שלו הוא 2. איברים אחרים יתעלמו מכיוון שאין להם מונים חיוביים. Counter הוא אוסף לא מסודר, לכן האיברים מוחזרים ללא סדר ספציפי.

most_common(n)

שיטה זו מחזירה את האיברים הנפוצים ביותר מתוך ה־counter. אם אינו מספקים ערך של 'n', אז מחזירים מילון ממוין מהאיברים הנפוצים ביותר לפחות נפוצים. ניתן להשתמש בחיתוך כדי לקבל את האיברים הפחות נפוצים במילון הממוין הזה.

counter = Counter({'Dog': 2, 'Cat': -1, 'Horse': 0})

# most_common()
most_common_element = counter.most_common(1)
print(most_common_element)  # [('Dog', 2)]

least_common_element = counter.most_common()[:-2:-1]
print(least_common_element)  # [('Cat', -1)]

subtract() ו־update()

מתודת Counter subtract() משמשת להורדת מונה אלמנטים ממונה אחר. מתודת update() משמשת להוספת מונים ממונה אחר.

counter = Counter('ababab')
print(counter)  # Counter({'a': 3, 'b': 3})
c = Counter('abc')
print(c)  # Counter({'a': 1, 'b': 1, 'c': 1})

# subtract
counter.subtract(c)
print(counter)  # Counter({'a': 2, 'b': 2, 'c': -1})

# update
counter.update(c)
print(counter)  # Counter({'a': 3, 'b': 3, 'c': 0})

פעולות חשבון Python Counter

ניתן לבצע פעולות אריתמטיות מסוימות גם על Counters, בדיוק כמו מספרים. אך רק אלמנטים עם מונה חיובי מוחזרים עם הפעולות הללו.

# פעולות אריתמטיות
c1 = Counter(a=2, b=0, c=-1)
c2 = Counter(a=1, b=-1, c=2)

c = c1 + c2  # return items having +ve count only
print(c)  # Counter({'a': 3, 'c': 1})

c = c1 - c2  # keeps only +ve count elements
print(c)  # Counter({'a': 1, 'b': 1})

c = c1 & c2  # intersection min(c1[x], c2[x])
print(c)  # Counter({'a': 1})

c = c1 | c2  # union max(c1[x], c2[x])
print(c)  # Counter({'a': 2, 'c': 2})

פעולות שונות בקונטר של Python

בואו נסתכל על קטעי קוד לדוגמאות שונות שאפשר לבצע על עצמות Counter.

counter = Counter({'a': 3, 'b': 3, 'c': 0})
# דוגמאות שונות
print(sum(counter.values()))  # 6

print(list(counter))  # ['a', 'b', 'c']
print(set(counter))  # {'a', 'b', 'c'}
print(dict(counter))  # {'a': 3, 'b': 3, 'c': 0}
print(counter.items())  # dict_items([('a', 3), ('b', 3), ('c', 0)])

# הסרת אלמנטים עם מונה 0 או שלילי
counter = Counter(a=2, b=3, c=-1, d=0)
counter = +counter
print(counter)  # Counter({'b': 3, 'a': 2})

# ניקוי כל האלמנטים
counter.clear()
print(counter)  # Counter()

זהו כל מה שיש לנו לדעת על מחלקת Counter של Python.

ניתן להוריד את קוד הדוגמא המלא מה־מאגר הקוד שלי ב־GitHub.

התייחסות: מסמכי פייתון