Seaborn은 Matplotlib을 기반으로 한 고급 시각화 라이브러리로, 통계적 그래프를 쉽게 생성할 수 있도록 설계됨. 기본적으로 데이터프레임과 잘 연동되며, 다양한 스타일과 색상 테마를 제공함.

1. Seaborn 기본 설정

Seaborn을 사용하기 위해 먼저 라이브러리를 불러오고, 기본 스타일을 설정할 수 있음.

import seaborn as sns
import matplotlib.pyplot as plt

# Seaborn 스타일 설정
sns.set_style("whitegrid")  # 스타일 변경 가능: "darkgrid", "white", "ticks" 등

# 샘플 데이터 로드
df = sns.load_dataset("tips")  # Seaborn 제공 예제 데이터셋

2. 주요 그래프 유형

● 분포 시각화 (Distribution Plots)

• 히스토그램(histogram)과 KDE(Kernel Density Estimation)를 사용하여 데이터의 분포를 시각화할 수 있음.
• bins 옵션을 사용하여 막대의 개수를 조절할 수 있으며, kde=True를 설정하면 밀도 그래프도 함께 표시됨.

히스토그램 (Histogram)

import numpy as np
np.random.seed(42)
data = np.random.randn(1000)  # 정규 분포를 따르는 랜덤 데이터 생성

# 히스토그램 & KDE
sns.histplot(data, bins=30, kde=True, color='blue')
plt.title("Histogram with KDE")
plt.xlabel("Value")
plt.ylabel("Frequency")
plt.show()

커널 밀도 추정(KDE) 그래프

sns.kdeplot(data, shade=True, color='red')
plt.title("Kernel Density Estimation (KDE) Plot")
plt.xlabel("Value")
plt.ylabel("Density")
plt.show()

● 관계 시각화 (Relational Plots)

• 두 변수 간 관계를 표현하는 그래프
• scatterplot()은 산점도를 그리며, lineplot()은 선 그래프를 그림.

산점도 (Scatter Plot)

# 산점도를 활용하여 total_bill과 tip의 관계를 시각화
sns.scatterplot(data=df, x="total_bill", y="tip", hue="sex", style="sex")
plt.title("Scatter Plot of Total Bill vs. Tip")
plt.xlabel("Total Bill ($)")
plt.ylabel("Tip ($)")
plt.show()

선 그래프 (Line Plot)

# total_bill의 평균값을 선 그래프로 표현
sns.lineplot(data=df, x="size", y="total_bill", ci=None)
plt.title("Line Plot of Total Bill by Party Size")
plt.xlabel("Party Size")
plt.ylabel("Total Bill ($)")
plt.show()

● 범주형 데이터 시각화 (Categorical Plots)

• barplot(), boxplot(), violinplot() 등 범주형 변수에 대한 다양한 시각화 제공

박스 플롯 (Box Plot)

sns.boxplot(data=df, x="day", y="total_bill", hue="sex")
plt.title("Box Plot of Total Bill by Day")
plt.xlabel("Day of the Week")
plt.ylabel("Total Bill ($)")
plt.legend(title="Sex")
plt.show()

바이올린 플롯 (Violin Plot)

sns.violinplot(data=df, x="day", y="total_bill", hue="sex", split=True)
plt.title("Violin Plot of Total Bill by Day")
plt.xlabel("Day of the Week")
plt.ylabel("Total Bill ($)")
plt.legend(title="Sex")
plt.show()

● 행렬 시각화 (Matrix Plots)

• heatmap()을 이용하여 데이터의 상관관계 또는 특정 행렬 데이터를 시각화 가능
• annot=True 옵션을 사용하면 값이 표시됨.

히트맵 (Heatmap)

# 상관행렬 계산
corr = df.corr()

# 히트맵 생성
sns.heatmap(corr, annot=True, cmap="coolwarm", fmt=".2f")
plt.title("Heatmap of Correlation Matrix")
plt.show()

● 다변수 시각화 (Multivariate Visualization)

• 여러 변수 간 관계를 한 번에 표현할 수 있는 pairplot()과 FacetGrid() 제공

페어플롯 (Pairplot)

sns.pairplot(df, hue="sex", diag_kind="kde")
plt.show()

페이싯 그리드 (FacetGrid)

g = sns.FacetGrid(df, col="sex", row="time", margin_titles=True)
g.map_dataframe(sns.scatterplot, x="total_bill", y="tip")
g.set_axis_labels("Total Bill ($)", "Tip ($)")
plt.show()

3. Seaborn 고급 기능

● 스타일과 색상 조정

Seaborn은 다양한 스타일과 색상 테마를 제공하여 시각화를 더욱 미적으로 만들 수 있음.

sns.set_style("darkgrid")  # 스타일 변경 가능: "whitegrid", "dark", "white", "ticks"
sns.set_palette("pastel")  # 색상 테마 설정 가능: "deep", "muted", "bright", "pastel", "dark"

● 범례 및 제목 설정

그래프의 제목과 범례를 추가하여 가독성을 높일 수 있음.

ax = sns.scatterplot(data=df, x="total_bill", y="tip", hue="sex", style="sex")
ax.set_title("Total Bill vs. Tip by Gender")
ax.legend(title="Gender")
plt.xlabel("Total Bill ($)")
plt.ylabel("Tip ($)")
plt.show()

판다스는 matplotlib과 연동하여 데이터를 쉽게 시각화할 수 있는 기능을 제공함. plot() 메서드를 사용하여 다양한 그래프를 그릴 수 있으며, 데이터의 유형에 따라 적절한 그래프를 선택하여 시각화를 수행함.

1. 시리즈(Series) 시각화

시리즈(Series)는 1차원 데이터 구조로, 시간에 따른 값의 변화나 특정 변수의 값을 표현하는 데 유용함.

● 선 그래프 (Line Plot)

• Series.plot()을 사용하여 간단한 선 그래프를 그릴 수 있음.
• 기본적으로 x축은 인덱스, y축은 값이 됨.
• marker 옵션을 추가하여 점을 강조할 수도 있음.

import pandas as pd
import matplotlib.pyplot as plt

s = pd.Series([1, 3, 2, 5, 7, 8], index=['A', 'B', 'C', 'D', 'E', 'F'])
s.plot(marker='o', linestyle='-')
plt.title("Series Line Plot")  # 그래프 제목 추가
plt.xlabel("Index")  # x축 라벨
plt.ylabel("Values")  # y축 라벨
plt.grid(True)  # 격자 추가
plt.show()

● 막대 그래프 (Bar Plot)

• kind='bar' 옵션을 사용하여 막대 그래프를 생성할 수 있음.
• 색상을 지정할 수 있으며, rot 옵션을 사용하여 x축 라벨 회전 가능.

s.plot(kind='bar', color='skyblue', rot=0)
plt.title("Series Bar Plot")
plt.xlabel("Categories")
plt.ylabel("Values")
plt.show()

2. 데이터프레임(DataFrame) 시각화

데이터프레임(DataFrame)은 2차원 데이터 구조로 여러 개의 열(column)과 행(row)으로 구성됨. 여러 변수의 값을 비교할 때 사용됨.

● 선 그래프 (Line Plot)

• 여러 열을 한 번에 선 그래프로 나타낼 수 있음.
• 스타일을 변경하여 선 모양을 조정 가능.

df = pd.DataFrame({
    'A': [1, 3, 2, 4],
    'B': [2, 4, 5, 7]
}, index=['Q1', 'Q2', 'Q3', 'Q4'])

df.plot(marker='o', linestyle='-')
plt.title("DataFrame Line Plot")
plt.xlabel("Quarter")
plt.ylabel("Values")
plt.grid(True)
plt.show()

● 막대 그래프 (Bar Plot)

• 데이터프레임에서도 kind='bar' 옵션을 사용하여 막대 그래프를 만들 수 있음.

df.plot(kind='bar', color=['blue', 'orange'])
plt.title("DataFrame Bar Plot")
plt.xlabel("Quarter")
plt.ylabel("Values")
plt.legend(title="Categories")
plt.show()

● 누적 막대 그래프 (Stacked Bar Plot)

• stacked=True 옵션을 사용하여 누적 막대 그래프를 생성할 수 있음.

df.plot(kind='bar', stacked=True, color=['blue', 'orange'])
plt.title("Stacked Bar Plot")
plt.xlabel("Quarter")
plt.ylabel("Total Values")
plt.legend(title="Categories")
plt.show()

● 그래프 스타일 변환

• style 옵션을 활용하여 선 스타일을 변경할 수 있음.
• '-', '--', ':', '-.' 등의 스타일을 조합할 수 있음.

df.plot(style=['--', 'o-'])
plt.title("Styled Line Plot")
plt.xlabel("Quarter")
plt.ylabel("Values")
plt.grid(True)
plt.show()

● 히스토그램 (Histogram)

• 연속형 데이터의 분포를 확인하는 데 유용함.
• bins 옵션을 통해 구간 개수를 조정할 수 있음.

df.hist(bins=5, color='lightblue', edgecolor='black')
plt.title("Histogram Plot")
plt.xlabel("Value Ranges")
plt.ylabel("Frequency")
plt.show()

● 산점도 (Scatter Plot)

• 두 개의 변수 간 관계를 나타낼 때 사용.

df.plot(kind='scatter', x='A', y='B', color='red')
plt.title("Scatter Plot")
plt.xlabel("A Values")
plt.ylabel("B Values")
plt.show()

3. 주석 추가 (Annotations)

• plt.text()를 사용하여 그래프 위에 주석을 추가할 수 있음.
• arrowprops를 사용하면 화살표 표시 가능.

