pandas
डेटा समूहीकरण

बुनियादी समूहन

एक कॉलम द्वारा समूह

निम्नलिखित DataFrame का उपयोग करना

df = pd.DataFrame({'A': ['a', 'b', 'c', 'a', 'b', 'b'], 
                   'B': [2, 8, 1, 4, 3, 8], 
                   'C': [102, 98, 107, 104, 115, 87]})

df
# Output: 
#    A  B    C
# 0  a  2  102
# 1  b  8   98
# 2  c  1  107
# 3  a  4  104
# 4  b  3  115
# 5  b  8   87

स्तंभ A द्वारा समूह और अन्य स्तंभों का माध्य मान प्राप्त करें:

df.groupby('A').mean()
# Output: 
#           B    C
# A               
# a  3.000000  103
# b  6.333333  100
# c  1.000000  107

कई स्तंभों द्वारा समूह

df.groupby(['A','B']).mean()
# Output: 
#          C
# A B       
# a 2  102.0
#   4  104.0
# b 3  115.0
#   8   92.5
# c 1  107.0

ध्यान दें कि परिणामी DataFrame में प्रत्येक पंक्ति को समूहीकृत करने के बाद एक tuple या MultiIndex (इस मामले में स्तंभ A और B से तत्वों की एक जोड़ी) द्वारा अनुक्रमित किया जाता है।

उदाहरण के लिए एक बार में कई एकत्रीकरण विधियों को लागू करने के लिए, प्रत्येक समूह में वस्तुओं की संख्या की गणना करने और उनके माध्य की गणना करने के लिए, agg फ़ंक्शन का उपयोग करें:

df.groupby(['A','B']).agg(['count', 'mean'])
# Output:
#         C       
#     count   mean
# A B             
# a 2     1  102.0
#   4     1  104.0
# b 3     1  115.0
#   8     2   92.5
# c 1     1  107.0

समूह संख्या

निम्नलिखित डेटा के लिए:

import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'Age': np.random.randint(20, 70, 100), 
                   'Sex': np.random.choice(['Male', 'Female'], 100), 
                   'number_of_foo': np.random.randint(1, 20, 100)})
df.head()
# Output: 

#    Age     Sex  number_of_foo
# 0   64  Female             14
# 1   67  Female             14
# 2   20  Female             12
# 3   23    Male             17
# 4   23  Female             15

समूह Age तीन श्रेणियों (या डिब्बे) में। के रूप में डिब्बे दिए जा सकते हैं

• एक पूर्णांक n जिस पर डिब्बे की संख्या का संकेत है - इस स्थिति में डेटाफ्रेम का डेटा बराबर आकार के n अंतराल में विभाजित है
• पूर्णांक के एक अनुक्रम में बाएं-खुले अंतराल के समापन बिंदु को दर्शाते हुए जिसमें डेटा को विभाजित किया जाता है - उदाहरण के लिए bins=[19, 40, 65, np.inf] तीन आयु समूह (19, 40] , (40, 65] bins=[19, 40, 65, np.inf] बनाता है (40, 65] , और (65, np.inf] ।

पांडास अंतराल के स्ट्रिंग संस्करणों को लेबल के रूप में स्वचालित रूप से असाइन करता है। स्ट्रिंग्स की सूची के रूप में एक labels पैरामीटर को परिभाषित करके स्वयं के लेबल को परिभाषित करना भी संभव है।

pd.cut(df['Age'], bins=4)
# this creates four age groups: (19.951, 32.25] < (32.25, 44.5] < (44.5, 56.75] < (56.75, 69]
Name: Age, dtype: category
Categories (4, object): [(19.951, 32.25] < (32.25, 44.5] < (44.5, 56.75] < (56.75, 69]]

pd.cut(df['Age'], bins=[19, 40, 65, np.inf])
# this creates three age groups: (19, 40], (40, 65] and (65, infinity)
Name: Age, dtype: category
Categories (3, object): [(19, 40] < (40, 65] < (65, inf]]

फू की औसत संख्या प्राप्त करने के लिए इसका उपयोग groupby में करें:

age_groups = pd.cut(df['Age'], bins=[19, 40, 65, np.inf])
df.groupby(age_groups)['number_of_foo'].mean()
# Output: 
# Age
# (19, 40]     9.880000
# (40, 65]     9.452381
# (65, inf]    9.250000
# Name: number_of_foo, dtype: float64

क्रॉस टैबिल आयु समूह और लिंग:

pd.crosstab(age_groups, df['Sex'])
# Output: 
# Sex        Female  Male
# Age
# (19, 40]       22    28
# (40, 65]       18    24
# (65, inf]       3     5

एक समूह का कॉलम चयन

जब आप एक समूह बनाते हैं तो आप एकल कॉलम या स्तंभों की सूची का चयन कर सकते हैं:

In [11]: df = pd.DataFrame([[1, 1, 2], [1, 2, 3], [2, 3, 4]], columns=["A", "B", "C"])

In [12]: df
Out[12]:
   A  B  C
0  1  1  2
1  1  2  3
2  2  3  4

In [13]: g = df.groupby("A")

In [14]: g["B"].mean()           # just column B
Out[14]:
A
1    1.5
2    3.0
Name: B, dtype: float64

