Pandas ~ : )

예시 코드:

import numpy as np
import pandas as pd

# 리스트로부터 Series 생성
s_list = pd.Series([10, 20, 30, 40, 50])
print("Series from list:\n", s_list)

# NumPy 배열로부터 Series 생성, 인덱스 지정
s_numpy = pd.Series(np.array([1.5, 2.3, 3.1, 4.7]), index=['a', 'b', 'c', 'd'])
print("\nSeries from NumPy array with custom index:\n", s_numpy)

# 딕셔너리로부터 Series 생성 (딕셔너리 키가 인덱스가 됨)
s_dict_data = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
s_dict = pd.Series(s_dict_data)
print("\nSeries from dictionary:\n", s_dict)

# Series에 이름(name) 부여
s_list.name = 'SampleNumbers'
s_list.index.name = 'ID'
print("\nSeries with name and index name:\n", s_list)

예상 결과:

Series from list:
0    10
1    20
2    30
3    40
4    50
dtype: int64

Series from NumPy array with custom index:
a    1.5
b    2.3
c    3.1
d    4.7
dtype: float64

Series from dictionary:
Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64

Series with name and index name:
ID
0    10
1    20
2    30
3    40
4    50
Name: SampleNumbers, dtype: int64

예시 코드:

import pandas as pd
s = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'], name='MyData')
print("Original Series:\n", s)
print("\ns.index:", s.index)
print("s.values:", s.values) # NumPy 배열 반환
print("s.dtype:", s.dtype)
print("s.name:", s.name)
print("s.size:", s.size)

# 인덱싱
print("\ns['c']:", s['c']) # 라벨 기반 인덱싱
print("s[2]:", s[2])   # 위치 기반 인덱싱 (라벨이 정수가 아닐 때 명확)

# 슬라이싱
print("\ns['b':'d'] (라벨 슬라이싱, 끝점 포함):\n", s['b':'d'])
print("s[1:4] (위치 슬라이싱, 끝점 미포함):\n", s[1:4])

# 불리언 인덱싱
print("\ns[s > 25]:\n", s[s > 25])

예상 결과:

Original Series:
a    10
b    20
c    30
d    40
e    50
Name: MyData, dtype: int64

s.index: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
s.values: [10 20 30 40 50]
s.dtype: int64
s.name: MyData
s.size: 5

s['c']: 30
s[2]: 30

s['b':'d'] (라벨 슬라이싱, 끝점 포함):
b    20
c    30
d    40
Name: MyData, dtype: int64
s[1:4] (위치 슬라이싱, 끝점 미포함):
b    20
c    30
d    40
Name: MyData, dtype: int64

s[s > 25]:
c    30
d    40
e    50
Name: MyData, dtype: int64

예시 코드:

import numpy as np
import pandas as pd

# 딕셔너리로부터 DataFrame 생성
data_dict = {'이름': ['Alice', 'Bob', 'Charlie', 'David'],
             '나이': [25, 30, 22, 35],
             '도시': ['서울', '부산', '서울', '인천']}
df_dict = pd.DataFrame(data_dict)
print("DataFrame from dictionary:\n", df_dict)

# 인덱스 지정
df_dict_idx = pd.DataFrame(data_dict, index=['id1', 'id2', 'id3', 'id4'])
print("\nDataFrame with custom index:\n", df_dict_idx)

# NumPy 2차원 배열로부터 DataFrame 생성, 컬럼명과 인덱스 지정
data_np = np.array([[1,2,3],[4,5,6],[7,8,9]])
df_np = pd.DataFrame(data_np, columns=['A', 'B', 'C'], index=['x', 'y', 'z'])
print("\nDataFrame from NumPy array:\n", df_np)

예상 결과:

DataFrame from dictionary:
      이름  나이  도시
0  Alice  25  서울
1    Bob  30  부산
2 Charlie  22  서울
3   David  35  인천

DataFrame with custom index:
       이름  나이  도시
id1  Alice  25  서울
id2    Bob  30  부산
id3 Charlie  22  서울
id4   David  35  인천

DataFrame from NumPy array:
   A  B  C
x  1  2  3
y  4  5  6
z  7  8  9

예시 코드:

import pandas as pd
data = {'col1': [1, 2, 3.5], 'col2': ['a', 'b', 'c'], 'col3': [True, False, True]}
df = pd.DataFrame(data)
print("DataFrame:\n", df)

print("\ndf.index:", df.index)
print("df.columns:", df.columns)
print("df.values (NumPy array):\n", df.values)
print("df.dtypes:\n", df.dtypes) # 각 열의 데이터 타입
print("df.shape:", df.shape) # (행 수, 열 수)
print("df.ndim:", df.ndim) # 차원 수 (DataFrame은 항상 2)
print("df.size:", df.size) # 전체 요소 수

print("\ndf.head(2) (처음 2개 행):\n", df.head(2))
print("\ndf.tail(1) (마지막 1개 행):\n", df.tail(1))
print("\ndf.info() (요약 정보):")
df.info()

예상 결과:

DataFrame:
   col1 col2   col3
0   1.0    a   True
1   2.0    b  False
2   3.5    c   True

df.index: RangeIndex(start=0, stop=3, step=1)
df.columns: Index(['col1', 'col2', 'col3'], dtype='object')
df.values (NumPy array):
 [[1.0 'a' True]
  [2.0 'b' False]
  [3.5 'c' True]]
df.dtypes:
col1    float64
col2     object
col3       bool
dtype: object
df.shape: (3, 3)
df.ndim: 2
df.size: 9

df.head(2) (처음 2개 행):
   col1 col2   col3
0   1.0    a   True
1   2.0    b  False

df.tail(1) (마지막 1개 행):
   col1 col2  col3
2   3.5    c  True

df.info() (요약 정보):
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   col1    3 non-null      float64
 1   col2    3 non-null      object 
 2   col3    3 non-null      bool   
dtypes: bool(1), float64(1), object(1)
memory usage: 200.0+ bytes

예시 코드:

import pandas as pd
import numpy as np

# 예제 DataFrame 생성
data = {'ID': [1, 2, 3, 4],
        'Name': ['Product A', 'Product B', 'Product C', 'Product D'],
        'Price': [1000, 1500, 800, 1200],
        'Stock': [10, np.nan, 5, 8]} # 결측치 포함
df_sample = pd.DataFrame(data)

# CSV 파일로 저장 (인덱스 제외)
csv_filename = 'sample_products.csv'
df_sample.to_csv(csv_filename, index=False, encoding='utf-8-sig') # Excel에서 한글 깨짐 방지
print(f"DataFrame saved to {csv_filename}")

# CSV 파일 읽기
df_loaded = pd.read_csv(csv_filename)
print("\nLoaded DataFrame from CSV:\n", df_loaded)

# 주요 파라미터 예시
# df_custom = pd.read_csv('other_file.csv', sep=';', header=None, names=['colA', 'colB'], index_col='colA', na_values=['?','MISSING'])
# print("\nCustom loaded DataFrame (예시):\n", df_custom) # 실제 파일 필요

예상 결과 (sample_products.csv 파일 생성 및 로드):

DataFrame saved to sample_products.csv

Loaded DataFrame from CSV:
   ID       Name   Price  Stock
0   1  Product A  1000.0   10.0
1   2  Product B  1500.0    NaN
2   3  Product C   800.0    5.0
3   4  Product D  1200.0    8.0

예시 코드:

import pandas as pd

# 예제 DataFrame (위 CSV 예제 df_sample 재사용 가정)
data_excel = {'ID': [1, 2, 3, 4],
              'Name': ['Product A', 'Product B', 'Product C', 'Product D'],
              'Price': [1000, 1500, 800, 1200],
              'Stock': [10, None, 5, 8]}
df_to_excel = pd.DataFrame(data_excel)

excel_filename = 'sample_products.xlsx'
# Excel 파일로 저장 (인덱스 제외, 특정 시트 이름으로)
df_to_excel.to_excel(excel_filename, sheet_name='Products', index=False)
print(f"DataFrame saved to {excel_filename} (sheet 'Products')")

# Excel 파일 읽기 (특정 시트)
df_loaded_excel = pd.read_excel(excel_filename, sheet_name='Products')
# df_loaded_excel_idx = pd.read_excel(excel_filename, index_col=0) # 첫 번째 열을 인덱스로

print("\nLoaded DataFrame from Excel:\n", df_loaded_excel)

# 여러 시트를 가진 Excel 파일 작업 예시 (주석 처리)
# with pd.ExcelWriter('multiple_sheets.xlsx') as writer:
#     df_sample.to_excel(writer, sheet_name='Sheet1', index=False)
#     df_loaded.to_excel(writer, sheet_name='Sheet2', index=False)
# all_sheets_dict = pd.read_excel('multiple_sheets.xlsx', sheet_name=None) # 모든 시트를 딕셔너리로
# print("\nAll sheets from 'multiple_sheets.xlsx':", list(all_sheets_dict.keys()))

예상 결과 (sample_products.xlsx 파일 생성 및 로드):

DataFrame saved to sample_products.xlsx (sheet 'Products')

Loaded DataFrame from Excel:
   ID       Name   Price  Stock
0   1  Product A  1000.0   10.0
1   2  Product B  1500.0    NaN
2   3  Product C   800.0    5.0
3   4  Product D  1200.0    8.0

예시 코드:

import pandas as pd
import numpy as np

data = {'이름': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
        '나이': [25, 30, 22, 35, 28],
        '점수': [85, 90, 78, 92, 88],
        '도시': ['서울', '부산', '서울', '인천', '광주']}
df = pd.DataFrame(data)
print("원본 DataFrame:\n", df)

# '이름' 열 선택 (Series 반환)
names_series = df['이름']
print("\n'이름' 열 선택 (Series):\n", names_series)
print("Type:", type(names_series))

# '나이' 열 선택 (dot notation)
ages_series = df.나이 # 컬럼명이 '나이'이므로 가능
print("\n'나이' 열 선택 (dot notation, Series):\n", ages_series)

예상 결과:

원본 DataFrame:
      이름  나이  점수  도시
0  Alice  25  85  서울
1    Bob  30  90  부산
2 Charlie  22  78  서울
3   David  35  92  인천
4     Eve  28  88  광주

'이름' 열 선택 (Series):
0    Alice
1      Bob
2    Charlie
3      David
4      Eve
Name: 이름, dtype: object
Type: <class 'pandas.core.series.Series'>

'나이' 열 선택 (dot notation, Series):
0    25
1    30
2    22
3    35
4    28
Name: 나이, dtype: int64

예시 코드:

# '이름'과 '점수' 열 선택 (DataFrame 반환)
name_score_df = df[['이름', '점수']]
print("\n'이름', '점수' 열 선택 (DataFrame):\n", name_score_df)
print("Type:", type(name_score_df))

예상 결과:

'이름', '점수' 열 선택 (DataFrame):
      이름  점수
0  Alice  85
1    Bob  90
2 Charlie  78
3   David  92
4     Eve  88
Type: <class 'pandas.core.frame.DataFrame'>

예시 코드:

# 1번 인덱스부터 3번 인덱스까지 행 선택 (3번 인덱스는 미포함)
rows_sliced = df[1:4]
print("\n행 슬라이싱 (1부터 4 이전까지):\n", rows_sliced)

예상 결과:

행 슬라이싱 (1부터 4 이전까지):
      이름  나이  점수  도시
1    Bob  30  90  부산
2 Charlie  22  78  서울
3   David  35  92  인천

예시 코드:

# 예제 DataFrame 인덱스 변경
df_indexed = df.copy()
df_indexed.index = ['p1', 'p2', 'p3', 'p4', 'p5']
print("인덱스가 변경된 DataFrame:\n", df_indexed)

# 단일 행 선택 (라벨 'p2')
row_p2 = df_indexed.loc['p2']
print("\nloc['p2'] (Series):\n", row_p2)

# 다중 행 선택 (라벨 리스트 ['p1', 'p4'])
rows_p1_p4 = df_indexed.loc[['p1', 'p4']]
print("\nloc[['p1', 'p4']] (DataFrame):\n", rows_p1_p4)

# 다중 행 선택 (라벨 슬라이스 'p2':'p4') - p4 포함
rows_slice_p2_p4 = df_indexed.loc['p2':'p4']
print("\nloc['p2':'p4'] (DataFrame, p4 포함):\n", rows_slice_p2_p4)

# 특정 행의 특정 열 선택 ('p3' 행의 '이름', '점수' 열)
p3_name_score = df_indexed.loc['p3', ['이름', '점수']]
print("\nloc['p3', ['이름', '점수']] (Series):\n", p3_name_score)

# 모든 행에 대해 특정 열들 선택
all_rows_name_city = df_indexed.loc[:, ['이름', '도시']] # ':'는 모든 행/열을 의미
print("\nloc[:, ['이름', '도시']] (DataFrame):\n", all_rows_name_city)

예상 결과:

인덱스가 변경된 DataFrame:
      이름  나이  점수  도시
p1  Alice  25  85  서울
p2    Bob  30  90  부산
p3 Charlie  22  78  서울
p4   David  35  92  인천
p5     Eve  28  88  광주

loc['p2'] (Series):
이름     Bob
나이      30
점수      90
도시      부산
Name: p2, dtype: object

loc[['p1', 'p4']] (DataFrame):
      이름  나이  점수  도시
p1  Alice  25  85  서울
p4   David  35  92  인천

loc['p2':'p4'] (DataFrame, p4 포함):
      이름  나이  점수  도시
p2    Bob  30  90  부산
p3 Charlie  22  78  서울
p4   David  35  92  인천

loc['p3', ['이름', '점수']] (Series):
이름    Charlie
점수         78
Name: p3, dtype: object

loc[:, ['이름', '도시']] (DataFrame):
       이름  도시
p1  Alice  서울
p2    Bob  부산
p3 Charlie  서울
p4   David  인천
p5     Eve  광주

예시 코드: (원본 df 사용)

print("원본 DataFrame (기본 정수 인덱스):\n", df)

# 단일 행 선택 (0번 위치)
row_0 = df.iloc[0]
print("\niloc[0] (Series):\n", row_0)

# 다중 행 선택 (1번, 3번 위치)
rows_1_3 = df.iloc[[1, 3]]
print("\niloc[[1, 3]] (DataFrame):\n", rows_1_3)

# 다중 행 선택 (0번부터 2번 위치까지 슬라이스 - 2번 미포함)
rows_slice_0_2 = df.iloc[0:2]
print("\niloc[0:2] (DataFrame, 2번 미포함):\n", rows_slice_0_2)

# 특정 위치의 행과 열 선택 (1번 행의 0번, 2번 열)
val_1_02 = df.iloc[1, [0, 2]]
print("\niloc[1, [0, 2]] (Series):\n", val_1_02)

