Greemplum DB로 데이터 분석을 하려고 할때 처음에 하는 일이 분석에 필요한 데이터를 Greenplum DB에 schema, table 생성하고 데이터를 table에 upload하는 입니다. 이번 포스팅에서는 외부의 데이터를 Greenplum Database Table에 업로드하는 5가지 방법을 소개하겠습니다. 


[ Greenplum DB에 외부 데이터를 upload하는 5가지 방법 ]

1. CREATE EXTERNAL TABLE 후 => CREATE TABLE

2. COPY table_name FROM directory DELIMITER

3. INSERT INTO VALUES ()

4. DB tool인 DBeaver Import Wizard (or pgAdmin IV)

5. Python pandas DataFrame.to_sql() 함수 사용


예제로 사용할 데이터는 UC Irvine Machine Learning Repository 에 있는 abalone 데이터셋입니다. 
( * source: http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data )

전복(abalone)의 성별, 길이, 반지름, 높이, 전체 무게, 내장을 뺀 후의 무게, 내장 무게, 껍질 무게, 고리 (+1.5를 하면 나이가 됨) 변수로 구성된 데이터셋입니다. Toy project로 나이 예측이나 성장정도 분류 문제에 종종 등장하곤 하는 데이터셋입니다. 

Attribute information:

   Given is the attribute name, attribute type, the measurement unit and a
   brief description.  The number of rings is the value to predict: either
   as a continuous value or as a classification problem.

	Name		Data Type	Meas.	Description
	----		---------	-----	-----------
	Sex		nominal			M, F, and I (infant)
	Length		continuous	mm	Longest shell measurement
	Diameter	continuous	mm	perpendicular to length
	Height		continuous	mm	with meat in shell
	Whole weight	continuous	grams	whole abalone
	Shucked weight	continuous	grams	weight of meat
	Viscera weight	continuous	grams	gut weight (after bleeding)
	Shell weight	continuous	grams	after being dried
	Rings		integer			+1.5 gives the age in years

   Statistics for numeric domains:

		Length	Diam	Height	Whole	Shucked	Viscera	Shell	Rings
	Min	0.075	0.055	0.000	0.002	0.001	0.001	0.002	    1
	Max	0.815	0.650	1.130	2.826	1.488	0.760	1.005	   29
	Mean	0.524	0.408	0.140	0.829	0.359	0.181	0.239	9.934
	SD	0.120	0.099	0.042	0.490	0.222	0.110	0.139	3.224 

Correl 0.557 0.575 0.557 0.540 0.421 0.504 0.628 1.0 




  1. CREATE EXTERNAL TABLE => CREATE TABLE

먼저 web 상에 올라가 있는 데이터를 url을 이용하여 external table로 만들고, 그 다음에 create table을 해서 Greenplum DB에 넣는 방법부터 소개하겠습니다. web에 있는 데이터 불러올 때나 하둡에 있는 데이터를 GPDB에 올릴 때는 이 방법에 제일 편리한거 같습니다. 


-- (1) Create an external web table

DROP EXTERNAL TABLE IF EXISTS public.abalone_external;

CREATE EXTERNAL WEB TABLE public.abalone_external(

sex text 

, length float8

, diameter float8

, height float8

, whole_weight float8

, shucked_weight float8

, viscera_weight float8

, shell_weight float8

, rings integer -- target variable to predict

) location('http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data') 

format 'CSV' 

(null as '?');


--Create a table at Greenplum Database from an external table

DROP TABLE IF EXISTS public.abalone;

CREATE TABLE public.abalone AS

SELECT * FROM public.abalone_external

DISTRIBUTED BY (sex);


SELECT * FROM public.abalone LIMIT 10;

 



  2. COPY table_name FROM directory DELIMITER

두번째 방법은 데이터를 csv나 text 파일로 다운로드를 한 후에 => psql로 \COPY 문을 사용해서 Greenplum DB에 데이터를 업로드하는 방법입니다. 만약 회사 보안 상 외부 website url에서 external table로 가져올 수 없는 경우에 유용하게 사용할 수 있는 방법입니다. 파일 다운로드 한 경로에 가서 pwd 로 경로 확인한 후에 FROM 뒤에 데이터를 가져올 경로를 입력하시면 됩니다. 


-- (2) COPY

DROP TABLE IF EXISTS public.abalone;

CREATE TABLE public.abalone(

sex text 

, length float8

, diameter float8

, height float8

, whole_weight float8

, shucked_weight float8

, viscera_weight float8

, shell_weight float8

, rings integer

) DISTRIBUTED BY (sex);


