Pandas

16 minute read

Pandas

Pandas는 파이썬에서 사용하는 데이터분석 라이브러리로, 행과 열로 이루어진 데이터 객체를 만들어 다룰 수 있게 되며 보다 안정적으로 대용량의 데이터들을 처리하는데 매우 편리한 도구 이다.
Pandas의 자료 구조로서는 Series, DataFrame두개가 존재한다.
pandas를 사용하기 위해서는 다음과 같이 import하여 사용한다.

1
2
import pandas as pd
from pandas import DataFrame,Series

Series

Series는 values와 index의 형태를 가지는 Pandas의 자료 구조이다.
아래와 같이 선언하고 사용할 수 있다.

1
2
3
4
5
6
7
8
#Series 클래스 사용하기
#선언
obj = Series([3,7,-5,4])
obj = Series((3,7,-5,4))
#obj = Series({3,7,-5,4}) # Type Error: "set" type is unorderd
obj = Series((3,7,-5,"kbs"))
print(obj)
print(type(obj))

0      3
1      7
2     -5
3    kbs
dtype: object
<class 'pandas.core.series.Series'>


Series의 특징으로서 index의 값을 직접 지정 가능하다는 것이다.
또한 Series는 values와 index로서 접근가능하며 sum(합), std(표준편차)와 같은 함수를 사용할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#Series의 특징이다 index의 값을 직접 지정 가능하다
obj2 = Series([3,7,-5,4], index=["a","b","d","c"])

print(obj2)
print(obj2.sum(), " ",obj2.std()) # 합계, 편차
print(obj2.values) # value만 추출가능
print(obj2.index) # index만 추출가능

print(obj2["a"])
print(obj2[["a", "d"]])
print(obj2["b":"c"]) # 범위지정 가능

print(obj2[2])
print(obj2[1:3])
print(obj2[[2,3]])

print(obj2>0)
print("a" in obj2)



a    3
b    7
d   -5
c    4
dtype: int64
9   5.123475382979799
[ 3  7 -5  4]
Index(['a', 'b', 'd', 'c'], dtype='object')
3
a    3
d   -5
dtype: int64
b    7
d   -5
c    4
dtype: int64
-5
b    7
d   -5
dtype: int64
d   -5
c    4
dtype: int64
a     True
b     True
d    False
c     True
dtype: bool
True


Series는 Pandas의 자료구조로서 객체로서 만들 수 있다.

1
2
3
4
5
6
#Series를 사용하여 객체로서 만들수 있다.
names = {'mouse':12000, 'keyboard':25000, 'mornitor':'450000'}
print(names)

obj3 = Series(names)
print(obj3) #Dict -> pandas.core.Series


{'mouse': 12000, 'keyboard': 25000, 'mornitor': '450000'}
mouse        12000
keyboard     25000
mornitor    450000
dtype: object


Series는 객체이고 객체 자체의 이름 부여가 가능하다..

1
2
3
obj3.index = ["마우스", "키보드", "모니터"] #index변경 가능
obj3.name = "시리즈데이터" #객체 자체에 이름 부여 가능
print(obj3)


마우스     12000
키보드     25000
모니터    450000
Name: 시리즈데이터, dtype: object


Series Slicing(슬라이싱)방법이다.
index 혹은 순서로서 접근 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Slicing(슬라이싱)
#Index 혹은 순서로서 접근 가능하다.
obj = Series(np.arange(4.), index = ("a","b","c","d"))
print(obj)
print(obj[1])
print(obj["b"])
print(obj[2:4])
print(obj[[1,3]])
print(obj[["c","a"]])
print(obj["a":"c"])
print(obj[obj<2])

obj["b":"c"] = 7
print(obj)


a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
1.0
1.0
c    2.0
d    3.0
dtype: float64
b    1.0
d    3.0
dtype: float64
c    2.0
a    0.0
dtype: float64
a    0.0
b    1.0
c    2.0
dtype: float64
a    0.0
b    1.0
dtype: float64
a    0.0
b    7.0
c    7.0
d    3.0
dtype: float64


Series 정렬 방법이다. ascending=True or False를 통하여 오름차순 혹은 내림차순으로서 정렬 가능하다.