# 마지막 행 선택
last_row = df.iloc[-1]
print("\niloc[-1] (마지막 행, Series):\n", last_row)

# 0번, 1번 행과 0번, 1번 열 선택
subset_01_01 = df.iloc[0:2, 0:2]
print("\niloc[0:2, 0:2] (DataFrame):\n", subset_01_01)

예상 결과:

원본 DataFrame (기본 정수 인덱스):
      이름  나이  점수  도시
0  Alice  25  85  서울
1    Bob  30  90  부산
2 Charlie  22  78  서울
3   David  35  92  인천
4     Eve  28  88  광주

iloc[0] (Series):
이름    Alice
나이       25
점수       85
도시       서울
Name: 0, dtype: object

iloc[[1, 3]] (DataFrame):
     이름  나이  점수  도시
1   Bob  30  90  부산
3  David  35  92  인천

iloc[0:2] (DataFrame, 2번 미포함):
     이름  나이  점수  도시
0  Alice  25  85  서울
1    Bob  30  90  부산

iloc[1, [0, 2]] (Series):
이름    Bob
점수     90
Name: 1, dtype: object

iloc[-1] (마지막 행, Series):
이름     Eve
나이      28
점수      88
도시      광주
Name: 4, dtype: object

iloc[0:2, 0:2] (DataFrame):
      이름  나이
0  Alice  25
1    Bob  30

예시 코드:

# '나이'가 30 이상인 행 선택
age_condition = df['나이'] >= 30
print("\n'나이' >= 30 조건 (Boolean Series):\n", age_condition)
df_age_over_30 = df[age_condition] # 또는 df.loc[age_condition]
print("\n'나이'가 30 이상인 학생들:\n", df_age_over_30)

# '도시'가 '서울'인 행 선택
city_seoul = df['도시'] == '서울'
df_seoul = df.loc[city_seoul]
print("\n'도시'가 '서울'인 학생들:\n", df_seoul)

예상 결과:

'나이' >= 30 조건 (Boolean Series):
0    False
1     True
2    False
3     True
4    False
Name: 나이, dtype: bool

'나이'가 30 이상인 학생들:
     이름  나이  점수  도시
1   Bob  30  90  부산
3  David  35  92  인천

'도시'가 '서울'인 학생들:
      이름  나이  점수  도시
0  Alice  25  85  서울
2 Charlie  22  78  서울

예시 코드:

# '나이'가 25 이상이고 '점수'가 90 이상인 행 선택
multi_condition_and = (df['나이'] >= 25) & (df['점수'] >= 90)
df_multi_and = df[multi_condition_and]
print("\n'나이' >= 25 AND '점수' >= 90 인 학생들:\n", df_multi_and)

# '도시'가 '서울'이거나 '점수'가 85 미만인 행 선택, 특정 열('이름', '도시', '점수')만 보기
multi_condition_or = (df['도시'] == '서울') | (df['점수'] < 85)
df_multi_or_selected_cols = df.loc[multi_condition_or, ['이름', '도시', '점수']]
print("\n'도시' == '서울' OR '점수' < 85 인 학생들의 '이름', '도시', '점수':\n", df_multi_or_selected_cols)

# '도시'가 '부산'이 아닌 학생들
not_busan = ~(df['도시'] == '부산')
df_not_busan = df[not_busan]
print("\n'도시'가 '부산'이 아닌 학생들:\n", df_not_busan)

예상 결과:

'나이' >= 25 AND '점수' >= 90 인 학생들:
     이름  나이  점수  도시
1   Bob  30  90  부산
3  David  35  92  인천

'도시' == '서울' OR '점수' < 85 인 학생들의 '이름', '도시', '점수':
      이름  도시  점수
0  Alice  서울  85
2 Charlie  서울  78

'도시'가 '부산'이 아닌 학생들:
      이름  나이  점수  도시
0  Alice  25  85  서울
2 Charlie  22  78  서울
3   David  35  92  인천
4     Eve  28  88  광주

예시 코드:

# '도시'가 '서울' 또는 '인천'인 경우
cities_to_filter = ['서울', '인천']
isin_condition = df['도시'].isin(cities_to_filter)
df_isin = df[isin_condition]
print("\n'도시'가 '서울' 또는 '인천'인 학생들:\n", df_isin)

예상 결과:

'도시'가 '서울' 또는 '인천'인 학생들:
      이름  나이  점수  도시
0  Alice  25  85  서울
2 Charlie  22  78  서울
3   David  35  92  인천

예시 코드:

# '이름'에 'li'가 포함된 학생 (대소문자 구분)
name_contains_li = df['이름'].str.contains('li')
df_name_li = df[name_contains_li]
print("\n'이름'에 'li'가 포함된 학생:\n", df_name_li)

# '도시'가 '서'로 시작하는 학생
city_starts_with_seo = df['도시'].str.startswith('서')
df_city_seo = df[city_starts_with_seo]
print("\n'도시'가 '서'로 시작하는 학생:\n", df_city_seo)

예상 결과:

'이름'에 'li'가 포함된 학생:
      이름  나이  점수  도시
0  Alice  25  85  서울
2 Charlie  22  78  서울

'도시'가 '서'로 시작하는 학생:
      이름  나이  점수  도시
0  Alice  25  85  서울
2 Charlie  22  78  서울

예시 코드:

df_copy = df.copy()
print("값 변경 전 DataFrame 복사본:\n", df_copy)

# 'Bob'의 '점수'를 95점으로 변경 (loc 사용)
df_copy.loc[df_copy['이름'] == 'Bob', '점수'] = 95
print("\n'Bob'의 점수 변경 후:\n", df_copy)

# '나이'가 30 미만인 학생들의 '도시'를 '미정'으로 변경
df_copy.loc[df_copy['나이'] < 30, '도시'] = '미정'
print("\n'나이' < 30 학생들 도시 변경 후:\n", df_copy)

# 0번 행의 모든 값을 특정 값으로 변경 (iloc 사용)
df_copy.iloc[0] = ['NewName', 20, 70, 'NewCity']
print("\n0번 행 전체 변경 후:\n", df_copy)

예상 결과:

값 변경 전 DataFrame 복사본:
      이름  나이  점수  도시
0  Alice  25  85  서울
1    Bob  30  90  부산
2 Charlie  22  78  서울
3   David  35  92  인천
4     Eve  28  88  광주

'Bob'의 점수 변경 후:
      이름  나이  점수  도시
0  Alice  25  85  서울
1    Bob  30  95  부산
2 Charlie  22  78  서울
3   David  35  92  인천
4     Eve  28  88  광주

'나이' < 30 학생들 도시 변경 후:
      이름  나이  점수  도시
0  Alice  25  85  미정
1    Bob  30  95  부산
2 Charlie  22  78  미정
3   David  35  92  인천
4     Eve  28  88  미정

0번 행 전체 변경 후:
        이름  나이  점수     도시
0  NewName  20  70  NewCity
1      Bob  30  95       부산
2  Charlie  22  78       미정
3    David  35  92       인천
4      Eve  28  88       미정

예시 코드:

import pandas as pd
import numpy as np

data = {'이름': ['Alice', 'Bob', 'Charlie', 'David'],
        '수학': [90, 75, 88, 92],
        '영어': [85, 80, 90, 78]}
df = pd.DataFrame(data)
print("원본 DataFrame:\n", df)

# 1. 기존 열 연산으로 '총점' 열 추가
df['총점'] = df['수학'] + df['영어']
print("\n'총점' 열 추가 후:\n", df)

# 2. 특정 값으로 '과목수' 열 추가
df['과목수'] = 2
print("\n'과목수' 열 추가 후:\n", df)

# 3. assign()으로 '평균' 열 추가 (원본 df는 변경되지 않음)
df_assigned = df.assign(평균 = df['총점'] / df['과목수'])
print("\nassign()으로 '평균' 열 추가된 DataFrame:\n", df_assigned)
print("\n원본 DataFrame (assign 후에도 변경 없음):\n", df)

예상 결과:

원본 DataFrame:
        이름  수학  영어
0  Alice  90  85
1    Bob  75  80
2 Charlie  88  90
3   David  92  78

'총점' 열 추가 후:
        이름  수학  영어   총점
0  Alice  90  85  175
1    Bob  75  80  155
2 Charlie  88  90  178
3   David  92  78  170

'과목수' 열 추가 후:
        이름  수학  영어   총점  과목수
0  Alice  90  85  175    2
1    Bob  75  80  155    2
2 Charlie  88  90  178    2
3   David  92  78  170    2

assign()으로 '평균' 열 추가된 DataFrame:
        이름  수학  영어   총점  과목수    평균
0  Alice  90  85  175    2  87.5
1    Bob  75  80  155    2  77.5
2 Charlie  88  90  178    2  89.0
3   David  92  78  170    2  85.0

원본 DataFrame (assign 후에도 변경 없음):
        이름  수학  영어   총점  과목수
0  Alice  90  85  175    2
1    Bob  75  80  155    2
2 Charlie  88  90  178    2
3   David  92  78  170    2

예시 코드:

df_copy = df_assigned.copy() # df_assigned 사용
print("열 삭제 전 DataFrame:\n", df_copy)

# 1. del 키워드로 '과목수' 열 삭제
del df_copy['과목수']
print("\n'과목수' 열 삭제 후 (del):\n", df_copy)

# 2. drop 메서드로 '총점' 열 삭제 (복사본 반환)
df_dropped_total = df_copy.drop('총점', axis=1) # 또는 columns='총점'
print("\n'총점' 열 삭제 후 (drop, 복사본):\n", df_dropped_total)

# 2. drop 메서드로 여러 열 삭제 및 원본 변경
df_copy.drop(columns=['수학', '영어'], inplace=True)
print("\n'수학', '영어' 열 삭제 후 (drop, 원본변경):\n", df_copy)

예상 결과:

열 삭제 전 DataFrame:
        이름  수학  영어   총점  과목수    평균
0  Alice  90  85  175    2  87.5
1    Bob  75  80  155    2  77.5
2 Charlie  88  90  178    2  89.0
3   David  92  78  170    2  85.0

'과목수' 열 삭제 후 (del):
        이름  수학  영어   총점    평균
0  Alice  90  85  175  87.5
1    Bob  75  80  155  77.5
2 Charlie  88  90  178  89.0
3   David  92  78  170  85.0

'총점' 열 삭제 후 (drop, 복사본):
        이름  수학  영어    평균
0  Alice  90  85  87.5
1    Bob  75  80  77.5
2 Charlie  88  90  89.0
3   David  92  78  85.0

'수학', '영어' 열 삭제 후 (drop, 원본변경):
        이름   총점    평균
0  Alice  175  87.5
1    Bob  155  77.5
2 Charlie  178  89.0
3   David  170  85.0

예시 코드:

data_nan = {'A': [1, 2, np.nan, 4, 5],
                'B': [np.nan, 7, 8, np.nan, 10],
                'C': [11, np.nan, np.nan, 14, 15]}
df_nan = pd.DataFrame(data_nan)
print("결측치가 포함된 DataFrame:\n", df_nan)

print("\n결측치 여부 (isnull()):\n", df_nan.isnull())
print("\n열별 결측치 개수:\n", df_nan.isnull().sum())
print("\n총 결측치 개수:", df_nan.isnull().sum().sum())

예상 결과:

결측치가 포함된 DataFrame:
     A     B     C
0  1.0   NaN  11.0
1  2.0   7.0   NaN
2  NaN   8.0   NaN
3  4.0   NaN  14.0
4  5.0  10.0  15.0

결측치 여부 (isnull()):
       A      B      C
0  False   True  False
1  False  False   True
2   True  False   True
3  False   True  False
4  False  False  False

열별 결측치 개수:
A    1
B    2
C    2
dtype: int64

총 결측치 개수: 5

예시 코드:

# NaN이 하나라도 있는 행 제거
df_dropna_row_any = df_nan.dropna() # how='any', axis=0 기본값
print("\nNaN이 하나라도 있는 행 제거 후:\n", df_dropna_row_any)

# 모든 값이 NaN인 행 제거 (이 예제에서는 해당 없음)
df_dropna_row_all = df_nan.dropna(how='all')
print("\n모든 값이 NaN인 행 제거 후:\n", df_dropna_row_all)

# NaN이 하나라도 있는 열 제거
df_dropna_col_any = df_nan.dropna(axis=1) # how='any' 기본값
print("\nNaN이 하나라도 있는 열 제거 후:\n", df_dropna_col_any)

# 'A' 열에 NaN이 있는 행만 제거
df_dropna_subset_A = df_nan.dropna(subset=['A'])
print("\n'A'열에 NaN이 있는 행 제거 후:\n", df_dropna_subset_A)

# NaN 아닌 값이 최소 2개 이상인 행만 유지
df_dropna_thresh2 = df_nan.dropna(thresh=2)
print("\nNaN 아닌 값이 최소 2개 이상인 행 유지:\n", df_dropna_thresh2)

예상 결과:

NaN이 하나라도 있는 행 제거 후:
     A     B     C
4  5.0  10.0  15.0

모든 값이 NaN인 행 제거 후:
     A     B     C
0  1.0   NaN  11.0
1  2.0   7.0   NaN
2  NaN   8.0   NaN
3  4.0   NaN  14.0
4  5.0  10.0  15.0

NaN이 하나라도 있는 열 제거 후:
Empty DataFrame
Columns: []
Index: [0, 1, 2, 3, 4]

'A'열에 NaN이 있는 행 제거 후:
     A     B     C
0  1.0   NaN  11.0
1  2.0   7.0   NaN
3  4.0   NaN  14.0
4  5.0  10.0  15.0

NaN 아닌 값이 최소 2개 이상인 행 유지:
     A     B     C
0  1.0   NaN  11.0
1  2.0   7.0   NaN
3  4.0   NaN  14.0
4  5.0  10.0  15.0

예시 코드:

# 모든 NaN을 0으로 채우기
df_fillna_0 = df_nan.fillna(0)
print("\n모든 NaN을 0으로 채운 후:\n", df_fillna_0)

# 'A'열의 NaN은 'A'열의 평균으로, 'B'열의 NaN은 'B'열의 중앙값으로 채우기
df_filled_stats = df_nan.copy()
df_filled_stats['A'].fillna(df_filled_stats['A'].mean(), inplace=True)
df_filled_stats['B'].fillna(df_filled_stats['B'].median(), inplace=True)
print("\n'A'는 평균, 'B'는 중앙값으로 채운 후:\n", df_filled_stats)

# ffill: 앞의 값으로 채우기
df_fillna_ffill = df_nan.fillna(method='ffill')
print("\nffill로 채운 후:\n", df_fillna_ffill)