COPY public.abalone (sex, length, diameter, height, whole_weight, shucked_weight, viscera_weight, shell_weight, rings) 

FROM '/Users/ihongdon/Downloads/abalone.data.txt' DELIMITER ',' CSV;

 



  3. INSERT INTO VALUES ()

입력해야 할 데이터 개수가 몇 개 안되는 경우, 혹은 기존 table에 소수의 데이터를 추가하는 경우에 간단하게 사용할 수 있는 방법이 insert into values() 입니다. tutorial 만들거나 교육용 샘플 데이터 만들 때 주로 사용하곤 하는 방법입니다. (반면, 데이터 개수가 많아지면 아무래도 사용하기에 좀 꺼려지는 방법입니다. -_-;)

create table에서 만든 칼럼과 동일한 순서로 데이터를 삽입할 때는 칼럼 이름을 생략해도 됩니다. 


-- (3)INSERT INTO VALUES()

DROP TABLE IF EXISTS public.abalone;

CREATE TABLE public.abalone(

sex text 

, length float8

, diameter float8

, height float8

, whole_weight float8

, shucked_weight float8

, viscera_weight float8

, shell_weight float8

, rings integer

) DISTRIBUTED BY (sex);


INSERT INTO public.abalone 

(sex, length, diameter, height, whole_weight, shucked_weight, viscera_weight, shell_weight, rings) 

VALUES 

('M',0.455,0.365,0.095,0.514,0.2245,0.101,0.15,15), 

('M',0.35,0.265,0.09,0.2255,0.0995,0.0485,0.07,7), 

('F',0.53,0.42,0.135,0.677,0.2565,0.1415,0.21,9), 

('M',0.44,0.365,0.125,0.516,0.2155,0.114,0.155,10), 

('I',0.33,0.255,0.08,0.205,0.0895,0.0395,0.055,7), 

('I',0.425,0.3,0.095,0.3515,0.141,0.0775,0.12,8), 

('F',0.53,0.415,0.15,0.7775,0.237,0.1415,0.33,20), 
('F',0.545,0.425,0.125,0.768,0.294,0.1495,0.26,16); 




  4. DB tool인 DBeaver Import Wizard 사용

csv나 text 파일로 다운로드 해놓은 데이터셋이 있는 경우, DB tool인 DBeaver나 pgAdmin IV의 Import Wizard를 사용하는 방법도 매우 편리합니다. 


-- (4) DBeaver tool's Import Wizard

DROP TABLE IF EXISTS public.abalone;

CREATE TABLE public.abalone(

sex text 

, "length" float8

, "diameter" float8

, "height" float8

, whole_weight float8

, shucked_weight float8

, viscera_weight float8

, shell_weight float8

, rings integer

) DISTRIBUTED BY (sex);



(1) DBeaver tool의 좌측 Database Navigator > DB > Schema > Tables > abalone 테이블에 '마우스 오른쪽' 클릭 > 'Import Data' 선택


(2) Data Transfer 창에서 'CSV' (Import from CSV file(s)) 선택

 

3. Input files 의 Source name 선택 > 탐색기 창이 나타나면 데이터셋이 저장되어 있는 경로로 가서 데이터셋 선택 > Open 단추 클릭 > Next 단추 클릭


4. Data Transfer: Preview data import 에서 데이터셋이 맞게 들어가 있는건지 미리보기로 확인


5. Data Transfer: Settings 화면 > Next 단추 클릭


6. Data Transfer: Confirm 창에서 최종 확인 후, 맞으면 'Finish' 단추 클릭


7. Data Transfer: Data transfer completed (소요 시간, 초)



  5. Python pandas DataFrame.to_sql() 함수 사용

파일 사이즈가 분석 환경의 메모리 한계 내에서 감당할만한 수준인 경우, Python pandas의 read_csv() 함수로 데이터를 읽어들여서 DataFrame으로 만든 다음에, pandas의 to_sql() 함수를 사용하여 Greenplum DB에 pandas DataFrame을 insert할 수 있습니다. 저는 분석할 때 대부분의 경우 Python이나 R을 GPDB와 연동(connect)에서 사용하는데요, Python이나 R의 분석결과를 다시 GPDB에 집어넣을 때 사용하는 방법입니다. 