1
2
3
4
5
6
7
8
9
10
11
# 정렬
obj = Series(np.arange(4.), index = ("a","b","c","d"))
print(obj)

print(obj.sort_values(0, ascending=True))
print(obj.sort_values(0, ascending=False))

print()
print(obj.sort_index())
print(obj.sort_index(ascending=False))



a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
d    3.0
c    2.0
b    1.0
a    0.0
dtype: float64

a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
d    3.0
c    2.0
b    1.0
a    0.0
dtype: float64


Series 연산 방법이다. 같은 index끼리 연산을 한다.
index가 서로 일치하지 않으면 연산하지 않고 그 칼럼의 값은 NaN으로 채운다.

1
2
3
4
5
6
#연산: 같은 Index끼리 연산한다. 
#Index가 서로 일치하지 않으면 연산하지 않고 그 칼럼의 값은 NaN으로 채운다.
s1 = Series([1,2,3], index=["a", "b", "c"])
s2 = Series([4,5,6], index=["a", "b", "d"])
print(s1+s2)
print(s1.add(s2))


a    5.0
b    7.0
c    NaN
d    NaN
dtype: float64
a    5.0
b    7.0
c    NaN
d    NaN
dtype: float64


DataFrame

DataFrame은 마치 DB와 같은 형태로 자료를 보기 편한 형태로 제공가능한 자료 구조이다.
아래와 같이 선언하고 접근 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#DataFrame 사용하기
#생성 및 접근
data = { 'irum':['홍길동', '한국인', '신기해', '공기밥', '한가해'], 
        'juso':('역삼동', '신당동', '역삼동', '역삼동', '신사동'), 
        'nai':[23, 25, 33, 30, 35], }
print(data, type(data))#Dict Type 출력

frame = DataFrame(data)
print(frame, type(frame)) #Dataframe으로 만들기

print(frame["irum"]) #Dataframe Column에 접근하는 방법
print(frame.irum)

print(DataFrame(data, columns=["juso", "irum", "nai"])) #Dataframe Column 내용 바꾸기

frame2 = DataFrame(data, columns=["irum", "nai", "juso", "junhwa"],\
                  index=["a","b","c","d","e"])
print(frame2) #값이 없으면 NaN으로서 채워진다.

frame2["junhwa"] = "111-1111" #모든값이 111-1111로 채워진다
print(frame2)

val = Series(["222-2222", "333-3333", "444-4444"]
             , index=["b","c","e"])
frame2["junhwa"] = val #index에 맞게 값이 들어가게 된다.
print(frame2)
print(frame2.values)

print()
print(frame2.T) # 전치
print(frame2.values)
print(frame2.values[0,2]) #index로 접근하여 특정 값만 추출 가능



{'irum': ['홍길동', '한국인', '신기해', '공기밥', '한가해'], 'juso': ('역삼동', '신당동', '역삼동', '역삼동', '신사동'), 'nai': [23, 25, 33, 30, 35]} <class 'dict'>
  irum juso  nai
0  홍길동  역삼동   23
1  한국인  신당동   25
2  신기해  역삼동   33
3  공기밥  역삼동   30
4  한가해  신사동   35 <class 'pandas.core.frame.DataFrame'>
0    홍길동
1    한국인
2    신기해
3    공기밥
4    한가해
Name: irum, dtype: object
0    홍길동
1    한국인
2    신기해
3    공기밥
4    한가해
Name: irum, dtype: object
  juso irum  nai
0  역삼동  홍길동   23
1  신당동  한국인   25
2  역삼동  신기해   33
3  역삼동  공기밥   30
4  신사동  한가해   35
  irum  nai juso junhwa
a  홍길동   23  역삼동    NaN
b  한국인   25  신당동    NaN
c  신기해   33  역삼동    NaN
d  공기밥   30  역삼동    NaN
e  한가해   35  신사동    NaN
  irum  nai juso    junhwa
a  홍길동   23  역삼동  111-1111
b  한국인   25  신당동  111-1111
c  신기해   33  역삼동  111-1111
d  공기밥   30  역삼동  111-1111
e  한가해   35  신사동  111-1111
  irum  nai juso    junhwa