ax = df.plot(marker='o')
plt.text(1, 3, 'Peak Point', fontsize=12, color='red')  # (x, y) 위치에 텍스트 추가
plt.annotate('Max Value', xy=(3, 7), xytext=(2, 6), 
             arrowprops=dict(facecolor='black', arrowstyle='->'))  # 화살표 추가
plt.show()

1. matplotlib.pyplot

• matplotlib.pyplot은 파이썬에서 그래프를 그릴 때 사용하는 가장 기본적인 라이브러리 중 하나임.
• MATLAB의 plot() 함수와 유사하게 작동하며, 간단한 명령어로 다양한 시각화를 구현할 수 있음.
• 그래프를 그리는 기본적인 흐름은 다음과 같음:
  1. import matplotlib.pyplot as plt로 라이브러리를 불러오기
  2. 데이터를 준비하기
  3. plt.plot() 등의 함수를 이용해 그래프를 생성하기
  4. plt.show()를 이용해 그래프를 화면에 출력하기

import matplotlib.pyplot as plt

2. 기본적인 그래프 그리기

• 가장 기본적인 라인 플롯(line plot) 그리는 방법

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]  # x축 값
y = [10, 20, 25, 30, 50]  # y축 값

plt.plot(x, y)  # x축과 y축 데이터를 연결하여 그래프 생성
plt.show()  # 그래프 출력

• plt.plot(x, y): x축과 y축 데이터를 연결하여 선 그래프를 그림.
• plt.show(): 생성된 그래프를 화면에 표시.

위 코드를 실행하면 x축 값 [1, 2, 3, 4, 5]와 y축 값 [10, 20, 25, 30, 50]을 가진 선 그래프가 출력됨.

3. 그래프 제목, 축 레이블, 범례 추가하기

• 그래프의 가독성을 높이기 위해 제목, 축 레이블, 범례를 추가할 수 있음.

plt.plot(x, y, label='Line Graph')  # 그래프에 라벨 추가
plt.xlabel('X 축')  # X축 이름
plt.ylabel('Y 축')  # Y축 이름
plt.title('기본 그래프')  # 그래프 제목
plt.legend()  # 범례 표시
plt.show()

• plt.xlabel(), plt.ylabel(): x축과 y축에 설명을 추가.
• plt.title(): 그래프 제목을 설정.
• plt.legend(): 그래프의 라벨을 표시하여 범례를 추가.

4. 마커(marker)와 선 스타일 변경하기

plt.plot(x, y, marker='o', linestyle='--', color='r', label='데이터')
plt.legend()
plt.show()

• marker='o': 데이터 포인트를 동그라미로 표시.
• linestyle='--': 점선 스타일 적용.
• color='r': 선의 색상을 빨간색으로 지정.

이 코드를 실행하면 점선 스타일의 빨간색 그래프가 출력되며, 데이터 포인트는 동그라미로 표시됨.

5. 여러 개의 그래프 그리기

• 한 개의 그래프에서 여러 개의 선을 그릴 수도 있음.

x2 = [1, 2, 3, 4, 5]
y2 = [5, 15, 20, 25, 35]

plt.plot(x, y, label='라인1', color='blue')
plt.plot(x2, y2, label='라인2', color='green')
plt.legend()
plt.show()

• plt.plot()을 여러 번 사용하면 한 그래프에 여러 개의 선을 표시할 수 있음.
• 각각의 label을 다르게 지정하여 범례를 활용 가능.

6. 바 그래프 (Bar Chart)

categories = ['A', 'B', 'C', 'D']
values = [10, 20, 15, 25]

plt.bar(categories, values, color='purple')
plt.xlabel('카테고리')
plt.ylabel('값')
plt.title('바 그래프')
plt.show()

• plt.bar()를 사용하여 바 그래프를 생성.
• 카테고리별 데이터를 시각적으로 비교할 때 유용함.

7. 히스토그램 (Histogram)

import numpy as np

# 난수 생성
np.random.seed(42)
data = np.random.randn(1000)

plt.hist(data, bins=30, color='skyblue', edgecolor='black')
plt.xlabel('값')
plt.ylabel('빈도')
plt.title('히스토그램')
plt.show()

• plt.hist(): 데이터의 분포를 나타내는 히스토그램을 생성.
• bins=30: 30개의 구간으로 나누어 표현.
• color='skyblue', edgecolor='black': 막대의 색상을 설정.

8. 산점도 (Scatter Plot)

x = np.random.rand(50)
y = np.random.rand(50)

plt.scatter(x, y, color='red')
plt.xlabel('X 값')
plt.ylabel('Y 값')
plt.title('산점도')
plt.show()

• plt.scatter(): 개별 데이터 포인트를 표시하는 산점도를 그림.
• 데이터 간의 관계를 시각화할 때 유용함.

9. 파이 차트 (Pie Chart)

labels = ['A', 'B', 'C', 'D']
sizes = [15, 30, 45, 10]
colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue']

plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=140)
plt.title('파이 차트')
plt.show()

• plt.pie(): 원형 그래프를 생성하여 각 데이터 비율을 시각적으로 표현.
• autopct='%1.1f%%': 비율을 소수점 1자리까지 표시.

10. 서브플롯 (Subplot)

• 여러 개의 그래프를 한 화면에 배치할 수 있음.

fig, axs = plt.subplots(2, 2, figsize=(10, 10))

axs[0, 0].plot(x, y, color='blue')
axs[0, 0].set_title('라인 플롯')

axs[0, 1].bar(categories, values, color='purple')
axs[0, 1].set_title('바 그래프')

axs[1, 0].scatter(x, y, color='red')
axs[1, 0].set_title('산점도')

axs[1, 1].hist(data, bins=30, color='skyblue')
axs[1, 1].set_title('히스토그램')

plt.tight_layout()
plt.show()

plt.subplots()를 활용하면 여러 개의 그래프를 한 화면에 구성할 수 있음.

1. 집계 함수 (그룹화 집계 메소드)

• 그룹화된 데이터에서 다양한 통계량을 계산할 때 사용됨.
• 대표적인 집계 함수들은 아래와 같음.

import pandas as pd

df = pd.DataFrame({'A': ['foo', 'foo', 'bar', 'bar'],
                   'B': [1, 2, 3, 4]})

grouped = df.groupby('A').sum()
print(grouped)
# 출력
#        B
# A
# bar    7
# foo    3

2. 사용자 정의 집계 함수

• 기본 제공 집계 함수 외에도 사용자가 직접 함수를 정의하여 적용 가능함.
• agg() 또는 apply()를 활용하여 특정 연산 수행 가능함.

def custom_function(x):
    return x.max() - x.min()

grouped = df.groupby('A')['B'].agg(custom_function)
print(grouped)
# 출력
# A
# bar    1
# foo    1

3. 비집계 함수

• 데이터 변환에 사용되는 함수로, 그룹별 특정 연산을 수행하지만 전체를 하나의 값으로 줄이지 않음.
• .transform()을 사용하면 원래 데이터의 형태를 유지하면서 그룹별 연산을 적용 가능함.

df['B_normalized'] = df.groupby('A')['B'].transform(lambda x: (x - x.mean()) / x.std())
print(df)
# 출력
#      A  B  B_normalized
# 0  foo  1          -1.0
# 1  foo  2           1.0
# 2  bar  3          -1.0
# 3  bar  4           1.0

4. 열별로 여러 함수 적용하기

• 여러 개의 집계 함수를 한 번에 적용할 수 있음.

df.groupby('A').agg({'B': ['sum', 'mean', 'std']})
# 출력
#          B
#        sum mean  std
# A
# bar     7  3.5  0.7071
# foo     3  1.5  0.7071

5. apply() - 다목적 데이터 집계

• 그룹화 후 특정 연산을 수행하여 데이터 변환이 가능함.

df.groupby('A').apply(lambda x: x.sort_values('B', ascending=False))

6. 그룹키 제거

• group_keys=False 옵션을 주면 그룹화된 데이터에서 키를 제거하고 원래 형태를 유지할 수 있음.

df.groupby('A', group_keys=False).apply(lambda x: x.head(1))

7. 분위와 구간 분석

• qcut()을 사용하여 데이터를 분위수 기준으로 나눌 수 있음.

df['quantile'] = pd.qcut(df['B'], q=4)
print(df)

8. 그룹별 결측치 채우기

• 그룹별 평균값으로 결측치를 채울 수 있음.

df.groupby('A').apply(lambda x: x.fillna(x.mean()))

9. 무작위 샘플링

• sample()을 사용하여 그룹별 샘플을 선택할 수 있음.

df.groupby('A').apply(lambda x: x.sample(n=1))

10. 그룹별 가중치 합

• 특정 열을 가중치로 사용하여 그룹별 합계를 계산할 수 있음.

df.groupby('A').apply(lambda x: (x['B'] * x['B']).sum())

11. 그룹 단위 선형회귀

• 그룹별로 선형회귀를 수행할 수 있음.

from sklearn.linear_model import LinearRegression

def lin_reg(df):
    model = LinearRegression()
    X = df[['B']]
    y = df['B']
    model.fit(X, y)
    return model.coef_[0]

df.groupby('A').apply(lin_reg)

12. 그룹 변환

• 그룹별 연산을 수행하면서 결과의 크기를 원래 데이터와 동일하게 유지할 수 있음.

df.groupby('A')['B'].transform(lambda x: x - x.mean())

13. 피벗 테이블

• 피벗 테이블을 사용하여 특정 그룹별 통계를 계산할 수 있음.

pd.pivot_table(df, values='B', index='A', aggfunc='mean')

14. Cross-Tabulations: crosstab

• 교차 테이블을 사용하여 범주형 변수 간의 관계를 분석할 수 있음.

pd.crosstab(df['A'], df['B'])

