fig = go.Figure()
fig.add_trace(go.Bar(x=df['시군구명'],y=df['총 의료시설수'],name = "총 의료시설수"))
fig.add_trace(go.Bar(x=df['시군구명'],y=df['약국 시설수'],name = "약국 시설수"))
fig.update_xaxes(tickangle=60)
fig.update_layout(title_text='총 병원 수와 약국 시설 수')
fig.show()

새로운 데이터 열 만들기

총 병원 = [
    '종합병원 시설수',
    '일반병원 시설수',
    '요양병원 시설수',
    '치과병의원 시설수',
    '한방병의원 시설수',
    '일반의원 시설수',
    '보건소 시설수'
]
#
# 총 의료시설 수 컬럼 #.sum(axis=1)은 각 행마다 더해서 총합을 구합니다.
df['총 의료시설수'] = df[총 병원].sum(axis=1)
print(df[['시군구명', '총 의료시설수']])
>>
      시군구명  총 의료시설수
0   포항시 남구      258
1   포항시 북구      374
2      경주시      291
3      김천시      157
...
23     울릉군        8

지하철 범죄 데이터 조회

df = pd.read_csv('경찰청_범죄 발생 장소별 통계-2.csv', encoding='UTF-8')
df = df[['지하철_전철', '범죄대분류']].sort_values(by='지하철_전철', ascending=False)#sort_values 오름차순 정렬
fig = px.bar(df, x='지하철_전철', y='범죄대분류',orientation='h')
fig.show()

부산광역시_영도구_동별 빈집현황

fig = px.bar(df, x='행정동명', y='빈집수(호)', text_auto='빈집수(호)')

fig.update_traces(textfont_size=12,textfont_color='white', textangle=0, textposition="inside")
fig.update_layout(title_text='부산광역시_영도구_동별 빈집현황')
fig.show()

강원랜드_게임기현황

fig = px.bar(df, x="게임명", y="대수",pattern_shape="대수")

fig.show()

fig = px.bar(df, x =' 구분 ',y = '  세대수  ', title = '부산광역시 인구현황')
fig.show()

기본적인 동별 세대수

동별 남,여 인구수

fig = go.Figure()

fig = make_subplots(rows=1,cols=2)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(남)  '],name = "인구(남)"),row=1,col=1)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(여)  '],name = "인구(여)"),row=1,col=2)

fig.update_xaxes(tickangle=45, row=1, col=1)#tick angle = 눈금 각도, 글자의 각도를 수정할 수 있게 해준다
fig.update_xaxes(tickangle=45, row=1, col=2)

fig.show()

부산동별 세대수 원그래프 시각화

fig = px.pie(df, values = '  세대수  ',names = ' 구분 ')
fig.update_layout(title = "부산동별 세대수")
fig.show()

꺾은 선

fig = px.scatter(df, x = ' 구분 ', y = '  세대수  ')
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  세대수  '])name="세대수")

fig.update_xaxes(tickangle=0)
fig.show()

동별 인구를 4분활로 출력하기

fig = go.Figure()

fig = make_subplots(rows=2,cols=2, subplot_titles=("인구수(남)","인구수(여)","18세이상인구수(남)","18세이상인구수(여)"))
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(남)  '],name = "인구(남)"),row=1,col=1)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(여)  '],name = "인구(여)"),row=1,col=2)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  18세이상인구수(남)  '],name = "18세이상인구(남)"),row=2,col=1)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  18세이상인구수(여)  '],name = "18세이상인구(여)"),row=2,col=2)
fig.update_xaxes(tickangle=45, row=1, col=1)#tick angle = 눈금 각도, 글자의 각도를 수정할 수 있게 해준다
fig.update_xaxes(tickangle=45, row=1, col=2)
fig.update_xaxes(tickangle=45,row=2,col=1)
fig.update_xaxes(tickangle=45,row=2,col=2)
fig.update_layout(title_text="부산인구현황",)
fig.show()

scatter도 같이

fig = go.Figure()

fig = make_subplots(rows=2,cols=2, subplot_titles=("인구수(남)","인구수(여)","18세이상인구수(남)","18세이상인구수(여)"))
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(남)  '],name = "인구(남)"),row=1,col=1)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(여)  '],name = "인구(여)"),row=1,col=2)
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  18세이상인구수(남)  '],name = "18세이상인구(남)"),row=2,col=1)
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  18세이상인구수(여)  '],name = "18세이상인구(여)"),row=2,col=2)
fig.update_xaxes(tickangle=45, row=1, col=1)#tick angle = 눈금 각도, 글자의 각도를 수정할 수 있게 해준다
fig.update_xaxes(tickangle=45, row=1, col=2)
fig.update_xaxes(tickangle=45,row=2,col=1)
fig.update_xaxes(tickangle=45,row=2,col=2)
fig.update_layout(title_text="부산인구현황",)
fig.show()

그래프 겹쳐서 출력

fig = px.scatter(df, x = ' 구분 ', y = '  인구수(계)  ')
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  인구수(계)  '],mode='lines+markers',name='인구수'))
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  65세이상인구수(계)  '],mode='lines+markers',name='65세이상인구수'))
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  18세이상인구수(계)  '],mode='lines+markers',name='18세이상인구수'))
fig.update_xaxes(tickangle=0)
fig.update_layout(title = "총인구수 및 18,65세이상인구수")
fig.show()

그래프 크기 조절

fig = make_subplots(rows=2,cols=2,  column_widths=[0.3, 0.7], row_heights =[0.7, 0.3], subplot_titles=("인구수(남)","인구수(여)","18세이상인구수(남)","18세이상인구수(여)"))
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(남)  '],name = "인구(남)"),row=1,col=1)
fig.add_trace(go.Bar(x=df[' 구분 '],y=df['  인구수(여)  '],name = "인구(여)"),row=1,col=2)
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  18세이상인구수(남)  '],name = "18세이상인구(남)"),row=2,col=1)
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  18세이상인구수(여)  '],name = "18세이상인구(여)"),row=2,col=2)
fig.update_xaxes(tickangle=45, row=1, col=1)#tick angle = 눈금 각도, 글자의 각도를 수정할 수 있게 해준다
fig.update_xaxes(tickangle=45, row=1, col=2)
fig.update_xaxes(tickangle=45,row=2,col=1)
fig.update_xaxes(tickangle=45,row=2,col=2)
fig.update_layout(title_text="부산인구현황",)
fig.show()

세대수가 가장 많은 동에서 가장 적은 동 사이에 사각영역 추가

fig = px.scatter(df, x = ' 구분 ', y = '  세대수  ')
fig.add_vrect(x0=1, x1=5, line_width=0, fillcolor="white", opacity=0.5,
              annotation_text="편차가 크다", 
              annotation_position="bottom right",
              annotation_font_size=10,
              annotation_font_color="black",
              annotation_font_family="Times New Roman")
fig.add_trace(go.Scatter(x=df[' 구분 '],y=df['  세대수  '],name="세대수"))
fig.update_layout(title = "동별 세대수")
fig.update_xaxes(tickangle=0)
fig.show()

Table시각화

fig = go.Figure()
fig.add_trace(
    go.Table(header=dict(values=["세대수","인구수","인구수(남)","인구수(여)"]), #헤더
             cells=dict(values=[df['  세대수  '], # 1열
                                df['  인구수(계)  '],
                                df['  인구수(남)  '],
                                df['  인구수(여)  ']]))) # 2열
fig.update_layout(title ="Table")
fig.show()

import plotly.express as px
#express 방식
#데이터 불러오기 
df = px.data.tips()

#데이터 확인
df.head()

#그래프 그리기
fig = px.scatter(df, x="total_bill", y="tip", color="sex")#x축은 total, y축은 tip, 찍히는건 성별로

fig.show()

#graph_object 방식은 직접 성별 데이터를 구분하고 따로따로 구분하고 그래프를 그려줘야합니다

Female = df.loc[df["sex"]=="Female", :]
Female.head()

Male = df.loc[df["sex"]=="Male", :]
Male.head()

#그래프 그리기
import plotly.graph_objects as go

fig = go.Figure()

fig.add_trace(go.Scatter(
    x=Female.total_bill,#x값
    y=Female.tip,#y값
    mode='markers',#그래프 형식
    name="Female"#이름
    #fig.add_trace() 를 통해 Trace를 추가할때 해당 데이터를 범례로 표시할 문구를name=안에 넣어줍니다.
))

fig.add_trace(go.Scatter(
    x=Male.total_bill,
    y=Male.tip,
    mode='markers',
    name="Male"
))

범례 삭제하기

fig.update_layout(showlegend=False)#update해서 비활성화 한다, 다시 보일려면 false에서true로 바꿔준다

범례 위치 지정

fig.update_layout(
            legend__x = (0~1) 사이값
            legend__y = (0~1) 사이값
            legend_xanchor = (`auto","left","center","right")#좌표를 중심으로한 왼쪽 또는 가운데 오른쪽
            legend_yanchor = ("auto","top","middle","bottom")
            })

Plotly 수직선/수평선/사각영역 그리기

수직/수평선 그리기

# 수평선 그리기
fig.add_hline(y= 선의 y 위치,
            line_width= 선 두깨, 
            line_dash=선 스타일, 
            line_color=선 색,
            annotation_text= 주석 입력, 
            annotation_position= 주석 위치,
            annotation_font_size= 주석 폰트 사이즈,
            annotation_font_color=주석 폰트 색,
            annotation_font_family=주석 폰트 서체)

# 수직선 그리기
fig.add_vline(x= 선의 x 위치,
            line_width= 선 두깨, 
            line_dash=선 스타일, 
            line_color=선 색,
            annotation_text= 주석 입력, 
            annotation_position= 주석 위치,
            annotation_font_size= 주석 폰트 사이즈,
            annotation_font_color=주석 폰트 색,
            annotation_font_family=주석 폰트 서체)

둘다 그리기

#데이터 불러오기
df = px.data.iris()

#그래프 그리기
fig = px.scatter(df, x="petal_length", y="petal_width")

# 수평선 추가하기
fig.add_hline(y=0.9,line_width=3, line_dash="dash",
              line_color="green",
              annotation_text="수평선", 
              annotation_position="bottom right",
              annotation_font_size=20,
              annotation_font_color="green",
              annotation_font_family="Times New Roman")

# 수직선 추가하기
fig.add_vline(x=3,line_width=3, line_dash="dash",
              line_color="red",
              annotation_text="수직선", 
              annotation_position="top left",
              annotation_font_size=20,
              annotation_font_color="red",
              annotation_font_family="Times New Roman")

사각 영역 그리기

# 수평 사각영역 그리기
fig.add_vrect(x0= 영역시작 x좌표, x1=영역끝 x좌표, ,line_width= 테두리 선 두깨, line_dash=테두리 선 스타일, line_color=테두리 선 색, fillcolor=영역 색, opacity=영역 투명도)

# 수직영역 그리기
fig.add_hrect(x0= 영역시작 x좌표, x1=영역끝 x좌표, ,line_width= 테두리 선 두깨, line_dash=테두리 선 스타일, line_color=테두리 선 색, fillcolor=영역 색, opacity=영역 투명도)

import plotly.express as px

#데이터 불러오기
df = px.data.iris()

#그래프 그리기
fig = px.scatter(df, x="petal_length", y="petal_width")

# 수직 사각 영 추가하기
fig.add_vrect(x0=3, x1=5, line_width=0, fillcolor="green", opacity=0.2,
#opacity= 불투명도, line_width 테두리 두께
              annotation_text="수직 영역", 
              annotation_position="bottom right",
              annotation_font_size=20,
              annotation_font_color="green",
              annotation_font_family="Times New Roman")

# 수평 사각 영역 추가하기
fig.add_hrect(y0=0.9, y1=1.5, line_width=0, fillcolor="red", opacity=0.2,
              annotation_text="수 영역", 
              annotation_position="top left",
              annotation_font_size=20,
              annotation_font_color="red",
              annotation_font_family="Times New Roman")

fig.show()

Plotly 다양한 도형 그리기

fig.add_shape(type="rect",
            x0= 왼쪽 아래 x좌표, y0= 왼쪽 아랫 y좌표,
            x1= 오늘쪽 위 x좌표, y1= 오른쪽 위 y좌표,
            line_width= 테두리선 두깨, 
            line_dash= 테두리선 스타일, 
            line_color= 테두리선 색,
            fillcolor= 안에 채우는 색,
            opacity = 투명도)

사각형

import plotly.graph_objects as go

#그래프 생성
fig = go.Figure()

# 텍스트 추가
fig.add_trace(go.Scatter(
    x=[1.5, 4.5],
    y=[0.75, 0.75],
    text=["Unfilled Rectangle", "Filled Rectangle"],
    mode="text",
))

# 축 설정 변경
fig.update_xaxes(range=[0, 7], showgrid=False)
fig.update_yaxes(range=[0, 3.5])

# 사각형 그리기

fig.add_shape(type="rect",#사각형 타입
    x0=1, y0=1, x1=2, y1=3,
    line_color="RoyalBlue")

fig.add_shape(type="rect",
    x0=3, y0=1, x1=6, y1=2,
    line_color="RoyalBlue",
    line_width=2,#테두리 두계
    fillcolor="LightSkyBlue",
    opacity=0.5)

fig.show()

원 그리기

fig.add_shape(type="circle",
            x0= 원점 x좌표, y0= 원 y좌표,
            x1= 가로 반지름, y1= 세로 반지름,
            line_width= 테두리선 두깨, 
            line_dash= 테두리선 스타일, 
            line_color= 테두리선 색,
            fillcolor= 안에 채우는 색,
            opacity = 투명도)

import plotly.graph_objects as go

#그래프 생성
fig = go.Figure()

# 텍스트 추가
fig.add_trace(go.Scatter(
    x=[1.5, 3.5],
    y=[0.75, 2.5],
    text=["Unfilled Circle",
          "Filled Circle"],
    mode="text",
))

# 축 설정 변경
fig.update_xaxes(range=[0, 4.5], zeroline=False)
fig.update_yaxes(range=[0, 4.5])

# 원 그리기

fig.add_shape(type="circle",
    xref="x", yref="y",
    x0=1, y0=1, x1=3, y1=3,
    line_color="LightSeaGreen",)

fig.add_shape(type="circle",
    xref="x", yref="y",
    fillcolor="PaleTurquoise",
    x0=3, y0=3, x1=4, y1=4,
    line_color="LightSeaGreen",)

fig.show()

선 그리기

fig.add_shape(type="line",
            x0= 선 시작 x좌표, y0= 선 시작 y좌표,
            x1= 선 끝 x좌표, y1= 선 끝 y좌표,
            line_width= 선 두깨, 
            line_dash= 선 스타일, 
            line_color= 선 색,
            opacity = 투명도)

import plotly.graph_objects as go

#그래프 생성
fig = go.Figure()

# 텍스트 추가
fig.add_trace(go.Scatter(
    x=[2, 3.5, 6],
    y=[1, 1.5, 1],
    text=["Vertical Line",
          "Horizontal Dashed Line",
          "Diagonal dotted Line"],mode="text",))

# 축 설정 변경
fig.update_xaxes(range=[0, 7])
fig.update_yaxes(range=[0, 2.5])

# 선 그리기

fig.add_shape(type="line",
    x0=1, y0=0, x1=1, y1=2,
    line_color="RoyalBlue",
    line_width=3)

fig.add_shape(type="line",
    x0=2, y0=2, x1=5, y1=2,
    line_color="LightSeaGreen",
    line_width=4,
    line_dash="dashdot")

fig.add_shape(type="line",
    x0=4, y0=0, x1=6, y1=2,
    line_color="MediumPurple",
    line_width=4,
    line_dash="dot")

fig.show()

다각형 그리기

import plotly.graph_objects as go
# 그래프 생성
fig = go.Figure()

# 삼각형 그리기
fig.add_trace(go.Scatter(x=[5,6,7,5], y=[2,3,2,2], fill="toself"))#채울꺼면 toself 아니면 fill을 안넣음

fig.show()

import plotly.graph_objects as go

fig = go.Figure()

# 육각형
fig.add_trace(go.Scatter(x=[1,1,2,3,4,4,3,2,1], y=[1,2,3,3,2,1,0,0,1], fill="toself"))

# 사각형
fig.add_trace(go.Scatter(x=[5,5,7,7,5], y=[0.5,1.5,1.5,0.5,0.5], fill="toself"))

# 삼각형
fig.add_trace(go.Scatter(x=[5,6,7,5], y=[2,3,2,2], fill="toself"))

fig.show()

Plotly 텍스트/주석 넣기

Annotation 넣기

fig.add_annotation(
            x= x 좌표, y= y 좌표,
            text= 주석 텍스트,
            textangle= 텍스트 각도,
            font_color = 텍스트 색,
            font_family = 텍스트 서체,
            font_size = 텍스트 사이즈,
            arrowhead = 화살표 스타일,
            arrowcolor= 화살표 색,
            arrowside= 화살표 방향,
            arrowsize= 화살표 크기,
            arrowwidth = 화살표 두깨,
            bgcolor=텍스트 백그라운드색,
            bordercolor= 테두리 색,
            borderwidth = 테두리 두깨,
            opacity = 투명도,
            xshift = x축 방향 평행이동,
            yshift = y축 방향 평행이동)

import plotly.graph_objects as go

#그래프 생성
fig = go.Figure()

fig.add_trace(go.Scatter(
    x=[0, 1, 2, 3, 4, 5, 6, 7, 8],
    y=[0, 1, 3, 2, 4, 3, 4, 6, 5]
))

fig.add_trace(go.Scatter(
    x=[0, 1, 2, 3, 4, 5, 6, 7, 8],
    y=[0, 4, 5, 1, 2, 2, 3, 4, 2]
))

# annotation 추가
fig.add_annotation(x=2, y=5,
            text="Text annotation with arrow",
            showarrow=True,
            arrowhead=1)
fig.add_annotation(x=4, y=4,
            text="Text annotation without arrow",
            showarrow=False,
            yshift=10)

fig.show()

텍스트 넣기

go.Scatter(x=[X좌표 리스트], y=[Y좌표 리스트],text=[텍스트 리스트] mode="text", textposition= 텍스트 위치)

import plotly.graph_objects as go

fig = go.Figure()

fig.add_trace(go.Scatter(
    x=[0, 1, 2],
    y=[1, 1, 1],
    mode="text",
    name="아랫줄",
    text=["Text A", "Text B", "Text C"],
    textposition="top center"))

fig.add_trace(go.Scatter(
    x=[0, 1, 2],
    y=[2, 2, 2],
    mode="text",
    name="중간줄",
    text=["Text D", "Text E", "Text F"],
    textposition="bottom center"))

fig.add_trace(go.Scatter(
    x=[0, 1, 2],
    y=[3, 3, 3],
    mode="text",
    name="윗줄",
    text=["Text G", "Text H", "Text I"],
    textposition="bottom center"))

fig.show()

눈금생성하기

import plotly.express as px
#데이터 불러오기
df = px.data.iris()

# Figure 생성
fig = px.scatter(df, x="sepal_width", y="sepal_length", facet_col="species")

# 눈금 생성
fig.update_xaxes(ticks="outside")#눈금이 x좌료의 바깥쪽에 생선된다
fig.update_yaxes(ticks="inside")#눈금이 y좌료의 안쪽에 생성된다

fig.show()

열만 지정하여 눈금생성

import plotly.express as px
#데이터 불러오기
df = px.data.iris()
# Figure 생성
fig = px.scatter(df, x="sepal_width", y="sepal_length", facet_col="species")
#facet_col-:"species" 는 종으로 나뉘기 때문에 3개가 생성됩니다
# 눈금 생성
fig.update_xaxes(ticks="outside")
fig.update_yaxes(ticks="inside", col=1)#y좌표의 생선된것중 col1만 눈금을 생성합니다

fig.show()

tick 간격지정

fig.update_xaxes(dtick=간격 입력)
fig.update_yaxes(dtick=간격 입력)#원하는 만큼 간격을 조절할 수 있습니다

tick 위치 수동 입력

fig.update_xaxes(tickvals=[tick 좌료 리스트])
fig.update_yaxes(tickvals=[tick 좌료 리스트])#자동생성이 아닌 생성된 위치 값을 입력하여 제한한다
#예제
fig.update_yaxes(tickvals=[5.1, 5.9, 6.3, 7.5])# 이러면 y축의 5.1, 5.9, 6.3, 7.5에 눈금이 생성된다

tick 스타일 설정

fig.update_xaxes(tickwidth=두꺠, tickcolor=색, ticklen=길이)
fig.update_yaxes(tickwidth=두꺠, tickcolor=색, ticklen=길이)#눈금의 두께, 색, 길이를 조절할 수 있다

tick 레이블 위치 설정

fig.update_yaxes(ticklabelposition="위치")
fig.update_xaxes(ticklabelposition="위치")#레이블의 위치를 바꿀수 있다

#위치 {"outside" | "inside" | "outside top" | "inside top" | "outside left" | "inside left" | "outside right" | "inside right" | "outside bottom" | "inside bottom"}

tick 레이블 삭제

fig.update_xaxes(showticklabels=False)#레이블을 비활성화 삭제 시켜준다
fig.update_yaxes(showticklabels=False)

Plotly 축 스타일 편집하기

import plotly.express as px
#데이터 불러오기
df = px.data.tips()

# Figure 생성
fig = px.histogram(df, x="sex", y="tip", histfunc='sum', facet_col='smoker')
#담배 피는 사람과 안피는 사람 두 종류로 분류한다
# 축 스타일 편집
fig.update_xaxes(showline=True, linewidth=3, linecolor='black')#라인을 보여주나=ture, 라인 두깨=3, 라인 색 = black
fig.update_yaxes(showline=True, linewidth=3, linecolor='red')
#이것도 뒤에 , col을 붙여주면 원하는 것만 지정해서 레이블을 달아 줄 수 있다

fig.show()

축 반대편 라인 편집

fig.update_xaxes(mirror=True)
fig.update_yaxes(mirror=True)#거울 보듯이 똑같이 라인의 스타일을 맞추냐 True False

Plotly 그리드 설정하기

그리드는 총 2종류가 있습니다. 큰 단위로 나뉘주는 그리드와 더 작은 단위로 촘촘하게 나뉘주는 minor gird가 있습니다. 기본 그리드는 설정을 따로 하지 않아도 시각화 시 자동으로 보여집니다. minor grid는 따로 코드를 추가해야만 추가가 됩니다.

그리드 설정

import plotly.express as px
#데이터 불러오기
df = px.data.iris()

# Figure 생성
fig = px.scatter(df, x="sepal_width", y="sepal_length", facet_col="species")

# 그리드/ minor 그리드 시각화
fig.update_xaxes(showgrid=True, minor_showgrid=True)
fig.update_yaxes(showgrid=True, minor_showgrid=True)
#그리드 또한 ,col을 사용하여 원하는 곳에만 지정할 수 있습니다
fig.show()

그리드 스타일 편집

# 그리드 스타일 편집
fig.update_xaxes(gridwidth= 두깨, gridcolor= 색,griddash = 그리드 모양)
fig.update_yaxes(gridwidth= 두깨, gridcolor= 색,griddash = 그리드 모양)

# minor 그리드 스타일 편집
fig.update_xaxes(minor_gridwidth= 두깨, minor_gridcolor= 색,minor_griddash = 그리드 모양)
fig.update_yaxes(minor_gridwidth= 두깨, minor_gridcolor= 색,minor_griddash = 그리드 모양)

Plotly 여러개의 그래프 겹쳐 그리기

1.Base 그래프 그리기’

import plotly.graph_objects as go

# Base Figure 생성
fig = go.Figure()

fig.show()

2.추가 할 그래프 그리기

import plotly.graph_objects as go

#데이터 생성
import numpy as np
np.random.seed(1)4

N = 100
random_x = np.linspace(0, 1, N)#0~1까지 N값을 랜덤으로 뽑는다
random_y0 = np.random.randn(N) + 5#n값 +5
random_y1 = np.random.randn(N)
random_y2 = np.random.randn(N) - 5#n값 -5 하는 이유는 그래프들이 겹치지 않기 위해서
# Base Figure 생성
fig = go.Figure()

# 추가 할 그래프 그리기
fig.add_trace(go.Scatter(x=random_x, y=random_y0,
                    mode='lines',
                    name='lines'))
fig.add_trace(go.Scatter(x=random_x, y=random_y1,
                    mode='lines+markers',
                    name='lines+markers'))
fig.add_trace(go.Scatter(x=random_x, y=random_y2,
                    mode='markers', 
                    name='markers'))

fig.show()

Plotly 여러개의 그래프 나눠 그리기

from plotly.subplots import make_subplots
import plotly.graph_objects as go

# 나눠서 그릴 공간 생성
fig = make_subplots(rows=1, cols=2)

# 각 공간에 Trace 채워넣
fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[4, 5, 6]),
    row=1, col=1
)
fig.add_trace(
    go.Scatter(x=[20, 30, 40], y=[50, 60, 70]),
    row=1, col=2
)
fig.show()

서브 제목 달기

subplot_titles=("Plot 1", "Plot 2", "Plot 3", "Plot 4"))
#자동으로 이름을 달아준다

각 공간별 크기 비율 지정하기

column_widths=[0.7, 0.3], row_heights =[0.7, 0.3])#각 trace가 위치할 크기 비율

공간 별 축 공유하기

shared_xaxes=(True or False), shared_yaxes=(True or False))

분할 공간 병합

    specs=[[{}, {}],
           [{"colspan": 2}, None]],#여기 공간은 총 2행2열 이므로 2행 1열과 2헹 2열을 병합 함으로 colspan:2를 쓰고 2행2열 자리에는 None을 입력해준다

Plotly 이중 Y축 표시하기

import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Create figure with secondary y-axis
fig = make_subplots(specs=[[{"secondary_y": True}]])#secondary = True로 이중축이 활성화 되고 오른쪽에 축이 생성됨

# 표 추가
fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[40, 50, 60], name="yaxis data"),
    secondary_y=False,
)
#표 추가
fig.add_trace(
    go.Scatter(x=[2, 3, 4], y=[4, 5, 6], name="yaxis2 data"),
    secondary_y=True,
)

# 타이틀 추가 
fig.update_layout(
    title_text="Double Y Axis Example"
)

# X축 이름
fig.update_xaxes(title_text="xaxis title")

# Y축 이름
fig.update_yaxes(title_text="<b>primary</b> yaxis title", secondary_y=False)
fig.update_yaxes(title_text="<b>secondary</b> yaxis title", secondary_y=True)

fig.show()

여러개 그래프 이중 Y축 설정하기

import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Create figure with secondary y-axis
fig = make_subplots(rows=2, cols=2,
                    specs=[[{"secondary_y": True}, {"secondary_y": True}],
                           [{"secondary_y": True}, {"secondary_y": True}]])
#4개의 그래프 모두 이중축을 허용한다
# Top left
fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[2, 52, 62], name="yaxis data"),
    row=1, col=1, secondary_y=False)

fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[40, 50, 60], name="yaxis2 data"),
    row=1, col=1, secondary_y=True,
)

# Top right
fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[2, 52, 62], name="yaxis3 data"),
    row=1, col=2, secondary_y=False,
)

fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[40, 50, 60], name="yaxis4 data"),
    row=1, col=2, secondary_y=True,
)

# Bottom left
fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[2, 52, 62], name="yaxis5 data"),
    row=2, col=1, secondary_y=False,
)

fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[40, 50, 60], name="yaxis6 data"),
    row=2, col=1, secondary_y=True,
)

# Bottom right
fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[2, 52, 62], name="yaxis7 data"),
    row=2, col=2, secondary_y=False,
)

fig.add_trace(
    go.Scatter(x=[1, 2, 3], y=[40, 50, 60], name="yaxis8 data"),
    row=2, col=2, secondary_y=True,
)

fig.show()

fig.update_layout(title_text="타이틀 입력")
#이것은 기존에 있는 fig라는 그래프에 타이틀을
#업데이트 한것으로 이걸로 express,graph 두가지 방식 모두 커버 가능하다

위치 지정

fig.update_layout(
            title_x = (0~1) 사이값#x좌표
            title_y = (0~1) 사이값#y좌표
            title_xanchor = (`auto","left","center","right")#좌표를 중심으로 타이틀을 왼쪽, 또는 가운데, 오른쪽에 놓을지 설정합니다.
            title_yanchor = ("auto","top","middle","bottom")#title_yanchor = 좌표를 중심으
            })

Plotly 축 타이틀 설정하기(Axes Title)

graph_object 그래프

fig.update_xaxes(title_text='X축 타이틀명')#x축에 삽입할 타이틀명을 업데이트 한다
fig.update_yaxes(title_text='Y축 타이틀명')#축만 바뀌지 위와 같다ㅣ

축 타이틀 스타일 설정방법

fig.update_xaxes(title_font_size =30,
                 title_font_color='crimson',
                 title_font_family='Courier')
fig.update_yaxes(title_font_size =30,
                 title_font_color='crimson',
                 title_font_family='Courier')

축의 타이틀도 글자크기, 색, 폰트변경이 똑같이 가능하다

축 타이틀 위치 지정방법

fig.update_xaxes(title_standoff= 100)#x축 타이틀의 위치간격을 업데이트할 수 있다
fig.update_yaxes(title_standoff= 100)#
fig.update_xaxes(title=None)#축에 있는 레이블삭제
fig.update_yaxes(title=None)

Plotly 축 범위 지정하기

fig.update_xaxes(range=[min, max])#최소값 최대값으로 축 범위 지정
fig.update_yaxes(range=[min, max])

축 범위 역방향으로 지정하기

fig.update_xaxes(autorange="reversed")#x좌표 레이어 역방향으로 반전시키기
fig.update_yaxes(autorange="reversed")

Log 스케일 지정하기,

# 축 Log 스케일로 변환
fig.update_xaxes(type="log")
fig.update_yaxes(type="log")

facet_col="species"#facet_col 열로 나눠준다( species = 종),열 방향으로 종을 기준으로 나눠준다

기본설정

import plotly.graph_objects as go

막대 그래프 시각화

#graph_objects
fig = go.Figure(
    data=[go.Bar(x=[1,2,3], y=[1,3,2])],#x는 가로 bar의 수 y= 높이 이다
    layout=go.Layout(
        title=go.layout.Title(text="A Figure Specified By"))#타이틀, 제목생성
)
fig.show()

#express
fig = px.bar(x=["a","b","c"], y=[1,3,2],title="A Figure Specified By express")
#여기는 데이터와 layout을 나누지 않고 px.bar로 묶어서 실행한다
fig.show()

add_trace()

fig = go.Figure()
fig.add_trace(go.Bar(x=[1,2,3,], y=[1,3,2]))
fig.show()
#위 막대그래프와 똑같이 출력

scatter 그래프 생성

df = px.data.iris()
fig = px.scatter(df, x= "sepal_width", y="sepal_length", color="species", title="Using The add_trace() method With A Plotly Express Figure")
fig.add_trace(
    go.Scatter(
        x=[2,4],
        y=[4,8],
        mode = "lines",
        line = go.scatter.Line(color="gray"),
        showlegend=False)
)
fig.show()

update_trace()

# subplot 생성
fig = make_subplots(rows=1, cols=2)

# Trace 추가하기
fig.add_scatter(y=[4, 2, 3.5], mode="markers",
                marker=dict(size=20, color="LightSeaGreen"),
                name="a", row=1, col=1)
fig.add_bar(y=[2, 1, 3],
            marker=dict(color="MediumPurple"),
            name="b", row=1, col=1)
fig.add_scatter(y=[2, 3.5, 4], mode="markers",
                marker=dict(size=20, color="MediumPurple"),
                name="c", row=1, col=2)
fig.add_bar(y=[1, 3, 2],
            marker=dict(color="LightSeaGreen"),
            name="d", row=1, col=2)
fig.update_traces(marker=dict(color="RoyalBlue"),
                  selector=dict(type="bar"))

fig.show()

update_layout()

update_layout() 함수를 사용하면 그래프 사이즈, 제목 및 텍스트, 글꼴크기 와 같은 Trace 외적인 그래프 요소를 업데이트 가능합니다.

#그래프 생성
fig = go.Figure(data=go.Bar(x=[1, 2, 3], y=[1, 3, 2]))

# 타이틀 추가하기
fig.update_layout(title_text="Using update_layout() With Graph Object Figures",title_font_size=30)

fig.show()

update_xaxes() / update_yaxes()

update_xaxes(), update_yaxes() 함수를 사용하면 각각 X축, Y축에 관한 다양한 편집이 가능합니다. ex) 축 타이틀, 축 라인 스타일, 그리드 설정 등

#데이터 생성
df = px.data.tips()
x = df["total_bill"]
y = df["tip"]
# 그래프 그리기
fig = go.Figure(data=go.Scatter(x=x, y=y, mode='markers'))
# 축 타이틀 추가하기
fig.update_xaxes(title_text='Total Bill ($)')
fig.update_yaxes(title_text='Tip ($)')
fig.show()

Ploty 그래프 사이즈 설정하기

express 그래프

fig = px.bar(x=["a", "b", "c"], y=[1, 3, 2],width=600, height=400)#width와 height는 그래프의 가로 세로의 크기를 정의 한다
fig.show()

graph object 그래프

fig = go.Figure(data=[go.Bar(x=[1, 2, 3], y=[1, 3, 2])])
fig.update_layout(width=600,height=400)
fig.show()

Margine

margin 이란 전체 크기(Figure) 와 그래프(Trace) 사이의 거리를 뜻합니다.

fig.update_layout(
        margin_l=left margine,#왼쪽
        margin_r=right margine,#오른쪽
        margin_b=bottom margine,#아래
        margin_t=top margine)#위

fig = px.bar(x=["a", "b", "c"], y=[1, 3, 2])

# 그래프 크기와 margin 설정하기
fig.update_layout(
    width=600,
    height=400,
    margin_l=100,
    margin_r=100,
    margin_b=70,
    margin_t=70,
    # 백그라운드 칼라 지정, margin 잘 보이게 하기위함
    paper_bgcolor="LightSteelBlue",
)

fig.show()

dataframe 객체를 시각화 하는 메서드

kind : 플로팅할 유형입니다. 목록은 아래와 같습니다.

※ {line / bar / barh / hist / box / kde / density / area / pie / scatter / hexbin} x / y : 각 축으로 설정할 값(컬럼명) 입니다.

ax : 현재 figure의 axes 입니다. (fig와 axes의 개념은 아래 링크 참고)

※ 링크

subplot : 각 열들을 별개의 서브차트로 플로팅할지의 여부입니다.

sharex / sharey : subplot=True 인 경우 각축의 눈금을 공유할지 여부 입니다.

layout : 튜플로 입력하는 subplot의 배열입니다.

figsize : 출력할 fig의 크기 입니다.

use_index : 인덱스를 x축의 눈금으로 사용할지 여부 입니다.

title : fig의 제목 입니다.

grid : 배경 격자의 형성 여부입니다.

legend : subplot에서의 범례 배치 입니다.

style : 선의 스타일 입니다. 자세한것은 링크 참고 바랍니다.

logx / logy / loglog : 각 축에 대해 로그 스케일을 적용할지 여부 입니다. loglog=True인 경우 두 축에 모두 적용합니다.

xticks / yticks : 각 축의 눈금 값을 지정합니다.

xlim / ylim : 각 축의 값의 경계를 지정합니다.

xlabel / ylabel : 각 축의 라벨을 지정합니다.

rot : 눈금값의 기울기 입니다. 눈금값이 많을경우 유용합니다.

fontsize : 눈금값의 크기 입니다.

colormap / colorbar : 각 값에 대해 matplolib 에서 지원하는 colormap을 적용할 수 있습니다.

table : True면 데이터를 테이블로 출력하며 matplotlib의 기본 레이아웃에 맞게 전치됩니다.

yerr / xerr : 특정 열의 값을 이용하여 오차범위 표현을 할 수 있습니다.

stacked : bar plot이나 barh plot의 경우 막대 그래프를 누적 막대그래프로 표현할 수 있습니다.

sort_columns : 열을 정렬하여 플랏할지 여부입니다.

secondary_y : 보조축 레이블을 출력할지 여부 입니다.

mark_right : 보조축 레이블을 출력할 경우 범례에 "(right)"으로 열 레이블을 표시할지 여부 입니다.

include_bool : bool형식의 값을 플랏할지 여부입니다.

backend : plotting.backend 옵션에 지정된 백엔드 대신 사용할 백엔드. 예를 들어, 'matplotlib'. 또는 전체 세션에 대해 plotting.backend를 지정하려면 pd.options.plotting.backend를 설정할 수 있습니다.

val = np.linspace(0,100,101)
sin = np.sin(np.pi/25*val)
tan = np.tan(np.pi/25*val)
df = pd.DataFrame(data={'val':val,'sin':sin,'tan':tan})
print(df)
>>
       val           sin           tan
0      0.0  0.000000e+00  0.000000e+00
1      1.0  1.253332e-01  1.263294e-01
2      2.0  2.486899e-01  2.567564e-01
3      3.0  3.681246e-01  3.959280e-01
4      4.0  4.817537e-01  5.497547e-01
..     ...           ...           ...
96    96.0 -4.817537e-01 -5.497547e-01
97    97.0 -3.681246e-01 -3.959280e-01
98    98.0 -2.486899e-01 -2.567564e-01
99    99.0 -1.253332e-01 -1.263294e-01
100  100.0  1.286498e-15  1.286498e-15

df2는 df에서 sin, tan값만 추려낸 데이터 입니다.

sin과 tan은 삼각함수로, 각도에 따라 변하는 값을 나타냅니다.

sin은 수직 변의 길이를, tan은 수직 변과 수평 변의 비율을 나타냅니다

sin(사인):

• 직각삼각형에서, 한 각에 대한 수직 변(높이)의 길이를 빗변의 길이로 나눈 값입니다.
• 수직 방향으로 얼마나 떨어져 있는지 나타냅니다.

tan(탄젠트):

• 직각삼각형에서, 한 각에 대한 수직 변(높이)의 길이를 수평 변(밑변)의 길이로 나눈 값입니다.

수직 변과 수평 변의 비율을 나타냅니다.

• 수직 변과 수평 변의 비율을 나타냅니다.

sin 값을 cos 값으로 나눈 것과 같습니다.

• sin 값을 cos 값으로 나눈 것과 같습니다.

df2 = df.loc[:,['sin','tan']]
print(df2)
>>
              sin           tan
0    0.000000e+00  0.000000e+00
1    1.253332e-01  1.263294e-01
2    2.486899e-01  2.567564e-01
3    3.681246e-01  3.959280e-01
4    4.817537e-01  5.497547e-01
..            ...           ...
96  -4.817537e-01 -5.497547e-01
97  -3.681246e-01 -3.959280e-01
98  -2.486899e-01 -2.567564e-01
99  -1.253332e-01 -1.263294e-01
100  1.286498e-15  1.286498e-15

[101 rows x 2 columns]

기본적인 사용법

기본 적인 사용법은 df.plot() 형태 입니다. line 형태로 모든 열을 plot하게 됩니다.

df2.plot()
plt.show()

sin그래프, tan그래프가 출력된 것을 확인할 수 있습니다.

kind, x, y 인수의 사용

kind인수를 통해 원하는 형태의 그래프를 출력 할 수 있으며, x와 y로 해당 그래프의 x와 y를 지정할 수 있습니다.

※ {line / bar / barh / hist / box / kde / density / area / pie / scatter / hexbin}

df.plot(kind='line', x='val', y='sin')
plt.show()

x축의 값은 0~100, y축의 값은 sin값으로 line 을 plot한 것을 확인할 수 있습니다.

ax 인수의 사용

ax인수를 통해 현재 axes값을 별도의 값으로 지정하여 plot에 사용할 수 있습니다.

fig, ax=plt.subplots(2) # 두개의 서브플롯에 ax를 배치하도록 fig를 설정
df.plot(kind='line', x='val', y='sin', ax=ax[0]) # sin그래프를 ax[0]으로 지정
df.plot(kind='line', x='val', y='tan', ax=ax[1]) # tan 그래프를 ax[1]으로 지정
plt.show()

각각의 ax로 구분한 Axes를 2칸짜리 subplot에 배열하여 plot한것을 확인 할 수 있습니다.

subplots 인수의 사용

subplots인수를 사용할 경우 각각의 열을 별도의 axes로 하여 subplot를 생성합니다.

※ 위 ax인수의 예시처럼 fig를 별도의 subplot 개체로 지정할 필요가 없습니다.

df2.plot(subplots=True)
plt.show()

각각의 열이 별도의 subplot에 할당된 것을 확인할 수 있습니다.

sharex / sharey 인수의 사용

subplot을 이용할 경우 두 Axes의 x축이나 y축값을 맞출 수 있습니다.

이때 공유된 축의 경우 한쪽은 보이지 않게 됩니다.

sharex의 기본값은 True로 x축은 맞추게 되고, sharey의 기본값은 False로 y축은 별도로 출력하는것이 기본입니다.

df2.plot(subplots=True, sharex=False, sharey=True) # x축값을 별도로 출력하고 y축값을 공유하도록 변경
plt.show()

x축값이 각각 그래프에 별도로 출력되는것을 확인 할 수 있습니다.

※subplot이 세로로 배열되어있기 때문에, shary=True인데 각각 출력이 됩니다. 가로로 배열되어있는상태라면 출력되지 않습니다.

layout인수의 사용

layout인수를 이용하여 subplot의 배열을 설정할 수 있습니다. 튜플 형태로 값을 입력합니다.

df2.plot(subplots=True, layout=(2,2))
plt.show()

fig가 2x2짜리 subplot으로 설정된 것을 확인할 수 있습니다.

figsize인수의 사용

figsize 인수를 이용해서 figure의 크기를 지정할 수 있습니다. 단위는 inch입니다.

df2.plot(figsize=(10,4))
plt.show()

fig의 크기가 변경된 것을 확인할 수 있습니다.

title / grid 인수의 사용

title인수는 figure의 제목을 설정하고, grid인수는 격자 출력 여부를 설정할 수 있습니다.

df2.plot(title="Pandas plot method", grid=True)
plt.show()

제목이 "Pandas plot method"로 설정되고, 격자가 설정된 것을 확인할 수 있습니다.

linestyle 인수의 사용

linestyle 인수를 지정하여 출력되는 그래프의 선 스타일을 지정할 수 있습니다.

선의 종류에 대해서는 matplotlib 홈페이지 참고 바랍니다.

df2.plot(linestyle='dashed')
plt.show()

선의 종류가 "- -" 형태인 'dashed'로 바뀐것을 확인 할 수 있습니다.

logx / logy / loglog인수의 사용

logs / logy / loglog인수를 이용해 각 축의 표시형식을 log스케일로 변경할 수 있습니다.

loglog인수는 모든 축의 값을 로그스케일로 변경합니다.

df2.plot(logx=True,logy=True) # df2.plot(loglog=True)
plt.show()

각 축의 표기형태가 로그 스케일로 변경된 것을 확인할 수 있습니다.

xticks / yticks 인수의 사용

xticks / yticks 인수에 리스트 형태의 값을 입력하여 특정 눈금의 값을 출력할 수 있습니다.

df.plot(kind='line', x='val',y='sin', xticks=[0,50,100],yticks=[0,0.5,1])
plt.show()

x축의 눈금이 0, 50, 100 만 y축의 눈금이 0, 0.5, 1 만 표시된 것을 확인할 수 있습니다.

xlim / ylim 인수의 사용

xlim / ylim 인수를 사용해 그래프의 출력 범위를 지정할 수 있습니다.

df.plot(kind='line', x='val',y='sin', xlim=[30,80],ylim=[0.25,0.75])
plt.show()

그래프가 x축으로는 3080의 범위가, y 축으로는 0.250.75의 범위가 출력 된 것을 확인할 수 있습니다.

xlabel / ylabel 인수의 사용

xlabel / ylabel 인수를 사용해 각 축의 라벨을 출력할 수 있습니다.

df2.plot(xlabel='Width',ylabel='Height')
plt.show()

각 축의 이름이 출력 된 것을 확인할 수 있습니다.

rot / fontsize 인수의 사용

rot 인수를 이용해 눈금값의 기울기를 지정할 수 있고, fontsize 인수를 통해 눈금값의 크기를 지정할 수 있습니다.

df2.plot(rot=45,fontsize=20)
plt.show()

그래프 눈금값의 기울기가 45도로, 눈금값의 크기가 20으로 변경된 것을 확인할 수 있습니다.

colormap / colorbar 인수의 사용

colormap 은 출력되는 그래프의 값을 특정 색 범위로 표현하는 matplotlib의 기능입니다. colorbar는 색에 해당하는 값의 범위를 막대 형태로 출력하는 기능입니다.

colorbar의 기본값은 True이기 때문에, False로 지정해주어야 출력이 안됩니다.

colorbar를 적용하기 위해서는, 각 값에 대해서 색을 지정해 주어야합니다. c인수에 색의 값을 지정하는 열을 입력하여 가능합니다.

colormap의 종류에 대해서는 matplolib 에서 지원하는 colormap 링크을 참고 바랍니다.

data = {'x_value':[4,7,3,1,2],'y_value':[1,2,3,4,5],'color_bar':[0,1,2,3,4]}#x축에 표시될 값들,y축에 표시될 값들,각 점의 색을 결정할 값 (컬러바)
df3 = pd.DataFrame(data)
df3.plot(kind='scatter',x='x_value',y='y_value',c='color_bar', colormap='cool',colorbar=True) # c인수로 color_bar 열을 지정.
# 산점도 그래프 (scatter plot)로 그림, x축은 'x_value' 열 사용, 축은 'y_value' 열 사용,각 점의 색을 'color_bar' 열 값에 따라 다르게 지정, 색상 맵(colormap) 지정 ('cool'은 보라-청록 계열), 색상 기준을 옆에 colorbar로 시각적으로 표시
plt.show()

c='color_bar'를 통해 색범위를 0~4로 정해주었고, 각 y값에 대해서 색값을 지정해주었습니다.

그에 맞게 colormap과 colorbar가 적용된 것을 확인할 수 있습니다.

position 인수의 사용

position인수는 막대그래프 'bar / barh'에대해서 막대의 위치가 눈금의 위치 {좌측(0), 중(0.5), 우측(1)}를 지정할 수 있습니다.

data = {'x_value':[4,7,3,1,2],'y_value':[1,2,3,4,5],'color_bar':[0,1,2,3,4]}
df3 = pd.DataFrame(data)
fig, ax=plt.subplots(3) # 3칸짜리 subplot을 갖는 fig 개체 설정
df3.plot(kind='bar',x='x_value',y='y_value',position=0,ax=ax[0])
df3.plot(kind='bar',x='x_value',y='y_value',position=0.5,ax=ax[1])
df3.plot(kind='bar',x='x_value',y='y_value',position=1,ax=ax[2])
plt.show()

각각 그래프에서 눈금의 위치와 막대 그래프의 위치를 비교해보면 position인수가 어떻게 적용되는지 확인할 수 있습니다.

xerr / yerr인수의 사용

xerr / yerr인수는 특정 축을 기존그래프의 오차범위로 설정하는 인수 입니다.

data = {'x_value':[1,2,3,4,5],'y_value':[2,5,3,7,1],'err':[0.1,0.3,0.6,1.0,0.1]}
df4 = pd.DataFrame(data)
fig, ax=plt.subplots(2)
df4.plot(kind='bar',x='x_value',y='y_value',yerr='err',ax=ax[0])
df4.plot(kind='barh',x='x_value',y='y_value',xerr='err',ax=ax[1])
plt.show()

기존 x_value / y_value 막대그래프에 대해서 작은 선 형태로 err 열이 오차범위로써 덧 씌워진 것을 확인할 수 있습니다.

stacked 인수의 사용

막대그래프의 경우 값이 여러개라면 stacked인수를 통해 누적 막대그래프의 형태로 변환이 가능합니다.

data = {'x_value':[1,2,3,4,5],'y_value':[2,5,3,7,1],'err':[0.1,0.3,0.6,1.0,0.1]}
df4 = pd.DataFrame(data)
df4.plot(kind='bar',x='x_value',y=['y_value','err'],stacked=True)
plt.show()

y의 값을 리스트 형태로 두 컬럼을 입력하여 두 막대그래프를 출력하도록 한 다음 stacked=True로 하여 누적 막대그래프가 된 것을 확인할 수 있습니다.

secondary_y 인수의 사용

두 그래프를 출력 할 경우 한 Axes를 다른 Axes에 종속시킴으로서 종속된 Axes를 secondary_y 인수를 이용해 보조 축으로 표현할 수 있습니다.

data = {'x_value':[1,2,3,4,5],'y_value':[2,5,3,7,1],'err':[0.1,0.3,0.6,1.0,0.1]}
df4 = pd.DataFrame(data)
ax1 = df4.plot(x='x_value',y='y_value',color='Red',) # y_value를 ax1로
ax2 = df4.plot(x='x_value',y='err',ax=ax1,secondary_y=True) # err을 ax2로하여 ax1에 종속 및 보조축 설정
ax1.set_ylabel('y_value') # 라벨 설정
ax2.set_ylabel('err')

ax1를 생성하고 ax2를 ax1에 종속시키면서 secondary_y=True로 하여 우측에 보조축이 생성된 것을 확인할 수 있습니다.

x,y축 지정 (area / bar / barh / line)

val = np.linspace(0,100,101)
sin = np.sin(np.pi/25*val)+1
cos = np.cos(np.pi/25*val)+1
df = pd.DataFrame(data={'val':val,'sin+1':sin,'cos+1':cos})
print(df)
>>
       val     sin+1     cos+1
0      0.0  1.000000  2.000000
1      1.0  1.125333  1.992115
2      2.0  1.248690  1.968583
3      3.0  1.368125  1.929776
4      4.0  1.481754  1.876307
..     ...       ...       ...
96    96.0  0.518246  1.876307
97    97.0  0.631875  1.929776
98    98.0  0.751310  1.968583
99    99.0  0.874667  1.992115
100  100.0  1.000000  2.000000

기본적인 사용법

plot.[area / bar / barh / line] 메서드는 반드시 x축과 y축(값)을 지정해주어야 합니다.

area메서드의 사용

plot.area 메서드는 데이터를 면적 그래프의 형태로 반환합니다. 기본적으로 stacked=True 이므로, 면적이 누적되는 형태로 출력됩니다.

df.plot.area(x='val',y=['sin+1','cos+1'],stacked=True) #stacked=True는 기본값
#sin과 cos 사인은 -1~+1까지 나타내기 때문에 1부터 시작하기 위헤서 1을 더한거다
plt.show()

stacked=False인 경우 면적이 겹치는것을 시각화 하여 보여줍니다.

df.plot.area(x='val',y=['sin+1','cos+1'],stacked=False)
plt.show()

bar / barh 메서드의 사용

plot.bar / plot.barh는 각각 세로 막대그래프, 가로 막대 그래프를 반환합니다.

df.plot.bar(x='val',y=['sin+1','cos+1'])#plot.bar 세로 막대그래프
plt.show()

df.plot.barh(x='val',y=['sin+1','cos+1'])#가로 막대그래프
plt.show()

line 메서드의 사용

plot.line 메서드는 선형 그래프를 반환합니다.

df.plot.line(x='val',y=['sin+1','cos+1'])#선형 그래프
plt.show()

x,y축, c값 지정 (hexbin / scatter)

x / y : 각 축으로 설정할 값(컬럼명) 입니다.

c : 각 값에 대한 colorbar의 값을 지정할 수 있습니다.

kwargs : 그 외에 matplotlib 중 plot에서 지원하는 인수의 사용이 가능합니다.

먼저 기본적인 사용법 예시를위하여 데이터를 만들어 보겠습니다.

df는 크기 10000짜리 가우시안 표준 정규분포 x와 y, 그리고 0~10까지의 난수를 갖는 1000개짜리 c열 의 데이터입니다.

df = pd.DataFrame({'x':np.random.randn(10000),
                   'y':np.random.randn(10000),
                   'c':np.random.randint(0,10,size=10000)})
>>
             x         y  c
0     0.987301  0.239920  4
1    -0.466582  0.432507  4
2     0.462679  0.869407  7
3     0.547113 -1.123641  8
4     0.046728 -1.220947  6
...        ...       ... ..
9995  0.241341 -0.598799  0
9996 -1.694559  1.428881  5
9997  0.929081 -1.504374  9
9998  1.561134  1.445425  5
9999  2.113502  0.611024  7

[10000 rows x 3 columns]

기본적인 사용법

plot.[hexbin / scatter]] 메서드는 반드시 x축과 y축(값)을 지정해주어야 합니다. (colormap은 자동으로 지정되며, c는 선택)

hexbin메서드의 사용

hexbin 메서드는 육각형의 그리드형태로 값을 반환하는 그래프 입니다. gridsize 인수 는 x축 기준 그리드 한칸의 크기를 의미합니다.

colormap 인수는 자동 지정되나, 원하는 colormap으로 지정이 가능합니다.

df.plot.hexbin(x='x',y='y',gridsize=20,colormap='viridis')
plt.show()

C 인수의 사용

C 인수를 통해 colormap 기준으로 각 값이 colorbar에서 어떤 값을 취할지 지정할 수 있습니다.

df.plot.hexbin(x='x',y='y',gridsize=20,colormap='jet',C='c')
plt.show()

reduce_C_function 인수의 사용

reduce_C_function 인수는 colorbar의 값에 대해서 그래프의 bin(한칸의 가로사이즈)에 속하는 값들이 하나의 대표값으로 통일하게 해주는 np 메서드를 지정하는 인수입니다.

df.plot.hexbin(x='x',y='y',gridsize=20,colormap='cool',C='c',reduce_C_function=np.max)
plt.show()

colorbar에 대해서 한 bin의 값들이 해당값의 max값으로 통일 되어 반환되는것을 확인 할 수 있습니다.

scatter메서드의 사용

scatter는 점산도 그래프를 반환하는 메서드입니다.

s인수는 점의 크기를 스칼라값으로 지정 가능하며, c인수를 통해 각 값이 colorbar에서 어떤 값을 취할지 지정 가능합니다.

df.plot.scatter(x='x',y='y',s=3,c='c',colormap='viridis')
plt.show()

축 설정 불필요 (box / hist / pie)

data = np.random.randn(100,2)
df = pd.DataFrame(data, columns = ['x','y'])
print(df)
>>
           x         y
0   1.476916 -1.549051
1   0.156672  1.601624
2   0.493568  0.096696
3  -0.550939  0.200391
4   0.885276  0.613648
..       ...       ...
95 -0.048403  2.432448
96  0.020946  0.900305
97  0.128520  0.514659
98  0.369856  1.519807
99  0.928380  0.105314

[100 rows x 2 columns]

기본적인 사용법

plot.[box / hist / pie]] 메서드는 각 열의 데이터를 가져오기 때문에 x축, y축등을 지정해 줄 필요가 없습니다.

box메서드의 사용

box 메서드의 경우 boxplot을 출력합니다.

df.plot.box메서드는 df.boxplot메서드와 동일한 기능을 수행합니다.

data = np.random.randn(100,2)
df = pd.DataFrame(data, columns = ['x','y'])
df.plot.box()
plt.show()

hist 메서드의 사용

hist 메서드의 경우 histogram을 출력합니다. bins 인수를통해 막대 하나의 크기를 정할 수 있으며, alpha를 통해 투명도를 설정할 수 있습니다.

df.plot.hist메서드는 df.hist메서드와 동일한 기능을 수행합니다.

data = np.random.randn(100,2)
df = pd.DataFrame(data, columns = ['x','y'])
df.plot.hist(bins=20,alpha=0.5,color=['green','blue']) # bins로 막대 크기20, alpha로 투명도 0.5, 색은 초록-파랑 설정
plt.show()

pie 메서드의 사용

pie메서드는 원형 그래프를 출력하는 메서드 입니다. 열의 갯수만큼의 원형그래프가 생성되므로 서브플롯을 설정해주어야합니다.

data = {'x':[3,7,9],'y':[2,6,3]}
idx = ['A','B','C']
df = pd.DataFrame(data=data, index= idx)
df.plot.pie(subplots=True)
plt.show()

커널밀도추정 그래프 (kde / density)

bw_method : 대역폭을 지정합니다. 대역폭이 작을수록 더 자세한 smoothing이 가능하고, 대역폭이 크면 러프한 smoothing이 수행됩니다.

ind : 예상 PDF에 대한 평가 포인트입니다. 기본값은 1000개의 타점이며, numpy array나 리스트형태로 입력 할 경우 해당 포인트로 계산이 수행됩니다.

kwargs : matplotlib 중 plot에서 지원하는 인수의 사용이 가능합니다.

예시

먼저 기본적인 사용법 예시를위하여 데이터를 만들어 보겠습니다.

df는 크기 1000짜리 가우시안 표준 정규분포 value열의 데이터입니다.

data = np.random.randn(1000,1)
df = pd.DataFrame(data,columns=['value'])
print(df)
>>
        value
0   -0.307367
1    0.310514
2    1.135779
3   -0.584566
4    0.859781
..        ...
995  0.449085
996 -0.513770
997 -0.782740
998  1.250284
999  0.566071

[1000 rows x 1 columns]

기본적인 사용법

커널밀도추정(KDE)는 간단히 말하면 데이터의 histogram을 smoothing하는 것이라고 볼 수 있습니다.(실제로는 더 복잡한 의미를 가집니다.)

50bin 짜리 histogram과 함께 kde 메서드를 수행해서 비교해보겠습니다.

data = np.random.randn(1000,1)
df = pd.DataFrame(data,columns=['value'])
ax = df.plot.hist(bins=50)
df.plot.kde(ax=ax,secondary_y=True)
plt.show()

bw_method 인수의 사용

bw_method 인수를이용해 대역폭(bandwidth)를 설정할 수 있습니다. bw_method가 작을수록 더욱 세부적인 계산이 수행됩니다.

data = np.random.randn(1000,1)
df = pd.DataFrame(data,columns=['value'])
ax = df.plot.hist(bins=50)
df.plot.kde(ax=ax,secondary_y=True,bw_method=0.1)
df.plot.kde(ax=ax,secondary_y=True,bw_method=3)
plt.show()

주황색 line의 0.1짜리 대역폭과, 녹색 line의 3짜리 대역폭의 차이점을 볼 수 있습니다.

ind 인수의 사용

ind 인수를 통해 계산이 수행되는 지점을 지정할 수 있습니다.

data = np.random.randn(1000,1)
df = pd.DataFrame(data,columns=['value'])
ax = df.plot.hist(bins=50)
df.plot.kde(ax=ax,secondary_y=True)
df.plot.kde(ax=ax,secondary_y=True,ind=[-6,-4,-2,0,2,4,6],color='red')
plt.show()

붉은색 line이 특정 지점을 기준으로 계산 된 것을 확인 할 수 있습니다.

간단한 문제 풀이

DataFrame.groupby max, min

위 데이터프레임에서 테마별 PER, PBR의 최대, 최소값을 계산하세요.

data = [
    ["2차전지(생산)", "SK이노베이션", 10.19, 1.29],
    ["해운", "팬오션", 21.23, 0.95],
    ["시스템반도체", "티엘아이", 35.97, 1.12],
    ["해운", "HMM", 21.52, 3.20],
    ["시스템반도체", "아이에이", 37.32, 3.55],
    ["2차전지(생산)", "LG화학", 83.06, 3.75]
]

columns = ["테마", "종목명", "PER", "PBR"]
df = pd.DataFrame(data=data, columns=columns)
print(df)
         테마      종목명    PER   PBR
0  2차전지(생산)  SK이노베이션  10.19  1.29
1        해운      팬오션  21.23  0.95
2    시스템반도체     티엘아이  35.97  1.12
3        해운      HMM  21.52  3.20
4    시스템반도체     아이에이  37.32  3.55
5  2차전지(생산)     LG화학  83.06  3.75

#

#정답

df.groupby(by="테마").max()
df.groupby(by="테마").min()
>>
    종목명    PER    PBR
테마            
2차전지(생산)    LG화학    10.19    1.29
시스템반도체    아이에이    35.97    1.12
해운    HMM    21.23    0.95

#2번정답

df.groupby(by="테마").size()
df.groupby(by="테마").size()
>>
0
테마    
2차전지(생산)    2
시스템반도체    2
해운    2

dtype: int64
#3번정답
df.groupby(by="테마").get_group("2차전지(생산)")
>>
테마    종목명    PER    PBR
0    2차전지(생산)    SK이노베이션    10.19    1.29
5    2차전지(생산)    LG화학    83.06    3.75

#4번정답
찐 df.groupby("테마")[["PER"]].mean()
df.groupby(by="테마").mean("PER","PBR")
>>
    PER    PBR
테마        
2차전지(생산)    46.625    2.520
시스템반도체    36.645    2.335
해운    21.375    2.075
#5번정답
df.groupby("테마")[["PER", "PBR"]].mean()
>>

PER    PBR
테마        
2차전지(생산)    46.625    2.520
시스템반도체    36.645    2.335
해운    21.375    2.075

to_dict 메서드는 데이터프레임 객체를 dict 형태로 변환하는 메서드 입니다.

orient : 출력할 dict의 형태를 지정합니다. 형태는 아래와 같습니다.

dict : {열 : {행 : 값, 행 : 값}, 열 : {행 : 값, 행 : 값}

list : {열 : [ 값 ], 열 : [ 값 ] }

series : {열 : Series, 열 : Series}

split : { index : [ 행, 행 ], columns : [ 열, 열 ], data : [ 값, 값 ] }

records : [ { 열 : 값 , 열 : 값 }, { 열 : 값, 열 : 값 } ]

index : { 행 : {열 : 값, 열 : 값}, 행 : {열 : 값, 열 : 값} }

into : 반환값의 모든 매핑에 사용되는 collections.abc.Mapping 하위클래스입니다.

Copydf = pd.DataFrame([[1,2],[3,4]], columns=['col1','col2'],index=['row1','row2'])
print(df)
>>
      col1  col2
row1     1     2
row2     3     4

orient 인수를 설정함으로써 출력되는 dict객체의 형태를 정할 수 있습니다.

orient = 'dict'인 경우 {열 : {행 : 값, 행 : 값}, 열 : {행 : 값, 행 : 값} 형태로 변환합니다.

print(df.to_dict(orient='dict'))
>>
{'col1': {'row1': 1, 'row2': 3}, 'col2': {'row1': 2, 'row2': 4}}

orient = 'list'인 경우 {열 : [ 값 ], 열 : [ 값 ] } 형태로 변환합니다.

print(df.to_dict(orient='list'))
>>
{'col1': [1, 3], 'col2': [2, 4]}

orient = 'series'인 경우 {열 : Series, 열 : Series} 형태로 변환합니다.

print(df.to_dict(orient='series'))
>>
{'col1': row1    1
row2    3
Name: col1, dtype: int64, 'col2': row1    2
row2    4
Name: col2, dtype: int64}

orient = 'split'인 경우 { index : [ 행, 행 ], columns : [ 열, 열 ], data : [ 값, 값 ] } 형태로 변환합니다.

print(df.to_dict(orient='split'))
>>
{'index': ['row1', 'row2'], 'columns': ['col1', 'col2'], 'data': [[1, 2], [3, 4]]}

orient = 'records'인 경우 [ { 열 : 값 , 열 : 값 }, { 열 : 값, 열 : 값 } ] 형태로 변환합니다.

print(df.to_dict(orient='records'))
>>
[{'col1': 1, 'col2': 2}, {'col1': 3, 'col2': 4}]

orient = 'index'인 경우 { 행 : {열 : 값, 열 : 값}, 행 : {열 : 값, 열 : 값} } 형태로 변환합니다.

Copyprint(df.to_dict(orient='index'))
>>
{'row1': {'col1': 1, 'col2': 2}, 'row2': {'col1': 3, 'col2': 4}}

Markdown으로 변환 (to_markdown)

마크다운은 노션에 쓴다

buf : 쓸 버퍼입니다. 입력하지 않으면 문자열이 반환됩니다.

mode : 파일을 열때 모드입니다. 기본값은 'wt'입니다.

index : 인덱스를 출력할지 여부입니다. 기본값은 True입니다.

storage_options : 특정 스토리지 연결에 적합한 추가 옵션을 지정합니다. (예 : 호스트, 포트, 사용자 이름, 비밀번호 등)

kwargs : 추가 적용 가능한 tabulate의 키워드입니다.

df = pd.DataFrame([[1,2],[3,4]], columns=['col1','col2'],index=['row1','row2'])
print(df)
>>
      col1  col2
row1     1     2
row2     3     4

print(df.to_markdown())
>>
|      |   col1 |   col2 |
|:-----|-------:|-------:|
| row1 |      1 |      2 |
| row2 |      3 |      4 |

실제 Markdown으로 출력시 아래와 같이 출력 됩니다.

| | col1 | col2 | |:-----|-------:|-------:| | row1 | 1 | 2 | | row2 | 3 | 4 |

index인수의 사용

index=False로 입력할 경우 인덱스가 제외됩니다.

print(df.to_markdown(index=False))
>>
|   col1 |   col2 |
|-------:|-------:|
|      1 |      2 |
|      3 |      4 |

string으로 변환(to_string)

buf : 저장할 버퍼 입니다. None이면 문자열로 출력됩니다.

columns : 출력할 열을 지정합니다.

col_space : 열 너비를 지정합니다. .

header / index : 열/행 레이블의 출력 여부 입니다. False이면 출력하지 않습니다.

리스트 형태로 입력하여 레이블명의 변경이 가능합니다.

na_rep : 결측값의 표현 방식 입니다.

formatters : 포매터 함수를 통해 값의 포맷을 설정합니다. .format() 메서드도 사용 가능합니다.

float_format : 소수점 단위 자리수를 지정합니다. 기본은 마침표( . ) 입니다.

sparsify : 각 행의 모든 다중 인덱스 키를 인쇄하려면 계층적 인덱스가 있는 DataFrame에 대해 False로 설정합니다.

index_names : 인덱스명을 출력할지를 정합니다.

justify : 정렬 방식을 지정합니다.

maxrows : 최대 출력할 줄 수를 지정합니다. 초과되는 줄은 ( ... )형태로 축약됩니다.

maxcols : 최대 출력할 열 수를 지정합니다. 초과되는 줄은 ( ... )형태로 축약됩니다.

show_dimensions : 출력된 html 객체 아래에 데이터 객체의 차원을 출력합니다.

decimal : 1000단위 구분기호로 인식되는 문자를 지정합니다.

linewidth : 문자로 줄바꿈할 너비 입니다.

minrow : maxrows로인해 잘린 표현을 표시할 수 입니다.

max_colwidth : 각 열을 문자열로 자르기 위한 최대 너비입니다. 기본값은 무제한 입니다.

encoding : 인코딩을 지정합니다.

예시

먼저 기본적인 사용법 예시를위하여 3x2 데이터를 만들어 보겠습니다.

data = [[1,np.NaN],['A',4.179],['<&>',32000]]
df = pd.DataFrame(data,columns=['col1','col2'])
df=df.rename_axis(columns='index')
print(df)
>>
index col1       col2
0        1        NaN
1        A      4.179
2      <&>  32000.000

columns 인수의 사용

columns 인수를 입력하여 특정 열만 출력이 가능합니다. list 형태로 입력하여야합니다

print(df.to_string(columns=['col2'])) # col2만 출력
>>
index       col2
0            NaN
1          4.179
2      32000.000

col_space 인수의 사용

col_space 인수를 입력하여 열 너비를 지정할 수 있습니다.

print(df.to_string(col_space=[10,20]))#열 너비를 지정해준다
>>
index       col1                 col2
0              1                  NaN
1              A                4.179
2            <&>            32000.000

header 인수의 사용

header 인수를 입력하여 열 이름을 지정할 수 있습니다. True 나 False, None를 입력하여 출력 여부를 설정할 수도 있습니다.

print(df.to_string(header=['val1','val2']))#col1 col2를 val1,2으로 바꿧습니다
>>
index val1       val2
0        1        NaN
1        A      4.179
2      <&>  32000.000

index인수의 사용

index 인수를 이용해 index의 출력 여부를 정할 수 있습니다.

print(df.to_string(index=False))#인덱스의 출력여부
>>
col1      col2
   1       NaN
   A     4.179
 <&> 32000.000

na_rep 인수의 사용

na_rep인수를 입력하여 결측치(NaN등)의 표현값을 변경할 수 있습니다.

print(df.to_string(na_rep='결측'))#결측치 값을 변경한다
>>
index col1       col2 # 결측치가 '결측' 으로 변경
0        1         결측
1        A      4.179
2      <&>  32000.000

index_names인수의 사용

index_names를 설정함으로서 인덱스명의 출력 여부를 정할 수 있습니다. 기본값은 True입니다.

`justify` 인수를 사용해 인덱스를 정렬할 수 있습니다.
사용 가능한 값 : {left / right / center / justify / justify-all / start / end / inherit / match-parent / initial / unset}
>>
index col1  col2      #인덱스가 왼쪽 정렬되어서 붙어 있는걸 알 수 있음
0        1        NaN
1        A      4.179
2      <&>  32000.000

max_raws / max_cols 인수의 사용

max_raws / max_cols 인수를 사용해 출력할 최대 행/열 수를 지정할 수 있습니다. 초과분은 ( ... )로 함축되어 표현됩니다.

print(df.to_string(max_rows=2))#2행만 출력되면서 1행이 ...으러 함축되어 표현됨
>>
index col1     col2
0        1      NaN
..     ...      ...
2      <&>  32000.0

print(df.to_string(max_cols=1))
>>
index col1  ...
0        1  ...
1        A  ...
2      <&>  ...

show_dimensions인수의 사용

show_dimensions인수를 이용하여 데이터의 차원을 출력할 수 있습니다.

print(df.to_string(show_dimensions=True))
>>
index col1       col2
0        1        NaN
1        A      4.179
2      <&>  32000.000

[3 rows x 2 columns] # 데이터의 차원이 출력됨, 3행 * 2

decimal 인수의 사용

decimal인수를 사용하여 1000단위 표현값을 지정할 수 있습니다. 기본값은 콤마( , ) 입니다.

print(df.to_string(decimal='_'))
>>
index col1       col2
0        1        NaN
1        A      4_179
2      <&>  32000_000 # 1000단위 표현값이 .에서 _로 바

line_width인수의 사용

linde_width인수값을 입력하여 줄바꿈할 열의 너비를 지정할 수 있습니다.

print(df.to_string(line_width=2))
>>
index col1  \ #줄바꿈이 진행되면서 \로 줄바꿈이 된걸 표현함
0        1
1        A
2      <&>

index       col2   # 줄바꿈이 진행됨.
0            NaN
1          4.179
2      32000.000

max_colwidth인수의 사용

max_colwidth 인수를 이용하여 열 내의 문자열 길이를 제한할 수 있습니다. 초과하는 문자는 ( ... ) 으로 함축됩니다.

print(df.to_string(max_colwidth=5))
>>
index col1  col2
0        1   NaN
1        A  4...
2      <&>  3... # 길이 5이상을 함축함

numpy로 변환 (values)

col1 = [1, 2, 3, 4]
col2 = ['one', 'two', 'three', 'four']
col3 = [1.5, 2.5, 3.5, 4.5]
col4 = [True, False, False, True]
index = ['row1','row2','row3','row4']
df = pd.DataFrame(index=index, data={"col1": col1, "col2": col2, "col3": col3, "col4": col4})
print(df)
>>
      col1   col2  col3   col4
row1     1    one   1.5   True
row2     2    two   2.5  False
row3     3  three   3.5  False
row4     4   four   4.5   True

여기에 values함수를 적용할 경우 아래와 같은 결과가 반환됩니다

numpy.ndarray형태로

반환되며, 레이블이 사라진것을 확인할 수 있습니다.

dict에서 변환 (from_dict)

data : dict 형태의 데이터 입니다.

orient : {index / columns / tight} 변환 방식입니다. index은 행을 키값으로 지정, columns는 열을 키값으로 지정, tight는 키값으로 [index / columns / data / index_names / columns_names] 를 가집니다.

dtype : 데이터의 type을 강제로 지정할 수 있습니다.

columns : index인수를 사용할 경우 columns인수를 통해 열 이름을 지정할 수 있습니다.

Copydata = {'col1':[1,3],'col2':[2,4]}
df = pd.DataFrame.from_dict(data=data, orient='columns')
print(df)
>>
   col1  col2
0     1     2
1     3     4

orient인수의 기본값은 'columns'로 키값으로 열 이름을 사용하게 됩니다.

data = {'col1':[1,3],'col2':[2,4]}
df = pd.DataFrame.from_dict(data=data, orient='columns')
print(df)
>>
   col1  col2
0     1     2
1     3     4

orient인수가 'index'인 경우 키 값으로 행 이름을 사용하게 됩니다.

data = {'row1':[1,2],'row2':[3,4]}
df = pd.DataFrame.from_dict(data=data, orient='index')
print(df)
>>
      0  1
row1  1  2
row2  3  4

orient인수가 'index'인 경우 columns인수를 통해 열 이름을 추가로 설정할 수 있습니다.

data = {'row1':[1,2],'row2':[3,4]}
df = pd.DataFrame.from_dict(data=data, orient='index', columns=['col1','col2'])
print(df)
>>
      col1  col2
row1     1     2
row2     3     4

dtype 인수를 이용하면 값의 type을 강제로 지정할 수 있습니다.

data = {'row1':[1,2],'row2':[3,4]}
df = pd.DataFrame.from_dict(data=data, orient='index', columns=['col1','col2'],dtype='float')
print(df)
>>
      col1  col2
row1   1.0   2.0
row2   3.0   4.0
# float type으로 변경된 것을 확인할 수 있습니다.

orient='tight'인 경우 'index' / 'columns' / 'data' / 'index_names' / 'column_names'를 키 값으로 지정하여 세부내용을 설정 할 수 있습니다.

※1.4.0 버전부터만 사용 가능합니다.

data =  {'index'        : [('idx1','row1'),('idx1','row2')], # 인덱스 이름 설정, 멀티 인덱스 가능
         'columns'      : [('col1','val1'),('col2','val2')], # 열 이름 설정, 멀티 컬럼 가능
         'data'         : [[1,2],[3,4]], # 데이터 값 설정
         'index_names'  : ['I1','I2'], # 인덱스명 설정
         'column_names' : ['C1','C2']} # 컬럼명 설정
df = pd.DataFrame.from_dict(data=data, orient='tight')
print(df)
>>
C1        col1 col2
C2        val1 val2
I1   I2
idx1 row1    1    2
     row2    3    4

data = {'col1':[1,2],'col2':[3,4]}
df = pd.DataFrame(data = data)
print(df)
>>
   col1  col2
0     1     3
1     2     4

기본적인 사용법

기본적으로 df.__iter__( ) 형태로 사용하며, 열 인덱스의 map 오브젝트를 반환합니다.

df2 = df.__iter__()
print(df2)
>>
<map object at 0x000001CAFD121D00>

map 오브젝트는 range함수처럼 하나씩 꺼내서 쓰는형태이기 때문에 단순 print로는 출력이 불가합니다.

반복자 (iterator)이기 때문에 next 메서드를 통해 하나씩 확인할 수 있습니다.

print(next(df2))
>>
col1

print(next(df2))
>>
col2

list 메서드를 이용하면 리스트 형태로 반환이 가능합니다.

print(list(df))
>>
['col1', 'col2']

열과 내용의 반복자 반환 (items, iteritems)

data = {'col1':[1,2],'col2':[3,4]}
idx = ['row1','row2']
df = pd.DataFrame(data = data, index=idx)
print(df)
>>
      col1  col2
row1     1     3
row2     2     4

기본적인 사용법

기본적으로 df.items() 형태로 사용하며, 출력 시 generator 객체인 것을 확인 할 수 있습니다.

df2 = df.items()
print(df2)
>>
<generator object DataFrame.items at 0x000001E83178D430>

generator 역시 iterator(반복자) 로 for문이나 list로 내용을 확인 할 수 있습니다.

df2 = df.items()
for iin df2:
    print("="*10)
    print(i)
>>
==========
('col1', row1    1
row2    2
Name: col1, dtype: int64)
==========
('col2', row1    3
row2    4
Name: col2, dtype: int64)

# 튜플 형태로 (열이름, 내용의 Series객체)출력됨

for문을 한번 더 사용해서 튜플의 내용을 한 줄마다 출력하면 보다 더 직관적으로 확인할 수 있습니다.

df2 = df.items()
for iin df2:
    print("="*30)
for jin i:
        print(j)
>>
==========
col1
row1    1
row2    2
Name: col1, dtype: int64
==========
col2
row1    3
row2    4
Name: col2, dtype: int64

행과 내용의 반복자 반환 (iterrows)

data = {'col1':[1,2],'col2':[3,4]}
idx = ['row1','row2']
df = pd.DataFrame(data = data, index=idx)
print(df)
>>
      col1  col2
row1     1     3
row2     2     4

기본적인 사용법

기본적으로 df.iterrows() 형태로 사용하며, 출력 시 generator 객체인 것을 확인 할 수 있습니다.

df2 = df.iterrows()
print(df2)
>>
<generator object DataFrame.iterrows at 0x0000027666A4C430>

generator 역시 iterator(반복자) 로 for문이나 list로 내용을 확인 할 수 있습니다.

df2 = df.iterrows()
for iin df2:
    print("="*30)
    print(i)
>>
==============================
('row1', col1    1
col2    3
Name: row1, dtype: int64)
==============================
('row2', col1    2
col2    4
Name: row2, dtype: int64)

for문을 한번 더 사용해서 튜플의 내용을 한 줄마다 출력하면 보다 더 직관적으로 확인할 수 있습니다.

Copydf2 = df.iterrows()
for iin df2:
    print("=" * 30)
for jin i:
        print(j)
>>
==============================
row1
col1    1
col2    3
Name: row1, dtype: int64
==============================
row2
col1    2
col2    4
Name: row2, dtype: int64

튜플형태 반복자 반환(itertuples)

print(df.itertuples())
>>
<map object at 0x0000027D368BCE80>

list를 이용해 출력해보면, 구성이 튜플(인덱스, 열=값, 열=값...) 형태인 것을 확인할 수 있습니다.

print(list(df.itertuples()))
>>
[Pandas(Index='row1', col1=1, col2=3), Pandas(Index='row2', col1=2, col2=4)]

index인수의 사용

index=False로 입력할 경우 반환되는 튜플값에서 인덱스 정보가 제외됩니다.

print(list(df.itertuples(index=False)))
>>
[Pandas(col1=1, col2=3), Pandas(col1=2, col2=4)]

name인수의 사용

name인수를 지정해주면, 튜플이 namedtuple 형태로 반환됩니다. 기본값은 Pandas이며 None 입력시 일반 튜플로 반환합니다.

print(list(df.itertuples(name=None)))#기본
>>
[('row1', 1, 3), ('row2', 2, 4)] #일반 튜플로 반환

print(list(df.itertuples(name="테스트")))
>>
[테스트(Index='row1', col1=1, col2=3), 테스트(Index='row2', col1=2, col2=4)] # 지정된 name으로 namedtuple 반환

csv으로 변환 (to_csv)

path_or_buf : csv파일이 생성되는 경로와 파일명 입니다.

sep : csv 파일의 구분자 입니다. 기본값은 ' , ' 입니다.

na_rep : 결측값을 어떻게 출력할지 지정할 수 있습니다. 기본값은 공백 입니다.

float_format : 부동소수점의 경우 어떤 형식으로 출력할지 지정할 수 있습니다.

columns : 출력할 열을 지정하는 인수 입니다.

header : 열 이름을 설정합니다. False일 경우 열 이름을 출력하지 않습니다.

index : 인덱스의 출력 여부 입니다. False일 경우 인덱스를 출력하지 않습니다.

index_label : 인덱스의 레이블(인덱스명)을 설정합니다.

mode : {'w' / 'a'} 쓰기 모드를 지정합니다. a로 지정할 경우 기존 파일 아래에 값을 추가하여 입력하게됩니다.

encoding : 인코딩 설정입니다. 기본값은 utf-8입니다.

compression : {‘infer’, ‘gzip’, ‘bz2’, ‘zip’, ‘xz’, None} 압축 설정을 지정합니다. 기본값은 'infer'로 적절한 압축형식을 추론합니다.

quoting : 값에 대해서 인용구 설정을 할 수 있습니다. 어떤 값에 대해서 인용구를 설정할지는 아래와 같습니다.

{0 : MINIMAL 문자와 특수문자 / 1 : ALL 모든필드 / 2 : NONNUMERIC 숫자가 아닌것 / 3 : NONE 안함}

quotechar : quoting에서 지정한 인용구에 대해서 인용구에 사용할 문자를 지정합니다. 기본값은 쌍따옴표 입니다.

chunksize : 한번에 불러올 행의 수를 지정합니다. 예를들어 100을 입력할 경우 한번에 100행씩 변환합니다. 속도 향상에 기여합니다.

date_format : 값이 시계열(datetime) 데이터인 경우 그 값의 포맷을 지정합니다.(예 : '%Y-%m')

doublequoto : 값중에 quotechar과 같은 값이 있을때, 그 값을 인용구 처리할지의 여부 입니다.

escapechar : doublequoto=False인 경우 인용구와 중복되는 그 값을 어떤 값으로 변경할지 여부입니다.

decimal : 자리수로 쓰이는 문자를 지정합니다.즉, 100,000의 경우 decimal="."으로 할 경우100.000으로 표시합니다.

errors : 인코딩 오류에 대해서 오류 처리를 정할 수 있습니다. 가능한 값은 아래와 같습니다.

{strict : 인코딩 오류에 ValueError 발생 / ignore : 무시 / replace 잘못된 데이터를 대체마커 '?' 지정 / ...}

더 많은 값에 대해서는 python library 의 strict 문서 참고 바랍니다.

storage_options : 특정 스토리지 연결에 적합한 추가 옵션, 예: 호스트, 포트, 사용자 이름, 비밀번호 등을 지정합니다.

CSV는 "Comma-Separated Values"의 약자로, 쉼표로 구분된 값들이라는 뜻입니다. CSV 파일은 엑셀처럼 표 형태의 데이터를 저장하는 텍스트 파일입니다. 각 줄은 하나의 행(row)을 나타내고, 쉼표(,)로 나뉜 각 값은 열(column)을 나타냅니다.

먼저 기본적인 사용법 예시를위하여 3x2 짜리 데이터를 만들어 보겠습니다.

data = [[1,np.NaN],['A',4.1],['-','3']]
df = pd.DataFrame(data)
#address = 'C:\\Users\\lifcr\\OneDrive\\바탕 화면\\pandas\\' #기본 경로 설정해줌(코딩이 길어지므로) colab에서 실행하면 굳아 지정해줄 필요가 없음
>>
   0    1
0  1  NaN # 결측치 NaN 포함
1  A  4.1 # 문자 A, 부동소수점 4.1 포함
2  -    3 # 문자 - 포함

기본적으로 path_or_buf에 경로와 파일 이름을 지정해주면, 해당 경로에 df가 변환된 csv파일이 생성됩니다.

df.to_csv(path_or_buf='test1.csv')

sep 인수는 csv파일의 구분자를 설정해 줍니다. 기본값은 쉼표(,)입니다.

Copydf.to_csv(path_or_buf=address+'test2.csv', sep='-')#쉼표들을 -로 대체해줍니다

>>
-0-1
0-1-
1-A-4.1
2-"-"-3
=
         -0-1#col
row 0-1-nan
        1-A-4.1
        2-"-"-3

na_rep인수는 데이터의 결측값(NaN)을 어떤 값으로 출력할지를 지정할 수 있습니다.

df.to_csv(path_or_buf='test3.csv', na_rep=100)#결측값을 100으로 지정해서 출력함

>>
,0,1
0,1,100
1,A,4.1
2,-,3

float_format인수는 부동소수점 형식 데이터의 출력 포맷을 설정할 수 있습니다.

만약 값으로 그냥 string 형태의 값을 입력할 경우 해당 값이 출력됩니다.

df.to_csv(path_or_buf='test4.csv', float_format='%.2f')
,0,1
0,1,
1,A,4.1 #원래 4.10이 출력되어야 하는데 소수점0이라서 그냥 무시하는거 같음
2,-,3

columns인수는 출력할 대상 열을 지정하는 인수입니다. 따로 입력하지 않는경우 모든 열이 csv변환 됩니다.

df.to_csv(path_or_buf='test5.csv', columns=[0])#열의 0번째만 출력함
>>
,0
0,1
1,A
2,-

header인수는 열의 이름을 지정하는 인수입니다. False일 경우 열 이름을 출력하지 않습니다.

df.to_csv(path_or_buf='test6.csv', header=['col1','col2'])#머리값을 추가해준다
>>

,col1,col2
0,1,
1,A,4.1
2,-,3

index인수는 인덱스의 출력 여부를 지정할 수 있습니다. 기본값은 True 입니다.

df.to_csv(path_or_buf='test7.csv', index=False)
>>
0,1
1,
A,4.1
-,3

index_lable인수는 출력되는 csv파일의 인덱스명을 지정하는 인수 입니다.

df.to_csv(path_or_buf='test8.csv', index_label=['index'])#인덱스명 지정함수
>>
index,0,1
0,1,
1,A,4.1
2,-,3

mode 인수의 사용

mode 인수는 기본값이 w로 기존 데이터에 새 데이터를 덮어씌웁니다. mode='a'인 경우 기존 데이터 아래에 새 데이터를 추가해서 입력합니다.

df.to_csv(path_or_buf=address+'test9.csv', mode='w') #기존 데이터 csv파일생성
df2 = pd.DataFrame(data=[[7,8],[9,10]],index=[3,4]) # 추가 입력할 새 데이터 객체 생성
df2.to_csv(path_or_buf=address+'test9.csv', mode='a') # mode=a로 기존데이터 아래에 추가함

결과는 아래와 같습니다. 기존 데이터 아래에 새 데이터가 추가된것을 확인할 수 있습니다.

이렇게 단순히 추가하는경우 열 이름이 새로 추가되기 때문에, 보기에 깔끔하지 않습니다. 이경우 header=False하여 새로 추가하는 데이터의 열 이름을 삭제해서 깔끔하게 합치는것이 가능합니다.

df.to_csv(path_or_buf=address+'test10.csv', mode='w')
df2.to_csv(path_or_buf=address+'test10.csv', mode='a',header=False)

결과는 아래와 같습니다. header=False로 열 이름이 삭제되어 깔끔하게 합쳐진것을 확인할 수 있습니다.

excel로 변환 (to_excel)

excel_writer : 경로와 파일 이름을 설정하거나 ExcelWriter 객체를 지정합니다.

sheet_name : 시트 이름을 설정해줍니다. 중복인 경우 덮어씌워집니다.

na_rep : 결측치를 대체할 값을 설정합니다. 기본값은 공백(" ") 입니다.

float_format : 부동소수점의 표현방식을 지정합니다.

columns : 엑셀로 변환할 열을 지정합니다.

header : 열 이름을 설정합니다. None인 경우에는 열이름을 출력하지 않습니다.

index : index의 출력 여부를 정합니다.

index_label : index명을 지정합니다. Multi Index의 경우 리스트 형식으로 지정해주어야합니다.

startrow / startcol : 값이 입력되는 위치를 지정합니다.

engine : 사용할 엔진을 지정합니다. 'openpyxl' 또는 'xlsxwriter'. io.excel.xlsx.writer, io.excel.xls.writer 및 io.excel.xlsm.writer 옵션을 통해 이를 설정할 수도 있습니다. merge_cells : Index가 중복인 경우 엑셀로 변환시 병합할지 정합니다. 기본값은 True로 병합이 됩니다.

encoding : 결과 엑셀파일의 인코딩을 지정합니다. xlwt에만 필요하며 다른 경우는 기본 유니코드를 지원합니다.

inf_rep : 엑셀은 기본적으로 무한에대한 표시형식이 없기때문에, 무한인 값을 어떻게 표시할지 정합니다. 기본값은 'inf' 입니다.

vervose : 오류 로그에 추가 정보를 표시할지 여부입니다. 기본값은 True입니다.

freeze_panes : 틀고정을 지정합니다. 튜플로 (값, 값) 형태로 지정합니다.

storage_options : 특정 스토리지 연결에 적합한 추가 옵션을 지정합니다. (예 : 호스트, 포트, 사용자 이름, 비밀번호 등)

먼저 기본적인 사용법 예시를위하여 3x2 데이터 하나와 Multi Index 데이터 하나를 만들어 보겠습니다.

Copydata1 = [[1,np.nan],['A',4.1],[math.inf,'3']]
df1 = pd.DataFrame(data)
df2 = pd.DataFrame(data=[[5,6],[7,8],[9,10]],index=[['A','B','B'],[3,4,5]]) #멀티인덱스 객체
print(df1)
print(df2)

>>
   0    1
0  1  NaN
1  A  4.1
2  -    3
     0   1
A 3  5   6
B 4  7   8
  5  9  10

기본적으로는 excel_writer에 단순히 경로를 지정하는것 만으로 엑셀로의 변환이 실행됩니다.

Copydf1.to_excel(excel_writer='test1.xlsx')

>>
    0    1    
0    1        
1    A    4.1    
2    -    3    

sheet_name인수를 통해 데이터가 변환되는 엑셀의 시트명을 지정할 수 있습니다.

Copydf1.to_excel(excel_writer='test2.xlsx',sheet_name='test_sheet')#sheet_name으로 시트명을 지정할 수 있다

여러 시트에 데이터를 적용하고자 할 경우 ExcelWriter 객체로 writer를 지정해 입력하면 됩니다.

with pd.ExcelWriter('test3.xlsx')as writer:
    df1.to_excel(writer, sheet_name='test_sheet_1')
    df2.to_excel(writer, sheet_name='test_sheet_2')

na_rep 인수를 통해 결측치를 대체할 값을 지정할 수 있습니다. 기본값은 공백(" ")입니다.

df1.to_excel(excel_writer='test4.xlsx',na_rep='BLANK')#na_rep= 함수로 결측치값을 대체할 수 있다

columns인수를 통해 변환할 열을 따로 지정할 수 있습니다.

df1.to_excel(excel_writer='test6.xlsx',columns=[0])#열지정 csv와 파일형식만 다르지 출력은 같다

header인수를 통해 변환될 데이터의 열 이름을 지정할 수 있습니다.

df1.to_excel(excel_writer='test7.xlsx',header=['col1','col2'])#열 이름 지정 csv와 파일형식만 다르지 출력은 같다

Index 인수를 통해 인덱스를 출력할지 여부를 지정할 수 있습니다. 기본값은 True로 인덱스를 출력합니다.

df1.to_excel(excel_writer='test8.xlsx', index=False)#인덱스 출력 여부 csv와 파일형식만 다르지 출력은 같다

Index_label 인수를 통해 인덱스명을 지정할 수 있습니다. Multi Index라면 리스트 형식으로 입력해주어야합니다.

df2.to_excel(excel_writer='test9.xlsx', index_label=['idx1','idx2'])#멀티인덱스이기 때문에 리스트 형식으로 입력했다 index_label은 인덱스 명을 지정해 준다

startrow / startcol 인수는 엑셀 변환시 데이터의 위치를 지정하는 인수입니다. 양수를 입력할 경우 처음 시작위치에서 행의 경우 아래로, 열의 경우 우측으로 해당 숫자만큼 이동하여 변환됩니다.

df1.to_excel(excel_writer='test10.xlsx', startrow=2,startcol=4)#2행 4열 우측으로 움직였다

merge_cells의 기본값은 True로 인덱스에 중복값이 있을 경우 병합하여 출력합니다.

False인 경우 각각 인덱스가 그대로 출력됩니다.

merge_cells=True인 경우

df2.to_excel(excel_writer=adress+'test11_1.xlsx')#중복값인 B가 병합하여 하나만 출력함

merge_cells=False인 경우

df2.to_excel(excel_writer=adress+'test11_2.xlsx', merge_cells=False)# 정상출력

inf_rep 인수의 사용

inf_rep 인수는 무한 값의 엑셀 변화시 표현값을 지정합니다. 기본값은 inf입니다. (엑셀에는 무한값에 대한 기본 표현값이 없습니다.)

df1.to_excel(excel_writer=adress+'test12.xlsx', inf_rep='∞')

아래와 같이 무한을 표현하는 math.inf 값이 문자 ∞ 로 입력된 것을 알 수 있습니다.

freeze_panes인수의 사용

freeze_panes인수의 값을 튜플로 입력함으로써 해당 (행,열) 기준으로 틀고정을 설정할 수 있습니다.

df1.to_excel(excel_writer=adress+'test13.xlsx', freeze_panes=(1,1))

아래와 같이 (1,1)을 기준으로 틀고정이 된 것을 확인할 수 있습니다.

shift메서드는 시계열 데이터의 데이터나 인덱스를 원하는 기간만큼 쉬프트 하는 메서드 입니다.

freq 인수를 입력하지 않으면 데이터가 이동하고, 인수값을 입력하게되면 인덱스가 freq값 만큼 이동하게됩니다.

periods : 이동할 기간입니다.

freq : 입력 할 경우 인덱스가 이동하게 됩니다. Y, M, D, H, T, S 나 Timestamp, 'Infer'등이 올 수 있습니다.

fill_value : shift로 인해 생긴 결측치를 대체할 값입니다.

먼저 기본적인 사용법 예시를위하여 5x3 짜리 데이터를 만들어보겠습니다.

pd.date_range를 이용해 기준시간에 대해 일정 간격을 가진 datetime index를 생성하겠습니다.

idx = pd.date_range(start='2022-01-01',periods=5,freq='2D')
# 2일 간격으로 5행의 인덱스 생성
data={'col1':[10,20,30,40,50],'col2':[1,3,6,7,9],'col3':[43,13,82,47,31]}
df = pd.DataFrame(data=data, index=idx)
print(df)
>>
            col1  col2  col3
2022-01-01    10     1    43
2022-01-03    20     3    13
2022-01-05    30     6    82
2022-01-07    40     7    47
2022-01-09    50     9    31

period 인수 사용할 경우 행 기준으로 이동

print(df.shift(periods=2,))
>>
            col1  col2  col3
2022-01-01   NaN   NaN   NaN
2022-01-03   NaN   NaN   NaN
2022-01-05  10.0   1.0  43.0
2022-01-07  20.0   3.0  13.0
2022-01-09  30.0   6.0  82.0

axis 사용

print(df.shift(periods=2,axis=1))
>>
            col1  col2  col3
2022-01-01   NaN   NaN    10
2022-01-03   NaN   NaN    20
2022-01-05   NaN   NaN    30
2022-01-07   NaN   NaN    40
2022-01-09   NaN   NaN    50

fill_value 인수를 사용하면, shift되면서 NaN처리된 결측치를 원하는 값으로 채울 수 있습니다.

print(df.shift(periods=2, axis=1,fill_value='-'))
>>
           col1 col2 col3
2022-01-01    -    -   10
2022-01-03    -    -   20
2022-01-05    -    -   30
2022-01-07    -    -   40
2022-01-09    -    -   50

freq 인수의 사용

freq 인수를 설정해주면, 데이터가 아닌 인덱스가 freq에 입력한 값 만큼 쉬프트 됩니다.

print(df.shift(periods=3,freq='D'))
# 일 기준 3기간 이동. 즉, 3일 이동
>>
#인덱스에 있는 년도와 날짜가 3일씩 이동된걸 알 수 있다
            col1  col2  col3
2022-01-04    10     1    43
2022-01-06    20     3    13
2022-01-08    30     6    82
2022-01-10    40     7    47
2022-01-12    50     9    31

freq='infer'인 경우, 현재 인덱스의 간격을 분석해서 적당한 freq를 추론해줍니다.

print(df.shift(periods=3,freq='infer'))
#인덱스의 날짜 간격이 처음 데이터프레임을 생성할때 2D라는 간격으로 설정했기 때문에 
#infer로 추론한 간격은 2D가 된다
>>
            col1  col2  col3
2022-01-07    10     1    43
2022-01-09    20     3    13
2022-01-11    30     6    82
2022-01-13    40     7    47
2022-01-15    50     9    31

위의 예시의 경우, 인덱스의 인터벌(간격)이 2일이므로 freq='2D'로 추론하였으며, period=3이기 때문에 6일이 쉬프트 된것을 알 수 있습니다.

period로 변환 (to_period)

DatetimeIndex와 PeriodIndex의 차이는 Datetimeindex는 연,월,일과 같은 모든 시간을 표시하지만 Periodindex는 그중에서 잘라서 출력해 줄 수 있

to_period 메서드는 DatetimeIndex를 PeriodIndex로 변환하는 메서드 입니다.

freq : 원하는 시간 단위로 변환할 수 있습니다.

axis : 변환할 기준 축 입니다.

copy : 사본을 형성할지 여부입니다.

idx = pd.date_range(start='2021-08-01',periods=5,freq='45D') # 45일 간격 인덱스
>>
DatetimeIndex(['2021-08-01', '2021-09-15', '2021-10-30', '2021-12-14',
               '2022-01-28'],
              dtype='datetime64[ns]', freq='45D') # 형식은 datetime64

freq값을 지정하여 원하는 시간간격으로 출력이 가능합니다.

freq="Y"

print(idx.to_period("Y"))
>>
PeriodIndex(['2021', '2021', '2021', '2021', '2022'], dtype='period[A-DEC]')

freq="M"

print(idx.to_period("M"))
>>
PeriodIndex(['2021-08', '2021-09', '2021-10', '2021-12', '2022-01'], dtype='period[M]')

freq="W"

print(idx.to_period("W"))
>>
PeriodIndex(['2021-07-26/2021-08-01', '2021-09-13/2021-09-19',
             '2021-10-25/2021-10-31', '2021-12-13/2021-12-19',
             '2022-01-24/2022-01-30'],
            dtype='period[W-SUN]')

freq="H"

print(idx.to_period("H"))
>>
PeriodIndex(['2021-08-01 00:00', '2021-09-15 00:00', '2021-10-30 00:00',
             '2021-12-14 00:00', '2022-01-28 00:00'],
            dtype='period[H]')

하위분류반환 (xs)

xs는 멀티인덱스 객체에 대해서 하위 분류를 출력하는 메서드입니다.

key : 분류의 기준이 되는 값입니다. Multi Index의 값을 지정합니다.

axis : 하위 분류 출력의 기준이되는 축을 지정합니다.

level : 멀티인덱스에 키가 부분적으로 포함되어있는경우, 레벨 지정을 통해 분류할 수 있습니다.

drop_level : 기본값은 True로 필터링하는 값을 제외하고 하위 분류만 출력합니다. False면 필터링하는 값이 있는 분류까지 출력합니다.

data = {'col1':[0,1,2,3,4], 'col2':[5,6,7,8,9],
        'level0':['A','A','A','B','B'],
        'level1':['X','X','Y','Y','Z'],
        'level2':['a','a','b','c','a']}
df = pd.DataFrame(data=data)
df = df.set_index(['level0', 'level1', 'level2'])
print(df)
>>
                      col1  col2
level0 level1 level2
A      X      a          0     5
              a          1     6
       Y      b          2     7
B      Y      c          3     8
       Z      a          4     9

기본적인 사용법

기본적으로 key값을 지정하면 해당 값의 하위 분류를 출력합니다.

print(df.xs(key='A'))
>>
               col1  col2
level1 level2
A      X      a          0     5
              a          1     6
       Y      b          2     7
#B      Y      c          3     8
#       Z      a          4     9
#여기는 제외된

key값을 여러 값으로 지정할 수 도 있습니다.

print(df.xs(key=('A','X')))#의 하위분류를 하기 때문에
>>

        col1  col2
level2            
a          0     5
a          1     6

                      col1  col2
level0 level1 level2
A      X      /a          0     5
              /a          1     6
       Y      /b          2     7
                      ////////////////////
B      Y      c          3     8
       Z      a          4     9

level을 지정하여 하위분류를 진행할 수 있습니다.

print(df.xs(key='Y',level=1))
>>
               col1  col2
level0 level2            
A      b          2     7
B      c          3     8

                      col1  col2
level0 level1 level2
A      X      a          0     5
              a          1     6
/////////////////////////////////
       Y!      b          2     7
B      Y!      c          3     8
/////////////////////////////////
       Z      a          4     9

drop_level=True로 할 경우 key값으로 지정된 레벨을 포함해서 줄력합니다.

print(df.xs(key='Y',level=1,drop_level=True)) #False가 기본이다 
>>
                      col1  col2
level0 level1 level2
A      Y      b          2     7
B      Y      c          3     8

피벗화, 열의 인덱스화 (stack)

stack 메서드는 열을 피벗하여 하위 인덱스로 변환하는 메서드입니다.

level : MultiColumns의 경우 하위인덱스로 변환할 열의 레벨입니다. 기본값은 -1로 최하위 레벨이 선택됩니다. dropna : {True / False} 기본값은 True로 피벗화로인해 생성된 하위인덱스의 모든 값이 결측치(NaN)인 경우 해당 열이 제거됩니다.

data = [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]]
idx = [['idx1','idx1','idx2','idx2'],['row1','row2','row3','row4']]
col = [['val1','val1','val2','val2'],['col1','col2','col3','col4']]
df = pd.DataFrame(data = data, index = idx, columns = col)
print(df)
>>
           val1      val2
           col1 col2 col3 col4
idx1 row1     0    1    2    3
     row2     4    5    6    7
idx2 row3     8    9   10   11
     row4    12   13   14   15

기본적인 사용법

'level'의 기본값은 '-1'로 최하위 레벨이 선택됩니다. 위 df에서는 level=1이 최하위 계층이기 때문에,

df.stack( ) = df.stack(level=1) 입니다. 함수 실행 시 level=1의 열이 인덱스로 피벗된걸 확인할 수 있습니다.

print(df.stack())# 있지 않은 값은 결측값이 된걸 볼 수 있다
>>
                val1  val2
idx1 row1 col1   0.0   NaN
          col2   1.0   NaN
          col3   NaN   2.0
          col4   NaN   3.0
     row2 col1   4.0   NaN
          col2   5.0   NaN
          col3   NaN   6.0
          col4   NaN   7.0
idx2 row3 col1   8.0   NaN
          col2   9.0   NaN
          col3   NaN  10.0
          col4   NaN  11.0
     row4 col1  12.0   NaN
          col2  13.0   NaN
          col3   NaN  14.0
          col4   NaN  15.0

level=0인 경우 아래와같이 'val1', 'val2'가 포함된 level=0의 열이 피벗화 되는것을 볼 수 있습니다.

print(df.stack(level=0))# 레벨 0일 경우 val1,val2가 피벗화 된걸 확인 할 수 있다
>>
                col1  col2  col3  col4
idx1 row1 val1   0.0   1.0   NaN   NaN
          val2   NaN   NaN   2.0   3.0
     row2 val1   4.0   5.0   NaN   NaN
          val2   NaN   NaN   6.0   7.0
idx2 row3 val1   8.0   9.0   NaN   NaN
          val2   NaN   NaN  10.0  11.0
     row4 val1  12.0  13.0   NaN   NaN
          val2   NaN   NaN  14.0  15.0

level=(0,1)처럼 튜플로 묶어줄 경우 해당되는 모든 계층에 대해 피벗화를 할 수 있습니다.

모든 계층(레벨)이 피벗화 될 경우 Serise 객체로 출력됩니다.

print(df.stack(level=(0,1))) 
>>
idx1  row1  val1  col1     0.0
                  col2     1.0
            val2  col3     2.0
                  col4     3.0
      row2  val1  col1     4.0
                  col2     5.0
            val2  col3     6.0
                  col4     7.0
idx2  row3  val1  col1     8.0
                  col2     9.0
            val2  col3    10.0
                  col4    11.0
      row4  val1  col1    12.0
                  col2    13.0
            val2  col3    14.0
                  col4    15.0
dtype: float64

dropna인수의 사용

dropna인수는 기본값이 True로 열이 피벗화된 인덱스의 값이 NaN이면 해당 열을 출력하지 않습니다.

예시를 위해 간단한 2x2 짜리 데이터를 만들어보겠습니다.

data = [[np.NaN,1],[2,3]]
idx = ['row1','row2']
col = ['col1','col2']
df = pd.DataFrame(data = data, index = idx, columns = col)
print(df)
>>
      col1  col2
row1   NaN     1
row2   2.0     3

stack메서드를 사용할 경우 col1, col2 열이 인덱스로 피벗화되는데, row1-col1의 값은 NaN이기 때문에 출력에서는 아래와같이 제거됩니다.

print(df.stack())#결측값이 제거된걸 볼 수 있다, 모든 열이 피벗화가 되었기 때문에 시리즈로 출력한다
>>
row1  col2    1.0 
row2  col1    2.0
      col2    3.0
dtype: float64

dropna=True로 출력 할 경우 결측값을 갖는 열 또한 정상적으로 출력되는것을 볼 수 있습니다.

print(df.stack(dropna=False))#결측값이 포함되어 정상적으로 출력되는걸 확인할 수 있다
>>
row1  col1    NaN
      col2    1.0
row2  col1    2.0
      col2    3.0
dtype: float64

언피벗화, 행의 열로 변환 (unstack)

unstack 메서드는 행을 언피벗하여 하위 열로 변환하는 메서드입니다.

level : MultiIndex의 경우 하위열로 변환할 행의 레벨입니다. 기본값은 -1로 최하위 레벨이 선택됩니다.

fill_value : 생성된 열의 값에 결측치가 있을 경우 대체할 값입니다.

data =[1,2,3,4,5]
idx = [['idx1','idx1','idx2','idx2','idx2'],['row1','row2','row1','row2','row3']]
df = pd.Series(data=data, index = idx)
print(df)
>>
idx1  row1    1
      row2    2
idx2  row1    3
      row2    4
      row3    5
dtype: int64

level은 기본값이 -1이며, 최하위 레벨의 행에 대해 열로 언피벗 합니다.

아래 예시를 보면 최 하위 계층인 row1,row2가 속한 인덱스가 열로 언피벗 된것을 확인할 수 있습니다.

print(df.unstack()) #출력을 보면 row가 위로 올라가면서 언피벗된걸 확인할 수 있
>>
      row1  row2  row3
idx1   1.0   2.0   NaN
idx2   3.0   4.0   5.0

fill_value 인수를 사용할 경우, 언피벗으로 인해 행성된 결측치를 특정 값으로 지정할 수 있습니다.

print(df.unstack(fill_value='-'))#결측값을 특정 값으로 지정해준다 피벗화에서도 똑같이 가능하다
>>
     row1 row2 row3
idx1    1    2    -
idx2    3    4    5

좀 더 큰 다중인덱스에 대해서 예시를 들어보기위해 4레벨의 멀티인덱스를 생성해보겠습니다.

data = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
level0=['idx1','idx1','idx1','idx1','idx1','idx1','idx1','idx1',
        'idx2','idx2','idx2','idx2','idx2','idx2','idx2','idx2']
level1=['row1','row1','row1','row1','row2','row2','row2','row2',
        'row3','row3','row3','row3','row4','row4','row4','row4']
level2=['val1','val1','val2','val2','val1','val1','val2','val2',
        'val1','val1','val2','val2','val1','val1','val2','val2']
level3=['col1','col2','col3','col4','col1','col2','col3','col4',
        'col1','col2','col3','col4','col1','col2','col3','col4']
idx = [level0,level1,level2,level3]
df = pd.Series(data =data, index =idx)
print(df)
>>
idx1  row1  val1  col1     0
                  col2     1
            val2  col3     2
                  col4     3
      row2  val1  col1     4
                  col2     5
            val2  col3     6
                  col4     7
idx2  row3  val1  col1     8
                  col2     9
            val2  col3    10
                  col4    11
      row4  val1  col1    12
                  col2    13
            val2  col3    14
                  col4    15
dtype: int64

val1, val2가 속한 level=2로 unstack메서드를 실행해보겠습니다.

print(df.unstack(level=2))#level=2가 언피벗화가 된걸 확일할 수 있다
>>
                val1  val2
idx1 row1 col1   0.0   NaN
          col2   1.0   NaN
          col3   NaN   2.0
          col4   NaN   3.0
     row2 col1   4.0   NaN
          col2   5.0   NaN
          col3   NaN   6.0
          col4   NaN   7.0
idx2 row3 col1   8.0   NaN
          col2   9.0   NaN
          col3   NaN  10.0
          col4   NaN  11.0
     row4 col1  12.0   NaN
          col2  13.0   NaN
          col3   NaN  14.0
          col4   NaN  15.0

level에 튜플을 이용하여 Multi Columns로 unstack을 실행할 수 있습니다.

print(df.unstack(level=(2,3)))
>>
          col1 col2 col3 col4
idx1 row1    0    1    2    3
     row2    4    5    6    7
idx2 row3    8    9   10   11
     row4   12   13   14   15

인덱스 순서변경 (swaplevel)

swaplevel메서드는 Multi Index (또는 Munti Columns)에서 두 인덱스의 순서를 변경하는 메서드입니다.

i , j : 순서를 변경할 두 인덱스의 레벨입니다. 기본적으로 제일 낮은 두 레벨의 인덱스가 교환됩니다.(-2, -1)

axis : 기본값은 0으로 axis=1로 변경할 경우 Multi Columns에 대해 메서드가 수행됩니다.

data = {'col':[0,1,2,3,4,5]}
level0 = ['idx1','idx1','idx1','idx1','idx2','idx2']
level1 = ['val1','val1','val2','val2','val3','val4']
level2 = ['row1','row2','row3','row4','row5','row6']
idx = [level0, level1, level2]
df = pd.DataFrame(data = data, index=idx)
print(df)
>>
                col
idx1 val1 row1    0
          row2    1
     val2 row3    2
          row4    3
idx2 val3 row5    4
     val4 row6    5

기본적인 사용법

i, j인수에 아무것도 입력하지 않는다면, 제일 낮은 두 레벨의 인덱스가 교환됩니다.

print(df.swaplevel())
>>
                col
idx1 row1 val1    0 # 인덱스의 level1과 level2의 위치가 바뀐것을 확인.
     row2 val1    1
     row3 val2    2
     row4 val2    3
idx2 row5 val3    4
     row6 val4    5

인수로 한 숫자만 입력하게되면, 가장 낮은 레벨의 인덱스와 인수로 입력한 숫자에 해당하는 레벨의 인덱스가 교환됩니다.

print(df.swaplevel(0))
>>
                col
row1 val1 idx1    0 #인덱스의 level0과 최하위 레벨의 인덱스의 위치가 바뀐것을 확인.
row2 val1 idx1    1
row3 val2 idx1    2
row4 val2 idx1    3
row5 val3 idx2    4
row6 val4 idx2    5

두 값을 지정하여 원하는 인덱스끼리의 교환이 가능합니다. 레벨명이 있다면 레벨명을 쓸 수도 있습니다.

print(df.swaplevel(i=0,j=1))#이거는 왜 지정하는지 모르겠다 컬러쪽에 레벨이 하나 더 있어도 axis로 구별을 안하면 행과 열도 같이 스왑 되는게 똑같다 굳이 왜 지정을 해서 바꾸는지 이해를 못함
>>
                col
val1 idx1 row1    0 # 레벨0과 레벨1의 위치가 바뀐것을 확인.
          row2    1
val2 idx1 row3    2
          row4    3
val3 idx2 row5    4
val4 idx2 row6    5

인덱스 제거 (droplevel)

droplevel 메서드는 Multi Index나 Multi Columns에서 특정 레벨을 제거하는 메서드입니다.

level : 제거할 단계 입니다.

axis : 특정 레벨을 제거할 축 입니다.

data= [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]]
idx = [['idx1','idx1','idx2','idx2'],['row1','row2','row3','row4']]
col = [['col1','col1','col2','col2'],['val1','val2','val3','val4']]
df = pd.DataFrame(data=data, index = idx, columns = col)
print(df)
>>
          col1      col2
          val1 val2 val3 val4
idx1 row1    0    1    2    3
     row2    4    5    6    7
idx2 row3    8    9   10   11
     row4   12   13   14   15

기본적인 사용법

level에 제거를 원하는 레벨을 입력함으로서 해당 레벨을 제거하여 값을 출력할 수 있습니다.

level=0인 경우 Multi Index의 level=0인 idx1, idx2가 제거된 것을 알 수 있습니다.

print(df.droplevel(axis=0,level=0))
>>
     col1      col2
     val1 val2 val3 val4
row1    0    1    2    3 # idx가 제거됨
row2    4    5    6    7
row3    8    9   10   11
row4   12   13   14   15

level=1인 경우 Multi Index의 level=1인 row1, row2, row3, row4가 제거된 것을 알 수 있습니다.

print(df.droplevel(axis=0,level=1))
>>
     col1      col2
     val1 val2 val3 val4
idx1    0    1    2    3 # row가 제거됨
idx1    4    5    6    7
idx2    8    9   10   11
idx2   12   13   14   15

axis=1인 경우 Multi Columns에 대해서 특정 레벨을 제거 할 수 있습니다.

print(df.droplevel(axis=1,level=0))
>>
           val1  val2  val3  val4 # col이 제거됨
idx1 row1     0     1     2     3
     row2     4     5     6     7
idx2 row3     8     9    10    11
     row4    12    13    14    15

Copyprint(df.droplevel(axis=1,level=1))
>>
           col1  col1  col2  col2 # vol이 제거됨
idx1 row1     0     1     2     3
     row2     4     5     6     7
idx2 row3     8     9    10    11
     row4    12    13    14    15

time : 기준이 될 시간 입니다.

asof : 현재 미사용 입니다.

axis : 기준이 될 축 입니다.

i = pd.date_range('2021-12-24', periods=10, freq='6H')
# 2021-12-24를 시작으로 10기간(간격 6H)의 데이터 생성.
# 2021-12-24를 시작으로 periods=10 (10개까지 출력)  freq='6H'(6시간 간격으로)
df = pd.DataFrame({'col1':[1,2,3,4,5,6,7,8,9,10]}, index=i)
print(df)
>>
                     col1
2021-12-24 00:00:00     1
2021-12-24 06:00:00     2
2021-12-24 12:00:00     3
2021-12-24 18:00:00f4
2021-12-25 00:00:00     5
2021-12-25 06:00:00     6
2021-12-25 12:00:00     7
2021-12-25 18:00:00     8
2021-12-26 00:00:00     9
2021-12-26 06:00:00    10

기본적인 사용법

위 시간에 대해서 시간이 06:00인 값만 출력해보도록 하겠습니다.

print(df.at_time('06:00'))
>>
                     col1
2021-12-24 06:00:00     2
2021-12-25 06:00:00     6
2021-12-26 06:00:00    10

df.between_time(start_time, end_time, include_start=True, include_end=True, axis=None)

start_time : 기준이 될 시작 시간입니다.

end_time : 기준이 될 끝 시간입니다.

include_start : 시작 시간을 포함할지 여부입니다.

inclusive_end : 끝 시간을 포함할지 여부입니다.

axis : 기준이 될 축 입니다.

i = pd.date_range('2021-12-24', periods=10, freq='1H')
df = pd.DataFrame({'col1':[1,2,3,4,5,6,7,8,9,10]}, index=i)
print(df)
>>
                     col1
2021-12-24 00:00:00     1
2021-12-24 01:00:00     2
2021-12-24 02:00:00     3
2021-12-24 03:00:00     4
2021-12-24 04:00:00     5
2021-12-24 05:00:00     6
2021-12-24 06:00:00     7
2021-12-24 07:00:00     8
2021-12-24 08:00:00     9
2021-12-24 09:00:00    10

3시에서 6시 사이만 출력

print(df.between_time(start_time='03:00',end_time='06:00'))
>>
                     col1
2021-12-24 03:00:00     4
2021-12-24 04:00:00     5
2021-12-24 05:00:00     6
2021-12-24 06:00:00     7

inclusive= both/none로 시작과 끝을 제외할 수 있다

print(df.between_time(start_time='03:00',end_time='06:00',inclusive= 'neither'))
>>
                     col1
2021-12-24 04:00:00     5
2021-12-24 05:00:00     6
# 03:00과 06:00이 제외됨.

'both' (기본값): 시작과 끝 모두 포함

'left': 시작 시간만 포함

'right': 끝 시간만 포함

'neither': 둘 다 포함하지 않음

해당 시간을 제외한 시간 필터링

start_time을 end_time보다 늦은 시간으로 둘 경우, 두 시간사이를 제외한 값을 출력합니다.

print(df.between_time(start_time='06:00',end_time='03:00'))
# start_time이 end_time보다 늦음
>>
                     col1
2021-12-24 00:00:00     1
2021-12-24 01:00:00     2
2021-12-24 02:00:00     3
2021-12-24 03:00:00     4
2021-12-24 06:00:00     7
2021-12-24 07:00:00     8
2021-12-24 08:00:00     9
2021-12-24 09:00:00    10
#03:00 ~ 06:00을 제외한 시간이 출력됨.

처음/끝 특정기간 필터링 (first / last)

i = pd.date_range('2021-12-06', periods=5, freq='3D')
# 2021-12-06을 시작일로 3일 간격의 5개 날짜 데이터를 생성
df = pd.DataFrame({'col1':[1,2,3,4,5]}, index=i)
print(df)
>>
            col1
2021-12-06     1
2021-12-09     2
2021-12-12     3
2021-12-15     4
2021-12-18     5

기본적인 사용법

offset은 기준이 될 기간을 선택합니다. 출력할 갯수가 아님을 명심해야합니다.

print(df.first('4D'))
>>
            col1
2021-12-06     1
2021-12-09     2
# 첫날짜 기준으로 4일간의 데이터를 필터링함. 4개 날짜의 출력이 아니라 4일동안.

last 메서드의 경우도 동일합니다.

Copyprint(df.last('4D'))
>>
            col1
2021-12-15     4
2021-12-18     5
# 마지막 날짜 기준으로 4일간의 데이터를 필터링.

Timezone변경[표준시간대] (tz_convert)

tz : 변경의 대상이 되는 시간대 입니다.

level : 멀티인덱스의 경우 레벨을 지정할 수 있습니다.

copy : 사본을 생성할지 여부입니다.

dr = pd.date_range(start='2021-12-29 09:00', freq='H', periods=4, tz='US/Eastern')
# date_range를 통해 기본 시간과 간격을 설정하고, tz인수를통해 timezone을 지정.
df=pd.DataFrame(index=dr, data={'Seoul':[0,0,0,0],'None':[0,0,0,0]})
print(df)
>>
                           Seoul  None
2021-12-29 09:00:00-05:00      0     0
2021-12-29 10:00:00-05:00      0     0
2021-12-29 11:00:00-05:00      0     0
2021-12-29 12:00:00-05:00      0     0
<ipython-input-17-28825d943d68>:1: FutureWarning: 'H' is deprecated and will be removed in a future version, please use 'h' instead.
  dr = pd.date_range(start='2021-12-29 09:00', freq='H', periods=4, tz='US/Eastern')

기본적인 사용법

단순히 원하는timezone을 지정함으로서 시간대의 변경이 가능합니다.

기본적으로 지역(대륙)/도시 형식으로 지원되며, 첫글자는 대문자여야 합니다. Asia/Seoul을 통해 서울 표준시로 변경해보겠습니다.

data1 = dr.tz_convert('Asia/Seoul')
# 지역/도시명 으로 표준시를 변경할 수 있습니다.
data2 = dr.tz_convert(None)
# None을 입력할 경우 시간대가 삭제됩니다.
df = pd.DataFrame(data={'Seoul':data1,'None':data2},index=dr)
print(df)
>>
                                              Seoul                None
2021-12-29 09:00:00-05:00 2021-12-29 23:00:00+09:00 2021-12-29 14:00:00
2021-12-29 10:00:00-05:00 2021-12-30 00:00:00+09:00 2021-12-29 15:00:00
2021-12-29 11:00:00-05:00 2021-12-30 01:00:00+09:00 2021-12-29 16:00:00
2021-12-29 12:00:00-05:00 2021-12-30 02:00:00+09:00 2021-12-29 17:00:00

Timezone설정[표준시간대] (tz_localize)

tz : 변경의 대상이 되는 시간대 입니다.

axis : 변경을 진행할 축 입니다..

copy : 사본을 생성할지 여부입니다.

ambiguous : DST(일광절약시) 즉, 서머타임이 적용될 경우 시간대가 꼬일 수 있습니다. 한쪽은 DST를 적용하는데, 한쪽은 적용하지 않는경우 등입니다.

이 때, ambiguous인수를 통해 모호한 시간 처리를 할 수 있습니다.

infer 은 가을-DST 전환 시간을 추론합니다.

True인 경우 DST시간대이며, False인 경우 DST시간대가 아닌 경우입니다.

NaT인 경우 모호한 시간대면 NaT를 반환합니다.

raise인 경우 모호한 시간대면 AmbiguousTimeError를 발생시킵니다.

nonexistent : DST를통해 시간이 당겨질 경우, 특정시간대는 존재하지 않을 수 있습니다.

shift_forward인 경우 존재하지 않는 시간을 가장 가까운 시간대로 당겨서 출력합니다.

shift_backward인 경우 존재하지 않는 시간을 가장 가까운 시간대로 미뤄서 출력합니다.

NaT인 경우 존재하지 않는 시간을 NaT로 출력합니다.

Timedelta값을 입력하는 경우 Timedelta값 만큼 이동합니다.

raise인 경우 존재하지 않는 시간이 발생하면 NonExistentTimeError를 발생시킵니다.

tz_convert의 예시와 같지만, date_range생성 단계에서 tz인수를 삭제하여 시간대를 설정하지 않고 진행해보겠습니다.

dr = pd.date_range(start='2021-12-29 09:00', freq='H', periods=4)
# tz인수를 삭제하여 시간대 미설정으로 진행
df=pd.DataFrame(index=dr, data={'Seoul':[0,0,0,0],'None':[0,0,0,0]})
print(df)
>>
                     Seoul  None
2021-12-29 09:00:00      0     0
2021-12-29 10:00:00      0     0
2021-12-29 11:00:00      0     0
2021-12-29 12:00:00      0     0

기본적인 사용법

이 상태에서 tz_convert를 진행하면 tz_convert raise TypeError가 발생합니다.

기존 시간대가 지정되어있지 않기 때문에 tz_convert를 진행하지 못하기 때문입니다.

data1 = dr.tz_convert('Asia/Seoul')
>>
Traceback (most recent call last):
...
TypeError: Cannot convert tz-naive timestamps, use tz_localize to localize

바로 이 경우에 tz_localize메서드를 통해 시간대를 지정해줄 수 있습니다.

dr = pd.date_range(start='2021-12-29 09:00', freq='H', periods=4)
dr = dr.tz_localize('US/Eastern') # 설정된 dr에 시간대를 설정
df = pd.DataFrame(index=dr, data={'Seoul':[0,0,0,0],'None':[0,0,0,0]})
print(df)
>>
                           Seoul  None
2021-12-29 09:00:00-05:00      0     0 # 정상적으로 시간대가 설정됨
2021-12-29 10:00:00-05:00      0     0
2021-12-29 11:00:00-05:00      0     0
2021-12-29 12:00:00-05:00      0     0
#tz_localize메서드를 통해서 Asia/seoul을 US/Eastern으로 변경한것을 확인 할 수 있다

이제 tz_convert를 진행하면 정상적으로 되는것을 확인할 수 있습니다.

data1 = dr.tz_convert('Asia/Seoul')
data2 = dr.tz_convert(None)
df = pd.DataFrame(data={'Seoul':data1,'None':data2},index=dr)
print(df)
>>
                                              Seoul                None
2021-12-29 09:00:00-05:00 2021-12-29 23:00:00+09:00 2021-12-29 14:00:00
2021-12-29 10:00:00-05:00 2021-12-30 00:00:00+09:00 2021-12-29 15:00:00
2021-12-29 11:00:00-05:00 2021-12-30 01:00:00+09:00 2021-12-29 16:00:00
2021-12-29 12:00:00-05:00 2021-12-30 02:00:00+09:00 2021-12-29 17:00:00

즉, 요약하자면 TimeStamp나 DateRange를 생성할 때 tz인수를 입력하는것과

만들어진 객체에 tz_localize인수를 통해 시간대를 설정하는것은 동일한 결과를 가집니다.

※아래 두 경우는 동일함

dr = pd.date_range(start='2021-12-29 09:00', freq='H', periods=4, tz='US/Eastern')

dr = pd.date_range(start='2021-12-29 09:00', freq='H', periods=4).tz_localize('US/Eastern')

TimeStamp변환(to_timestamp)

freq : timestamp로의 기준이 되는 주기 입니다. [Y/M/D, H/T(min)/S 등등..], 더 많은 freq항목은 이 링크의 DateOffset objects 항목에서 확인 바랍니다.

how : {start / end} 기간의 시작을 기준으로할지, 끝을 기준으로 할지 정합니다.

axis : 기준이 될 축을 지정합니다.

copy : 사본을 생성할지 여부입니다.

예시

pd.period_range를 이용해 기준시간에 대해 일정 간격을 가진 datetime index를 생성하겠습니다.

period = pd.period_range(start='2021-10-04 00:00:00',end='2021-10-04 01:00:00',freq='30T')
# 2021-10-04 00:00:00부터 2021-10-04 01:00:00 까지 30분 단위로 인덱스 생성
# 여기서 T는 min을 의미합니다.
df=pd.DataFrame(data=range(len(period)),index=period)
print(df)
>>
                  0
2021-10-04 00:00  0
2021-10-04 00:30  1
2021-10-04 01:00  2

기본적인 사용법

먼저 how=start로 하여 시작시간을 기준으로 freq를 변경해가면서 datetime index가 어떻게 timestamp화되는지 확인해보겠습니다.

print(df.to_timestamp(freq="S",how='start'))
>>
                     0
2021-10-04 00:00:00  0
2021-10-04 00:30:00  1
2021-10-04 01:00:00  2

print(df.to_timestamp(freq="T",how='start'))#= T는 (min)분으로 month가 M을 가져갔기 때문에 T로 대체되었
>>
                     0
2021-10-04 00:00:00  0
2021-10-04 00:30:00  1
2021-10-04 01:00:00  2

print(df.to_timestamp(freq="H",how='start'))
>>
                     0
2021-10-04 00:00:00  0
2021-10-04 00:00:00  1
2021-10-04 01:00:00  2

print(df.to_timestamp(freq="D",how='start'))
>>
            0
2021-10-04  0
2021-10-04  1
2021-10-04  2

print(df.to_timestamp(freq="M",how='start'))
>>
            0
2021-10-31  0
2021-10-31  1
2021-10-31  2

print(df.to_timestamp(freq="Y",how='start'))
>>
            0
2021-12-31  0
2021-12-31  1
2021-12-31  2

how=start와 how=end를 비교하여 index가 어떻게 변화하는지 확인 할 수 있습니다.

Copyprint(df.to_timestamp(freq="T",how='start'))
print(df.to_timestamp(freq="T",how='end'))
>>
                     0
2021-10-04 00:00:00  0
2021-10-04 00:30:00  1
2021-10-04 01:00:00  2
                               0
2021-10-04 00:29:59.999999999  0
2021-10-04 00:59:59.999999999  1
2021-10-04 01:29:59.999999999  2

리샘플링 (resample)%이해못함!!!%

freq : 기준이 될 주기 입니다.

method : {bfill / ffill} 리샘플링으로 생성된 빈(NaN) 값을 채울 방식입니다.

bfill : 아래 값으로 빈 값을 채웁니다.

ffill : 위 값으로 빈 값을 채웁니다.

how : {start / end} period Index에서 사용하는 방식입니다. 유사한 것을 to_timestamp에서 볼 수 있습니다.

normalize : {True / False} 출력되는 인덱스를 자정으로 설정할지 여부입니다.

fill_value : 리샘플링으로 생성된 빈(NaN) 값을 채울 값입니다.

예시

먼저 기본적인 사용법 예시를위하여 3x1짜리 데이터를 만들어보겠습니다.

pd.date_range를 이용해 기준시간에 대해 일정 간격을 가진 datetime index를 생성하겠습니다.

idx = pd.date_range('2021-12-30',periods=3,freq='min')
# 2021-12-30 기준으로 1분 간격의 3개 값 만듦
df = pd.DataFrame(index=idx, data=[1,None,3],columns=['col'])
# 값중 하나는 의도적으로 NaN입력
print(df)
>>
                     col
2021-12-30 00:00:00  1.0
2021-12-30 00:01:00  NaN
2021-12-30 00:02:00  3.0

기본적인 사용법

먼저 freq=30S로 하여 1분간격의 데이터를 30초 간격으로 리샘플링 해보겠습니다.

print(df.asfreq(freq='30S'))
>>
                     col
2021-12-30 00:00:00  1.0
2021-12-30 00:00:30  NaN
2021-12-30 00:01:00  NaN
2021-12-30 00:01:30  NaN
2021-12-30 00:02:00  3.0
# 30초 단위의 인덱스가 생성되며 값은 NaN으로 채워짐

결측치 채우기(method / fill_value)

method를 통해 빈 값을 앞이나 뒤의 값으로 채울 수 있으며, fill_value를 통해 지정된 값으로 채울 수 있습니다.

method='bfill'으로 뒤의 값으로 결측치 채우기

print(df.asfreq(freq='30S',method='bfill'))
>>
                     col
2021-12-30 00:00:00  1.0
2021-12-30 00:00:30  NaN
2021-12-30 00:01:00  NaN
2021-12-30 00:01:30  3.0
2021-12-30 00:02:00  3.0

method='ffill'으로 앞의 값으로 결측치 채우기

print(df.asfreq(freq='30S',method='ffill'))
>>
                     col
2021-12-30 00:00:00  1.0
2021-12-30 00:00:30  1.0
2021-12-30 00:01:00  NaN
2021-12-30 00:01:30  NaN
2021-12-30 00:02:00  3.0

fill_value를 입력하여 결측치를 채우기

print(df.asfreq(freq='30S',fill_value='-'))
>>                     col
2021-12-30 00:00:00  1.0
2021-12-30 00:00:30    -
2021-12-30 00:01:00  NaN
2021-12-30 00:01:30    -
2021-12-30 00:02:00  3.0

자정 기준으로 변경(normalize)

normalize인수를 통해 시간기준을 자정(00:00:00)으로 고정할 수 있습니다.

예시를 위해 날짜 기준으로 3일치 데이터를 만들어보겠습니다.

idx = pd.date_range('2021-12-20',periods=3,freq='D')
df = pd.DataFrame(index=idx, data=[1,2,3],columns=['col'])
print(df)
>>
            col
2021-12-20    1
2021-12-21    2
2021-12-22    3

이제 이 데이터를 asfreq를 통해 8시간 기준으로 리샘플링 해보겠습니다.

print(df.asfreq(freq='8H'))
>>
                     col
2021-12-20 00:00:00  1.0
2021-12-20 08:00:00  NaN
2021-12-20 16:00:00  NaN
2021-12-21 00:00:00  2.0
2021-12-21 08:00:00  NaN
2021-12-21 16:00:00  NaN
2021-12-22 00:00:00  3.0

이제 normalize=True를 하여 시간대를 자정으로 고정해보겠습니다.

print(df.asfreq(freq='8H',normalize=True))
>>
            col
2021-12-20  1.0
2021-12-20  NaN
2021-12-20  NaN
2021-12-21  2.0
2021-12-21  NaN
2021-12-21  NaN
2021-12-22  3.0

인덱스나누기[리샘플링] (asfreq)

rule : 리샘플링 할 기준 입니다. 단위로는 Y, M, D, H, T(min), S ... 등을 조합하여 사용할 수 있습니다.

axis : 리샘플링할 축 입니다.

closed : {left / right} 간격의 시작과 끝중 어느부분을 닫을지 입니다. 기본적으로 왼쪽(시작) 입니다.

간단히 예를들면 1분간격 인터벌로 01:00의 값이 1이라고하면 left는 시작부분을 닫아 01:00≤ x＜02:00인 시간의 값을 1으로,

right는 끝 부분을 닫아 00:00＜x ≤01:00인 시간의 값을 10이라고 판단하는 것입니다.

label : {left / right} 리샘플링될 시간을 포함하는 간격의 어떤 가장자리를 레이블로 정할지 입니다. 기본적으로 왼쪽 입니다.

convection : {start, end, s, e} PeriodIndex의 경우에만 규칙의 시작 또는 끝을 사용할지 여부를 제어합니다.

kind : {timestamp / period} 결과 인덱스를 DateTimeIndex로 변환하려면 'timestamp'를 전달하고 PeriodIndex로 변환하려면 'period'를 전달합니다. loffset : 리샘플링된 시간 레이블을 조정하는 인수로 현재는 사용하지 않습니다. (offset 인수로 대체)

base : 리샘플링한 데이터의 간격의 원점을 지정하는 인수로, 현재 사용하지 않습니다.(origin 인수로 대체)

on : 인덱스가 아닌 열 기준으로 리샘플링을 시도할 경우, 해당 열의 이름을 지정하는 인수 입니다.

level : 멀티인덱스(Multi Index)의 경우 리샘플링할 인덱스의 레벨을 지정하는 인수 입니다.

origin : {epoch, start, start_day, end, end_day / Timestamp} 리샘플링할 경우 데이터 간격의 원점을 지정합니다.

epoch : 1970-01-01을 기준으로 간격을 설정합니다.

start : 인덱스의 첫 번째 값을 기준으로 간격을 설정합니다.

start_day : 인덱스의 첫 번째 값이 포함되는 날의 자정을 기준으로 간격을 설정합니다.

end : 인덱스의 마지막 값을 기준으로 간격을 설정합니다.

end_day : 인덱스의 마지막 값이 포함되는 나르이 자정을 기준으로 간격을 설정합니다.

Timestamp : 지정한 시간(Timestamp)를 기준으로 간격을 설정합니다.

offset : origin의 값에 시간 오프셋을 더해줍니다.

먼저 기본적인 사용법 예시를위하여 10x1짜리 데이터를 만들어보겠습니다.

pd.date_range를 이용해 기준시간에 대해 일정 간격을 가진 datetime index를 생성하겠습니다.

idx = pd.date_range('2021-12-30',periods=10,freq='min')
# 2021-12-30일기준으로 1분간격의 10개의 행 생성
df = pd.DataFrame(index=idx, data=[0,1,2,3,4,5,6,7,8,9],columns=['col'])
print(df)
>>
                     col
2021-12-30 00:00:00    0
2021-12-30 00:01:00    1
2021-12-30 00:02:00    2
2021-12-30 00:03:00    3
2021-12-30 00:04:00    4
2021-12-30 00:05:00    5
2021-12-30 00:06:00    6
2021-12-30 00:07:00    7
2021-12-30 00:08:00    8
2021-12-30 00:09:00    9

resample 메서드는 단독으로 사용하면 DatetimeIndexResampler를 출력한다 왜냐하면 우리가 원하는 데이터를 리샘플링된 데이터를 출력하고 싶으면 다른 메서드 뒤에 붙여서, 리셈플링된 데이터의 열의 값을 지정해야한다

우리가 원하는 리샘플링된 데이터를 출력하고자 하면, 다른 메서드를 뒤에 붙여서, 리샘플링된 데이터의 열의 값을 지정해주어야합니다.

1분간격으로 1~10까지의 값을 가지는 데이터를 3분(3T or 3min) 간격으로 리샘플링하면서, 값은 합치도록 해보겠습니다.

print(df.resample(rule='3T').sum()) # 뒤에 .sum()을 붙여주어서 합쳐질 열의 값을 더해줍니다.
>>
                     col
2021-12-30 00:00:00    3 #3분 간격으로 리셈플링(축소되어)되어 출력한다
2021-12-30 00:03:00   12 #col 12의 값에는 
2021-12-30 00:06:00   21 
2021-12-30 00:09:00    9 

sum() 뿐만아니라 prod(), mean()등 객체간 연산 에 이용되는 모든 메서드가 가능하며,

asfreq같은 메서드등도 지원합니다.

closed인수의 사용

closed인수는 bin(시간 간격)을 닫는 위치를 지정하는 인수로 기본적으로 left값을 가집니다.

1분 간격 인터벌인 df값 중 2021-12-30 00:03:00 3의 예시를 들면, left인 경우는 03:00≤ x ＜04:00인 시간간격에 3이 부여되는 것이고,

right인 경우는 02:00＜ x ≤03:00 인 시간 간격에 3이 부여되는 것입니다.

아래 예시와 그림을 보면 이해가 쉽습니다.

# closed='left'인 경우
print(df.resample(rule='3T',closed='left').sum())
>>
                     col
2021-12-30 00:00:00    3
2021-12-30 00:03:00   12
2021-12-30 00:06:00   21
2021-12-30 00:09:00    9

Copy# closed='right'인 경우
print(df.resample(rule='3T',closed='right').sum())
>>
                     col
2021-12-29 23:57:00    0
2021-12-30 00:00:00    6
2021-12-30 00:03:00   15
2021-12-30 00:06:00   24

left

인 경우 00:00≤ x ＜03:00 인 시간대에 0,1,2가 들어가기 때문에 00:00부터 리샘플링하여 0+1+2=3 이 출력됩니다.

right

인 경우 0은 23:59:00＜ x ≤ 00:00:00인 시간대에 들어가므로 3분 단위 리샘플링이 23:57:00＜ x ≤ 00:00:00 으로 0이 출력됩니다.

아래 이미지를 보면 보다 직관적으로 이해할 수 있습니다.

label 인수의 사용

label인수는 closed인수보다는 개념이 간단합니다. 단순히 리샘플링된 인덱스의 간격을 대표할 값을

간격의 시작값으로할지 끝 값으로할지를 지정하는 것입니다. 기본값은 left로 인터벌(간격)의 시작을 기준으로합니다.

# label = 'left'인 경우
print(df.resample(rule='3T',label='left').sum())
>>
                     col
2021-12-30 00:00:00    3 # 00:00~03:00의 간격에서 시작값인 00:00을 기준으로 지정
2021-12-30 00:03:00   12
2021-12-30 00:06:00   21
2021-12-30 00:09:00    9

# label = 'right'인 경우
print(df.resample(rule='3T',label='right').sum())
>>
                     col
2021-12-30 00:03:00    3 # 00:00~03:00의 간격에서 끝값인 03:00을 기준으로 지정
2021-12-30 00:06:00   12
2021-12-30 00:09:00   21
2021-12-30 00:12:00    9

kind 인수의 사용

kind 인수는 리샘플링된 인덱스의 dtype을 datetime으로 할지 peroid로할지 정할 수 있습니다.

index의 dtype정보는 10-10 인덱스 (index) 항목에서 확인할 수 있습니다.

kind='timestamp'인 경우 DatetimeIndex가 됩니다.

print(df.resample(rule='3T',kind='timestamp').sum().index)
# index메서드를 통해 인덱스 정보 확인 가능
>>
DatetimeIndex(['2021-12-30 00:00:00', '2021-12-30 00:03:00',
               '2021-12-30 00:06:00', '2021-12-30 00:09:00'],
              dtype='datetime64[ns]', freq='3T')
# 분류가 DatetimeIndex 이며 dtype='datetime`으로 설정됨.

kind='period'인 경우 PeriodIndex가 됩니다.

print(df.resample(rule='3T',kind='period').sum().index)
>>
PeriodIndex(['2021-12-30 00:00', '2021-12-30 00:03', '2021-12-30 00:06',
             '2021-12-30 00:09'],
            dtype='period[3T]')
# 분류가 PeriodIndex 이며 dtype='period`로 설정됨.

on 인수의 사용

먼저 on인수의 사용을 위해 열의 값이 timestamp형태인 데이터를 만들어보겠습니다.

idx = pd.date_range('2021-12-30',periods=2,freq='5min')
df = pd.DataFrame(index=idx, data=[1,6],columns=['col'])
# 5분간격의 2개 열을 가진 데이터 생성
df2 = df.reset_index(drop=False)
# reset_index를 통해 기존인덱스를 열로 변경, 새 인덱스는 0,1,2, ... , n으로 변경.
print(df2)
>>
                index  col
0 2021-12-30 00:00:00    1
1 2021-12-30 00:05:00    6
# 기존 index가 'index'라는 이름의 열로 바뀜

※ reset_index에 대한 자세한 내용은 13-09 인덱스 리셋 (reset_index)을 참고 바랍니다.

on=index를 입력하여 index라는이름을 가진 열을 기준으로 리샘플링을 진행해보겠습니다.

print(df2.resample(rule='min',on='index').sum())
# 5분간격으로 2개의 값을가지는 `index`열을 1분(min) 간격으로 리샘플링.
>>
                     col
index
2021-12-30 00:00:00    1 # index라는 이름의 열 기준으로 리샘플링이 진행되고
2021-12-30 00:01:00    0 # 해당 열이 index로 변경됨.
2021-12-30 00:02:00    0
2021-12-30 00:03:00    0
2021-12-30 00:04:00    0
2021-12-30 00:05:00    6

origin 인수의 사용

먼저, origin인수와 offset인수를 사용하기 위해 3분간격의 9행짜리 Timeindex 데이터를 만들어보겠습니다.

idx = pd.date_range('2021-12-31',periods=9,freq='3min')
df = pd.DataFrame(index=idx, data=[1,2,3,4,5,6,7,8,9],columns=['col'])
print(df)
>>
                     col
2021-12-31 00:00:00    1
2021-12-31 00:03:00    2
2021-12-31 00:06:00    3
2021-12-31 00:09:00    4
2021-12-31 00:12:00    5
2021-12-31 00:15:00    6
2021-12-31 00:18:00    7
2021-12-31 00:21:00    8
2021-12-31 00:24:00    9

이것을 7min 간격으로 리샘플링을 진행해보겠습니다.

print(df.resample(rule='7min').sum())
>>
                     col
2021-12-31 00:00:00    6
2021-12-31 00:07:00    9
2021-12-31 00:14:00   13
2021-12-31 00:21:00   17

origin인수의 기본값은 start_day로 처음값이 포함된 날짜의 시작시간인 자정(00:00:00)을 기준으로 7분 간격으로 리샘플링을 진행합니다.

print(df.resample(rule='7min',origin='start_day').sum())
>>
                     col
2021-12-31 00:00:00    6
2021-12-31 00:07:00    9
2021-12-31 00:14:00   13
2021-12-31 00:21:00   17

origin='start'인 경우 처음 값을 기준으로 7분 간격으로 리샘플링을 진행하게됩니다.

여기서는 시작시간이 00:00:00이므로 start_day인 경우와 동일합니다.

print(df.resample(rule='7min',origin='start').sum())
>>
                     col
2021-12-31 00:00:00    6
2021-12-31 00:07:00    9
2021-12-31 00:14:00   13
2021-12-31 00:21:00   17

origin='epoch'인 경우 1970-01-01을 기준으로 7분 간격의 리샘플링을 하게 됩니다.

print(df.resample(rule='7min',origin='epoch').sum())
>>
                     col
2021-12-30 23:55:00    1
2021-12-31 00:02:00    5
2021-12-31 00:09:00   15
2021-12-31 00:16:00   15
2021-12-31 00:23:00    9

origin='end'인 경우 마지막 값을 기준으로 7분간격으로 리샘플링을 진행하게 됩니다.

print(df.resample(rule='7min',origin='end').sum())
>>
                     col
2021-12-31 00:03:00    3
2021-12-31 00:10:00    7
2021-12-31 00:17:00   11
2021-12-31 00:24:00   24

origin='end_day'인 경우 마지막값이 포함된 날의 끝 시간인 자정(00:00:00)을 기준으로 7분 간격의 리샘플링을 진행 합니다.

print(df.resample(rule='7min',origin='end_day').sum())
>>
                     col
2021-12-31 00:05:00    3
2021-12-31 00:12:00   12
2021-12-31 00:19:00   13
2021-12-31 00:26:00   17

origin값에 특정 날짜를 입력할 경우 그 날짜(시간)을 기준으로 리샘플링이 진행됩니다.

print(df.resample(rule='7min',origin='2021-12-30').sum())
>>
                     col
2021-12-30 23:55:00    1
2021-12-31 00:02:00    5
2021-12-31 00:09:00   15
2021-12-31 00:16:00   15
2021-12-31 00:23:00    9

offset인수의 사용

먼저 offset인수를 사용하지 않은 경우를 보겠습니다.

print(df.resample(rule='7min').sum())
>>
                     col
2021-12-31 00:00:00    6
2021-12-31 00:07:00    9
2021-12-31 00:14:00   13
2021-12-31 00:21:00   17

offset인수는 origin에 대해서 시간을 더하는 인수입니다.

만약 offset='4min'을 지정해준다면, 기본값인 origin='start_day'인 첫 값이 포함된 날의 자정(00:00:00)을 기준으로

4분을 더해준 값인 00:04:00을 기준으로 리샘플링이 진행되게 되는 것입니다.

즉, origin = '2021-12-31 00:04:00'으로 입력한 경우와 완벽히 같습니다.

print(df.resample(rule='7min',offset='4min').sum())
>>
                     col
2021-12-30 23:57:00    3 #00:04:00 기준으로 리샘플링이 진행됐기 때문에, 00:04:00에서 7min을 뺀 23:57부터 리샘플링이 진행됨.
2021-12-31 00:04:00    7
2021-12-31 00:11:00   11
2021-12-31 00:18:00   24

2.concat

예시문제

data = [
    {"cd":"A060310", "nm":"3S", "open":2920, "close":2800},
    {"cd":"A095570", "nm":"AJ네트웍스", "open":1920, "close":1900},
    {"cd":"A006840", "nm":"AK홀딩스", "open":2020, "close":2010},
    {"cd":"A054620", "nm":"APS홀딩스", "open":3120, "close":3200}
]
df = DataFrame(data=data)
df = df.set_index('cd')

>>
             nm  open  close
cd                          
A060310      3S  2920   2800
A095570  AJ네트웍스  1920   1900
A006840   AK홀딩스  2020   2010
A054620  APS홀딩스  3120   3200

#위에서 데이터프레임 query 메서드를 사용하여 종가(close)가 시가(open)보다 큰 데이터만 가져오세요.

df.query("close > open")#query문은 비교연산자를 문자열로 해도 다 알아 먹는다 이문제를 풀어서 해결하면

str = ("close > open")
df.query(str)

>>

nm    open    close
cd            
A054620    APS홀딩스    3120    3200

#위와 같이도 할 수 있다

#위 데이터프레임에서 시가(open)가 2,000원 이상이고 종가(close)가 시가(open)이상인 종목을 출력하세요.

df.query("close > open" and "open > 2000") #and, or 등 여러개의 비교연산자도 한번에 할 수 있다

>>

nm    open    close
cd            
A060310    3S    2920    2800
A006840    AK홀딩스    2020    2010
A054620    APS홀딩스    3120    3200

#위 데이터프레임에서 종목명(nm)이 'A'로 시작하는 종목만 선택하세요.

print(df.query("nm.str.startswith('A')"))#str.startswith() 앞 글자에 xx이 포함되었는지

>>

nm    open    close
cd            
A095570    AJ네트웍스    1920    1900
A006840    AK홀딩스    2020    2010
A054620    APS홀딩스    3120    3200

#이름에 홀딩스가 포함된것만 출력
print(df.query("nm.str.contains('홀딩스')"))#str.contains() ***이 포함했는지 확인하는 함수
>>
    nm    open    close
cd            
A006840    AK홀딩스    2020    2010
A054620    APS홀딩스    3120    3200

---------------------------------------
data = {
    "PER": [6.42, 17.63, 21.09, 13.93],
    "PBR": [1.10, 1.49, 2.06, 1.88],
    "DPS": [1416, 1716, 2994, 1755]
}
index = ["2019/12", "2020/12", "2021/12", "2022/12(E)"]
df = pd.DataFrame(data=data, index=index)
>>
              PER   PBR   DPS
2019/12      6.42  1.10  1416
2020/12     17.63  1.49  1716
2021/12     21.09  2.06  2994
2022/12(E)  13.93  1.88  1755

#다음 데이터프레임에서 filter 메서드를 사용해서 "PER"과 "PBR" 컬럼만 선택하세요.

df.filter(items=["PER","PBR"])

>>
PER    PBR
2019/12    6.42    1.10
2020/12    17.63    1.49
2021/12    121.09    2.06
2022/12(E)    13.93    1.88

#DataFrame filter 정규식
df.filter(regex="P.R", axis=1)#Column에서 P,R이 포함된 걸 출력한
>>
    PER    PBR
2019/12    6.42    1.10
2020/12    17.63    1.49
2021/12    21.09    2.06
2022/12(E)    13.93    1.88

#위 데이터프레임에서 filter 메서드를 사용해서 예상치인 '2022/12(E)'를 제외한 나머지 로우 데이터를 선택하세요.

df.filter(regex="12$", axis=0)
>>

PER    PBR    DPS
2019/12    6.42    1.10    1416
2020/12    17.63    1.49    1716
2021/12    21.09    2.06    2994

#위 데이터프레임에서 "2022"년 데이터만 선택하세요. 2022년 데이터는 인덱스에 '2022'라는 문자열이 포함되어있습니다.
df.filter(like="2022", axis=0)

---------------------

#데이터터프레임 위/아래 붙이기 (concat)

columns = ['open', 'high', 'low', 'close']
index1 = [
    datetime(2022, 9, 8),
    datetime(2022, 9, 7),
    datetime(2022, 9, 6),
    datetime(2022, 9, 5),
    datetime(2022, 9, 2)
]

index2 = [
    datetime(2022, 9, 1),
    datetime(2022, 8, 31),
    datetime(2022, 8, 30),
    datetime(2022, 8, 29),
    datetime(2022, 8, 26)
]

df1 = pd.DataFrame(data=np.arange(0, 20).reshape(5,4), index=index1, columns=columns)
df2 = pd.DataFrame(data=np.arange(20,40).reshape(5,4), index=index2, columns=columns)

            open  high  low  close
2022-09-08     0     1    2      3
2022-09-07     4     5    6      7
2022-09-06     8     9   10     11
2022-09-05    12    13   14     15
2022-09-02    16    17   18     19

#df1 df2 붙이기(위 아래로)
pd.concat([df1, df2], axis=0)
>>

open    high    low    close
2022-09-08    0    1    2    3
2022-09-07    4    5    6    7
2022-09-06    8    9    10    11
2022-09-05    12    13    14    15
2022-09-02    16    17    18    19
2022-09-01    20    21    22    23
2022-08-31    24    25    26    27
2022-08-30    28    29    30    31
2022-08-29    32    33    34    35
2022-08-26    36    37    38    39

#좌 우로 붙이기
index = [
    datetime(2022, 9, 8),
    datetime(2022, 9, 7),
    datetime(2022, 9, 6),
    datetime(2022, 9, 5),
    datetime(2022, 9, 2)
]

df1 = pd.DataFrame(data=np.arange(0, 10).reshape(5,2), index=index, columns=['open', 'high'])
df2 = pd.DataFrame(data=np.arange(10,20).reshape(5,2), index=index, columns=['low', 'close'])

pd.concat([df1, df2], axis=1)

--------------------------

index1 = [
    datetime(2022, 9, 8),
    datetime(2022, 9, 7)
]

index2 = [
    datetime(2022, 9, 6),
    datetime(2022, 9, 5)
]
df1 = pd.DataFrame(np.arange(0, 6).reshape(2,3), index=index1, columns=['open', 'high', 'low'])
df2 = pd.DataFrame(np.arange(6,12).reshape(2,3), index=index2, columns=['high', 'low', 'close'])

#outer,inner를 써보
pd.concat([df1, df2], axis=0, join='outer')
>>

open    high    low    close
2022-09-08    0.0    1.0    NaN    NaN
2022-09-07    2.0    3.0    NaN    NaN
2022-09-06    4.0    5.0    NaN    NaN
2022-09-05    6.0    7.0    NaN    NaN
2022-09-02    8.0    9.0    NaN    NaN
2022-09-08    NaN    NaN    10.0    11.0
2022-09-07    NaN    NaN    12.0    13.0
2022-09-06    NaN    NaN    14.0    15.0
2022-09-05    NaN    NaN    16.0    17.0
2022-09-02    NaN    NaN    18.0    19.0

pd.concat([df1, df2], axis=0, join='inner')
>>
2022-09-08
2022-09-07
2022-09-06
2022-09-05
2022-09-02
2022-09-08
2022-09-07
2022-09-06
2022-09-05
2022-09-02

#새로운 데이터프레임 두개 생성
df1 = pd.DataFrame(np.arange(0, 4).reshape(2,2))
df2 = pd.DataFrame(np.arange(4, 8).reshape(2,2))

#axis를 False 해서 출력
pd.concat([df1, df2], axis= False)
>>
0    1
0    0    1
1    2    3
0    4    5
1    6    7

#pd.concat 멀티인덱스 만들기
#예제 생성
index = ["2020", "2021"]

data1 = {
    "PER": [21.09, 13.55],
    "PBR": [2.06, 1.80]
}

data2 = {
    "PER": [12.40, 24.19],
    "PBR": [1.58, 1.44]
}

df1 = pd.DataFrame(data=data1, index=index)
df2 = pd.DataFrame(data=data2, index=index)
>>

        PER   PBR
2020  21.09  2.06
2021  13.55  1.80
        PER   PBR
2020  12.40  1.58
2021  24.19  1.44

#멀티인덱스 붙이기

combined = pd.concat([df1, df2], keys=["삼성전자", "LG전자"])#keys 함수를 붙이면 자동으로 만들어진다
print(combined)

>>
             PER   PBR
삼성전자 2020  21.09  2.06
     2021  13.55  1.80
LG전자 2020  12.40  1.58
     2021  24.19  1.44


#회사와 연도까지 붙이기
combined = pd.concat([df1, df2], keys=["삼성전자", "LG전자"])
combined.index.names = ["회사", "연도"]
print(combined)

**>>

             PER   PBR
회사   연도               
삼성전자 2020  21.09  2.06
     2021  13.55  1.80
LG전자 2020  12.40  1.58
     2021  24.19  1.44



 ------------------------------
 #groupby 
 data = [
    ["2차전지(생산)", "SK이노베이션", 10.19, 1.29],
    ["해운", "팬오션", 21.23, 0.95],
    ["시스템반도체", "티엘아이", 35.97, 1.12],
    ["해운", "HMM", 21.52, 3.20],
    ["시스템반도체", "아이에이", 37.32, 3.55],
    ["2차전지(생산)", "LG화학", 83.06, 3.75]
]

columns = ["테마", "종목명", "PER", "PBR"]
df = pd.DataFrame(data=data, columns=columns)

>>**

    테마    종목명    PER    PBR
0    2차전지(생산)    SK이노베이션    10.19    1.29
1             해운    팬오션    21.23    0.95
2    시스템반도체    티엘아이    35.97    1.12
3                해운    HMM    21.52    3.20
4    시스템반도체    아이에이    37.32    3.55
5    2차전지(생산)    LG화학    83.06    3.75

df.groupby(by="테마")[["PER","PBR"]].mean

공분산은 두 변수가 서로 얼마나 관련이 있는지 같이 움직이는지를 보여주는 수치

공분산 구하기

1. x,y 두 데이터의 평균 구하기
2. 기존 데이터에 평균 데이터를 빼서 x,y의 편차 구하기
3. x편차와 y편차를 곱해서 두 값의 관계 보기
4. 공분산은 편차 곱의 평균이야 그래서 구한 값들을 모두 더하고, 학생수로 나누면 돼
5. 공분산이 양수 일떄는 양의 관계고 음수 일때는 음의 관계

이걸 쉽게 만든게 상관관계

상관관계

두 변수 사이의 선형적인 관계의 강도와 방향을 나타내는 수치입니다

보통은 r로 포현합니다

해석 방법

공분산과 차이점

y값과 x 값이 같이 올라가면 관계는 양의 상관관계(같이 움직임)

y값이 올라가면 x값이 낮아지는 관계는 음의 상관관계다(두 가지가 반대로 움직임)

y와 x가 전혀 관계가 없다면 상관관계는 없다

공분(cov)

cov 메서드는 결측값을 제외한 쌍별 공분산을 구하는 메서드입니다.

공분산이란 확률변수가 2가지 일때 얼마나 퍼져있는가를 구하는 방법입니다.

즉, 두 값을 X축 Y축으로 놓고 점산도를 그렸을때 퍼진 정도라고 할 수 있습니다.

min_periods : 공분산을 구할 최소 요소의 갯수 입니다. 요소의 갯수가 모자르면 NaN을 반환합니다.

col = ['X','Y']
data1 = [[-6,-3],[-4,-1],[-2,-3],[0,1],[2,2]]
data2 = [[7,-4],[4,-1],[2,0],[-1,3],[-4,9]]
data3 = [[3,-4],[3,-1],[3,0],[3,3],[3,9]]
df1 = pd.DataFrame(data=data1, columns=col)
df2 = pd.DataFrame(data=data2, columns=col)
df3 = pd.DataFrame(data=data3, columns=col)

여기에 사진 첨부

기본적인 사용법

df1은 좌표평면상에서 x가 증가할때 y도 증가하는 경향을 가집니다.

이때 공분산(cov)값은 0보다 크며 양의 상관관계라고 합니다.

print(df1.cov())
>>
      X    Y
X  10.0  6.0
Y   6.0  5.2

df2은 좌표평면상에서 x가 증가할때 y는 감소하는 경향을 가집니다.

이때 공분산(cov)값은 0보다 작으며 음의 상관관계라고 합니다.

print(df2.cov())
>>
       X      Y
X  18.30 -20.55
Y -20.55  24.30

df3은 좌표평면상에서 y가 변하여도 x는 변하지 않습니다.

이처럼 x와 y가 상관 없는경우 공분산(cov)값은 0입니다.

print(df3.cov())
>>
     X     Y
X  0.0   0.0
Y  0.0  24.3

min_periods인수의 사용

min_periods인수는 공분산에 이용될 요소의 최소 갯수를 제한합니다.

이 숫자보다 요소의 수가 적을 경우 NaN을 반환합니다.

print(df3.cov(min_periods=6))
>>
    X   Y
X NaN NaN
Y NaN NaN

!pip install pandas

import pandas as pd
from pandas import DataFrame
from pandas import Series
import numpy as np
import numba

def mad(data):

    avg = np.average(data)#데이터의 평균을 구한다
    abs_deviation = [abs(x - avg) for x in data]#abs_deviation(절대편차)를 구하는 거다 (for x in data는  0부터 훓어준다,abs(x-avg)는 절대값으로 바꿔 x에 평균값을 빼준다)
    return np.average(abs_deviation)#절대편차의 평균을 구한다

data = (2,8,0,7)
print(mad(data))

최대/최소 (max / min)

min / max 메서드는 행/열 의 최대값, 최소값을 구하는 메서드 입니다.

axis : {0 : index / 1 : columns} 계산의 기준이 될 축입니다.

skipna : 결측치를 무시할지 여부입니다.

level : Multi Index의 경우 연산을 수행할 레벨입니다.

numeric_only : 숫자, 소수, 부울만 이용할지 여부입니다.

kwargs : 함수에 전달할 추가 키워드입니다.

[N,T,F]=[np.NaN,True,False]
idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = [['COL1','COL1','COL2','COL2'],['val1','val2','val3','val4']]
data = [[N,13,3,4],[5,7,10,8],[15,6,N,3],[2,14,9,1]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
           COL1       COL2
           val1 val2  val3 val4
IDX1 row1   NaN   13   3.0    4
     row2   5.0    7  10.0    8
IDX2 row3  15.0    6   NaN    3
     row4   2.0   14   9.0    1

기본적인 사용법(+axis)

기본적으로 df.max( ) / df.min( )를 사용할 경우 모든 행/열에 대해서 최대/최소 값을 찾습니다.

print(df.max())
>>
COL1  val1    15.0
      val2    14.0
COL2  val3    10.0
      val4     8.0
dtype: float64

axis를 설정해 줄 경우 축을 지정할 수 있습니다.

print(df.max(axis=1))
>>
IDX1  row1    13.0
      row2    10.0
IDX2  row3    15.0
      row4    14.0
dtype: float64

skipna인수의 사용

skipna인수를 사용할 경우 계산에 대해서 결측치를 포함하거나 제외시킬 수 있습니다.

print(df.max(skipna=True))
>>
COL1  val1    15.0
      val2    14.0
COL2  val3    10.0
      val4     8.0
dtype: float64

print(df.max(skipna=False))
>>
COL1  val1     NaN
      val2    14.0
COL2  val3     NaN
      val4     8.0
dtype: float64

level의 설정

Multi Index의 경우 연산을 수행할 level을 지정할 수 있습니다.

print(df.max(level=0))
>>
      COL1       COL2
      val1 val2  val3 val4
IDX1   5.0   13  10.0    8
IDX2  15.0   14   9.0    3
# print(df.groupby(level=0).max()) 와 동일한 역할을 수행

min메서드의 경우

이 아래는 위 예시와 동일하게 min메서드를 수행한 경우 입니다.

print(df.min())
>>
COL1  val1    2.0
      val2    6.0
COL2  val3    3.0
      val4    1.0
dtype: float64

print(df.min(axis=1))
>>
IDX1  row1    3.0
      row2    5.0
IDX2  row3    3.0
      row4    1.0
dtype: float64

print(df.min(skipna=True))
>>
COL1  val1    2.0
      val2    6.0
COL2  val3    3.0
      val4    1.0
dtype: float64

print(df.min(skipna=False))
>>
COL1  val1    NaN
      val2    6.0
COL2  val3    NaN
      val4    1.0
dtype: float64

print(df.min(level=0))
>>
     COL1      COL2
     val1 val2 val3 val4
IDX1  5.0    7  3.0    4
IDX2  2.0    6  9.0    1
# print(df.groupby(level=0).min())와 동일

mean(평균)

mean메서드는 행/열의 값들의 평균을 구하는 메서드입니다.

axis : {0 : index / 1 : columns} 계산의 기준이 될 축입니다.

skipna : 결측치를 무시할지 여부입니다.

level : Multi Index의 경우 연산을 수행할 레벨입니다.

numeric_only : 숫자, 소수, 부울만 이용할지 여부입니다.

kwargs : 함수에 전달할 추가 키워드입니다.

idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = [['COL1','COL1','COL2','COL2'],['val1','val2','val3','val4']]
data = [[N,13,3,4],[5,7,10,8],[15,6,N,3],[2,14,9,1]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
           COL1       COL2
           val1 val2  val3 val4
IDX1 row1   NaN   13   3.0    4
     row2   5.0    7  10.0    8
IDX2 row3  15.0    6   NaN    3
     row4   2.0   14   9.0    1

기본적인 사용법(+axis)

기본적으로 mean을 그대로 사용할 경우 모든 행/열에 대해서 연산을 수행합니다.

print(df.mean())
>>
COL1  val1     7.333333
      val2    10.000000
COL2  val3     7.333333
      val4     4.000000
dtype: float64

axis 인수를 이용하여 대상 축을 지정할 수 있습니다.

print(df.mean(axis=1))
>>
IDX1  row1    6.666667
      row2    7.500000
IDX2  row3    8.000000
      row4    6.500000
dtype: float64

skipna인수의 사용

skipna인수를 이용하여 결측치를 무시할지 정할 수 있습니다.

print(df.mean(skipna=True))
>>
COL1  val1     7.333333
      val2    10.000000
COL2  val3     7.333333
      val4     4.000000
dtype: float64

print(df.mean(skipna=False))
>>
COL1  val1     NaN
      val2    10.0
COL2  val3     NaN
      val4     4.0
dtype: float64

level인수의 사용

Multi Index의 경우 대상 레벨을 지정할 수 있습니다.

print(df.mean(level=0))
>>
     COL1       COL2
     val1  val2 val3 val4
IDX1  5.0  10.0  6.5  6.0
IDX2  8.5  10.0  9.0  2.0
# print(df.groupby(level=0).mean())와 완전히 동일합니다.

중앙값 (median)

median메서드는 행/열의 값들의 중앙값을 구하는 메서드입니다.

만약 수의 갯수가 짝수이면 중앙값 두 값의 평균값을 반환합니다.

axis : {0 : index / 1 : columns} 계산의 기준이 될 축입니다.

skipna : 결측치를 무시할지 여부입니다.

level : Multi Index의 경우 연산을 수행할 레벨입니다.

numeric_only : 숫자, 소수, 부울만 이용할지 여부입니다.

kwargs : 함수에 전달할 추가 키워드입니다.

[N,T,F]=[np.NaN,True,False]
idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = [['COL1','COL1','COL2','COL2'],['val1','val2','val3','val4']]
data = [[N,13,3,4],[5,7,10,8],[15,6,N,3],[2,14,9,1]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
           COL1       COL2
           val1 val2  val3 val4
IDX1 row1   NaN   13   3.0    4
     row2   5.0    7  10.0    8
IDX2 row3  15.0    6   NaN    3
     row4   2.0   14   9.0    1

기본적인 사용법(+axis)

기본적으로 median을 그대로 사용할 경우 모든 행/열에 대해서 연산을 수행합니다.

만약 수의 갯수가 짝수이면 중앙값 두 값의 평균값을 반환합니다.

print(df.median())
>>
COL1  val1     5.0 # 2, 5, 15의 중앙값인 5
      val2    10.0 # 6, 7, 13, 14 의 중앙값은 7과 13의 평균인 10
COL2  val3     9.0
      val4     3.5
dtype: float64

axis 인수를 이용하여 대상 축을 지정할 수 있습니다.

print(df.median(axis=1))
>>
IDX1  row1    4.0
      row2    7.5
IDX2  row3    6.0
      row4    5.5
dtype: float64

skipna인수의 사용

skipna인수를 이용하여 결측치를 무시할지 정할 수 있습니다.

print(df.median(skipna=True))
>>
COL1  val1     5.0
      val2    10.0
COL2  val3     9.0
      val4     3.5
dtype: float64

print(df.median(skipna=False))
>>
COL1  val1     NaN
      val2    10.0
COL2  val3     NaN
      val4     3.5
dtype: float64

level인수의 사용

Multi Index의 경우 대상 레벨을 지정할 수 있습니다.

print(df.groupby(level=0).median())
>>
     COL1       COL2
     val1  val2 val3 val4
IDX1  5.0  10.0  6.5  6.0
IDX2  8.5  10.0  9.0  2.0

최빈값 (mode)

mode메서드는 대상 행/열의 최빈값을 구하는 메서드입니다.

최빈값이 여러개일 경우 모두 표시합니다.

axis : {0 : index / 1 : columns} 최빈값을 구할 축 입니다.

numeric_only : True일 경우 숫자, 소수, 부울값만 있는 열에대해서만 연산을 수행합니다.

dropna : 결측치를 계산에서 제외할지 여부입니다. False일 경우 결측치도 계산에 포함됩니다.

[N,T,F]=[np.NaN,True,False]
idx = ['row1','row2','row3','row4']
col = ['col1','col2','col3','col4']
data = [['A',2,'x',N],['B',2,'y',N],['C',1,'y',1],['A',N,'z',3]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
     col1  col2 col3  col4
row1    A   2.0    x   NaN
row2    B   2.0    y   NaN
row3    C   1.0    y   1.0
row4    A   NaN    z   3.0

기본적인 사용법

mode메서드를 사용하면 각 열에 대해서 최빈값이 인덱스 0에 출력됩니다.

만약 최빈값이 여러개일 경우 갯수만큼 인덱스가 생성되어 출력됩니다.

이 때, 최빈값 이외의 값은 NaN을 출력합니다.

print(df.mode())
>>
  col1  col2 col3  col4
0    A   2.0    y   1.0
1  NaN   NaN  NaN   3.0
# col4의 최빈값이 1과 3으로 두개이기 때문에 두개 다 출력, 나머지는 최빈값이
# 하나이므로 1행에는 NaN출력

dropna인수의 사용

기본적으로 결측치는 최빈값 계산에서 제외됩니다. dropna= True로 할 경우 결측치도 계산에 포함되며,

결측치가 제일 많을 경우 최빈값은 결측치가 됩니다.

print(df.mode(dropna=False))
>>
  col1  col2 col3  col4
0    A   2.0    y   NaN
# col4에는 NaN이 가장 많으므로 최빈값이 NaN으로 계산됨.

numeric_only인수의 사용

numeric_only인수가 True인 경우 숫자 or bool형태가 아닌 자료형을 갖는 열은 계산에서 제외됩니다.

Copyprint(df.mode(numeric_only=True))
>>
   col2  col4
0   2.0   1.0
1   NaN   3.0
# col1, col3에는 문자열 형식이 존재하므로 계산에서 제외됨.

표준편차 (std)

std 메서드는 행/열에 대한 표본표준편차를 구하는 메서드입니다.

※ 모표준편차가 아니라 표본표준편차입니다.

• ※ ※ 후술할 ddof=0 일 경우 자유도가 n이므로 모표준편차로 계산이 가능합니다 *모표준편차표본표준편차

  σ(모표준편차)=Σ|x−μ|2ns(표본표준편차)=Σ|x−μ|2n−ddof

axis : 표본표준편차를 구할 축을 지정합니다.

skipna : 결측치를 무시할지 여부입니다.

level : Multi Index의 경우 대상 레벨을 지정할 수 있습니다.

ddof : 표본표준편차 계산의 분모가되는 자유도를 지정합니다. 산식은 n - ddof값으로 기본값은 n-1입니다.

numeric_only : 숫자, 소수, bool로 구성된 열만 대상으로할지 여부입니다.

kwargs : 함수의 경우에 추가적으로 적용할 키워드입니다.

[N,T,F]=[np.NaN,True,False]
idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = ['col1','col2','col3','col4']
data = [[1,5,7,13],[5,2,19,1],[13,6,4,12],[8,N,0,8]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
           col1  col2  col3  col4
IDX1 row1     1   5.0     7    13
     row2     5   2.0    19     1
IDX2 row3    13   6.0     4    12
     row4     8   NaN     0     8

기본적인 사용법

인수입력 없이 std메서드를 사용할 경우 각 열의 요소들의 표본표준편차를 계산합니다.

print(df.std())
>>
col1    5.057997
col2    2.081666
col3    8.185353
col4    5.446712
dtype: float64

skipna인수의 사용

skipna=False인 경우 결측값이 포함된 경우 NaN을 출력합니다.

print(df.std(skipna=False))
>>
col1    5.057997
col2         NaN
col3    8.185353
col4    5.446712
dtype: float64

axis인수의 사용

axis 인수를 통해 계산의 대상이 될 축을 지정할 수 있습니다.

print(df.std(axis=1))
>>
IDX1  row1    5.000000
      row2    8.341663
IDX2  row3    4.425306
      row4    4.618802
dtype: float64

level인수의 사용

Multi Index의 경우 level 인수를 이용해 레벨을 지정할 수 있습니다.

print(df.std(level=0))
>>
          col1     col2      col3      col4
IDX1  2.828427  2.12132  8.485281  8.485281
IDX2  3.535534      NaN  2.828427  2.828427

print(df.std())
>>
col1    5.057997
col2    2.081666
col3    8.185353
col4    5.446712
dtype: float64

print(df.std(ddof=2))
>>
col1     6.194756
col2     2.943920
col3    10.024969
col4     6.670832
dtype: float64

print(df.std(ddof=3))
>>
col1     8.760708
col2          NaN
col3    14.177447
col4     9.433981
dtype: float64

print(df.std(ddof=4))
>>
col1   NaN
col2   NaN
col3   NaN
col4   NaN분산 (var)

분산(var)

var 메서드는 행/열에 대한 불편향분산를 구하는 메서드입니다.

※ 모분산이 아니라 불편향분산을 구하는 메서드입니다. 불편향 메서드란 분모에 n이 아닌 n-1나누는 기대값을 적용해 편향을 제거한 분산입니다.

• ※ ※ 후술할 ddof=0 일 경우 자유도가 n이므로 모분산으로 계산이 가능합니다 *모분산불편향분산

  σ2(모분산)=Σ|x−μ|2nS2(불편향분산)=Σ|x−μ|2n−ddof

axis : 불편향분산을 구할 축을 지정합니다.

skipna : 결측치를 무시할지 여부입니다.

level : Multi Index의 경우 대상 레벨을 지정할 수 있습니다.

ddof : 불편향분산 계산의 분모가되는 자유도를 지정합니다. 산식은 n - ddof값으로 기본값은 n-1입니다.

numeric_only : 숫자, 소수, bool로 구성된 열만 대상으로할지 여부입니다.

kwargs : 함수의 경우에 추가적으로 적용할 키워드입니다.

먼저 기본적인 사용법 예시를 위해 4x4짜리 Multi Index 객체를 생성하겠습니다.

[N,T,F]=[np.NaN,True,False]
idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = ['col1','col2','col3','col4']
data = [[1,5,7,13],[5,2,19,1],[13,6,4,12],[8,N,0,8]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
           col1  col2  col3  col4
IDX1 row1     1   5.0     7    13
     row2     5   2.0    19     1
IDX2 row3    13   6.0     4    12
     row4     8   NaN     0     8

기본적인 사용법

인수입력 없이 var메서드를 사용할 경우 각 열의 요소들의 불편향분산을 계산합니다.

int(df.var())
>>
col1    25.583333
col2     4.333333
col3    67.000000
col4    29.666667
dtype: float64

skipna인수의 사용

skipna=False인 경우 결측값이 포함된 경우 NaN을 출력합니다.

print(df.var(skipna=False))
>>
col1    25.583333
col2          NaN
col3    67.000000
col4    29.666667
dtype: float64

axis인수의 사용

axis 인수를 통해 계산의 대상이 될 축을 지정할 수 있습니다.

print(df.var(axis=1))
>>

IDX1  row1    25.000000
      row2    69.583333
IDX2  row3    19.583333
      row4    21.333333
dtype: float64

level인수의 사용

Multi Index의 경우 level 인수를 이용해 레벨을 지정할 수 있습니다.

print(df.groupby(level=0).var())
>>
      col1  col2  col3  col4
IDX1   8.0   4.5  72.0  72.0
IDX2  12.5   NaN   8.0   8.0

누적 최대/최소 (cummax / cummin)

cummax / cummin메서드는 행/열의 누적 최대값/최소값을 구하는 메서드입니다.

위에서부터 아래로 한줄씩 검사하여 해당 행/열 까지의 값중 최대/최소값을 반환합니다.

axis : 누적 최대/최소값을 구할 축을 지정합니다.

skipna : 결측치를 무시할지 여부 입니다

[N,T,F]=[np.NaN,True,False]
df = pd.DataFrame({'col1':[1,-2,5,3,0,7],'col2':[3,4,N,9,2,5]})
print(df)
>>
   col1  col2
0     1   3.0
1    -2   4.0
2     5   NaN
3     3   9.0
4     0   2.0
5     7   5.0

기본적인 사용법

cummax / cummin을 사용할 경우 해당 행/열 까지의 값중 최대/최소값을 반환합니다.

print(df.cummax())
>>
   col1  col2
0     1   3.0
1     1   4.0
2     5   NaN # col1에서 최대값 5발생
3     5   9.0 # col2에서 최대값 9발생
4     5   9.0
5     7   9.0 # col1에서 최대값7 발생

print(df.cummin())
>>
   col1  col2
0     1   3.0
1    -2   3.0 # col1에서 최소값 -2발생
2    -2   NaN
3    -2   3.0
4    -2   2.0 # col2에서 최소값 2 발생
5    -2   2.0

skipna 인수의 사용

skipna=False일 경우 결측값이 발생하면 최대/최소값을 결측값으로 반환하게됩니다.

print(df.cummax(skipna=False))
>>
   col1  col2
0     1   3.0
1     1   4.0
2     5   NaN # col2에서 결측값 발생
3     5   NaN
4     5   NaN
5     7   NaN
#결측값이 반환되면 쭉 반환된

분위수 (quantile)

cumsum / cumprod메서드는 행/열의 누적합/누적곱을 구하는 메서드입니다.

위에서부터 아래로 한줄씩 덧셈/곱셈을 누적하여 수행합니다.

axis : 누적합/누적곱을 구할 축을 지정합니다.

skipna : 결측치를 무시할지 여부 입니다

quantile메서드는 해당 행/열의 분위수의 해당하는 값을 반환하는 메서드입니다.

사용법

기본 사용법

※ 자세한 내용은 아래 예시를 참고 바랍니다.

df.quantile(q=0.5, axis=0, numeric_only=True, interpolation='linear')

q : 분위수 입니다. 소수로 표현합니다. (예 : 75% = 0.75)

aixs : 분위수의 값을 구할 축입니다.

numeric_only : 수(소수)만 대상으로할지 여부입니다. False일 경우 datetime 및 timedelta 데이터의 분위수도 계산됩니다.

interpolation : 분위수에 값이 없을때 보간하는 방법입니다. 방식은 아래와 같습니다.

liner : i + (j - i) x 비율 [분위수 앞, 뒤 수 간격 * 비율]

lower : i [분위수 앞, 뒤수 중 작은수]

higher : j [분위수 앞, 뒤수 중 큰수]

midpoint : (i+j)÷2 [분위수 앞, 뒤수의 중간값]

nearest : i or j [분위수 앞, 뒤수중 분위수에 가까운 수]

예시

먼저 기본적인 사용법 예시를 위해 3x3짜리 객체를 생성하겠습니다.

idx = ['row1','row2','row3']
col = ['col1','col2','col3']
data= [[0,1,32],[50,10,-9],[100,100,18]]

df = pd.DataFrame(data,idx,col)
print(df)
>>
      col1  col2  col3
row1     0     1    32
row2    50    10    -9
row3   100   100    18

기본적인 사용법

q의 값에 따라 해당 분위수를 출력하게 됩니다.

0분위수의 경우

print(df.quantile(q=0))
# 0분위수인 가장 작은수를 출력
>>
col1    0.0
col2    1.0
col3   -9.0
Name: 0.0, dtype: float64

0.5분위수의 경우

print(df.quantile(q=0.5))
# 0.5분위수인 중간값을 출력
>>
col1    50.0
col2    10.0
col3    18.0
Name: 0.5, dtype: float64

1분위수의 경우

print(df.quantile(q=1))
# 1분위수인 가장 큰 값 출력
>>
col1    100.0
col2    100.0
col3     32.0
Name: 1.0, dtype: float64

interpolation인수의 사용

interpolation은 분위수의 해당하는 값이 없는 경우 어떤 수를 출력할지 정하는 보간법입니다.

linear의 경우 i + (j - i) x 비율입니다.

print(df.quantile(q=0.75, interpolation='linear'))
>>
col1    75.0
col2    55.0
col3    25.0
Name: 0.75, dtype: float64

lower의 경우 i [분위수 앞, 뒤수 중 작은수] 입니다.

print(df.quantile(q=0.75, interpolation='lower'))
>>
col1    50
col2    10
col3    18
Name: 0.75, dtype: int64

higher의 경우 j [분위수 앞, 뒤수 중 큰수] 입니다.

col1    100
col2    100
col3     32
Name: 0.75, dtype: int64

midpoint의 경우 (i+j)÷2 [분위수 앞, 뒤수의 중간값] 입니다.

print(df.quantile(q=0.75, interpolation='midpoint'))
>>
col1    75.0
col2    55.0
col3    25.0
Name: 0.75, dtype: float64

nearest의 경우 i or j [분위수 앞, 뒤수중 분위수에 가까운 수] 입니다.

print(df.quantile(q=0.75, interpolation='nearest'))
>>
col1    100
col2    100
col3     32
Name: 0.75, dtype: int64

swapaxes메서드는 행/열을 바꿔주는 메서드입니다. 값들도 교환됩니다.

axis1, axis2 : {0 : index / 1 : columns} 교환할 행과 열 입니다.

copy : 사본을 생성할지 여부입니다.

idx = ['row1','row2']
col = ['col1','col2']
data= [['A','B'],[1,2]]
df = pd.DataFrame(data, idx, col)
print(df)

axis1과 axis2에 행/열을 지정하여 교환할 수 있습니다. 행<->열 교환이나 열<->행 교환이나 완벽히 동일합니다.

print(df.swapaxes(axis1=0,axis2=1))
>>
     row1 row2
col1    A    1
col2    B    2

axis1과 axis2이 같다면, 당연히 원래 값과 같습니다.

print(df.swapaxes(axis1=1,axis2=1))
>>
     col1 col2
row1    A    B
row2    1    2

레이블명 변경 (rename)

rename 메서드는 레이블의 이름을 변경하는 메서드 입니다.

mapper : 변경할 {레이블명 : 값} 입니다. dict나 함수형태가 올 수 있는데, 축이 지정되어있지 않으므로 axis인수와 함께 사용해야 합니다.

axis : mapper의 변경값이 적용될 축 입니다.

index, columns : 변경할 {레이블명 : 값}입니다. 미리 축을 지정하기 때문에 axis인수와 병행사용할 수 없습니다.

copy : 사본을 생성할지 여부입니다.

inplace : Pandas 공통 인수인 inplace는 원본을 수정할지의 여부를 지정합니다.

level : Multi Index의 경우 레벨을 지정해줍니다.

errors : {'ignore' / 'raise'} mapper, index, columns에서 지정한 dict에 해당하는 key값이 없을경우, 오류를 발생시킬지 여부 입니다.

data= [['-','-'],['-','-']]
df1 = pd.DataFrame(data)
print(df1)
>>
   0  1
0  -  -
1  -  -

mapper와 axis를 이용하는 방법

mapper를 이용해 변경 내용을 설정해준 경우, axis인수를 이용해 적용 축을 설정해주어야합니다.

print(df1.rename(mapper={0:'col1',1:'col2'}, axis=1))
>>
# mapper를 통해 0을 col1로, 1을 col2로 설정하고 축을 열(1:columns)로 설정
  col1 col2
0    -    -
1    -    -

index나 columns를 이용하는 방법

index나 columns에 변경 내용을 설정해주는 경우 axis설정 없이 적용이 됩니다.

# index에 변경값을 입력
print(df1.rename(index = {0:'row1',1:'row2'}))
#인덱스의 0번째와 1번째 인덱스 변경
>>
      0  1
row1  -  -
row2  -  -

inplace인수를 이용한 원본 변경

pandas 공통사항으로 inplace=True인 경우 원본의 값이 변경됩니다.

df1.rename(index={0:'row1',1:'row2'}, columns={0:'col1',1:'col2'},inplace=True)
print(df1)
>>
     col1 col2
row1    -    -
row2    -    -

Multi Index의 경우

먼저 예시를 위한 Multi Index를 만들어 보겠습니다

idx = [['row1','row1','row2','row2'],[1,2,3,4]]
col = ['col1','col2']
data = [['-','-'],['-','-'],['-','-'],['-','-']]
df2 = pd.DataFrame(data, idx, col)
print(df2)
>>
       col1 col2
row1 1    -    -
     2    -    -
row2 3    -    -
     4    -    -

level의 지정

Multi Index의 경우 rename으로 레이블명을 변경할 경우 level을 통해 레벨을 설정해주어야 합니다.

print(df2.rename(level=1, index={1:'val1',2:'val2',3:'val3',4:'val4',5:'val5'}))
>>
          col1 col2
row1 val1    -    -
     val2    -    -
row2 val3    -    -
     val4    -    -

레벨1 의 인덱스가 변경된 것을 확인할 수 있습니다. 그런데 { ... , 5:'val5'}는 존재하지 않는 인덱스인데, 오류가 발생하지 않았습니다.

이는 errors인수를 통해 오류 발생이 가능합니다.

errors인수의 사용

errors는 기본적으로 ignore으로 존재하지 않은 인덱스에 대해 dict를 입력하더라도 오류를 발생시키지 않습니다.

위의 예시를 errors='raise'를 이용하여 다시 실행해보겠습니다.

print(df2.rename(errors='raise',level=1, index={1:'val1',2:'val2',3:'val3',4:'val4',5:'val5'}))
>>
오류 발생
KeyError: '[1, 2, 3, 4, 5] not found in axis'

축 이름 변경 (rename_axis)

rename_axis메서드는 축의 이름을 지정하는 메서드입니다.

mapper : 변경할 값 입니다. dict나 함수, 스칼라형태가 올 수 있는데, 축이 지정되어있지 않으므로 axis인수와 함께 사용해야 합니다.

axis : mapper의 변경값이 적용될 축 입니다.

index, columns : 변경할 축을 지정해서 값을 변경합니다.

copy : 사본을 생성할지 여부입니다.

inplace : Pandas 공통 인수인 inplace는 원본을 수정할지의 여부를 지정합니다.

df = pd.DataFrame(data=[['-','-'],['-','-']],index=['row1','row2'],columns=['col1','col2'])
print(df)
>>
     col1 col2
row1    -    -
row2    -    -

mapper와 axis를 이용하는 방법

mapper를 통해 변경값을 지정해주는 경우 axis를 통해 적용될 축을 지정해주어야 합니다.

df = df.rename_axis(mapper='index',axis=0)
#index라는 행의 축을 추가한다
print(df)

>>
      col1 col2
index
row1     -    -
row2     -    -

index나 columns를 이용하는 경우

index나 columns에 값을 지정해주는경우 별도의 축을 지정해줄 필요가 없습니다.

df = df.rename_axis(columns='columns')
print(df)
>>
columns col1 col2
index
row1       -    -
row2       -    -

inplace의 사용

pandas 공통사항으로 inplace=True인 경우 원본을 변경하게 됩니다. 지정해준 축 이름을 대문자로 변경하는 함수와 함께 inplace를 사용해보겠습니다.

df.rename_axis(index=str.upper, columns=str.upper, inplace=True)
print(df)
>>
COLUMNS col1 col2
INDEX
row1       -    -
row2       -    -

레이블명 변경 (set_axis)

set_axis메서드는 레이블명을 원하는 값으로 변경하는 메서드입니다.

labels : 변경할 이름입니다. list형태로 사용 가능합니다.

axis : {0 : index / 1 : columns} 변경값을 적용할 축 입니다.

inplace : pandas 공통인수인 inplace는 True인 경우 원본을 변경하게 됩니다.

df = pd.DataFrame(data=[[1,2],[3,4]])
print(df)
>>
   0  1
0  1  2
1  3  4

labels에 변경할 값을 입력하고, axis를 통해 축을 설정해주어서 레이블명을 변경할 수 있습니다.

df=df.set_axis(labels=['row1','row2'],axis=0)
#행 레이블 변경
print(df)
>>
      0  1
row1  1  2
row2  3  4

df = df.set_axis(labels=['col1','col2'],axis=1)
#열 레이블 변경
print(df)
>>
      col1  col2
row1     1     2
row2     3     4

열을 인덱스로 설정 (set_index)

set_index메서드는 기존의 열을 인덱스로 설정하는 메서드입니다.

keys : 인덱스로 설정할 열의 이름입니다. list형태로 설정할 경우 Multi Index로 설정됩니다.

drop : 인덱스로 설정한 열을 기존 열에서 제거할지 여부입니다. 기본값은 True로 열에서 제거됩니다.

append : 기존 인덱스를 유지하면서 새 인덱스를 추가할 지 여부입니다.

inplace : pandas 공통 인수로 원본을 대체할지 여부입니다.

verify_integrity : 추가하려는 인덱스에 중복값이 있을경우 오류를 띄울지 여부 입니다.

data={'col1':['A','A','A','B','B'],
      'col2':['[1]','[2]','[3]','[1]','[2]'],
      'col3':[2,5,3,4,1],
      'col4':['X','X','Y','Z','Z']}
idx=['row1','row2','row3','row4','row5']
df = pd.DataFrame(data=data,index=idx)
print(df)
>>
     col1 col2  col3 col4
row1    A  [1]     2    X
row2    A  [2]     5    X
row3    A  [3]     3    Y
row4    B  [1]     4    Z
row5    B  [2]     1    Z

기본적인 사용법

keys로 인덱스가 될 열 이름을 지정할 수 있습니다.

# col1을 인덱스로 만들기
print(df.set_index(keys='col1'))
>>
     col2  col3 col4
col1
A     [1]     2    X
A     [2]     5    X
A     [3]     3    Y
B     [1]     4    Z
B     [2]     1    Z

keys에 list가 입력될 경우 Multi Index 형태로 설정이 됩니다.

print(df.set_index(keys=['col1','col2']))
>>
           col3 col4
col1 col2
A    [1]      2    X
     [2]      5    X
     [3]      3    Y
B    [1]      4    Z
     [2]      1    Z

append 인수의 사용

append인수를 True로 설정 할 경우 기존 Index를 유지하고 새 인덱스를 추가하게됩니다.

print(df.set_index(keys='col1',append=True))
>>
          col2  col3 col4
     col1
row1 A     [1]     2    X
row2 A     [2]     5    X
row3 A     [3]     3    Y
row4 B     [1]     4    Z
row5 B     [2]     1    Z

drop 인수의 사용

drop 인수가 False일 경우 인덱스가 설정된 이후에도 해당 열이 유지됩니다.

기본값은 True로 keys에 설정된 열이 인덱스로 설정될 경우 열이 삭제됩니다.

print(df.set_index(keys='col1',drop=False))
>>
     col1 col2  col3 col4
col1
A       A  [1]     2    X
A       A  [2]     5    X
A       A  [3]     3    Y
B       B  [1]     4    Z
B       B  [2]     1    Z
#col1 이 그대로 유지되어있는것을 확인할 수 있습니다.<br>

verify_integrity인수의 사용

verify_integrity인수의 기본값은 False로 인덱스에 중복된 값이 있더라도 출력합니다. 만약 True일 경우 중복값이 있다면 오류를 출력하게 됩니다.

# 기본값은 False로 중복을 허용
print(df.set_index(keys='col4'))
>>
     col1 col2  col3
col4
X       A  [1]     2
X       A  [2]     5
Y       A  [3]     3
Z       B  [1]     4
Z       B  [2]     1

# True일 경우 인덱스에 중복값이 있다면 오류를 출력하게됩니다.<br>
print(df.set_index(keys='col4',verify_integrity=True))
>>
오류 발생
ValueError: Index has duplicate keys: Index(['X', 'Z'], dtype='object', name='col4')

접미사/접두사 (suffix / prefix)

add_suffix와 add_preffix메서드는 각각 열 이름에 접미사/접두사를 붙이는 메서드 입니다.

suffix / prefix : 열 이름에 추가할 문자열입니다.

df = pd.DataFrame(data=[[1,2],[3,4]])
print(df)

>>
   0  1
0  1  2
1  3  4

기본적인 사용법

add_suffix메서드를 이용할 경우 열 이름의 뒤쪽에 해당 문자열이 붙게 됩니다.

print(df.add_suffix('_열'))
>>
#뒤에 붙여준다
   0_열  1_열
0    1    2
1    3    4

add_prefix메서드를 이용할 경우 열 이름의 앞쪽에 해당 문자열이 붙게 됩니다.

print(df.add_prefix('열_'))
>>
#앞에 붙여준다
   열_0  열_1
0    1    2
1    3    4

인덱스 변경 (reindex)

reindex 메서드는 인덱스를 새 인덱스로 덮어씌우고 내용을 채우는 메서드 입니다.

labels : 변경할 값입니다. labels인수를 이용할 경우 axis인수를 통해 축을 지정해줘야합니다. 추가된 index의 경우 NaN을 요소로 갖습니다.

index / columns : 변경할 값입니다. 행과 열을 미리 지정해줍니다. 추가된 index의 경우 NaN을 요소로 갖습니다.

method : {bfill / ffill / nearest이 결측치를 채울 규칙입니다.

ffill : 바로 전 값으로 결측치를 채웁니다.

bfill : 바로 뒤 값으로 결측치를 채웁니다.

nearest : 근처의 유효값으로 결측치를 채웁니다.

※ 결측치를 채울 때 값의 전/후 값을 기준으로하는것이 아닌 인덱스의 전/후 인덱스를 기준으로 합니다.

copy : 사본을 생성할지 여부입니다.

level : Multi Index의 경우 레벨을 선택할 수 있습니다.

fill_value : 결측값을 이 값으로 변경할 수 있습니다.

limit : method인수를 사용할 경우 몇개까지 변경할지 제한할 수 있습니다

tolerance : method인수를 사용할 때 index가 다를 경우 허용 범위 입니다.

★│변경 전 인덱스 - 변경 후 인덱스│≤ tolerance 를 만족하게 method 적용 허용 범위를 정할 수 있습니다. 자세한건 예시 참고바랍니다.

idx = [3,6,11]
col = ['col1','col2','col3','col4']
data = [[1,2,3,4],[2,4,6,8],[3,6,9,12]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
    col1  col2  col3  col4
3      1     2     3     4
6      2     4     6     8
11     3     6     9    12

기본적인 사용법(+fill_value인수)

기본적으로 새 index가 될 list를 형성하고 labels / axis나 index / columns를 사용해서 적용 할 수 있습니다.

labels / axis를 이용할 경우

col2 = ['col1','idx2','idx3','col4']
print(df.reindex(labels=col2,axis=1)) # labels로 변경값을 정해주면 axis를 이용해 적용할 축을 지정해줘야함.
>>
    col1  idx2  idx3  col4
3      1   NaN   NaN     4
6      2   NaN   NaN     8
11     3   NaN   NaN    12

index / columns를 이용할 경우

print(df.reindex(columns=col2)) # index나 columns를 이용해 대상 축에 변경값을 바로 적용할 수 있다.
>>
    col1  idx2  idx3  col4
3      1   NaN   NaN     4
6      2   NaN   NaN     8
11     3   NaN   NaN    12

fill_value를 설정하면 NaN을 원하는 값으로 지정하여 변경할 수 있습니다.

print(df.reindex(columns=col2,fill_value='-'))
>>
    col1 idx2 idx3  col4
3      1    -    -     4
6      2    -    -     8
11     3    -    -    12

method 와 limit의 사용

method를 이용하면 결측치를 앞/뒤/근처의 인덱스를 기준으로 변경이 가능합니다.

먼저 기존 열에 새 열을 reindex메서드를 이용해 추가해보겠습니다.

col3 = ['col0','col1','col2','col3','col4','col5','col6','col7']
print(df.reindex(columns=col3))
>>
    col0  col1  col2  col3  col4  col5  col6  col7 #새로 추가된 열은 NaN을 가진다.
3    NaN     1     2     3     4   NaN   NaN   NaN
6    NaN     2     4     6     8   NaN   NaN   NaN
11   NaN     3     6     9    12   NaN   NaN   NaN

method='bfill'인 경우 뒤의 열의 값을 가져옵니다.

print(df.reindex(columns=col3,method='bfill'))
>>
    col0  col1  col2  col3  col4  col5  col6  col7 # col0의 경우 뒤의 열인 col1의 값을 가져옴.
3      1     1     2     3     4   NaN   NaN   NaN # col5, col6, col7의 경우 뒤의 열이 없으니 변경 불가.
6      2     2     4     6     8   NaN   NaN   NaN
11     3     3     6     9    12   NaN   NaN   NaN

method='ffill'인 경우 앞의 열의 값을 가져옵니다.

print(df.reindex(columns=col3,method='ffill'))
>>
    col0  col1  col2  col3  col4  col5  col6  col7 # col0의 경우 앞에 열이 없으므로 변경 불가
3    NaN     1     2     3     4     4     4     4 # col5, col6, col7의 경우 앞의 열의 값을 가져옴
6    NaN     2     4     6     8     8     8     8
11   NaN     3     6     9    12    12    12    12

limit는 method로 변경할 열의 갯수를 제한할 수 있습니다.

print(df.reindex(columns=col3,method='ffill',limit=2))
>>
    col0  col1  col2  col3  col4  col5  col6  col7 # ffill으로 변경할 열의 수를 2로 제한하였기때문에 col5, col6만 변경됨.
3    NaN     1     2     3     4     4     4   NaN
6    NaN     2     4     6     8     8     8   NaN
11   NaN     3     6     9    12    12    12   NaN

tolerance 인수의 사용

│변경 전 인덱스 - 변경 후 인덱스│≤ tolerance 를 만족하게 method 적용 허용 범위를 정할 수 있습니다.

tolerance=1인 경우

idx2 = [4, 8, 14]
print(df.reindex(index=idx2,method='ffill',tolerance=1))
>>
    col1  col2  col3  col4
4    1.0   2.0   3.0   4.0 # │3-4│=1 만족
8    NaN   NaN   NaN   NaN # │6-8│ = 2 불만족
14   NaN   NaN   NaN   NaN # │11-14│ = 3 불만족

tolerance=2인 경우

idx2 = [4, 8, 14]
print(df.reindex(index=idx2,method='ffill',tolerance=2))
>>
    col1  col2  col3  col4
4    1.0   2.0   3.0   4.0 # │3-4│=1 만족
8    2.0   4.0   6.0   8.0 # │6-8│=2 만족
14   NaN   NaN   NaN   NaN # │11-14│=3 불만족

tolerance=3인 경우

idx2 = [4, 8, 14]
print(df.reindex(index=idx2,method='ffill',tolerance=3))
>>
    col1  col2  col3  col4
4      1     2     3     4 # │3-4│=1 만족
8      2     4     6     8 # │6-8│=2 만족
14     3     6     9    12 # │11-14│=3 만족

인덱스 변경 (reindex_like)

reindex_like메서드는 other의 인덱스를 기준으로 self의 인덱스와 값을 적용하는 메서드입니다.

self.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

method : {bfill / ffill / nearest이 결측치를 채울 규칙입니다.

ffill : 바로 전 값으로 결측치를 채웁니다.

bfill : 바로 뒤 값으로 결측치를 채웁니다.

nearest : 근처의 유효값으로 결측치를 채웁니다.

※ 결측치를 채울 때 값의 전/후 값을 기준으로하는것이 아닌 인덱스의 전/후 인덱스를 기준으로 합니다.

copy : 사본을 생성할지 여부입니다.

limit : method인수를 사용할 경우 몇개까지 변경할지 제한할 수 있습니다

tolerance : method인수를 사용할 때 index가 다를 경우 허용 범위 입니다.

★│변경 전 인덱스 - 변경 후 인덱스│≤ tolerance 를 만족하게 method 적용 허용 범위를 정할 수 있습니다.

먼저 self가 될 객체와, other가 될 객체를 만들어보겠습니다.

col1  = ['col1','col3','col6']
idx1  = ['row0','row2','row3']
data1 = [['A','X','+'],['B','Y','-'],['C','Z','=']]
self = pd.DataFrame(data1, idx1, col1)
print(self)
>>
     col1 col3 col6
row0    A    X    +
row2    B    Y    -
row3    C    Z    =

col2  = ['col1','col2','col3','col4','col5','col6']
idx2  = ['row1','row2','row3']
data2 = [[1,2,3,4,5,6],[2,3,6,8,10,12],[3,6,9,12,15,18]]
other = pd.DataFrame(data2, idx2, col2)
print(other)
>>
      col1  col2  col3  col4  col5  col6
row1     1     2     3     4     5     6
row2     2     3     6     8    10    12
row3     3     6     9    12    15    18

인덱스를 열로 변환 (reset_index)

reset_index메서드는 설정 인덱스를 제거하고 기본 인덱스(0,1,2, ... , n)으로 변경하는 메서드 입니다.

level : Multi Index의 경우 제거할 인덱스의 레벨을 설정할수 있습니다. 기본적으로 모든 레벨입니다.

drop : 제거한 인덱스를 열에 추가할지 여부입니다. 기본값은 False로 제거된 인덱스는 열로 변환됩니다.

inplace : pandas 공통 인수로, 원본을 변경할지 여부 입니다.

col_level / col_fill : Multi Index의 경우 제거된 인덱스를 열에 추가할 때 레벨과 열의 이름을 설정할 수 있습니다.

col_level을 통해 레벨을 설정하고, col_fill을통해 해당 열의 이름을 정합니다.

df = pd.DataFrame([[1,2],[3,4],[5,6]],['row1','row2','row3'],['col1','col2'])
print(df)
>>
      col1  col2
row1     1     2
row2     3     4
row3     5     6

.

기본적인 사용법(+drop, inplace)

기본적으로 아무 인수 없이 사용하게 되면, 모든 레벨에 대해 인덱스가 제거되며, 열에 추가됩니다.

print(df.reset_index())
>>
# index라는 열이 생성되고 기존 인덱스가 기본 인덱스로 변경됨
# 기존 인덱스는 열로 변함
  index  col1  col2 
0  row1     1     2
1  row2     3     4
2  row3     5     6

drop = True인 경우 열이 밖으로 꺼내지는게 아니라 완전히 삭제됩니다

print(df.reset_index(drop=True))
>>
#밖으로 꺼내지는게 아닌 완전한 삭제를 합니다
   col1  col2
0     1     2
1     3     4
2     5     6

inplace=True인 경우 원본이 변경되게 됩니다.

Copydf.reset_index(inplace=True)
print(df)
>>
  index  col1  col2
0  row1     1     2
1  row2     3     4
2  row3     5     6

Multi Index의 예시

Multi Index의 예시를 위하여 4x4짜리 Multi Index를 하나 생성하겠습니다.

idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = [['COL1','COL1','COL2','COL2'],['val1','val2','val3','val4']]
data = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
df2 = pd.DataFrame(data,idx,col)
print(df2)
>>
          COL1      COL2
          val1 val2 val3 val4
IDX1 row1    1    2    3    4
     row2    5    6    7    8
IDX2 row3    9   10   11   12
     row4   13   14   15   16

기본적인 사용법(+level)

Multi Index의 경우 level을 설정해줌으로서 제거할 인덱스의 레벨을 선택할 수 있습니다.

level을 입력하지 않은 경우 모든 index에 대해서 수행됩니다.

print(df2.reset_index())
>>
  level_0 level_1 COL1      COL2
                  val1 val2 val3 val4
0    IDX1    row1    1    2    3    4
1    IDX1    row2    5    6    7    8
2    IDX2    row3    9   10   11   12
3    IDX2    row4   13   14   15   16

level=0인 경우

print(df2.reset_index(level=0))
>>
     level_0 COL1      COL2
             val1 val2 val3 val4
row1    IDX1    1    2    3    4
row2    IDX1    5    6    7    8
row3    IDX2    9   10   11   12
row4    IDX2   13   14   15   16

level=1인 경우

print(df2.reset_index(level=1))
>>
     level_1 COL1      COL2
             val1 val2 val3 val4
IDX1    row1    1    2    3    4
IDX1    row2    5    6    7    8
IDX2    row3    9   10   11   12
IDX2    row4   13   14   15   16

col_fill / col_level의 사용

col_fill을 이용하여 열로 변경되는 인덱스의 열 이름을 설정할 수 있습니다. COL0으로 설정해보겠습니다.

print(df2.reset_index(level=1,col_fill='COL0'))
>>
     level_1 COL1      COL2
        COL0 val1 val2 val3 val4 #COL0이 열 이름으로 생성됨.
IDX1    row1    1    2    3    4
IDX1    row2    5    6    7    8
IDX2    row3    9   10   11   12
IDX2    row4   13   14   15   16

col_level을 이용해 열 이름의 레벨을 정할 수 있습니다. COL0을 다른 열이름에 맞게 LEVEL을 변경해보겠습니다.

print(df2.reset_index(level=1,col_fill='COL0',col_level=1))
>>
        COL0 COL1      COL2
     level_1 val1 val2 val3 val4
IDX1    row1    1    2    3    4
IDX1    row2    5    6    7    8
IDX2    row3    9   10   11   12
IDX2    row4   13   14   15   16

멀티인덱스 레벨 변경 (reorder_levels)

reorder_levels메서드는 Multi Index에서 Index의 위치를 변경하는 메서드입니다.

order : 새로 정렬할 인덱스 순서입니다. 리스트 형태입니다.

axis : {0 : index / 1 : columns} 순서를 적용할 축 입니다.

idx = [['IDX1','IDX1','IDX2','IDX2'],['row1','row2','row3','row4']]
col = [['COL1','COL1','COL2','COL2'],['val1','val2','val3','val4']]
data = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
df = pd.DataFrame(data,idx,col)
print(df)
>>
          COL1      COL2
          val1 val2 val3 val4
IDX1 row1    1    2    3    4
     row2    5    6    7    8
IDX2 row3    9   10   11   12
     row4   13   14   15   16

기본적인 사용법

order에 리스트 형태의 level 순서를 입력하므로써 인덱스 순서의 변경이 가능합니다.

print(df.reorder_levels([1,0])) #인덱스 순서를 레벨1 - 레벨0으로 변경
>>
          COL1      COL2
          val1 val2 val3 val4
row1 IDX1    1    2    3    4
row2 IDX1    5    6    7    8
row3 IDX2    9   10   11   12
row4 IDX2   13   14   15   16

axis를 설정하여 적용될 축을 지정할 수 있습니다.

print(df.reorder_levels([1,0],axis=1))
>>
          val1 val2 val3 val4
          COL1 COL1 COL2 COL2
IDX1 row1    1    2    3    4
     row2    5    6    7    8
IDX2 row3    9   10   11   12
     row4   13   14   15   16

index메서드는 pandas객체의 index(행)를 출력합니다

df.index

실행 결과

실행결과는 아래와 같이 Index명과 type이 차례로 출력되는것을 볼 수 있습니다.

반환 타입은 pandas의 Index타입임을 사용에 참고 바랍니다.

result = df.index
print(result)
>>
Index(['row1', 'row2', 'row3'], dtype='object')

열 (Columns)

columns메서드는 pandas객체의 columns(열)을 출력합니다.

df = pd.DataFrame([[1,2,3], [4,5,6], [7,8,9]], index=['row1', 'row2', 'row3'], columns=['col1', 'col2', 'col3'])
print(df)

실행결과는 아래와 같이 columns명과 type이 차례로 출력되는것을 볼 수 있습니다. 반환 타입은 index함수에서와 같이 pandas의 Index타입임을 사용에 참고 바랍니다.

result = df.columns
print(result)
>>
Index(['col1', 'col2', 'col3'], dtype='object')

데이터 타입 (dtype)

dtypes 메서드는 열에 포함된 데이터들의 type을 Series형태로 반환합니다.

반환된 Series의 index는 원래 DataFrame 객체의 columns(열)에 해당됩니다.

df = pd.DataFrame([[1,'A',3.1], [4,'B',6.2], [7,'C',9.3]], index=['row1', 'row2', 'row3'], columns=['col1', 'col2', 'col3'])
print(df)
>>
      col1 col2  col3
row1     1    A   3.1
row2     4    B   6.2
row3     7    C   9.3

아래와 같이 실행 시 각 columns에 대해 dtypes를 반환합니다. 만약 type이 혼합되어있는경우

object 타입으로 반환합니다.

result = df.dtypes
print(result)
>>
col1      int64
col2     object
col3    float64
dtype: object
#시리즈로 받아낸다

print(type(result))
>>
<class 'pandas.core.series.Series'>

축 (axes)

axes메서드는 DataFrame 객체의 축(axes) 레이블 정보를 list형태로 반환합니다.

list의 첫 번째 요소는 행(row), 두 번째 요소는 열(columns)로 반환되며, 각각의 type은 index입니다.

추가로 요소의 type이 함께 출력됩니다.

df = pd.DataFrame(data=[[1,2],[3,4],[5,6],[7,8]],index=['row1','row2','row3','row4'],columns=['col1','col2'])
print(df)
>>
      col1  col2
row1     1     2
row2     3     4
row3     5     6
row4     7     8

df.axes실행시 아래와 같이 list형태로 축의 정보가 출력되는것을 확인할 수 있습니다.

result = df.axes
print(result)
>>
[Index(['row1', 'row2', 'row3', 'row4'], dtype='object'), Index(['col1', 'col2'], dtype='object')]

print(result[0])
>>
Index(['row1', 'row2', 'row3', 'row4'], dtype='object')

print(result[1])
>>
Index(['col1', 'col2'], dtype='object')

차원 (ndim)

ndim메서드는 데이터의 차원(축의 수)를 반환합니다. Series일경우 1차원, DataFrame이면 2차원이므로

데이터의 종류 파악에 사용할 수 있습니다.

df1 = pd.Series({'idx1':1,'idx2':2,'idx2':2})
print(df1)
>>
idx1    1
idx2    2
dtype: int64

df2 = pd.DataFrame(data=[[1,2],[3,4]],index=['row1','row2'],columns=['col1','col2'])
print(df2)
>>
      col1  col2
row1     1     2
row2     3     4

ndim 함수 사용시, Series의 경우 1을 반환하고 DataFrame의 경우 2를 반환하는것을 확인할 수 있습니다.

Copyprint(df1.ndim)
print(df2.ndim)
>> 1
>> 2

요소의 갯수(size)

size메서드는 데이터의 총 수의 갯수를 구합니다. 즉, Series일 경우 행의 수를 반환하고

df1 = pd.Series({'idx1':1,'idx2':2,'idx2':2})
print(df1)
>>
idx1    1
idx2    2
dtype: int64

df2 = pd.DataFrame(data=[[1,2],[3,4]],index=['row1','row2'],columns=['col1','col2'])
print(df2)
>>
      col1  col2
row1     1     2
row2     3     4

size 함수 사용시, 요소의 수를 반환 한 것을 확인 할 수 있습니다.

print(df1.size)
print(df2.size)
>> 2
>> 4

차원의 형태 (shape)

shape 메서드는 DataFrame 객체의 차원의 형태를(레이블 정보)를 튜플의 형식으로 반환합니다.

즉, 3행 2열의 객체의 경우 (3,2)를 반환합니다.

data1= [[1,2,3],[4,5,6],[7,8,9]]
df1 = pd.DataFrame(data = data1, index = ['row1', 'row2', 'row3'], columns=['col1','col2','col3'])
print(df1)
>>
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9

data2 = [[1,2,3,4]]
df2 = pd.DataFrame(data =data2, index = ['row1'], columns=['col1','col2','col3','col4'])
print(df2)
>>
      col1  col2  col3  col4
row1     1     2     3     4

shape 함수 사용 시, 아래와 같이 3행3열, 1행4열의 정보가 튜플 형태로 반환된 것을 확인할 수 있습니다.

print(df1.shape)
print(df2.shape)
>>(3, 3)
>>(1, 4)

정보축 (keys)

keys 메서드는 'info axis(정보축)' 값을 가져옵니다.

여기서 정보축이란 Series에서는 index, DataFrame에서는 열을 말합니다.

data = [[1,2,3],[4,5,6],[7,8,9]]
col = ['col1','col2','col3']
row = ['row1','row2','row3']
df = pd.DataFrame(data=data,index=row,columns=col)
print(df)
>>
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9

DataFrame 객체이기 때문에 key 메서드를 사용할 경우 열의 값을 가져옵니다.

print(df.keys)
.>>
<bound method NDFrame.keys of       col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9>

키값(열의 요소) 반환 (get)

get 메서드는 pandas객체에서 key값(예: DataFrame에서 열)을 검색해서 요소를 가져옵니다.

찾는게 없을경우 default 값을 반환합니다.

data = [[1,2,3],[4,5,6],[7,8,9]]
col = ['col1','col2','col3']
row = ['row1','row2','row3']
df = pd.DataFrame(data=data,index=row,columns=col)
print(df)
>>
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9

key='col1'로 해서 col1의 요소를 반환해보겠습니다.

result = df.get('col1')
print(result)
>>
row1    1
row2    4
row3    7
Name: col1, dtype: int64

key='col4'로 해서 존재하지 않는 col4를 반환하면 default 값인 None을 반환하게 됩니다.

result = df.get('col100')
print(result)
>>
None

default값을 설정해줌으로써 원하는 반환을 설정할 수 있습니다.

result = df.get('col4',default='값이없습니다.')
print(result)
>>
값이없습니다.

비교 (compare)

compare 메서드는 두 객체의 요소의 차이를 반환합니다.

other : 원본과 비교할 데이터입니다. align_axis : {0 : index / 1 : columns} self와 other를 정렬할 축입니다.

keep_shape : 원본의 모양을 유지할지 여부입니다. False인 경우 차이가 있는 행만 출력합니다.

keep_equal : 값이 같은경우 값을 출력할지 여부입니다. 기본값은 False로 NaN을 출력합니다.

idx = ['row1','row2','row3','row4']
col = ['col1','col2','col3']
data1 = [['A',1,11],['B',2,12],['C',3,13],['D',4,14]]
data2 = [['X',1,11],['B','Y',12],['C',3,13],['D',4,'Z']]
df1 = pd.DataFrame(data1, idx, col)
df2 = pd.DataFrame(data2, idx, col)
print(df1)
print(df2)
>>
     col1  col2  col3
row1    A     1    11
row2    B     2    12
row3    C     3    13
row4    D     4    14

     col1 col2 col3
row1    X    1   11
row2    B    Y   12
row3    C    3   13
row4    D    4    Z

compare메서드를 이용해서 단순히 df1과 df2를 비교할 경우 아래와 같이 self와 other이 multi columns로 추가되며 차이가 있는 행만 출력하고, 동일한 값은 NaN을 출력하게 됩니다.

print(df1.compare(df2))#df1을 df2에 비교한다 
#self = df1
#other = df2
>>
     col1       col2        col3
     self other self other  self other
row1    A     X  NaN   NaN   NaN   NaN
row2  NaN   NaN  2.0     Y   NaN   NaN
row4  NaN   NaN  NaN   NaN  14.0     Z

align_axis인수의 사용

align_axis인수를 사용하여 self와 other 카테고리가 multi index로 반환될지 multi columns로 반환될지 지정할 수 있습니다.

align_axis=0일 경우 multi index로 출력됩니다.

print(df1.compare(other=df2, align_axis=0))
>>
           col1 col2  col3
row1 self     A  NaN   NaN
     other    X  NaN   NaN
row2 self   NaN  2.0   NaN
     other  NaN    Y   NaN
row4 self   NaN  NaN  14.0
     other  NaN  NaN     Z

align_axis=1일 경우 multi columns으로 출력됩니다.(기본값)

print(df1.compare(other=df2, align_axis=1))
>>
     col1       col2        col3
     self other self other  self other
row1    A     X  NaN   NaN   NaN   NaN
row2  NaN   NaN  2.0     Y   NaN   NaN
row4  NaN   NaN  NaN   NaN  14.0     Z

keep_shape인수의 사용

keep_shape=True로 사용할 경우 기존 열을 모두 출력하게되고, keep_shape=False일 경우(기본값) 차이가 있는 열만 출력하게 됩니다.

print(df1.compare(other=df2, keep_shape=True))
>>
     col1       col2        col3
     self other self other  self other
row1    A     X  NaN   NaN   NaN   NaN
row2  NaN   NaN  2.0     Y   NaN   NaN
row3  NaN   NaN  NaN   NaN   NaN   NaN
row4  NaN   NaN  NaN   NaN  14.0     Z

print(df1.compare(other=df2, keep_shape=False))
>>
     col1       col2        col3
     self other self other  self other
row1    A     X  NaN   NaN   NaN   NaN
row2  NaN   NaN  2.0     Y   NaN   NaN
row4  NaN   NaN  NaN   NaN  14.0     Z

keep_equal인수의 사용

keep_equal인수를 사용할 경우 같은값을 출력할지 아니면 NaN으로 출력할지 지정할 수 있습니다.

keep_eaual=True인 경우 같은값도 출력합니다.

print(df1.compare(other=df2, keep_equal=True))
>>
     col1       col2       col3
     self other self other self other
row1    A     X    1     1   11    11
row2    B     B    2     Y   12    12
row4    D     D    4     4   14     Z

keep_eaual=False인 경우 같은값은 NaN을 출력합니다.(기본값)

Copyprint(df1.compare(other=df2, keep_equal=False))
>>
     col1       col2        col3
     self other self other  self other
row1    A     X  NaN   NaN   NaN   NaN
row2  NaN   NaN  2.0     Y   NaN   NaN
row4  NaN   NaN  NaN   NaN  14.0     Z

고유한 행의 수 (value_counts)

value_counts메서드는 고유한 행의 갯수를 반환합니다.

고유한 행이란 구성요소의 값이 완전히 동일한 경우를 말합니다.

subset : 기준으로 삼을 열 입니다. list형태로도 입력이 가능합니다.

normalize : 갯수가 아니라 비율로 출력합니다.

sort : 빈도 순서로 정렬할지 여부입니다. 기본값은 True입니다.

ascending : 오름차순으로 정렬할지 여부입니다.

dropna : 결측치를 제외할지 여부입니다. 기본값은 True로 결측값은 제외됩니다.

n=np.NaN
idx = ['row1','row2','row3','row4','row5']
col = ['col1','col2','col3']
data = [['A','Z',3,],['D','Y',n],['B','Z',3],['C','Y',8],['A','Z',3]]
df = pd.DataFrame(data, idx, col)
print(df)
>>
     col1 col2  col3
row1    A    Z   3.0
row2    D    Y   NaN
row3    B    Z   3.0
row4    C    Y   8.0
row5    A    Z   3.0

기본적인 사용법(+subset)

요소로 아무값도 입력하지 않는 경우 행의 모든 값을 대상으로 완전히 같은 행의 갯수를 우측에 출력하게됩니다.

print(df.value_counts())
>>

## row1과 row5는 완벽히 동일한 값을 가지므로 2로 출력되고, row2의 경우 결측치가 있어 제외됨.
col1  col2  col3
A     Z     3.0     2
B     Z     3.0     1
C     Y     8.0     1
Name: count, dtype: int64

subset에 값을 입력해 줄경우 입력된 열의 값에 대해서만 동일성 검증을 진행하게 됩니다.

col2, col3에 대해서만 실행해보겠습니다.

print(df.value_counts(subset=['col2','col3']))
>>
col2  col3  # row1, row3, row5는 col2, col3의 값이 같으므로 3으로 출력됩니다.
Z     3.0     3
Y     8.0     1
dtype: int64

normalize인수의 사용

normalize인수를 사용할 경우 동일한 행의 갯수가 아닌 전체에서 차지하는 비율로 출력됩니다.

normalize=False인 경우(기본값)

print(df.value_counts(subset='col2',normalize=False))
>>
col2
Z    3
Y    2
dtype: int64

normalize=True인 경우

print(df.value_counts(subset='col2',normalize=True))
>>
col2
Z    0.6    #전체 5개중 3개로 60% 인 0.6 출력
Y    0.4    #전체 5개중 2개로 40% 인 0.4 출력
dtype: float64

ort와 ascending인수의 사용

sort인수를 사용할 경우 최빈값부터 정렬하게되고, ascending을 사용할 경우 오름차순으로 정렬하게 됩니다.

먼저 비교를 위해 sort=False이고 ascending=False으로 출력해보겠습니다.

print(df.value_counts(subset=['col2','col3'],sort=False,ascending=False))
>>
col2  col3
Y     8.0     1
Z     3.0     3
dtype: int64

sort=True인 경우(기본값) 제일 고유값의 갯수가 많은 행부터 정렬됩니다.

print(df.value_counts(subset=['col2','col3'],sort=True,ascending=False))
>>
col2  col3
Z     3.0     3
Y     8.0     1
dtype: int64

ascending=True인 경우 오름차순으로 정렬됩니다.

print(df.value_counts(subset=['col2','col3'],sort=True,ascending=True))
>>
col2  col3
Y     8.0     1
Z     3.0     3
dtype: int64

dropna의 사용(결측치 포함 여부)

dropna=True인 경우(기본값) 결측치가 포함된 행은 계산하지 않습니다. False인 경우 포함하게됩니다.

Copyprint(df.value_counts(subset=['col2','col3'],dropna=False))
>>
col2  col3
Z     3.0     3
Y     8.0     1
      NaN     1
dtype: int64

고유한 요소의 수 (nunique)

nunique메서드는 선택된 축에 대해서 고유한 요소의 수를 구하는 메서드입니다.

axis : 기준이 되는 축 입니다.

dropna : 결측치를 무시할지 여부 입니다. False일경우 하나의 요소로 간주합니다.

idx =  ['row1','row2','row3']
col =  ['col1','col2','col3']
data = [[1,1,n],[1,2,6],[1,3,n]]
df = pd.DataFrame(data, idx, col)
print(df)
>>
      col1  col2  col3
row1     1     1   NaN
row2     1     2   6.0
row3     1     3   NaN

기본적인 사용법

기본값인 axis=0으로 실행할 경우 각 축에 대해서 고유값의 갯수를 출력합니다.

즉, 각 열에 대해서 값의 종류의 수를 반환합니다.

print(df.nunique(axis=0))
>>
col1    1 # col1의 경우 1 한종류만 있음
col2    3 # col2의 경우 1,2,3으로 3 종류있음
col3    1 # col3의 경우 na를 제외하고 6 한종류만 있음
dtype: int64

만약 dropna=False로 할 경우 NaN도 하나의 요소로 간주합니다.

print(df.nunique(axis=0,dropna=False))
>>
#dropna가 false면 nan도 하나의 요소로 간주하기 때문에 1->2로 유니크가 늘어난다
col1    1
col2    3
col3    2 # col3에는 NaN과 6, 2 종류가 있음
dtype: int64

axis=1로 하면 행 기준으로 메서드가 실행됩니다.

print(df.nunique(axis=1))
>>
row1    1
row2    3
row3    2
dtype: int64

dtype변경 (astype)

astype 메서드는 열의 요소의 dtype을 변경하는함수 입니다.

dtype : 변경할 type입니다.

copy : 사본을 생성할지 여부입니다.

errors : {'raies', 'ignore'} : 변경불가시 오류를 발생시킬 여부입니다.

copy는 사본을 생성할지 여부 입니다. False로 할 경우 원본 데이터의 값이 변경 될 경우

원본 데이터를 사용해 생성된 객체의 데이터도 변경되기 때문에 False의 선택은 신중해야합니다.

errors는 변경 불가능한 dtype일 경우 오류를 발생시킬지 여부입니다. False로 하여 오류를

발생시키지 않으면, 변경불가능한 요소는 원래 dtype 그대로 보존됩니다.

먼저, 아래와 같이 기본적인 4x4 행렬을 만듭니다. col1은 int64, col2는 object, col3은 float64, col4는 bool의 dtype을 가집니다.

col1 = [1, 2, 3, 4]
col2 = ['one', 'two', 'three', 'four']
col3 = [1.5, 2.5, 3.5, 4.5]
col4 = [True, False, False, True]
index = ['row1','row2','row3','row4']
df = pd.DataFrame(index=index, data={"col1": col1, "col2": col2, "col3": col3, "col4": col4})
print(df)
>>
      col1   col2  col3   col4
row1     1    one   1.5   True
row2     2    two   2.5  False
row3     3  three   3.5  False
row4     4   four   4.5   True

print(df.dtypes)
>>
col1      int64
col2     object
col3    float64
col4       bool
dtype: object

한개의 열만 type 변경

열의 dtype 변경 시 딕셔너리 형태로 {'열이름' : '변경 dtype'}와 같이 입력해줍니다.

df1 = df.astype({'col1':'int32'})# astype({바꿀값의 인덱스:바꿀갑})
print(df1.dtypes)
>>
col1      int32
col2     object
col3    float64
col4       bool
dtype: object

int64 였던 col1의 dtype이 int32로 변경된 것을 확인할 수 있습니다.

다수의 열의 dtype 변경

다수의 열의 변경도 딕셔너리 형식을 이용하면 됩니다.

df1 = df.astype({'col1':'int32', 'col3':'int64'})#다수의 타입 변경은 콤마를 찍어주면 간단하다
print(df1.dtypes)
>>
col1     int32
col2    object
col3     int64
col4      bool
dtype: object

int64 였던 col1의 dtype이 int32로 변경되고 float64였던 col3의 dtype의 값이 int64로 변경된 것을 확인할 수 있습니다.

모든 열의 dtype 변경

모든열의 변경을 하고자하는 경우 dtype 인수에 원하는 dtype을 입력해주는 것만으로도 가능합니다.

df1= df.astype(dtype='int64')#모든 열을 변경하고자 하면 dtype에 변경하고자 하는 타입을 집어 넣으면 된다
print(df1.dtypes)
>>
ValueError: invalid literalfor int()with base 10: 'one'

col2 : object형식은 int64형태로 변경할 수가 없기 때문에 오류가 발생합니다. 변경 가능한 열만 변경하려면, 아래와 같이 errors 인수를 기본값인 'raise' 에서 'ignore'로 변경하면 됩니다.

Copydf1= df.astype(dtype='int64',errors='ignore')#errors='ignore'은 에러를 무시해준다
print(df1.dtypes)
>>
col1     int64
col2    object
col3     int64
col4     int64
dtype: object

열의 dtype통일 (convert_dtypes)

convert_dtypes 메서드는 열의 요소가 혼합된 dtype일 경우, 열의 요소를 같은 dtype으로 통일할 수 있는 가장 합리적인 형식을 갖는 pd.NA로 변환합니다.

infer_object : dtype이 object인 경우 적절한 type으로 변경 할지의 여부입니다. 기본적으로 True이며,

이 경우 열의 요소를 확인해서 가장 적절한 dtype을 가진 pd.NA를 반환합니다.

convert_string, convert_integer, convert_boolean, convert_floating : 해당 유형으로의 pd.NA를 설정할지의 여부입니다.

기본적으로 True이기 때문에, 가능한 모든 dtype에 대해서 적절한 값을 반환합니다.

먼저, 아래와 같이 NaN이 포함된 3x4 행렬을 만듭니다.

col1은 string, col2는 bool, col3, col4는 dtype을 가지지만, NaN 을 포함하기 때문에

col1과 col2는 object 형식을 갖는것을 볼 수 있습니다.

**col1 = ['a','b',np.nan]
col2 = [True, np.nan, False]
col3 = [np.nan, 2, 4]
col4 = [1.4, np.nan, 2.5]
df = pd.DataFrame(data={'col1':col1,'col2':col2,'col3':col3,'col4':col4},index=['row1','row1','row3'])
print(df)
>>
     col1   col2  col3  col4
row1    a   True   NaN   1.4
row1    b    NaN   2.0   NaN
row3  NaN  False   4.0   2.5**

print(df.dtypes)
>>
col1     object
col2     object
col3    float64
col4    float64
dtype: object

이제 df.convert_dtype를 실행해서 가장 적절한 dtype으로 만들 수 있는

np.NA를 추가해보겠습니다.

result = df.convert_dtypes()
print(result)
>>
#nan은 not a number이지만 na값은 다르다
      col1   col2  col3  col4
row1     a   True  <NA>   1.4
row1     b   <NA>     2  <NA>
row3  <NA>  False     4   2.5

위와 같이 기존 NaN들이 NA 형태로 변경된 것을 확인 할 수 있습니다.

그럼 이어서 dtype또한 변경되었는지 확인해보겠습니다.

print(result.dtypes)
>>
col1     string
col2    boolean
col3      Int64
col4    Float64
dtype: object

각 열의 dtype또한 기돈 object type에서 string, boolean, int64, float64로

각각에 맞게 변경된 것을 확인할 수 있습니다.

object 열의 적절 dtype추론(infer_objects)

infer_object메서드는 dtype이 object인 열에 대해서 적당한 dtype을 추론합니다.

사용법을 참고 바랍니다.

먼저 str과 int가 혼합된 col1을 가진 DataFrame 객체를 만들어 dtype이 object인 열을 만들어 보겠습니다.

col1 = ['a','b', 3, 4]
df = pd.DataFrame({'col1':col1},index=['row1','row2','row3','row4'])
print(df)
print(df.dtypes)
>>
     col1
row1    a
row2    b
row3    3
row4    4

col1    object
dtype: object

이제 df에서 형식이 int인 행만 남겨서 인덱싱을 한 뒤. dtype을 살펴보면, 여전히 dtype이 object인 것을 확인 할 수 있습니다.

df = df.iloc[2:]
print(df)
>>
     col1
row3    3
row4    4

print(df.dtypes)
>>
col1    object
dtype: object

이런 경우에 대해 infer_object는 가장 적당한 dtype을 제안하는 기능을 합니다.

print(df.infer_objects())
>>
      col1
row3     3
row4     4

print(df.infer_objects().dtypes)
>>
col1    int64
dtype: object

위와 같이 int형식만 남은 df의 col1 열에 대해 가장 적절한 dtype인 int64로 변환된 것을 확인할 수 있습니다.

최대/최소값이 포함된 행/열 (idxmax / idxmin)

idxmax와 idxmin은 각각 축에서 최대/최소값의 인덱스를 반환하는 메서드입니다.

axis : {0 : index / 1:columns} 기준이 될 축입니다.

skipna : 결측치의 무시 여부입니다. True면 결측치가 포함된 열은 무시하고 False면 NaN를 출력합니다.

n=np.nan
idx =  ['row1','row2','row3']
col =  ['col1','col2','col3']
data = [[1,2,200],[100,5,6],[7,300,n]]
df = pd.DataFrame(data, idx, col)
print(df)
>>
      col1  col2   col3
row1     1     2  200.0
row2   100     5    6.0
row3     7   300    NaN

axis=0인경우(기본값) 열에서 최대/최소 값에 해당되는 행을 출력합니다.

print(df.idxmax(axis=0))
>>
col1    row2
col2    row3
col3    row1
dtype: object

print(df.idxmin(axis=0))
>>
col1    row1
col2    row1
col3    row2
dtype: object

axis=1인경우 행에서 최대/최소 값에 해당되는 열을 출력합니다.

print(df.idxmax(axis=1))
>>
row1    col1
row2    col2
row3    col1
dtype: object

print(df.idxmin(axis=1))
>>
row1    col1
row2    col2
row3    col1
dtype: object

skipna인수의 사용

skipna인수는 기본값이 True로 결측값이 포함된 행/열을 연산에서 무시합니다. False일 경우 NaN를 출력하게됩니다.

Copyprint(df.idxmax(axis=1,skipna=False))
>>
row1    col1
row2    col2
row3     NaN
dtype: object

비어있는지 확인 (empty)

empty메서드는 DataFrame이 비어있는지 여부를 bool 형식으로 반환합니다.

여기서 비어있다는것은 정말 완전히 비어있는 상태를 말하는 것으로,

공백 문자열("")이나 Nan의 경우조차 허용하지 않는것을 말합니다.

즉, 축이 존재하지 않는 경우를 말합니다.

공백으로 이루어진 객체, Nan으로 이루어진 객체, 행이 없는 객체, 열이 없는객체로 확인해보겠습니다.

data_empty=[['','',''],['','',''],['','','']]
df = pd.DataFrame(data = data_empty, index = ['row1', 'row2', 'row3'], columns=['col1','col2','col3'])
print(df)
>>
     col1 col2 col3
row1
row2
row3

print(df.empty)

#행,열이 공백이기 때문에 false
>> False

공백으로 이루어져있지만 df.empty 가 False로 출력됩니다.

""으로 차있기 때문입니다.

NaN으로 이루어진 객체

df = pd.DataFrame(data = np.nan, index = ['row1', 'row2', 'row3'], columns=['col1','col2','col3'])
print(df)
>>
      col1  col2  col3
row1   NaN   NaN   NaN
row2   NaN   NaN   NaN
row3   NaN   NaN   NaN

print(df.empty)
#모두 결측값이기 때문에 false
>> False

NaN으로 이루어진 객체 또한, 어쨌던 Nan으로 채워져 있기 때문에 df.empty값을 False로 반환합니다.

행이나 열이 없는 객체

열이없는경우

df1 = pd.DataFrame(index = ['row1', 'row2', 'row3']) # 열이 없는 객체
print(df1)
>>
Empty DataFrame
Columns: [] #열이 없다
Index: [row1, row2, row3]#인덱스는 행 1,2,3밖에 없다

print(df1.empty)
#구성요소가 없기 때문에 true
>> True

행이 없는 경우

df2 = pd.DataFrame(columns=['col1','col2','col3']) # 행이 없는 객체
print(df2)
>>
Empty DataFrame
Columns: [col1, col2, col3]
Index: []

print(df2.empty)
>> True

행이나 열이 없는 경우는 아예 구성하는 요소가 없기 때문에 df.empty가 True로 반환되는것을 볼 수 있습니다.

일치하는 요소 확인 (isin)

value : Iterable, Series, DataFrame, dict등이 올 수 있습니다.

Series일 경우 : Index가 일치해야 합니다.

DataFrame일 경우 : Index와 열 레이블이 일치해야 합니다.

Dict일 경우 : key는 열 레이블 입니다.

data = [[1,1,1],[2,3,4],[5,3,6]]
col = ['col1','col2','col3']
row = ['row1','row2','row3']
df = pd.DataFrame(data=data,index=row,columns=col)
print(df)
>>
      col1  col2  col3
row1     1     1     1
row2     2     3     4
row3     5     3     6

list의 사용

리스트를 이용하여 1과 3이 포함된 요소를 확인해보겠습니다.

result = df.isin([1,3])
print(result)
>>
#1,3일 경우 true를 반환함
       col1  col2   col3   
row1   True  True   True
row2  False  True  False
row3  False  True  False

dict의 사용

dict를 사용해서 col1에서는 2,3인 경우, col3에서는 1,6이 포함된 요소를 확인해보겠습니다.

result = df.isin({'col1':[2,3],'col3':[1,6]})
print(result)
#col1에서는 2,3이 있는지 col3에서는 1,6이 있는지
>>
       col1   col2   col3
row1  False  False   True
row2   True  False  False
row3  False  False   True

Series 와 DataFrame의 사용

DataFrame객체를 사용하기위해 match_df라는 DataFrame객체를 하나 만들어보겠습니다.

match_col = ['col1','col3']
match_row = ['row1','row3']
match_data = [[2,3],[1,6]]
match_df = pd.DataFrame(data=match_data,index=match_row,columns=match_col)
print(match_df)
>>
      col1  col3
row1     2     3
row3     1     6

이제 이 match_df를 value로 isin 메서드를 사용해보겠습니다.

result = df.isin(match_df)
print(result)
>>
       col1   col2   col3   # match_df에 지정된 row,col의 값과 일치할 때만 True를 반환합니다.
row1  False  False  False
row2  False  False  False
row3  False  False   True

요소의 True/False 확인 (all / any)

all/any는 축의 값들의 True/False여부를 판단하는 메서드입니다.

all은 축의 값이 전부 True이면 True반환, 하나라도 False가 있으면 False를 반환합니다.

any는 축의 값이 하나라도 True가 있으면 True반환, 전부 False이면 False를 반환합니다.

axis : {0 : index / 1:columns} 기준이 될 축입니다.

bool_only : True면 축의 모든 값이 bool인 경우에만 계산을 수행합니다. None면 모든 경우를 고려합니다.

예를들어 0과 공백()은 False로 고려되고 결측값(pd.NA)은 True로 고려되는 등 입니다.

skipna : 결측치의 무시 여부입니다. True면 결측치가 포함된 열은 무시됩니다.

level : Multi Index에서 레벨의 선택입니다.

kwargs : 추가 키워드는 효과가 없지만 NumPy와의 호환성을 위해 허용될 수 있습니다.

[N,T,F]=[pd.NA,True,False]
idx = ['row1','row2','row3','row4']
data = {'col1':[T,T,T,T], 'col2':[F,F,F,F],'col3':[F,T,T,T],'col4':[T,N,T,T],'col5':[T,T,'',T],'col6':[T,T,T,0]}
df = pd.DataFrame(data=data, index=idx)
print(df)
>>
      col1   col2   col3  col4  col5  col6
row1  True  False  False  True  True  True
row2  True  False   True  <NA>  True  True
row3  True  False   True  True        True
row4  True  False   True  True  True     0

기본적인 사용법(all과 any 비교)

all은 축의 값이 전부 True면 True를 반환하고 any는 하나라도 True면 True를 반환합니다.

0과 공백()은 False로, 결측값(pd.NA)은 True로 분류됩니다.

print(df.all())
>>
col1     True #모두 True
col2    False #모두 False
col3    False #1개가 Ture
col4     True #<NA>포함(나머지True)
col5    False #공백 포함(나머지True)
col6    False #0포함(나머지True)
dtype: bool

print(df.any())
>>
col1     True #모두 True
col2    False #모두 False
col3     True #1개가 Ture
col4     True #<NA>포함(나머지True)
col5     True #공백 포함(나머지True)
col6     True #0포함(나머지True)
dtype: bool

any의 경우 하나라도True면 True를 반환하기때문에, axis=1로 하여 행 기준으로 실행하면, 모두 True를 반환하는것을 볼 수 있습니다.

print(df.any(axis=1))
>>
row1    True
row2    True
row3    True
row4    True
dtype: bool

bool_only인수의 사용

bool_only=True일 경우 모든 요소가 bool형식인 경우만 계산됩니다.

print(df.all(bool_only=True))
>>
col1     True
col2    False
col3    False
dtype: bool

skipna인수의 사용

skipna=True인 경우 결측치는 True로서 계산되며, skipna=False인 경우 결측치가 포함된 축이 계산에서 제외됩니다.

print(df.all(skipna=True))
>>
col1     True
col2    False
col3    False
col4     True
col5    False
col6    False
dtype: bool

print(df.all(skipna=False))
>>
col1     True
col2    False
col3    False
col5    False
col6    False
dtype: bool

결측값이 아닌 요소의 수 (count)

count메서드는 각 행/열에 결측치가 아닌 요소의 갯수를 구합니다.

axis : 적용할 축입니다.

level : Multi Index의 경우 레벨을 설정할 수 있습니다.

numeric_only : True일 경우 int, float, bool 형태인 경우만 출력합니다.

[N,T,F]=[pd.NA,True,False]
idx = ['row1','row2','row3','row4']
data = {'col1':[1,N,N,4.0],'col2':['A','B','C',N],'col3':[N,N,N,7],'col4':[1,2.4,3.6,4]}
df = pd.DataFrame(data,idx)
print(df)
>>
      col1  col2  col3  col4
row1     1     A  <NA>   1.0
row2  <NA>     B  <NA>   2.4
row3  <NA>     C  <NA>   3.6
row4   4.0  <NA>     7   4.0

기본적인 사용법

axis에 대해서 기본값은 0으로 열에 대해서 결측치가 아닌 값의 갯수를 구합니다.

print(df.count())
>>
col1    2
col2    3
col3    1
col4    4
dtype: int64

axis=1인 경우 행에 대해서 결측치가 아닌 값의 갯수를 구합니다.

print(df.count(axis=1))
>>
row1    3
row2    2
row3    2
row4    3
dtype: int64

numeric_only인수의 사용

numeric_only=True인 경우 int, float, bool로 구성된 행/열에 대해서만 계산값을 반환합니다.

print(df.count(numeric_only=True))
>>
col4    4
dtype: int64

일치 여부 (equals)

equals메서드는 두 객체가 완벽하게 동일한지를 확인하는 메서드입니다.

other : df와 일치하는지 비교할 객체입니다.

먼저 2x2짜리 객체를3개 만들어보겠습니다.

df1과 df2는 완벽하게 같고, df3는 3의 값이 3.0으로 type이 다릅니다.

df1 = pd.DataFrame(data=[[1,N],[3,T]])
df2 = pd.DataFrame(data=[[1,N],[3,T]])
print(df1)
>>
   0     1
0  1  <NA>
1  3  True

df3 = pd.DataFrame(data=[[1,N],[3.0,T]])
print(df3)
>>
     0     1
0  1.0  <NA>
1  3.0  True

기본적인 사용법

두 객체가 완벽히 같을경우 True를 반환하며 다를경우 False를 반환합니다. 요소의 type이 다르더라도 False를 반환합니다.

print(df1.equals(df2))
>>
#df1과 df2를 비교하여 데이터 타입이 같은지 확인한다
True

print(df1.equals(df3))
>>
False

1칸 객체의 bool 확인 (bool)

bool 메서드는 1칸짜리 Series나 DataFrame에 대해서 bool 값의 True or False여부를 확인합니다.

값이 bool이 아니거나 1칸이 아니라면 Value Error를 발생시킵니다.

먼저 1x1짜리 이며 값이 bool인 DataFrame객체를 2개 만들어보겠습니다.

df1은 True, df2는 False입니다.

df1 = pd.DataFrame([True],['row'],['col'])
print(df1)
>>
      col
row  True

df2 = pd.DataFrame([False],['row'],['col'])
print(df2)
>>
       col
row  False

기본적인 사용법

1칸짜리 객체의 bool값을 그대로 반환하게 됩니다.

print(df1.bool( ))
>>
True

print(df2.bool( ))
>>
False

중복행 확인 (duplicated)

duplicated 메서드는 중복되는 행을 확인하는 메서드입니다.

행의 모든 요소가 동일한 행이 이미 존재할경우 해당 행은 True로 반환됩니다.

subset : 특정 열만을 대상으로 할 수 있습니다. list의 사용도 가능합니다.

keep : {first : 위부터 검사 / last : 아래부터 검사} 검사 순서를 정합니다. first일 경우 위부터 확인해서 중복행이 나오면 True를 반환하며, last일 경우 아래부터 확인합니다.

idx = ['row1','row2','row3','row4','row5']
col = ['col1','col2','col3']
data= [['A','가',1],['A','가',1],['A','나',2],['B','나',3],['B','다',4]]
df = pd.DataFrame(data, idx, col)
print(df)
>>
     col1 col2  col3
row1    A    가     1
row2    A    가     1
row3    A    나     2
row4    B    나     3
row5    B    다     4

기본적인 사용법

기본적으로 keep='first'이며 위에서부터 행을 확인하여 중복인 행이 나오면 True를 반환합니다.

print(df.duplicated(keep='first'))
>>
row1    False
row2     True # row1과 row2는 모든 요소가 같고, 위에서부터 확인시 row2가 중복값이 됩니다. -> True반환
row3    False
row4    False
row5    False
dtype: bool

keep='last'일 경우 아래부터 행을 확인하여 중복인 행이 나오면 True를 반환합니다.

print(df.duplicated(keep='last'))
>>
row1     True # row1과 row2는 모든 요소가 같고, 아래에서부터 확인시 row1가 중복값이 됩니다. -> True반환
row2    False
row3    False
row4    False
row5    False
dtype: bool

subset으로 특정 열만 확인

subset을 이용하여 특정 열을 대상으로만 중복행의 확인이 가능합니다.

print(df.duplicated(subset=['col1','col3']))
>>
row1    False
row2     True
row3     True
row4    False
row5     True
dtype: bool

loc,iloc의 활용

data = [
    ["037730", "3R", 1510, 7.36],
    ["036360", "3SOFT", 1790, 1.65],
    ["005760", "ACTS", 1185, 1.28],
]
columns = ["종목코드", "종목명", "현재가", "등락률"]
df = pd.DataFrame(data=data, columns=columns)
df.set_index('종목코드', inplace=True)
>>
          종목명   현재가   등락률
종목코드                     
037730     3R  1510  7.36
036360  3SOFT  1790  1.65
005760   ACTS  1185  1.28

#데이터프레임에서 현재가 열만 출력하기
df['현재가']
>>
    현재가
종목코드    
037730    1510
036360    1790
005760    1185

dtype: int64
#데이터프레임에서 037730 종목 데이터 인덱싱하기
print(df.loc['037730',])

#loc 멀티 인덱싱
df.loc[["037730", "005760"]]
    종목명    현재가    등락률
종목코드            
037730    3R    1510    7.36
005760    ACTS    1185    1.28
#iloc를 사용하여 특정 값 가져오기
df.iloc[0,2]
>>
np.float64(7.36)
#위 데이터프레임에서 iat과 at 속성을 사용하여 037730 종목의 등락률을 출력하세요
df.iat [0,2]
>>
np.float64(7.36)

#loc로 등락률 출력
print(df.loc['037730','등락률'])
>>
7.36
#iloc속성을 사용하여 첫번째, 두번째 행을 슬라이싱하세요
df.iloc[0:2]
>>
    종목명    현재가    등락률
종목코드            
037730    3R    1510    7.36
036360    3SOFT    1790    1.65
#loc 속성을 이용하여 첫번쨰, 두번째 행을 슬라이싱하기
df.loc[["037730":"036360"]]
>>
    종목명    현재가    등락률
종목코드            
037730    3R    1510    7.36
036360    3SOFT    1790    1.65
#위 데이터프레임에서 iloc 속성을 사용하여 첫 번쨰 컬럼을 인덱싱하세요
df.iloc[:,0]
>>
    종목명
종목코드    
037730    3R
036360    3SOFT
005760    ACTS
#loc속성을 사용하여 첫 번째 컬러을 인덱상하세요
df.loc[:,'종목명']
>>
 종목명
종목코드    
037730    3R
036360    3SOFT
005760    ACTS
#loc 속성을 사용하여 037730 종목의 '종목명','현재가'컬럼을 선택하세요
df.loc['037730',['종목명','현재가']]
>>
    037730
종목명    3R
현재가    1510

#iloc 속성을 사용하여 037730 종목의 '종목명','현재가'컬럼을 선택하세요
df.iloc[0,[0,1]]
>>
037730
종목명    3R
현재가    1510
#loc 속성을 사용하여 다음 범위를 가져오세요(2행3열까지
df.loc[['037730','036360'],['종목명','현재가']])
    종목명    현재가
종목코드        
037730    3R    1510
036360    3SOFT    1790
#iloc 속성을 사용하여 다음 범위를 가져오세요(2행3열까지
df.iloc[[0,1],[0,1]]
>>
    종목명    현재가
종목코드        
037730    3R    1510
036360    3SOFT    1790

filter,name,dropna,rename(컬럼,인덱스변경)추가활용

(데이터프레임은 위에서 쓰던거 계속 사용)

09-01. 열 삽입 (insert)

insert 메서드는 DataFrame의 특정 위치에 열을 삽입하는 메서드입니다..

DataFrame에 해당 열이 이미 존재 할 경우 allow_duplicates=True가 아니면 Value Errer를 발생시킵니다.

df.insert(loc, column, value, allow_duplicates=False)

loc : 삽입될 열의 위치

column : 삽입될 열의 이름

val : 삽입될 열의 값

allow_duplicates : {True or False} 기본값은 False로 True일경우 중복 열의 삽입을 허용합니다.

data = [[1,2,3],[4,5,6],[7,8,9]]
col = ['col1','col2','col3']
row = ['row1','row2','row3']
df = pd.DataFrame(data=data,index=row,columns=col)
print(df)
>>
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9

loc=3으로해서 4열로 설정, column을 통해 이름을 col4로하고 value로 값을 설정하여 열을 추가해보겠습니다.

df.insert(3,'col4',[10,11,12])#col4라는 열을 10,11,12로 삽입한다
print(df)
>>
      col1  col2  col3  col4
row1     1     2     3    10
row2     4     5     6    11
row3     7     8     9    12

col4가 3번열에 추가된 것을 확인할 수 있습니다. (0번부터 시작하기 때문에 3번 열은 4번째 열입니다.)

그럼 이미 추가되어있는 'col3'을 추가하면 어떻게 될까요? 바로 오류를 발생시키게 됩니다.

df.insert(3,'col3',[10,11,12],allow_duplicates=False)
print(df)
>>
ValueError: cannot insert col3, already exists

여기서 allow_duplicates=True하면 중복된 이름으로 col3이 추가되는것을 확인 할 수 있습니다.

df.insert(3,'col3',[10,11,12],allow_duplicates=True)
print(df)
>>
      col1  col2  col3  col3
row1     1     2     3    10
row2     4     5     6    11
row3     7     8     9    12

열 꺼내기(pop)

pop메서드는 DataFrame에서 열 레이블을 꺼냅니다. 즉, 원본 DataFrame에서 해당 열이 제거됩니다.

df.pop(item)

item : 꺼낼 열의 이름입니다.

data = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
col = ['col1','col2','col3','col4']
row = ['row1','row2','row3','row4']
df = pd.DataFrame(data=data,index=row,columns=col)
print(df)

      col1  col2  col3  col4
row1     1     2     3     4
row2     5     6     7     8
row3     9    10    11    12
row4    13    14    15    16

item에 col3을 입력하여 열을 꺼내보겠숩나다.

pop한 것을 변수에 넣어 출력해 보면 해당 열이 출력 되는것을 확인 할 수 있습니다.

item = df.pop('col3')
print(item)

row1     3
row2     7
row3    11
row4    15
Name: col3, dtype: int64

원본이었던 df는 어떻게 되었을까요? pop함수는 원본에서 꺼낸다는 의미이기 때문에, col3이 원본에서 삭제된것을 알 수 있습니다.

print(df)
>>
      col1  col2  col4
row1     1     2     4
row2     5     6     8
row3     9    10    12
row4    13    14    16

복사 (copy)

개요

Pandas객체를 복사합니다. deep copy와 shallow copy기능을 지원합니다.

deep : {True or False} 기본값 True

deep = True인 경우를 deep copy라고 하며 원본과는 완전하게 별개인 복사본이 생성됩니다. 사본과 원본의 수정은 서로에게 영향을 끼치지 않습니다.

deep = False인 경우를 shallow copy라고 하며 원본의 데이터 및 인덱스를 복사하지않고 새 객체를 호출합니다.

즉, 원본의 데이터가 수정되면 사본의 데이터도 수정되며, 그 반대도 마찬가지 입니다.

먼저, 아래와 같이 series객체를 하나 만들고, deep copy본과 shallow copy본인 객체를 생성해봅니다.

sr = pd.Series([1, 2], index=["col1", "col2"])
deep = sr.copy(deep=True)
shallow = sr.copy(deep=False)
print(sr)

col1    1
col2    2
dtype: int64

이제 원본인 sr과 deep copy본인 deep, shallow copy본인 shallow의 요소를 변경하고 다시 출력해보겠습니다.

sr[0] = 9
shallow[1] = 8
deep[1]=7

원본 출력시

shallow에서 변경한 내용이 원본인 sr에도 적용된 것을 확인할 수 있습니다.

Copyprint(sr)
>>
col1    9
col2    8
dtype: int64

shallow copy본 출력시

sr에서 변경한 내용이 사본인 shallow에도 적용된 것을 확인할 수 있습니다.

print(shallow)

col1    9
col2    8
dtype: int64

deep copy본 출력시

원본이나 다른 사본의 변경내용과 무관하게 자기 자신의 변경내용만이 적용된 것을 확인할 수 있습니다.

print(deep)
col1    1
col2    7
dtype: int64

DataFrame의 경우

마찬가지로 기본적인 3x3 DataFrame객체를 생성해보겠습니다.

col = ['col1','col2','col3']
row = ['row1','row2','row3']
df = pd.DataFrame(data=[[1,2,3],[4,5,6],[7,8,9]],index=row,columns=col)
deep = df.copy(deep=True)
shallow = df.copy(deep=False)

print(df)
>>
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9

이제 원본과 copy본의 값을 아래와 같이 변경하고 출력해보겠습니다.

df['col1']['row1']=99
shallow['col2']['row2']=88
deep['col2']['row2']=77

원본 출력시

print(df)
#shallow에서 변경한 내용이 원본인 df에도 적용된 것을 확인할 수 있습니다.
      col1  col2  col3
row1    99     2     3
row2     4    88     6
row3     7     8     9

shallow copy본 출력시

print(shallow)
#df에서 변경한 내용이 사본인 shallow에도 적용된 것을 확인할 수 있습니다.
      col1  col2  col3
row1    99     2     3
row2     4    88     6
row3     7     8     9

deep copy본 출력시

Copyprint(deep)
#원본이나 다른 사본의 변경내용과 무관하게 자기 자신의 변경내용만이 적용된 것을 확인할 수 있습니다.
      col1  col2  col3
row1     1     2     3
row2     4    77     6
row3     7     8     9

행/열 삭제 (drop)

drop메서드는 데이터프레임에서 열을 삭제하는 메서드입니다.

pop메서드와는 다르게 원본이 변경되지 않습니다.

labels : 삭제할 레이블명입니다. axis를 지정해주어야합니다.

axis : {0 : index / 1 : columns} labels인수를 사용할경우 지정할 축입니다.

index : 인덱스명을 입력해서 바로 삭제를 할 수 있습니다.

columns : 컬럼명을 입력해서 바로 삭제를 할 수 있습니다.

level : 멀티인덱스의 경우 레벨을 지정해서 진행할 수 있습니다.

inplace : 원본을 변경할지 여부입니다. True일경우 원본이 변경됩니다.

errors : 삭제할 레이블을 찾지 못할경우 오류를 띄울지 여부입니다. ignore할 경우 존재하는 레이블만 삭제됩니다.

※ axis=0 + labels 는 index인수와 역할이 같고 axis=1 + labels는 columns와 역할이 같습니다.

sr = pd.Series([1, 2], index=["col1", "col2"])
deep = sr.copy(deep=True)
shallow = sr.copy(deep=False
print(sr)
>>
col1    1
col2    2
dtype: int64

이제 원본인 sr과 deep copy본인 deep, shallow copy본인 shallow의 요소를 변경하고 다시 출력해보겠습니다.

row = ['row1','row2','row3']
col = ['col1','col2','col3']
data = [[1,2,3],[4,5,6],[7,8,9]]
df = pd.DataFrame(data=data, index=row, columns=col)
print(df)
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9

labels인수와 axis인수로 삭제

labels인수로 삭제할 레이블명을 지정해주게되면, axis인수를 통해 해당 레이블(축)을 지정해주어야합니다.

row2 를 삭제해보겠습니다.

print(df.drop(labels='row2',axis=0))
          col1  col2  col3
row1     1     2     3
row3     7     8     9

col2를 삭제해보겠습니다.

print(df.drop(labels='col2',axis=1))
      col1  col3
row1     1     3
row2     4     6
row3     7     9

index인수와 columns 인수로 삭제

index인수와 columns인수를 사용하면 labels인수와 axis 사용 없이 삭제가 가능합니다.

index를 사용해서 row3을 삭제해보겠습니다.

print(df.drop(index='row3'))

      col1  col2  col3
row1     1     2     3
row2     4     5     6

columns를 이용해 col3을 삭제해보겠습니다.

print(df.drop(columns='col3'))
      col1  col2
row1     1     2
row2     4     5
row3     7     8

errors인수 예시

삭제하고자하는 레이블이 존재하지 않으면 오류가 발생하게됩니다. errors='ignore'로 설정하면 오류를 발생하지 않습니다.

row3, row4를 삭제해보겠습니다.(row4는 존재하지 않음)

print(df.drop(labels=['row3','row4'],errors='raise'))

KeyError: "['row4'] not found in axis"

row4가 존재하지 않기 때문에 오류가 발생하였습니다. errors='ignore'로 실행해보겠습니다.

print(df.drop(labels=['row3','row4'],errors='ignore'))

      col1  col2  col3
row1     1     2     3
row2     4     5     6

오류없이 존재하는 row3이 삭제된 것을 확인할 수 있습니다.

inplace인수로 원본 변경

inplace인수는 Pandas객체의 공통사항으로 원본의 변경여부를 의미합니다.

True일 경우 반환값 없이 원본이 변경됩니다.

df.drop(labels=['col1','col2'],axis=1,inplace=True)
print(df)

      col3
row1     3
row2     6
row3     9

행 추가 (append)

append 메서드는 데이터프레임에 행을 추가하는 메서드입니다.

두 데이터프레임 객체를 행 기준으로 합치는 개념입니다.

기본 사용

other : self 객체에 행 기준으로 합칠 객체입니다.

ignore_index : 기존 인덱스를 사용할지 여부 입니다. False로 할 경우 0,1,2,..,n 이 부여됩니다.

verify_integrity : 합칠 때 이름이 중복되는 인덱스가 있을 경우 오류를 발생시킬지 여부 입니다.

sort : 열을 사전적으로 정렬할 지 여부입니다.

df = pd.DataFrame(data=[[1,2],[3,4]], index=['row1','row2'], columns=['col1','col3'])
print(df)
>>
      col1  col3
row1     1     2
row2     3     4

기본적인 사용법(+sort, ignore_index)

먼저 간단한 df2를 만들어 pd.concat로 df와 합쳐보겠습니다.

df2 = pd.DataFrame(data=[[5,6]],index=['row3'],columns=['col2','col4'])
print(df2)
>>
      col2  col4
row3     5     6

print(pd.concat([df,df2]))#리스트 형태로 해줘야 한다
>>
      col1  col3  col2  col4
row1   1.0   2.0   NaN   NaN
row2   3.0   4.0   NaN   NaN
row3   NaN   NaN   5.0   6.0

row3이 행추가 되었고 기존df에는 없던 col2과 col4가 생성된것을 확인할 수 있습니다.

sort인수를 사용하면 열을 사전적으로 정렬 할 수 있습니다.

print(pd.concat([df,df2],sort=True))
      col1  col2  col3  col4
row1   1.0   NaN   2.0   NaN
row2   3.0   NaN   4.0   NaN
row3   NaN   5.0   NaN   6.0

ignore_index인수를 사용하면 기존 index를 무시할 수 있습니다.

print(pd.concat([df,df2],sort=True,ignore_index=True))

   col1  col2  col3  col4
0   1.0   NaN   2.0   NaN
1   3.0   NaN   4.0   NaN
2   NaN   5.0   NaN   6.0

verify_integrity인수의 사용

verify_integrity 인수를 True로 설정하면 이름이 중복되는 인덱스가 존재할 경우 오류를 발생시킵니다.

먼저 중복되는 인덱스가 있는 2x2 객체를 하나 생성하겠습니다.

df3 = pd.DataFrame(data=[[7,8],[9,0]], index=['row2','row3'], columns=['col1','col3'])
print(df3)
>>
      col1  col3
row2     7     8
row3     9     0

verify_integrity가 False일 경우 (기본값)

print(pd.concat([df,df3],verify_integrity=False))
>>
      col1  col3
row1     1     2
row2     3     4
row2     7     8
row3     9     0

verify_integrity가 True일 경우

Copyprint(pd.concat([df,df3],verify_integrity=True))
>>
오류발생
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-57-5460e119f181> in <cell line: 0>()
----> 1 Copyprint(pd.concat([df,df3],verify_integrity=True))

NameError: name 'Copyprint' is not defined

자르기 (truncate)

turncate메서드는 행이나 열에 대해서 앞뒤를 자르는 메서드 입니다.

df.truncate(before=None, after=None, axis=None, copy=True)

before : 이 기준 이전을 삭제합니다.

after : 이 기준 이후를 삭제합니다.

axis : 자를 축 입니다.

copy : 사본을 생성할지 여부입니다.

row = ['row1','row2','row3','row4']
col = ['col1','col2','col3','col4']
data = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
df = pd.DataFrame(data=data, index=row, columns=col)
print(df)
>>
      col1  col2  col3  col4
row1     1     2     3     4
row2     5     6     7     8
row3     9    10    11    12
row4    13    14    15    16

before, after, axis를 이용하여 앞뒤를 잘라보겠습니다.

print(df.truncate(before='row2',after='row3',axis=0))
#행 자르기 (row2 이전, row3이후 자르기
      col1  col2  col3  col4
row2     5     6     7     8
row3     9    10    11    12

print(df.truncate(before='col2',after='col3',axis=1))
#열 자르기 (col2 이전, col3이후 자르기)
      col2  col3
row1     2     3
row2     6     7
row3    10    11
row4    14    15

중복행 제거 (drop_duplicates)

drop_duplicates메서드는 내용이 중복되는 행을 제거하는 메서드입니다.

subset : 중복값을 검사할 열 입니다. 기본적으로 모든 열을 검사합니다.

keep : {first / last} 중복제거를할때 남길 행입니다. first면 첫값을 남기고 last면 마지막 값을 남깁니다.

inplace : 원본을 변경할지의 여부입니다.

ignore_index : 원래 index를 무시할지 여부입니다. True일 경우 0,1,2, ... , n으로 부여됩니다.

col = ['col1','col2','col3']
data = [['A','x','-'],['A','x','-'],['B','x','앞'],['B','y','-'],['B','y','뒤']]
df = pd.DataFrame(data=data, columns=col)
print(df)
>>
  col1 col2 col3
0    A    x    -
1    A    x    -
2    B    x    앞
3    B    y    -
4    B    y    뒤

기본적인 사용법

subset에 입력된 컬럼명을 기준으로 해당 컬럼의 중복값을 검사하게됩니다.

subset이 따로 입력되지 않는 경우는 모든 열에대해 값이 중복인 행을 제거합니다.

Copyprint(df.drop_duplicates())
# 모든 요소가 중복인 0행과 1행중 1행이 삭제됨(처음값 남기는게 기본)
  col1 col2 col3 
0    A    x    -
2    B    x    앞
3    B    y    -
4    B    y    뒤

subset에 특정 컬럼명만 입력할 경우, 해당 열에대해서만 중복값 검사를 수행합니다.

print(df.drop_duplicates(subset='col2'))
>>
  col1 col2 col3 # col2에서 x와 y에대해서 중복값들 제거
0    A    x    -
3    B    y    -

subset에 리스트를 입력할 경우 해당 열들에대해서 모두 중복인 경우만 삭제를 진행합니다.

print(df.drop_duplicates(subset=['col1','col2']))
>>
  col1 col2 col3
0    A    x    -
2    B    x    앞
3    B    y    -

keep인수를 통해 남길 행 선택

keep인수를 통해서 중복값을 제거하고 남길 행을 선택할 수 있습니다.

keep='first'인 경우 처음 값을 남깁니다. (기본값)

print(df.drop_duplicates(subset='col1',keep='first'))
>>
  col1 col2 col3
0    A    x    -
2    B    x    앞

keep='last'인 경우 마지막 값을 남깁니다.

print(df.drop_duplicates(subset='col1',keep='last'))
>>
  col1 col2 col3
1    A    x    -
4    B    y    뒤

추가로 ignore_index=True로 할 경우 결과값의 인덱스를 0, 1, 2, ... , n으로 설정합니다.

print(df.drop_duplicates(subset='col1',keep='last',ignore_index=True))
>>
  col1 col2 col3 #인덱스가 0, 4에서 0, 1로 정리됩
0    A    x    -
1    B    y    뒤

inplace 인수의 사용

Pandas 공통사항으로 inplace인수를 사용할 경우 원본에 변경이 적용됩니다.

df.drop_duplicates(subset='col3',inplace=True)
print(df)
>>
  col1 col2 col3
0    A    x    -
2    B    x    앞
4    B    y    뒤

차원축소, 스칼라 변환 (squeeze)

squeeze메서드는 차원을 축소(압축)하는 메서드입니다. 예를들어 한개의 행이나 열만 있는 DataFrame을 squeeze하면 Series 객체가 되며, 1개 인덱스만 있는 Series를 squeeze하면 스칼라값이 됩니다. 마찬가지로 1행,1열만 있는 DataFrame 객체를 squeeze하면 스칼라 값이 됩니다.

axis : 압축을 진행할 축 입니다.

df=pd.DataFrame(data=[[1,2],[3,4]],index=['row1','row2'],columns=['col1','col2'])
print(df)
>>
      col1  col2
row1     1     2
row2     3     4

DataFrame을 Series로

1개의 열이나 1개의 행만 있는 DataFrame객체를 squeeze하면 Series 객체가 됩니다.

먼저 row1을 drop하여 1행짜리 DataFrame을 만들고 squeeze하겠습니다.

# row1 삭제
df_row=df.drop(index='row1')
print(df_row)

      col1  col2
row2     3     4

# 압축 실행
print(df_row.squeeze())
#행을 축소한다
col1    3
col2    4
Name: row2, dtype: int64

결과값이 Series객체로 변환된 것을 확인할 수 있습니다.

col1을 drop하여 1열짜리 DataFrame을 만들고 squeeze하겠습니다.

# col1 삭제
df_col=df.drop(columns='col1')
print(df_col)

      col2
row1     2
row2     4

print(df_row.squeeze())
#행을 축소
col1    3
col2    4
Name: row2, dtype: int64

결과값이 Series객체로 변환된 것을 확인할 수 있습니다.

DataFrame을 스칼라 값으로 압축

col1과 row1을 삭제해서 요소1개짜리 DataFrame을 생성하고, squeeze를 실행하면 스칼라값이 반환됩니다.

# row1 , col1을 삭제하여 1행/1열짜리 DataFrame만들기
df_col_row = df.drop(index='row1',columns='col1')
print(df_col_row)

      col2
row2     4

print(df_col_row.squeeze())
>>
4

결과값으로 스칼라값이 반환된것을 확인할 수 있습니다.

압축할 수 없는 경우

압축할 수 없는경우 원본을 반환합니다.

print(df.squeeze())
>>
      col1  col2
row1     1     2
row2     3     4

피벗변환 (pivot)

pivot메서드는 데이터의 열을 기준으로 피벗테이블로 변환시키는 메서드 입니다.

index : 인덱스로 사용될 열입니다.

columns : 열로 사용될 열 입니다.

values : 값으로 입력될 열 입니다.

※ index나 columns에 리스트를 입력 할 경우 멀티 인덱스로 피벗테이블이 생성됩니다.

values에 리스트를 입력 할 경우 각 값에 대한 테이블이 연속적으로 생성됩니다.

col = ['Machine','Country','Price','Brand']
data = [['TV','Korea',1000,'A'],
        ['TV','Japan',1300,'B'],
        ['TV','China',300,'C'],
        ['PC','Korea',2000,'A'],
        ['PC','Japan',3000,'E'],
        ['PC','China',450,'F']]
df = pd.DataFrame(data=data, columns=col)
print(df)

  Machine Country  Price Brand
0      TV   Korea   1000     A
1      TV   Japan   1300     B
2      TV   China    300     C
3      PC   Korea   2000     A
4      PC   Japan   3000     E
5      PC   China    450     F

기본적인 사용법

index를 Machine으로 columns를 Country로, values를 Price로 피벗 테이블을 생성해보겠습니다.

print(df.pivot(index='Machine',columns='Country',values='Price'))

Country  China  Japan  Korea
Machine
PC         450   3000   2000
TV         300   1300   1000

values값이 list형태일 경우 피벗테이블이 옆쪽으로 연속으로 생성됩니다.

print(df.pivot(index='Machine',columns='Country',values=['Price','Brand']))

        Price             Brand
Country China Japan Korea China Japan Korea
Machine
PC        450  3000  2000     F     E     A
TV        300  1300  1000     C     B     A

참고로, values를 따로 입력하지 않으면 남은 모든 열이 values에 입력되어 연속으로 출력됩니다.

print(df.pivot(index='Machine',columns='Country')

        Price             Brand
Country China Japan Korea China Japan Korea
Machine
PC        450  3000  2000     F     E     A
TV        300  1300  1000     C     B     A

그 상태에서 [열 이름] 형태를 붙여서 원하는 values만 출력할 수 있습니다.

print(df.pivot(index='Machine',columns='Country')['Brand'])

Country China Japan Korea
Machine
PC          F     E     A
TV          C     B     A

Multi index로 피벗 변환

index나 columns에 list형태의 데이터를 입력할 경우 멀티 인덱스 형식으로 피벗 테이블이 생성됩니다.

index가 list형태일 경우

print(df.pivot(index=['Country','Machine'],columns='Brand',values='Price'))

Brand                 A       B      C       E      F
Country Machine
China   PC          NaN     NaN    NaN     NaN  450.0
        TV          NaN     NaN  300.0     NaN    NaN
Japan   PC          NaN     NaN    NaN  3000.0    NaN
        TV          NaN  1300.0    NaN     NaN    NaN
Korea   PC       2000.0     NaN    NaN     NaN    NaN
        TV       1000.0     NaN    NaN     NaN    NaN

columns가 list형태일 경우

print(df.pivot(index='Country',columns=['Machine','Brand'],values='Price'))

Machine      TV                     PC
Brand         A       B      C       A       E      F
Country
China       NaN     NaN  300.0     NaN     NaN  450.0
Japan       NaN  1300.0    NaN     NaN  3000.0    NaN
Korea    1000.0     NaN    NaN  2000.0     NaN    NaN

피벗변환이 불가한 경우

중복값으로인해 피벗테이블의 생성이 불가능한 경우 오류를 반환합니다.

# 피벗화가 불가능한 중복값이 있는 객체 생성
df2 = pd.DataFrame(data=[['A','x',1],['A','x',2],['B','y',3],['B','z',4]],columns=['col1','col2','col3'])
print(df2
  col1 col2  col3
0    A    x     1
1    A    x     2
2    B    y     3
3    B    z     4

# 피벗생성 시 오류 발생
print(df2.pivot(index='col1',columns='col2',values='col3'))
>>
오류발생
ValueError: Index contains duplicate entries, cannot reshape

피벗생성_스프레드시트 기반 (pivot_table)

pivot_table메서드는 데이터를 스프레드시트 기반 피벗 테이블로 변환하는 메서드입니다.

엑셀 스프레드시트 피벗 테이블과 유사한 기능을 합니다.

values : 값으로 입력될 열 입니다.

index : 인덱스로 사용될 열입니다.

columns : 열로 사용될 열 입니다.

aggfunc : 결과로 출력될 함수 입니다.

fill_value : 결측치를 채워넣을 값입니다.

margins : 합계를 표시할지 여부입니다. True일 경우 새 열을 생성하여 합계를 출력합니다.

dropna : 항목이 모두 결측치인 열을 포함할지 여부입니다. 기본값은 True로 포함하지 않습니다.

margins_name : margins가 True일 경우 해당 열의 이름입니다.

observed : 범주형 그룹에 대해 관찰된 값만 표시할지 여부 입니다.

sort : 각 범주들을 사전적으로 정리할지 여부입니다. 기본값은 True로 정렬이 수행됩니다.

col = ['Machine','Country','Grade','Price','Count']
data = [['TV','Korea','A',1000,3],
        ['TV','Korea','B', 800,8],
        ['TV','Korea','B', 800,2],
        ['TV','Japan','A',1300,5],
        ['TV','Japan','A',1300,1],
        ['PC','Korea','B',1500,6],
        ['PC','Korea','A',2000,9],
        ['PC','Japan','A',3000,3],
        ['PC','Japan','B',2500,3]]
df = pd.DataFrame(data=data, columns=col)
print(df)

  Machine Country Grade  Price  Count
0      TV   Korea     A   1000      3
1      TV   Korea     B    800      8
2      TV   Korea     B    800      2
3      TV   Japan     A   1300      5
4      TV   Japan     A   1300      1
5      PC   Korea     B   1500      6
6      PC   Korea     A   2000      9
7      PC   Japan     A   3000      3
8      PC   Japan     B   2500      3

기본적인 사용법

index를 Machine, Country로 하고 columns를 Grade로 설정하고 Count값들을 np.sum으로 합계를 계산하여 스프레드 시트로 출력해보겠습니다.

print(df.pivot_table(values='Count',index=['Machine','Country'],columns='Grade',aggfunc=np.sum))

# sum값으로 출력됨.
Grade              A     B
Machine Country
PC      Japan    3.0   3.0
        Korea    9.0   6.0
TV      Japan    6.0   NaN
        Korea    3.0  10.0

sort인수의 사용

결과는 기본적으로 사전적으로 정렬이 되어있습니다. PC와 TV, Japan과 Korea는 알파벳순서로 정렬되어있습니다.

sort를 False로하면 기존 입력 순서대로 출력이 됩니다.

print(df.pivot_table(values='Count',index=['Machine','Country'],columns='Grade',aggfunc=np.sum,sort=False))

Grade              A     B
Machine Country
TV      Korea    3.0  10.0
        Japan    6.0   NaN
PC      Korea    9.0   6.0
        Japan    3.0   3.0

여러 값에 대해 여러 함수 적용

엑셀의 피벗테이블과 유사하게 여러 값에 대해서 여러 값(values)에 대해 여러 함수(aggfunc)를 설정할 수 있습니다.

# list를 이용하여 다중 함수 적용이 가능합니다.
print(df.pivot_table(values=['Count','Price'],index=['Machine','Country'],columns='Grade',aggfunc=[np.sum,np.mean]))

                  sum                        mean
                Count         Price         Count        Price
Grade               A     B       A       B     A    B       A       B
Machine Country
PC      Japan     3.0   3.0  3000.0  2500.0   3.0  3.0  3000.0  2500.0
        Korea     9.0   6.0  2000.0  1500.0   9.0  6.0  2000.0  1500.0
TV      Japan     6.0   NaN  2600.0     NaN   3.0  NaN  1300.0     NaN
        Korea     3.0  10.0  1000.0  1600.0   3.0  5.0  1000.0   800.0

dict를 이용할 경우 각 값에 대해서 특정 함수의 적용이 가능합니다.

print(df.pivot_table(values=['Count','Price'],index=['Machine','Country'],columns='Grade',aggfunc={'Count':np.sum,'Price':np.mean}))

                Count         Price
Grade               A     B       A       B
Machine Country
PC      Japan     3.0   3.0  3000.0  2500.0
        Korea     9.0   6.0  2000.0  1500.0
TV      Japan     6.0   NaN  1300.0     NaN
        Korea     3.0  10.0  1000.0   800.0

fill_value를 이용한 결측치 제거

fill_value에 값을 입력하므로서 결측치를 해당 값으로 대체할 수 있습니다.

print(df.pivot_table(values='Count',index=['Machine','Country'],columns='Grade',aggfunc=np.sum,fill_value='누락'))

Grade              A     B
Machine Country
PC      Japan    3.0   3.0
        Korea    9.0   6.0
TV      Japan    6.0    누락
        Korea    3.0  10.0

margines / margines_name 인수의 사용

margines를 이용해서 총계를 출력할 수 있으며 margines_name을 이용해서 해당 레이블의 이름을 지정할 수 있습니다.

print(df.pivot_table(values='Count',index=['Machine','Country'],columns='Grade',aggfunc=np.sum,margins=True))

Grade               A     B  All
Machine Country
PC      Japan     3.0   3.0    6
        Korea     9.0   6.0   15
TV      Japan     6.0   NaN    6
        Korea     3.0  10.0   13
All              21.0  19.0   40

All로 출력된 행/열의 이름을 변경해보겠습니다.

Copyprint(df.pivot_table(values='Count',index=['Machine','Country'],columns='Grade',aggfunc=np.sum,margins=True,margins_name='총계'))

Grade               A     B  총계
Machine Country
PC      Japan     3.0   3.0   6
        Korea     9.0   6.0  15
TV      Japan     6.0   NaN   6
        Korea     3.0  10.0  13
총계               21.0  19.0  40

피벗해제 (melt)

melt 메서드는 피벗 형태의 DataFrame을 기존 형태로 해체하는 메서드입니다.

id_vars : 기준이 될 열 입니다.

value_vars : 기준열에 대한 하위 카테고리를 나열할 열을 선택합니다.

var_name : 카테고리들이 나열된 열의 이름을 설정합니다.

value_name : 카테고리들의 값이 나열될 열의 이름을 설정합니다.

col_leve : multi index의 경우 melt를 수행할 레벨을 설정합니다.

ignore_index : 인덱스를 1,2,3, ... , n으로 설정할지 여부입니다. 기본적으로 True로 1,2,3, ... , n으로 설정됩니다.

col = ['Country','Machine','Price','Brand']
data = [['Korea','TV',1000,'A'],
        ['Japan','TV',1300,'B'],
        ['Korea','PC',2000,'A'],
        ['Japan','PC',3000,'E']]
df = pd.DataFrame(data=data, columns=col)
print(df)

  Country Machine  Price Brand
0   Korea      TV   1000     A
1   Japan      TV   1300     B
2   Korea      PC   2000     A
3   Japan      PC   3000     E

Country를 기준으로하여 Machine과 Price의 값을 하위 카데고리로 melt를 수행해보겠습니다.

print(df.melt(id_vars='Country',value_vars=['Machine','Price']))

  Country variable value
0   Korea  Machine    TV
1   Japan  Machine    TV
2   Korea  Machine    PC
3   Japan  Machine    PC
4   Korea    Price  1000
5   Japan    Price  1300
6   Korea    Price  2000
7   Japan    Price  3000

ignore_index를 False로 할 경우 기존 인덱스를 사용하게 됩니다.

print(df.melt(id_vars='Country',value_vars=['Machine','Price'],ignore_index=False))

# 기존 인덱스를 사용한 것을 확인 할 수 있습니다.
  Country variable value
0   Korea  Machine    TV
1   Japan  Machine    TV
2   Korea  Machine    PC
3   Japan  Machine    PC
0   Korea    Price  1000
1   Japan    Price  1300
2   Korea    Price  2000
3   Japan    Price  3000

var_name과 value_name을 지정함으로써 열 이름의 기본값인 variable과 value를 원하는 값으로 변경할 수 있습니다.

print(df.melt(id_vars='Country',value_vars=['Machine','Price'],var_name='Category',value_name='val'))

  Country Category   val
0   Korea  Machine    TV
1   Japan  Machine    TV
2   Korea  Machine    PC
3   Japan  Machine    PC
4   Korea    Price  1000
5   Japan    Price  1300
6   Korea    Price  2000
7   Japan    Price  3000

Multi-Index의 경우

Multi-Index(Multi-Columns)의 경우에는 인수들을 리스트-튜플로 설정하거나 col_level을 지정해줌으로써 원하는대로 출력이 가능합니다.

먼저 기존의 Country열을 좀더 세분화하여 Country-City로 Multi-Columns을 생성해보겠습니다.

col2 = [['Area','Area','Value','Value','Value'],['Country','City','Machine','Price','Brand']]
data2 =[['Korea','Seoul','TV',1000,'A'],
        ['Japan','Tokyo','TV',1300,'B'],
        ['Korea','Jeju','PC',2000,'A'],
        ['Japan','Kyoto','PC',3000,'E']]
df2=pd.DataFrame(data=data2, columns=col2)
print(df2)

     Area          Value
  Country   City Machine Price Brand
0   Korea  Seoul      TV  1000     A
1   Japan  Tokyo      TV  1300     B
2   Korea   Jeju      PC  2000     A
3   Japan  Kyoto      PC  3000     E

이제 City에대해서 Price만 출력해보겠습니다.

하위 레벨에대해 출력할 경우 튜플을 이용해서 ('Area','City')로, ('Value','Price')로 세부설정을 입력하여 출력할 수 있습니다.

print(df2.melt(id_vars=[('Area','City')],value_vars=[('Value','Price')])
  (Area, City) variable_0 variable_1  value
0        Seoul      Value      Price   1000
1        Tokyo      Value      Price   1300
2         Jeju      Value      Price   2000
3        Kyoto      Value      Price   3000

col_level을 설정해 줄 경우 보다 간단하게 하위 카테고리의 출력이 가능합니다.

print(df2.melt(id_vars='City',value_vars='Price',col_level=1))
>>
    City variable  value
0  Seoul    Price   1000
1  Tokyo    Price   1300
2   Jeju    Price   2000
3  Kyoto    Price   3000

새 열 할당 (assign)

assign메서드는 DataFrame에 새 열을 할당하는 메서드입니다.

할당할 새 열이 기존열과 이름이 같을경우 덮어씌워집니다.

kwargs : 새열이름 = 내용 형식으로 입력되는 키워드입니다. 콤마(,)를 통해 여러개를 입력할 수 있습니다.

df = pd.DataFrame(index=['row1','row2','row3'],data={'col1':[1,2,3]})
print(df)
>>
      col1
row1     1
row2     2
row3     3

lambda를 이용해 col1에 +2를 한 값으로 col2를 생성해보겠습니다.

print(df.assign(col2=lambda x : x.col1+2))
>>
      col1  col2
row1     1     3
row2     2     4
row3     3     5

lambda를 사용하지 않고 아래와같이 새 열을 추가할 수 있습니다.

print(df.assign(col3=df['col1']*(-2)))
>>
      col1  col3
row1     1    -2
row2     2    -4
row3     3    -6

동시에 여러열 할당

쉼표로 구분을 지으면서 여러개의 열을 할당할 수 있습니다.

print(df.assign(col2=lambda x : x.col1+2,col3=df['col1']*(-2)))
>>
      col1  col2  col3
row1     1     3    -2
row2     2     4    -4
row3     3     5    -6

열이 중복될 경우

만약 추가할 새 열의 이름이 기존열과 중복된다면, 새 값으로 덮어씌워집니다.

print(df.assign(col1=[0,0,0]))
>>
      col1
row1     0
row2     0
row3     0

값 변경 (replace)

replace메서드는 객체 내 값을 다른 값으로 변경하는 메서드입니다.

to_replace : 변경전 기존 값입니다.

value : 변경될 값입니다.

inplace : 원본을 변경할지 여부입니다.

limit : method 사용시 변경 될 갯수 입니다.

regex : regex 문법을 이용하여 변경값을 정합니다.

df = pd.DataFrame([[1,2,3], [4,5,6], [7,8,9]], index=['row1', 'row2', 'row3'], columns=['col1', 'col2', 'col3'])
print(df)
>>
     col1 col2 col3
row1   1    2    3
row2   4    5    6
row3   7    8    9

기본적인 사용법

객체 전체에서 1을 99로 변경해보겠습니다.

print(df.replace(to_replace=1,value=99))
>>
     col1 col2  col3   col4
row1    A    w    99  alpha
row2    B    x     2   beta
row3    C    y     3  gamma
row4    D    z     4  delta

to_replace값이 list형태이고 value값이 단일값이면 전체가 동일하게 변경됩니다.

A, B, y, z를 -로 변경해보겠습니다.

print(df.replace(to_replace=['A','B','y','z'],value='-'))
>>
     col1 col2  col3   col4
row1    -    w     1  alpha
row2    -    x     2   beta
row3    C    -     3  gamma
row4    D    -     4  delta

to_replace값과 value값이 모두 같은 길이의 list형태일 경우 각각 같은 순서의 값으로 변경됩니다.

A, B, y, z를 각각 a, b, Y, Z로 변경해보겠습니다.

print(df.replace(to_replace=['A','B','y','z'],value=['a','b','Y','Z']))
>>
     col1 col2  col3   col4
row1    a    w     1  alpha
row2    b    x     2   beta
row3    C    Y     3  gamma
row4    D    Z     4  delta

method와 limit인수의 사용

method가 ffill일 경우 to_replace값을 바로 위 값으로 변경하며, bfill일 경우 to_replace값을 바로 아래 값으로 변경합니다.

method가 ffill인 경우

print(df.replace(to_replace=['x','y'],method='ffill'))
>>
     col1 col2  col3   col4   # x와 y를 바로 위의 값인 w로 변경
row1    A    w     1  alpha
row2    B    w     2   beta
row3    C    w     3  gamma
row4    D    z     4  delta

method가 bfill인 경우

print(df.replace(to_replace=['x','y'],method='bfill'))
>>
     col1 col2  col3   col4  # x와 y를 바로 아래의 값인 z로 변경
row1    A    w     1  alpha
row2    B    z     2   beta
row3    C    z     3  gamma
row4    D    z     4  delta

method인수를 사용할때 limit인수를 통해 변경될 갯수를 지정할 수 있습니다. limit=1을 통해 1개만 변경해보겠습니다.

print(df.replace(to_replace=['x','y'],method='bfill',limit=1))
>>
     col1 col2  col3   col4   # x와 y에 대하여 bfill을 통해 아랫값인 z로 변경했으나 limit=1로 1개만 변경
row1    A    w     1  alpha
row2    B    x     2   beta
row3    C    z     3  gamma
row4    D    z     4  delta

dict형식의 사용

to_replace에 dict형태를 입력하여 value값 설정 없이 변경이 가능합니다.

A를 a로, z를 Z로 변경해보겠습니다.

print(df.replace(to_replace={'A':'a','z':'Z'}))
>>
     col1 col2  col3   col4
row1    a    w     1  alpha
row2    B    x     2   beta
row3    C    y     3  gamma
row4    D    Z     4  delta

dict안에 dict를 넣음으로써 특정 열의 특정값을 원하는 값으로 변경 할 수 있습니다.

col3을 대상으로 1을 -로, 4를 +로 변경해보겠습니다.

print(df.replace(to_replace={'col3':{1:'-',4:'+'}}))
>>
     col1 col2 col3   col4
row1    A    w    -  alpha
row2    B    x    2   beta
row3    C    y    3  gamma
row4    D    z    +  delta

dict를 통해 각 열의 변경 원하는 값을 지정 후 value를 통해 변경이 가능합니다.

col1열에서 B를, col2열에서 w를 100으로 변경해보겠습니다.

print(df.replace(to_replace={'col1':'B','col2':'w'},value=100))
>>
     col1 col2  col3   col4
row1    A  100     1  alpha
row2  100    x     2   beta
row3    C    y     3  gamma
row4    D    z     4  delta

regex의 사용

regex를 사용할 경우 정규표현식으로 원하는 값을 지정해서 변경 할 수 있습니다.

to_replace를 r'[e]'로 지정하고value를-로 하여 문자열에e가 포함될 경우-로 바꿔보겠습니다.

※이때 regex=True로 해서 활성화를 진행해주어야 합니다.

print(df.replace(to_replace=r'[e]',value='-',regex=True))
>>
     col1 col2  col3   col4
row1    A    w     1  alpha
row2    B    x     2   b-ta
row3    C    y     3  gamma
row4    D    z     4  d-lta

to_replace를 사용하지 않고 단순히 regex에 정규표현식을 입력하여도 동일한 결과를 얻을 수 있습니다.

print(df.replace(regex=r'[e]', value='-'))
>>
     col1 col2  col3   col4
row1    A    w     1  alpha
row2    B    x     2   b-ta
row3    C    y     3  gamma
row4    D    z     4  d-lta

inplace를 통한 원본의 변경

Pandas 공통사항으로 inplcace=True일 경우 원본을 변경하게 됩니다.

df.replace(regex=r'[e]', value='-',inplace=True)
print(df)
>>
     col1 col2  col3   col4   # df를 출력함으로서 원본이 변경된것을 확인.
row1    A    w     1  alpha
row2    B    x     2   b-ta
row3    C    y     3  gamma
row4    D    z     4  d-lta

리스트 형태의 값 전개 (explode)

explode 메서드는 리스트형태의 값을 여러 행으로 전개하는 메서드 입니다.

column : 전개할 리스트형태의 데이터가 있는 열 입니다.

ignore_index : True일 경우 기존 인덱스를 무시하고 0,1,2, ... , n 형태의 인덱스로 변환됩니다.

data= [[[1,2,3],0,['a','b','c']],[4,[],3],[5,2,['x','y','z']]]
idx = ['row1','row2','row3']
col = ['col1','col2','col3']
df = pd.DataFrame(data = data, index = idx, columns = col)
print(df)
>>
           col1 col2       col3
row1  [1, 2, 3]    0  [a, b, c]
row2          4   []          3
row3          5    2  [x, y, z]

기본적인 사용법

리스트형태의 데이터가 있는 열을 지정함으로써 해당 리스트를 여러행으로 전개할 수 있습니다.

col1열을 전개해보겠습니다.

print(df.explode('col1'))
>>
     col1 col2       col3
row1    1    0  [a, b, c] # row1, col1의 [1,2,3]이 전개된 것을 확인할 수 있습니다.<br>
row1    2    0  [a, b, c]
row1    3    0  [a, b, c]
row2    4   []          3
row3    5    2  [x, y, z]

빈 리스트의 경우 NaN이 반환됩니다.

print(df.explode('col2'))
>>
           col1 col2       col3
row1  [1, 2, 3]    0  [a, b, c]
row2          4  NaN          3 # 빈 리스트가 NaN으로 전개된것을 확인할 수 있습니다.<br>
row3          5    2  [x, y, z]

행에 여러개의 리스트 형태의 데이터가 있을 경우 모두 전개합니다.

print(df.explode('col3'))
>>
           col1 col2 col3
row1  [1, 2, 3]    0    a
row1  [1, 2, 3]    0    b
row1  [1, 2, 3]    0    c
row2          4   []    3
row3          5    2    x
row3          5    2    y
row3          5    2    z

여러 열을 동시에 전개할 경우

여러 열을 동시에 전개하려면 해당 열의 같은 행에 있는 리스트 형태의 데이터가 같은 길이를 가져야 합니다.

먼저, 해당 예시를 만족하는 데이터를 만들어 보겠습니다.

data = [[[1,2],['a','b']],[3,'c']]
idx = ['row1','row2']
col = ['col1','col2']
df = pd.DataFrame(data =data, index = idx, columns = col)
print(df)
>>
        col1    col2
row1  [1, 2]  [a, b]
row2       3       c

row1에 같은 길이를 갖는 리스트 형태의 데이터가 있습니다.

print(df.explode(column=['col1','col2']))
>>
     col1 col2
row1    1    a
row1    2    b
row2    3    c

ignore_index인수의 사용

ignore_index=True인 경우 기존 인덱스는 무시되고 0, 1, 2, ... , n 형태의 인덱스로 변경됩니다.

print(df.explode(column=['col1','col2'],ignore_index=True))
>>
  col1 col2
0    1    a
1    2    b
2    3    c

sort_values 메서드는 값을 기준으로 레이블을 정렬하는 메서드입니다.

by : 정렬 기준이될 레이블입니다. axis : {0 : index / 1: columns} 정렬할 레이블입니다. 0이면 행, 1이면 열을 기준으로 정렬합니다. inplace : 원본을 대체할지 여부입니다. True일 경우 원본을 대체하게 됩니다. kind : 알고리즘 모드 입니다. 모드는 총 4종으로 quicksort, mergesort, heapsort, stable이 있는데, 속도와 효율성의 차이를 갖습니다. 기본적으로 quicksort이며, 자세한건 numpy doc에서 확인 가능합니다. na_position : {first / last} Na값의 위치입니다. 기본값은 last로 정렬시 맨 뒤에 위치합니다. ignore_index : 인덱스의 무시 여부입니다. True일 경우 인덱스의 순서와 상관없이 0,1,2,... 로 정해집니다. key : 이 인수를 통해 정렬방식으로 함수를 사용할 수 있습니다. lamba의 사용이 가능합니다.

먼저 np.NaN이 포함된 간단한 5x3짜리 데이터를 만들어보겠습니다.

na = np.NaN
data = [[-3,'A',17],
        [na,'D',31],
        [ 7,'D',-8],
        [15,'Z', 3],
        [ 0, na,-7]]
col = ['col1','col2','col3']
row = ['row1','row2','row3','row4','row5']
df = pd.DataFrame(data = data, index = row, columns= col)
print(df)

>>
      col1 col2  col3
row1  -3.0    A    17
row2   NaN    D    31
row3   7.0    D    -8
row4  15.0    Z     3
row5   0.0  NaN    -7

정렬의 기준이 되는 by에는 레이블명이 되는 str이 올수도 있고, 레이블명들의 list가 올 수 있습니다. list형태가 올 경우, 첫 값부터 정렬합니다.

print(df.sort_values(by='col3'))
#col3을 기준으로 오름차순 정렬된 것을 확인할 수 있습니다.
      col1 col2  col3
row3   7.0    D    -8
row5   0.0  NaN    -7
row4  15.0    Z     3
row1  -3.0    A    17
row2   NaN    D    31

print(df.sort_values(by=['col2','col3']))
 # col2 기준으로 정렬 후 같은값인 'D'에 대해서는
 # col3 기준으로 정렬된 것을 확인 할 수 있습니다 
      col1 col2  col3
row1  -3.0    A    17
row3   7.0    D    -8
row2   NaN    D    31
row4  15.0    Z     3
row5   0.0  NaN    -7

axis인수의 사용

axis인수를 사용하여 어떤축을 기준으로 정렬할지 설정이 가능합니다. 단, 문자와 숫자의 혼용시 오류가 발생합니다. ※ Na는 무시됩니다. 열 기준 col3으로 오름차순 정렬

print(df.sort_values(by='col3',axis=0))

      col1 col2  col3
row3   7.0    D    -8
row5   0.0  NaN    -7
row4  15.0    Z     3
row1  -3.0    A    17
row2   NaN    D    31

행 기준 row1의 오름차순 정렬. 문자와 숫자의 혼용으로 오류가 발생합니다.

print(df.sort_values(by='row1',axis=1))
>>
오류 발생

행 기준 row5의 오름차순 정렬. 문자와 NaN의 혼용이기 때문에 정상적으로 정렬 됩니다.

print(df.sort_values(by='row5',axis=1))
      col3  col1 col2
row1    17  -3.0    A
row2    31   NaN    D
row3    -8   7.0    D
row4     3  15.0    Z
row5    -7   0.0  NaN

ascending인수의 사용

ascending인수를 이용하여 오름차순과 내림차순을 설정할 수 있습니다. 기본값은 True로 오름차순입니다. 내림차순의 경우 False로 아래와 같습니다.

print(df.sort_values(by='col3',ascending=False))

      col1 col2  col3  
# col3 기준으로 내림차순정렬이 된 것을 알 수 있습니다.
row2   NaN    D    31
row1  -3.0    A    17
row4  15.0    Z     3
row5   0.0  NaN    -7
row3   7.0    D    -8

na_position인수의 사용

na_position인수를 이용하여 결측값의 위치를 지정할 수 있습니다. 결측값이 맨 뒤(기본값)

print(df.sort_values(by='col1',na_position='last'))

      col1 col2  col3
row1  -3.0    A    17
row5   0.0  NaN    -7
row3   7.0    D    -8
row4  15.0    Z     3
row2   NaN    D    31

결측값이 맨 앞

print(df.sort_values(by='col1',na_position='first'))

      col1 col2  col3
row2   NaN    D    31
row1  -3.0    A    17
row5   0.0  NaN    -7
row3   7.0    D    -8
row4  15.0    Z     3

ignore_index인수의 사용

ignore_index인수를 사용하여 인덱스를 미사용 할 수 있습니다. 어떤식으로 정렬 되더라도 인덱스는 0, 1, 2, 3, ... 순서로 표시됩니다.

print(df.sort_values(by='col3',ignore_index=True))

   col1 col2  col3
0   7.0    D    -8
1   0.0  NaN    -7
2  15.0    Z     3
3  -3.0    A    17
4   NaN    D    31

key인수의 사용

key인수를 사용하여 정렬에 함수를 이용할 수 있습니다

print(df.sort_values(by='col2',key=lambda col: col.str.lower()))

      col1 col2  col3
row1  -3.0    A    17
row2   NaN    D    31
row3   7.0    D    -8
row4  15.0    Z     3
row5   0.0  NaN    -7

inplcae 인수의 사용

inplace 인수를 사용해서 원본을 대체할지의 여부를 설정할 수 있습니다.

df.sort_values(by='col3',inplace=True)
print(df) #그냥 df를 출력함으로써 원본의 대체 여부가 확인 가능합니다.

      col1 col2  col3
row3   7.0    D    -8
row5   0.0  NaN    -7
row4  15.0    Z     3
row1  -3.0    A    17
row2   NaN    D    31

인덱스 기준 정렬 (sort_index)

axis : {0 : index / 1: columns} 정렬할 레이블입니다. 0이면 행, 1이면 열을 기준으로 정렬합니다. level : multi index의 경우 정렬을 진행할 level입니다. ascending : 오름차순으로할지 여부 입니다. 기본은 True로 오름차순입니다. inplace : 원본을 대체할지 여부입니다. True일 경우 원본을 대체하게 됩니다. kind : 알고리즘 모드 입니다. 모드는 총 4종으로 quicksort, mergesort,heapsort, stable이 있는데, 속도와 효율성의 차이를 갖습니다. 기본적으로 quicksort이며, 자세한건 numpy doc에서 확인 가능합니다.

na_position : {first / last} Na값의 위치입니다. 기본값은 last로 정렬시 맨 뒤에 위치합니다. sort_remaining : multi index의 경우 다른 레벨에 대해서도 정렬을할지 여부입니다. True로 할 경우 한 레벨에 대한 정렬이 완료되면, 다른 레벨도 정렬합니다. ignore_index : 인덱스의 무시 여부입니다. True일 경우 인덱스의 순서와 상관없이 0,1,2,... 로 정해집니다.

level의 지정 level을 지정하므로써 해당 level에서의 정렬이 가능합니다. level이 0인 경우 row기준으로 정렬되는것을 확인 할 수 있습니다.

print(df.sort_index(axis=0, level=0))

           col4  col1  col2
row1 val1   1.0   2.0     3
     val2   4.0   NaN     6
row2 val2  19.0  20.0    21
     val5  16.0  17.0    18
row3 val1   NaN  11.0    12
     val2  13.0  14.0    15
     val3   7.0   8.0     9

level이 1인 경우 val기준으로 정렬되는것을 확인 할 수 있습니다.

print(df.sort_index(axis=0, level=1))

           col4  col1  col2
row1 val1   1.0   2.0     3
row3 val1   NaN  11.0    12
row1 val2   4.0   NaN     6
row2 val2  19.0  20.0    21
row3 val2  13.0  14.0    15
     val3   7.0   8.0     9
row2 val5  16.0  17.0    18

level별 ascending의 병용

level과 ascending의 값을 list형태로 입력하므로써, 각 level에 다른 정렬방식의 사용이 가능합니다. level이 1인 val이 내림차순 정렬되고, level이 0인 row가 오름차순 정렬된것을 확인 할 수 있습니다.

print(df.sort_index(axis=0, level=[1,0],ascending=[False,True]))

           col4  col1  col2
row2 val5  16.0  17.0    18
row3 val3   7.0   8.0     9
row1 val2   4.0   NaN     6
row2 val2  19.0  20.0    21
row3 val2  13.0  14.0    15
row1 val1   1.0   2.0     3
row3 val1   NaN  11.0    12

sort_remaining 인수의 사용

multi index에서 sort_remaining인수를 True로 할 경우 level별로 순차적으로 정렬이 진행됩니다. 만약 level을 따로 지정했다면, 해당 level부터 정렬한 후 나머지 level을 순차적으로 정렬합니다. row정렬 후 val의 정렬까지 완료된 것을 확인할 수 있습니다.

print(df.sort_index(axis=0, sort_remaining=True))#기본적으로 sort_remaining은 True가 기본값이다

           col4  col1  col2
row1 val1   1.0   2.0     3
     val2   4.0   NaN     6
row2 val2  19.0  20.0    21
     val5  16.0  17.0    18
row3 val1   NaN  11.0    12
     val2  13.0  14.0    15
     val3   7.0   8.0     9

정렬후 추출 (nlargest, nsmallest)

nlargest메서드와 nsmallest메서드는 데이터를 오름차순/내림차순 정렬 후, 위에서 n개의 행을 출력하는 메서들입니다. 사실상 df.sort_values(columns, ascending=True/False).head(n)와 사용방식이 완전히 동일합니다.

n : 정렬 후 출력할 행의 수 입니다.

columns : 정렬의 기준이 될 열 입니다.

keep :{first, last, all} 동일한 값일경우 어느 행을 출력할지 정합니다. first면 위부터, last면 아래부터, all이면 모두 출력합니다.

col = ['col1','col2','col3']
row = ['row3','row5','row1','row4','row2']
data = [[ 1, 21, 7],
        [ 2, 33, 3],
        [ 2,  7,97],
        [ 4, 56,31],
        [ 5, 18, 5]]
df = pd.DataFrame(data=data, index=row, columns=col)
print(df)
>>
      col1  col2  col3
row3     1    21     7
row5     2    33     3
row1     2     7    97
row4     4    56    31
row2     5    18     5

keep 인수의 사용

keep인수를 통해 중복일경우의 출력할 행을 지정할 수 있습니다. 처음 발생한 값부터 출력(위쪽값 출력)

print(df.nlargest(n=3, columns='col1',keep='first'))
#중복된 값은 첫번째 부터 출력한다
           col4  col1  col2
row2 val2  19.0  20.0    21
     val5  16.0  17.0    18
row3 val2  13.0  14.0    15

print(df.nlargest(n=3, columns='col1',keep='last'))#컬럼1에서 가장 큰값 3개를 출력한다, 중복된 값은 마지막 값을 출력한다

           col4  col1  col2
row2 val2  19.0  20.0    21
     val5  16.0  17.0    18
row3 val2  13.0  14.0    15

중복값 모두 출력

print(df.nlargest(n=3,columns='col1',keep='all'))#중복된 값도 모두 출력한다
>>
      col1  col2  col3
row2     5    18     5
row4     4    56    31
row5     2    33     3
row1     2     7    97

여러 열을 동시에 고려하여 정렬

여러 열을 동시에 고려하여 정렬하고자 한다면 list를 사용하면됩니다.

col1과 col3 모두에서 큰 값 기준 정렬할 경우 아래와 같습니다.

Copyprint(df.nlargest(n=3,columns=['col1','col3']))
#만약 col1값이 같다면 col3까지 비교를 한다
>>
      col1  col2  col3
row2     5    18     5
row4     4    56    31
row1     2     7    97
#col1에서 중복인 row1, row5에 대해 col3의 값이 더 큰 row1이 출력

함수를 이용한 열 단위 결합 (combine)

combine 메서드는 두 pandas 객체를 func함수를 이용하여 결합하는 메서드입니다.

other : 결합 할 DataFrame객체 입니다. func : 결합에 이용할 함수 입니다. fill_value : 결합하기전 Na의 값을 이 값으로 대체합니다. overwrite : other에 존재하지 않는 self의 열의 값을 NaN으로 대체합니다.

먼저 np.NaN이 포함된 간단한 3x3짜리 데이터 2개를 만들어보겠습니다.

n=np.nan
col = ['col1','col2','col3']
row = ['row1','row2','row3']
data1 = [[1,3,4],
         [n,8,2],
         [2,6,7]]
data2 = [[7,2,3],
         [2,4,2],
         [3,1,5]]
df1 = pd.DataFrame(data1,row,col)
df2 = pd.DataFrame(data2,row,col)

print(df1)
print(df2)

      col1  col2  col3
row1   1.0     3     4
row2   NaN     8     2
row3   2.0     6     7

      col1  col2  col3
row1     7     2     3
row2     2     4     2
row3     3     1     5

기본적인 사용법

func 인수에 np.maximum을 입력하여 df1과 df2의 요소를 비교, 큰 값으로 결합하여 보겠습니다.

print(df1.combine(df2,np.maximum))
>>
      col1  col2  col3
row1   7.0     3     4
row2   NaN     8     2
row3   3.0     6     7

fill_value를 이용하여 결측치 채우기

fill_value에 값을 입력하면, 결측치가 해당 값으로 채워진 후 결합이 진행됩니다.

print(df1.combine(df2,np.maximum,fill_value=9))#결측값을 9로 채운다

      col1  col2  col3
row1   7.0     3     4
row2   9.0     8     2
row3   3.0     6     7

col1, row2의 값이 NaN에서 9로 변경 된후 np.maximum이 진행된 것을 확인할 수 있습니다.

overwrite 인수의 사용

overwrite인수는 other에 존재하지 않는 self의 열의 요소를 NaN으로 변경하는 메서드입니다. 먼저 이해를 돕기 위해 2x2 데이터인 df3을 만들어 보겠습니다.

col3 = ['col1','col2']
row3 = ['row1','row2']
data3 = [[1,2],
         [3,4]]
df3 = pd.DataFrame(data3, row3, col3)
print(df3)
>>
      col1  col2
row1     1     2
row2     3     4

overwrite가 False일 경우 존재하지 않는 열에 대해서는 기존값으로 채워집니다.

print(df1.combine(df3, np.maximum,overwrite=False))
#존재하지 않는 열에 대해서는 기존값(df1)으로 채워진다

      col1  col2  col3
row1   1.0   3.0     4
row2   NaN   8.0     2
row3   NaN   NaN     7

overwrite가 True일 경우 존재하지 않는 열에 대해서는 NaN으로 채워집니다. col3의 값이 모두 NaN으로 채워진 것을 확인할 수 있습니다.

print(df1.combine(df3, np.maximum,overwrite=True))#결측값으로 채워진다

      col1  col2  col3
row1   1.0   3.0   NaN
row2   NaN   8.0   NaN
row3   NaN   NaN   NaN

다른 객체로 결측치 덮어쓰기 (combine_first)

combine_first 메서드는 other의 값으로 self(df)의 NaN값을 덮어쓰는 메서드입니다.

other : self객체의 결측치를 덮어쓸 객체 입니다.

n=np.nan
col = ['col1','col2','col3']
row = ['row1','row2','row3']
data1 = [[n,n,1],
         [n,n,1],
         [1,1,1]]
data2 = [[2,2,2],
         [2,n,2],
         [2,1,2]]
df1 = pd.DataFrame(data1,row,col)
df2 = pd.DataFrame(data2,row,col)

print(df1)
print(df2)

      col1  col2  col3
row1   NaN   NaN     1
row2   NaN   NaN     1
row3   1.0   1.0     1

      col1  col2  col3
row1     2   2.0     2
row2     2   NaN     2
row3     2   1.0     2

기본적인 사용법

self객체의 NaN값을 other객체의 같은위치의 인수로 덮어쓰기 합니다. 만약 self에서 NaN인 값이 other에서도 NaN이라면 NaN을 출력합니다.

print(df1.combine_first(df2))#df1에 df2를 덮어 쒸웁니다

      col1  col2  col3
row1   2.0   2.0     1
row2   2.0   NaN     1
row3   1.0   1.0     1

인덱스기준 병합 (join)

join 메서드는 두 객체를 인덱스 기준으로 병합하는 메서드 입니다.

other : self와 합칠 객체 입니다. on : self의 열이나 인덱스 중에서 other의 어떤 열을 기준으로 결합할지 입니다. 즉, other의 (인덱스 기준이 아닌) 열 기준으로 결합할 때 on인수를 사용합니다. how : {left : self기준 / right : other기준 / inner : 교집합 / outer : 합집합} 출력할 인덱스의 기준입니다. lsuffix / rsffix : 이름이 중복되는 열이 있을 때 그 열에 추가로 붙일 접미사입니다. lsuffix는 self의 열에 붙을 접미사고, rsuffix는 other의 열에 붙을 접미사입니다. sort : 출력되는 데이터의 index를 사전적으로 정렬할지 여부입니다.

기본데이터 생성

df1 = pd.DataFrame({'col1':[1,2,3]},index=['row3','row2','row1'])
print(df1)
      col1
row3     1
row2     2
row1     3

df2 = pd.DataFrame({'col2':[13,14]},index=['row4','row3'])
print(df2)
      col2
row4    13
row3    14

df3 = pd.DataFrame({'col1':[23,24]},index=['row4','row3'])
print(df3)
      col1
row4    23
row3    24

df4 = pd.DataFrame({'IDX':['A','B','C'],'col1':[1,2,3]})
print(df4)
  IDX  col1
0   A     1
1   B     2
2   C     3

df5 = pd.DataFrame({'IDX':['C','D'],'col2':[13,14]})
print(df5)
  IDX  col2
0   C    13
1   D    14

how를 통한 인덱스의 설정

how인수를 통해 인덱스의 기준을 어떤 값으로 할지 정할 수 있습니다 how=left인 경우 (기본값) df1의 인덱스를 기준으로 합니다.

print(df1.join(df2,how='left'))
      col1  col2
row3     1  14.0
row2     2   NaN
row1     3   NaN

how=right인 경우 df2의 인덱스를 기준으로 합니다.

print(df1.join(df2,how='right'))
      col1  col2
row4   NaN    13
row3   1.0    14

how=outer인 경우 df1와 df2의 인덱스의 합집합을 기준으로 합니다.

print(df1.join(df2,how='outer'))
      col1  col2
row1   3.0   NaN
row2   2.0   NaN
row3   1.0  14.0
row4   NaN  13.0

how=inner인 경우 df1와 df2의 인덱스의 교집합을 기준으로 합니다.

print(df1.join(df2,how='inner'))
      col1  col2
row3     1    14

sort 인수를 통한 인덱스의 정렬

sort인수를 True로 설정할 경우 인덱스의 값을 사전적으로 정렬 할 수 있습니다. sort가 False 인경우(기본값)

print(df1.join(df2,how='left'))
      col1  col2
row3     1  14.0
row2     2   NaN
row1     3   NaN

sort가 True 인경우 인덱스가 정렬 된 것을 확인할 수 있습니다.

print(df1.join(df2,how='left',sort=True))
      col1  col2
row1     3   NaN
row2     2   NaN
row3     1  14.0

lsuffix / rsuffix 인수를 통해 중복 열 구분하df1과 df3은 col1이라는 이름이 중복된 열을 가지기 때문에, join메서드를 사용할 경우 오류가 발생하게 됩니다.

이때, lsuffix / rsuffix 인수를 입력함으로서 기존 열 이름에 접미사를 붙일 수 있습니다.

print(df1.join(df3,how='outer',lsuffix="_left",rsuffix='_right'))
      col1_left  col1_right
row1        3.0         NaN
row2        2.0         NaN
row3        1.0        24.0
row4        NaN        23.0

인덱스가 아닌 열 기준으로 결합하기(+ on 인수의 사용) 먼저 IDX라는 이름의 열을 갖는 두 객체를 생성해보겠습니다.

df4 = pd.DataFrame({'IDX':['A','B','C'],'col1':[1,2,3]})
print(df4)
  IDX  col1
0   A     1
1   B     2
2   C     3

df5 = pd.DataFrame({'IDX':['C','D'],'col2':[13,14]})
print(df5)
  IDX  col2
0   C    13
1   D    14

join메서드는 기본적으로 index를 기준으로 결합하기 때문에, 열 기준으로 결합하기 위해서는

set_index메서드를 활용해 열을 인덱스로 변경하여 join메서드를 사용하면 됩니다.

print(df4.set_index('IDX').join(df5.set_index('IDX')))
IDX
A       1   NaN
B       2   NaN
C       3  13.0

하지만 위와 같이 진행 할 경우 기존 인덱스가 열 값으로 변경됩니다.

이를 방지하고 순수하게 열 기준으로 병합하려면 on 인수를 사용하면 됩니다.

print(df4.join(df5.set_index('IDX'),on='IDX'))
  IDX  col1  col2
0   A     1   NaN
1   B     2   NaN
2   C     3  13.0

객체병합 (merge)

merge메서드는 두 객체를 병합하는 메서드입니다. join과 비슷하지만 더 세부적인 설정이 가능한 메서드로,

인덱스-열 기준 병합도 가능하며, indicator인수를 통한 병합정보확인, validate를 통한 병합방식 확인등이 가능합니다.

left.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

right: left와 함께 병합할 객체입니다.

how : 병합시 기준이 될 인덱스를 정하는 방식입니다. left는 기존객체, right는 병합할 객체, inner은 두 객체의 인덱스의 교집합, outer은 두 객체의 인덱스의 합집합, cross는 행렬곱 입니다.

on : 열 기준 병합시 기준으로할 열의 이름이 양측이 동일하다면, on인수에 입력함으로써 기준 열을 정할 수 있습니다.

left_on / right_on : 열기준 병합 시 기준으로 할 열의 양측 이름이 다르다면, 각각 어떤 열을 기준으로 할지 정해줍니다.

열의 이름을 입력하면 됩니다.

left_index / right_index : 인덱스 기준 병합 시 True로 하면 해당 객체의 인덱스가 병합 기준이됩니다.

※ 즉 left_on을 입력하고 right_index를 True로 한다면 열-인덱스 기준 병합도 가능합니다.

sort : 병합 후 인덱스의 사전적 정렬 여부입니다. join메서드와 기능이 동일하므로 참고 바랍니다.

suffixes : 병합할 객체들간 이름이 중복되는 열이 있다면, 해당 열에 붙일 접미사를 정합니다.

기본적으로 join메서드의 lsuffix / rsuffix와 기능이 동일하지만, suffixes인수는 튜플로 두 값을

한번에 입력한다는 차이가 있습니다.

copy : 사본을 생성할지 여부입니다.

indicator : True로 할경우 병합이 완료된 객체에 추가로 열을 하나 생성하여 병합 정보를 출력합니다.

validate : {'1:1' / '1:m' / 'm:1' / 'm:m'} 병합 방식에 맞는지 확인할 수 있습니다. 만약 validate에 입력한 병합방식과, 실제 병합 방식이 다를경우 오류가 발생됩니다.

예를들어, validate="1:m"으로 입력하였는데, 실제로 m:1 병합방식일 경우 오류가 발생됩니다.

열 기준으로 병합 (left_on / right_on)

left_on / right_on에 열 이름을 입력하므로서 열 기준으로 병합이 가능합니다. 먼저 객체 2개를 만들어 보겠습니다.

df1 = pd.DataFrame({'IDX1':['a','b','c','a'],'VAL':[1,2,3,4]})
print(df1)
  IDX1  VAL
0    a    1
1    b    2
2    c    3
3    a    4

df2 = pd.DataFrame({'IDX2':['a','c','d'],'VAL':[5,6,7]})
print(df2)
  IDX2  VAL
0    a    5
1    c    6
2    d    7

df1에서는 IDX1을, df2에서는 IDX2를 기준으로 하여 두 객체를 병합하겠습니다. IDX1과 IDX2의 값을 매칭하여 병합된 후 이름이 같은 VAL열에 대해서는 _x와 _y가 붙었습니다.

print(df1.merge(df2, left_on='IDX1',right_on='IDX2'))
  IDX1  VAL_x IDX2  VAL_y
0    a      1    a      5
1    c      3    c      6
2    a      4    a      5

suffixes를 통한 동명인 열 구분

suffixes에 ('_left', '_right')를 입력하므로써 열 이름에 _left, _right를 붙일 수 있습니다.

print(df1.merge(df2, left_on='IDX1',right_on='IDX2',suffixes = ('_left','_right')))
  IDX1  VAL_left IDX2  VAL_right
0    a         1    a          5
1    c         3    c          6
2    a         4    a          5

인덱스 기준으로 병합(left_index / right_index)

left_index / right_index를 통해 인덱스 기준으로 두 객체를 병합할 수 있습니다.

먼저 병합할 두 객체를 만들어보겠습니다.

df3 = pd.DataFrame({'VAL1':[1,2,3]},index=['row1','row2','row3'])
print(df3)
>>
      VAL1
row1     1
row2     2
row3     3

df4 = pd.DataFrame({'VAL2':[4,5,6]},index=['row2','row3','row4'])
print(df4)
>>
      VAL2
row2     4
row3     5
row4     6

left_index와 right_index를 True로 입력하여 두 객체 모두 인덱스를 기준으로 병합할 수 있습니다.

print(df3.merge(df4, left_index=True,right_index=True))
      VAL1  VAL2
row2     2     4
row3     3     5

열과 인덱스를 혼합하여 병합하기

left_on / right_on 과 left_index / right_index를 이용하여 양쪽의 기준을 설정해줌으로서, 인덱스와 열의 혼합 병합도 가능합니다.

예시를 위해서 새 객체 두개를 만들어보겠습니다.

df5는 인덱스를, df6은 열을 기준으로 하겠습니다.

df5 = pd.DataFrame({'VAL1':[1,2,3]},index=['row1','row2','row3'])
print(df5)
>>
      VAL1
row1     1
row2     2
row3     3

df6 = pd.DataFrame({'IDX':['row2','row3','row4'],'VAL2':[4,5,6]})
print(df6)
>>
    IDX  VAL2
0  row2     4
1  row3     5
2  row4     6

이제 left_index는 True로하여 인덱스를 기준으로하고 right_on은 IDX로 하여 열 기준으로 병합하겠습니다.

print(df5.merge(df6, left_index=True,right_on='IDX'))
   VAL1   IDX  VAL2
0     2  row2     4
1     3  row3     5

how 인수의 사용

how인수를 사용하여 병합된 객체의 인덱스의 기준을 정할 수 있습니다.

먼저 예시에 이용될 두 객체를 만들어 보겠습니다.

df7 = pd.DataFrame({'IDX':['a','b','c','a'],'VAL':[1,2,3,4]})
print(df7)
>>
  IDX  VAL
0   a    1
1   b    2
2   c    3
3   a    4

Copydf8 = pd.DataFrame({'IDX':['a','c','d'],'VAL':[5,6,7]})
print(df8)
>>
  IDX  VAL
0   a    5
1   c    6
2   d    7

how=left인 경우 왼쪽 객체의 인덱스를 기준으로 합니다.

print(df7.merge(df8,how='left',on='IDX'))
  IDX  VAL_x  VAL_y
0   a      1    5.0
1   b      2    NaN
2   c      3    6.0
3   a      4    5.0

how=right인 경우 오른쪽 객체의 인덱스를 기준으로 합니다.

print(df7.merge(df8,how='right',on='IDX'))
  IDX  VAL_x  VAL_y
0   a    1.0      5
1   a    4.0      5
2   c    3.0      6
3   d    NaN      7

how=inner인 경우 양쪽 객체 모두가 공통으로 갖는 인덱스를 기준으로 합니다.(교집합)

print(df7.merge(df8,how='inner',on='IDX'))
>>
  IDX  VAL_x  VAL_y
0   a      1      5
1   a      4      5
2   c      3      6

how=outer인 경우 양쪽 객체의 인덱스 모두를 기준으로 합니다.(합집합)

print(df7.merge(df8,how='outer',on='IDX'))
>>
  IDX  VAL_x  VAL_y
0   a    1.0    5.0
1   a    4.0    5.0
2   b    2.0    NaN
3   c    3.0    6.0
4   d    NaN    7.0

※cross에 대해서는 뒤에 후술하겠습니다.

indicator인수를 통한 병합 정보 출력

indicator인수를 True로 할 경우 마지막 열에 _merge열을 추가하여 병합 정보를 출력합니다.

print(df7.merge(df8,how='outer',on='IDX',indicator=True))
>>
  IDX  VAL_x  VAL_y      _merge
0   a    1.0    5.0        both
1   a    4.0    5.0        both
2   b    2.0    NaN   left_only
3   c    3.0    6.0        both
4   d    NaN    7.0  right_only

validate를 통한 병합방식 검증

validate인수에 값을 입력하여 해당 병합방식이 맞는지 검증이 가능합니다. 병합 방식이 다를경우 오류를 출력합니다.

1:m인지 검증

print(df7.merge(df8,how='outer',on='IDX',validate='1:m'))
>>
오류발생
pandas.errors.MergeError: Merge keys arenot uniquein left dataset;not a one-to-many merge

m:1인지 검증. 병합 방식이 m:1이 맞기 때문에 결과값을 출력합니다.

print(df7.merge(df8,how='outer',on='IDX',validate='m:1'))
>>
  IDX  VAL_x  VAL_y
0   a    1.0    5.0
1   a    4.0    5.0
2   b    2.0    NaN
3   c    3.0    6.0
4   d    NaN    7.0

how인수에 cross를 적용하는 경우

how인수중 cross는 행렬의 곱집합을 의미합니다. 단순히 말하면 행렬의 모든 경우의수를 출력합니다.

예시를 위해 두 객체를 생성해보겠습니다.

df9 = pd.DataFrame({'IDX1':['a','b']})
print(df9)
>>
  IDX1
0    a
1    b

df10 = pd.DataFrame({'IDX2':['c','d']})
print(df10)
>>
  IDX2
0    c
1    d

이제 how인수에 cross를 입력하므로써 두 객체의 행렬곱을 출력하겠습니다.

print(df9.merge(df10,how='cross'))
>>
  IDX1 IDX2
0    a    c
1    a    d
2    b    c
3    b    d

객체 병합_결측제어 가능 (align)

align메서드는 두 객체를 특정 기준들에 맞추어 정렬하는 메서드입니다.

두개의 데이터를 튜플 형태로 반환한다는것을 반드시 명심하시기 바랍니다.

인수들에 따라 다양한 구현이 가능하므로 아래 사용법을 참고 바랍니다.

self.align(other, join='outer', axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None)

other : self와 함께 정렬할 객체 입니다.

join : {inner / left / right / outer} 정렬 기준이 될 인덱스 입니다. inner이면 교집합, left면 self의 인덱스, right면 other의 인덱스, outer이면 합집합으로 인덱스를 사용합니다.

axis : {0 : index / 1 : columns} 정렬할 레이블입니다. 기본값으로 두 축 모두 정렬합니다.

level : multi index의 경우 실행할 수준(level)을 설정합니다.

copy : 사본을 생성할지의 여부입니다.

fill_value : 결측치를 어떤 값으로 채울지의 여부입니다. 기존 객체에 포함된 결측치의 경우는 바뀌지 않습니다.

method : {ffill / bfill} 결측치를 어떻게 채울지 여부입니다. ffill의 경우 위의값과 동일하게, bfill의 경우 아래 값과 동일하게 채웁니다.

limit : 결측치를 몇개나 채울지 여부입니다. limit에 설정된 갯수만큼만 결측치를 변경합니다.

fill_axis : {0 : index / 1 : columns} method와 limit를 가로로 적용할지 세로로 적용할지 여부입니다.

broadcast_axis : {0 : index / 1 : columns} 어느 축을 기준으로 브로드캐스트할지 여부입니다.

브로드캐스트란 서로 차원이 다른 두 객체에 대해서 저차원 데이터의 차원을 고차원 데이터에 맞추는 과정입니다.

기본 사용법

먼저 일부 레이블을 공유하는 3x3짜리 데이터 2개를 만들어보겠습니다.

전체적으로 보면 아래와 같습니다.(빨강이 df1, 파랑이df2, 녹색이 레이블이 겹치는구간)

편의를 위해 겹치는 부분의 값을 동일하게 했습니다

두개의 데이터를 튜플 형태로 반환하기 때문에, 달라도 상관없습니다.

n=np.NaN
col1 = ['col1','col2','col3']
row1 = ['row1','row2','row3']
data1 = [[1,2,3],[5,6,7],[9,n,11]]

col2 = ['col2','col3','col4']
row2 = ['row3','row4','row5']
data2 = [[10,11,12],[14,n,16],[18,19,20]]

df1 = pd.DataFrame(data1,row1,col1)
df2 = pd.DataFrame(data2,row2,col2)

print(df1)
>>
      col1  col2  col3
row1     1   2.0     3
row2     5   6.0     7
row3     9   NaN    11

print(df2)
>>
      col2  col3  col4
row3    10  11.0    12
row4    14   NaN    16
row5    18  19.0    20

join 인수의 사용을 통한 레이블 설정

join 인수를 이용해 {outer : 합집합 / left : df1기준 / right : df2기준 / inner : 교집합} 인 index로 출력합니다.

두개의 데이터를 튜플 형태로 반환하기 때문에 리스트 슬라이싱으로 따로 print를 진행해보겠습니다.

outer로 출력시 레이블이 df1과 df2 모두의 합집합으로 사용되고 있는것을 알 수 있습니다.

print(df1.align(df2,join='outer')[0])
print(df1.align(df2,join='outer')[1])

      col1  col2  col3  col4
row1   1.0   2.0   3.0   NaN
row2   5.0   6.0   7.0   NaN
row3   9.0   NaN  11.0   NaN
row4   NaN   NaN   NaN   NaN
row5   NaN   NaN   NaN   NaN
      col1  col2  col3  col4
row1   NaN   NaN   NaN   NaN
row2   NaN   NaN   NaN   NaN
row3   NaN  10.0  11.0  12.0
row4   NaN  14.0   NaN  16.0
row5   NaN  18.0  19.0  20.0

left로 출력시 df1의 레이블만 사용되는 것을 알 수 있습니다.

print(df1.align(df2,join='left')[0])
print(df1.align(df2,join='left')[1])
      col1  col2  col3
row1     1   2.0     3
row2     5   6.0     7
row3     9   NaN    11
      col1  col2  col3
row1   NaN   NaN   NaN
row2   NaN   NaN   NaN
row3   NaN  10.0  11.0

right로 출력시 df2의 레이블만 사용되는 것을 알 수 있습니다.

print(df1.align(df2,join='right')[0])
print(df1.align(df2,join='right')[1])
      col2  col3  col4
row3   NaN  11.0   NaN
row4   NaN   NaN   NaN
row5   NaN   NaN   NaN
      col2  col3  col4
row3    10  11.0    12
row4    14   NaN    16
row5    18  19.0    20

inner로 출력시 레이블이 df1과 df2 모두의 교집합으로 사용되고 있는것을 알 수 있습니다.

print(df1.align(df2,join='inner')[0])
print(df1.align(df2,join='inner')[1])

      col2  col3
row3   NaN    11
      col2  col3
row3    10  11.0

axis 인수의 사용을 통한 정렬 축 설정

axis인수를 통해 정렬을 진행 할 축을 정할 수 있습니다. 기본적으로 두축 모두 입니다.

df1에 대해서만 inner로 출력하여 확인해보겠습니다.

axis를 0으로 하였을 경우 행 기준 inner인 row3만 정렬되었습니다.

print(df1.align(df2,join='inner',axis=1)[0])
      col2  col3
row1   2.0     3
row2   6.0     7
row3   NaN    11

fill_value를 사용한 결측치 입력

fill_value를 사용해서 결측치를 원하는 값으로 변경이 가능합니다.

단, 기존 객체에 입력되어있던 결측치의 경우 변경되지 않습니다.

print(df1.align(df2,join='outer',fill_value='X')[0])
print(df1.align(df2,join='outer',fill_value='X')[1])

     col1 col2 col3 col4
row1    1  2.0    3    X
row2    5  6.0    7    X
row3    9  NaN   11    X
row4    X    X    X    X
row5    X    X    X    X
     col1 col2  col3 col4
row1    X    X     X    X
row2    X    X     X    X
row3    X   10  11.0   12
row4    X   14   NaN   16
row5    X   18  19.0   20

method / limit인수를 사용한 결측치 보정

method인수는 {ffill / bfill}를 이용해 위쪽 또는 아래쪽 값으로 결측치 보정이 가능합니다.

limit인수의 경우는 method인수를 통해 결측치 보정할 때, 몇개의 값을 보정할지 설정합니다.

ffill로 입력 시 결측값을 바로 위의 값과 동일하게, bfill로 입력 시 결측값을 바로 아래 값과 동일하게 변경 된것을 확인할 수 있습니다.

print(df1.align(df2,join='outer',method='ffill')[0])
print(df1.align(df2,join='outer',method='bfill')[1])
>>
      col1  col2  col3  col4
row1   1.0   2.0   3.0   NaN
row2   5.0   6.0   7.0   NaN
row3   9.0   6.0  11.0   NaN
row4   9.0   6.0  11.0   NaN
row5   9.0   6.0  11.0   NaN
      col1  col2  col3  col4
row1   NaN  10.0  11.0  12.0
row2   NaN  10.0  11.0  12.0
row3   NaN  10.0  11.0  12.0
row4   NaN  14.0  19.0  16.0
row5   NaN  18.0  19.0  20.0

limit 설정시 각 레이블에 대해서 아래와 같이 설정한 갯수만 변경 됩니다.

print(df1.align(df2,join='outer',method='bfill',limit=1)[1])
>>
      col1  col2  col3  col4
row1   NaN   NaN   NaN   NaN
row2   NaN  10.0  11.0  12.0
row3   NaN  10.0  11.0  12.0
row4   NaN  14.0  19.0  16.0
row5   NaN  18.0  19.0  20.0

fill_axis 인수의 사용

fill_axis는 method및 limit를 어느축 기준으로 실행할지 여부입니다. 즉, 가로로 할지 세로로할지 여부입니다.

print(df1.align(df2,join='outer',method='ffill',fill_axis=0)[0])
print(df1.align(df2,join='outer',method='ffill',fill_axis=1)[0])
>>
      col1  col2  col3  col4
row1   1.0   2.0   3.0   NaN
row2   5.0   6.0   7.0   NaN
row3   9.0   6.0  11.0   NaN
row4   9.0   6.0  11.0   NaN
row5   9.0   6.0  11.0   NaN
      col1  col2  col3  col4
row1   1.0   2.0   3.0   3.0
row2   5.0   6.0   7.0   7.0
row3   9.0   9.0  11.0  11.0
row4   NaN   NaN   NaN   NaN
row5   NaN   NaN   NaN   NaN

업데이트 (update)

update메서드는 DataFrame의 열을 other객체의 동일한 열의 값으로 덮어씌우는 메서드입니다.

반환값 없이 원본이 변경됩니다.

self.update(other, join='left', overwrite=True, filter_func=None, errors='ignore')

other : self에 덮어씌울 객체 입니다.

join : {left} 기준이 될 인덱스 입니다. left만 선택 가능하므로 무시해도됩니다.

overwrite : {True / False} 덮어씌울 방식입니다. True면 self의 모든 데이터에 other을 덮어씌웁니다.

False면 self에서 Na인 값에 대해서만 덮어씌우기를 진행합니다.

filter_func : 덮어씌울값을 함수로 정할 수 있습니다.

errors : {raise / ignore} raise일 경우 self와 other 모두 Na가 아닌 값이 있을경우 오류를 발생시킵니다.

df1 = pd.DataFrame({'A':[1,2,3],'B':[n,5,6]})
print(df1)
>>
   A    B
0  1  NaN
1  2  5.0
2  3  6.0

df2 = pd.DataFrame({'B':[24,n,26],'C':[37,38,39]})
print(df2)
>>
      B   C
0  24.0  37
1   NaN  38
2  26.0  39

overwrite인수로 업데이트 방식 설정

overwrite인수가 True면 df1과 df2가 이름을 공유하는 열에 대해서 df2의 값을 df1에 덮어씌웁니다.

False일 경우 df1에서 Na인 값에 대해서만 덮어씌우기를 진행합니다.

※ df2에서 Na인 값의 경우 덮어씌워지지 않습니다.

overwrite=True일 경우(기본값)

df1.update(df2,overwrite=True)
print(df1)
>>
   A     B   # df1의 Na를 포함 덮어씌우기가 진행됨. 5의 경우 df2의 값이 Na이므로 무시
0  1  24.0
1  2   5.0
2  3  26.0

overwrite=False일 경우

df1.update(df2,overwrite=False)
print(df1)
>>
   A     B  # df1에서 Na인 값에 대해서만 업데이트가 진행됨.
0  1  24.0
1  2   5.0
2  3   6.0

filter_func로 원하는 값만 업데이트

filter_func에 함수를 넣음으로서 원하는 값만 업데이트가 가능합니다.

6인 값에 대해서만 업데이트를 하도록 filter_func를 설정하겠습니다

df1.update(df2,filter_func=lambda x: x==6)
print(df1)
>>
   A     B   #df1에서 6인 값에 대해서만 업데이트가 진행됨.
0  1   NaN
1  2   5.0
2  3  26.0

errors인수의 사용법

errors인수를 raise로 할 경우 df1과 df2 모두 같은 위치에 Na가 아닌 값이 있을 경우 오류를 발생시킵니다.

Copydf1.update(df2,errors='raise')
print(df1)
>>
오류발생
ValueError: Data overlaps.

pandas.DataFrame.gt(other, axis='columns', level=None) >pandas.DataFrame.lt(other, axis='columns', level=None) <pandas.DataFrame.ge(other, axis='columns', level=None) >=pandas.DataFrame.le(other, axis='columns', level=None) <=pandas.DataFrame.eq(other, axis='columns', level=None) ==pandas.DataFrame.ne(other, axis='columns', level=None) !=

lt, gt, le, ge, eq, ne 메서드는 DataFrame의 크기 비교를 수행하는 메서드입니다. 각각 >, <, >=, <=, ==, !=와 용도가 같습니다. 그리고 각 메서드는 사용법이 동일합니다. ※각각 less than, grater than, less equal, grater equal, equal, not equal을 뜻합니다.

other : 스칼라, 시퀀스, Series, DataFrame, list등이 올 수 있습니다. 비교하고자 하는 값입니다. axis : {0 : index / 1 : columns} 비교할 레이블 입니다. level : 멀티인덱스 사용시 비교할 레이블의 레벨입니다.

객체생성

col = ['col1','col2','col3']
row = ['A','B','C']
df = pd.DataFrame(data=[[10,20,10],
                        [80,30,60],
                        [20,10,70]],index=row,columns=col)
df

>>
   col1  col2  col3
A    10    20    10
B    80    30    60
C    20    10    70

스칼라와의 비교시에는 단순히 other에 스칼라값을 입력하는것으로 실행할 수 있습니다. 비교 결과는 bool로 표시됩니다.

print(df.eq(10)) # 10과 같은 경우 True 표시
>>

    col1   col2   col3
A   True  False   True
B  False  False  False
C  False   True  False

Series로 입력할 경우 Series의 index를 통해 비교할 레이블의 설정이 가능합니다.

s1 = pd.Series([10,30],index=["col1","col3"])
print(df.gt(s1)) # col1에서 10이상, col3에서 30이상이면 True
>>
    col1   col2   col3
A  False  False  False
B   True  False   True
C   True  False   True

만약 존재하지 않는 레이블을 비교한다면, 해당 레이블이 생성(broadcast)됩니다.

s2 = pd.Series([10],index=["col4"])
print(df.lt(s2)) # df에는 col4가 없기 때문에 col4가 브로드캐스트 됩니다.
>>
    col1   col2   col3   col4
A  False  False  False  False
B  False  False  False  False
C  False  False  False  False

axis에 따른 비교의 차이

print(df.le([10,20,30], axis="columns")) # 열 기준으로 비교했을때 각각 10, 20, 30 이하면 True
>>
    col1   col2   col3
A   True   True   True
B  False  False  False
C  False   True  False

print(df.le([10,20,30], axis="index")) # 행 기준으로 비교했을때 각각 10,20,30 이하면 True
>>
    col1   col2   col3
A   True  False   True
B  False  False  False
C   True   True  False

DataFrame과의 비교

Series와 마찬가지로 특정 레이블이 일치하는 DataFrame과의 비교가 가능합니다.

※ 레이블이 일치하지 않을경우 해당 레이블이 생성(broadcast)됩니다.

먼저 간단한 3x1 짜리 DataFrame을 하나 만들어보겠습니다.

df2 = pd.DataFrame([[50],[50],[50]],index=row,columns=['col1'])
print(df2)
>>
   col1
A    50
B    50
C    50

이제 df와 비교해보겠습니다.

print(df.ge(df2)) # col1에 대해서 각각50, 50, 50 이상이면 True
>>
    col1   col2   col3
A  False  False  False
B   True  False  False
C  False  False  False

멀티 인덱스의 사용 (level인수)

먼저 간단한 멀티인덱스 데이터프레임을 하나 만들어보겠습니다.

row_mul = [['U','U','U','D','D','D'],['A','B','C','A','B','C']]
df_mul = pd.DataFrame(data=[[10,20,10],
                            [80,30,60],
                            [20,10,70],
                            [30,70,60],
                            [10,90,40],
                            [50,30,80]],index=row_mul,columns=col)
print(df_mul)
>>
     col1  col2  col3
U A    10    20    10
  B    80    30    60
  C    20    10    70
D A    30    70    60
  B    10    90    40
  C    50    30    80

이제 여기서 레벨을 선택하여 df와의 비교에 사용해 보겠습니다.

Copyprint(df.ge(df_mul,level=1)) # level=1이기 때문에 A, B, C를 index로하는 두 DataFrame과의 비교처럼
                             # 진행됩니다.
>>
      col1   col2   col3
U A   True   True   True
  B   True   True   True
  C   True   True   True
D A  False  False  False
  B   True  False   True
  C  False  False  False

dtype기반 열 선택 (select_dtyps)

select_dtypes 함수는 열에 포함된 데이터들을 type 기준으로 인덱싱 할 수 있도록 합니다.

select_dtypes(include=None, exclude=None) 형태를 가지며, include에 넣은값을 포함하고

exclude에 넣은 값을 제외한 columns(열)을 DaraFrame 형태로 반환합니다.

col1 = [1, 2, 3, 4, 5]
col2 = ['one', 'two', 'three', 'four', 'five']
col3 = [1.5, 2.5, 3.5, 4.5, 5.5]
col4 = [True, False, False, True, True]
df = pd.DataFrame({"col1": col1, "col2": col2, "col3": col3, "col4": col4})
print(df)

print(df.dtypes)

>>
   col1   col2  col3   col4
0     1    one   1.5   True
1     2    two   2.5  False
2     3  three   3.5  False
3     4   four   4.5   True
4     5   five   5.5   True
col1      int64
col2     object
col3    float64
col4       bool
dtype: object

include사용

include에 포함될 type을 입력함으로써, 해당 type인 열만 반환하는것이 가능합니다.

result = df.select_dtypes(include=[float,bool])
print(result)
>>
   col3   col4
0   1.5   True
1   2.5  False
2   3.5  False
3   4.5   True
4   5.5   True

exclude사용

exclude에 제외할 type을 입력함으로써, 해당 type인 열만 제외하여 반환하는것이 가능합니다.

result = df.select_dtypes(exclude=['int64'])
print(result)
>>
    col2  col3   col4
0    one   1.5   True
1    two   2.5  False
2  three   3.5  False
3   four   4.5   True
4   five   5.5   True

• include & exclude 혼합 사용**

include에 포함될 type을, exclude에 제외할 type을 입력하여 혼용 인덱싱이 가능합니다.

Copyresult = df.select_dtypes(include =[float,object], exclude=['int64'])
print(result)
>>
    col2  col3
0    one   1.5
1    two   2.5
2  three   3.5
3   four   4.5
4   five   5.5

임계값 적용 (clip)

lower : 하한값입니다. 이 이하의 값은 이 값으로 변경됩니다.

upper : 상한값입니다. 이 이상의 값은 이 값으로 변경됩니다.

axis : 계산할 기준이되는 레이블입니다.

inplace : 제자리에서 계산할지 여부 입니다.

inplace의 개념은 간단합니다. 우리가 만약 print(df.dropna())로 df에서 NA를 제거한다고 가정해봅니다.

그럼 NA가 사라진 데이터가 출력되겠지만, 다시 print(df)할 경우 df는 변경되어있지 않을 것입니다.

이때 print(df.dropna(inplace=True))를 수행한다면 print(df) 실행 시 df에도 NA가 삭제되어있는것을

확인할 수 있습니다. 물론 dropna뿐만 아니라 clip처럼 inplace 인수를 가진 모든 함수에서 동일합니다.

즉, df.dropna(inplace=True)는 df = df.dropna( )와 같은 효과를 가집니다.

col  = ['col1','col2','col3']
row  = ['row1','row2','row3']
data = [[-7,3,9],
        [6,-8,1],
        [-3,0,-7]]


df = pd.DataFrame(data,row,col)
print(df)
>>
      col1  col2  col3
row1    -7     3     9
row2     6    -8     1
row3    -3     0    -7

일반적인 사용법

하한선을 -4로 상한선을 5로 clip메서드를 적용시켜보겠습니다.

즉, -4보다 작은수는 -4로. 5보다 큰 수 는 5로 변경되며 그 안의 수는 변경되지 않습니다.

print(df.clip(-4,5))#초과하는 모든 값을 정해진 값으로 변경한다
>>
      col1  col2  col3
row1    -4     3     5 #-7이 -4로 변경, 9가 5로 변경
row2     5    -4     1 # 6이 5로 변경 -8이 -4로 변겅
row3    -3     0    -4 # -7이 -4로 변경

• • 임계값을 Series로 설정**

임계값을 Series형태로 설정하여 각행이나 열마다 원하는 임계값의 지정이 가능합니다.

row1에는 -11, row2에는 -22, row3에는 -3~3으로 임계값을 지정해보겠습니다.

먼저 Series인 s를 설정해보겠습니다.

s = pd.Series(data=[1,2,3],index=row)
print(s)
>>
row1    1
row2    2
row3    3
dtype: int64

이제 임계값을 -s 와 s로 설정하여 clip메서드를 적용해보겠습니다.

Copyprint(df.clip(-s,s,axis=0))#행을 기준으로 모든 값이 변경된다
>>
      col1  col2  col3
row1    -1     1     1 # -1~1 으로 변경
row2     2    -2     1 # -2~2 로 변경
row3    -3     0    -3 # -3~3 으로 변경

레이블 필터링 (filter)

filter 메서드는 레이블에 대해서 조건에 맞는 레이블만 필터링하는 메서드입니다.

내용물이 아니라 레이블에 대해서만 필터링하는것을 유의하세요.

특정 레이블을 이름으로 필터링하거나, 포함된 문자열을 통해 필터링하거나, 정규표현식으로 필터링이 가능합니다.

정규표현식(regular expression)의 경우 regex라고도 하며 파이썬에서는 re 메서드가 지원하는 내용과 동일합니다.

※ 정규표현식의경우 웹상에 자료가 방대하므로 이 페이지에서는 설명하지 않겠습니다. 추후 별도 페이지로 생성 예정입니다.

df.filter(items=None, like=None, regex=None, axis=None)

items : 이름으로 필터링하는 경우입니다. 리스트형태로 입력합니다.

like : str로 필터링합니다. 해당 문자열이 포함된 경우를 반환합니다.

regex : 정규표현식을 이용해 필터링합니다. re.search(regex, label) == True에서 사용되는 경우와 동일합니다.

axis : {0 : index / 1 : columns} 필터링할 레이블입니다. 0은 행, 1은 열 입니다.

먼저 간단한 3x5짜리 데이터를 만들어보겠습니다.

col  = ['alpha','beta','gamma','delta','epsilon']
row  = ['sigma','omega','lambda']
data = [[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]]
df = pd.DataFrame(data,row,col)
print(df)
>>
        alpha  beta  gamma  delta  epsilon
sigma       1     2      3      4        5
omega       6     7      8      9       10
lambda     11    12     13     14       15

items 인수를 사용하는 경우

items인수를 통해 alpha, beta 열을 필터링 해보겠습니다.

print(df.filter(items=['alpha','delta']))#알파와 델타만을 출력한다
>>
        alpha  delta
sigma       1      4
omega       6      9
lambda     11     14

omega행을 필터링해보겠습니다.

print(df.filter(items=['omega'],axis=0))#오메가를 행으로 출력한다
>>
       alpha  beta  gamma  delta  epsilon
omega      6     7      8      9       10

• • like 인수를 사용하는 경우**

like인수를 이용해 'ta'가 포함된 열을 필터링해보겠습니다.

print(df.filter(like='ta'))#ta가 포함된걸 출력한다
>>
        beta  delta
sigma      2      4
omega      7      9
lambda    12     14

• • regex 인수를 사용하는 경우**

regex인수를 사용해서 m과 n이 포함된 열을 필터링 해보겠습니다.

정규표현식 [ ] 는 [ ] 안의 모든 문자가 포함된 경우를 말합니다.

즉, [mn]은m과 n이 포함된 경우입니다.

print(df.filter(regex='[mn]'))#m이나n이 포함된 모든걸 출력한다
>>
        gamma  epsilon
sigma       3        5
omega       8       10
lambda     13       15

g로 시작하는 경우에 대해 필터링 해보겠습니다.

정규표현식 ^는 ^뒤에있는 문자로 시작하는 문자열을 말합니다.

즉, ^g는 g로 시작하는 경우를 말합니다.

print(df.filter(regex='^g'))#g로 시작하는 걸 출력한다
>>
        gamma
sigma       3
omega       8
lambda     13

a로 끝나는 경우에 대해 필터링 해보겠습니다.

정규표현식 $는 $앞에있는 문자로 끝나는 문자열을 말합니다.

즉, a$는 a로 끝나는 경우를 말합니다.

print(df.filter(regex='a$'))# a로 끝나는 걸 모두 출력한다
>>
        alpha  beta  gamma  delta
sigma       1     2      3      4
omega       6     7      8      9
lambda     11    12     13     14

샘플 추출 (sample)

sample 메서드는 DataFrame이나 Series에서 무작위로 몇개의 값(레이블)을 출력하는 메서드입니다.

n : 추출할 갯수 입니다. replace가 False면 n의 최댓값은 레이블의 갯수를 넘을수 없습니다. frac : 추출할 비율입니다. 1보다 작은값으로 설정하며(예 : 0.3 이면 30%), n과 동시에 사용할 수 없습니다.

replace : 중복추출의 허용 여부 입니다. True로 하면 중복추출이 가능하며 n의 최댓값이 레이블의 갯수보다 커도 됩니다. weight : 가중치입니다. 즉 레이블마다 추출될 확률을 지정할 수 있습니다. 합계가 1(100%)이 아닐경우 자동으로 1로 연산합니다. random_state : 랜덤 추출한 값에 시드를 설정할 수 있습니다. 원하는 값을 설정하면, 항상 같은 결과를 출력합니다. ignore_index : index의 무시 여부입니다. True일경우 출력시 index를 무시하고 숫자로 출력합니다. axis : {0 : index / 1 : columns} 추출할 레이블입니다.

col  = ['col1','col2','col3']
row  = ['row1','row2','row3','row4','row5']
data = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15]]
df = pd.DataFrame(data,row,col)
print(df)
>>
      col1  col2  col3
row1     1     2     3
row2     4     5     6
row3     7     8     9
row4    10    11    12
row5    13    14    15

n의 사용과 replcae의 사용

n을 설정함으로써 원하는 갯수의 추출이 가능합니다. n을 2로 설정함으로써 2개의 행이 추출된것을 볼 수 있습니다.

print(df.sample(2))
>>
      col1  col2  col3
row3     7     8     9
row4    10    11    12

행이 5이지만 replace=True로 설정하여 중복 추출을 허용한다면, n이 5보다 커도 됩니다.

print(df.sample(10,replace=True))
>>
      col1  col2  col3
row2     4     5     6
row4    10    11    12
row5    13    14    15
row5    13    14    15
row5    13    14    15
row1     1     2     3
row5    13    14    15
row2     4     5     6
row1     1     2     3
row1     1     2     3

frac를 사용하는경우

frac을 통해 전체에대한 추출 비율을 정할 수 있습니다. frac을 0.4로 설정하므로써, 전체에서 40%인 2개를 추출해보겠습니다.

 print(df.sample(frac=0.4))
 >>
      col1  col2  col3
row2     4     5     6
row5    13    14    15

weights를 통한 가중치의 사용

먼저 가중치를 적용하기위해 5짜리 Series를 하나 만들어보겠습니다.

s = pd.Series(data=[10,10,3,3,1],index=row)
print(s)
>>
row1    10
row2    10
row3     3
row4     3
row5     1
dtype: int64

이제 이 Series s를 weights에 적용시켜보겠습니다. 가장 가중치가 높은 row1, row2가 추출된 것을 확인할 수 있습니다.

물론 가중치가 적더라도 확률적으로 추출될 가능성이 존재합니다.

print(df.sample(2,weights=s))
>>
      col1  col2  col3
row3     7     8     9
row2     4     5     6

random_state를 통한 동일값 재출력 허용

random_state에 원하는 값을 설정하므로써 출력 결과를 동일하게 다시 출력하는것이 가능합니다.

print(df.sample(5,random_state=7))
>>
      col1  col2  col3
row1     1     2     3
row4    10    11    12
row3     7     8     9
row2     4     5     6
row5    13    14    15

위 과정을 통해 row1, row2, row3, row4, row5가 출력되고 random_state에 7을 부여했습니다.

동일한 내용으로 다시 출력하면 같은 값이 아래와 같이 재현됨을 알 수 있습니다.

print(df.sample(5,random_state=7))
>>
      col1  col2  col3
row1     1     2     3
row4    10    11    12
row3     7     8     9
row2     4     5     6
row5    13    14    15

ignore_index의 사용

ignore_index를 True로 하면 index는 사라지고 순서대로 번호가 부여됩니다.

print(df.sample(3,ignore_index=True))
>>
   col1  col2  col3
0     7     8     9
1     4     5     6
2    10    11    12

결측값 확인 (isna, isnull, notna, notnull)

DataFrame.isna( )※ isnull( )과 완전히 동일합니다.

DataFrame.notna( )※ notnull( )과 완전히 동일합니다.

개요

isna 메서드와 notna 메서드는 DataFrame내의 결측값을 확인해서 bool형식으로 반환하는 메서드입니다.

isna의 경우 결측값이면 True 반환, 정상값이면 False반환이며,

notna의 경우 결측값이면False반환, 정상값이면 True를 반환합니다.

먼저 다양한 결측값이 포함된 간단한 4x4짜리 데이터를 만들어보겠습니다.

col  = ['col1','col2','col3','col4']
row  = ['row1','row2','row3']
data = [[1,2,pd.NA,4],
        [np.nan,6,7,8],
        [9,10,11,None]]
df = pd.DataFrame(data,row,col)
>>
      col1  col2  col3  col4
row1   1.0     2  <NA>   4.0
row2   NaN     6     7   8.0
row3   9.0    10    11   NaN

isna / isnull의 사용

isna나 isnull의 경우 결측값이면 True를 반환합니다.

print(df.isna())
>>
           col1   col2   col3   col4 #isna기 때문에 결측값이 true로 출력함
row1  False  False   True  False
row2   True  False  False  False
row3  False  False  False   True

notna / notnull의 사용

notna나 notnull의 경우 결측값이면 False를 반환합니다.

Copyprint(df.notna())#notna는 isna의 반대로 출력한다
>>
       col1  col2   col3   col4
row1   True  True  False   True
row2  False  True   True   True
row3   True  True   True  False

결측값 제거 (dropna)

df.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

axis : {0: index / 1: columns} 결측치 제거를 진행 할 레이블입니다.

how : {'any' : 존재하면 제거 / 'all' : 모두 결측치면 제거} 제거할 유형입니다. 포함만 시켜도 제거할지, 전무 NA여야 제거할지 정할 수 있습니다.

tresh : 결측값이 아닌 값이 몇 개 미만일 경우에만 적용시키는 인수 입니다.

예를들어, tresh값이 3이라면 결측값이 아닌 값이 3개 미만일 경우에만 dropna메서드를 수행합니다.

subset : dropna메서드를 수행할 레이블을 지정합니다.

inplace : 원본을 변경할지의 여부입니다.

예시

먼저 pd.NA가 포함된 간단한 4x5짜리 데이터를 만들어보겠습니다.

col  = ['col1','col2','col3','col4','col5']
row  = ['row1','row2','row3','row4']
data = [[1,2,3,pd.NA,5],[6,pd.NA,8,pd.NA,10],[11,12,13,14,15],[pd.NA,pd.NA,pd.NA,pd.NA,pd.NA]]
df = pd.DataFrame(data,row,col)
print(df)
>>
      col1  col2  col3  col4  col5
row1     1     2     3  <NA>     5
row2     6  <NA>     8  <NA>    10
row3    11    12    13    14    15
row4  <NA>  <NA>  <NA>  <NA>  <NA>

axis값에 따른 결측치 제거 수행

axis가 0인경우 행에 대해서, axis가 1인경우 열에 대해서 결측치 제거가 수행됩니다.

axis=0인 경우 결측치가 포함된 모든 행이 제거되었습니다.

print(df.dropna(axis=0))#결측치 포함 모든 행 제거
>>
     col1 col2 col3 col4 col5
row3   11   12   13   14   15

axis=1인 경우 결측치가 포함된 모든 열이 제거되었습니다. 예시의 경우 모든 열에 NA가 존재하므로 빈 값이 반환됩니다.

print(df.dropna(axis=1))#결측치 포함 모든 열 제거
>>
Empty DataFrame
Columns: []
Index: [row1, row2, row3, row4]

how로 연산기준을 정할 경우

기본적으로 how 는 'any'이며 이 경우 한 값이라도 NA를 가진다면 해당 레이블을 제거합니다.

print(df.dropna(how='any'))
>>
     col1 col2 col3 col4 col5
row3   11   12   13   14   15

how를 'all'로 할 경우 모든값이 NA인 레이블만 삭제됩니다.

print(df.dropna(how='all'))
>>
     col1  col2 col3  col4 col5
row1    1     2    3  <NA>    5
row2    6  <NA>    8  <NA>   10
row3   11    12   13    14   15

thresh 를 이용하는 경우

thresh를 이용하여 정상값의 수를 보장할 수 있습니다.

thresh가 3일 경우 정상값이 3개 미만인 경우에 대해서만 결측치 보정을 진행합니다.

print(df.dropna(thresh=3))
>>
     col1  col2 col3  col4 col5
row1    1     2    3  <NA>    5
row2    6  <NA>    8  <NA>   10
row3   11    12   13    14   15

thresh가 4인 경우 정상값이 4개 미만인 경우에 대해서 결측치 보정을 진행합니다.

print(df.dropna(thresh=4))
>>
     col1 col2 col3  col4 col5
row1    1    2    3  <NA>    5
row3   11   12   13    14   15

subset 인수를 통한 레이블 지정

subset에 리스트형태의 값을 입력함으로써 결측치 제거를 수행할 레이블을 지정할 수 있습니다.

col1, col2에 대해서 결측치가 있는경우만 제거되었습니다.

print(df.dropna(subset=['col1','col2']))
>>
     col1 col2 col3  col4 col5
row1    1    2    3  <NA>    5
row3   11   12   13    14   15

inplcae 인수를 통한 원본의 수정

Pandas에서 공통적으로 inplace 인수는 원본의 수정을 의미합니다. inplace가 True인 경우 원본이 수정됩니다.

df.dropna(inplace=True)
print(df)
>>
     col1 col2 col3 col4 col5    #원본에 대해서도 결측치 제거가 수행됨.
row3   11   12   13   14   15

결측값 없는 인덱스 확인 (first_valid_index / last_valid_index)

first_valid_index메서드의 경우 처음으로 결측치가 아닌값이 나오는 행의 인덱스를 출력합니다. last_valid_index메서드의 경우 마지막으로 결측치가 아닌값이 나오는 행의 인덱스를 출력합니다. 즉, 결측값만 있는 행은 무시한다고 생각하면 됩니다.

먼저 다양한 결측값이 포함된 간단한 5x2짜리 데이터를 만들어보겠습니다.

col  = ['col1','col2']
row  = ['row1','row2','row3','row4','row5']
data = [[np.nan,np.nan],[pd.NA,4],[pd.NA,pd.NaT],[5,6],[np.nan,pd.NA]]
df = pd.DataFrame(data,row,col)
print(df)
>>
      col1  col2
row1   NaN   NaN
row2  <NA>     4
row3  <NA>   NaT
row4     5     6
row5   NaN  <NA>

first_valid_index의 사용

first_valid_index메서드의 경우 처음으로 결측치가 아닌값이 나오는 행의 인덱스를 출력합니다.

이 경우 row2에서 처음으로 정상값인 4가 있으므로 row2를 출력합니다.

print(df.first_valid_index())
>>
row2

last_valid_index의 사용

last_valid_index메서드의 경우 마지막으로 결측치가 아닌값이 나오는 행의 인덱스를 출력합니다.

이 경우 row4이후에는 정상값이 없으므로 row4를 출력합니다.

Copyprint(df.last_valid_index())
>>
row4

결측값 변경 (fillna / backfill / bfill / pad / ffill)

fillna 메서드는 DataFrame에서 결측값을 원하는 값으로 변경하는 메서드입니다.

value : 결측값을 대체할 값입니다. dict형태로도 가능합니다.

method : 결측값을 변경할 방식입니다. bfill로 할경우 결측값을 바로 아래 값과 동일하게 변경합니다.

ffill로 할 경우 결측값을 바로 위 값과 동일하게 변경합니다.

axis : {0 : index / 1 : columns} fillna 메서드를 적용할 레이블입니다.

inplace : 원본을 변경할지 여부입니다. True일 경우 원본을 변경하게 됩니다.

limit : 결측값을 변경할 횟수입니다. 위에서부터 limit로 지정된 갯수만큼만 변경합니다.

downcast : 다운캐스트할지 여부입니다. downcast='infer'일 경우 float64를 int64로 변경합니다.

col  = ['col1','col2','col3','col4','col5']
row  = ['row1','row2','row3','row4','row5']
na = np.nan
data = [[na, 2,na, 4,na],
        [ 6, 7,na, 9,na],
        [11,na,na,14,15],
        [na,17,na,na,20],
        [na,22,na,na,25]]
df = pd.DataFrame(data,row,col)
print(df)
>>
      col1  col2  col3  col4  col5
row1   NaN   2.0   NaN   4.0   NaN
row2   6.0   7.0   NaN   9.0   NaN
row3  11.0   NaN   NaN  14.0  15.0
row4   NaN  17.0   NaN   NaN  20.0
row5   NaN  22.0   NaN   NaN  25.0

value의 형식에 따른 사용

value가 숫자나 문자일 경우 그대로 결측값을 대체하게 됩니다. 여기서는 A로 바꿔보겠습니다.

print(df.fillna('A'))
>>
      col1  col2 col3  col4  col5
row1     A   2.0    A   4.0     A
row2   6.0   7.0    A   9.0     A
row3  11.0     A    A  14.0  15.0
row4     A  17.0    A     A  20.0
row5     A  22.0    A     A  25.0

dict형태로 입력할 경우 각각 레이블값에 대해 원하는 값으로의 변경이 가능합니다.

dict = {'col1':'A','col2':'B','col3':'C','col4':'D','col5':'E'}
print(df.fillna(value=dict))
>>
      col1  col2 col3  col4  col5
row1     A   2.0    C   4.0     E
row2   6.0   7.0    C   9.0     E
row3  11.0     B    C  14.0  15.0
row4     A  17.0    C     D  20.0
row5     A  22.0    C     D  25.0

method인수를 사용하는 경우

method인수에 bfill을 입력할 경우 결측값이 바로 아래값과 동일하게 설정됩니다.

※ df.backfill( )이나 df.bfill( )과 완전히 동일한 기능을 수행합니다.

print(df.fillna(method='bfill'))
>>
      col1  col2  col3  col4  col5
row1   6.0   2.0   NaN   4.0  15.0
row2   6.0   7.0   NaN   9.0  15.0
row3  11.0  17.0   NaN  14.0  15.0
row4   NaN  17.0   NaN   NaN  20.0
row5   NaN  22.0   NaN   NaN  25.0

method인수에 ffill을 입력할 경우 결측값이 바로 위값과 동일하게 설정됩니다.

※ df.pad( )나 df.ffill( )과 완전히 동일한 기능을 수행합니다.

print(df.fillna(method='ffill'))
>>
      col1  col2  col3  col4  col5
row1   NaN   2.0   NaN   4.0   NaN
row2   6.0   7.0   NaN   9.0   NaN
row3  11.0   7.0   NaN  14.0  15.0
row4  11.0  17.0   NaN  14.0  20.0
row5  11.0  22.0   NaN  14.0  25.0

limit인수를 사용하는 경우

limit인수는 각 레이블값에 대해서 결측치 변경을 수행할 횟수입니다. 행 기준일경우 왼쪽부터, 열 기준일 경우 위에서부터 수행합니다.

print(df.fillna('A', limit=2))
>>
      col1  col2 col3  col4  col5
row1     A   2.0    A   4.0     A
row2   6.0   7.0    A   9.0     A
row3  11.0     A  NaN  14.0  15.0
row4     A  17.0  NaN     A  20.0
row5   NaN  22.0  NaN     A  25.0

downcast인수를 사용하는 경우

downcast 인수를 'infer'로 설정함으로써 float64형태를 int64형태로 변경할 수 있습니다.

print(df.fillna(0, downcast='infer'))
>>
      col1  col2  col3  col4  col5
row1     0     2     0     4     0
row2     6     7     0     9     0
row3    11     0     0    14    15
row4     0    17     0     0    20
row5     0    22     0     0    25

inplace를 사용하는 경우

다른 파이썬 객체에서와 마찬가지로 inplace는 원본을 덮어씌우는 기능과 유사한 기능알 합니다.

즉 df.fillna(0, inplace=True) 는 df=df.fillna(0)과 동일한 기능을 합니다.

df.fillna('A',inplace=True)
print(df)
>>
      col1  col2 col3  col4  col5
row1     A   2.0    A   4.0     A
row2   6.0   7.0    A   9.0     A
row3  11.0     A    A  14.0  15.0
row4     A  17.0    A     A  20.0
row5     A  22.0    A     A  25.0

결측값 없는 마지막 행 반환 (asof)

asof 메서드는 인덱스 기준으로 where이전에 결측치가 없는 마지막 행을 구합니다.

기본 사용법

df.asof(where, subset=None)

where : 기준이 되는 인덱스 값입니다.

subset : 기준이 되는 열 입니다.

먼저 결측치가 포함된 6x2짜리 객체를 생성해보겠습니다..

row = [10,20,30,40,50,60]
data = {'A':[1,n,n,4,5,6],'B':[7,8,9,10,n,12]}
df = pd.DataFrame(data=data, index = row)
print(df)
>>
      A     B
10  1.0   7.0
20  NaN   8.0
30  NaN   9.0
40  4.0  10.0
50  5.0   NaN
60  6.0  12.0

where이 단일값이면 반환은 Series형태로 하게 됩니다. subset을 입력하지 않으면 모든 열에대해서 조건을 만족하는 경우를 반환합니다.

print(df.asof(where=45))
>>
A     4.0
B    10.0
Name: 45, dtype: float64

45이전에 A열과 B열 모두 결측치가 없는 행은 40입니다. Index가 40인 값을 출력하였습니다.

입력값이 list인 경우

입력값이 list인 경우 list의 각각 요소에 대해 조건을 만족하는 행을 DataFrame 형태로 반환합니다.

print(df.asof(where=[10,45,60]))
>>
      A     B
10  1.0   7.0
45  4.0  10.0
60  6.0  12.0

10이전에 A와 B모두 결측치가 없는 행은 10입니다.

45이전에 A와 B모두 결측치가 없는 행은 40입니다.

60이전에 A와 B모두 결측치가 없는 행은 60입니다.

subset의 사용

subset을 이용해 특정 열에 대해서만 만족하는 경우를 반환할 수 있습니다.

A에 대해서만 연산 할 경우

print(df.asof(where=[10,35,60],subset='A'))
>>
      A     B
10  1.0   7.0
35  1.0   7.0
60  6.0  12.0

10이전에 A에 대해서 결측치가 없는 행은 10입니다.

35이전에 A에 대해서 결측치가 없는 행은 10입니다.

60이전에 A에 대해서 결측치가 없는 행은 60입니다.

B에 대해서만 연산 할 경우

print(df.asof(where=[10,35,60],subset='B'))
>>
      A     B
10  1.0   7.0
35  NaN   9.0
60  6.0  12.0

10이전에 B에 대해서 결측치가 없는 행은 10입니다.

35이전에 B에 대해서 결측치가 없는 행은 30입니다.

60이전에 B에 대해서 결측치가 없는 행은 60입니다.