मान लें कि मेरे पास इस तरह की एक सूची है:

[[0.5, 5281],
 [0.7, 6597],
 [0.7, 6716],
 [0.7, 6902],
 [0.7, 5704]]

मैं उन तत्वों को जोड़ना चाहता हूं जिनमें पहला तत्व समान है और कुछ ऐसा प्राप्त करें:

[[0.5, 5281],
 [0.7, the result of 6597+6716+..+5704]].

क्या पाइथन में ऐसा करने का कोई आसान तरीका है?

2
SidiAli 30 पद 2021, 14:42

8 जवाब

pandas का उपयोग करने के बारे में क्या? (मुझे लगता है कि आप अपने डेटाबेस को pandas वैसे भी पढ़ते हैं)

import pandas as pd

original_list = [
    [0.5, 5281],
    [0.7, 6597],
    [0.7, 6716],
    [0.7, 6902],
    [0.7, 5704]]

df = pd.DataFrame(original_list, columns=['col1', 'col2'])
df_out = df.groupby('col1').sum()
print(df_out)

नतीजा:

       col2
col1       
0.5    5281
0.7   25919
2
Matiiss 30 पद 2021, 14:58
1
पूरे उत्तर के लिए pd.DataFrame(original_list, columns=['c1', 'c2']).groupby('c1').sum().reset_index().values.tolist()
 – 
sophocles
30 पद 2021, 14:57
मैंने इसे पंडों का उपयोग करके किया था लेकिन मैं डेटाफ्रेम के बिना एक ही परिणाम प्राप्त करने का एक आसान तरीका ढूंढ रहा हूं।
 – 
SidiAli
30 पद 2021, 14:59
प्रारूप को सही करने के लिए धन्यवाद मैटिस! ;)
 – 
Gabriele
30 पद 2021, 14:59
सरल से आपका क्या तात्पर्य है? मैं pandas को भी नहीं जानता, लेकिन मैं इस समाधान को अत्यंत सरल मानूंगा
 – 
Matiiss
30 पद 2021, 15:00

यह मुझे काफी सरल लगता है। आप एक खाली dict बना सकते हैं और उसकी कुंजियों और मानों को जोड़ सकते हैं। यदि उप-सूची का पहला भाग पहले से ही key के रूप में मौजूद है, तो उप-सूची के दूसरे भाग को इसके value में जोड़ें:

l = [[0.5, 5281], [0.7, 6597], [0.7, 6716], [0.7, 6902], [0.7, 5704]]
d = {}

for item in l:
   if item[0] in d.keys():
      d[item[0]] += item[1]
   else:
      d[item[0]] = item[1]

नतीजा:

>>> print(d)
{0.5: 5281, 0.7: 25919}

>>> print(list(map(list, d.items())))
[[0.5, 5281], [0.7, 25919]]
2
sophocles 30 पद 2021, 16:04

एक अन्य समाधान जो pandas का उपयोग नहीं करता है (लेकिन मैं यह नहीं कहूंगा कि यह सरल है, शायद, इसके विपरीत भी)। आप वस्तुओं को समूहबद्ध करने के लिए groupby से itertools का उपयोग कर सकते हैं (लेकिन पहले आपको सूची को क्रमबद्ध करने की आवश्यकता है (जब तक कि आप इसे पहले से ही सॉर्ट नहीं कर लेते हैं (जिस स्थिति में सॉर्टिंग वैसे भी कई संसाधनों का उपभोग नहीं करेगी)) क्योंकि अन्यथा यह सभी समान वस्तुओं को एक साथ समूहित नहीं कर सकता है, केवल वे जो एक दूसरे का अनुसरण करते हैं)। फिर समूह और योग को सूची में जोड़ें:

import itertools
import operator


original_list = [
    [0.5, 5281],
    [0.7, 6597],
    [0.7, 6716],
    [0.7, 6902],
    [0.7, 5704]]


key = operator.itemgetter(0)
out_list = []
sorted_list = sorted(original_list, key=key)
for group, items in itertools.groupby(sorted_list, key=key):
    out_list.append([group, sum(x[1] for x in items)])

