Python 학습 노트 - 데이터 분석 - pandas 07 - 데이터 그룹 및 관련 조작
그룹 그룹
2. 기본 조작 (1)
3. 기본 조작 (2)
4. 기본 조작 (3)
그룹 그룹
groupby 매개 변 수 는 다음 과 같 습 니 다.
by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs
기본 조작 방법: getgroup (), groups (), size (), 데이터 형식 으로 그룹 을 나 누고 사전 으로 그룹 을 나 누 며 Series 로 그룹 을 나 누고 다 함수 로 agg () 를 계산 합 니 다.
2. 기본 조작 (1)
# dataframe
# axis = 0，
# （[]）
df = pd.DataFrame({'A' : ['python', 'java', 'python', 'java','python', 'C++', 'java', 'python'],
'B' : ['P', 'P', 'J', 'C', 'J', 'J', 'P', 'C'],
'C' : np.random.randn(8),
'D' : np.random.randn(8)})
print(df)
print('----------------------------------------------------------------')
# ： .groupby() ， groupby ， ， ，
# .groupby() ， 。
# A
print(' ， ：
',df.groupby('A'))
print('----------------------------------------------------------------')
# A ，
print(' sum()， ：
',df.groupby('A').sum())
print('----------------------------------------------------------------')
# A ，
print(' mean()， ：
',df.groupby('A').mean())
print('----------------------------------------------------------------')
# A B 。
a = df.groupby(['A','B']).sum()
print(a)
print('----------------------------------------------------------------')
# A ， D , D。
b = df.groupby(['A'])['D'].mean()
print(b)
print('----------------------------------------------------------------')
실행 결 과 는 다음 과 같 습 니 다.
A B C D
0 python P 1.464222 0.311215
1 java P 0.094774 -0.550092
2 python J -1.675885 1.092220
3 java C -0.826553 0.193789
4 python J -1.015872 -0.483023
5 C++ J 1.779017 -0.875131
6 java P -0.897008 0.781554
7 python C -1.198245 -0.479048
----------------------------------------------------------------
， ：
<pandas.core.groupby.DataFrameGroupBy object at 0x000001DDAFE312B0>
----------------------------------------------------------------
sum()， ：
C D
A
C++ 1.779017 -0.875131
java -1.628787 0.425250
python -2.425780 0.441363
----------------------------------------------------------------
mean()， ：
C D
A
C++ 1.779017 -0.875131
java -0.542929 0.141750
python -0.606445 0.110341
----------------------------------------------------------------
C D
A B
C++ J 1.779017 -0.875131
java C -0.826553 0.193789
P -0.802234 0.231462
python C -1.198245 -0.479048
J -2.691757 0.609197
P 1.464222 0.311215
----------------------------------------------------------------
A
C++ -0.875131
java 0.141750
python 0.110341
Name: D, dtype: float64
----------------------------------------------------------------
3. 기본 조작 (2) getgroup() 、groups() 、size()
df = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [1, 2, 3, 4]})
print(df)
print('----------------------------------------------------------------')
print(df.groupby('X'))
print('----------------------------------------------------------------')
print(type(df.groupby('X')))
print('----------------------------------------------------------------')
# list() list，list 。
a = list(df.groupby('X'))
# ， ， ， dataframe。
print(a)
print('----------------------------------------------------------------')
# 。 A B ， [0] A
print(a[0])
print('----------------------------------------------------------------')
# B
print(a[1])
print('----------------------------------------------------------------')
# for 。
# n ，g 。
for n,g in a:
print(n)
print(g)
print(type(g))
print('#####################')
print('----------------------------------------------------------------')
# get_group()
print(' A：
',df.groupby(['X']).get_group('A'))
print('----------------------------------------------------------------')
print(' A：
',df.groupby(['X']).get_group('B'))
print('----------------------------------------------------------------')
# .groups （dict）， groups
# groups index。
dg = df.groupby(['X'])
print(dg.groups)
print('----------------------------------------------------------------')
print(dg.groups['A'])
#
#print(df.groupby('X').groups['A'])
print('----------------------------------------------------------------')
# .size()
sz = dg.size()
print(sz)
print('----------------------------------------------------------------')
print(type(sz))
print('----------------------------------------------------------------')
#
df = pd.DataFrame({'A' : ['python', 'java', 'python', 'java','python', 'C++', 'java', 'python'],
'B' : ['P', 'P', 'J', 'C', 'J', 'J', 'P', 'C'],
'C' : np.random.randn(8),
'D' : np.random.randn(8)})
dg1 = df.groupby(['A','B']).groups
print(df)
print('----------------------------------------------------------------')
# ， ， 。 。
print(dg1)
print('----------------------------------------------------------------')
print(dg1[('python', 'J')])
print('----------------------------------------------------------------')
실행 결 과 는 다음 과 같 습 니 다.
X Y
0 A 1
1 B 2
2 A 3
3 B 4
----------------------------------------------------------------
<pandas.core.groupby.DataFrameGroupBy object at 0x000001DDB4CF2C18>
----------------------------------------------------------------
<class 'pandas.core.groupby.DataFrameGroupBy'>
----------------------------------------------------------------
[('A', X Y
0 A 1
2 A 3), ('B', X Y
1 B 2
3 B 4)]
----------------------------------------------------------------
('A', X Y
0 A 1
2 A 3)
----------------------------------------------------------------
('B', X Y
1 B 2
3 B 4)
----------------------------------------------------------------
A
X Y
0 A 1
2 A 3
<class 'pandas.core.frame.DataFrame'>
#####################
B
X Y
1 B 2
3 B 4
<class 'pandas.core.frame.DataFrame'>
#####################
----------------------------------------------------------------
A：
X Y
0 A 1
2 A 3
----------------------------------------------------------------
A：
X Y
1 B 2
3 B 4
----------------------------------------------------------------
{'A': Int64Index([0, 2], dtype='int64'), 'B': Int64Index([1, 3], dtype='int64')}
----------------------------------------------------------------
Int64Index([0, 2], dtype='int64')
----------------------------------------------------------------
X
A 2
B 2
dtype: int64
----------------------------------------------------------------
<class 'pandas.core.series.Series'>
----------------------------------------------------------------
A B C D
0 python P -0.325400 1.196631
1 java P -1.033418 -0.735083
2 python J 0.464612 -0.611501
3 java C -0.925026 -0.041456
4 python J -1.275745 0.972651
5 C++ J -0.509822 0.858560
6 java P -0.340469 0.865028
7 python C -0.261158 -0.883880
----------------------------------------------------------------
{('C++', 'J'): Int64Index([5], dtype='int64'), ('java', 'C'): Int64Index([3], dtype='int64'), ('java', 'P'): Int64Index([1, 6], dtype='int64'), ('python', 'C'): Int64Index([7], dtype='int64'), ('python', 'J'): Int64Index([2, 4], dtype='int64'), ('python', 'P'): Int64Index([0], dtype='int64')}
----------------------------------------------------------------
Int64Index([2, 4], dtype='int64')
----------------------------------------------------------------
4. 기본 조작 (3)
1. 값 유형 에 따라 열 을 나눈다.
#
df = pd.DataFrame({'data1':np.random.rand(3),
'data2':np.random.rand(3),
'key1':['a','b','c'],
'key2':['one','two','three']})
print(df)
print('----------------------------------------------------------------')
# dtypes
print(df.dtypes)
print('----------------------------------------------------------------')
# groupby， df.dtypes， 。 axis 1。
# groupby axis=0 （ ） ， axis=1 （ ） 。
for n,p in df.groupby(df.dtypes, axis=1):
print(n)
print(p)
print('################')
print('----------------------------------------------------------------')
실행 결 과 는 다음 과 같 습 니 다.
data1 data2 key1 key2
0 0.764642 0.777184 a one
1 0.587359 0.988120 b two
2 0.523824 0.426143 c three
----------------------------------------------------------------
data1 float64
data2 float64
key1 object
key2 object
dtype: object
----------------------------------------------------------------
float64
data1 data2
0 0.764642 0.777184
1 0.587359 0.988120
2 0.523824 0.426143
################
object
key1 key2
0 a one
1 b two
2 c three
################
----------------------------------------------------------------
2. 사전 과 Series 를 통 해 그룹 을 나눈다.
# Series
# Series ， 。
df = pd.DataFrame(np.arange(20).reshape(4,5),
columns = ['a','b','c','d','e'])
print(df)
print('----------------------------------------------------------------')
# ， a、b one，c、d two，e three
dict1 = {'a':'one','b':'one','c':'two','d':'two','e':'three'}
print(dict1)
print('----------------------------------------------------------------')
print(type(dict1))
print('----------------------------------------------------------------')
# df
by_column = df.groupby(dict1, axis = 1)
# a b one ， a b 。c d 。e ， 。
print(by_column.sum())
print('----------------------------------------------------------------')
# Series
# # s ，index a、b one，c、d two，e three。
s = pd.Series(dict1)
print(s,'
')
print('----------------------------------------------------------------')
print(s.groupby(s).count())
print('----------------------------------------------------------------')
# groups ， 。
print(s.groupby(s).groups)
print('----------------------------------------------------------------')
실행 결 과 는 다음 과 같 습 니 다.
a b c d e
0 0 1 2 3 4
1 5 6 7 8 9
2 10 11 12 13 14
3 15 16 17 18 19
----------------------------------------------------------------
{'a': 'one', 'b': 'one', 'c': 'two', 'd': 'two', 'e': 'three'}
----------------------------------------------------------------
<class 'dict'>
----------------------------------------------------------------
one three two
0 1 4 5
1 11 9 15
2 21 14 25
3 31 19 35
----------------------------------------------------------------
a one
b one
c two
d two
e three
dtype: object
----------------------------------------------------------------
one 2
three 1
two 2
dtype: int64
----------------------------------------------------------------
{'one': Index(['a', 'b'], dtype='object'), 'three': Index(['e'], dtype='object'), 'two': Index(['c', 'd'], dtype='object')}
----------------------------------------------------------------
3. 함수 로 그룹 구성
#
df = pd.DataFrame(np.arange(16).reshape(4,4),
columns = ['a','b','c','d'],
index = ['abc','bcd','aa','b'])
print(df,'
')
# ，
print(df.groupby(len).sum())
실행 결 과 는 다음 과 같 습 니 다.
a b c d
abc 0 1 2 3
bcd 4 5 6 7
aa 8 9 10 11
b 12 13 14 15
a b c d
1 12 13 14 15
2 8 9 10 11
3 4 6 8 10
4. 조별 계산 함수 방법
#
s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
grouped = s.groupby(level=0) # .groupby(level=0)， index
print(grouped)
print('first： NaN :
',grouped.first())
print('last： NaN :
',grouped.last())
print('sum： NaN :
',grouped.sum())
print('mean： NaN :
',grouped.mean())
print('median： NaN :
',grouped.median())
print('count： NaN :
',grouped.count())
print('min、max： NaN 、 :
',grouped.min())
print('std，var： NaN :
',grouped.std())
print('prod： NaN :
',grouped.prod())
실행 결 과 는 다음 과 같 습 니 다.
<pandas.core.groupby.SeriesGroupBy object at 0x000001DDB4CF2710>
----------------------------------------------------------------
first： NaN :
1 1
2 2
3 3
dtype: int64
----------------------------------------------------------------
last： NaN :
1 10
2 20
3 30
dtype: int64
----------------------------------------------------------------
sum： NaN :
1 11
2 22
3 33
dtype: int64
----------------------------------------------------------------
mean： NaN :
1 5.5
2 11.0
3 16.5
dtype: float64
----------------------------------------------------------------
median： NaN :
1 5.5
2 11.0
3 16.5
dtype: float64
----------------------------------------------------------------
count： NaN :
1 2
2 2
3 2
dtype: int64
----------------------------------------------------------------
min、max： NaN 、 :
1 1
2 2
3 3
dtype: int64
----------------------------------------------------------------
std，var： NaN :
1 6.363961
2 12.727922
3 19.091883
dtype: float64
----------------------------------------------------------------
prod： NaN :
1 10
2 40
3 90
dtype: int64
----------------------------------------------------------------
5. 다 함수 계산 agg ()
# agg()
# agg str， np.
# agg list，dict ， dict ，key columns
df = pd.DataFrame({'a':[1,1,2,2],
'b':np.random.rand(4),
'c':np.random.rand(4),
'd':np.random.rand(4),})
print(df)
print('----------------------------------------------------------------')
# a ， agg
# a 1 2， b c d 。
print(df.groupby('a').agg(['mean',np.sum]))
print('----------------------------------------------------------------')
# a ， b 。
print(df.groupby('a')['b'].agg({'result1':np.mean,
'result2':np.sum}))
print('----------------------------------------------------------------')
실행 결 과 는 다음 과 같 습 니 다.
a b c d
0 1 0.008648 0.434679 0.642889
1 1 0.408283 0.240458 0.539475
2 2 0.392103 0.533814 0.406897
3 2 0.217749 0.631762 0.025736
----------------------------------------------------------------
b c d
mean sum mean sum mean sum
a
1 0.208465 0.416931 0.337569 0.675137 0.591182 1.182363
2 0.304926 0.609853 0.582788 1.165576 0.216316 0.432633
----------------------------------------------------------------
result1 result2
a
1 0.208465 0.416931
2 0.304926 0.609853
----------------------------------------------------------------
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
다양한 언어의 JSONJSON은 Javascript 표기법을 사용하여 데이터 구조를 레이아웃하는 데이터 형식입니다. 그러나 Javascript가 코드에서 이러한 구조를 나타낼 수 있는 유일한 언어는 아닙니다. 저는 일반적으로 '객체'{}...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