# bfill: 뒤의 값으로 채우기, limit=1 (한 번만 채움)
df_fillna_bfill_limit = df_nan.fillna(method='bfill', limit=1)
print("\nbfill (limit=1)로 채운 후:\n", df_fillna_bfill_limit)

예상 결과:

모든 NaN을 0으로 채운 후:
     A     B     C
0  1.0   0.0  11.0
1  2.0   7.0   0.0
2  0.0   8.0   0.0
3  4.0   0.0  14.0
4  5.0  10.0  15.0

'A'는 평균, 'B'는 중앙값으로 채운 후:
     A     B     C
0  1.00   8.5  11.0
1  2.00   7.0   NaN
2  3.00   8.0   NaN  # A의 평균 (1+2+4+5)/4 = 3.0
3  4.00   8.5  14.0  # B의 중앙값 (7+8+10)/2 (정렬 후) or 8.5 (7,8,10 -> 8) - 여기선 8.5가 나옴. (7,8,10) => median 8. Pandas median은 (7+8+10) 사이 값 중 8.5로 계산. np.nanmedian은 8.
4  5.00  10.0  15.0   # 정확한 중앙값 계산은 (7,8,10)에서 8. Pandas 1.x버전에서는 8.5가 될 수 있음. (np.nanmedian을 사용하면 8)
                       # 여기서는 fillna가 내부적으로 처리하므로 코드가 실행되는 환경에 따라 다를 수 있음.
                       # 예시에서는 Pandas가 (7, 8, 10) -> 8.0 으로 처리한다고 가정하고 작성 (일반적인 중앙값)

ffill로 채운 후:
     A     B     C
0  1.0   NaN  11.0
1  2.0   7.0  11.0
2  2.0   8.0  11.0
3  4.0   8.0  14.0
4  5.0  10.0  15.0

bfill (limit=1)로 채운 후:
     A     B     C
0  1.0   7.0  11.0
1  2.0   7.0   NaN  # C열 1번 인덱스는 뒤에 채울 값이 없음 (limit에 의해 한칸만 진행)
2  4.0   8.0  14.0
3  4.0  10.0  14.0
4  5.0  10.0  15.0

예시 코드:

data_dup = {'col1': ['A', 'B', 'A', 'C', 'B', 'A'],
                'col2': [1, 2, 1, 3, 2, 1],
                'col3': [10, 20, 10, 30, 20, 10]}
df_dup = pd.DataFrame(data_dup)
print("중복이 포함된 DataFrame:\n", df_dup)

# 전체 행 기준 중복 확인 (기본 keep='first')
print("\n중복 여부 (keep='first'):\n", df_dup.duplicated())

# 'col1' 기준 중복 확인
print("\n'col1' 기준 중복 여부:\n", df_dup.duplicated(subset=['col1']))

# 모든 중복 행을 True로 표시
print("\n모든 중복 행을 True로 (keep=False):\n", df_dup.duplicated(keep=False))

예상 결과:

중복이 포함된 DataFrame:
  col1  col2  col3
0    A     1    10
1    B     2    20
2    A     1    10  # (0번 행과 중복)
3    C     3    30
4    B     2    20  # (1번 행과 중복)
5    A     1    10  # (0, 2번 행과 중복)

중복 여부 (keep='first'):
0    False
1    False
2     True
3    False
4     True
5     True
dtype: bool

'col1' 기준 중복 여부:
0    False
1    False
2     True
3    False
4     True
5     True
dtype: bool

모든 중복 행을 True로 (keep=False):
0     True
1     True
2     True
3    False
4     True
5     True
dtype: bool

예시 코드:

# 중복 행 제거 (기본 keep='first')
df_no_dup_first = df_dup.drop_duplicates()
print("\n중복 제거 후 (keep='first'):\n", df_no_dup_first)

# 중복 행 제거 (keep='last', 마지막 값 유지)
df_no_dup_last = df_dup.drop_duplicates(keep='last')
print("\n중복 제거 후 (keep='last'):\n", df_no_dup_last)

# 'col1', 'col2' 기준 중복 제거
df_no_dup_subset = df_dup.drop_duplicates(subset=['col1', 'col2'], keep='first')
print("\n'col1', 'col2' 기준 중복 제거 후:\n", df_no_dup_subset)

예상 결과:

중복 제거 후 (keep='first'):
  col1  col2  col3
0    A     1    10
1    B     2    20
3    C     3    30

중복 제거 후 (keep='last'):
  col1  col2  col3
3    C     3    30
4    B     2    20
5    A     1    10

'col1', 'col2' 기준 중복 제거 후:
  col1  col2  col3
0    A     1    10
1    B     2    20
3    C     3    30

예시 코드:

df_types = pd.DataFrame({
    'ID': ['1', '2', '3', '4'],
    'Score': ['85.5', '90.2', '77.0', '92.1'],
    'Age': [25, 30, 22, 35],
    'Registered': ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-10']
})
print("초기 DataFrame:\n", df_types)
print("\n초기 데이터 타입:\n", df_types.dtypes)

예상 결과:

초기 DataFrame:
  ID Score  Age  Registered
0  1  85.5   25  2023-01-01
1  2  90.2   30  2023-01-15
2  3  77.0   22  2023-02-01
3  4  92.1   35  2023-02-10

초기 데이터 타입:
ID            object
Score         object
Age            int64
Registered    object
dtype: object

예시 코드:

df_converted = df_types.copy()

# 'ID'를 정수형으로 변환
df_converted['ID'] = df_converted['ID'].astype(int)

# 'Score'를 부동소수점형으로 변환 (pd.to_numeric 사용)
df_converted['Score'] = pd.to_numeric(df_converted['Score'])

# 'Registered'를 datetime 객체로 변환
df_converted['Registered'] = pd.to_datetime(df_converted['Registered'])

# 'Age'를 문자열로 변환
df_converted['Age'] = df_converted['Age'].astype(str)

print("\n변환 후 데이터 타입:\n", df_converted.dtypes)
print("\n변환 후 DataFrame:\n", df_converted)

예상 결과:

변환 후 데이터 타입:
ID                     int64
Score                float64
Age                   object
Registered    datetime64[ns]  # Pandas < 2.0: datetime64[ns], Pandas >= 2.0: datetime64[us] or similar
dtype: object

변환 후 DataFrame:
   ID  Score Age Registered
0   1   85.5  25 2023-01-01
1   2   90.2  30 2023-01-15
2   3   77.0  22 2023-02-01
3   4   92.1  35 2023-02-10

예시 코드:

df_func = pd.DataFrame({'A': [1, 2, 3], 'B': [10, 20, 30]})
print("함수 적용 전 DataFrame:\n", df_func)

# Series.map() 예시: 'A' 열의 각 요소에 100을 더함
df_func['A_mapped'] = df_func['A'].map(lambda x: x + 100)
print("\n'A' 열 map 적용 후:\n", df_func)

# DataFrame.applymap() 예시: 모든 요소에 제곱 함수 적용 (숫자형 열에만 의미 있음)
# applymap is deprecated in newer pandas, use map for DataFrames element-wise operations.
# df_func_squared = df_func[['A', 'B']].applymap(lambda x: x*x) # Older Pandas
df_func_squared = df_func[['A', 'B']].map(lambda x: x*x) # Pandas 2.1.0+
print("\nDataFrame 모든 요소 제곱 (map):\n", df_func_squared)

예상 결과 (Pandas 2.1.0+ 기준):

함수 적용 전 DataFrame:
   A   B
0  1  10
1  2  20
2  3  30

'A' 열 map 적용 후:
   A   B  A_mapped
0  1  10       101
1  2  20       102
2  3  30       103

DataFrame 모든 요소 제곱 (map):
   A    B
0  1  100
1  4  400
2  9  900

예시 코드:

df_apply_data = pd.DataFrame(np.random.randn(3, 4), columns=['W', 'X', 'Y', 'Z'])
print("apply 적용 전 DataFrame:\n", df_apply_data)

# 열(axis=0) 단위로 최대값 - 최소값 계산
col_range = df_apply_data.apply(lambda x: x.max() - x.min(), axis=0)
print("\n열별 (최대값 - 최소값):\n", col_range)

# 행(axis=1) 단위로 합계 계산
row_sum = df_apply_data.apply(np.sum, axis=1)
print("\n행별 합계:\n", row_sum)

# 행 단위로 W와 X 열의 차이를 계산하여 새 열 'W-X' 생성
df_apply_data['W-X'] = df_apply_data.apply(lambda row: row['W'] - row['X'], axis=1)
print("\n행 단위 연산으로 새 열 추가 후:\n", df_apply_data)

예상 결과 (randn 부분은 실행 시마다 다름):

apply 적용 전 DataFrame:
          W         X         Y         Z
0  0.626386 -0.303790  0.905374 -0.022715
1 -0.470543 -0.828799  0.346416  0.016854
2 -0.099666  0.549702 -0.486393 -1.107797

열별 (최대값 - 최소값):
W    1.096929
X    1.378500
Y    1.391767
Z    1.085082
dtype: float64

행별 합계:
0    1.205255
1   -0.936072
2   -1.144153
dtype: float64

행 단위 연산으로 새 열 추가 후:
          W         X         Y         Z       W-X
0  0.626386 -0.303790  0.905374 -0.022715  0.930176
1 -0.470543 -0.828799  0.346416  0.016854  0.358256
2 -0.099666  0.549702 -0.486393 -1.107797 -0.649368

예시 코드:

df_replace = pd.DataFrame({'Group': ['A', 'B', 'C', 'A', 'B', 'D'],
                               'Score': [10, -99, 20, 10, 30, -99]})
print("값 치환 전 DataFrame:\n", df_replace)

# 단일 값 치환: -99를 NaN으로
df_replaced_single = df_replace.replace(-99, np.nan)
print("\n-99를 NaN으로 치환 후:\n", df_replaced_single)

# 리스트를 사용한 다중 값 치환: ['A', 'B']를 'Group_AB'로
df_replaced_list = df_replace.replace(['A', 'B'], 'Group_AB')
print("\n['A', 'B']를 'Group_AB'로 치환 후:\n", df_replaced_list)

# 딕셔너리를 사용한 값 치환: {'A': 'Alpha', 'D': 'Delta', -99: 0}
df_replaced_dict = df_replace.replace({'A': 'Alpha', 'D': 'Delta', -99: 0})
print("\n딕셔너리로 여러 값 치환 후:\n", df_replaced_dict)

# 특정 열에 대해서만 치환
df_replaced_col_specific = df_replace.replace({'Score': {-99: np.nan}})
print("\n'Score' 열의 -99만 NaN으로 치환 후:\n", df_replaced_col_specific)

예상 결과:

값 치환 전 DataFrame:
  Group  Score
0     A     10
1     B    -99
2     C     20
3     A     10
4     B     30
5     D    -99

-99를 NaN으로 치환 후:
  Group  Score
0     A   10.0
1     B    NaN
2     C   20.0
3     A   10.0
4     B   30.0
5     D    NaN

['A', 'B']를 'Group_AB'로 치환 후:
      Group  Score
0  Group_AB     10
1  Group_AB    -99
2         C     20
3  Group_AB     10
4  Group_AB     30
5         D    -99

딕셔너리로 여러 값 치환 후:
    Group  Score
0   Alpha     10
1       B      0
2       C     20
3   Alpha     10
4       B     30
5   Delta      0

'Score' 열의 -99만 NaN으로 치환 후:
  Group  Score
0     A   10.0
1     B    NaN
2     C   20.0
3     A   10.0
4     B   30.0
5     D    NaN

예시 코드:

import pandas as pd
import numpy as np

data = {'col_B': [4, 7, 1, 5],
        'col_A': [10, 20, 30, 40],
        'col_C': [100, 50, np.nan, 200]}
df_sort_idx = pd.DataFrame(data, index=['d', 'a', 'c', 'b'])
print("원본 DataFrame:\n", df_sort_idx)

# 행 인덱스 기준 오름차순 정렬
df_sorted_rows_asc = df_sort_idx.sort_index() # axis=0, ascending=True 기본값
print("\n행 인덱스 오름차순 정렬:\n", df_sorted_rows_asc)

# 행 인덱스 기준 내림차순 정렬, 원본 변경
df_sort_idx_copy = df_sort_idx.copy()
df_sort_idx_copy.sort_index(ascending=False, inplace=True)
print("\n행 인덱스 내림차순 정렬 (원본 변경):\n", df_sort_idx_copy)

# 열 이름 기준 오름차순 정렬
df_sorted_cols_asc = df_sort_idx.sort_index(axis=1)
print("\n열 이름 오름차순 정렬:\n", df_sorted_cols_asc)

# 열 이름 기준 내림차순 정렬, NaN 값 맨 앞에
df_sorted_cols_desc_nafirst = df_sort_idx.sort_index(axis=1, ascending=False, na_position='first')
# (na_position은 sort_values에서 주로 사용되나, sort_index는 인덱스 자체의 NaN을 다루진 않음.
#  여기서는 열 이름에 NaN이 없으므로 na_position은 큰 의미 없음. 값 정렬 시 유용)
print("\n열 이름 내림차순 정렬:\n", df_sorted_cols_desc_nafirst)

예상 결과:

원본 DataFrame:
   col_B  col_A  col_C
d      4     10  100.0
a      7     20   50.0
c      1     30    NaN
b      5     40  200.0

행 인덱스 오름차순 정렬:
   col_B  col_A  col_C
a      7     20   50.0
b      5     40  200.0
c      1     30    NaN
d      4     10  100.0

행 인덱스 내림차순 정렬 (원본 변경):
   col_B  col_A  col_C
d      4     10  100.0
c      1     30    NaN
b      5     40  200.0
a      7     20   50.0

열 이름 오름차순 정렬:
   col_A  col_B  col_C
d     10      4  100.0
a     20      7   50.0
c     30      1    NaN
b     40      5  200.0

열 이름 내림차순 정렬:
   col_C  col_B  col_A
d  100.0      4     10
a   50.0      7     20
c    NaN      1     30
b  200.0      5     40

예시 코드:

data_val = {'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
                'Age': [25, 30, 22, 30, 28],
                'Score': [85, 90, 78, 92, 85]}
df_sort_val = pd.DataFrame(data_val)
print("원본 DataFrame:\n", df_sort_val)

# 'Score' 열 기준 내림차순 정렬
df_sorted_score_desc = df_sort_val.sort_values(by='Score', ascending=False)
print("\n'Score' 기준 내림차순 정렬:\n", df_sorted_score_desc)

# 'Age' 열 오름차순, 같으면 'Score' 열 내림차순 정렬
# NaN 값을 맨 앞에 오도록 설정
df_sorted_multi = df_sort_val.sort_values(by=['Age', 'Score'], ascending=[True, False], na_position='first')
print("\n'Age'(오름차순), 'Score'(내림차순) 기준 정렬 (NaN 맨 앞):\n", df_sorted_multi)