a  홍길동   23  역삼동       NaN
b  한국인   25  신당동  222-2222
c  신기해   33  역삼동  333-3333
d  공기밥   30  역삼동       NaN
e  한가해   35  신사동  444-4444
[['홍길동' 23 '역삼동' nan]
 ['한국인' 25 '신당동' '222-2222']
 ['신기해' 33 '역삼동' '333-3333']
 ['공기밥' 30 '역삼동' nan]
 ['한가해' 35 '신사동' '444-4444']]

          a         b         c    d         e
irum    홍길동       한국인       신기해  공기밥       한가해
nai      23        25        33   30        35
juso    역삼동       신당동       역삼동  역삼동       신사동
junhwa  NaN  222-2222  333-3333  NaN  444-4444
[['홍길동' 23 '역삼동' nan]
 ['한국인' 25 '신당동' '222-2222']
 ['신기해' 33 '역삼동' '333-3333']
 ['공기밥' 30 '역삼동' nan]
 ['한가해' 35 '신사동' '444-4444']]
역삼동


DataFrame 삭제 방법이다.

1
2
3
4
5
6
7
8
#삭제
print(frame2)
frame3 = frame2.drop("d") # drop: 행 삭제 함수
frame3 = frame2.drop("d", axis=0) # 상동표현
print(frame3)

frame4 = frame3.drop("junhwa", axis=1)
print(frame4)


  irum  nai juso    junhwa
a  홍길동   23  역삼동       NaN
b  한국인   25  신당동  222-2222
c  신기해   33  역삼동  333-3333
d  공기밥   30  역삼동       NaN
e  한가해   35  신사동  444-4444
  irum  nai juso    junhwa
a  홍길동   23  역삼동       NaN
b  한국인   25  신당동  222-2222
c  신기해   33  역삼동  333-3333
e  한가해   35  신사동  444-4444
  irum  nai juso
a  홍길동   23  역삼동
b  한국인   25  신당동
c  신기해   33  역삼동
e  한가해   35  신사동


DataFrame 정렬 방법이다. Series와 마찬가지로 ascending=True or False를 통하여 오름차순 혹은 내림차순으로서 사용 가능하다.
value_counts() 는 많이 사용하는 함수로서 value의 개수를 반환한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#정렬하기
print(frame4.sort_index(axis=0, ascending=False))
print(frame4.sort_index(axis=1, ascending=True))

print(frame4.rank(axis=1))
print(frame4.rank(axis=0))

print(frame4["irum"][:2])

counts = frame4["juso"].value_counts() #juso 칼럼의 value들의 갯수를 반환
print(counts)

data = {"juso":["강남구 역삼동", "중구 신당동", "강남구 대치동"],
       "inwon":[23, 25, 15]}
frame = DataFrame(data)
print(frame)

results = Series([x.split()[0] for x in frame.juso])
print(results.value_counts())



  irum  nai juso
e  한가해   35  신사동
c  신기해   33  역삼동
b  한국인   25  신당동
a  홍길동   23  역삼동
  irum juso  nai
a  홍길동  역삼동   23
b  한국인  신당동   25
c  신기해  역삼동   33
e  한가해  신사동   35
   nai
a  1.0
b  1.0
c  1.0
e  1.0
   irum  nai  juso
a   4.0  1.0   3.5
b   3.0  2.0   1.0
c   1.0  3.0   3.5
e   2.0  4.0   2.0
a    홍길동
b    한국인
Name: irum, dtype: object
역삼동    2
신사동    1
신당동    1
Name: juso, dtype: int64
      juso  inwon
0  강남구 역삼동     23
1   중구 신당동     25
2  강남구 대치동     15
강남구    2
중구     1
dtype: int64


Reindex(재색인)방법이다.
결측치는 fill_value=”특정값”으로 치환을 하거나 method=ffill or bfill으롯 앞 혹은 뒤의 값으로 대체할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
#Reindex: 재색인 
data = Series([5,7,-2,3], index = ("d","b","a","c"))
print(data)

data2 = data.reindex(["a", "b", "c", "d", "e"], fill_value=0) #결측치는 0으로 대체 
print(data2) #index를 기준으로 순서 재배치