(Greenplum Database에 Python 연동하는 방법은 https://rfriend.tistory.com/251 , https://rfriend.tistory.com/379 를 참고하세요)


# Importing data from website using pandas read_csv() function

abalone_data_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data"

abalone_columns = ( 'sex', 'length', 'diameter', 'height', 'whole_weight', 'shucked_weight', 'viscera_weight', 'shell_weight', 'rings')

df_abalone = pd.read_csv(abalone_data_url, names=abalone_columns)

 df_abalone.info()

<class 'pandas.core.frame.DataFrame'> RangeIndex: 4177 entries, 0 to 4176 Data columns (total 9 columns): sex 4177 non-null object length 4177 non-null float64 diameter 4177 non-null float64 height 4177 non-null float64 whole_weight 4177 non-null float64 shucked_weight 4177 non-null float64 viscera_weight 4177 non-null float64 shell_weight 4177 non-null float64 rings 4177 non-null int64 dtypes: float64(7), int64(1), object(1) memory usage: 293.8+ KB


# export to Greenplum DB using pandas df.to_sql() function

df_abalone.to_sql( 'abalone', conn, schema='public', if_exists='replace', index=True, index_label='id', chunksize=10000)



많은 도움이 되었기를 바랍니다. 

이번 포스팅이 도움이 되었다면 아래의 '공감~'를 꾹 눌러주세요. 


Posted by R Friend R_Friend

댓글을 달아 주세요

데이터 분석을 하다 보면 여기 저기 흩어져 있는 데이터를 특정한 Key를 기준으로 병합해서 분석해야 하는 경우가 매우 많습니다.

 

지난번 포스팅에서는 DataFrame을 pandas의 concat() 함수를 이용해서 합치는 방법, append() 함수를 사용해서 합치는 방법을 소개하였습니다.

 

이번 포스팅에서는 SQL을 사용해서 Database의 Table 들을 Join/Merge 하는 것과 유사하게 Python pandas의 pd.merge() 함수를 사용해서 DataFrame을 Key 기준으로 inner, outer, left, outer join 하여 합치는 방법을 소개하도록 하겠습니다.

 

SQL을 사용하는데 익숙한 분석가라면 매우 쉽고 빠르게 이해하실 수 있을 것입니다. 그리고 Python의 merge() 기능은 메모리 상에서 매우 빠르게 작동함으로 사용하는데 있어 불편함이 덜할 것 같습니다.

 

 

 

 

 

pandas merge 함수 설정값들은 아래와 같이 여러개가 있는데요, 이중에서  'how'와 'on'은 꼭 기억해두셔야 합니다.

 

 

pd.merge(left, right, # merge할 DataFrame 객체 이름
             how='inner', # left, rigth, inner (default), outer
             on=None, # merge의 기준이 되는 Key 변수
             left_on=None, # 왼쪽 DataFrame의 변수를 Key로 사용
             right_on=None, # 오른쪽 DataFrame의 변수를 Key로 사용
             left_index=False, # 만약 True 라면, 왼쪽 DataFrame의 index를 merge Key로 사용
             right_index=False, # 만약 True 라면, 오른쪽 DataFrame의 index를 merge Key로 사용
             sort=True, # merge 된 후의 DataFrame을 join Key 기준으로 정렬
             suffixes=('_x', '_y'), # 중복되는 변수 이름에 대해 접두사 부여 (defaults to '_x', '_y'
             copy=True, # merge할 DataFrame을 복사
             indicator=False) # 병합된 이후의 DataFrame에 left_only, right_only, both 등의 출처를 알 수 있는 부가 정보 변수 추가

 

 

 

먼저, pandas, DataFrame library를 importing 한 후에, 2개의 DataFrame을 만들어보겠습니다.

 

 

In [1]: import pandas as pd


In [2]: from pandas import DataFrame


In [3]: df_left = DataFrame({'KEY': ['K0', 'K1', 'K2', 'K3'],

   ...: 'A': ['A0', 'A1', 'A2', 'A3'],

   ...: 'B': ['B0', 'B1', 'B2', 'B3']})

   ...:


In [4]: df_right = DataFrame({'KEY': ['K2', 'K3', 'K4', 'K5'],

   ...: 'C': ['C2', 'C3', 'C4', 'C5'],

   ...: 'D': ['D2', 'D3', 'D4', 'D5']})

   ...:


In [5]: df_left

Out[5]:

    A   B KEY
0  A0  B0  K0
1  A1  B1  K1
2  A2  B2  K2
3  A3  B3  K3


In [6]: df_right

Out[6]:

    C   D KEY
0  C2  D2  K2
1  C3  D3  K3
2  C4  D4  K4
3  C5  D5  K5

 

 

 

 

 

'how' 의 left, right, inner, outer 별로 위에서 만든 'df_left'와 'df_right' 두 개의 DataFrame을 'KEY' 변수를 기준으로 merge 해보겠습니다.  SQL join에 익숙하신 분이라면 쉽게 이해할 수 있을 것입니다.

 

 

  (1) Merge method : left (SQL join name : LEFT OUTER JOIN)

 

 

In [7]: df_merge_how_left = pd.merge(df_left, df_right,

   ...: how='left',

   ...: on='KEY')

   ...:


In [8]: df_merge_how_left

Out[8]:

     A   B   KEY   C     D
0  A0  B0  K0  NaN  NaN
1  A1  B1  K1  NaN  NaN
2  A2  B2  K2   C2   D2
3  A3  B3  K3   C3   D3 

 

 

 

 

  (2) Merge method : right (SQL join name : RIGHT OUTER JOIN)

 

 

In [9]: df_merge_how_right = pd.merge(df_left, df_right,

   ...: how='right',

   ...: on='KEY')


In [10]: df_merge_how_right

Out[10]:

     A    KEY   C   D
0   A2   B2  K2  C2  D2
1   A3   B3  K3  C3  D3
2  NaN  NaN  K4  C4  D4
3  NaN  NaN  K5  C5  D5

 

 

 

 

  (3) Merge method : inner (SQL join name : INNER JOIN)

 

 

In [11]: df_merge_how_inner = pd.merge(df_left, df_right,

    ...: how='inner', # default

    ...: on='KEY')

    ...:


In [12]: df_merge_how_inner

Out[12]:

    A   B KEY   C   D
0  A2  B2  K2  C2  D2
1  A3  B3  K3  C3  D3

 

 

 

 

  (4) Merge method : outer (SQL join name : FULL OUTER JOIN)

 

 

In [13]: df_merge_how_outer = pd.merge(df_left, df_right,

    ...: how='outer',

    ...: on='KEY')

    ...:


In [14]: df_merge_how_outer

Out[14]:

     A    B  KEY    C    D
0   A0   B0  K0  NaN  NaN
1   A1   B1  K1  NaN  NaN
2   A2   B2  K2   C2   D2
3   A3   B3  K3   C3   D3
4  NaN  NaN  K4   C4   D4
5  NaN  NaN  K5   C5   D5

 

 

 

[참고] Hive 조인 문 : INNER JOIN, LEFT OUTER JOIN, RIGHT OUTER JOIN, FULL JOIN, CARTESIAN PRODUCT JOIN, MAP-SIDE JOIN, UNION ALL : http://rfriend.tistory.com/216

 

 

 

  (5) indicator = True : 병합된 이후의 DataFrame에 left_only, right_only, both 등의 

                              출처를 알 수 있는 부가정보 변수 추가

 

 

In [15]: pd.merge(df_left, df_right, how='outer', on='KEY',

    ...: indicator=True)

Out[15]:

     A    B KEY    C    D      _merge
0   A0   B0  K0  NaN  NaN   left_only
1   A1   B1  K1  NaN  NaN   left_only
2   A2   B2  K2   C2   D2        both
3   A3   B3  K3   C3   D3        both
4  NaN  NaN  K4   C4   D4  right_only
5  NaN  NaN  K5   C5   D5  right_only

 

 

 

위에서는 indicator=True로 했더니 '_merge'라는 새로운 변수가 생겼습니다.

 

이 방법 외에도, 아래처럼 indicator='변수 이름(예: indicator_info)'을 설정해주면, 새로운 변수 이름에 indicator 정보가 반환됩니다.

 

 

In [16]: pd.merge(df_left, df_right, how='outer', on='KEY',

    ...: indicator='indicator_info')

Out[16]:

     A    B KEY    C    D indicator_info
0   A0   B0  K0  NaN  NaN      left_only
1   A1   B1  K1  NaN  NaN      left_only
2   A2   B2  K2   C2   D2           both
3   A3   B3  K3   C3   D3           both
4  NaN  NaN  K4   C4   D4     right_only
5  NaN  NaN  K5   C5   D5     right_only

 

 

 

 

  (6) 변수 이름이 중복될 경우 접미사 붙이기 : suffixes = ('_x', '_y')

 

'B'와 'C' 의 변수 이름이 동일하게 있는 두 개의 DataFrame을 만든 후에, KEY를 기준으로 합치기(merge)를 해보겠습니다.  변수 이름이 중복되므로 Data Source를 구분할 수 있도록 suffixes = ('string', 'string') 을 사용해서 중복되는 변수의 뒷 부분에 접미사를 추가해보겠습니다.  default는 suffixes = ('_x', '_y') 입니다.

 

 

# making DataFrames with overlapping columns

In [17]: df_left_2 = DataFrame({'KEY': ['K0', 'K1', 'K2', 'K3'],

    ...: 'A': ['A0', 'A1', 'A2', 'A3'],

    ...: 'B': ['B0', 'B1', 'B2', 'B3'],

    ...: 'C': ['C0', 'C1', 'C2', 'C3']})


In [18]: df_right_2 = DataFrame({'KEY': ['K0', 'K1', 'K2', 'K3'],

    ...: 'B': ['B0_2', 'B1_2', 'B2_2', 'B3_2'],

    ...: 'C': ['C0_2', 'C1_2', 'C2_2', 'C3_2'],

    ...: 'D': ['D0_2', 'D1_2', 'D2_2', 'D3_3']})

    ...:


In [19]: df_left_2

Out[19]:

    A   B   C KEY
0  A0  B0  C0  K0
1  A1  B1  C1  K1
2  A2  B2  C2  K2
3  A3  B3  C3  K3


In [20]: df_right_2

Out[20]:

      B     C     D KEY
0  B0_2  C0_2  D0_2  K0
1  B1_2  C1_2  D1_2  K1
2  B2_2  C2_2  D2_2  K2
3  B3_2  C3_2  D3_3  K3

 


# adding string suffixes to apply to overlapping columns

In [21]: pd.merge(df_left_2, df_right_2, how='inner', on='KEY',

    ...: suffixes=('_left', '_right'))

    ...:

Out[21]:

    A B_left C_left KEY B_right C_right     D
0  A0     B0     C0  K0    B0_2    C0_2  D0_2
1  A1     B1     C1  K1    B1_2    C1_2  D1_2
2  A2     B2     C2  K2    B2_2    C2_2  D2_2
3  A3     B3     C3  K3    B3_2    C3_2  D3_3

 


# suffixes defaults to ('_x', '_y') 

In [22]: pd.merge(df_left_2, df_right_2, how='inner', on='KEY')

    ...:

Out[22]:

    A B_x C_x KEY   B_y   C_y     D
0  A0  B0  C0  K0  B0_2  C0_2  D0_2
1  A1  B1  C1  K1  B1_2  C1_2  D1_2
2  A2  B2  C2  K2  B2_2  C2_2  D2_2
3  A3  B3  C3  K3  B3_2  C3_2  D3_3

 

 

 

 

 

left_on, right_on, left_index, right_index 에 대해서는 다음번 포스팅에서 소개하도록 하겠습니다.

 

Posted by R Friend R_Friend

댓글을 달아 주세요

분석을 하다보면 여기저기 흩어져 있는 여러 개의 데이터 테이블을 모아서 합쳐야 하는 일이 생기곤 합니다. 나를 대신해서 누군가가 데이터 전처리를 해주지 않는다고 했을 때는 말이지요.

 

특히 정규화해서 Database 관리를 하는 곳이라면 주제별로 Data Entity를 구분해서 여러 개의 Table들로 데이터가 나뉘어져 있을 것입니다.

 

특히, 데이터의 속성 형태가 동일한 데이터셋(homogeneously-typed objects)끼리 합칠 때 사용할 수 있는 pandas의 DataFrame 합치는 방법(concatenating DataFrames)으로 이번 포스팅에서는 pd.concat() 함수를 소개하겠습니다.

(R의 rbind(), cbind() 와 유사함)

 

pd.concat() 의 parameter 값들의 default setting은 아래와 같습니다. 하나씩 예를 들어가면서 소개하겠습니다.

 

 

pd.concat(objs,  # Series, DataFrame, Panel object

             axis=0,  # 0: 위+아래로 합치기, 1: 왼쪽+오른쪽으로 합치기

             join='outer', # 'outer': 합집합(union), 'inner': 교집합(intersection)

             join_axes=None, # axis=1 일 경우 특정 DataFrame의 index를 그대로 이용하려면 입력

             ignore_index=False,  # False: 기존 index 유지, True: 기존 index 무시
             keys=None, # 계층적 index 사용하려면 keys 튜플 입력

             levels=None,

             names=None, # index의 이름 부여하려면 names 튜플 입력

             verify_integrity=False, # True: index 중복 확인
             copy=True) # 복사

 

 

 

 

  (1-1) 위 + 아래로 DataFrame 합치기(rbind) : axis = 0

 

 

# importing libraries

In [1]: import pandas as pd

   ...: from pandas import DataFrame

 

 

 

# making DataFrames

In [2]: df_1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

   ...: 'B': ['B0', 'B1', 'B2'],

   ...: 'C': ['C0', 'C1', 'C2'],

   ...: 'D': ['D0', 'D1', 'D2']},

   ...: index=[0, 1, 2])


