Python Count: आधुनिक पैटर्न, आम गलतियाँ, और व्यवहारिक उदाहरण

चीज़ों की गिनती आसान लगती है, जब तक नतीजे थोड़े—या काफी—गलत न दिखें। मैंने बार-बार list.count() कॉल्स से की गई फ़्रीक्वेंसी जाँचें और pandas के ऐसे तरीकों का गलत उपयोग देखा है जो चुपचाप missing values छोड़ देते हैं। नतीजा: धीमा कोड और गलत संख्या। समाधान है काम के लिए सही टूल चुनना: फ़्रीक्वेंसी मैप्स के लिए collections.Counter, एकल मान के त्वरित क्वेरी के लिए बिल्ट-इन count(), और DataFrame में होने पर pandas का value_counts()।

Counter क्या है और यह कैसे काम करता है

collections.Counter हैशेबल ऑब्जेक्ट्स की गिनती (एक मल्टीसेट) के लिए डिक्शनरी का सबक्लास है। आप किसी iterable या mapping से Counter बना सकते हैं। गुम कुंजियाँ डिफ़ॉल्ट रूप से 0 लौटाती हैं; काउंट बढ़ाए या घटाए जा सकते हैं; और कई सुविधाजनक मेथड आम कार्यों को आसान बनाते हैं।

from collections import Counter

# From an iterable (one pass over the data)
nyc_eatery_types = [
    "Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant", "Food Cart",
    "Restaurant", "Mobile Food Truck", "Snack Bar", "Mobile Food Truck"
]
eatery_type_counts = Counter(nyc_eatery_types)
print(eatery_type_counts)  # dict-like view
print(eatery_type_counts["Restaurant"])  # missing keys return 0 instead of KeyError
print(eatery_type_counts["Kiosk"])संचालित द्वारा

Counter({'Mobile Food Truck': 3, 'Food Cart': 2, 'Snack Bar': 2, 'Restaurant': 2})
2
0संचालित द्वारा

Counter के iteration क्रम पर निर्भर न रहें। जब रैंकिंग चाहिए, तो most_common() का उपयोग करें।

most_common() से सबसे आम मान ढूँढें

Counter.most_common(n) घटते क्रम में (item, count) युग्मों की सूची लौटाता है। परिणाम सीमित करने के लिए n दें, या सभी युग्म पाने के लिए इसे छोड़ दें।

top_3 = eatery_type_counts.most_common(3)
print(top_3)संचालित द्वारा

[('Mobile Food Truck', 3), ('Food Cart', 2), ('Snack Bar', 2)]संचालित द्वारा

इसे तब उपयोग करें जब आपको फ़्रीक्वेंसी एनालिटिक्स, लीडरबोर्ड्स, या श्रेणीबद्ध डेटा पर त्वरित sanity checks चाहिए।

Counter से और क्या कर सकते हैं

update और subtract से काउंट बदलें

व्यावसायिक डेटा बदलता रहता है। update() काउंट बढ़ाता है, जबकि subtract() उन्हें घटाता है। दोनों iterable या mapping स्वीकार करते हैं।

new_permits = ["Restaurant", "Food Cart", "Restaurant"]
eatery_type_counts.update(new_permits)  # add 1 for each occurrence
print(eatery_type_counts)

closures = {"Snack Bar": 1}
eatery_type_counts.subtract(closures)   # reduce counts (can go negative)
print(eatery_type_counts)संचालित द्वारा

Counter({'Mobile Food Truck': 3, 'Restaurant': 4, 'Food Cart': 3, 'Snack Bar': 2})
Counter({'Restaurant': 4, 'Mobile Food Truck': 3, 'Food Cart': 3, 'Snack Bar': 1})संचालित द्वारा

यदि कोई काउंट 0 या उससे नीचे चला जाता है, तो elements() और most_common() जैसे मेथड उसे नज़रअंदाज़ करते हैं। किसी कुंजी को पूरी तरह हटाने के लिए del counter[key] का उपयोग करें।