data3 = Series(["마우스", "키보드", "모니터"], index=(0,2,3)) 
print(data3)

print(data3.reindex(range(6)))
print(data3.reindex(range(6), method="ffill")) #결측치는 앞의 값으로 대체
print(data3.reindex(range(6), method="bfill")) #결측치는 뒤의 값으로 대체



d    5
b    7
a   -2
c    3
dtype: int64
a   -2
b    7
c    3
d    5
e    0
dtype: int64
0    마우스
2    키보드
3    모니터
dtype: object
0    마우스
1    NaN
2    키보드
3    모니터
4    NaN
5    NaN
dtype: object
0    마우스
1    마우스
2    키보드
3    모니터
4    모니터
5    모니터
dtype: object
0    마우스
1    키보드
2    키보드
3    모니터
4    NaN
5    NaN
dtype: object


DataFrame을 reshape()를 통하여 크기를 지정하여 생성하는 방법이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
frame = DataFrame(np.arange(6).reshape(3,2),\
                  index=["1월","3월","4월"], columns=["강남","강북"])
# arange(6)으로 0~5까지의 숫자 부여하고, reshape(3,2)으로 3x2 행렬로 조정
# index와 columns로 행, 열 이름 부여
print(frame)

frame2 = frame.reindex(["1월","2월","3월","4월"])
print(frame2)

site = ["강남", "강동", "서초"]
frame3 = frame.reindex(columns=site)
print(frame3)

frame4 = frame.reindex(["1월","2월","3월","4월"], columns=site, method="ffill")
print(frame4)



    강남  강북
1월   0   1
3월   2   3
4월   4   5
     강남   강북
1월  0.0  1.0
2월  NaN  NaN
3월  2.0  3.0
4월  4.0  5.0
    강남  강동  서초
1월   0 NaN NaN
3월   2 NaN NaN
4월   4 NaN NaN
    강남  강동  서초
1월   0   0   1
2월   0   0   1
3월   2   2   3
4월   4   4   5


DataFrame Slicing방법이다.
조건을 주어서 return type을 Boolean형태로 취할 수 있다.
DataFrame은 iloc을 통하여 숫자로서 접근이 가능하다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Slicing(슬라이싱)
frame = DataFrame(np.arange(12).reshape(4,3),\
                  index=["1월","2월","3월","4월"], columns=["강남","강북","종로"])
print(frame)
print()
print(frame["강남"])

print()
print(frame["강남"] > 3) #결과를 Boolean Type으로 반환한다.

print()
print(frame < 3) 
frame[frame < 3] = 0 #조건을 만족하는 column의 값을 바꿀 수 있다.
print(frame)

print(frame.iloc[2]) # iloc : 숫자지원
print(frame.iloc[:3])
print(frame.iloc[:3,2])



    강남  강북  종로
1월   0   1   2
2월   3   4   5
3월   6   7   8
4월   9  10  11

1월    0
2월    3
3월    6
4월    9
Name: 강남, dtype: int32

1월    False
2월    False
3월     True
4월     True
Name: 강남, dtype: bool

       강남     강북     종로
1월   True   True   True
2월  False  False  False
3월  False  False  False
4월  False  False  False
    강남  강북  종로
1월   0   0   0
2월   3   4   5
3월   6   7   8
4월   9  10  11
강남    6
강북    7
종로    8
Name: 3월, dtype: int32
    강남  강북  종로
1월   0   0   0
2월   3   4   5
3월   6   7   8
1월    0
2월    5
3월    8
Name: 종로, dtype: int32


DataFrame연산 방법이다. Series와 마찬가지로 index끼리 연산을 한다.
index가 서로 일치하지 않으면 연산하지 않고 그 칼럼의 값을 NaN으로 채운다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#연산: 같은 Index끼리 연산한다. Index가 서로 일치하지 않으면
#연산하지 않고 그 칼럼의 값은 NaN으로 채운다.
df1 = DataFrame(np.arange(9).reshape(3,3), columns=list("kbs"),\
              index=["서울", "대전", "부산"], dtype=np.int32)