# Series 정렬
s_sort = pd.Series([3, 1, np.nan, 5, 2], index=['a', 'b', 'c', 'd', 'e'])
print("\n원본 Series:\n", s_sort)
print("\nSeries 값 기준 오름차순 정렬 (NaN 맨 뒤):\n", s_sort.sort_values(na_position='last'))

예상 결과:

원본 DataFrame:
      Name  Age  Score
0    Alice   25     85
1      Bob   30     90
2  Charlie   22     78
3    David   30     92
4      Eve   28     85

'Score' 기준 내림차순 정렬:
      Name  Age  Score
3    David   30     92
1      Bob   30     90
0    Alice   25     85
4      Eve   28     85
2  Charlie   22     78

'Age'(오름차순), 'Score'(내림차순) 기준 정렬 (NaN 맨 앞):
      Name  Age  Score
2  Charlie   22     78
0    Alice   25     85
4      Eve   28     85
3    David   30     92  # Age 30 중에서 Score 92가 먼저
1      Bob   30     90  # Age 30 중에서 Score 90이 다음

원본 Series:
a    3.0
b    1.0
c    NaN
d    5.0
e    2.0
dtype: float64

Series 값 기준 오름차순 정렬 (NaN 맨 뒤):
b    1.0
e    2.0
a    3.0
d    5.0
c    NaN
dtype: float64

예시 코드:

s_rank = pd.Series([10, 30, 20, 30, 50, np.nan, 20])
print("원본 Series:\n", s_rank)

# 기본 순위 (method='average', ascending=True)
print("\n기본 순위 (average):\n", s_rank.rank())

# 내림차순, method='min' (높은 점수가 높은 순위)
print("\n내림차순, method='min':\n", s_rank.rank(ascending=False, method='min'))

# 오름차순, method='dense', NaN은 가장 낮은 순위로 (top)
print("\n오름차순, method='dense', na_option='top':\n", s_rank.rank(method='dense', na_option='top'))

# 백분위수 순위
print("\n백분위수 순위 (pct=True):\n", s_rank.rank(pct=True))

# DataFrame에서 'Score' 열에 대한 순위를 'Rank_Score' 열로 추가
df_rank_example = df_sort_val.copy() # 이전 예제 df_sort_val 재사용
df_rank_example['Score_Rank_Dense_Desc'] = df_rank_example['Score'].rank(method='dense', ascending=False)
print("\nDataFrame에 점수 순위(dense, 내림차순) 추가:\n", df_rank_example)

예상 결과:

원본 Series:
0    10.0
1    30.0
2    20.0
3    30.0
4    50.0
5     NaN
6    20.0
dtype: float64

기본 순위 (average):
0    1.0  # 10
1    4.5  # 30 (30, 30 -> 4, 5 -> avg 4.5)
2    2.5  # 20 (20, 20 -> 2, 3 -> avg 2.5)
3    4.5  # 30
4    6.0  # 50
5    NaN
6    2.5  # 20
dtype: float64

내림차순, method='min':
0    5.0  # 10 (가장 낮은 점수)
1    2.0  # 30 (30, 30 중 min 순위)
2    3.0  # 20 (20, 20 중 min 순위)
3    2.0  # 30
4    1.0  # 50 (가장 높은 점수)
5    NaN
6    3.0  # 20
dtype: float64

오름차순, method='dense', na_option='top':
0    2.0  # 10
1    4.0  # 30
2    3.0  # 20
3    4.0  # 30
4    5.0  # 50
5    1.0  # NaN (가장 낮은 순위로 간주)
6    3.0  # 20
dtype: float64

백분위수 순위 (pct=True):
0    0.166667  # 1/6
1    0.750000  # 4.5/6
2    0.416667  # 2.5/6
3    0.750000  # 4.5/6
4    1.000000  # 6/6
5         NaN
6    0.416667  # 2.5/6
dtype: float64

DataFrame에 점수 순위(dense, 내림차순) 추가:
      Name  Age  Score  Score_Rank_Dense_Desc
0    Alice   25     85                    3.0 # 85점은 3등 (92, 90 다음)
1      Bob   30     90                    2.0 # 90점은 2등
2  Charlie   22     78                    4.0 # 78점은 4등
3    David   30     92                    1.0 # 92점은 1등
4      Eve   28     85                    3.0 # 85점은 3등

예시 코드:

import pandas as pd
import numpy as np

data = {'A': [1, 2, 3, 4, 5, np.nan],
        'B': [10, 20, 10, 30, 50, 40],
        'C': [100, 200, 300, np.nan, 500, 600]}
df_stats = pd.DataFrame(data)
print("원본 DataFrame:\n", df_stats)

print("\n--- 기본 통계량 ---")
print("df_stats.count():\n", df_stats.count()) # 열별 NaN 아닌 개수
print("df_stats['A'].sum():", df_stats['A'].sum()) # 'A'열 합계
print("df_stats.mean(numeric_only=True):\n", df_stats.mean(numeric_only=True)) # 전체 열 평균
print("df_stats.median(numeric_only=True, axis=0):\n", df_stats.median(numeric_only=True, axis=0)) # 열별 중앙값
print("df_stats['B'].quantile(0.75):", df_stats['B'].quantile(0.75)) # 'B'열 3사분위수
print("df_stats['B'].mode():\n", df_stats['B'].mode()) # 'B'열 최빈값
print("df_stats.std(numeric_only=True):\n", df_stats.std(numeric_only=True)) # 열별 표준편차
print("df_stats.idxmax(numeric_only=True):\n", df_stats.idxmax(numeric_only=True)) # 열별 최대값 인덱스
print("df_stats.min(axis=1, numeric_only=True):\n", df_stats.min(axis=1, numeric_only=True)) # 행별 최소값

예상 결과:

원본 DataFrame:
     A   B      C
0  1.0  10  100.0
1  2.0  20  200.0
2  3.0  10  300.0
3  4.0  30    NaN
4  5.0  50  500.0
5  NaN  40  600.0

--- 기본 통계량 ---
df_stats.count():
A    5
B    6
C    5
dtype: int64
df_stats['A'].sum(): 15.0
df_stats.mean(numeric_only=True):
A      3.000000
B     26.666667
C    340.000000
dtype: float64
df_stats.median(numeric_only=True, axis=0):
A      3.0
B     25.0
C    300.0
dtype: float64
df_stats['B'].quantile(0.75): 37.5
df_stats['B'].mode():
0    10
dtype: int64
df_stats.std(numeric_only=True):
A      1.581139
B     16.329932
C    207.364414
dtype: float64
df_stats.idxmax(numeric_only=True):
A    4
B    4
C    5
dtype: int64
df_stats.min(axis=1, numeric_only=True):
0      1.0
1      2.0
2      3.0
3      4.0
4      5.0
5     40.0  # NaN은 A열에, B열과 C열 값 중 최소는 40
dtype: float64

예시 코드:

df_desc = pd.DataFrame({
    'NumericCol': [10, 20, np.nan, 30, 20, 40, 50],
    'StringCol': ['apple', 'banana', 'apple', 'orange', 'banana', 'apple', 'grape'],
    'BoolCol': [True, False, True, True, False, True, False]
})
print("기술 통계용 DataFrame:\n", df_desc)

# 숫자형 열에 대한 describe() (기본)
print("\n숫자형 열 describe():\n", df_desc['NumericCol'].describe())

# 전체 DataFrame에 대한 describe() (숫자형 열만 기본으로 처리)
print("\n전체 DataFrame describe() (숫자형만):\n", df_desc.describe())

# 문자열(object) 열에 대한 describe()
print("\n문자열 열 describe():\n", df_desc['StringCol'].describe())

# 모든 열에 대한 describe() (include='all')
print("\n모든 열 describe() (include='all'):\n", df_desc.describe(include='all'))

# 특정 분위수 포함
print("\n특정 분위수 포함 describe() (NumericCol):\n", df_desc['NumericCol'].describe(percentiles=[.1, .5, .9]))

예상 결과:

기술 통계용 DataFrame:
   NumericCol StringCol  BoolCol
0        10.0     apple     True
1        20.0    banana    False
2         NaN     apple     True
3        30.0    orange     True
4        20.0    banana    False
5        40.0     apple     True
6        50.0     grape    False

숫자형 열 describe():
count     6.000000
mean     28.333333
std      14.719601
min      10.000000
25%      20.000000
50%      25.000000
75%      37.500000
max      50.000000
Name: NumericCol, dtype: float64

전체 DataFrame describe() (숫자형만):
       NumericCol
count    6.000000
mean    28.333333
std     14.719601
min     10.000000
25%     20.000000
50%     25.000000
75%     37.500000
max     50.000000

문자열 열 describe():
count         7
unique        4
top       apple
freq          3
Name: StringCol, dtype: object

모든 열 describe() (include='all'):
       NumericCol StringCol BoolCol
count    6.000000         7       7
unique        NaN         4       2  # BoolCol은 2개의 unique 값 (True, False)
top           NaN     apple    True
freq          NaN         3       4
mean    28.333333       NaN     NaN
std     14.719601       NaN     NaN
min     10.000000       NaN     NaN
25%     20.000000       NaN     NaN
50%     25.000000       NaN     NaN
75%     37.500000       NaN     NaN
max     50.000000       NaN     NaN

특정 분위수 포함 describe() (NumericCol):
count     6.000000
mean     28.333333
std      14.719601
min      10.000000
10%      14.000000  # (10과 20 사이의 10% 지점)
50%      25.000000
90%      46.000000  # (40과 50 사이의 90% 지점)
max      50.000000
Name: NumericCol, dtype: float64

예시 코드:

df_cum = pd.DataFrame(np.arange(1, 10).reshape(3, 3), columns=['X', 'Y', 'Z'])
df_cum.iloc[1, 1] = np.nan # 예시를 위해 NaN 추가
print("누적 계산용 DataFrame:\n", df_cum)

print("\n열 기준 누적 합계 (cumsum, axis=0):\n", df_cum.cumsum())
print("\n행 기준 누적 곱 (cumprod, axis=1):\n", df_cum.cumprod(axis=1, skipna=False)) # skipna=False로 NaN 전파
print("\n열 기준 누적 최소값 (cummin):\n", df_cum.cummin())
print("\n열 기준 누적 최대값 (cummax, skipna=True 기본):\n", df_cum.cummax(skipna=True))

예상 결과:

누적 계산용 DataFrame:
   X    Y  Z
0  1  2.0  3
1  4  NaN  6
2  7  8.0  9

열 기준 누적 합계 (cumsum, axis=0):
     X     Y     Z
0  1.0   2.0   3.0
1  5.0   NaN   9.0  # NaN 이후로는 NaN 또는 이전 값 (버전에 따라) - 여기선 skipna=True 기본값
2 12.0   8.0  18.0  # Y열은 2.0 + (skip NaN) + 8.0 = 10.0. -> 이전 버전은 NaN 이후 NaN. 현재는 skipna=True가 기본이라 건너뜀

행 기준 누적 곱 (cumprod, axis=1, skipna=False):
     X    Y      Z
0  1.0  2.0    6.0
1  4.0  NaN    NaN
2  7.0 56.0  504.0

열 기준 누적 최소값 (cummin):
   X    Y    Z
0  1  2.0  3.0
1  1  NaN  3.0
2  1  8.0  3.0

열 기준 누적 최대값 (cummax, skipna=True 기본):
   X    Y    Z
0  1  2.0  3.0
1  4  2.0  6.0  # Y열: max(2, NaN) -> 2 (NaN 스킵)
2  7  8.0  9.0

예시 코드:

s_val_counts = pd.Series(['A', 'B', 'A', 'C', 'B', 'A', 'D', 'A'])
print("원본 Series:\n", s_val_counts)
print("\n고유값 빈도 (value_counts()):\n", s_val_counts.value_counts())
print("\n고유값 비율 (normalize=True):\n", s_val_counts.value_counts(normalize=True))

예상 결과:

원본 Series:
0    A
1    B
2    A
3    C
4    B
5    A
6    D
7    A
dtype: object

고유값 빈도 (value_counts()):
A    4
B    2
C    1
D    1
Name: count, dtype: int64

고유값 비율 (normalize=True):
A    0.50
B    0.25
C    0.125
D    0.125
Name: proportion, dtype: float64

예시 코드:

print("df_stats의 열별 고유값 개수:\n", df_stats.nunique(axis=0))
print("s_val_counts의 고유값 개수:", s_val_counts.nunique())

예상 결과:

df_stats의 열별 고유값 개수:
A    5
B    4
C    5
dtype: int64
s_val_counts의 고유값 개수: 4

예시 코드:

df_corr_data = pd.DataFrame({'X': [1,2,3,4,5], 'Y': [5,4,3,2,1], 'Z': [1,3,2,5,4]})
print("\n상관관계 계산용 DataFrame:\n", df_corr_data)
print("\n피어슨 상관계수 행렬 (corr()):\n", df_corr_data.corr())
print("\n공분산 행렬 (cov()):\n", df_corr_data.cov())

예상 결과:

상관관계 계산용 DataFrame:
   X  Y  Z
0  1  5  1
1  2  4  3
2  3  3  2
3  4  2  5
4  5  1  4

피어슨 상관계수 행렬 (corr()):
     X    Y         Z
X  1.0 -1.0  0.774597
Y -1.0  1.0 -0.774597
Z  0.774597 -0.774597  1.0

공분산 행렬 (cov()):
     X    Y    Z
X  2.5 -2.5  2.0
Y -2.5  2.5 -2.0
Z  2.0 -2.0  2.8

예시 코드:

s_change = pd.Series([10, 12, 15, 14, 18])
print("\n변화율 계산용 Series:\n", s_change)
print("\n차분 (diff()):\n", s_change.diff())
print("\n퍼센트 변화율 (pct_change()):\n", s_change.pct_change())

예상 결과:

변화율 계산용 Series:
0    10
1    12
2    15
3    14
4    18
dtype: int64

차분 (diff()):
0    NaN
1    2.0
2    3.0
3   -1.0
4    4.0
dtype: float64

퍼센트 변화율 (pct_change()):
0         NaN
1    0.200000  # (12-10)/10
2    0.250000  # (15-12)/12
3   -0.066667  # (14-15)/15
4    0.285714  # (18-14)/14
dtype: float64

활용 방안: 범주형 데이터의 분포 파악(value_counts), 변수 간 선형 관계 파악(corr), 시계열 데이터의 증감 추세(diff, pct_change) 분석 등 다양한 분석 작업에 활용됩니다.

예시 코드: 데이터 준비 및 GroupBy 객체 생성

import pandas as pd
import numpy as np