1-1. 문자열 다루기에서 정규표현식이 중요한 이유

• 일반적인 문자열 처리는 split(), replace() 같은 기본 함수로 해결할 수 있지만, 복잡한 패턴을 다룰 때는 코드가 길어지고 복잡해짐.
• 정규표현식(Regex)을 사용하면 짧고 간결한 코드로 패턴을 검색하고 수정할 수 있음.

1-2. 예제 문제: 전화번호 가운데 자리 숨기기

import re

text = '''
Elice 123456-1234567 010-1234-5678
Cheshire 345678-678901 01098765432
'''

# 전화번호 패턴을 찾아 가운데 숫자를 '*'로 변경
masked_text = re.sub(r'(\d{3,4})-(\d{4})-(\d{4})', r'\1-****-\3', text)
print(masked_text)

• re.sub(pattern, replace, text): 특정 패턴을 찾아 변경하는 함수.
• (\d{3,4})-(\d{4})-(\d{4}) → 전화번호 패턴을 정의 (3~4자리 숫자)-(4자리 숫자)-(4자리 숫자)
• \1, \3 → 그룹핑을 활용해 첫 번째, 세 번째 그룹은 그대로 유지하고 두 번째 그룹만 ***로 변경.

2. 메타 문자(Meta Characters)

2-1. 메타 문자의 개념

• 특정한 의미를 가지는 특수 기호로, 정규표현식을 구성하는 중요한 요소.
• 특정 패턴을 빠르게 찾을 수 있도록 도와줌.

2-2. 주요 메타 문자

2-3. 메타 문자 예제

import re

text = "apple banana orange"
pattern = r"b.n"

match = re.findall(pattern, text)
print(match)  # ['ban']

• b.n → b와 n 사이에 아무 문자나 하나 있는 단어 찾기

3. 수량자(Quantifiers)

3-1. 수량자의 개념

• 특정 패턴이 반복되는 횟수를 지정하는 기호.
• 패턴이 몇 번 나타나는지 정의할 수 있음.

3-2. 주요 수량자

3-3. 수량자 예제

import re

text = "helloooo world!"
pattern = r"o{2,}"

match = re.findall(pattern, text)
print(match)  # ['oooo']

• o{2,} → "o"가 2개 이상 연속된 부분 찾기

4. 그룹(Grouping) 활용

4-1. 그룹의 개념

• ()를 사용해 하나의 패턴을 그룹으로 묶을 수 있음.
• |(OR)와 함께 사용 가능.
• 그룹핑을 하면 재사용이 가능함.

4-2. 그룹을 활용한 패턴 예제

import re

text = "elice alice tomato potato"
pattern = r"(e|a)lice"

match = re.findall(pattern, text)
print(match)  # ['e', 'a']

• (e|a)lice → elice, alice 둘 다 찾을 수 있음.

4-3. 그룹 재사용 예제

import re

text = "tomato potato"
pattern = r"(to)ma\\1"

match = re.findall(pattern, text)
print(match)  # ['to']

• (to)를 그룹으로 저장하고, 뒤에서 \\1로 재사용 가능.

• 모듈(Module): 관련된 변수, 함수, 클래스를 포함하는 파이썬 파일 (.py 확장자)
• 모듈을 사용하는 이유: 코드 재사용, 유지보수 용이, 기능 분리
• 기본 공식

import 모듈이름  # 전체 모듈 가져오기
from 모듈이름 import 함수/변수/클래스  # 특정 기능만 가져오기

1-1. import 사용하기

• import를 사용하면 모듈 전체를 가져올 수 있음.
• 모듈명을 앞에 붙여야 함 (모듈명.함수명 형식)

import math  # math 모듈 가져오기
print(math.sqrt(16))  # 4.0 (제곱근 계산)

1-2. from ~ import 사용하기

• 특정 함수나 변수만 가져와서 사용할 수 있음.
• 모듈명을 붙이지 않아도 됨.

from math import sqrt
print(sqrt(25))  # 5.0 (math.sqrt 대신 sqrt 사용 가능)

1-3. as 별칭 사용하기

• 모듈명이 길거나 자주 사용할 경우 별칭을 지정할 수 있음.

import numpy as np  # numpy 모듈을 np로 사용
array = np.array([1, 2, 3])
print(array)  # [1 2 3]

2. random 모듈

• 난수(랜덤한 숫자) 생성을 위한 모듈
• 프로그램에서 무작위 값을 사용할 때 유용함.

2-1. random.randint(a, b) - 지정 범위의 정수 반환

import random
num = random.randint(1, 10)  # 1~10 사이 정수 반환
print(num)  # 예: 7

2-2. random.choice(리스트) - 리스트에서 랜덤 선택

• 리스트에서 무작위 요소를 선택할 때 사용

options = ['가위', '바위', '보']
choice = random.choice(options)
print(choice)  # 무작위로 '가위', '바위', '보' 중 하나 출력

2-3. random.shuffle(리스트) - 리스트 요소 섞기

• 리스트 내부 요소들의 순서를 랜덤하게 변경

cards = [1, 2, 3, 4, 5]
random.shuffle(cards)
print(cards)  # 리스트 순서 랜덤하게 변경됨

3. 패키지

• 패키지(Package): 여러 모듈을 포함하는 디렉토리 (폴더)
• 패키지는 모듈을 체계적으로 관리하는 역할을 함.
• 패키지 구조 예시

my_package/    # 패키지 폴더
  ├── __init__.py  # 패키지를 인식하도록 하는 파일
  ├── module1.py   # 모듈 1
  ├── module2.py   # 모듈 2

• __init__.py 파일이 있어야 해당 폴더가 패키지로 인식됨.

3-1. 패키지 사용하기

from my_package import module1
module1.hello()  # module1.py의 hello 함수 실행

4. 그외 모듈

4-1. os 모듈 예제

• 현재 작업 디렉토리를 확인하는 방법

import os
print(os.getcwd())  # 현재 작업 디렉토리 출력

4-2. datetime 모듈 예제

• 현재 날짜 및 시간을 가져오기

import datetime
now = datetime.datetime.now()
print(now)  # 현재 날짜와 시간 출력

• 부모 클래스의 메소드를 자식 클래스에서 다시 정의(재정의) 하는 것.
• 같은 이름의 메소드를 새롭게 구현하여 동작을 변경할 수 있음.
• 상속을 사용할 때, 부모 클래스의 기본 기능을 유지하면서 일부 동작을 변경하고 싶을 때 사용됨.

1-1. 기본 공식

class 부모클래스:
    def 메소드(self):
        동작

class 자식클래스(부모클래스):
    def 메소드(self):  # 부모 메소드를 재정의 (오버라이딩)
        새로운 동작

1-2. 예제