In [15]: g[["B", "C"]].mean()    # columns B and C
Out[15]:
     B    C
A
1  1.5  2.5
2  3.0  4.0

आप कॉलम और एकत्रीकरण को निर्दिष्ट करने के लिए agg का उपयोग कर सकते हैं:

In [16]: g.agg({'B': 'mean', 'C': 'count'})
Out[16]:
   C    B
A        
1  2  1.5
2  1  3.0

गिनती द्वारा आकार बनाम के आधार पर

size और count बीच का अंतर है:

size NaN मानों को count है, count नहीं करता है।

df = pd.DataFrame(
        {"Name":["Alice", "Bob", "Mallory", "Mallory", "Bob" , "Mallory"],
         "City":["Seattle", "Seattle", "Portland", "Seattle", "Seattle", "Portland"],
         "Val": [4, 3, 3, np.nan, np.nan, 4]})

df
# Output: 
#        City     Name  Val
# 0   Seattle    Alice  4.0
# 1   Seattle      Bob  3.0
# 2  Portland  Mallory  3.0
# 3   Seattle  Mallory  NaN
# 4   Seattle      Bob  NaN
# 5  Portland  Mallory  4.0


df.groupby(["Name", "City"])['Val'].size().reset_index(name='Size')
# Output: 
#       Name      City  Size
# 0    Alice   Seattle     1
# 1      Bob   Seattle     2
# 2  Mallory  Portland     2
# 3  Mallory   Seattle     1

df.groupby(["Name", "City"])['Val'].count().reset_index(name='Count')
# Output: 
#       Name      City  Count
# 0    Alice   Seattle      1
# 1      Bob   Seattle      1
# 2  Mallory  Portland      2
# 3  Mallory   Seattle      0

समूह बनाना

In [1]: import numpy as np   
In [2]: import pandas as pd

In [3]: df = pd.DataFrame({'A': list('XYZXYZXYZX'), 'B': [1, 2, 1, 3, 1, 2, 3, 3, 1, 2], 
                           'C': [12, 14, 11, 12, 13, 14, 16, 12, 10, 19]})

In [4]: df.groupby('A')['B'].agg({'mean': np.mean, 'standard deviation': np.std})
Out[4]: 
   standard deviation      mean
A                              
X            0.957427  2.250000
Y            1.000000  2.000000
Z            0.577350  1.333333

कई स्तंभों के लिए:

In [5]: df.groupby('A').agg({'B': [np.mean, np.std], 'C': [np.sum, 'count']})
Out[5]: 
    C               B          
  sum count      mean       std
A                              
X  59     4  2.250000  0.957427
Y  39     3  2.000000  1.000000
Z  35     3  1.333333  0.577350

विभिन्न फ़ाइलों में समूहों का निर्यात करें

आप groupby() द्वारा लौटाए गए ऑब्जेक्ट पर iterate कर सकते हैं groupby() । (Category, DataFrame) में (Category, DataFrame) ट्यूपल्स होते हैं।

# Same example data as in the previous example.
import numpy as np
import pandas as pd
np.random.seed(0)
df = pd.DataFrame({'Age': np.random.randint(20, 70, 100), 
                   'Sex': np.random.choice(['Male', factor'Female'], 100), 
                   'number_of_foo': np.random.randint(1, 20, 100)})

# Export to Male.csv and Female.csv files.
for sex, data in df.groupby('Sex'):
    data.to_csv("{}.csv".format(sex))

मूल डेटाफ़्रेम को संरक्षित करते हुए समूह-स्तरीय आँकड़े प्राप्त करने के लिए परिवर्तन का उपयोग करना

उदाहरण:

df = pd.DataFrame({'group1' :  ['A', 'A', 'A', 'A',
                               'B', 'B', 'B', 'B'],
                   'group2' :  ['C', 'C', 'C', 'D',
                               'E', 'E', 'F', 'F'],
                   'B'      :  ['one', np.NaN, np.NaN, np.NaN,
                                np.NaN, 'two', np.NaN, np.NaN],
                   'C'      :  [np.NaN, 1, np.NaN, np.NaN,
                               np.NaN, np.NaN, np.NaN, 4]})           

 df
Out[34]: 
     B    C group1 group2
0  one  NaN      A      C
1  NaN  1.0      A      C
2  NaN  NaN      A      C
3  NaN  NaN      A      D
4  NaN  NaN      B      E
5  two  NaN      B      E
6  NaN  NaN      B      F
7  NaN  4.0      B      F

मैं group1 और group1 प्रत्येक संयोजन के लिए बी के गैर-लापता टिप्पणियों की गिनती प्राप्त करना चाहता group2 । groupby.transform एक बहुत शक्तिशाली फ़ंक्शन है जो वास्तव में ऐसा करता है।

df['count_B']=df.groupby(['group1','group2']).B.transform('count')                        

df
Out[36]: 
     B    C group1 group2  count_B
0  one  NaN      A      C        1
1  NaN  1.0      A      C        1
2  NaN  NaN      A      C        1
3  NaN  NaN      A      D        0
4  NaN  NaN      B      E        1
5  two  NaN      B      E        1
6  NaN  NaN      B      F        0
7  NaN  4.0      B      F        0