df2 = DataFrame(np.arange(12).reshape(4,3), columns=list("kbs"),\
              index=["서울", "대전", "제주","광주"], dtype=np.int32)
print(df1)
print(df2)
print(df1+df2)

print(df1.add(df2))
print()
print(df1.add(df2, fill_value=0))
print()
print(df1.mul(df2, fill_value=0))



    k  b  s
서울  0  1  2
대전  3  4  5
부산  6  7  8
    k   b   s
서울  0   1   2
대전  3   4   5
제주  6   7   8
광주  9  10  11
      k    b     s
광주  NaN  NaN   NaN
대전  6.0  8.0  10.0
부산  NaN  NaN   NaN
서울  0.0  2.0   4.0
제주  NaN  NaN   NaN
      k    b     s
광주  NaN  NaN   NaN
대전  6.0  8.0  10.0
부산  NaN  NaN   NaN
서울  0.0  2.0   4.0
제주  NaN  NaN   NaN

      k     b     s
광주  9.0  10.0  11.0
대전  6.0   8.0  10.0
부산  6.0   7.0   8.0
서울  0.0   2.0   4.0
제주  6.0   7.0   8.0

      k     b     s
광주  0.0   0.0   0.0
대전  9.0  16.0  25.0
부산  0.0   0.0   0.0
서울  0.0   1.0   4.0
제주  0.0   0.0   0.0


Series와 DataFrame간의 연산하는 과정이다.

1
2
3
4
5
6
:
seri = df1.iloc[0]
print(seri, type(seri))
print()
print(df1 - seri) # DataFrame과 Series 간 연산 가능
# -> Series 색인을 데이터프레임에 맞춰 전파한다.



k    0
b    1
s    2
Name: 서울, dtype: int32 <class 'pandas.core.series.Series'>

    k  b  s
서울  0  0  0
대전  3  3  3
부산  6  6  6


DataFrame의 여러가지 함수를 적용하는 방법이다.

  1. sum(): 합(NaN은 연산에서 제외한다.)
  2. sum(axis=0): 열의 합
  3. sum(axis=1): 행이 합
  4. fillna(0): NaN값을 모두 0으로 대체
  5. dropna(): NaN값을 모두 제거


1
2
3
4
5
6
7
8
9
10
df3 = df1.add(df2)
print(df3)
print(df3.dropna()) 
print(df3.dropna(how="all")) 
print(df3.fillna(0)) # NaN 값을 모두 0으로 대체한다.

print(df3.sum()) #NaN은 연산에서 제외한다.
print(df3.sum(axis=0)) #열의 합
print(df3.sum(axis=1)) #행의 합


      k    b     s
광주  NaN  NaN   NaN
대전  6.0  8.0  10.0
부산  NaN  NaN   NaN
서울  0.0  2.0   4.0
제주  NaN  NaN   NaN
      k    b     s
대전  6.0  8.0  10.0
서울  0.0  2.0   4.0
      k    b     s
대전  6.0  8.0  10.0
서울  0.0  2.0   4.0
      k    b     s
광주  0.0  0.0   0.0
대전  6.0  8.0  10.0
부산  0.0  0.0   0.0
서울  0.0  2.0   4.0
제주  0.0  0.0   0.0
k     6.0
b    10.0
s    14.0
dtype: float64
k     6.0
b    10.0
s    14.0
dtype: float64
광주     0.0
대전    24.0
부산     0.0
서울     6.0
제주     0.0
dtype: float64


describe()는 데이터의 각종 통계 정보들을 한눈에 보여주는 함수이다.

1
2
print(df3.describe())
#describe()함수는 데이터의 각종 통계 정보들을 한눈에 보여준다.


              k         b          s
count  2.000000  2.000000   2.000000
mean   3.000000  5.000000   7.000000
std    4.242641  4.242641   4.242641
min    0.000000  2.000000   4.000000
25%    1.500000  3.500000   5.500000
50%    3.000000  5.000000   7.000000
75%    4.500000  6.500000   8.500000
max    6.000000  8.000000  10.000000


행과열을 서로 변환하는 함수이다.

  • stack(): 열을 행으로 변경하는 함수
  • unstack(): 행을 열로 변경하는 함수