In [3]: df_2 = pd.DataFrame({'A': ['A3', 'A4', 'A5'],

   ...: 'B': ['B3', 'B4', 'B5'],

   ...: 'C': ['C3', 'C4', 'C5'],

   ...: 'D': ['D3', 'D4', 'D5']},

   ...: index=[3, 4, 5])

 

In [4]: df_1

Out[4]:

    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2


In [5]: df_2

Out[5]:

    A   B   C   D
3  A3  B3  C3  D3
4  A4  B4  C4  D4
5  A5  B5  C5  D5

 

 

 

# concatenating DataFrame1, 2 along rows, axis=0, default

In [6]: df_12_axis0 = pd.concat([df_1, df_2]) # row bind : axis = 0, default


In [7]: df_12_axis0

Out[7]:

    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2
3  A3  B3  C3  D3
4  A4  B4  C4  D4
5  A5  B5  C5  D5

 

 

 

 

 (1-2) 왼쪽 + 오른쪽으로 DataFrame 합치기(cbind) : axis = 1

 

 

In [8]: df_3 = pd.DataFrame({'E': ['A6', 'A7', 'A8'],

   ...: 'F': ['B6', 'B7', 'B8'],

   ...: 'G': ['C6', 'C7', 'C8'],

   ...: 'H': ['D6', 'D7', 'D8']},

   ...: index=[0, 1, 2])

 

