Python: नेस्टेड सूची में पंक्ति-वार संचयी आवृत्ति गिनना

Python में नेस्टेड सूची (मैट्रिक्स) की प्रत्येक पंक्ति में, विशिष्ट तत्वों की आवृत्ति (frequency) गिनना और उनका योग निकालना। collections.Counter का उपयोग किया जाता है।

समस्या

मैट्रिक्स: [[11, 2, 32, 4, 31], [52, 52, 3, 71, 71, 3], [1, 3], [19, 19, 40, 40, 40]]

लक्ष्य तत्व: [19, 2, 71]

प्रत्येक पंक्ति में इन लक्ष्य तत्वों की कुल गिनती निकालें।

उदाहरण

from collections import Counter

my_list = [
    [11, 2, 32, 4, 31],
    [52, 52, 3, 71, 71, 3],
    [1, 3],
    [19, 19, 40, 40, 40]
]

my_element_list = [19, 2, 71]
print("मैट्रिक्स:", my_list)
print("लक्ष्य तत्व:", my_element_list)

# प्रत्येक पंक्ति के लिए Counter बनाएं
row_counters = [Counter(row) for row in my_list]
print("\nपंक्ति-वार Counter:")
for i, cnt in enumerate(row_counters):
    print(f"  पंक्ति {i}: {dict(cnt)}")

# प्रत्येक पंक्ति में लक्ष्य तत्वों की गिनती का योग
my_result = [
    sum(cnt[elem] for elem in my_element_list if elem in cnt)
    for cnt in row_counters
]

print("\nप्रति पंक्ति संचयी आवृत्ति:", my_result)

आउटपुट

मैट्रिक्स: [[11, 2, 32, 4, 31], [52, 52, 3, 71, 71, 3], [1, 3], [19, 19, 40, 40, 40]]
लक्ष्य तत्व: [19, 2, 71]

पंक्ति-वार Counter:
  पंक्ति 0: {11: 1, 2: 1, 32: 1, 4: 1, 31: 1}
  पंक्ति 1: {52: 2, 3: 2, 71: 2}
  पंक्ति 2: {1: 1, 3: 1}
  पंक्ति 3: {19: 2, 40: 3}

प्रति पंक्ति संचयी आवृत्ति: [1, 2, 0, 2]

व्याख्या

संक्षिप्त संस्करण

# एक लाइनर (कम पठनीय)
result = [sum(Counter(row)[e] for e in my_element_list) for row in my_list]
print(result)  # [1, 2, 0, 2]

# Counter.get() का उपयोग (KeyError से बचने के लिए)
result2 = [sum(Counter(row).get(e, 0) for e in my_element_list) for row in my_list]
print(result2)  # [1, 2, 0, 2]

फंक्शन के रूप में

def cumulative_row_frequencies(matrix, target_elements):
    """प्रत्येक पंक्ति में लक्ष्य तत्वों की संचयी आवृत्ति"""
    target_set = set(target_elements)
    return [
        sum(count for elem, count in Counter(row).items() if elem in target_set)
        for row in matrix
    ]

# या Counter.get के साथ
def cumulative_row_frequencies_v2(matrix, target_elements):
    return [
        sum(Counter(row).get(elem, 0) for elem in target_elements)
        for row in matrix
    ]

print(cumulative_row_frequencies(my_list, my_element_list))
print(cumulative_row_frequencies_v2(my_list, my_element_list))

Pandas DataFrame में उपयोग

import pandas as pd

df = pd.DataFrame({
    'A': [11, 52, 1, 19],
    'B': [2, 52, 3, 19],
    'C': [32, 3, None, 40],
    'D': [4, 71, None, 40],
    'E': [31, 71, None, 40],
    'F': [None, 3, None, None]
})
print("DataFrame:\n", df)

targets = [19, 2, 71]

# प्रत्येक पंक्ति के लिए गिनती
def count_targets(row):
    return sum((row == t).sum() for t in targets)

df['target_count'] = df.apply(count_targets, axis=1)
print("\nलक्ष्य गिनती के साथ:\n", df)

आउटपुट

DataFrame:
     A   B     C     D     E    F
0   11   2  32.0   4.0  31.0  NaN
1   52  52   3.0  71.0  71.0  3.0
2    1   3   NaN   NaN   NaN  NaN
3   19  19  40.0  40.0  40.0  NaN

लक्ष्य गिनती के साथ:
     A   B     C     D     E    F  target_count
0   11   2  32.0   4.0  31.0  NaN             1
1   52  52   3.0  71.0  71.0  3.0             2
2    1   3   NaN   NaN   NaN  NaN             0
3   19  19  40.0  40.0  40.0  NaN             2

उन्नत: प्रति तत्व ब्रेकडाउन

def detailed_frequency_breakdown(matrix, targets):
    """प्रति पंक्ति, प्रति लक्ष्य तत्व गिनती"""
    from collections import Counter
    result = []
    for row in matrix:
        cnt = Counter(row)
        breakdown = {t: cnt.get(t, 0) for t in targets}
        breakdown['total'] = sum(breakdown.values())
        result.append(breakdown)
    return result

breakdown = detailed_frequency_breakdown(my_list, my_element_list)
for i, bd in enumerate(breakdown):
    print(f"पंक्ति {i}: {bd}")

आउटपुट

पंक्ति 0: {'19': 0, '2': 1, '71': 0, 'total': 1}
पंक्ति 1: {'19': 0, '2': 0, '71': 2, 'total': 2}
पंक्ति 2: {'19': 0, '2': 0, '71': 0, 'total': 0}
पंक्ति 3: {'19': 2, '2': 0, '71': 0, 'total': 2}