1
2
3
4
5
6
7
8
9
10
11
12
13
14
#행과 열의 변환
#stack(): 열을 행으로 변경하는 함수
#unstack(): 행을 열로 변경하는 함수
df = DataFrame(1000 + np.arange(6).reshape(2,3), index = ["대전", "서울"],\
              columns = ["2016", "2017", "2018"])
print(df)

print()
df_row = df.stack()
print(df_row)

print()
df_col = df_row.unstack() 
print(df_col) # 원래의 형태로 돌아왔다.



    2016  2017  2018
대전  1000  1001  1002
서울  1003  1004  1005

대전  2016    1000
    2017    1001
    2018    1002
서울  2016    1003
    2017    1004
    2018    1005
dtype: int32

    2016  2017  2018
대전  1000  1001  1002
서울  1003  1004  1005


중복자료를 하나로 합치는 방법이다.

1
2
3
4
5
#중복자료 처리
data = {"data1":["a"] * 4, "data2":[1,1,2,2]}
df2 = DataFrame(data)
print(df2)
print(df2.drop_duplicates())



  data1  data2
0     a      1
1     a      1
2     a      2
3     a      2
  data1  data2
0     a      1
2     a      2


범주화를 하는 방법이다.
범주화란 연속적인 변수를 구간을 설정하여 이산형변수 로서 나타내는 것이다.

1
2
3
4
5
6
7
8
9
10
#범주화: 구간 설정
# 범주화 (구간 설정)
price = [10.3, 5.5, 7.8, 3.6]
cut = [3, 7, 9, 11] # 구간 설정
result_cut = pd.cut(price, cut)
print(result_cut)

print()
count = pd.value_counts(result_cut)
print(count)


[(9, 11], (3, 7], (7, 9], (3, 7]]
Categories (3, interval[int64]): [(3, 7] < (7, 9] < (9, 11]]

(3, 7]     2
(9, 11]    1
(7, 9]     1
dtype: int64


두개의 DataFrame을 합치는 방법이다.
아래의 예시는 DB에서 inner join과 같다.

1
2
3
4
5
6
7
8
9
#자료 합치기
df1 = DataFrame({"data1":range(7), "key":["b","b","a","c","a","a","b"]})
print(df1)
df2 = DataFrame({"key":["a","b","d"], "data2": range(3)})
print(df2)

print()
print(pd.merge(df1, df2))
print(pd.merge(df1, df2, on="key")) #inner join: 교집합



   data1 key
0      0   b
1      1   b
2      2   a
3      3   c
4      4   a
5      5   a
6      6   b
  key  data2
0   a      0
1   b      1
2   d      2

   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0
   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0


두개의 DataFrame을 합치는 방법이다.
아래의 예시는 DB에서 outer join과 같다.

1
2
3
4
5
6
print(pd.merge(df1, df2, on="key", how = "inner"))
print(pd.merge(df1, df2, on="key", how = "outer"))

print()
print(pd.merge(df1, df2, on="key", how = "left"))
print(pd.merge(df1, df2, on="key", how = "right"))



   data1 key  data2
0      0   b      1
1      1   b      1
2      6   b      1
3      2   a      0
4      4   a      0
5      5   a      0
   data1 key  data2
0    0.0   b    1.0
1    1.0   b    1.0
2    6.0   b    1.0
3    2.0   a    0.0
4    4.0   a    0.0
5    5.0   a    0.0
6    3.0   c    NaN
7    NaN   d    2.0

   data1 key  data2
0      0   b    1.0
1      1   b    1.0
2      2   a    0.0
3      3   c    NaN
4      4   a    0.0
5      5   a    0.0
6      6   b    1.0
   data1 key  data2
0    0.0   b      1
1    1.0   b      1
2    6.0   b      1
3    2.0   a      0
4    4.0   a      0
5    5.0   a      0
6    NaN   d      2


group by란 Data에 특정한 조건을 주어서 합치는 방법이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#group by
df = DataFrame({"key1":["a","a","b","b","a"],\
               "key2":["one", "two", "one", "two", "one"],
               "data1":np.random.randn(5),
               "data2":np.random.randn(5)})
print(df)