print(out_list)
1
Matiiss 30 पद 2021, 15:20
docs.python.org/3/library/operator.html#operator. आइटमगेटर एक ऐसे फ़ंक्शन के उपयोग के लिए आदर्श है जो केवल x[0] लौटाता है। तो कुंजी बस itemgetter(0) बन जाती है।
 – 
gold_cy
30 पद 2021, 15:09
धन्यवाद, अद्यतन उत्तर, मुझे अभी तक operator मॉड्यूल का उपयोग करने की आदत नहीं है/इसके प्रदान किए गए कार्यों के बारे में सीखना है
 – 
Matiiss
30 पद 2021, 15:14

सरल और बिना किसी मॉड्यूल के, इसे इस तरह करें-

ll = [[0.5, 5281],
      [0.7, 6597],
      [0.7, 6716],
      [0.7, 6902],
      [0.7, 5704]]

res = {}
for l in ll:
    if l[0] in res.keys():
        res[l[0]] += [l[1]]
    else:
        res[l[0]] = [l[1]]

for k, v in res.items():
    res[k] = sum(v)

print(res)
1
Gautam Jangid 30 पद 2021, 15:44

बिल्ट-इन itertools आज़माएं:

import itertools
import operator

DATA = [[0.5, 5281],
        [0.7, 6597],
        [0.7, 6716],
        [0.7, 6902],
        [0.7, 5704]]

if __name__ == "__main__":
    result = [
        [key, sum(value for _, value in original_pairs)]
        for key, original_pairs in itertools.groupby(DATA, operator.itemgetter(0))
    ]
    print(result)
0
reartnew 30 पद 2021, 15:06

निम्नानुसार numpy का उपयोग करना,

import numpy as np

def func_(input_):
    input_array = np.array(input_)
    result = []

    for unique_elem in np.unique(input_array[:,0]):
        indices = np.where(input_array[:,0] == unique_elem)
        result.append([unique_elem, np.sum(input_array[:,1][indices])])

    return result

original_list = [[0.5, 5281],
    [0.7, 6597],
    [0.7, 6716],
    [0.7, 6902],
    [0.7, 5704]]

print(func_(input_))

आउटपुट:

[[0.5, 5281.0], [0.7, 25919.0]]

इसमें अभी भी सुधार किया जा सकता है

0
Mohandass 30 पद 2021, 15:08

चूंकि यह क्लासिक "वर्डकाउंट" समस्या के समान है, आप इसे मैपरेडस शैली में functools.reduce:

from operator import itemgetter
from functools import reduce

myList=[[0.5, 5281],
 [0.7, 6597],
 [0.7, 6716],
 [0.7, 6902],
 [0.7, 5704]]

# sort data by first coordinate (key)
# in Hadoop this is done by the mapper 
sorted(myList, key=itemgetter(0))
# Out: [[0.5, 5281], [0.7, 6597], [0.7, 6716], [0.7, 6902], [0.7, 5704]]

# reducer function that adds up items with the same key 
# this works because input list is sorted by key
def myReducer(a,b):
    if a!=[] and b[0] == a[-1][0]:
        c = a.pop()
        return a + [[c[0],c[1]+b[1]]]
    else:
        return a + [b]

# putting it all together
reduce(myReducer, sorted(myList, key=itemgetter(0)), [])
# Out: [[0.5, 5281], [0.7, 25919]]

यह दृष्टिकोण समांतरता के लिए भी उपयुक्त है।

0
user2314737 30 पद 2021, 15:16

हाँ यकीन है कि यह करने योग्य है! यदि आप इसे बिना किसी आयातित पुस्तकालय के खरोंच से करना चाहते हैं:

A = [
    [0.5, 5281],
    [0.7, 6597],
    [0.7, 6716],
    [0.7, 6902],
    [0.7, 5704]
    ]


table_of_first_entries = []
result = []

for input_pair in A:
    if input_pair[0] not in table_of_first_entries:
        table_of_first_entries.append(input_pair[0])

for first_entry in table_of_first_entries:
    sum = 0
    for input_pair in A:
        if input_pair[0] == first_entry:
            sum = sum + input_pair[1]
    
    result.append([first_entry,sum])


print(result)

और आपको जो आउटपुट मिलेगा वह होगा

[[0.5, 5281], [0.7, 25919]]
0
Noahela 30 पद 2021, 15:28