In [9]: df_1

Out[9]:

    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2


In [10]: df_3

Out[10]:

    E   F   G   H
0  A6  B6  C6  D6
1  A7  B7  C7  D7
2  A8  B8  C8  D8

 

 

 

# concatenating DataFrames along columns, axis=1

In [11]: df_13_axis1 = pd.concat([df_1, df_3], axis=1) # column bind


In [12]: df_13_axis1

Out[12]:

     A   B   C   D    E    F    G   H
0  A0  B0  C0  D0  A6  B6  C6  D6
1  A1  B1  C1  D1  A7  B7  C7  D7
2  A2  B2  C2  D2  A8  B8  C8  D8

 

 

 

 

 (2-1) 합집합(union)으로 DataFrame 합치기 : join = 'outer'

 

 

In [13]: df_4 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

    ...: 'B': ['B0', 'B1', 'B2'],

    ...: 'C': ['C0', 'C1', 'C2'],

    ...: 'E': ['E0', 'E1', 'E2']},

    ...: index=[0, 1, 3])


In [17]: df_1

Out[17]:

    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2


In [18]: df_4

Out[18]:

     A   B   C   E
0  A0  B0  C0  E0
1  A1  B1  C1  E1
3  A2  B2  C2  E2


In [19]: df_14_outer = pd.concat([df_1, df_4], join='outer') # union, default