कुल जोड़ें और Top-N निकालें

Python 3.10 से, Counter.total() सभी काउंट का योग लौटाता है। अनुपात या शेयर निकालने में यह सहायक है।

total_permits = eatery_type_counts.total()
for eatery, count in eatery_type_counts.most_common(3):
    share = count / total_permits
    print(f"{eatery}: {count} ({share:.1%})")संचालित द्वारा

elements() से क्रम पुनर्निर्मित करें

elements() प्रत्येक तत्व को उसके काउंट के अनुसार बार-बार उत्पन्न करता है। क्रम मनमाना होता है।

expanded = list(eatery_type_counts.elements())
print(len(expanded), "items reconstructed from counts")संचालित द्वारा

गणित और सेट-शैली के ऑपरेशन उपयोग करें

आप काउंटर्स को अंकगणित और min/max शैली के ऑपरेशनों से मिला सकते हैं। परिणाम शून्य और नकारात्मक काउंट हटा देते हैं।

from collections import Counter

a = Counter({"Food Cart": 5, "Restaurant": 2})
b = Counter({"Food Cart": 3, "Snack Bar": 4})

print(a + b)   # add counts
print(a - b)   # subtract (keeps positives only)
print(a & b)   # intersection: min of counts
print(a | b)   # union: max of countsसंचालित द्वारा

Counter({'Food Cart': 8, 'Snack Bar': 4, 'Restaurant': 2})
Counter({'Food Cart': 2, 'Restaurant': 2})
Counter({'Food Cart': 3})
Counter({'Food Cart': 5, 'Snack Bar': 4, 'Restaurant': 2})संचालित द्वारा

list.count(), Counter, या pandas कब उपयोग करें

अपनी आवश्यकताओं और प्रदर्शन सीमाओं के अनुरूप सबसे सरल टूल चुनें।

एकल मान की जाँच count() से

जब आपको केवल यह जानना हो कि किसी अनुक्रम में कोई एक मान कितनी बार आता है, या किसी स्ट्रिंग में गैर-ओवरलैपिंग सबस्ट्रिंग काउंट चाहिए, तो बिल्ट-इन count() का उपयोग करें।

numbers = [1, 2, 2, 3, 2]
print(numbers.count(2))  # 3

word = "banana"
print(word.count("a"))   # 3

text = "aaa"
print(text.count("aa"))  # 1: non-overlapping matches only
print("cat".count(""))   # 4: empty string counts len(s)+1 positionsसंचालित द्वारा

बूलियन और इंटीजर्स के साथ सावधान रहें: True == 1 और False == 0। यदि आप प्रकार मिलाते हैं, तो काउंट बढ़ सकते हैं।

mixed = [1, True, 0, False, True]
print(mixed.count(1))  # 3 (counts 1 and True)
print(mixed.count(0))  # 2 (counts 0 and False)संचालित द्वारा

बड़े डेटा पर लूप्स के अंदर count() को बार-बार कॉल करने से बचें; हर कॉल पूरा अनुक्रम स्कैन करता है।

# Inefficient: O(n^2) for large lists
# freq = {x: numbers.count(x) for x in numbers}

# Efficient: one pass
from collections import Counter
freq = Counter(numbers)संचालित द्वारा

कई मानों की फ़्रीक्वेंसी के लिए Counter

जब आपको कई अद्वितीय मानों के काउंट चाहिए, तो एक बार Counter बनाएँ और आवश्यकता अनुसार क्वेरी करें। यह स्पष्ट, तेज़, और इसी उपयोग के लिए बना है।

pandas के साथ सारणीबद्ध डेटा

pandas में, DataFrame.count() और Series.count() non-missing काउंट निकालते हैं। मानों की फ़्रीक्वेंसी टेबल के लिए Series.value_counts() का उपयोग करें।