data = {'Company': ['GOOG', 'GOOG', 'MSFT', 'MSFT', 'FB', 'FB'],
        'Person': ['Sam', 'Charlie', 'Amy', 'Vanessa', 'Carl', 'Sarah'],
        'Sales': [200, 120, 340, 124, 243, 350],
        'Quarter': ['Q1', 'Q2', 'Q1', 'Q2', 'Q1', 'Q2']}
df_company = pd.DataFrame(data)
print("원본 DataFrame:\n", df_company)

# 'Company' 컬럼으로 그룹화
by_comp = df_company.groupby('Company')
print("\nGroupBy 객체:\n", by_comp) # GroupBy 객체 자체는 내용을 직접 보여주지 않음

# 그룹 확인 (어떤 인덱스들이 어떤 그룹에 속하는지)
print("\n그룹별 인덱스 (groups 속성):\n", by_comp.groups)

# 특정 그룹 데이터 가져오기
print("\n'GOOG' 그룹 데이터 (get_group()):\n", by_comp.get_group('GOOG'))

# 그룹별 크기 (size) 또는 개수 (count)
print("\n그룹별 크기 (size()):\n", by_comp.size())
print("\n그룹별 Sales 개수 (count() - Sales 열만):\n", by_comp['Sales'].count())

예상 결과:

원본 DataFrame:
  Company   Person  Sales Quarter
0    GOOG      Sam    200      Q1
1    GOOG  Charlie    120      Q2
2    MSFT      Amy    340      Q1
3    MSFT  Vanessa    124      Q2
4      FB     Carl    243      Q1
5      FB    Sarah    350      Q2

GroupBy 객체:
 <pandas.core.groupby.generic.DataFrameGroupBy object at 0x...>

그룹별 인덱스 (groups 속성):
{'FB': [4, 5], 'GOOG': [0, 1], 'MSFT': [2, 3]}

'GOOG' 그룹 데이터 (get_group()):
  Company   Person  Sales Quarter
0    GOOG      Sam    200      Q1
1    GOOG  Charlie    120      Q2

그룹별 크기 (size()):
Company
FB      2
GOOG    2
MSFT    2
dtype: int64

그룹별 Sales 개수 (count() - Sales 열만):
Company
FB      2
GOOG    2
MSFT    2
Name: Sales, dtype: int64

예시 코드:

# 'Company'별 Sales 평균
print("\n회사별 Sales 평균 (mean()):\n", by_comp['Sales'].mean())

# 'Company'별 Sales 합계
print("\n회사별 Sales 합계 (sum()):\n", by_comp['Sales'].sum())

# agg()로 여러 집계 함수 적용
agg_funcs_sales = by_comp['Sales'].agg(['sum', 'mean', 'count', 'std', lambda x: x.max() - x.min()])
agg_funcs_sales.rename(columns={'': 'range'}, inplace=True) # 람다 함수 컬럼명 변경
print("\nagg()로 Sales에 여러 함수 적용:\n", agg_funcs_sales)

# agg()로 컬럼별 다른 함수 적용
agg_dict = {'Sales': ['sum', 'mean'], 'Person': 'count'}
print("\nagg()로 컬럼별 다른 함수 적용:\n", by_comp.agg(agg_dict))

# 이름 있는 집계 (Named Aggregation)
named_agg = by_comp.agg(
    Total_Sales=('Sales', 'sum'),
    Average_Sales=('Sales', 'mean'),
    Number_of_People=('Person', 'nunique') # 고유한 Person 수
)
print("\n이름 있는 집계 결과:\n", named_agg)

예상 결과:

회사별 Sales 평균 (mean()):
Company
FB      296.5
GOOG    160.0
MSFT    232.0
Name: Sales, dtype: float64

회사별 Sales 합계 (sum()):
Company
FB      593
GOOG    320
MSFT    464
Name: Sales, dtype: int64

agg()로 Sales에 여러 함수 적용:
          sum   mean  count        std  range
Company                                     
FB        593  296.5      2  75.660426    107
GOOG      320  160.0      2  56.568542     80
MSFT      464  232.0      2 152.735065    216

agg()로 컬럼별 다른 함수 적용:
         Sales        Person
           sum   mean  count
Company                     
FB         593  296.5      2
GOOG       320  160.0      2
MSFT       464  232.0      2

이름 있는 집계 결과:
          Total_Sales  Average_Sales  Number_of_People
Company                                             
FB                593          296.5                 2
GOOG              320          160.0                 2
MSFT              464          232.0                 2

예시 코드:

# 그룹별 Sales 평균으로 각 Sales 값 대체 (예시)
df_company['Group_Avg_Sales'] = by_comp['Sales'].transform('mean')
print("\n그룹 평균 Sales로 변환된 값 추가:\n", df_company)

# 그룹별 Sales의 Z-score 계산
# Z-score = (x - mean) / std
df_company['Sales_Zscore'] = by_comp['Sales'].transform(lambda x: (x - x.mean()) / x.std())
print("\n그룹별 Sales Z-score 추가:\n", df_company)

# 그룹별 최대 Sales 값으로 NaN 채우기 (예시용으로 새 DataFrame 생성)
df_nan_sales = df_company[['Company', 'Sales']].copy()
df_nan_sales.loc[1, 'Sales'] = np.nan # GOOG의 두 번째 Sales를 NaN으로
print("\nNaN 포함 Sales 데이터:\n", df_nan_sales)

# GOOG 그룹의 최대값은 200. NaN이 200으로 채워짐
df_nan_sales['Sales_filled_by_group_max'] = df_nan_sales.groupby('Company')['Sales'].transform(lambda x: x.fillna(x.max()))
print("\n그룹별 최대값으로 NaN 채운 Sales:\n", df_nan_sales)

예상 결과:

그룹 평균 Sales로 변환된 값 추가:
  Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore
0    GOOG      Sam    200      Q1            160.0      0.707107
1    GOOG  Charlie    120      Q2            160.0     -0.707107
2    MSFT      Amy    340      Q1            232.0      0.707107
3    MSFT  Vanessa    124      Q2            232.0     -0.707107
4      FB     Carl    243      Q1            296.5     -0.707107
5      FB    Sarah    350      Q2            296.5      0.707107

그룹별 Sales Z-score 추가:
  Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore
0    GOOG      Sam    200      Q1            160.0      0.707107
1    GOOG  Charlie    120      Q2            160.0     -0.707107
2    MSFT      Amy    340      Q1            232.0      0.707107
3    MSFT  Vanessa    124      Q2            232.0     -0.707107
4      FB     Carl    243      Q1            296.5     -0.707107
5      FB    Sarah    350      Q2            296.5      0.707107

NaN 포함 Sales 데이터:
  Company  Sales
0    GOOG  200.0
1    GOOG    NaN
2    MSFT  340.0
3    MSFT  124.0
4      FB  243.0
5      FB  350.0

그룹별 최대값으로 NaN 채운 Sales:
  Company  Sales  Sales_filled_by_group_max
0    GOOG  200.0                      200.0
1    GOOG    NaN                      200.0
2    MSFT  340.0                      340.0
3    MSFT  124.0                      124.0
4      FB  243.0                      243.0
5      FB  350.0                      350.0

예시 코드:

# Sales 평균이 200 이상인 회사들의 데이터만 필터링
filtered_by_mean_sales = by_comp.filter(lambda x: x['Sales'].mean() >= 200)
print("\nSales 평균 200 이상인 회사 데이터:\n", filtered_by_mean_sales)

# 그룹 내 Sales 값이 하나라도 300을 초과하는 회사의 데이터만 필터링
filtered_by_any_high_sales = by_comp.filter(lambda x: (x['Sales'] > 300).any())
print("\nSales 300 초과 건이 있는 회사 데이터:\n", filtered_by_any_high_sales)

# 그룹 크기(행 수)가 2인 회사들의 데이터만 필터링 (이 예제에서는 모든 회사가 해당)
filtered_by_size = by_comp.filter(lambda x: len(x) == 2)
print("\n그룹 크기가 2인 회사 데이터:\n", filtered_by_size)

예상 결과:

Sales 평균 200 이상인 회사 데이터:
  Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore
2    MSFT      Amy    340      Q1            232.0      0.707107
3    MSFT  Vanessa    124      Q2            232.0     -0.707107
4      FB     Carl    243      Q1            296.5     -0.707107
5      FB    Sarah    350      Q2            296.5      0.707107

Sales 300 초과 건이 있는 회사 데이터:
  Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore
2    MSFT      Amy    340      Q1            232.0      0.707107
3    MSFT  Vanessa    124      Q2            232.0     -0.707107
4      FB     Carl    243      Q1            296.5     -0.707107
5      FB    Sarah    350      Q2            296.5      0.707107

그룹 크기가 2인 회사 데이터:
  Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore
0    GOOG      Sam    200      Q1            160.0      0.707107
1    GOOG  Charlie    120      Q2            160.0     -0.707107
2    MSFT      Amy    340      Q1            232.0      0.707107
3    MSFT  Vanessa    124      Q2            232.0     -0.707107
4      FB     Carl    243      Q1            296.5     -0.707107
5      FB    Sarah    350      Q2            296.5      0.707107

예시 코드:

# 각 회사별로 Sales가 가장 높은 사람의 정보 가져오기
def get_top_sales_person(group_df):
    return group_df.loc[group_df['Sales'].idxmax()]

top_sales_per_company = by_comp.apply(get_top_sales_person)
# 만약 위 함수가 Series를 반환하면, GroupBy는 이를 DataFrame으로 결합하려고 시도합니다.
# 반환 값이 DataFrame이면, 결과는 MultiIndex를 가진 DataFrame이 될 수 있습니다.
print("\n각 회사별 최고 Sales 기록자:\n", top_sales_per_company)


# 각 회사별 Sales를 해당 회사 Sales의 평균으로 나눈 값을 새 열로 추가
def sales_divided_by_group_mean(group_df):
    group_df['Sales_Norm_By_Mean'] = group_df['Sales'] / group_df['Sales'].mean()
    return group_df

df_applied_norm = by_comp.apply(sales_divided_by_group_mean)
# apply는 때때로 인덱스를 재설정하거나 변경할 수 있으므로, 원본과 병합 시 주의 필요
# 이 경우에는 그룹화 키가 인덱스로 들어가므로, 원본 df_company와 인덱스가 다를 수 있음.
# 결과를 원본에 병합하려면 인덱스를 맞추거나, apply 결과의 인덱스를 초기화 후 병합.
print("\napply로 그룹 평균 대비 Sales 비율 추가 (결과 확인용):\n", df_applied_norm)

# 참고: 위 연산은 transform으로 더 간단히 가능
# df_company['Sales_Norm_By_Mean_Transform'] = by_comp['Sales'].transform(lambda x: x / x.mean())
# print("\n(참고) transform으로 그룹 평균 대비 Sales 비율 추가:\n", df_company)

예상 결과:

각 회사별 최고 Sales 기록자:
         Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore
Company                                                               
FB      5       FB    Sarah    350      Q2            296.5      0.707107
GOOG    0     GOOG      Sam    200      Q1            160.0      0.707107
MSFT    2     MSFT      Amy    340      Q1            232.0      0.707107

apply로 그룹 평균 대비 Sales 비율 추가 (결과 확인용):
  Company   Person  Sales Quarter  Group_Avg_Sales  Sales_Zscore  Sales_Norm_By_Mean
0    GOOG      Sam    200      Q1            160.0      0.707107              1.2500
1    GOOG  Charlie    120      Q2            160.0     -0.707107              0.7500
2    MSFT      Amy    340      Q1            232.0      0.707107              1.465517
3    MSFT  Vanessa    124      Q2            232.0     -0.707107              0.534483
4      FB     Carl    243      Q1            296.5     -0.707107              0.819562
5      FB    Sarah    350      Q2            296.5      0.707107              1.180438

예시 코드:

import pandas as pd

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                    'B': ['B0', 'B1', 'B2']},
                   index=[0, 1, 2])

df2 = pd.DataFrame({'A': ['A3', 'A4', 'A5'],
                    'B': ['B3', 'B4', 'B5']},
                   index=[3, 4, 5])

df3 = pd.DataFrame({'C': ['C0', 'C1'],
                    'D': ['D0', 'D1']},
                   index=[0, 1])

print("df1:\n", df1)
print("\ndf2:\n", df2)
print("\ndf3:\n", df3)

# 행 방향으로 연결 (axis=0, 기본값)
result_row_concat = pd.concat([df1, df2])
print("\n행 방향 연결 (기본):\n", result_row_concat)

# ignore_index=True로 새 인덱스 생성
result_row_ignore_idx = pd.concat([df1, df2], ignore_index=True)
print("\n행 방향 연결 (ignore_index=True):\n", result_row_ignore_idx)

# 열 방향으로 연결 (axis=1)
result_col_concat_outer = pd.concat([df1, df3], axis=1, join='outer') # 기본 join='outer'
print("\n열 방향 연결 (join='outer'):\n", result_col_concat_outer)

result_col_concat_inner = pd.concat([df1, df3], axis=1, join='inner')
print("\n열 방향 연결 (join='inner'):\n", result_col_concat_inner)

# keys를 사용하여 계층적 인덱스 생성
result_with_keys = pd.concat([df1, df2], keys=['DF1_KEY', 'DF2_KEY'])
print("\nkeys를 사용한 연결:\n", result_with_keys)
print("\nDF1_KEY 접근:\n", result_with_keys.loc['DF1_KEY'])

예상 결과:

df1:
    A   B
0  A0  B0
1  A1  B1
2  A2  B2

df2:
    A   B
3  A3  B3
4  A4  B4
5  A5  B5

df3:
    C   D
0  C0  D0
1  C1  D1

행 방향 연결 (기본):
    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3
4  A4  B4
5  A5  B5

행 방향 연결 (ignore_index=True):
    A   B
0  A0  B0
1  A1  B1
2  A2  B2
3  A3  B3
4  A4  B4
5  A5  B5

열 방향 연결 (join='outer'):
     A    B    C    D
0   A0   B0   C0   D0
1   A1   B1   C1   D1
2   A2   B2  NaN  NaN  # df3에는 인덱스 2가 없으므로 NaN

열 방향 연결 (join='inner'):
    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1

keys를 사용한 연결:
         A   B
DF1_KEY 0  A0  B0
        1  A1  B1
        2  A2  B2
DF2_KEY 3  A3  B3
        4  A4  B4
        5  A5  B5

DF1_KEY 접근:
   A   B
0  A0  B0
1  A1  B1
2  A2  B2

예시 코드:

left_df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                                'A': ['A0', 'A1', 'A2', 'A3'],
                                'B': ['B0', 'B1', 'B2', 'B3']})