In [20]: df_14_outer

Out[20]:

     A   B   C    D    E
0  A0  B0  C0   D0  NaN
1  A1  B1  C1   D1  NaN
2  A2  B2  C2   D2  NaN
0  A0  B0  C0  NaN   E0
1  A1  B1  C1  NaN
   E1
3  A2  B2  C2  NaN   E2

 

 

 

 

 (2-2) 교집합(intersection)으로 DataFrame 합치기 : join = 'inner'

 

 

In [21]: df_14_inner = pd.concat([df_1, df_4], join='inner') # intersection


In [22]: df_14_inner

Out[22]:

    A   B   C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
0  A0  B0  C0
1  A1  B1  C1
3  A2  B2  C2

 

 

 

 

 (3) axis=1일 경우 특정 DataFrame의 index를 그대로 이용하고자 할 경우 : join_axes

 

아래에 axis=1 (왼쪽+오른쪽) 인 경우, join='outer', join='inner', join_axes=[df.index] 의 3개 방법을 소개하였습니다. 합쳐진 DataFrame의 index 를 유심히 비교해보시기 바랍니다.

 

 

In [23]: df_1

Out[23]:

     A   B   C   D
 0  A0  B0  C0  D0
 1  A1  B1  C1  D1
 2  A2  B2  C2  D2