gr = df["data1"].groupby(df["key1"])
print(gr)

print()
print(gr.sum())
print(gr.mean())

print()
gr_means = df["data1"].groupby([df["key1"],df["key2"]]).mean()
print(gr_means)

print()
print(gr_means.unstack())



  key1 key2     data1     data2
0    a  one  1.178993  1.096159
1    a  two  0.545936 -0.355670
2    b  one  0.825063  1.298997
3    b  two -1.775862 -1.514613
4    a  one  0.575223  1.599840
<pandas.core.groupby.generic.SeriesGroupBy object at 0x000002296F5305F8>

key1
a    2.300152
b   -0.950799
Name: data1, dtype: float64
key1
a    0.766717
b   -0.475400
Name: data1, dtype: float64

key1  key2
a     one     0.877108
      two     0.545936
b     one     0.825063
      two    -1.775862
Name: data1, dtype: float64

key2       one       two
key1                    
a     0.877108  0.545936
b     0.825063 -1.775862


pivot이란 데이터 프레임 열 중에서 두 개의 key를 이용하여 데이터를 선택 출력하는 방법이다.

1
2
3
4
5
6
7
#pivot
#데이터프레임 열 중에서 두 개의 key를 이용하여 데이터를 선택 출력하기
data = {"city":["강남","강북","강남","강북"],
       "year":[2000,2001,2002,2002],
       "pop":[3.3, 2.5, 3.0, 2.0]}
df = pd.DataFrame(data)
print(df)


  city  year  pop
0   강남  2000  3.3
1   강북  2001  2.5
2   강남  2002  3.0
3   강북  2002  2.0


pivot table이란 pivot과 group by의 성질을 적절하게 융합시킨 형태이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#pivot table: pivot과 group by의 성질을 적절하게 융합시킨 형태
print(df)

print()
print(df.pivot_table(index=["city"]))

print()
print(df.pivot_table(index=["city"], aggfunc = np.mean))
# aggfunc = np.mean -> 디폴트 설정

print()
print(df.pivot_table(index=["city","year"], aggfunc = [len, np.sum]))
# city, year 별로 갯수와 합이 나온다.

print()
print(df.pivot_table(["pop"], index=["city"]))
# 연산대상: "pop"

print()
print(df.pivot_table(["pop"], index=["city"], aggfunc = [len]))

print()
print(df.pivot_table(["pop"], index="year", columns = ["city"]))
print(df.pivot_table(["pop"], index=["year"], columns = ["city"], margins=True))

print()
print(df.pivot_table(["pop"], index=["year"],\
                     columns = ["city"], margins=True, fill_value=0))

print()
print(df.groupby(["city"]).sum())

print()
print(df.groupby(["city", "year"]).sum())



  city  year  pop
0   강남  2000  3.3
1   강북  2001  2.5
2   강남  2002  3.0
3   강북  2002  2.0

       pop    year
city              
강남    3.15  2001.0
강북    2.25  2001.5

       pop    year
city              
강남    3.15  2001.0
강북    2.25  2001.5

           len  sum
           pop  pop
city year          
강남   2000  1.0  3.3
     2002  1.0  3.0
강북   2001  1.0  2.5
     2002  1.0  2.0

       pop
city      
강남    3.15
강북    2.25

      len
      pop
city     
강남    2.0
강북    2.0

      pop     
city   강남   강북
year          
2000  3.3  NaN
2001  NaN  2.5
2002  3.0  2.0
       pop           
city    강남    강북  All
year                 
2000  3.30   NaN  3.3
2001   NaN  2.50  2.5
2002  3.00  2.00  2.5
All   3.15  2.25  2.7

       pop           
city    강남    강북  All
year                 
2000  3.30  0.00  3.3
2001  0.00  2.50  2.5
2002  3.00  2.00  2.5
All   3.15  2.25  2.7

      year  pop
city           
강남    4002  6.3
강북    4003  4.5

           pop
city year     
강남   2000  3.3
     2002  3.0
강북   2001  2.5
     2002  2.0



참조: 원본코드
코드에 문제가 있거나 궁금한 점이 있으면 wjddyd66@naver.com으로 Mail을 남겨주세요.

Leave a comment