right_df = pd.DataFrame({'key': ['K0', 'K1', 'K4', 'K5'], # K2, K3 없음, K4, K5 추가
                                 'C': ['C0', 'C1', 'C4', 'C5'],
                                 'D': ['D0', 'D1', 'D4', 'D5']})
print("left_df:\n", left_df)
print("\nright_df:\n", right_df)

# inner merge (기본, 공통 'key' 기준)
inner_merged = pd.merge(left_df, right_df, on='key')
print("\nInner Merge (on 'key'):\n", inner_merged)

# outer merge
outer_merged = pd.merge(left_df, right_df, on='key', how='outer')
print("\nOuter Merge (on 'key'):\n", outer_merged)

# left merge
left_merged = pd.merge(left_df, right_df, on='key', how='left')
print("\nLeft Merge (on 'key'):\n", left_merged)

# right merge with indicator
right_merged_indicator = pd.merge(left_df, right_df, on='key', how='right', indicator=True)
print("\nRight Merge (on 'key', with indicator):\n", right_merged_indicator)

# 다른 이름의 키로 병합 (left_on, right_on)
left_df_diffkey = pd.DataFrame({'lkey': ['K0', 'K1', 'K2'], 'val_L': [1,2,3]})
right_df_diffkey = pd.DataFrame({'rkey': ['K0', 'K1', 'K3'], 'val_R': [4,5,6]})
merged_diff_keys = pd.merge(left_df_diffkey, right_df_diffkey, left_on='lkey', right_on='rkey', how='inner')
print("\n다른 이름의 키로 병합 (inner):\n", merged_diff_keys)

# 인덱스 기준 병합
left_idx_df = pd.DataFrame({'A': ['A0', 'A1']}, index=['K0', 'K1'])
right_idx_df = pd.DataFrame({'B': ['B0', 'B1']}, index=['K0', 'K2']) # K1 대신 K2
merged_idx = pd.merge(left_idx_df, right_idx_df, left_index=True, right_index=True, how='outer')
print("\n인덱스 기준 병합 (outer):\n", merged_idx)

예상 결과:

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

right_df:
  key   C   D
0  K0  C0  D0
1  K1  C1  D1
2  K4  C4  D4
3  K5  C5  D5

Inner Merge (on 'key'):
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1

Outer Merge (on 'key'):
  key    A    B    C    D
0  K0   A0   B0   C0   D0
1  K1   A1   B1   C1   D1
2  K2   A2   B2  NaN  NaN
3  K3   A3   B3  NaN  NaN
4  K4  NaN  NaN   C4   D4
5  K5  NaN  NaN   C5   D5

Left Merge (on 'key'):
  key   A   B    C    D
0  K0  A0  B0   C0   D0
1  K1  A1  B1   C1   D1
2  K2  A2  B2  NaN  NaN
3  K3  A3  B3  NaN  NaN

Right Merge (on 'key', with indicator):
  key    A    B   C   D      _merge
0  K0   A0   B0  C0  D0        both
1  K1   A1   B1  C1  D1        both
2  K4  NaN  NaN  C4  D4  right_only
3  K5  NaN  NaN  C5  D5  right_only

다른 이름의 키로 병합 (inner):
  lkey  val_L rkey  val_R
0   K0      1   K0      4
1   K1      2   K1      5

인덱스 기준 병합 (outer):
      A    B
K0   A0   B0
K1   A1  NaN
K2  NaN   B1

예시 코드:

left_join_df = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                                 'B': ['B0', 'B1', 'B2']},
                                index=['K0', 'K1', 'K2'])

right_join_df = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                                  'D': ['D0', 'D2', 'D3']},
                                 index=['K0', 'K2', 'K3']) # K1 없음, K3 추가
print("left_join_df:\n", left_join_df)
print("\nright_join_df:\n", right_join_df)

# 기본 join (left join, 인덱스 기준)
joined_default = left_join_df.join(right_join_df)
print("\nDefault Join (left, on index):\n", joined_default)

# outer join
joined_outer = left_join_df.join(right_join_df, how='outer')
print("\nOuter Join (on index):\n", joined_outer)

# inner join
joined_inner = left_join_df.join(right_join_df, how='inner')
print("\nInner Join (on index):\n", joined_inner)

# 왼쪽 DataFrame의 특정 열('A')과 오른쪽 DataFrame의 인덱스 기준 결합
left_on_col_df = pd.DataFrame({'key_col': ['K0', 'K0', 'K1'], 'val1': [0,1,2]})
right_on_idx_df = pd.DataFrame({'val2': [10,20]}, index=['K0', 'K1'])
joined_on_col_idx = left_on_col_df.join(right_on_idx_df, on='key_col', how='left')
print("\n왼쪽 열 & 오른쪽 인덱스 기준 결합:\n", joined_on_col_idx)

# 중복 열 이름 처리 (lsuffix, rsuffix)
df_x = pd.DataFrame({'X': [1,2]}, index=['a','b'])
df_y = pd.DataFrame({'X': [3,4]}, index=['a','c'])
joined_suffix = df_x.join(df_y, lsuffix='_left', rsuffix='_right', how='outer')
print("\n중복 열 이름 접미사 처리:\n", joined_suffix)

예상 결과:

left_join_df:
     A   B
K0  A0  B0
K1  A1  B1
K2  A2  B2

right_join_df:
     C   D
K0  C0  D0
K2  C2  D2
K3  C3  D3

Default Join (left, on index):
     A   B    C    D
K0  A0  B0   C0   D0
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2

Outer Join (on index):
      A    B    C    D
K0   A0   B0   C0   D0
K1   A1   B1  NaN  NaN
K2   A2   B2   C2   D2
K3  NaN  NaN   C3   D3

Inner Join (on index):
     A   B   C   D
K0  A0  B0  C0  D0
K2  A2  B2  C2  D2

왼쪽 열 & 오른쪽 인덱스 기준 결합:
  key_col  val1  val2
0      K0     0  10.0
1      K0     1  10.0
2      K1     2  20.0

중복 열 이름 접미사 처리:
   X_left  X_right
a     1.0      3.0
b     2.0      NaN
c     NaN      4.0

예시 코드:

import pandas as pd

# Timestamp 생성
ts_now = pd.Timestamp('2025-05-20 10:30:00')
print("Timestamp:", ts_now)
print("Year:", ts_now.year, ", Month:", ts_now.month, ", Day:", ts_now.day, ", Day of week:", ts_now.dayofweek) # 월요일=0, 일요일=6

# DatetimeIndex 생성
date_idx = pd.to_datetime(['2025-01-01', '2025-01-02', '2025-01-03'])
print("\nDatetimeIndex:\n", date_idx)

# Period 생성
period_month = pd.Period('2025-05', freq='M') # 'M'은 월말 빈도
print("\nPeriod (Month):", period_month)
print("Start time:", period_month.start_time, ", End time:", period_month.end_time)

# Timedelta 생성
delta = pd.Timestamp('2025-05-21') - pd.Timestamp('2025-05-20')
print("\nTimedelta:", delta)

예상 결과:

Timestamp: 2025-05-20 10:30:00
Year: 2025 , Month: 5 , Day: 20 , Day of week: 1

DatetimeIndex:
 DatetimeIndex(['2025-01-01', '2025-01-02', '2025-01-03'], dtype='datetime64[ns]', freq=None)

Period (Month): 2025-05
Start time: 2025-05-01 00:00:00 , End time: 2025-05-31 23:59:59.999999999

Timedelta: 1 days 00:00:00

예시 코드:

date_strings = ['2025-01-05', '2025/01/10', 'Jan 15, 2025', '2025.01.20', 'invalid_date']
dt_index_from_strings = pd.to_datetime(date_strings, errors='coerce') # 오류 발생 시 NaT으로
print("\n문자열에서 변환된 DatetimeIndex (errors='coerce'):\n", dt_index_from_strings)

# 특정 포맷 지정
custom_format_dates = pd.to_datetime(['25-12-2024', '26-12-2024'], format='%d-%m-%Y')
print("\n사용자 정의 포맷으로 변환된 DatetimeIndex:\n", custom_format_dates)

예상 결과:

문자열에서 변환된 DatetimeIndex (errors='coerce'):
 DatetimeIndex(['2025-01-05', '2025-01-10', '2025-01-15', '2025-01-20', 'NaT'], dtype='datetime64[ns]', freq=None)

사용자 정의 포맷으로 변환된 DatetimeIndex:
 DatetimeIndex(['2024-12-25', '2024-12-26'], dtype='datetime64[ns]', freq=None)

예시 코드:

# 2025년 1월 1일부터 5일간 일별 DatetimeIndex
date_range_daily = pd.date_range(start='2025-01-01', periods=5, freq='D')
print("\n일별 DatetimeIndex (5일간):\n", date_range_daily)

# 2025년 1월 한 달간 업무일(Business day) DatetimeIndex
date_range_business = pd.date_range(start='2025-01-01', end='2025-01-31', freq='B')
print("\n2025년 1월 업무일 DatetimeIndex:\n", date_range_business)

# 2025년 5월 20일 0시부터 4시간 간격으로 6개
date_range_hourly = pd.date_range(start='2025-05-20', periods=6, freq='4H')
print("\n4시간 간격 DatetimeIndex:\n", date_range_hourly)

예상 결과:

일별 DatetimeIndex (5일간):
 DatetimeIndex(['2025-01-01', '2025-01-02', '2025-01-03', '2025-01-04',
               '2025-01-05'],
              dtype='datetime64[ns]', freq='D')

2025년 1월 업무일 DatetimeIndex:
 DatetimeIndex(['2025-01-01', '2025-01-02', '2025-01-03', '2025-01-06',
               '2025-01-07', '2025-01-08', '2025-01-09', '2025-01-10',
               '2025-01-13', '2025-01-14', '2025-01-15', '2025-01-16',
               '2025-01-17', '2025-01-20', '2025-01-21', '2025-01-22',
               '2025-01-23', '2025-01-24', '2025-01-27', '2025-01-28',
               '2025-01-29', '2025-01-30', '2025-01-31'],
              dtype='datetime64[ns]', freq='B')

4시간 간격 DatetimeIndex:
 DatetimeIndex(['2025-05-20 00:00:00', '2025-05-20 04:00:00',
               '2025-05-20 08:00:00', '2025-05-20 12:00:00',
               '2025-05-20 16:00:00', '2025-05-20 20:00:00'],
              dtype='datetime64[ns]', freq='4H')

예시 코드:

# 시계열 데이터 생성
ts_idx = pd.date_range('2025-01-01', periods=100, freq='D')
ts_data = pd.Series(np.random.randn(len(ts_idx)), index=ts_idx)
print("\n샘플 시계열 데이터 (첫 5개):\n", ts_data.head())

# 특정 날짜 선택
print("\n2025-01-05 데이터:", ts_data['2025-01-05'])

# 특정 연도/월 선택
print("\n2025년 2월 데이터 (일부):\n", ts_data['2025-02'].head())

# 날짜 범위 슬라이싱
print("\n2025-01-10 부터 2025-01-15 까지 데이터:\n", ts_data['2025-01-10':'2025-01-15'])

# truncate: 특정 날짜 이전/이후/사이 데이터 자르기
# 2025년 2월 15일 이후 데이터만 선택
truncated_after = ts_data.truncate(before='2025-02-15')
print("\n2025-02-15 이후 데이터 (truncate, 첫 3개):\n", truncated_after.head(3))

# asof: 특정 시점 또는 그 이전의 가장 가까운 유효한 값
# 만약 ts_data['2025-01-15 12:00:00']가 없다면, 그 이전 가장 가까운 값
# 정확한 예시를 위해 시간을 포함한 인덱스 재생성
ts_idx_time = pd.date_range('2025-01-15 00:00:00', periods=5, freq='H')
ts_data_time = pd.Series(range(5), index=ts_idx_time)
ts_data_time.iloc[2] = np.nan # 2025-01-15 02:00:00을 NaN으로
print("\n시간 포함 시계열 데이터:\n", ts_data_time)
print("\n2025-01-15 02:30:00 시점 또는 이전 최근 값 (asof):", ts_data_time.asof('2025-01-15 02:30:00'))

예상 결과 (randn 부분은 실행 시마다 다름):

샘플 시계열 데이터 (첫 5개):
2025-01-01    0.123456
2025-01-02   -0.567890
2025-01-03    1.122334
2025-01-04   -0.987654
2025-01-05    0.456789
Freq: D, dtype: float64

2025-01-05 데이터: 0.456789...

2025년 2월 데이터 (일부):
2025-02-01   -0.111111
2025-02-02    0.222222
2025-02-03   -0.333333
2025-02-04    0.444444
2025-02-05   -0.555555
Freq: D, dtype: float64

2025-01-10 부터 2025-01-15 까지 데이터:
2025-01-10    ...
2025-01-11    ...
2025-01-12    ...
2025-01-13    ...
2025-01-14    ...
2025-01-15    ...
Freq: D, dtype: float64

2025-02-15 이후 데이터 (truncate, 첫 3개):
2025-02-15    ...
2025-02-16    ...
2025-02-17    ...
Freq: D, dtype: float64

시간 포함 시계열 데이터:
2025-01-15 00:00:00    0.0
2025-01-15 01:00:00    1.0
2025-01-15 02:00:00    NaN
2025-01-15 03:00:00    3.0
2025-01-15 04:00:00    4.0
Freq: H, dtype: float64

2025-01-15 02:30:00 시점 또는 이전 최근 값 (asof): 1.0

예시 코드 (위의 ts_data 사용):

# 월별 평균 계산 (다운샘플링)
monthly_mean = ts_data.resample('M').mean() # 'M'은 월말 빈도
print("\n월별 평균 (다운샘플링):\n", monthly_mean.head(3))

# 주별(일요일 기준) 합계 계산
weekly_sum = ts_data.resample('W').sum() # 'W'는 주별 빈도 (일요일이 주의 끝)
print("\n주별 합계 (다운샘플링):\n", weekly_sum.head(3))

# 분기별 OHLC (Open, High, Low, Close) 계산 - 주가 데이터 등에 사용
# 여기서는 임의의 데이터로 예시
ts_ohlc_data = pd.Series(np.random.randint(50,100, size=len(ts_data)), index=ts_data.index)
quarterly_ohlc = ts_ohlc_data.resample('Q').ohlc() # 'Q'는 분기말 빈도
print("\n분기별 OHLC (다운샘플링):\n", quarterly_ohlc)

예상 결과 (randn 부분은 실행 시마다 다름):

월별 평균 (다운샘플링):
2025-01-31    ... (1월 데이터 평균)
2025-02-28    ... (2월 데이터 평균)
2025-03-31    ... (3월 데이터 평균)
Freq: M, Name: (randn 값에 따라 다름), dtype: float64