In [24]: df_4

Out[24]:

     A   B   C   E
 0  A0  B0  C0  E0
 1  A1  B1  C1  E1
 3  A2  B2  C2  E2

 

# comparison 1
In [25]: df_14_outer_axis1 = pd.concat([df_1, df_4], join='outer', axis=1) # default


In [26]: df_14_outer_axis1

Out[26]:

      A    B    C    D    A    B    C    E
 0   A0   B0   C0   D0   A0   B0   C0   E0
 1   A1   B1   C1   D1   A1   B1   C1   E1
 2   A2   B2   C2   D2  NaN  NaN  NaN  NaN
 3  NaN  NaN  NaN  NaN   A2   B2   C2   E2

 

# comparison 2 

In [29]: df_14_inner_axis1 = pd.concat([df_1, df_4], join='inner', axis=1)


In [30]: df_14_inner_axis1

Out[30]:

     A   B   C   D   A   B   C   E
 0  A0  B0  C0  D0  A0  B0  C0  E0
 1  A1  B1  C1  D1  A1  B1  C1  E1

 

 

# reuse the exact index from the original DataFrame : join_axes

In [31]: df_14_join_axes_axis1 = pd.concat([df_1, df_4], join_axes=[df_1.index], axis=1)


In [32]: df_14_join_axes_axis1

Out[32]:

     A   B   C   D    A    B    C    E
 0  A0  B0  C0  D0   A0   B0   C0   E0
 1  A1  B1  C1  D1   A1   B1   C1   E1
 2  A2  B2  C2  D2  NaN  NaN  NaN  NaN

 

 

 

 (4) 기존 index를 무시하고 싶을 때 : ignore_index

 

 

In [33]: df_5 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

    ...: 'B': ['B0', 'B1', 'B2'],

    ...: 'C': ['C0', 'C1', 'C2'],

    ...: 'D': ['D0', 'D1', 'D2']},

    ...: index=['r0', 'r1', 'r2'])


In [34]: df_6 = pd.DataFrame({'A': ['A3', 'A4', 'A5'],

    ...: 'B': ['B3', 'B4', 'B5'],

    ...: 'C': ['C3', 'C4', 'C5'],

    ...: 'D': ['D3', 'D4', 'D5']},

    ...: index=['r3', 'r4', 'r5'])

 

In [35]: df_56_with_index = pd.concat([df_5, df_6], ignore_index=False) # default


In [36]: df_56_with_index

Out[36]:

     A   B   C   D
 r0  A0  B0  C0  D0
 r1  A1  B1  C1  D1
 r2  A2  B2  C2  D2
 r3  A3  B3  C3  D3
 r4  A4  B4  C4  D4
 r5  A5  B5  C5  D5

 

# if you want ignore current index, use 'ignore_index=True'

In [37]: df_56_ignore_index = pd.concat([df_5, df_6], ignore_index=True)# index 0~(n-1)


In [38]: df_56_ignore_index

Out[38]:

    A   B   C   D
 0  A0  B0  C0  D0
 1  A1  B1  C1  D1
 2  A2  B2  C2  D2
 3  A3  B3  C3  D3
 4  A4  B4  C4  D4
 5  A5  B5  C5  D5

 

 

 

 

 (5) 계층적 index (hierarchical index) 만들기 : keys 

 

 

# concatenating DataFrames : Construct hierarchical index using 'keys'


In [40]: df_56_with_keys = pd.concat([df_5, df_6], keys=['df_5', 'df_6'])


In [41]: df_56_with_keys

Out[41]:

            A   B   C   D
 df_5  r0  A0  B0  C0  D0
         r1  A1  B1  C1  D1
         r2  A2  B2  C2  D2
 df_6  r3  A3  B3  C3  D3
         r4  A4  B4  C4  D4
         r5  A5  B5  C5  D5 

 

 

 

참고로, 계층적 index를 가지고 indexing 하는 방법을 아래에 예를 들어 소개하겠습니다.  'df_56_with_keys' DataFrame은 index가 1층, 2층으로 계층을 이루고 있으므로 indexing 할 때 1층용 index와 2층용 index를 따로 따로 사용하면 됩니다. 아래 예시를 참고하세요.

 

 

In [42]: df_56_with_keys.ix['df_5']

Out[42]:

     A   B   C   D