class Animal:
    def sound(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def sound(self):  # 부모 클래스의 sound 메소드를 재정의
        print("멍멍!")

animal = Animal()
animal.sound()  # 동물이 소리를 냅니다.

dog = Dog()
dog.sound()  # 멍멍!

• Dog 클래스에서 sound 메소드를 재정의하여, 원래의 동물 소리 대신 강아지 소리가 출력됨.

2. pass 키워드

• 코드를 비워둘 때 사용 (아직 구현하지 않은 부분을 임시로 작성할 때 유용).
• 문법적으로 코드가 있어야 하지만, 실행할 내용이 없을 때 사용됨.

2-1. 기본 공식

class 클래스이름:
    pass  # 클래스가 비어 있어도 오류 발생하지 않음

2-2. 예제

class Bird:
    def fly(self):
        pass  # 아직 구현하지 않은 메소드

• pass를 사용하면 나중에 구현할 코드의 자리를 미리 만들어둘 수 있음.

3. 예외 처리 (try-except)

• 프로그램 실행 중 오류(예외)가 발생해도 멈추지 않고 처리할 수 있도록 하는 방법.
• 예외가 발생하면 except 블록이 실행되어 프로그램이 멈추지 않고 계속 실행될 수 있음.

3-1. 기본 공식

try:
    실행할 코드
except 예외종류:
    예외 발생 시 실행할 코드

3-2. 예제

try:
    x = 10 / 0  # 0으로 나누기 (오류 발생)
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다!")

출력:

0으로 나눌 수 없습니다!

• 10 / 0 연산은 ZeroDivisionError 예외를 발생시키므로 except 블록이 실행됨.

4. try-except-else-finally

• else: 예외가 발생하지 않을 때 실행.
• finally: 예외 발생 여부와 관계없이 무조건 실행.

4-1. 기본 공식

try:
    실행할 코드
except 예외종류:
    예외 발생 시 실행할 코드
else:
    예외가 발생하지 않았을 때 실행할 코드
finally:
    항상 실행할 코드

4-2. 예제

try:
    num = int(input("숫자를 입력하세요: "))
    result = 10 / num
except ValueError:
    print("숫자가 아닙니다!")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다!")
else:
    print("결과:", result)
finally:
    print("프로그램 종료")

입력값 예시 1: 2

결과: 5.0
프로그램 종료

입력값 예시 2: 0

0으로 나눌 수 없습니다!
프로그램 종료

입력값 예시 3: a

숫자가 아닙니다!
프로그램 종료

• else는 예외가 발생하지 않은 경우 실행됨.
• finally는 어떤 경우에도 실행됨.

5. 에러 종류

5-1. 예제

try:
    my_list = [1, 2, 3]
    print(my_list[5])  # 리스트 범위 초과 (IndexError 발생)
except IndexError:
    print("인덱스 범위를 벗어났습니다!")

출력:

인덱스 범위를 벗어났습니다!

• my_list[5]는 존재하지 않는 인덱스를 참조하기 때문에 IndexError가 발생하여 except 블록이 실행됨.

• 클래스(Class)는 객체(Object)를 생성하기 위한 설계도 또는 틀.
• 클래스 안에는 변수(속성)와 함수(메소드)가 포함됨.
• 객체는 클래스를 기반으로 만들어지는 실제 데이터가 담긴 실체.

1-1. 기본 공식

class 클래스이름:
    def __init__(self):
        # 생성자 (객체가 생성될 때 자동 실행)
        pass

1-2. 예제

class Person:
    def __init__(self, name, age):
        self.name = name  # 멤버 변수
        self.age = age

person1 = Person("공주", 20)  # 객체 생성
print(person1.name, person1.age)  # 공주 20

2. __init__ (생성자)

• 객체가 생성될 때 자동으로 실행되는 메소드.
• 주로 초기값을 설정하는 역할.

2-1. 기본 공식

class 클래스이름:
    def __init__(self, 매개변수):
        self.변수 = 매개변수

2-2. 예제

class Animal:
    def __init__(self, species):
        self.species = species  # 멤버 변수 설정

animal = Animal("고양이")
print(animal.species)  # 고양이

3. 멤버 변수

• 클래스 내부에서 선언된 변수로, 객체의 속성을 저장.
• self.변수명 형식으로 사용.

3-1. 기본 공식

class 클래스이름:
    def __init__(self, 값):
        self.변수명 = 값

3-2. 예제

class Car:
    def __init__(self, brand):
        self.brand = brand

car1 = Car("Hyundai")
print(car1.brand)  # Hyundai

4. 메소드

• 클래스 내부에서 정의된 함수로, 객체의 동작을 정의함.

4-1. 기본 공식

class 클래스이름:
    def 메소드이름(self):
        동작

4-2. 예제

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(self.name, "가 멍멍!")

dog1 = Dog("초코")
dog1.bark()  # 초코 가 멍멍!

5. self

• 클래스 내부에서 객체 자기 자신을 가리키는 키워드.
• 멤버 변수와 메소드를 호출할 때 반드시 사용.

5-1. 기본 공식

class 클래스이름:
    def 메소드(self):
        print(self.변수명)

5-2. 예제

class Cat:
    def __init__(self, name):
        self.name = name

    def meow(self):
        print(self.name, "야옹!")

cat1 = Cat("나비")
cat1.meow()  # 나비 야옹!

6. 상속 (Inheritance)

• 기존 클래스를 확장하여 새로운 클래스를 만드는 개념.
• 코드 재사용성이 높아짐.

6-1. 기본 공식

class 부모클래스:
    pass

class 자식클래스(부모클래스):
    pass

6-2. 예제

class Animal:
    def sound(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def bark(self):
        print("멍멍!")

dog = Dog()
dog.sound()  # 동물이 소리를 냅니다.
dog.bark()   # 멍멍!

7. super()

• 부모 클래스의 기능을 자식 클래스에서 호출할 때 사용.

7-1. 기본 공식

class 부모클래스:
    def __init__(self, 값):
        self.변수 = 값

class 자식클래스(부모클래스):
    def __init__(self, 값):
        super().__init__(값)

7-2. 예제

class Parent:
    def __init__(self, name):
        self.name = name

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

child = Child("공주", 10)
print(child.name, child.age)  # 공주 10

8. 다중 상속

• 두 개 이상의 부모 클래스를 상속받는 것.

8-1. 기본 공식

class 부모클래스1:
    pass

class 부모클래스2:
    pass

class 자식클래스(부모클래스1, 부모클래스2):
    pass

8-2. 예제

class Flyer:
    def fly(self):
        print("날 수 있습니다!")

class Swimmer:
    def swim(self):
        print("수영할 수 있습니다!")

class Duck(Flyer, Swimmer):
    pass

duck = Duck()
duck.fly()  # 날 수 있습니다!
duck.swim()  # 수영할 수 있습니다!

1-1. 기본 개념

• 사용자가 키보드로 입력한 값을 프로그램에서 받을 때 사용.
• 항상 문자열(str) 타입으로 반환됨.

기본 공식

변수 = input("입력 안내 문구")

예제

name = input("이름을 입력하세요: ")
print("안녕하세요,", name, "님!")  # 예: 이름이 '공주'라면 '안녕하세요, 공주 님!' 출력

1-2. 숫자 입력 받기

• input()은 문자열을 반환하므로, 숫자로 사용하려면 형 변환이 필요함.

기본 공식

변수 = 데이터타입(input("입력 안내 문구"))

예제

age = int(input("나이를 입력하세요: "))
print("내년 나이는", age + 1, "살입니다.")  # 입력값이 25라면 '내년 나이는 26살입니다.' 출력

2. 파일 입출력 (open())

2-1. open() 함수 개요

• 파일을 열고 조작할 수 있도록 해줌.

기본 공식

파일객체 = open(파일명, 열기모드, encoding="인코딩")

예제

file = open("example.txt", "w", encoding="utf-8")
file.write("파일 테스트입니다.\n")
file.close()

2-2. 열기 모드

3. 파일 쓰기

3-1. 기본 파일 쓰기 (w 모드)

기본 공식

파일객체 = open(파일명, "w", encoding="인코딩")
파일객체.write(내용)
파일객체.close()

예제

file = open("example.txt", "w", encoding="utf-8")
file.write("첫 번째 줄\n")
file.write("두 번째 줄\n")
file.close()

3-2. 추가 모드 (a 모드)

기본 공식

파일객체 = open(파일명, "a", encoding="인코딩")
파일객체.write(추가할_내용)
파일객체.close()

예제

file = open("example.txt", "a", encoding="utf-8")
file.write("세 번째 줄 추가\n")
file.close()

4. 파일 읽기

4-1. 전체 읽기 (read())

기본 공식

파일객체 = open(파일명, "r", encoding="인코딩")
내용 = 파일객체.read()
파일객체.close()

예제

file = open("example.txt", "r", encoding="utf-8")
content = file.read()
print(content)
file.close()

4-2. 한 줄씩 읽기 (readline())

기본 공식

파일객체 = open(파일명, "r", encoding="인코딩")
한줄 = 파일객체.readline()
파일객체.close()

예제

file = open("example.txt", "r", encoding="utf-8")
line = file.readline()
print(line, end="")
line = file.readline()
print(line, end="")
file.close()

4-3. 모든 줄을 리스트로 읽기 (readlines())

기본 공식

파일객체 = open(파일명, "r", encoding="인코딩")
리스트 = 파일객체.readlines()
파일객체.close()

예제

file = open("example.txt", "r", encoding="utf-8")
lines = file.readlines()
for line in lines:
    print(line, end="")
file.close()

5. with문을 사용한 파일 입출력

• 파일을 열고 자동으로 닫아줌 (close() 필요 없음)

5-1. 파일 쓰기 (with 사용)

기본 공식

with open(파일명, "w", encoding="인코딩") as 파일객체:
    파일객체.write(내용)

예제

with open("example.txt", "w", encoding="utf-8") as file:
    file.write("with 문을 사용한 파일 쓰기\n")

5-2. 파일 읽기 (with 사용)

기본 공식

with open(파일명, "r", encoding="인코딩") as 파일객체:
    내용 = 파일객체.read()

예제

with open("example.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print(content)

1-1. 기본 개념

• 리스트를 빠르고 간결하게 생성하는 방법.
• 일반적인 for 문을 한 줄로 작성 가능.
• 기본 구조:

[표현식 for 변수 in 반복가능한객체 if 조건]

1-2. 기본 예제

numbers = [x for x in range(5)]
print(numbers)  # 출력: [0, 1, 2, 3, 4]

1-3. 조건문 추가

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # 출력: [0, 2, 4, 6, 8]

1-4. 중첩 반복문 사용

pairs = [(x, y) for x in range(2) for y in range(3)]
print(pairs)  # 출력: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]

2. 함수

2-1. 함수 정의

• 특정 작업을 수행하는 코드 블록.
• def 키워드를 사용하여 정의.

def hello():
    print("안녕하세요!")
hello()  # 출력: 안녕하세요!

2-2. 전달값 (매개변수)

• 함수를 호출할 때 값을 전달하여 동작을 조절할 수 있음.

def greet(name):
    print(f"안녕하세요, {name}님!")
greet("철수")  # 출력: 안녕하세요, 철수님!

2-3. 반환값

• 함수에서 값을 돌려줄 때 return 사용.

def add(a, b):
    return a + b
result = add(3, 5)
print(result)  # 출력: 8

2-4. 기본값 설정

• 매개변수에 기본값을 지정 가능.

def introduce(name, age=20):
    print(f"이름: {name}, 나이: {age}")
introduce("영희")  # 출력: 이름: 영희, 나이: 20
introduce("민수", 25)  # 출력: 이름: 민수, 나이: 25

2-5. 키워드 인자

• 매개변수 이름을 명시적으로 지정하여 전달.

def describe_pet(animal, name):
    print(f"종: {animal}, 이름: {name}")
describe_pet(name="코코", animal="강아지")  # 출력: 종: 강아지, 이름: 코코

2-6. 가변 인자 (*args)

• 여러 개의 값을 전달할 수 있음.

def sum_numbers(*numbers):
    return sum(numbers)
print(sum_numbers(1, 2, 3, 4, 5))  # 출력: 15

2-7. 지역변수와 전역변수

• 지역변수: 함수 내부에서만 사용되는 변수.
• 전역변수: 함수 바깥에서 선언된 변수로 함수 내부에서도 접근 가능.

global_var = "전역변수"

def example():
    local_var = "지역변수"
    print(global_var)  # 출력: 전역변수
    print(local_var)  # 출력: 지역변수

example()
print(global_var)  # 출력: 전역변수
# print(local_var)  # 오류 발생 (지역변수는 함수 밖에서 사용 불가)

message = "전역 변수입니다."  # 전역 변수

def example():
    message = "지역 변수입니다."  # 지역 변수 (함수 내부에서 새롭게 정의)
    print("함수 내부:", message)  # 출력: 함수 내부: 지역 변수입니다.

example()
print("함수 외부:", message)  # 출력: 함수 외부: 전역 변수입니다.

• 설명

  • message라는 변수가 함수 바깥과 안에서 각각 정의됨.
  • 함수 내부에서 message = "지역 변수입니다."라고 하면, 이 변수는 함수 안에서만 존재하는 지역 변수가 됨.
  • example()을 호출하면 지역 변수가 사용되고, 함수 호출이 끝난 후에는 여전히 전역 변수 message가 유지됨.

• global 키워드 사용

  함수 내부에서도 전역 변수 값을 변경할 수 있음.

count = 0

def increase():
    global count  # 전역 변수 수정
    count += 1
    print(count)

increase()  # 출력: 1
increase()  # 출력: 2

1-1. 기본 구조

while 조건:
    실행할 코드

• 조건이 True인 동안 반복 실행됨.
• 조건이 False가 되면 반복 종료.

예제

count = 0
while count < 5:
    print(count)  # 출력: 0, 1, 2, 3, 4
    count += 1

2. break 문

2-1. 기본 구조

while 조건:
    실행할 코드
    if 종료조건:
        break  # 반복문 즉시 종료

• break를 만나면 반복문을 즉시 빠져나감.

예제

num = 1
while num <= 10:
    if num == 5:
        break  # num이 5가 되면 종료
    print(num)  # 출력: 1, 2, 3, 4
    num += 1

3. continue 문

3-1. 기본 구조

while 조건:
    실행할 코드
    if 건너뛸조건:
        continue  # 이후 코드 실행하지 않고 다음 반복 진행

• continue를 만나면 아래 코드 실행 없이 다음 반복으로 넘어감.

예제

num = 0
while num < 5:
    num += 1
    if num == 3:
        continue  # num이 3일 때 아래 코드 건너뜀
    print(num)  # 출력: 1, 2, 4, 5

1-1. 기본 구조

if 조건:
    실행할 코드

• 조건이 True일 경우에만 실행됨.

예제

x = 10
if x > 5:
    print("x는 5보다 큽니다.")  # 출력: x는 5보다 큽니다.

1-2. else 추가

if 조건:
    실행할 코드
else:
    조건이 거짓일 때 실행할 코드

• if 조건이 False일 경우 else 블록이 실행됨.

예제

x = 3
if x > 5:
    print("x는 5보다 큽니다.")
else:
    print("x는 5 이하입니다.")  # 출력: x는 5 이하입니다.

1-3. elif 추가 (다중 조건)

if 조건1:
    실행할 코드
elif 조건2:
    실행할 코드
else:
    위 조건이 모두 거짓일 때 실행할 코드

• 여러 개의 조건을 순차적으로 비교하며, 첫 번째로 참인 조건만 실행됨.

예제

score = 75
if score >= 90:
    print("A 학점")
elif score >= 80:
    print("B 학점")
elif score >= 70:
    print("C 학점")  # 출력: C 학점
else:
    print("D 학점")

1-4. if, elif, else 혼합 예제

age = 20
if age < 13:
    print("어린이")
elif 13 <= age < 20:
    print("청소년")
else:
    print("성인")  # 출력: 성인

2. if 중첩

score = 85
if score >= 60:
    print("합격")  # 출력: 합격
    if score >= 90:
        print("우수")
    else:
        print("보통")  # 출력: 보통
else:
    print("불합격")

• if 내부에 또 다른 if를 넣을 수 있음.

3. for 반복문

3-1. 기본 구조

for 변수 in 반복가능한객체:
    실행할 코드

• 리스트, 튜플, 문자열 등 반복 가능한 객체를 순차적으로 순회함.

예제

for i in [1, 2, 3]:
    print(i)  # 출력: 1, 2, 3

3-2. range() 함수 활용

for i in range(5):  # 0부터 4까지 반복
    print(i)  # 출력: 0, 1, 2, 3, 4

3-3. range()의 다양한 사용법

for i in range(2, 10, 2):  # 2부터 9까지 2씩 증가
    print(i)  # 출력: 2, 4, 6, 8

• range(n): 0부터 n-1까지
• range(a, b): a부터 b-1까지
• range(a, b, step): a부터 b-1까지 step 간격으로

4. for 반복문 활용

4-1. 리스트

fruits = ["사과", "바나나", "체리"]
for fruit in fruits:
    print(fruit)  # 출력: 사과, 바나나, 체리

4-2. 튜플

tuple_data = (1, 2, 3)
for num in tuple_data:
    print(num)  # 출력: 1, 2, 3

4-3. 딕셔너리

scores = {"철수": 90, "영희": 85, "민수": 80}
for key, value in scores.items():
    print(f"{key}: {value}")  # 출력: 철수: 90, 영희: 85, 민수: 80

4-4. 문자열

for char in "Python":
    print(char)  # 출력: P, y, t, h, o, n

• 문자열에서 특정 기능을 수행하는 특수 문자
• \ 기호와 함께 사용됨

2. 리스트 (List)

• 여러 개의 데이터를 순서대로 저장하는 자료형
• 대괄호 []를 사용하며, 다양한 자료형을 포함 가능
• 변경(수정, 추가, 삭제) 가능

2-1. 리스트 메서드

3. 튜플 (Tuple)

• 리스트와 유사하지만 변경 불가능(immutable)
• 소괄호 ()를 사용하여 정의
• 속도가 빠르고, 변경이 필요 없는 데이터 저장에 적합

3-1. 튜플 주요 메서드

4. 세트 (Set)

• 중복을 허용하지 않는 자료형
• 중괄호 {}를 사용하여 정의 (딕셔너리와 차이점: key-value가 없음)
• 순서가 없으므로 인덱싱 불가

4-1. 세트 주요 메서드

5. 딕셔너리 (Dictionary)

• 키(key)와 값(value) 형태로 데이터를 저장하는 자료형
• 중괄호 {}를 사용하여 정의
• 키는 중복 불가, 값은 중복 가능
• 키를 통해 데이터를 빠르게 찾을 수 있음

5-1. 딕셔너리 주요 메서드

6. 자료형 비교

## 1. 자료형 변환

- 한 자료형을 다른 자료형으로 변경하는 것
- 명시적 변환(개발자가 직접 변환)과 암시적 변환(파이썬이 자동 변환)으로 나뉨

## 2. 명시적 자료형 변환

### 2-1. 정수형 변환

- `int(x)`: x를 정수형으로 변환
- 예시:

    ```python
    print(int(3.14))  # 3
    print(int("10"))  # 10

    ```


### 2-2. 실수형 변환

- `float(x)`: x를 실수형으로 변환
- 예시:

    ```python
    print(float(10))  # 10.0
    print(float("3.14"))  # 3.14

    ```


### 2-3. 문자열 변환

- `str(x)`: x를 문자열로 변환
- 예시:

    ```python
    print(str(10))  # "10"
    print(str(3.14))  # "3.14"

    ```


### 2-4. 리스트 변환

- `list(x)`: x를 리스트로 변환
- 예시:

    ```python
    print(list("hello"))  # ['h', 'e', 'l', 'l', 'o']
    print(list((1, 2, 3)))  # [1, 2, 3]

    ```


### 2-5. 튜플 변환

- `tuple(x)`: x를 튜플로 변환
- 예시:

    ```python
    print(tuple([1, 2, 3]))  # (1, 2, 3)
    print(tuple("abc"))  # ('a', 'b', 'c')

    ```


### 2-6. 세트 변환

- `set(x)`: x를 세트로 변환 (중복 제거됨)
- 예시:

    ```python
    print(set([1, 2, 2, 3]))  # {1, 2, 3}
    print(set("banana"))  # {'b', 'a', 'n'}

    ```


### 2-7. 딕셔너리 변환

- `dict(x)`: x를 딕셔너리로 변환 (키-값 쌍 필요)
- 예시:

    ```python
    print(dict([["a", 1], ["b", 2]]))  # {'a': 1, 'b': 2}
    print(dict((("x", 10), ("y", 20))))  # {'x': 10, 'y': 20}

    ```


## 3. 암시적 자료형 변환

- 파이썬이 자동으로 변환하는 경우 (작은 범위 → 큰 범위)
- 예시:

    ```python
    print(10 + 3.5)  # 13.5 (정수 → 실수 변환)
    print(True + 2)  # 3 (Boolean → 정수 변환)

    ```

• 코드의 설명을 위해 사용되며 실행되지 않음

• 한 줄 주석: # 기호 사용

  • 예: # 이것은 한 줄 주석입니다.

• 여러 줄 주석: 따옴표 세 개(''' 또는 """) 사용

  • 예:

    '''
    이것은 여러 줄 주석입니다.
    여러 줄에 걸쳐 작성할 수 있습니다.
    '''
    

2. 인덱스와 슬라이싱

2-1. 문자열 인덱싱

• 문자열에서 특정 위치의 문자에 접근하는 방법
• 인덱스는 0부터 시작하며, 음수 인덱스도 사용 가능
  • 예: s = "Python"
    • s[0] → 'P'
    • s[-1] → 'n'

2-2. 문자열 슬라이싱

• 문자열의 일부를 추출하는 방법
• [시작:끝:간격] 형태로 사용하며, 끝 인덱스는 포함되지 않음
  • 예: s = "Python"
    • s[0:4] → 'Pyth'
    • s[:3] → 'Pyt' (0부터 3 전까지)
    • s[2:] → 'thon' (2부터 끝까지)
    • s[::2] → 'Pto' (2칸씩 건너뜀)

3. 문자열 처리

• 문자열 연결: + 연산자 사용 ("Hello" + " World" → "Hello World")
• 문자열 반복: 연산자 사용 ("Hi" * 3 → "HiHiHi")
• 문자열 길이: len() 함수 사용 (len("Python") → 6)

4. 문자열 메서드

5. 문자열 포맷

• 문자열 내 변수 값을 삽입하는 방법
• 다양한 방식이 존재함

5-1. % 기호 사용

name = "Alice"
age = 25
print("이름: %s, 나이: %d" % (name, age))
# 출력: 이름: Alice, 나이: 25

5-2. format() 함수 사용

print("이름: {}, 나이: {}".format(name, age))
# 출력: 이름: Alice, 나이: 25

5-3. f-string 사용 (파이썬 3.6 이상)

print(f"이름: {name}, 나이: {age}")
# 출력: 이름: Alice, 나이: 25

1-1. 기본 자료형

• 정수형 (int): 소수점이 없는 숫자 (예: 10, -5)
• 실수형 (float): 소수점이 있는 숫자 (예: 3.14, -0.7)
• 문자열 (str): 문자들의 집합 (예: "Hello", 'Python')
• 불리언 (bool): 참(True)과 거짓(False)을 나타내는 값

1-2. 컬렉션 자료형

• 리스트 (list): 여러 값을 순서대로 저장하는 자료형 (예: [1, 2, 3])
• 튜플 (tuple): 변경할 수 없는 리스트 (예: (1, 2, 3))
• 딕셔너리 (dict): 키-값 쌍을 저장하는 자료형 (예: {"name": "Alice", "age": 25})
• 집합 (set): 중복을 허용하지 않는 자료형 (예: {1, 2, 3})

2. 변수 (Variable)

• 데이터를 저장하는 공간

• 변수 선언 방식: 변수명 = 값

• 예제:

    age = 25
    name = "Alice"
    height = 170.5
  

• 변수의 자료형은 동적으로 결정됨 (동적 타이핑)

3. 변수 이름 (Variable Naming)

3-1. 변수 이름 규칙

• 영문자, 숫자, 밑줄(_)만 사용 가능
• 숫자로 시작할 수 없음
• 대소문자를 구분함 (예: Name과 name은 다른 변수)
• 파이썬 키워드는 사용 불가 (예: if, while, def 등)

3-2. 변수 이름 스타일

• 스네이크 케이스 (snake_case): 여러 단어를 밑줄(_)로 구분 (예: user_name)
• 카멜 케이스 (camelCase): 첫 단어는 소문자, 이후 단어는 대문자로 시작 (예: userName)
• 파스칼 케이스 (PascalCase): 모든 단어의 첫 글자를 대문자로 (예: UserName)

4. 형 변환 (Type Casting)

• 한 자료형을 다른 자료형으로 변환하는 과정

• 주요 함수:

  • int(): 정수로 변환
  • float(): 실수로 변환
  • str(): 문자열로 변환
  • bool(): 불리언 값으로 변환

• 예제:

    num_str = "100"
    num_int = int(num_str)  # 문자열을 정수로 변환
    num_float = float(num_int)  # 정수를 실수로 변환
  

1. 시리즈 계층 인덱싱

다중 인덱스 사용 시리즈

• 다중 인덱스(MultiIndex)는 여러 단계로 구성된 인덱스를 의미하며, 계층적으로 데이터를 관리할 수 있음.
• pd.Series에서 다중 인덱스를 생성할 때 pd.MultiIndex.from_tuples()를 사용함.
• 다중 인덱스를 활용하면 그룹별 데이터를 보다 직관적으로 표현할 수 있음.

기본 코드:

import pandas as pd
import numpy as np

index = pd.MultiIndex.from_tuples([('A', 1), ('A', 2), ('B', 1), ('B', 2)])
s = pd.Series([10, 20, 30, 40], index=index)
print(s)

출력:

A  1    10
   2    20
B  1    30
   2    40
dtype: int64

시리즈 인덱싱 & 슬라이싱

0-레벨 인덱싱

• 최상위 레벨의 값을 기준으로 슬라이싱 가능.

print(s['A'])

출력:

1    10
2    20
dtype: int64

0-레벨과 1-레벨 동시 인덱싱 (loc 속성 사용)

• 특정 레벨 값을 함께 지정하여 접근 가능.

print(s.loc['A', 1])

출력:

10

팬시 인덱싱

• 여러 개의 값을 한 번에 선택 가능.

print(s.loc[['A', 'B']])

출력:

A  1    10
   2    20
B  1    30
   2    40
dtype: int64

2. 스택과 언스택

스택(Stack)

• 다중 인덱스를 컬럼에서 행 인덱스로 변환하는 과정.

df = s.unstack()
print(df)

출력:

     1   2
A   10  20
B   30  40

언스택(Unstack)

• 행 인덱스를 다시 컬럼으로 변환하는 과정.

print(df.stack())

출력:

A  1    10
   2    20
B  1    30
   2    40
dtype: int64

3. 데이터프레임 계층 인덱싱

다중 행/열 인덱스 사용

• pd.MultiIndex.from_product()를 사용하여 다중 행 및 열 인덱스를 생성할 수 있음.

columns = pd.MultiIndex.from_product([['X', 'Y'], ['A', 'B']])
df = pd.DataFrame(np.arange(16).reshape(4, 4), index=index, columns=columns)
print(df)

4. 다중 인덱스 레벨 교환과 정렬

레벨 교환

• swaplevel()을 사용하여 인덱스의 레벨을 교환할 수 있음.

print(df.swaplevel())

인덱스 라벨 정렬

• sort_index()를 사용하여 정렬 가능.

print(df.sort_index())

5. 레벨 단위 그룹화

• groupby(level=0)을 사용하여 특정 레벨 기준으로 그룹화 가능.

print(df.groupby(level=0).sum())

6. 인덱스 지정과 초기화

set_index() 메소드

• 특정 열을 인덱스로 설정 가능.

df = pd.DataFrame({'A': ['foo', 'bar', 'baz'], 'B': [1, 2, 3]})
df.set_index('A', inplace=True)
print(df)

출력:

     B
A
foo  1
bar  2
baz  3

reset_index() 메소드

• 기존 인덱스를 제거하고 열로 변환.

df.reset_index(inplace=True)
print(df)

출력:

     A  B
0  foo  1
1  bar  2
2  baz  3

drop=True 옵션

• 인덱스를 삭제하고 열로 변환하지 않음.

df.reset_index(drop=True, inplace=True)
print(df)

출력:

   B
0  1
1  2
2  3

데이터 그룹화

1. 개요

• 데이터 그룹화는 데이터를 특정 기준으로 묶어서 분석하는 기법임.

• groupby() 메소드를 사용하여 그룹을 생성하고, 다양한 집계 함수를 적용할 수 있음.

  ---

2. 시리즈 그룹화

value_counts() 메소드

• 특정 값의 개수를 계산할 때 사용.

s = pd.Series(['A', 'B', 'A', 'C', 'B', 'A'])
print(s.value_counts())

출력:

A    3
B    2
C    1
dtype: int64

mean() 메소드

• 그룹별 평균 값을 구함.

df = pd.DataFrame({'Category': ['A', 'B', 'A', 'B'], 'Value': [10, 20, 30, 40]})
print(df.groupby('Category')['Value'].mean())

출력:

Category
A    20.0
B    30.0
Name: Value, dtype: float64

3. 데이터프레임 그룹화

다중 키 활용 그룹화

• 두 개 이상의 키를 기준으로 그룹화 가능.

print(df.groupby(['Category', 'Value']).count())

dropna 키워드 인자

• dropna=True: 결측값이 있는 그룹을 제거
• dropna=False: 결측값이 있는 그룹도 유지

count() 집계 함수

print(df.groupby('Category').count())

4. 그룹 확인

for 반복문 활용

for name, group in df.groupby('Category'):
    print(name)
    print(group)

5. 열 선택 및 함수 활용 그룹화

• 특정 열을 기준으로 그룹화할 수 있으며, 시리즈나 사전을 활용할 수 있음.

print(df.groupby('Category')['Value'].sum())

6. 멀티 인덱스 레벨 활용

• 행과 열 모두를 기준으로 그룹화 가능.

print(df.groupby(['Category', 'Value']).sum())

1. 시리즈 계층 인덱싱

다중 인덱스 사용 시리즈

• 다중 인덱스(MultiIndex)는 여러 단계로 구성된 인덱스를 의미하며, 계층적으로 데이터를 관리할 수 있음.
• pd.Series에서 다중 인덱스를 생성할 때 pd.MultiIndex.from_tuples()를 사용함.
• 다중 인덱스를 활용하면 그룹별 데이터를 보다 직관적으로 표현할 수 있음.

기본 코드:

import pandas as pd
import numpy as np

index = pd.MultiIndex.from_tuples([('A', 1), ('A', 2), ('B', 1), ('B', 2)])
s = pd.Series([10, 20, 30, 40], index=index)
print(s)

출력:

A  1    10
   2    20
B  1    30
   2    40
dtype: int64

시리즈 인덱싱 & 슬라이싱

0-레벨 인덱싱

• 최상위 레벨의 값을 기준으로 슬라이싱 가능.

print(s['A'])

출력:

1    10
2    20
dtype: int64

0-레벨과 1-레벨 동시 인덱싱 (loc 속성 사용)

• 특정 레벨 값을 함께 지정하여 접근 가능.

print(s.loc['A', 1])

출력:

10

팬시 인덱싱

• 여러 개의 값을 한 번에 선택 가능.

print(s.loc[['A', 'B']])

출력:

A  1    10
   2    20
B  1    30
   2    40
dtype: int64

2. 스택과 언스택

스택(Stack)

• 다중 인덱스를 컬럼에서 행 인덱스로 변환하는 과정.

df = s.unstack()
print(df)

출력:

     1   2
A   10  20
B   30  40

언스택(Unstack)

• 행 인덱스를 다시 컬럼으로 변환하는 과정.

print(df.stack())

출력:

A  1    10
   2    20
B  1    30
   2    40
dtype: int64

3. 데이터프레임 계층 인덱싱

다중 행/열 인덱스 사용

• pd.MultiIndex.from_product()를 사용하여 다중 행 및 열 인덱스를 생성할 수 있음.

columns = pd.MultiIndex.from_product([['X', 'Y'], ['A', 'B']])
df = pd.DataFrame(np.arange(16).reshape(4, 4), index=index, columns=columns)
print(df)

4. 다중 인덱스 레벨 교환과 정렬

레벨 교환

• swaplevel()을 사용하여 인덱스의 레벨을 교환할 수 있음.

print(df.swaplevel())

인덱스 라벨 정렬

• sort_index()를 사용하여 정렬 가능.

print(df.sort_index())

5. 레벨 단위 그룹화

• groupby(level=0)을 사용하여 특정 레벨 기준으로 그룹화 가능.

print(df.groupby(level=0).sum())

6. 인덱스 지정과 초기화

set_index() 메소드

• 특정 열을 인덱스로 설정 가능.

df = pd.DataFrame({'A': ['foo', 'bar', 'baz'], 'B': [1, 2, 3]})
df.set_index('A', inplace=True)
print(df)

출력:

     B
A
foo  1
bar  2
baz  3

reset_index() 메소드

• 기존 인덱스를 제거하고 열로 변환.

df.reset_index(inplace=True)
print(df)

출력:

     A  B
0  foo  1
1  bar  2
2  baz  3

drop=True 옵션

• 인덱스를 삭제하고 열로 변환하지 않음.

df.reset_index(drop=True, inplace=True)
print(df)

출력:

   B
0  1
1  2
2  3

7. 모양 변환의 항목 재배열

스택과 언스택

• dropna=False 옵션을 사용하면 NaN 값도 유지됨.

print(df.stack(dropna=False))

8. 테이블 데이터셋에서 긴 형태의 데이터 프레임 생성

• pop() 메소드 사용 시 주의해야 함.

df['C'] = [10, 20, 30]
removed_column = df.pop('C')
print(df)

출력:

     A  B
0  foo  1
1  bar  2
2  baz  3

9. 피버팅과 언피버팅

피버팅 (pivot())

• 하나 또는 두 개의 열을 기준으로 변환 가능.

df = pd.DataFrame({'A': ['X', 'X', 'Y', 'Y'], 'B': [1, 2, 1, 2], 'C': [10, 20, 30, 40]})
pivot_df = df.pivot(index='A', columns='B', values='C')
print(pivot_df)

출력:

B   1   2
A
X  10  20
Y  30  40

pd.melt() 함수

• id_vars 키워드 인자를 활용하여 변환.

melted_df = pd.melt(df, id_vars=['A'])
print(melted_df)

출력:

   A variable  value
0  X        B      1
1  X        B      2
2  Y        B      1
3  Y        B      2
4  X        C     10
5  X        C     20
6  Y        C     30
7  Y        C     40

pivot()과 unstack() 비교

• set_index()와 unstack()을 연속 적용한 결과와 동일함.

print(df.set_index(['A', 'B']).unstack())

1.데이터 결합

pd.conact() 함수

Pandas 라이브러리에서 여러 DataFrame 또는 Series를 연결(concatenate)행(row) 또는 열(column) 단위로 데이터를 합칠 수 있습니다.

import pandas as pd

# 예시 DataFrame
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})

# 행 방향으로 연결 (기본 axis=0)
result = pd.concat([df1, df2])
print(result)

• 주요 인자

  1. objs: 합칠 객체들의 리스트. 이 객체들은 DataFrame 또는 Series여야 합니다.
  2. axis: 연결할 축을 지정합니다. axis=0은 행 방향으로 연결, axis=1은 열 방향으로 연결합니다. 기본값은 axis=0입니다.
  3. ignore_index: True로 설정하면 인덱스를 무시하고 새로 생성된 인덱스를 할당합니다. 기본값은 False입니다.
  4. keys: 여러 DataFrame을 합칠 때 각 DataFrame에 대한 레벨을 지정할 수 있습니다. MultiIndex를 생성할 수 있습니다.
  5. join: inner 또는 outer를 지정할 수 있습니다. outer는 모든 열을 포함, inner는 공통 열만 포함하여 합칩니다. 기본값은 outer입니다.
  6. verify_integrity: True로 설정하면, 중복된 인덱스를 체크하고 오류를 발생시킵니다.

• 행 방향 연결 (axis=0)

df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})

# 두 DataFrame을 행 방향으로 합치기
result = pd.concat([df1, df2], ignore_index=True)
print(result)

   A  B
0  1  3
1  2  4
2  5  7
3  6  8

• 열 방향 연결 (axis=1)

df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'B': [3, 4]})

# 두 DataFrame을 열 방향으로 합치기
result = pd.concat([df1, df2], axis=1)
print(result)

   A  B
0  1  3
1  2  4

기본 설정

pandas 라이브러리는 보통 pd 라는 별칭으로 사용됨.

import pandas as pd
import numpy as np

랜덤 시드, 어레이 내부에 사용되는 부동소수점 정확도, 도표 크기 지정 옵션 등은 이전과 동일함.

np.random.seed(12345)
np.set_printoptions(precision=4, suppress=True)

import matplotlib.pyplot as plt
plt.rc('figure', figsize=(10, 6))

Series와 DataFrame을 표로 보여줄 때 사용되는 행의 수를 20으로 지정함.

기본값=60

pd.options.display.max_rows # 원래 60이 기본.

기본값(60)을 20으로 변경함.

pd.set_option("display.max_rows",20)

데이터 탐색

주요 메서드

• head()
• tail()
• info()

예시를 위한 아래 데이터프레임 이용

dict = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada', 'NY', 'NY', 'NY'],
         'year': [str(num) for num in [2000, 2001, 2002, 2001, 2002, 2003, 2002, 2003, 2004]],
         'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2, 8.3, 8.4, 8.5],
         'debt':np.linspace(0, 1, 9)}

frame = pd.DataFrame(dict, columns=['year', 'state', 'pop', 'debt'],
                      index=['one', 'two', 'three', 'four',
                             'five', 'six', 'seven', 'eight', 'nine'])
frame

       year     state     pop     debt
one     2000    Ohio      1.5     0.000
two     2001    Ohio      1.7     0.125
three2002    Ohio      3.6     0.250
four 2001    Nevada    2.4     0.375
five 2002    Nevada    2.9     0.500
six     2003    Nevada    3.2     0.625
seven2002    NY        8.3     0.750
eight2003    NY        8.4     0.875
nine 2004    NY        8.5     1.000

#표 형태임.

head() 메서드

head() 메서드는 지정된 크기만큼의 행을 보여줌.

인자를 지정하지 않으면 처음 5개의 행을 보여줌.

frame.head() #처음_5개행만
frame.head(3)

tail() 메서드

tail() 메서드는 지정된 크기만큼의 행을 뒤에서부터 보여줌.

인자를 지정하지 않으면 뒤에서부터 5개의 행을 보여줌.

frame.tail() #마지막부터_5개행만
frame.tail(3)

info() 메서드

열(columns) 별로 결측치가 아닌 항목의 수와 자료형을 확인해줌.

• 9 non-null: 결측치가 아닌 항목이 9개 있음을 의미함.
• object: 일반적으로 문자열 자료형을 가리킴.

frame.info()

<class 'pandas.core.frame.DataFrame'>
Index: 9 entries, one to nine
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   year    9 non-null      object 
 1   state   9 non-null      object 
 2   pop     9 non-null      float64
 3   debt    9 non-null      float64
dtypes: float64(2), object(2)
memory usage: 360.0+ bytes

합, 평균, 표준편차

기초 통계에서 사용되는 주요 메서드

• sum()
• mean()
• std()
• idxmax()/idxmin()
• cumsum()
• describe()

기본적으로 열 단위로 작동, 결측치는 행 또는 열의 모든 값이 결측치가 아니라면 기본적으로 무시함.

행 단위로 작동하게 하려면 축을 axis=1 또는 axis='columns'로 지정하고, 결측치를 무시하지 않으려면 skipna=False로 지정한다.

df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=['a', 'b', 'c', 'd'],
                  columns=['one', 'two'])
df

     one    two
a    1.40    NaN
b    7.10    -4.5
c    NaN      NaN
d    0.75    -1.3
#표 형태임.

sum() 메서드

행/열 단위 합 계산

df.sum()
# one 9.25
# two -5.80
# dtype: float64

결측치를 무시하지 않으면, 결측치가 포함된 행/렬에 대한 계산은 하지 않음.

df.sum(skipna=False)
# one NaN
# two NaN
# dtype: float64

df.sum(axis='columns')
# a 1.40
# b 2.60
# c 0.00
# d -0/55
#dtype: float64

시리즈는 하나의 열을 갖는 데이터프레임처럼 작동함.

df['one']
# a 1.40
# b 7.10
# c NaN
# d 0.75
# Name: one, dtype: float64

df['one'].sum()
#9.25

mean() 메서드

평균값 계산

df.mean()
# one 3.083333
# two -2.90000
# dtype: float64

df.mear(axis='columns')
#a    1.400
#b    1.300
#c    NaN
#d   -0.275
#dtype: float64

결측치를 무시하지 않으면, 결측치가 포함된 행/렬에 대한 계산은 하지 않음.

df.mean(skipna=False)
#one   NaN
#two   NaN
#dtype: float64

df.mean(axis='columns', skipna=False)
#a      NaN
#b    1.300
#c      NaN
#d   -0.275
#dtype: float64

시리즈의 경우도 동일하게 작동함.

df['one'].mean()
#3.0833333333333335

df['one'].mean(skipna=False)
#NaN

std() 메서드

표준편차 계산

df.std()
#one    3.493685
#two    2.262742
#dtype: float64

df.std(axis='columns',skipna=False)
#a    NaN
#b    8.202439
#c    NaN
#d    1.449569
#dtype: float64

idxmax()/idxmin()

최댓값/최솟값을 갖는 인덱스 확인

아래 코드는 열별 최댓값을 갖는 인덱스를 찾아줌.

df.imax()
#one b
#two b
#dtype: object

cumsum()

누적 합 계산

df.cumsum()

     one     two
a     1.40     NaN
b     8.50     -4.5
c     NaN     NaN
d     9.25     -5.8
#표 형태임

describe()

요약 통계 보여주기

수치형 데이터의 경우 평균값, 표준편차, 사분위수 등의 통계 정보를 요약해서 보여줌.

df.describe()

         one         two
count    3.000000      2.000000
mean    3.083333    -2.900000
std      3.493685     2.262742
min      0.750000    -4.500000
25%      1.075000    -3.700000
50%     1.400000    -2.900000
75%      4.250000    -2.100000
max     7.100000    -1.300000
#표 형태임

상관관계와 공분산

금융 사이트에서 구한 4 개 회사의 주가(price)와 거래량(volume)을 담고 있는 두 개의 데이터를 이용하여 상관계수와 공분산을 계산할 것임.

이를 위해 먼저 바이너리 파일 두 개를 다운로드해서 지정된 하위 디렉토리에 저장해야 함.

• 파일 저장 디렉토리 지정 및 생성

from pathlib import Path

data_path = Path() / "examples"

data_path.mkdir(parents=True, exist_ok=True)

• 특정 서버에서 파일 다운로드 함수

import requests

# 파일 서버 기본 주소
base_url = "https://raw.githubusercontent.com/codingalzi/datapy/master/jupyter-book/examples/"

def myWget(filename):
    # 다운로드 대상 파일 경로
    file_url = base_url + filename

    # 저장 경로와 파일명
    target_path = data_path / filename

    data = requests.get(file_url)

    with open(target_path, 'wb') as f:
        f.write(data.content)

두 개의 픽클 파일 다운로드.

• pkl 파일: 판다스에서 제공하는 객체를 to_pickle() 메서드를 이용하여 컴퓨터에 파일로 저장할 때 사용되는 바이너리 파일.

myWget("yahoo_price.pkl")
myWget("yahoo_volume.pkl")

다운로드한 두 개의 데이터를 불러옴.

• read_pickle(): 저장된 pkl 파일을 파이썬으로 불러오는 함수

아래 코드는 일별 주가 데이터를 불러온다. 2010년 1월 4일부터 2016년 10월 21일까지의 데이터 1714개를 담고 있음.

price=pd.read_pickle('examples/yahoo_price.pkl')
price

아래 코드는 동일 회사, 동일 날짜의 1일 거래량(volume) 담고 있는 데이터를 불러옴.

volume = pd.read_pickle('examples/yahoo_volume.pkl')
volume

주가의 일단위 변화율을 알아보기 위해 퍼센트 변화율을 확인함.

참고: 증권분야에서 return은 이익율을 의미함.

returns = price.pct_change()
returns.tail()

corr()/cov() 메서드

상관계수와 공분산 모두 두 확률변수 사이의 선형관계를 보여줌

상관계수와 공분산의 차이점

| 공분산 | 두 확률변수 X, Y 사이의 선형관계를 계량화함. 양/음수 여부에 따른 선형관계를 보이며, 절댓값이 클수록 선형관계가 강함. but 사용되는 확률변수의 척도(scale)에 많은 영향을 받음. #정규화한 값인 상관계수를 사용하는 이유 | Cov(X,Y)=E((X−μX)(Y−μY)) μX=E(X)=∑X/n μY=E(Y)=∑Y/n | | --- | --- | --- | | 상관계수 | 두 확률변수 사이의 선형관계를 -1과 1 사이의 값으로 표현함. 양/음수 여부에 따른 선형관계로 절댓값이 1에 가까울수록 선형관계가 강함. | ρ=Cov(X,Y)/σX⋅σY σX=√Var(X) Var(X)=∑(X−μX)^2/n Var(Y)=∑(X−μY)^2/n |

'MSFT'와 'IBM' 사이의 공분산은 다음과 같음.

returns['MSFT'].cov(returns['IBM'])
#8.870655479703546e-05

'MSFT'와 'IBM' 사이의 상관계수는 다음과 같음.

returns['MSFT'].corr(returns['IBM'])
#0.49976361144151144

전체 회사를 대상으로 하는 상관계수와 공분산을 계산할 수도 있음.

returns.cov()
returns.corr()

중복과 빈도

unique() 메서드

시리즈에서 사용된 값을 중복 없이 확인

 set() 함수와 유사하게 작동하며, 넘파이 어레이를 반환.

obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
obj

0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
dtype: object

uniques = obj.unique()
uniques

array(['c', 'a', 'd', 'b'], dtype=object)

value_counts() 메서드

값들의 빈도수를 확인

obj.value_counts()

c    3
a    3
b    2
d    1
Name: count, dtype: int64

1. 기본 설정

1-1. 시리즈(Series)

• 1차원 데이터 구조로, 인덱스와 값(value)으로 구성됨.
• 리스트, 딕셔너리, 넘파이 배열 등을 활용하여 생성 가능.

1-2. 데이터프레임(DataFrame)

• 2차원 데이터 구조로, 여러 개의 시리즈가 모여 만들어짐.
• 행(row)과 열(column)로 구성됨.
• 딕셔너리, 리스트, 넘파이 배열 등을 활용하여 생성 가능.

2. 시리즈 산술연산

• 시리즈 간의 산술연산은 같은 인덱스를 기준으로 수행됨.
• 연산 대상이 없는 인덱스 값은 NaN(결측치)로 처리됨.

예제 (덧셈)

import pandas as pd

s1 = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
s2 = pd.Series([5, 15, 25], index=['b', 'c', 'd'])

result = s1 + s2
print(result)

a     NaN
b    25.0
c    45.0
d     NaN
dtype: float64

예제 (뺄셈)

result = s1 - s2
print(result)

a    NaN
b     5.0
c     5.0
d    NaN
dtype: float64

예제 (곱셈)

result = s1 * s2
print(result)

a      NaN
b    300.0
c    750.0
d      NaN
dtype: float64

예제 (나눗셈)

result = s1 / s2
print(result)

a    NaN
b    1.333333
c    1.2
d    NaN
dtype: float64

• ‘a’와 ‘d’는 대응되는 값이 없어 NaN(결측치)로 표시됨.

3. 데이터프레임 산술연산

• 같은 열(column)과 같은 행(index)을 기준으로 연산이 수행됨.
• 대응되는 값이 없으면 NaN(결측치)로 처리됨.

예제 (덧셈)

df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [10, 20, 30], 'C': [40, 50, 60]})

result = df1 + df2
print(result)

      A   B   C
0  11.0 NaN NaN
1  22.0 NaN NaN
2  33.0 NaN NaN

예제 (뺄셈)

result = df1 - df2
print(result)

      A   B   C
0  -9.0 NaN NaN
1 -18.0 NaN NaN
2 -27.0 NaN NaN

예제 (곱셈)

result = df1 * df2
print(result)

      A   B   C
0  10.0 NaN NaN
1  40.0 NaN NaN
2  90.0 NaN NaN

예제 (나눗셈)

result = df1 / df2
print(result)

      A   B   C
0  0.1 NaN NaN
1  0.1 NaN NaN
2  0.1 NaN NaN

• ‘B’와 ‘C’ 열은 상대 데이터프레임에 없어서 NaN으로 표시됨.

4. 연산과 결측치

• 연산 시 NaN(결측치)이 포함되면 결과값도 NaN이 됨.
• 결측치를 처리하기 위한 메소드 활용 가능.

자주 사용되는 연산 메소드

예제 (fillna 활용)

result = df1.add(df2, fill_value=0)
print(result)

      A    B     C
0  11.0  4.0  40.0
1  22.0  5.0  50.0
2  33.0  6.0  60.0

• NaN 대신 0을 채워 연산 수행.

5. 브로드캐스팅

• 차원이 다른 데이터 간 연산을 자동으로 확장하여 수행하는 기능.

5-1. 차원 맞추기

• 데이터프레임과 시리즈 간 연산 시 자동으로 차원이 맞춰짐.

5-2. 데이터프레임과 시리즈 간 연산

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
s = pd.Series([10, 20, 30])

result = df + s
print(result)

    A   B
0  11  14
1  22  25
2  33  36

• 시리즈의 값이 각 행(row)에 더해짐.

5-3. 공통 인덱스 존재 시

s = pd.Series([10, 20], index=['A', 'B'])
result = df + s
print(result)

     A   B
0  11  24
1  12  25
2  13  26

• 공통 인덱스만 연산에 적용됨.

5-4. axis=0 또는 axis='index' 적용

result = df.add(s, axis=0)
print(result)

     A   B
0  11  24
1  12  25
2  13  26

• axis=0을 지정하면 행(row) 방향으로 브로드캐스팅이 적용됨.