R, Python 분석과 프로그래밍의 친구 (by R Friend)

[Greenplum DB] 외부 데이터를 Table에 업로드하는 5가지 방법 : CREATE EXTERNAL TABLE, COPY, INSERT INTO VALUES(), pd.DataFrame.to_sql(), DBeaver import

Greenplum and PostgreSQL Database 2019. 3. 10. 23:58

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;

Encodnig 을 설정하려면 아래의 예처럼 COPY 구문의 'ENCODING' 매개변수에 원하는 encoding 방법을 설정해주면 됩니다.

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

FROM '/Users/ihongdon/Downloads/abalone.data.txt'
(DELIMITER ',', FORMAT CSV, ENCODING 'UTF8');

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
# postgresql://Username:Password@Host:Port/Database
conn = "postgresql://gpadmin:changeme@localhost:5432/demo"

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

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

이번 포스팅이 도움이 되었다면 아래의 '공감~

'를 꾹 눌러주세요.

728x90

저작자표시 비영리 변경금지

'Greenplum and PostgreSQL Database' 카테고리의 다른 글

[Greenplum & PostgreSQL DB] 동일 간격 범위별로 관측치 개수를 세고(width_bucket), Python으로 막대그래프 시각화하기(bar plot) (0)	2019.03.21
[Greenplum DB] 데이터 전처리 (data preprocessing) : 결측값, 대소문자, 조건문, Substring, 날짜 (0)	2019.03.16
Greenplum DB, Postgresql DB에 사용할 수 있는 오픈소스 database tool DBeaver 설치 및 사용 방법 (0)	2019.03.04
[Docker] Error response from daemon: driver failed programming external connectivity on endpoint, port is already allocated 대처 방법 (port 강제 종료) (11)	2018.09.24
[Greenplum, Postgresql] 중복된 관측치 제거하기 (how to delete duplicated rows) (0)	2018.08.29

Posted by Rfriend

,

[Python pandas] Database처럼 DataFrame Join/Merge 하기 : pd.merge()

Python 분석과 프로그래밍/Python 데이터 전처리 2016. 12. 3. 23:31

데이터 분석을 하다 보면 여기 저기 흩어져 있는 데이터를 특정한 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    B 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 에 대해서는 다음번 포스팅에서 소개하도록 하겠습니다.

728x90

저작자표시 비영리 변경금지

'Python 분석과 프로그래밍 > Python 데이터 전처리' 카테고리의 다른 글

[Python pandas] DataFrame 결측값 여부 확인, 결측값 개수 : isnull(), notnull(), df.isnull().sum(), df.notnull().sum(), df.isnull().sum(1), df.notnull().sum(1) (0)	2016.12.07
[Python pandas] DataFrame을 index 기준으로 합치기 (merge, join on index) (3)	2016.12.06
[Python pandas] DataFrame과 Series 합치기 : pd.concat(), append() (3)	2016.11.30
[Python pandas] 여러개의 동일한 형태 DataFrame 합치기 : pd.concat() (2)	2016.11.28
[Python pandas] DataFrame의 index 재설정(reindex) 와 결측값 채우기(fill in missing values) (4)	2016.11.27

Posted by Rfriend

,

[Python pandas] 여러개의 동일한 형태 DataFrame 합치기 : pd.concat()

Python 분석과 프로그래밍/Python 데이터 전처리 2016. 11. 28. 23:47

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

정규화해서 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를 그대로 이용하려면 입력 (deprecated, 더이상 지원하지 않음)~~

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 : reindex()

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

In [32]: df_14_axis1_reindex

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

* (참고) 최신버전의 pandas를 사용하면서 join_axes 매개변수를 사용한다면 아래와 같은 TypeError: concat() got an unexpected keyword argument 'join_axes' 에러 메시지가 뜰 것입니다. 본 블로그를 2016년도에 썼다보니 그동안 pandas 매개변수 업데이터된 내용을 블로그 포스팅에 미처 반영 못한 부분이 있었습니다. (본문 바로잡을 수 있도록 댓글 남겨주신 김명찬님 감사합니다.)

join_axes 매개변수는 사용이 중단되었네요.(join_axes is deprecated.) 대신에 위의 In [32]의 예에서처럼 reindex() 를 사용해서 기존의 index를 재사용할 수 있습니다.

pd.concat([df_1, df_4], join_szes=[df_1.index], axis=1)

------------------------------------------------------------

Type Error Traceback (most recent call last)

<ipython-input-20-748c1e0a3504> in <module>

----> 1 df_14_join_axes_axis1 = pd.concat([df_1, df_4], join_axes=[df_1.index], axis=1)

TypeError: concat() got an unexpected keyword argument 'join_axes'

(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.loc['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.loc['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']

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

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

728x90

저작자표시 비영리 변경금지

'Python 분석과 프로그래밍 > Python 데이터 전처리' 카테고리의 다른 글

[Python pandas] Database처럼 DataFrame Join/Merge 하기 : pd.merge() (0)	2016.12.03
[Python pandas] DataFrame과 Series 합치기 : pd.concat(), append() (3)	2016.11.30
[Python pandas] DataFrame의 index 재설정(reindex) 와 결측값 채우기(fill in missing values) (4)	2016.11.27
[Python pandas] DataFrame의 행 또는 열 데이터 선택해서 가져오기 (DataFrame objects indexing and selection) (2)	2016.11.27
[Python pandas] pd.DataFrame 만들고 Attributes 조회하기 (0)	2016.11.26