Pandas Dataframe 통합 실현
Pandas 는 Series 와 Dataframe 을 통합 하 는 강력 한 기능 을 많이 제공 하여 이러한 기능 을 통 해 데이터 분석 을 편리 하 게 할 수 있 습 니 다.본 고 는 어떻게 Pandas 를 사용 하여 Series 와 Dataframe 을 합병 하 는 지 상세 하 게 설명 할 것 이다.
concat 사용 하기
concat 는 DF 를 합병 하 는 가장 일반적인 방법 입 니 다.먼저 concat 의 정 의 를 보십시오.
pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None,
levels=None, names=None, verify_integrity=False, copy=True)obbs 는 Series 나 Series 의 시퀀스 나 맵 입 니 다.
axis 에서 연결 축 을 지정 합 니 다.
join:{'inner','outer'},연결 방식,다른 축의 index 를 어떻게 처리 하 는 지,outer 는 합병 을 표시 하고 inner 는 교 집합 을 표시 합 니 다.ignore_index:원래 의 index 값 을 무시 하고 0,1,...n-1 로 대체 합 니 다.
copy:복사 할 지 여부 입 니 다.
keys:가장 바깥쪽 의 다 차원 구조의 index 를 지정 합 니 다.
우 리 는 먼저 몇 개의 DF 를 정의 한 후에 concat 를 사용 하여 이 몇 개의 DF 를 연결 하 는 지 봅 시다.
In [1]: df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
...: 'B': ['B0', 'B1', 'B2', 'B3'],
...: 'C': ['C0', 'C1', 'C2', 'C3'],
...: 'D': ['D0', 'D1', 'D2', 'D3']},
...: index=[0, 1, 2, 3])
...:
In [2]: df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
...: 'B': ['B4', 'B5', 'B6', 'B7'],
...: 'C': ['C4', 'C5', 'C6', 'C7'],
...: 'D': ['D4', 'D5', 'D6', 'D7']},
...: index=[4, 5, 6, 7])
...:
In [3]: df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
...: 'B': ['B8', 'B9', 'B10', 'B11'],
...: 'C': ['C8', 'C9', 'C10', 'C11'],
...: 'D': ['D8', 'D9', 'D10', 'D11']},
...: index=[8, 9, 10, 11])
...:
In [4]: frames = [df1, df2, df3]
In [5]: result = pd.concat(frames)
여러 등급 의 예 를 들다.
In [6]: result = pd.concat(frames, keys=['x', 'y', 'z'])
keys 를 사용 하면 frames 의 다른 frames 의 key 를 지정 할 수 있 습 니 다.
사용 할 때,우 리 는 외부 키 를 선택 하여 특정한 frame 로 돌아 갈 수 있 습 니 다:
In [7]: result.loc['y']
Out[7]:
A B C D
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
In [8]: df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
...: 'D': ['D2', 'D3', 'D6', 'D7'],
...: 'F': ['F2', 'F3', 'F6', 'F7']},
...: index=[2, 3, 6, 7])
...:
In [9]: result = pd.concat([df1, df4], axis=1, sort=False)
기본 값
join='outer'합병 후 index 가 존재 하지 않 는 곳 은 NaN 으로 보 완 됩 니 다.다음은 join='inner'의 상황 을 보 겠 습 니 다.
In [10]: result = pd.concat([df1, df4], axis=1, join='inner')
join='inner'는 index 와 같은 것 만 선택 하여 보 여 줍 니 다.
합병 후,우 리 는 원래 frame 의 index 와 관련 된 데이터 만 저장 하려 면 reindex 를 사용 할 수 있 습 니 다.
In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)
In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]:
A B C D B D F
0 A0 B0 C0 D0 NaN NaN NaN
1 A1 B1 C1 D1 NaN NaN NaN
2 A2 B2 C2 D2 B2 D2 F2
3 A3 B3 C3 D3 B3 D3 F3
DF 와 Series 를 합 칠 수 있 습 니 다.
In [18]: s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X')
In [19]: result = pd.concat([df1, s1], axis=1)
여러 Series 라면 concat 를 사용 하면 열 이름 을 지정 할 수 있 습 니 다.
In [23]: s3 = pd.Series([0, 1, 2, 3], name='foo')
In [24]: s4 = pd.Series([0, 1, 2, 3])
In [25]: s5 = pd.Series([0, 1, 4, 5])
In [27]: pd.concat([s3, s4, s5], axis=1, keys=['red', 'blue', 'yellow'])
Out[27]:
red blue yellow
0 0 0 0
1 1 1 1
2 2 2 4
3 3 3 5append 는 concat 의 간략화 버 전 으로 볼 수 있 습 니 다.
In [13]: result = df1.append(df2)
append 의 두 DF 열 이 다 르 면 NaN 을 자동 으로 완성 합 니 다.
In [14]: result = df1.append(df4, sort=False)
ignore 를 설정 하면index=True,원래 의 index 를 무시 하고 분배 index 를 다시 쓸 수 있 습 니 다.
In [17]: result = df1.append(df4, ignore_index=True, sort=False)
DF append 에 Series:
In [35]: s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])
In [36]: result = df1.append(s2, ignore_index=True)
merge 사용 하기
DF 와 가장 유사 한 것 은 데이터베이스 의 표 로 merge 를 사용 하여 데이터베이스 작업 과 유사 한 DF 통합 작업 을 할 수 있다.
merge 의 정 의 를 먼저 보 세 요:
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False,
validate=None)on 은 join 의 열 이나 index 이름 을 대표 합 니 다.
left_on:왼쪽 연결
오른쪽 연결
4.567914.연결 후 왼쪽 index 나 column 을 선택 하 십시오.
4.567914.연결 후 오른쪽 index 나 column 을 선택 하 십시오.
how:연결 방식,
axis=0,right_on,left_index,right_index기본 값'left'4.567914.정렬 여부.4.567914.중 복 된 열 을 처리 합 니 다.
데이터 복사 여부
먼저 간단 한 merge 의 예 를 보 세 요.
In [39]: left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
....: 'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3']})
....:
In [40]: right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
....: 'C': ['C0', 'C1', 'C2', 'C3'],
....: 'D': ['D0', 'D1', 'D2', 'D3']})
....:
In [41]: result = pd.merge(left, right, on='key')
위의 두 DF 는 키 를 통 해 연결된다.
여러 key 연결 의 예 를 다시 봅 니 다:
In [42]: left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
....: 'key2': ['K0', 'K1', 'K0', 'K1'],
....: 'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3']})
....:
In [43]: right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
....: 'key2': ['K0', 'K0', 'K0', 'K0'],
....: 'C': ['C0', 'C1', 'C2', 'C3'],
....: 'D': ['D0', 'D1', 'D2', 'D3']})
....:
In [44]: result = pd.merge(left, right, on=['key1', 'key2'])
How merge 방식 을 지정 할 수 있 습 니 다.데이터베이스 와 마찬가지 로 내부 연결,외부 연결 등 을 지정 할 수 있 습 니 다.
합병 방법
SQL 방법
left
LEFT OUTER JOIN
right
RIGHT OUTER JOIN
outer
FULL OUTER JOIN
inner
INNER JOIN
In [45]: result = pd.merge(left, right, how='left', on=['key1', 'key2'])
indicator=True 를 지정 하면 구체 적 인 줄 의 연결 방식 을 표시 할 수 있 습 니 다.
In [60]: df1 = pd.DataFrame({'col1': [0, 1], 'col_left': ['a', 'b']})
In [61]: df2 = pd.DataFrame({'col1': [1, 2, 2], 'col_right': [2, 2, 2]})
In [62]: pd.merge(df1, df2, on='col1', how='outer', indicator=True)
Out[62]:
col1 col_left col_right _merge
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only
In [63]: pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
Out[63]:
col1 col_left col_right indicator_column
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only
In [112]: leftindex = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),
.....: ('K1', 'X2')],
.....: names=['key', 'X'])
.....:
In [113]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
.....: 'B': ['B0', 'B1', 'B2']},
.....: index=leftindex)
.....:
In [114]: rightindex = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),
.....: ('K2', 'Y2'), ('K2', 'Y3')],
.....: names=['key', 'Y'])
.....:
In [115]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
.....: 'D': ['D0', 'D1', 'D2', 'D3']},
.....: index=rightindex)
.....:
In [116]: result = pd.merge(left.reset_index(), right.reset_index(),
.....: on=['key'], how='inner').set_index(['key', 'X', 'Y'])
여러 열의 병합 지원:
In [117]: left_index = pd.Index(['K0', 'K0', 'K1', 'K2'], name='key1')
In [118]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
.....: 'B': ['B0', 'B1', 'B2', 'B3'],
.....: 'key2': ['K0', 'K1', 'K0', 'K1']},
.....: index=left_index)
.....:
In [119]: right_index = pd.Index(['K0', 'K1', 'K2', 'K2'], name='key1')
In [120]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
.....: 'D': ['D0', 'D1', 'D2', 'D3'],
.....: 'key2': ['K0', 'K0', 'K0', 'K1']},
.....: index=right_index)
.....:
In [121]: result = left.merge(right, on=['key1', 'key2'])
join 사용 하기
join 은 서로 다른 index 의 DF 두 개 를 하나 로 합 쳤 다.merge 의 약자 로 볼 수 있 습 니 다.
In [84]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
....: 'B': ['B0', 'B1', 'B2']},
....: index=['K0', 'K1', 'K2'])
....:
In [85]: right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
....: 'D': ['D0', 'D2', 'D3']},
....: index=['K0', 'K2', 'K3'])
....:
In [86]: result = left.join(right)
연결 방식 을 지정 하 는 방법 을 지정 할 수 있 습 니 다:
In [87]: result = left.join(right, how='outer')
기본 join 은 index 로 연결 합 니 다.
열 에 따라 연결 할 수 있 습 니 다:
In [91]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3'],
....: 'key': ['K0', 'K1', 'K0', 'K1']})
....:
In [92]: right = pd.DataFrame({'C': ['C0', 'C1'],
....: 'D': ['D0', 'D1']},
....: index=['K0', 'K1'])
....:
In [93]: result = left.join(right, on='key')
단일 index 와 여러 index 로 join:
In [100]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
.....: 'B': ['B0', 'B1', 'B2']},
.....: index=pd.Index(['K0', 'K1', 'K2'], name='key'))
.....:
In [101]: index = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),
.....: ('K2', 'Y2'), ('K2', 'Y3')],
.....: names=['key', 'Y'])
.....:
In [102]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
.....: 'D': ['D0', 'D1', 'D2', 'D3']},
.....: index=index)
.....:
In [103]: result = left.join(right, how='inner')
열 이름 이 중 복 된 경우:
In [122]: left = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'v': [1, 2, 3]})
In [123]: right = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'v': [4, 5, 6]})
In [124]: result = pd.merge(left, right, on='k')
중복 열 이름 의 이름 규칙 을 사용자 정의 할 수 있 습 니 다:
In [125]: result = pd.merge(left, right, on='k', suffixes=('_l', '_r'))
덮어 쓰기 데이터
때때로 우 리 는 DF2 의 데 이 터 를 사용 하여 DF1 의 데 이 터 를 채 워 야 하 는데,이 럴 때 는 combine 를 사용 할 수 있다.first：
In [131]: df1 = pd.DataFrame([[np.nan, 3., 5.], [-4.6, np.nan, np.nan],
.....: [np.nan, 7., np.nan]])
.....:
In [132]: df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-5., 1.6, 4]],
.....: index=[1, 2])
.....:
In [133]: result = df1.combine_first(df2)
Pandas 의 Dataframe 통합 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.Pandas Dataframe 통합 에 관 한 더 많은 내용 은 저희 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 읽 어 주시 기 바 랍 니 다.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Pandas의 DataFrame 스왑 열 순서 방법 구현1. DataFrame 열 레이블 가져오기 ['ps_state-stopped', 'ps_state-running', 'ps_state-blocked', 'ps_state-paging', 'ps_state-sleepi...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