import pandas as pd
df = pd.DataFrame({
    "line": ["A", "A", "B", None, "B", "B"],
    "ridership": [100, None, 120, 130, None, 150],
})

print(df["line"].count())         # 5 (non-missing)
print(df["line"].value_counts())  # value frequencies

# For full row count, use len(df), not df.count()
print(len(df))                    # 6संचालित द्वारा

Counter से डेटा वैलिडेट और क्लीन करें

विश्लेषण से पहले, मैं श्रेणीगत स्थिरता, अप्रत्याशित मान, और डुप्लिकेट जाँचता हूँ। Counter ये जाँचें तेज़ और दोहराने योग्य बना देता है।

from collections import Counter

# Example: validate allowed categories
allowed_types = {"Mobile Food Truck", "Food Cart", "Snack Bar", "Restaurant"}
type_counts = Counter(nyc_eatery_types)

unexpected = {t: c for t, c in type_counts.items() if t not in allowed_types}
if unexpected:
    print("Unexpected categories found:", unexpected)

# Example: flag duplicates (e.g., station IDs appearing more than once)
station_ids = ["ST-001", "ST-002", "ST-003", "ST-002", "ST-004", "ST-002"]
dup_counts = Counter(station_ids)
duplicates = [sid for sid, c in dup_counts.items() if c > 1]
print("Duplicate station IDs:", duplicates)संचालित द्वारा

व्यावहारिक नोट्स और आम गलतियाँ

ये बिंदु समय बचाते हैं और सूक्ष्म बग्स से बचाते हैं।

• Counter डिक्शनरी जैसा है: गुम कुंजियाँ 0 लौटाती हैं; एंट्री हटाने के लिए del counter[key] उपयोग करें। जब तक अस्थायी ज़रूरत न हो, शून्य संग्रहीत करने से बचें।

• iteration क्रम पर निर्भर न रहें। रैंक्ड आउटपुट के लिए most_common() का उपयोग करें।

• str.count() गैर-ओवरलैपिंग मैच गिनता है। ओवरलैपिंग सबस्ट्रिंग काउंट के लिए re.finditer() का उपयोग करें।

• एक ही बड़े अनुक्रम पर बार-बार list.count() कॉल करने से बचें। इसके बजाय एक Counter बनाएँ।

• pandas में, .count() non-missing काउंट के लिए है; मानों की फ़्रीक्वेंसी के लिए .value_counts() उपयोग करें।

वे न्यूनतम पैटर्न जिन पर मैं भरोसा करता हूँ

ये वे स्निपेट्स हैं जिन्हें मैं प्रोडक्शन और शिक्षण में सबसे अधिक उपयोग करता हूँ।

• एक-पास फ़्रीक्वेंसी मैप: Counter(iterable)

• टॉप-N श्रेणियाँ: Counter(data).most_common(n)

• इन्क्रीमेंटल अपडेट्स: counter.update(batch) या counter.subtract(batch)

• एकल मान की जाँच: sequence.count(x) (लूप्स में न करें)

• सारणीबद्ध फ़्रीक्वेंसी: df["col"].value_counts() (df.count() नहीं)

निष्कर्ष

collections.Counter कई मानों की गिनती तेज़ी और स्पष्टता से करने का सही टूल है। एकमुश्त जाँचों के लिए बिल्ट-इन count(), फ़्रीक्वेंसी मैप्स और टॉप-N विश्लेषण के लिए Counter, और pandas में काम करते समय Series.value_counts() का उपयोग करें। स्ट्रिंग-काउंटिंग के किनारे के मामलों, बूलियन–इंटीज़र समकक्षता, और non-missing काउंट तथा मानों की फ़्रीक्वेंसी के अंतर पर ध्यान रखें। इन पैटर्न्स के साथ, आपकी गिनतियाँ तेज़ भी होंगी और सही भी।