주별 합계 (다운샘플링):
2025-01-05    ... (첫 주 ~1/5 합계)
2025-01-12    ... (1/6 ~ 1/12 합계)
2025-01-19    ... (1/13 ~ 1/19 합계)
Freq: W-SUN, Name: (randn 값에 따라 다름), dtype: float64

분기별 OHLC (다운샘플링):
            open  high  low  close
2025-03-31   ...   ...  ...    ...  (1분기 ohlc)
2025-06-30   ...   ...  ...    ...  (2분기 ohlc, 4월 10일까지의 데이터로 계산됨)
Freq: Q-DEC, Name: (randint 값에 따라 다름), dtype: int...

예시 코드 (위의 monthly_mean 사용 가정):

# 월별 데이터를 일별 데이터로 업샘플링 (asfreq)
daily_from_monthly_asfreq = monthly_mean.resample('D').asfreq()
print("\n월별 -> 일별 업샘플링 (asfreq, 첫 5개):\n", daily_from_monthly_asfreq.head())

# ffill로 채우기
daily_from_monthly_ffill = monthly_mean.resample('D').ffill()
print("\n월별 -> 일별 업샘플링 (ffill, 첫 5개):\n", daily_from_monthly_ffill.head())

# 선형 보간으로 채우기
daily_from_monthly_interp = monthly_mean.resample('D').interpolate(method='linear')
print("\n월별 -> 일별 업샘플링 (선형 보간, 첫 5개):\n", daily_from_monthly_interp.head())

예상 결과 (monthly_mean 값에 따라 다름):

월별 -> 일별 업샘플링 (asfreq, 첫 5개):
2025-01-31         ... (1월 평균값)
2025-02-01         NaN
2025-02-02         NaN
2025-02-03         NaN
2025-02-04         NaN
Freq: D, Name: (이름), dtype: float64

월별 -> 일별 업샘플링 (ffill, 첫 5개):
2025-01-31         ... (1월 평균값)
2025-02-01         ... (1월 평균값)
2025-02-02         ... (1월 평균값)
2025-02-03         ... (1월 평균값)
2025-02-04         ... (1월 평균값)
Freq: D, Name: (이름), dtype: float64

월별 -> 일별 업샘플링 (선형 보간, 첫 5개):
2025-01-31         ... (1월 평균값)
2025-02-01         ... (1월과 2월 평균 사이의 보간값)
2025-02-02         ...
2025-02-03         ...
2025-02-04         ...
Freq: D, Name: (이름), dtype: float64

예시 코드 (위의 ts_data 사용):

# 3일 이동 평균
rolling_mean_3d = ts_data.rolling(window=3).mean()
print("\n3일 이동 평균 (첫 7개):\n", rolling_mean_3d.head(7))

# 5일 이동 표준편차 (최소 3개 이상 데이터 필요)
rolling_std_5d_min3 = ts_data.rolling(window=5, min_periods=3).std()
print("\n5일 이동 표준편차 (min_periods=3, 첫 7개):\n", rolling_std_5d_min3.head(7))

# 사용자 정의 함수 적용 (예: 창 내 최대값과 최소값의 차이)
rolling_range = ts_data.rolling(window=3).apply(lambda x: x.max() - x.min(), raw=True) # raw=True는 성능 향상에 도움
print("\n3일 이동 범위 (첫 7개):\n", rolling_range.head(7))

# Expanding window: 시작점부터 현재까지 확장되는 창
expanding_mean = ts_data.expanding().mean()
print("\n확장창 평균 (첫 7개):\n", expanding_mean.head(7))

# EWM: 지수 가중 이동 평균
ewm_mean = ts_data.ewm(span=3).mean() # span은 대략적인 창 크기 효과
print("\n지수 가중 이동 평균 (span=3, 첫 7개):\n", ewm_mean.head(7))

예상 결과 (randn 부분은 실행 시마다 다름):

3일 이동 평균 (첫 7개):
2025-01-01         NaN
2025-01-02         NaN
2025-01-03         ... (1,2,3일차 평균)
2025-01-04         ... (2,3,4일차 평균)
2025-01-05         ... (3,4,5일차 평균)
2025-01-06         ...
2025-01-07         ...
Freq: D, Name: (이름), dtype: float64

5일 이동 표준편차 (min_periods=3, 첫 7개):
2025-01-01         NaN
2025-01-02         NaN
2025-01-03         ... (1,2,3일차 std)
2025-01-04         ... (1,2,3,4일차 std)
2025-01-05         ... (1,2,3,4,5일차 std)
2025-01-06         ...
2025-01-07         ...
Freq: D, Name: (이름), dtype: float64

3일 이동 범위 (첫 7개):
2025-01-01         NaN
2025-01-02         NaN
2025-01-03         ... (1,2,3일차 max-min)
2025-01-04         ... (2,3,4일차 max-min)
2025-01-05         ... (3,4,5일차 max-min)
2025-01-06         ...
2025-01-07         ...
Freq: D, Name: (이름), dtype: float64

확장창 평균 (첫 7개):
2025-01-01    ... (1일차 값)
2025-01-02    ... (1~2일차 평균)
2025-01-03    ... (1~3일차 평균)
2025-01-04    ... (1~4일차 평균)
2025-01-05    ... (1~5일차 평균)
2025-01-06    ...
2025-01-07    ...
Freq: D, Name: (이름), dtype: float64

지수 가중 이동 평균 (span=3, 첫 7개):
2025-01-01    ...
2025-01-02    ...
2025-01-03    ...
2025-01-04    ...
2025-01-05    ...
2025-01-06    ...
2025-01-07    ...
Freq: D, Name: (이름), dtype: float64

예시 코드 (위의 ts_data 사용):

# 값을 1일 뒤로 이동 (오늘 값은 어제의 값이 됨)
shifted_1_day_later = ts_data.shift(1)
print("\n1일 뒤로 이동 (첫 5개):\n", shifted_1_day_later.head())

# 값을 1일 앞으로 이동 (오늘 값은 내일의 값이 됨)
shifted_1_day_earlier = ts_data.shift(-1)
print("\n1일 앞으로 이동 (첫 5개):\n", shifted_1_day_earlier.head())

# 전일 대비 변화량 계산
daily_change = ts_data - ts_data.shift(1) # 또는 ts_data.diff()
print("\n전일 대비 변화량 (첫 5개):\n", daily_change.head())

# 인덱스를 2 영업일(Business day)만큼 이동 (값은 그대로)
# DatetimeIndex 객체에 직접 DateOffset 더하기 권장
shifted_index = ts_data.index + pd.offsets.BDay(2)
ts_data_shifted_idx = pd.Series(ts_data.values, index=shifted_index) # 값은 원래대로, 인덱스만 변경
print("\n인덱스를 2 영업일 이동 (첫 5개):\n", ts_data_shifted_idx.head())
# 예전 tshift 방식: ts_data.tshift(2, freq='B') -> 더 이상 사용되지 않음
# 또는 ts_data.shift(2, freq='B') -> 인덱스 이동, 값 그대로

예상 결과 (randn 부분은 실행 시마다 다름):

1일 뒤로 이동 (첫 5개):
2025-01-01         NaN
2025-01-02         ... (원래 2025-01-01 값)
2025-01-03         ... (원래 2025-01-02 값)
2025-01-04         ... (원래 2025-01-03 값)
2025-01-05         ... (원래 2025-01-04 값)
Freq: D, Name: (이름), dtype: float64

1일 앞으로 이동 (첫 5개):
2025-01-01         ... (원래 2025-01-02 값)
2025-01-02         ... (원래 2025-01-03 값)
2025-01-03         ... (원래 2025-01-04 값)
2025-01-04         ... (원래 2025-01-05 값)
2025-01-05         ... (원래 2025-01-06 값)
Freq: D, Name: (이름), dtype: float64

전일 대비 변화량 (첫 5개):
2025-01-01         NaN
2025-01-02         ... (ts_data[1] - ts_data[0])
2025-01-03         ... (ts_data[2] - ts_data[1])
2025-01-04         ...
2025-01-05         ...
Freq: D, Name: (이름), dtype: float64

인덱스를 2 영업일 이동 (첫 5개):
2025-01-03    ... (원래 2025-01-01의 값)
2025-01-06    ... (원래 2025-01-02의 값)
2025-01-07    ... (원래 2025-01-03의 값)
2025-01-08    ...
2025-01-09    ...
dtype: float64

예시 코드:

# 시간대가 없는(naive) DatetimeIndex
naive_dt_idx = pd.date_range('2025-05-20 09:00:00', periods=3, freq='H')
s_naive = pd.Series(range(3), index=naive_dt_idx)
print("시간대 없는(naive) Series:\n", s_naive)

# UTC 시간대로 현지화 (localize)
s_utc = s_naive.tz_localize('UTC')
print("\nUTC 시간대로 현지화된 Series:\n", s_utc)

# 'Asia/Seoul' 시간대로 변환 (convert)
s_seoul = s_utc.tz_convert('Asia/Seoul')
print("\nAsia/Seoul 시간대로 변환된 Series:\n", s_seoul)

# 다른 방법: 처음부터 시간대 지정하여 생성
s_seoul_direct = pd.Series(range(3), index=pd.date_range('2025-05-20 09:00:00', periods=3, freq='H', tz='Asia/Seoul'))
print("\nAsia/Seoul 시간대로 직접 생성된 Series:\n", s_seoul_direct)

예상 결과:

시간대 없는(naive) Series:
2025-05-20 09:00:00    0
2025-05-20 10:00:00    1
2025-05-20 11:00:00    2
Freq: H, dtype: int64

UTC 시간대로 현지화된 Series:
2025-05-20 09:00:00+00:00    0
2025-05-20 10:00:00+00:00    1
2025-05-20 11:00:00+00:00    2
Freq: H, dtype: int64

Asia/Seoul 시간대로 변환된 Series:
2025-05-20 18:00:00+09:00    0  # 09:00 UTC -> 18:00 KST
2025-05-20 19:00:00+09:00    1
2025-05-20 20:00:00+09:00    2
Freq: H, dtype: int64

Asia/Seoul 시간대로 직접 생성된 Series:
2025-05-20 09:00:00+09:00    0
2025-05-20 10:00:00+09:00    1
2025-05-20 11:00:00+09:00    2
Freq: H, dtype: int64

예시 코드:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt # Matplotlib 임포트

# 샘플 데이터 생성
s = pd.Series(np.random.randn(10).cumsum(), index=np.arange(0, 100, 10))
df_vis = pd.DataFrame(np.random.randn(10, 4).cumsum(axis=0),
                      columns=['A', 'B', 'C', 'D'],
                      index=np.arange(0, 100, 10))

print("샘플 Series (s):\n", s.head())
print("\n샘플 DataFrame (df_vis):\n", df_vis.head())

# Series 라인 플롯
s.plot()
plt.title("Sample Series Line Plot") # Matplotlib 함수로 제목 추가
plt.xlabel("Index")
plt.ylabel("Value")
plt.show() # 스크립트 환경에서는 필수

# DataFrame 라인 플롯 (각 열이 하나의 라인)
df_vis.plot()
plt.title("Sample DataFrame Line Plot")
plt.show()

예상 결과 (텍스트 설명):

위 코드를 실행하면 두 개의 플롯 창이 나타납니다 (Jupyter 환경에서는 셀 아래에 표시됨).

1. 첫 번째 플롯은 Series s의 인덱스를 x축, 값을 y축으로 하는 라인 플롯입니다. 제목, x축 라벨, y축 라벨이 Matplotlib 함수를 통해 추가된 것을 볼 수 있습니다.
2. 두 번째 플롯은 DataFrame df_vis의 인덱스를 x축으로 하고, 각 열('A', 'B', 'C', 'D')의 데이터를 별도의 라인으로 그린 플롯입니다. 자동으로 각 라인에 대한 범례(legend)가 표시됩니다.

예시 코드:

# df_vis는 위에서 생성한 DataFrame 사용
df_vis.plot.line(y=['A', 'C'], title='Line Plot of Columns A and C', grid=True)
plt.ylabel("Values")
plt.show()

예상 결과 (텍스트 설명):

DataFrame df_vis에서 'A'열과 'C'열의 데이터만 선택하여 라인 플롯을 그립니다. 제목이 지정되고 그리드가 표시됩니다.

활용 방안: 주가 변동, 기온 변화, 시간에 따른 웹사이트 트래픽 등 연속적인 데이터의 추세를 시각화합니다.

예시 코드:

df_bar = pd.DataFrame({'Category': ['X', 'Y', 'Z'], 'Value1': [10, 25, 15], 'Value2': [12, 18, 22]})
df_bar.set_index('Category', inplace=True) # Category를 인덱스로 설정

# 수직 막대 그래프
df_bar.plot.bar(title='Vertical Bar Plot', rot=0) # rot=0은 x축 라벨 회전 안 함
plt.ylabel("Counts")
plt.show()

# 수평 누적 막대 그래프
df_bar.plot.barh(stacked=True, title='Horizontal Stacked Bar Plot')
plt.xlabel("Counts")
plt.show()

예상 결과 (텍스트 설명):

1. 첫 번째 플롯은 'X', 'Y', 'Z' 카테고리별로 'Value1'과 'Value2'의 값을 나타내는 수직 막대 그래프입니다. 각 카테고리마다 두 개의 막대(Value1, Value2)가 그룹지어 표시됩니다.
2. 두 번째 플롯은 각 카테고리별로 'Value1'과 'Value2'의 값을 누적하여 보여주는 수평 막대 그래프입니다.

활용 방안: 제품별 판매량 비교, 설문조사 응답 결과 비교, 지역별 인구수 비교 등 범주 간의 양적 비교에 유용합니다.

예시 코드:

s_hist_data = pd.Series(np.random.normal(0, 1, size=1000)) # 정규분포 데이터 생성

s_hist_data.plot.hist(bins=30, alpha=0.7, title='Histogram of Normal Distribution')
plt.xlabel("Value")
plt.ylabel("Frequency")
plt.show()

# DataFrame의 여러 열에 대한 히스토그램 (겹쳐서 또는 서브플롯으로)
df_vis[['A', 'B']].plot.hist(bins=20, alpha=0.6, subplots=False, title='Histogram of A and B (Overlay)') # subplots=False면 겹쳐서
plt.show()

df_vis[['C', 'D']].plot.hist(bins=15, alpha=0.8, subplots=True, layout=(1,2), figsize=(10,4), title='Histograms of C and D (Subplots)')
plt.tight_layout() # 서브플롯 간 간격 자동 조절
plt.show()

예상 결과 (텍스트 설명):

1. 첫 번째 플롯은 정규분포를 따르는 1000개 데이터의 히스토그램입니다. 30개의 구간으로 나누어 각 구간의 빈도수를 보여줍니다.
2. 두 번째 플롯은 DataFrame df_vis의 'A'열과 'B'열에 대한 히스토그램을 하나의 플롯에 겹쳐서 그립니다.
3. 세 번째 플롯은 'C'열과 'D'열에 대한 히스토그램을 각각 별도의 서브플롯으로 나란히 그립니다.