r0  A0  B0  C0  D0
r1  A1  B1  C1  D1
r2  A2  B2  C2  D2


In [43]: df_56_with_keys.ix['df_5'][0:2]

Out[43]:

     A   B   C   D
r0  A0  B0  C0  D0
r1  A1  B1  C1  D1

 

 

 

 

 (6) index에 이름 부여하기 : names

 

 

In [44]: df_56_with_name = pd.concat([df_5, df_6],

    ...: keys=['df_5', 'df_6'],

    ...: names=['df_name', 'row_number'])


In [45]: df_56_with_name

Out[45]:

                                 A   B   C   D
df_name   row_number               
df_5         r0                A0  B0  C0  D0
              r1                A1  B1  C1  D1
              r2                A2  B2  C2  D2
df_6         r3                A3  B3  C3  D3
              r4                A4  B4  C4  D4
              r5                A5  B5  C5  D5

 

 

 

 

 (7) index 중복 여부 점검 : verify_integrity

 

df_7, df_8 DataFrame에 'r2' index를 중복으로 포함시킨 후에 pd.concat() 을 적용해보겠습니다. verify_integrity=False (디폴트이므로 별도 입력 안해도 됨) 에서는 아무 에러 메시지 없이 위+아래로 잘 합쳐집니다 ('r2' index가 위+아래로 2번 중복해서 나타남).  반면에, verify_integrity=True 를 설정해주면 만약 index 중복이 있을 경우 'ValueError: Indexes have overlapping values: xxx' 에러 메시지가 뜨면서 합치기가 아예 안됩니다.

 

 

In [48]: df_7 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],

    ...: 'B': ['B0', 'B1', 'B2'],

    ...: 'C': ['C0', 'C1', 'C2'],

    ...: 'D': ['D0', 'D1', 'D2']},

    ...: index=['r0', 'r1', 'r2'])

    ...:


In [49]: df_8 = pd.DataFrame({'A': ['A2', 'A3', 'A4'],

    ...: 'B': ['B2', 'B3', 'B4'],

    ...: 'C': ['C2', 'C3', 'C4'],

    ...: 'D': ['D2', 'D3', 'D4']},

    ...: index=['r2', 'r3', 'r4'])


In [50]: df_7

Out[50]:

     A   B   C   D
r0  A0  B0  C0  D0
r1  A1  B1  C1  D1
r2  A2  B2  C2  D2


In [51]: df_8

Out[51]:

     A   B   C   D
r2  A2  B2  C2  D2
r3  A3  B3  C3  D3
r4  A4  B4  C4  D4

 

 

# concatenating DataFrames without overlap checking : verify_integrity=False

 

In [52]: df_78_F_verify_integrity = pd.concat([df_7, df_8],

    ...: verify_integrity=False) # default


In [53]: df_78_F_verify_integrity

Out[53]:

     A   B   C   D
r0  A0  B0  C0  D0
r1  A1  B1  C1  D1
r2  A2  B2  C2  D2
r2  A2  B2  C2  D2
r3  A3  B3  C3  D3
r4  A4  B4  C4  D4

 

 

# index overlap checking, using verify_integrity=True

 

In [54]: df_78_T_verify_integrity = pd.concat([df_7, df_8],

    ...: verify_integrity=True)

 

Traceback (most recent call last):

  File "<ipython-input-56-5512ad3b5016>", line 2, in <module>
    verify_integrity=True)

  File "C:\Anaconda3\lib\site-packages\pandas\tools\merge.py", line 845, in concat
    copy=copy)

  File "C:\Anaconda3\lib\site-packages\pandas\tools\merge.py", line 984, in __init__
    self.new_axes = self._get_new_axes()

  File "C:\Anaconda3\lib\site-packages\pandas\tools\merge.py", line 1073, in _get_new_axes
    new_axes[self.axis] = self._get_concat_axis()

  File "C:\Anaconda3\lib\site-packages\pandas\tools\merge.py", line 1132, in _get_concat_axis
    self._maybe_check_integrity(concat_axis)

  File "C:\Anaconda3\lib\site-packages\pandas\tools\merge.py", line 1141, in _maybe_check_integrity
    % str(overlap))

 

ValueError: Indexes have overlapping values: ['r2']

 

 

많은 도움이 되었기를 바랍니다.

 

도움이 되었다면 아래의 '공감 ~♡'를 꾹 눌러주세요. ^^

 

Posted by R Friend R_Friend

댓글을 달아 주세요