활용 방안: 데이터의 분포 형태(정규분포, 치우친 분포 등), 중심 경향, 산포도 등을 시각적으로 확인하는 데 사용됩니다.

예시 코드:

# df_vis는 위에서 생성한 DataFrame 사용
df_vis.plot.box(title='Box Plot of Columns A, B, C, D')
plt.ylabel("Value Distribution")
plt.show()

# 특정 컬럼 그룹화 후 박스 플롯
df_grouped_box = pd.DataFrame({
    'Category': np.random.choice(['Group1', 'Group2', 'Group3'], 100),
    'Value': np.random.randn(100) * 5 + np.repeat([10, 20, 15], [40, 30, 30]) # 그룹별 평균 다르게
})
df_grouped_box.boxplot(column='Value', by='Category', grid=False)
plt.title("Box Plot of Value by Category")
plt.suptitle("") # 기본으로 생성되는 상위 제목 제거
plt.xlabel("Category")
plt.ylabel("Value")
plt.show()

예상 결과 (텍스트 설명):

1. 첫 번째 플롯은 DataFrame df_vis의 각 열('A', 'B', 'C', 'D')에 대한 박스 플롯을 나란히 그려 분포를 비교합니다.
2. 두 번째 플롯은 'Category'별로 'Value'의 분포를 박스 플롯으로 보여줍니다. 'Group1', 'Group2', 'Group3' 각 그룹의 데이터 분포 특성(중앙값, 사분위 범위, 이상치 등)을 비교할 수 있습니다.

활용 방안: 데이터의 전반적인 분포 특성 파악, 그룹 간 분포 비교, 이상치 식별 등에 효과적입니다.

예시 코드:

# df_vis는 위에서 생성한 DataFrame 사용 (양수 값으로 변경하면 보기 좋음)
df_area_data = pd.DataFrame(np.abs(np.random.randn(10, 3).cumsum(axis=0)), columns=['X', 'Y', 'Z'])

# 누적 영역 플롯 (기본)
df_area_data.plot.area(title='Stacked Area Plot')
plt.show()

# 누적되지 않은 영역 플롯
df_area_data.plot.area(stacked=False, alpha=0.5, title='Unstacked Area Plot')
plt.show()

예상 결과 (텍스트 설명):

1. 첫 번째 플롯은 'X', 'Y', 'Z' 각 열의 값을 시간에 따라 누적하여 영역으로 표시합니다. 전체 크기와 각 부분의 기여도를 함께 볼 수 있습니다.
2. 두 번째 플롯은 각 열의 영역을 누적하지 않고 겹쳐서 그립니다. 투명도(alpha)를 조절하여 겹치는 부분을 확인할 수 있습니다.

활용 방안: 시간에 따른 여러 그룹의 누적된 양 변화(예: 시장 점유율 변화), 전체 대비 각 구성 요소의 크기 변화 등을 보여줄 때 사용합니다.

예시 코드:

df_scatter = pd.DataFrame(np.random.rand(50, 3), columns=['Var1', 'Var2', 'Var3'])
df_scatter['Var4_Size'] = np.random.rand(50) * 100 # 점 크기용 변수
df_scatter['Var5_Color'] = np.random.randint(0, 3, 50) # 점 색상용 변수 (범주형)

# Var1과 Var2의 산점도
df_scatter.plot.scatter(x='Var1', y='Var2', title='Scatter Plot of Var1 vs Var2')
plt.show()

# Var3를 색상(c), Var4_Size를 크기(s)로 표현
df_scatter.plot.scatter(x='Var1', y='Var2', c='Var5_Color', s='Var4_Size', colormap='viridis', alpha=0.6,
                        title='Scatter Plot with Color and Size Variation')
plt.show()

예상 결과 (텍스트 설명):

1. 첫 번째 플롯은 'Var1'을 x축, 'Var2'를 y축으로 하는 기본적인 산점도입니다. 두 변수 간의 분포 패턴을 볼 수 있습니다.
2. 두 번째 플롯은 'Var1'과 'Var2'의 관계를 점으로 표시하되, 각 점의 색상은 'Var5_Color' 값에 따라, 점의 크기는 'Var4_Size' 값에 따라 다르게 표현됩니다. 이를 통해 최대 4개의 변수 정보를 하나의 산점도에 나타낼 수 있습니다.

활용 방안: 두 변수 간의 선형/비선형 관계, 데이터의 군집 형성 여부, 이상치 등을 탐색하는 데 사용됩니다.

예시 코드:

s_pie = pd.Series([15, 30, 45, 10], index=['A', 'B', 'C', 'D'], name='Portion')

s_pie.plot.pie(autopct='%.1f%%', figsize=(6, 6), title='Pie Chart of Portions', startangle=90, counterclock=False,
               colors=['skyblue', 'lightcoral', 'lightgreen', 'gold'], wedgeprops={'edgecolor': 'black'})
plt.ylabel('') # 불필요한 y축 라벨 제거
plt.show()

예상 결과 (텍스트 설명):

Series s_pie의 각 항목('A', 'B', 'C', 'D')이 전체에서 차지하는 비율을 파이 차트로 나타냅니다. 각 조각에 백분율이 표시되고, 지정된 색상과 시작 각도 등이 적용됩니다.

활용 방안: 시장 점유율, 예산 구성 비율 등 전체에 대한 각 부분의 상대적인 크기를 보여주고자 할 때 제한적으로 사용될 수 있습니다.

예시 코드:

# s_hist_data는 위에서 생성한 정규분포 Series 사용
s_hist_data.plot.kde(title='Density Plot (KDE) of Normal Distribution')
plt.xlabel("Value")
plt.show()

# DataFrame의 여러 열에 대한 밀도 플롯
df_vis[['A', 'B']].plot.kde(title='Density Plots of A and B')
plt.show()

예상 결과 (텍스트 설명):

1. 첫 번째 플롯은 s_hist_data의 분포를 부드러운 곡선 형태의 밀도 플롯으로 보여줍니다.
2. 두 번째 플롯은 DataFrame df_vis의 'A'열과 'B'열 각각에 대한 밀도 플롯을 하나의 그림에 함께 그립니다.

활용 방안: 변수의 분포 형태를 히스토그램보다 부드럽게 파악하거나, 여러 그룹 간의 분포를 비교할 때 사용됩니다.

예시 코드: 커스터마이징 및 Matplotlib 객체 활용

# df_vis는 위에서 생성한 DataFrame 사용
ax = df_vis.plot(kind='line',
                 title='Customized DataFrame Plot',
                 figsize=(12, 6),
                 grid=True,
                 legend=True,
                 style=['-', '--', ':', '-.'], # 각 라인 스타일 다르게
                 color=['blue', 'green', 'red', 'purple']) # 각 라인 색상 다르게

# Matplotlib Axes 객체(ax)를 사용하여 추가 설정
ax.set_xlabel("Time Index (0-90, step 10)")
ax.set_ylabel("Cumulative Sum of Random Values")
ax.legend(title='Columns', loc='upper left') # 범례 위치 및 제목 변경
ax.set_facecolor('lightyellow') # 플롯 배경색 변경

plt.figtext(0.5, 0.01, 'Figure caption or additional text', ha='center', fontsize=10) # 그림 하단에 텍스트 추가
plt.tight_layout()
plt.show()

예상 결과 (텍스트 설명):

DataFrame df_vis의 라인 플롯이 생성됩니다. 이 플롯은 지정된 제목, 크기, 그리드, 범례, 라인 스타일, 색상 등을 가집니다. 또한, ax 객체를 통해 x축 및 y축 라벨, 범례 상세 설정, 배경색 변경 등이 적용됩니다. 그림 하단에는 추가적인 텍스트도 표시됩니다.

예시 코드: MultiIndex 생성 및 사용

import pandas as pd
import numpy as np

# MultiIndex 생성 예시 (from_product)
arrays = [['bar', 'baz', 'foo', 'qux'], ['one', 'two']]
multi_idx = pd.MultiIndex.from_product(arrays, names=['first', 'second'])
s_multi = pd.Series(np.random.randn(8), index=multi_idx)
print("Series with MultiIndex:\n", s_multi)

print("\nMultiIndex에서 'bar' 그룹 선택:\n", s_multi.loc['bar'])
print("\nMultiIndex에서 ('baz', 'one') 선택:\n", s_multi.loc[('baz', 'one')])

# stack() / unstack() 예시
df_for_stack = pd.DataFrame(np.arange(6).reshape((2, 3)),
                            index=pd.Index(['A', 'B'], name='row_idx'),
                            columns=pd.Index(['X', 'Y', 'Z'], name='col_idx'))
print("\n원본 DataFrame for stack/unstack:\n", df_for_stack)
stacked_df = df_for_stack.stack()
print("\nStacked DataFrame (열 -> 행 인덱스):\n", stacked_df)
print("\nUnstacked DataFrame (다시 원래대로):\n", stacked_df.unstack())

예상 결과 (randn 부분은 실행 시마다 다름):

Series with MultiIndex:
first  second
bar    one       0.123456
       two      -0.567890
baz    one       1.122334
       two      -0.987654
foo    one       0.456789
       two       0.012345
qux    one      -1.543210
       two       0.678901
dtype: float64

MultiIndex에서 'bar' 그룹 선택:
second
one    0.123456
two   -0.567890
dtype: float64

MultiIndex에서 ('baz', 'one') 선택:
1.122334...

원본 DataFrame for stack/unstack:
col_idx  X  Y  Z
row_idx         
A        0  1  2
B        3  4  5

Stacked DataFrame (열 -> 행 인덱스):
row_idx  col_idx
A        X          0
         Y          1
         Z          2
B        X          3
         Y          4
         Z          5
dtype: int...

Unstacked DataFrame (다시 원래대로):
col_idx  X  Y  Z
row_idx         
A        0  1  2
B        3  4  5

예시 코드:

sizes = pd.Series(['S', 'M', 'L', 'XL', 'S', 'M', 'M', 'XL', 'L', 'S'])
print("원본 Series (object type):\n", sizes)
print("Memory usage (object):", sizes.memory_usage(deep=True))

# Categorical 타입으로 변환
size_cat = sizes.astype('category')
print("\nCategorical Series:\n", size_cat)
print("Memory usage (category):", size_cat.memory_usage(deep=True))
print("Categories:", size_cat.cat.categories)
print("Codes:", size_cat.cat.codes)

# 순서 있는 Categorical 타입
ordered_size_cat = pd.Categorical(sizes, categories=['S', 'M', 'L', 'XL'], ordered=True)
print("\nOrdered Categorical Series:\n", ordered_size_cat)
print("Is ordered:", ordered_size_cat.ordered)
print("Sorted (ordered):\n", pd.Series(ordered_size_cat).sort_values())

예상 결과:

원본 Series (object type):
0     S
1     M
2     L
3    XL
4     S
5     M
6     M
7    XL
8     L
9     S
dtype: object
Memory usage (object): ... (문자열 길이에 따라 다름, 상대적으로 큼)

Categorical Series:
0     S
1     M
2     L
3    XL
4     S
5     M
6     M
7    XL
8     L
9     S
dtype: category
Categories (4, object): ['L', 'M', 'S', 'XL']
Memory usage (category): ... (상대적으로 작음)
Categories: Index(['L', 'M', 'S', 'XL'], dtype='object')
Codes: [2 1 0 3 2 1 1 3 0 2]

Ordered Categorical Series:
['S', 'M', 'L', 'XL', 'S', 'M', 'M', 'XL', 'L', 'S']
Categories (4, object): ['S' < 'M' < 'L' < 'XL']
Is ordered: True
Sorted (ordered):
0     S
4     S
9     S
1     M
5     M
6     M
2     L
8     L
3    XL
7    XL
dtype: category

예시 코드: 데이터 타입 변경으로 메모리 절약

df_mem = pd.DataFrame({'col_int': np.random.randint(0, 100, size=1000000),
                                   'col_float': np.random.rand(1000000)})
print("기본 데이터 타입 메모리 사용량:\n", df_mem.memory_usage(deep=True).sum(), "bytes")

df_mem['col_int'] = df_mem['col_int'].astype('int16') # 값의 범위가 int16에 맞는지 확인 필요
df_mem['col_float'] = df_mem['col_float'].astype('float32')
print("데이터 타입 변경 후 메모리 사용량:\n", df_mem.memory_usage(deep=True).sum(), "bytes")

예상 결과:

기본 데이터 타입 메모리 사용량:
 16000128 bytes  (예시 값, 실제로는 더 클 수 있음)
데이터 타입 변경 후 메모리 사용량:
 6000128 bytes (예시 값,显著减少)

예시 코드:

# 현재 설정 확인 (예시)
print("현재 display.max_rows:", pd.get_option("display.max_rows"))
print("현재 display.max_columns:", pd.get_option("display.max_columns"))

# 설정 변경
pd.set_option("display.max_rows", 10)
pd.set_option("display.max_columns", 5)
pd.set_option("display.precision", 2) # 소수점 2자리까지

df_display_test = pd.DataFrame(np.random.rand(12, 6), columns=[f'Col{i}' for i in range(6)])
print("\n변경된 설정으로 DataFrame 출력:\n", df_display_test)

# 설정 원래대로 되돌리기 (또는 특정 값으로 재설정)
pd.reset_option("display.max_rows")
pd.reset_option("all") # 모든 옵션 초기화 (주의해서 사용)
# pd.set_option("display.max_rows", 60) # 원래 기본값으로

예상 결과 (randn 부분은 실행 시마다 다름):

현재 display.max_rows: 60
현재 display.max_columns: 20

변경된 설정으로 DataFrame 출력:
     Col0  Col1  Col2  Col3  Col4   ...
0    0.12  0.34  0.56  0.78  0.90   ...
1    0.23  0.45  0.67  0.89  0.01   ...
2    0.34  0.56  0.78  0.90  0.12   ...
3    0.45  0.67  0.89  0.01  0.23   ...
4    0.56  0.78  0.90  0.12  0.34   ...
..    ...   ...   ...   ...   ...   ... # 중간 생략 표시 (총 12행이지만 max_rows=10)
7    0.78  0.90  0.12  0.34  0.56   ...
8    0.89  0.01  0.23  0.45  0.67   ...
9    0.90  0.12  0.34  0.56  0.78   ...
10   0.01  0.23  0.45  0.67  0.89   ...
11   0.12  0.34  0.56  0.78  0.90   ...

[12 rows x 6 columns]  (max_columns=5 설정으로 실제 열은 6개지만 ...로 표시될 수 있음)