1. Matplotlib 시작하기 - 기초부터 차근차근 💻

Matplotlib은 파이썬에서 가장 오래되고 널리 사용되는 데이터 시각화 라이브러리예요. 2003년에 John Hunter가 MATLAB의 plotting 기능을 파이썬에서 구현하기 위해 만들었다는 사실, 알고 계셨나요? 역사가 깊은 만큼 안정적이고 다양한 기능을 제공한답니다!

1.1 Matplotlib 설치하기

먼저 Matplotlib을 설치해볼까요? 파이썬 환경이 준비되어 있다면 pip를 사용해서 쉽게 설치할 수 있어요.

pip install matplotlib

아나콘다를 사용하시는 분들은 이렇게 설치하셔도 돼요!

conda install matplotlib

설치가 완료됐다면, 이제 첫 번째 그래프를 그려볼까요? ㅎㅎ 두근두근~

1.2 첫 번째 그래프 그리기

Matplotlib의 가장 기본적인 사용법은 pyplot 모듈을 통해 이루어져요. 간단한 선 그래프부터 시작해볼게요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
x = np.linspace(0, 10, 100)  # 0부터 10까지 100개의 점
y = np.sin(x)  # 사인 함수

# 그래프 그리기
plt.figure(figsize=(10, 6))  # 그래프 크기 설정
plt.plot(x, y)  # 선 그래프 그리기
plt.title('사인 함수 그래프')  # 제목
plt.xlabel('x 값')  # x축 레이블
plt.ylabel('sin(x)')  # y축 레이블
plt.grid(True)  # 그리드 표시
plt.show()  # 그래프 보여주기

위 코드를 실행하면 사인 함수의 그래프가 나타날 거예요! 어때요? 생각보다 쉽죠? ㅋㅋㅋ

2. Matplotlib의 두 가지 인터페이스 이해하기 🧩

Matplotlib을 사용할 때 알아두면 좋은 점! Matplotlib에는 두 가지 주요 인터페이스가 있어요.

2.1 pyplot 인터페이스 (상태 기반)

pyplot 인터페이스는 MATLAB 스타일의 상태 기반 인터페이스예요. 간단하게 그래프를 그릴 때 많이 사용하죠. 위에서 본 예제가 바로 이 방식이에요!

import matplotlib.pyplot as plt

plt.figure()
plt.plot([1, 2, 3, 4], [10, 20, 25, 30], 'ro-')
plt.title('간단한 그래프')
plt.show()

이 방식은 빠르게 그래프를 그릴 때 좋지만, 복잡한 그래프나 여러 그래프를 관리할 때는 좀 불편할 수 있어요. 그럴 땐 객체 지향 인터페이스를 사용하면 좋답니다! 👍

2.2 객체 지향 인터페이스

객체 지향 인터페이스는 Figure와 Axes 객체를 명시적으로 생성하고 관리해요. 복잡한 그래프나 여러 서브플롯을 다룰 때 더 효과적이죠!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 객체 지향 방식으로 그래프 그리기
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, y1, 'b-', label='sin(x)')
ax.plot(x, y2, 'r-', label='cos(x)')
ax.set_title('사인과 코사인 함수')
ax.set_xlabel('x 값')
ax.set_ylabel('y 값')
ax.legend()
ax.grid(True)

plt.show()

이 방식이 처음엔 좀 복잡해 보일 수 있지만, 실제로 큰 프로젝트에서는 이 방식이 훨씬 관리하기 쉽고 유연해요! 진짜 실무에서는 거의 이 방식만 쓴다고 보면 됩니다 ㅋㅋㅋ

3. 다양한 그래프 유형 마스터하기 📊

Matplotlib으로는 정말 다양한 종류의 그래프를 그릴 수 있어요. 이제 기본적인 그래프 유형들을 하나씩 살펴볼게요! 실무에서 자주 쓰이는 것들 위주로 정리했습니다~

3.1 선 그래프 (Line Plot)

선 그래프는 데이터의 연속적인 변화를 보여줄 때 가장 많이 사용해요. 시계열 데이터 분석할 때 진짜 많이 쓰이죠!

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2, label='sin(x)')
plt.title('선 그래프 예제')
plt.xlabel('x 값')
plt.ylabel('y 값')
plt.legend()
plt.grid(True)
plt.show()

선 그래프에서는 선의 스타일, 색상, 두께 등을 다양하게 설정할 수 있어요. 'b-'는 파란색 실선을 의미하고, 'r--'는 빨간색 점선, 'g:'는 초록색 점선 등으로 표현할 수 있답니다. 완전 꿀팁이죠? ㅋㅋㅋ

3.2 산점도 (Scatter Plot)

산점도는 두 변수 간의 관계를 점으로 표현하는 그래프예요. 상관관계 분석할 때 많이 사용하죠!

import matplotlib.pyplot as plt
import numpy as np

# 랜덤 데이터 생성
np.random.seed(42)
x = np.random.rand(50)
y = x + np.random.normal(0, 0.2, 50)

plt.figure(figsize=(10, 6))
plt.scatter(x, y, s=100, c='purple', alpha=0.6, edgecolors='black')
plt.title('산점도 예제')
plt.xlabel('x 값')
plt.ylabel('y 값')
plt.grid(True)
plt.show()

산점도에서는 점의 크기(s), 색상(c), 투명도(alpha) 등을 조절할 수 있어요. 데이터 포인트에 추가 정보를 담고 싶을 때 이런 속성들을 활용하면 좋답니다! 😉

3.3 막대 그래프 (Bar Plot)

막대 그래프는 범주형 데이터를 비교할 때 아주 유용해요. 각 범주별 값의 크기를 직관적으로 비교할 수 있죠!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
categories = ['A', 'B', 'C', 'D', 'E']
values = [23, 45, 56, 78, 32]

plt.figure(figsize=(10, 6))
plt.bar(categories, values, color='skyblue', edgecolor='navy', width=0.6)
plt.title('막대 그래프 예제')
plt.xlabel('카테고리')
plt.ylabel('값')
plt.ylim(0, 100)  # y축 범위 설정
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

막대 그래프에서는 막대의 색상, 테두리, 너비 등을 조절할 수 있어요. 수평 막대 그래프를 그리고 싶다면 plt.barh()를 사용하면 된답니다! 👌

3.4 히스토그램 (Histogram)

히스토그램은 데이터의 분포를 시각화할 때 사용해요. 데이터가 어떤 범위에 얼마나 많이 분포하는지 확인할 수 있죠!

import matplotlib.pyplot as plt
import numpy as np

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

plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, color='lightgreen', edgecolor='darkgreen', alpha=0.7)
plt.title('히스토그램 예제')
plt.xlabel('값')
plt.ylabel('빈도')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

히스토그램에서 bins 매개변수는 데이터를 몇 개의 구간으로 나눌지 결정해요. 값이 클수록 더 세밀한 분포를 볼 수 있답니다. 데이터 특성에 따라 적절한 bins 값을 설정하는 게 중요해요! 🧐

3.5 파이 차트 (Pie Chart)

파이 차트는 전체에 대한 각 부분의 비율을 시각화할 때 사용해요. 특히 구성 비율을 강조하고 싶을 때 효과적이죠!

import matplotlib.pyplot as plt

# 데이터 준비
labels = ['A', 'B', 'C', 'D', 'E']
sizes = [15, 30, 25, 10, 20]
colors = ['#ff9999', '#66b3ff', '#99ff99', '#ffcc99', '#c2c2f0']
explode = (0.1, 0, 0, 0, 0)  # A 조각만 돌출

plt.figure(figsize=(10, 8))
plt.pie(sizes, explode=explode, labels=labels, colors=colors, 
        autopct='%1.1f%%', shadow=True, startangle=90)
plt.axis('equal')  # 원형으로 보이게 설정
plt.title('파이 차트 예제')
plt.show()

파이 차트에서는 explode 매개변수로 특정 조각을 돌출시킬 수 있어요. autopct는 각 조각에 표시할 퍼센트 형식을 지정하는 매개변수예요. 진짜 깔끔한 파이 차트 만들 수 있답니다! 😍

3.6 박스 플롯 (Box Plot)

박스 플롯은 데이터의 분포와 이상치를 시각화하는 데 유용해요. 중앙값, 사분위수, 이상치 등을 한눈에 볼 수 있죠!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
np.random.seed(42)
data = [np.random.normal(0, std, 100) for std in range(1, 5)]

plt.figure(figsize=(10, 6))
plt.boxplot(data, patch_artist=True, 
            boxprops=dict(facecolor='lightblue'),
            whiskerprops=dict(color='black'),
            medianprops=dict(color='red'))
plt.title('박스 플롯 예제')
plt.xlabel('그룹')
plt.ylabel('값')
plt.grid(axis='y', linestyle='--', alpha=0.7)
plt.show()

박스 플롯에서 patch_artist=True로 설정하면 박스에 색상을 입힐 수 있어요. 각 요소의 색상과 스타일도 세부적으로 조절할 수 있답니다! 데이터 분석할 때 진짜 유용한 그래프예요~ 📦

4. 서브플롯으로 여러 그래프 배치하기 🖼️

여러 그래프를 한 화면에 배치하고 싶을 때는 서브플롯을 사용해요. 이렇게 하면 여러 데이터를 한눈에 비교할 수 있어서 정말 편리하답니다!

4.1 기본 서브플롯 만들기

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.exp(-x/3)
y4 = x**2/30

# 2x2 서브플롯 생성
plt.figure(figsize=(12, 10))

plt.subplot(2, 2, 1)  # 2행 2열의 첫 번째
plt.plot(x, y1, 'b-')
plt.title('사인 함수')
plt.grid(True)

plt.subplot(2, 2, 2)  # 2행 2열의 두 번째
plt.plot(x, y2, 'r-')
plt.title('코사인 함수')
plt.grid(True)

plt.subplot(2, 2, 3)  # 2행 2열의 세 번째
plt.plot(x, y3, 'g-')
plt.title('지수 함수')
plt.grid(True)

plt.subplot(2, 2, 4)  # 2행 2열의 네 번째
plt.plot(x, y4, 'm-')
plt.title('이차 함수')
plt.grid(True)

plt.tight_layout()  # 서브플롯 간 간격 자동 조정
plt.show()

plt.subplot(행, 열, 인덱스)로 서브플롯의 위치를 지정할 수 있어요. tight_layout()을 사용하면 서브플롯 간의 간격을 자동으로 조정해줘서 겹치는 문제를 해결할 수 있답니다! 👍

4.2 객체 지향 방식으로 서브플롯 만들기

더 세밀한 제어가 필요할 때는 객체 지향 방식을 사용하는 게 좋아요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 객체 지향 방식으로 서브플롯 생성
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# 첫 번째 서브플롯
ax1.plot(x, y1, 'b-', linewidth=2)
ax1.set_title('사인 함수')
ax1.set_xlabel('x 값')
ax1.set_ylabel('sin(x)')
ax1.grid(True)

# 두 번째 서브플롯
ax2.plot(x, y2, 'r-', linewidth=2)
ax2.set_title('코사인 함수')
ax2.set_xlabel('x 값')
ax2.set_ylabel('cos(x)')
ax2.grid(True)

plt.tight_layout()
plt.show()

이 방식은 각 서브플롯을 변수(ax1, ax2)로 받아서 다루기 때문에 코드가 더 깔끔하고 유지보수하기 좋아요! 실무에서는 거의 이 방식만 쓴다고 보면 됩니다 ㅋㅋㅋ

4.3 GridSpec으로 복잡한 레이아웃 만들기

더 복잡한 레이아웃이 필요할 때는 GridSpec을 사용해요. 다양한 크기의 서브플롯을 자유롭게 배치할 수 있답니다!

import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import numpy as np

# 데이터 준비
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.exp(-x/3)

# GridSpec으로 복잡한 레이아웃 생성
fig = plt.figure(figsize=(12, 8))
gs = gridspec.GridSpec(2, 3)  # 2행 3열의 그리드

# 첫 번째 행 전체를 차지하는 서브플롯
ax1 = fig.add_subplot(gs[0, :])
ax1.plot(x, y1, 'b-', linewidth=2)
ax1.set_title('사인 함수 (전체 너비)')
ax1.grid(True)

# 두 번째 행의 첫 번째와 두 번째 열을 차지하는 서브플롯
ax2 = fig.add_subplot(gs[1, :2])
ax2.plot(x, y2, 'r-', linewidth=2)
ax2.set_title('코사인 함수 (2/3 너비)')
ax2.grid(True)

# 두 번째 행의 세 번째 열을 차지하는 서브플롯
ax3 = fig.add_subplot(gs[1, 2])
ax3.plot(x, y3, 'g-', linewidth=2)
ax3.set_title('지수 함수')
ax3.grid(True)

plt.tight_layout()
plt.show()

GridSpec을 사용하면 gs[행, 열] 형식으로 서브플롯의 위치와 크기를 지정할 수 있어요. gs[0, :]는 0번째 행의 모든 열을 의미하고, gs[1, :2]는 1번째 행의 0부터 1까지의 열을 의미해요. 이렇게 하면 정말 다양한 레이아웃을 만들 수 있답니다! 😎

5. 그래프 스타일링과 커스터마이징 🎨

이제 그래프를 더 예쁘고 전문적으로 꾸미는 방법을 알아볼게요! Matplotlib은 정말 다양한 커스터마이징 옵션을 제공한답니다.

5.1 색상과 스타일 설정

Matplotlib에서는 다양한 색상과 스타일을 사용할 수 있어요.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.cos(x)

plt.figure(figsize=(10, 6))

# 다양한 선 스타일과 색상 사용
plt.plot(x, y1, 'b-', linewidth=2, label='sin(x)')
plt.plot(x, y2, 'r--', linewidth=2, label='cos(x)')
plt.plot(x, y3, 'g-.', linewidth=2, label='sin(x)cos(x)')

plt.title('다양한 선 스타일과 색상')
plt.xlabel('x 값')
plt.ylabel('y 값')
plt.legend()
plt.grid(True)
plt.show()

선 스타일은 '-'(실선), '--'(점선), '-.'(대시점선), ':'(점선) 등이 있어요. 색상은 'b'(파란색), 'r'(빨간색), 'g'(초록색) 등의 약자나 '#FF5733'와 같은 HEX 코드, 'skyblue'와 같은 이름으로 지정할 수 있답니다! 👨‍🎨

5.2 마커 사용하기

데이터 포인트를 강조하고 싶을 때는 마커를 사용해요!

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 20)  # 포인트 수를 줄여서 마커가 잘 보이게
y = np.sin(x)

plt.figure(figsize=(12, 6))

# 다양한 마커 스타일 보여주기
markers = ['o', 's', '^', 'D', '*', 'p', 'h', 'x', '+']
colors = ['blue', 'red', 'green', 'purple', 'orange', 'brown', 'pink', 'gray', 'cyan']

for i, (marker, color) in enumerate(zip(markers, colors)):
    plt.plot(x, y + i*0.2, marker=marker, color=color, 
             linestyle='-', markersize=10, label=f'마커: {marker}')

plt.title('다양한 마커 스타일')
plt.xlabel('x 값')
plt.ylabel('y 값')
plt.legend(loc='upper left', bbox_to_anchor=(1, 1))
plt.grid(True)
plt.tight_layout()
plt.show()

마커 종류는 정말 다양해요! 'o'(원), 's'(사각형), '^'(삼각형), '*'(별) 등이 있어요. markersize로 크기를 조절하고, markerfacecolor와 markeredgecolor로 마커의 색상을 설정할 수 있답니다! 😊

5.3 스타일 시트 사용하기

Matplotlib은 미리 정의된 스타일 시트를 제공해요. 이를 사용하면 그래프의 전체적인 모양을 쉽게 바꿀 수 있답니다!

import matplotlib.pyplot as plt
import numpy as np

# 사용 가능한 스타일 목록 확인
print(plt.style.available)

# 스타일 적용 예시
styles = ['default', 'ggplot', 'seaborn', 'bmh', 'dark_background']
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(15, 10))

for i, style in enumerate(styles):
    plt.subplot(2, 3, i+1)
    with plt.style.context(style):
        plt.plot(x, y, linewidth=2)
        plt.title(f'스타일: {style}')
        plt.xlabel('x 값')
        plt.ylabel('sin(x)')
        plt.grid(True)

plt.tight_layout()
plt.show()

'ggplot', 'seaborn', 'bmh' 등의 스타일을 사용하면 그래프가 훨씬 더 전문적으로 보여요! 특히 'dark_background' 스타일은 어두운 배경에 밝은 색상의 그래프를 그려서 프레젠테이션에 아주 좋답니다! 🌟

5.4 텍스트와 주석 추가하기

그래프에 텍스트나 주석을 추가하면 데이터의 특정 부분을 강조할 수 있어요!

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2)

# 텍스트 추가
plt.text(4, 0.8, '최대값', fontsize=12, color='red')
plt.text(7, -0.8, '최소값', fontsize=12, color='red')

# 화살표 주석 추가
plt.annotate('중요 지점', xy=(3, 0), xytext=(4, 0.5),
             arrowprops=dict(facecolor='black', shrink=0.05))

plt.title('텍스트와 주석이 있는 그래프')
plt.xlabel('x 값')
plt.ylabel('sin(x)')
plt.grid(True)
plt.show()

plt.text()로 텍스트를 추가하고, plt.annotate()로 화살표가 있는 주석을 추가할 수 있어요. arrowprops 매개변수로 화살표의 스타일을 설정할 수 있답니다! 📝

5.5 그래프 테마 설정하기

그래프의 전체적인 테마를 설정하고 싶다면 rcParams를 사용해요!

import matplotlib.pyplot as plt
import numpy as np

# 그래프 테마 설정
plt.rcParams['font.family'] = 'DejaVu Sans'
plt.rcParams['font.size'] = 12
plt.rcParams['axes.grid'] = True
plt.rcParams['grid.linestyle'] = '--'
plt.rcParams['grid.alpha'] = 0.7
plt.rcParams['figure.figsize'] = [10, 6]
plt.rcParams['axes.prop_cycle'] = plt.cycler(color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd'])

# 데이터 준비
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 그래프 그리기
plt.plot(x, y1, linewidth=2, label='sin(x)')
plt.plot(x, y2, linewidth=2, label='cos(x)')
plt.title('커스텀 테마가 적용된 그래프')
plt.xlabel('x 값')
plt.ylabel('y 값')
plt.legend()
plt.show()

rcParams를 사용하면 그래프의 폰트, 크기, 색상 등 거의 모든 요소를 세부적으로 설정할 수 있어요. 프로젝트 전체에 일관된 스타일을 적용하고 싶을 때 아주 유용하답니다! 💯

6. 고급 시각화 기법 🚀

이제 더 고급 시각화 기법들을 알아볼게요! 이 기술들을 익히면 정말 프로페셔널한 데이터 시각화가 가능해져요.

6.1 3D 그래프 그리기

Matplotlib의 mplot3d 툴킷을 사용하면 3D 그래프를 그릴 수 있어요!

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 데이터 준비
x = np.linspace(-5, 5, 50)
y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# 3D 그래프 그리기
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='viridis', edgecolor='none', alpha=0.8)

# 컬러바 추가
fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5)

ax.set_title('3D 표면 그래프')
ax.set_xlabel('X 축')
ax.set_ylabel('Y 축')
ax.set_zlabel('Z 축')

plt.show()

3D 그래프는 projection='3d' 매개변수를 사용해 생성해요. plot_surface(), plot_wireframe(), scatter3D() 등 다양한 3D 플로팅 함수를 사용할 수 있답니다! 🌐

6.2 등고선 그래프 (Contour Plot)

등고선 그래프는 3D 데이터를 2D로 표현하는 좋은 방법이에요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

plt.figure(figsize=(12, 5))

# 등고선 그래프
plt.subplot(1, 2, 1)
contour = plt.contour(X, Y, Z, 20, cmap='RdBu')
plt.colorbar(contour)
plt.title('등고선 그래프')
plt.xlabel('X 축')
plt.ylabel('Y 축')

# 채워진 등고선 그래프
plt.subplot(1, 2, 2)
filled_contour = plt.contourf(X, Y, Z, 20, cmap='RdBu')
plt.colorbar(filled_contour)
plt.title('채워진 등고선 그래프')
plt.xlabel('X 축')
plt.ylabel('Y 축')

plt.tight_layout()
plt.show()

contour()는 선으로 된 등고선을, contourf()는 색으로 채워진 등고선을 그려요. 등고선 그래프는 지형도나 온도 분포 같은 데이터를 시각화할 때 아주 유용하답니다! 🗺️

6.3 히트맵 (Heatmap)

히트맵은 데이터의 패턴이나 상관관계를 색상으로 표현해요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비 (상관관계 행렬 예시)
np.random.seed(42)
data = np.random.rand(10, 10)
corr = np.corrcoef(data)

plt.figure(figsize=(10, 8))
heatmap = plt.imshow(corr, cmap='coolwarm', interpolation='none')
plt.colorbar(heatmap)

# 축 레이블 설정
plt.title('상관관계 히트맵')
plt.xticks(np.arange(10), [f'변수 {i+1}' for i in range(10)])
plt.yticks(np.arange(10), [f'변수 {i+1}' for i in range(10)])

# 각 셀에 값 표시
for i in range(10):
    for j in range(10):
        plt.text(j, i, f'{corr[i, j]:.2f}', 
                 ha='center', va='center', 
                 color='white' if abs(corr[i, j]) > 0.5 else 'black')

plt.tight_layout()
plt.show()

히트맵은 imshow() 함수로 쉽게 그릴 수 있어요. 색상 스케일을 조절하고 각 셀에 값을 표시하면 더 정보가 풍부한 히트맵을 만들 수 있답니다! 🔥

6.4 스타일이 있는 산점도 (Styled Scatter Plot)

산점도에 다양한 스타일을 적용해 더 많은 정보를 담을 수 있어요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
np.random.seed(42)
n = 50
x = np.random.rand(n)
y = np.random.rand(n)
colors = np.random.rand(n)  # 색상용 랜덤 값
sizes = 1000 * np.random.rand(n)  # 크기용 랜덤 값

plt.figure(figsize=(10, 8))
scatter = plt.scatter(x, y, c=colors, s=sizes, alpha=0.6, 
                      cmap='viridis', edgecolors='black', linewidths=1)

plt.colorbar(scatter, label='색상 값')
plt.title('스타일이 있는 산점도')
plt.xlabel('X 값')
plt.ylabel('Y 값')
plt.grid(True, linestyle='--', alpha=0.7)

# 범례 추가 (크기 기준)
handles, labels = scatter.legend_elements(prop="sizes", alpha=0.6, 
                                          num=4, func=lambda s: s/1000)
plt.legend(handles, labels, loc="upper right", title="크기")

plt.tight_layout()
plt.show()

산점도에서 c 매개변수로 점의 색상을, s 매개변수로 점의 크기를 설정할 수 있어요. 이렇게 하면 2차원 그래프에 추가 차원의 정보를 표현할 수 있답니다! 🎯

6.5 애니메이션 만들기

Matplotlib의 animation 모듈을 사용하면 동적인 그래프를 만들 수 있어요!

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# 데이터 준비
fig, ax = plt.subplots(figsize=(10, 6))
x = np.linspace(0, 2*np.pi, 100)
line, = ax.plot(x, np.sin(x))

ax.set_xlim(0, 2*np.pi)
ax.set_ylim(-1.1, 1.1)
ax.set_title('사인 함수 애니메이션')
ax.grid(True)

# 애니메이션 함수
def animate(i):
    line.set_ydata(np.sin(x + i/10))  # i를 사용해 데이터 업데이트
    return line,

# 애니메이션 생성
ani = animation.FuncAnimation(fig, animate, frames=100, 
                              interval=50, blit=True)

# 애니메이션 저장 (옵션)
# ani.save('sine_wave.gif', writer='pillow', fps=20)

plt.tight_layout()
plt.show()

FuncAnimation 클래스를 사용해 애니메이션을 만들 수 있어요. frames는 총 프레임 수, interval은 프레임 간 시간 간격(ms)을 의미해요. 애니메이션은 GIF나 MP4 파일로 저장할 수도 있답니다! 🎬

7. 실전 데이터 시각화 예제 📈

이제 실제 데이터를 사용한 시각화 예제를 살펴볼게요! 이론보다 실전이 중요하니까요~

7.1 시계열 데이터 시각화

시계열 데이터는 시간에 따른 변화를 보여주는 데이터예요. 주식 가격, 기온 변화 등이 대표적이죠!

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# 시계열 데이터 생성
np.random.seed(42)
start_date = datetime(2023, 1, 1)
dates = [start_date + timedelta(days=i) for i in range(100)]
values = np.cumsum(np.random.randn(100))  # 랜덤 워크 생성

# 데이터프레임 생성
df = pd.DataFrame({'date': dates, 'value': values})

# 시계열 그래프 그리기
plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['value'], 'b-', linewidth=2)
plt.fill_between(df['date'], df['value'], alpha=0.2)  # 영역 채우기

# x축 포맷 설정
plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
plt.gca().xaxis.set_major_locator(mdates.WeekdayLocator(interval=2))
plt.gcf().autofmt_xdate()  # 날짜 레이블 자동 포맷팅

# 그래프 꾸미기
plt.title('시계열 데이터 시각화 예제')
plt.xlabel('날짜')
plt.ylabel('값')
plt.grid(True, linestyle='--', alpha=0.7)

# 이동평균선 추가
df['MA7'] = df['value'].rolling(window=7).mean()  # 7일 이동평균
plt.plot(df['date'], df['MA7'], 'r-', linewidth=2, label='7일 이동평균')

plt.legend()
plt.tight_layout()
plt.show()

시계열 데이터를 시각화할 때는 matplotlib.dates 모듈이 유용해요. 날짜 형식을 지정하고, 이동평균선 같은 추가 정보를 함께 표시하면 더 의미 있는 시각화가 가능하답니다! 📅

7.2 다변량 데이터 시각화

여러 변수가 있는 데이터를 시각화하는 방법을 알아볼게요!

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris

# 아이리스 데이터셋 로드
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target

# 산점도 행렬 그리기
plt.figure(figsize=(12, 10))

# 변수 쌍 조합
features = iris.feature_names
n_features = len(features)

for i in range(n_features):
    for j in range(n_features):
        plt.subplot(n_features, n_features, i*n_features + j + 1)
        
        # 대각선에는 히스토그램
        if i == j:
            for species in range(3):
                plt.hist(df[df['species'] == species][features[i]], 
                         alpha=0.5, bins=15, label=iris.target_names[species])
            plt.title(features[i].split(' (')[0])
        # 나머지는 산점도
        else:
            for species in range(3):
                plt.scatter(df[df['species'] == species][features[j]], 
                            df[df['species'] == species][features[i]], 
                            alpha=0.5, label=iris.target_names[species])
            
            if i == n_features-1:  # 맨 아래 행에만 x축 레이블
                plt.xlabel(features[j].split(' (')[0])
            if j == 0:  # 맨 왼쪽 열에만 y축 레이블
                plt.ylabel(features[i].split(' (')[0])

        plt.xticks([])  # 축 눈금 제거
        plt.yticks([])

# 범례는 한 번만 표시
handles, labels = plt.gca().get_legend_handles_labels()
plt.figlegend(handles, labels, loc='lower center', ncol=3, bbox_to_anchor=(0.5, 0))

plt.tight_layout(rect=[0, 0.05, 1, 0.95])  # 범례 공간 확보
plt.suptitle('아이리스 데이터셋 산점도 행렬', fontsize=16)
plt.show()

이런 산점도 행렬(Scatter Plot Matrix)은 여러 변수 간의 관계를 한눈에 볼 수 있어서 탐색적 데이터 분석(EDA)에 아주 유용해요! 대각선에는 각 변수의 분포를, 나머지 칸에는 변수 간 관계를 보여주는 방식이랍니다. 😊

7.3 지리 데이터 시각화

지도 위에 데이터를 표시하는 방법도 알아볼게요!

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.basemap import Basemap

# 지도 그리기
plt.figure(figsize=(12, 8))
m = Basemap(projection='merc', llcrnrlat=20, urcrnrlat=50,
            llcrnrlon=110, urcrnrlon=150, resolution='i')

# 지도 스타일 설정
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawmapboundary(fill_color='lightblue')
m.fillcontinents(color='lightgreen', lake_color='lightblue')
m.drawparallels(np.arange(20, 51, 10), labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(110, 151, 10), labels=[0, 0, 0, 1])

# 주요 도시 위치 (경도, 위도)
cities = {
    '서울': (126.9780, 37.5665),
    '부산': (129.0756, 35.1796),
    '도쿄': (139.6917, 35.6895),
    '베이징': (116.4074, 39.9042),
    '상하이': (121.4737, 31.2304)
}

# 도시 표시
for city, (lon, lat) in cities.items():
    x, y = m(lon, lat)
    m.plot(x, y, 'ro', markersize=8)
    plt.text(x, y, city, fontsize=12, fontweight='bold',
             ha='right', va='bottom')

plt.title('동아시아 주요 도시')
plt.tight_layout()
plt.show()

지리 데이터 시각화를 위해서는 Basemap 패키지를 사용할 수 있어요. 최근에는 Cartopy라는 패키지도 많이 사용한답니다! 지도 위에 데이터를 표시하면 지역적 패턴을 쉽게 파악할 수 있어요. 🗺️

7.4 금융 데이터 시각화

금융 데이터를 시각화하는 방법도 알아볼게요! 주식 차트 같은 거 말이에요~

import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from matplotlib.finance import candlestick_ohlc

# 주식 데이터 생성 (예시)
np.random.seed(42)
start_date = datetime(2023, 1, 1)
dates = [start_date + timedelta(days=i) for i in range(30)]


# OHLC (Open, High, Low, Close) 데이터 생성
base_price = 100
opens = [base_price]
for i in range(29):
    opens.append(opens[-1] + np.random.normal(0, 2))
    
highs = [o + abs(np.random.normal(0, 1)) for o in opens]
lows = [o - abs(np.random.normal(0, 1)) for o in opens]
closes = [np.random.uniform(l, h) for l, h in zip(lows, highs)]
volumes = [np.random.randint(1000, 5000) for _ in range(30)]

# 데이터프레임 생성
df = pd.DataFrame({
    'date': dates,
    'open': opens,
    'high': highs,
    'low': lows,
    'close': closes,
    'volume': volumes
})

# 날짜를 matplotlib 날짜 형식으로 변환
df['date_num'] = mdates.date2num(df['date'])

# 그래프 그리기
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), gridspec_kw={'height_ratios': [3, 1]})

# 캔들스틱 차트
ohlc = df[['date_num', 'open', 'high', 'low', 'close']].values
candlestick_ohlc(ax1, ohlc, width=0.6, colorup='g', colordown='r')

# x축 포맷 설정
ax1.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
ax1.xaxis.set_major_locator(mdates.WeekdayLocator(interval=1))

# 이동평균선 추가
df['MA5'] = df['close'].rolling(window=5).mean()
df['MA10'] = df['close'].rolling(window=10).mean()
ax1.plot(df['date'], df['MA5'], 'b-', linewidth=1.5, label='MA5')
ax1.plot(df['date'], df['MA10'], 'r-', linewidth=1.5, label='MA10')

ax1.set_title('주식 캔들스틱 차트')
ax1.set_ylabel('가격')
ax1.grid(True, linestyle='--', alpha=0.7)
ax1.legend()

# 거래량 차트
ax2.bar(df['date'], df['volume'], width=0.6, color='gray', alpha=0.5)
ax2.set_ylabel('거래량')
ax2.grid(True, linestyle='--', alpha=0.7)

plt.gcf().autofmt_xdate()  # 날짜 레이블 자동 포맷팅
plt.tight_layout()
plt.show()

금융 데이터는 보통 캔들스틱 차트로 표현해요. 시가(Open), 고가(High), 저가(Low), 종가(Close) 정보를 한 번에 볼 수 있죠! 이동평균선과 거래량 정보도 함께 표시하면 더 풍부한 분석이 가능해요. 📊

8. Matplotlib과 다른 라이브러리 연동하기 🔄

Matplotlib은 다른 파이썬 라이브러리들과 잘 연동돼요. 이런 연동을 통해 더 강력한 시각화가 가능하답니다!

8.1 Pandas와 함께 사용하기

Pandas는 데이터 분석에 특화된 라이브러리로, Matplotlib과 함께 사용하면 정말 편리해요!

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# 데이터프레임 생성
np.random.seed(42)
df = pd.DataFrame({
    '그룹': ['A', 'B', 'C', 'D', 'E'] * 10,
    '값1': np.random.randn(50) * 10 + 50,
    '값2': np.random.randn(50) * 5 + 25
})

# Pandas의 내장 플로팅 기능 사용
plt.figure(figsize=(12, 10))

# 1. 그룹별 평균 막대 그래프
plt.subplot(2, 2, 1)
df.groupby('그룹')['값1'].mean().plot(kind='bar', color='skyblue')
plt.title('그룹별 값1 평균')
plt.ylabel('평균 값')
plt.grid(axis='y', linestyle='--', alpha=0.7)

# 2. 박스 플롯
plt.subplot(2, 2, 2)
df.boxplot(column=['값1', '값2'], grid=True)
plt.title('값1과 값2의 분포')
plt.ylabel('값')

# 3. 산점도
plt.subplot(2, 2, 3)
df.plot(kind='scatter', x='값1', y='값2', alpha=0.6, 
        c=pd.Categorical(df['그룹']).codes, cmap='viridis', 
        s=50, edgecolors='black')
plt.title('값1 vs 값2 산점도')
plt.grid(True, linestyle='--', alpha=0.7)

# 4. 히스토그램
plt.subplot(2, 2, 4)
df['값1'].plot(kind='hist', bins=15, alpha=0.7, color='orange')
plt.title('값1 히스토그램')
plt.xlabel('값')
plt.ylabel('빈도')
plt.grid(True, linestyle='--', alpha=0.7)

plt.tight_layout()
plt.show()

Pandas의 plot() 메서드는 내부적으로 Matplotlib을 사용해요. kind 매개변수로 그래프 유형을 지정할 수 있어서 정말 편리하답니다! 'bar', 'line', 'scatter', 'hist', 'box' 등 다양한 그래프를 쉽게 그릴 수 있어요. 👍

8.2 Seaborn과 함께 사용하기

Seaborn은 Matplotlib을 기반으로 한 고급 시각화 라이브러리예요. 더 예쁘고 정보가 풍부한 그래프를 쉽게 그릴 수 있답니다!

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

# 데이터 준비
np.random.seed(42)
df = pd.DataFrame({
    '그룹': np.random.choice(['A', 'B', 'C'], 100),
    '변수1': np.random.normal(0, 1, 100),
    '변수2': np.random.normal(5, 2, 100),
    '변수3': np.random.normal(-3, 1.5, 100)
})

# Seaborn 스타일 설정
sns.set(style="whitegrid")

plt.figure(figsize=(12, 10))

# 1. 향상된 산점도 (regplot)
plt.subplot(2, 2, 1)
sns.regplot(x='변수1', y='변수2', data=df, scatter_kws={'alpha':0.5})
plt.title('회귀선이 있는 산점도')

# 2. 바이올린 플롯
plt.subplot(2, 2, 2)
sns.violinplot(x='그룹', y='변수1', data=df, palette='Set3')
plt.title('그룹별 변수1 분포 (바이올린 플롯)')

# 3. 히트맵
plt.subplot(2, 2, 3)
corr = df[['변수1', '변수2', '변수3']].corr()
sns.heatmap(corr, annot=True, cmap='coolwarm', vmin=-1, vmax=1)
plt.title('상관관계 히트맵')

# 4. 쌍별 산점도 (pairplot은 별도 그림으로)
plt.subplot(2, 2, 4)
sns.kdeplot(data=df['변수1'], shade=True, color='r', label='변수1')
sns.kdeplot(data=df['변수2'], shade=True, color='g', label='변수2')
sns.kdeplot(data=df['변수3'], shade=True, color='b', label='변수3')
plt.title('커널 밀도 추정 플롯')
plt.legend()

plt.tight_layout()
plt.show()

# 별도로 쌍별 산점도 그리기
sns.pairplot(df[['변수1', '변수2', '변수3', '그룹']], hue='그룹', diag_kind='kde')
plt.suptitle('쌍별 산점도', y=1.02)
plt.show()

Seaborn은 regplot, violinplot, heatmap, pairplot 등 다양한 고급 시각화 함수를 제공해요. 특히 통계적 시각화에 강점이 있어서 데이터 분석에 아주 유용하답니다! 🎨

8.3 Plotly와 함께 사용하기

Plotly는 인터랙티브한 시각화를 위한 라이브러리예요. Matplotlib 그래프를 Plotly로 변환할 수 있답니다!

import matplotlib.pyplot as plt
import plotly.express as px
import pandas as pd
import numpy as np
from plotly.tools import mpl_to_plotly

# 데이터 준비
np.random.seed(42)
df = pd.DataFrame({
    'x': np.random.normal(0, 1, 100),
    'y': np.random.normal(0, 1, 100),
    '그룹': np.random.choice(['A', 'B', 'C'], 100),
    '크기': np.random.randint(10, 100, 100)
})

# 1. Matplotlib로 그래프 그리기
fig_mpl, ax = plt.subplots(figsize=(10, 6))
scatter = ax.scatter(df['x'], df['y'], c=pd.Categorical(df['그룹']).codes, 
                    s=df['크기'], alpha=0.6, cmap='viridis')
ax.set_title('Matplotlib 산점도')
ax.set_xlabel('x 값')
ax.set_ylabel('y 값')
ax.grid(True)
legend1 = ax.legend(*scatter.legend_elements(num=3),
                    loc="upper right", title="그룹")
ax.add_artist(legend1)

# Matplotlib 그래프를 Plotly로 변환 (실제로는 아래 코드 사용)
# fig_plotly = mpl_to_plotly(fig_mpl)
# fig_plotly.show()

# 2. 직접 Plotly Express 사용 (더 간단)
fig_px = px.scatter(df, x='x', y='y', color='그룹', size='크기',
                   title='Plotly Express 산점도',
                   labels={'x': 'x 값', 'y': 'y 값'},
                   hover_data=['x', 'y', '그룹', '크기'])

# Jupyter Notebook에서 표시
# fig_px.show()

# HTML 파일로 저장
# fig_px.write_html('interactive_scatter.html')

plt.show()  # Matplotlib 그래프 표시

Plotly는 인터랙티브한 그래프를 만들 수 있어서 데이터 탐색에 아주 유용해요! 줌인/줌아웃, 호버 정보 표시, 그래프 저장 등 다양한 기능을 제공한답니다. 웹 기반 대시보드를 만들 때 특히 좋아요! 🌐

9. 실무에서 자주 사용하는 Matplotlib 팁과 트릭 💡

이제 실무에서 정말 유용하게 쓰이는 Matplotlib 팁과 트릭을 알아볼게요! 이것만 알아도 여러분의 데이터 시각화 실력이 한층 업그레이드될 거예요.

9.1 그래프 저장하기

만든 그래프를 다양한 형식으로 저장할 수 있어요!

import matplotlib.pyplot as plt
import numpy as np

# 간단한 그래프 생성
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2)
plt.title('사인 함수')
plt.xlabel('x 값')
plt.ylabel('sin(x)')
plt.grid(True)

# 다양한 형식으로 저장
plt.savefig('sine_function.png', dpi=300)  # PNG 형식 (300 DPI)
plt.savefig('sine_function.pdf')  # PDF 형식 (벡터 그래픽)
plt.savefig('sine_function.svg')  # SVG 형식 (벡터 그래픽)
plt.savefig('sine_function.jpg', quality=95)  # JPG 형식 (95% 품질)

# 투명한 배경으로 저장
plt.savefig('sine_function_transparent.png', dpi=300, transparent=True)

plt.show()

savefig() 함수로 그래프를 다양한 형식으로 저장할 수 있어요. dpi 매개변수로 해상도를 조절하고, transparent=True로 배경을 투명하게 만들 수 있답니다! 프레젠테이션이나 보고서에 넣을 때 유용해요. 💾

9.2 그래프 크기와 비율 조절하기

그래프의 크기와 비율을 세밀하게 조절하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 1. figsize로 크기 지정
plt.figure(figsize=(10, 6))  # 가로 10인치, 세로 6인치
plt.plot(x, y)
plt.title('figsize로 크기 지정')
plt.tight_layout()
plt.show()

# 2. 비율 유지하면서 크기 조절
fig, ax = plt.subplots(figsize=(8, 8))
ax.plot(x, y)
ax.set_title('정사각형 그래프')
ax.set_aspect('equal')  # x축과 y축의 스케일을 동일하게 설정
plt.tight_layout()
plt.show()

# 3. 특정 영역 확대
plt.figure(figsize=(10, 6))
plt.plot(x, y)
plt.title('특정 영역 확대')
plt.xlim(4, 6)  # x축 범위 제한
plt.ylim(-0.2, 0.2)  # y축 범위 제한
plt.grid(True)
plt.tight_layout()
plt.show()

# 4. 여백 조절
plt.figure(figsize=(10, 6))
plt.plot(x, y)
plt.title('여백 조절')
plt.subplots_adjust(left=0.15, right=0.95, top=0.9, bottom=0.15)  # 여백 조절
plt.grid(True)
plt.show()

figsize로 그래프 크기를, set_aspect로 축 비율을, xlim/ylim으로 축 범위를, subplots_adjust로 여백을 조절할 수 있어요. 이런 세부 조정으로 더 보기 좋은 그래프를 만들 수 있답니다! 📏

9.3 그래프에 워터마크 추가하기

그래프에 워터마크나 로고를 추가하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.offsetbox import OffsetImage, AnnotationBbox

# 데이터 준비
x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2)
plt.title('워터마크가 있는 그래프')
plt.xlabel('x 값')
plt.ylabel('sin(x)')
plt.grid(True)

# 텍스트 워터마크 추가
plt.figtext(0.5, 0.5, '워터마크', fontsize=40, color='gray',
            ha='center', va='center', alpha=0.2, rotation=30)

# 이미지 워터마크 추가 (로고 이미지가 있는 경우)
# from PIL import Image
# logo = np.array(Image.open('logo.png'))
# imagebox = OffsetImage(logo, zoom=0.1, alpha=0.3)
# ab = AnnotationBbox(imagebox, (5, 0), frameon=False)
# plt.gca().add_artist(ab)

plt.tight_layout()
plt.show()

figtext()로 텍스트 워터마크를, AnnotationBbox와 OffsetImage로 이미지 워터마크를 추가할 수 있어요. alpha 매개변수로 투명도를 조절하면 원래 그래프를 방해하지 않게 할 수 있답니다! 👀

9.4 그래프에 테이블 추가하기

그래프 아래에 데이터 테이블을 추가하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np

# 데이터 준비
categories = ['A', 'B', 'C', 'D', 'E']
values = [22, 35, 48, 27, 40]

# 막대 그래프 그리기
fig, ax = plt.subplots(figsize=(10, 8))
bars = ax.bar(categories, values, color='skyblue', edgecolor='navy')

# 막대 위에 값 표시
for bar in bars:
    height = bar.get_height()
    ax.text(bar.get_x() + bar.get_width()/2., height + 1,
            f'{height}', ha='center', va='bottom')

ax.set_title('테이블이 있는 막대 그래프')
ax.set_xlabel('카테고리')
ax.set_ylabel('값')
ax.set_ylim(0, max(values) + 10)

# 테이블 데이터 준비
table_data = [values]
table_rows = ['값']
table_cols = categories

# 테이블 추가
table = ax.table(cellText=table_data, rowLabels=table_rows, colLabels=table_cols,
                loc='bottom', cellLoc='center', bbox=[0, -0.3, 1, 0.2])
table.auto_set_font_size(False)
table.set_fontsize(12)
table.scale(1, 1.5)  # 테이블 크기 조절

# 그래프 여백 조정 (테이블 공간 확보)
plt.subplots_adjust(bottom=0.25)
plt.tight_layout()
plt.show()

ax.table() 함수로 그래프 아래에 데이터 테이블을 추가할 수 있어요. 이렇게 하면 그래프와 함께 정확한 데이터 값도 보여줄 수 있어서 프레젠테이션이나 보고서에 아주 유용하답니다! 📊

9.5 대화형 그래프 만들기

Matplotlib에서도 간단한 대화형 기능을 추가할 수 있어요!

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.widgets import Slider, Button, RadioButtons

# 초기 데이터
t = np.linspace(0, 10, 1000)
a0 = 5
f0 = 3
s = a0 * np.sin(2 * np.pi * f0 * t)

# 그래프 설정
fig, ax = plt.subplots(figsize=(10, 8))
plt.subplots_adjust(bottom=0.25)  # 슬라이더 공간 확보
line, = ax.plot(t, s, lw=2)
ax.set_xlabel('시간 [초]')
ax.set_ylabel('진폭')
ax.grid(True)

# 슬라이더 영역 생성
ax_freq = plt.axes([0.25, 0.15, 0.65, 0.03])
ax_amp = plt.axes([0.25, 0.1, 0.65, 0.03])

# 슬라이더 생성
s_freq = Slider(ax_freq, '주파수', 0.1, 10.0, valinit=f0)
s_amp = Slider(ax_amp, '진폭', 0.1, 10.0, valinit=a0)

# 슬라이더 업데이트 함수
def update(val):
    freq = s_freq.val
    amp = s_amp.val
    line.set_ydata(amp * np.sin(2 * np.pi * freq * t))
    fig.canvas.draw_idle()

# 슬라이더에 업데이트 함수 연결
s_freq.on_changed(update)
s_amp.on_changed(update)

# 리셋 버튼 영역 생성
ax_reset = plt.axes([0.8, 0.025, 0.1, 0.04])
button = Button(ax_reset, '리셋', color='lightgoldenrodyellow', hovercolor='0.975')

# 리셋 버튼 함수
def reset(event):
    s_freq.reset()
    s_amp.reset()
button.on_clicked(reset)

plt.suptitle('대화형 사인 파형 그래프')
plt.show()

Matplotlib의 widgets 모듈을 사용하면 슬라이더, 버튼, 라디오 버튼 등의 대화형 요소를 추가할 수 있어요. 이렇게 하면 사용자가 직접 매개변수를 조절하며 데이터를 탐색할 수 있답니다! 🎛️

10. Matplotlib 성능 최적화 및 고급 기법 🚀

마지막으로, Matplotlib의 성능을 최적화하고 더 고급 기법을 사용하는 방법을 알아볼게요!

10.1 대용량 데이터 처리하기

대용량 데이터를 효율적으로 시각화하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np
import time

# 대용량 데이터 생성
n_points = 1000000  # 백만 개의 점
np.random.seed(42)
x = np.random.randn(n_points)
y = np.random.randn(n_points)

# 1. 일반 산점도 (느림)
start_time = time.time()
plt.figure(figsize=(10, 6))
plt.scatter(x[:10000], y[:10000])  # 일부만 표시 (전체는 너무 느림)
plt.title('일반 산점도 (10,000개 점)')
plt.grid(True)
print(f"일반 산점도 시간: {time.time() - start_time:.2f}초")
plt.show()

# 2. plot 함수 사용 (빠름)
start_time = time.time()
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'o', markersize=1, alpha=0.5)
plt.title('plot 함수로 그린 산점도 (1,000,000개 점)')
plt.grid(True)
print(f"plot 함수 시간: {time.time() - start_time:.2f}초")
plt.show()

# 3. 히스토그램 2D 사용 (매우 빠름, 밀도 표현)
start_time = time.time()
plt.figure(figsize=(10, 6))
plt.hist2d(x, y, bins=100, cmap='viridis')
plt.colorbar(label='빈도')
plt.title('2D 히스토그램 (1,000,000개 점)')
plt.grid(True)
print(f"히스토그램 2D 시간: {time.time() - start_time:.2f}초")
plt.show()

# 4. hexbin 사용 (육각형 빈, 밀도 표현)
start_time = time.time()
plt.figure(figsize=(10, 6))
plt.hexbin(x, y, gridsize=100, cmap='inferno')
plt.colorbar(label='빈도')
plt.title('Hexbin 플롯 (1,000,000개 점)')
plt.grid(True)
print(f"Hexbin 시간: {time.time() - start_time:.2f}초")
plt.show()

대용량 데이터를 시각화할 때는 scatter() 대신 plot()을 사용하거나, hist2d()나 hexbin()으로 밀도를 표현하는 것이 훨씬 효율적이에요! 이렇게 하면 수백만 개의 데이터 포인트도 빠르게 시각화할 수 있답니다. 🚄

10.2 블렌딩과 투명도 활용하기

겹치는 데이터를 효과적으로 표현하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LinearSegmentedColormap

# 데이터 준비
np.random.seed(42)
n_points = 1000
x1 = np.random.normal(0, 1, n_points)
y1 = np.random.normal(0, 1, n_points)
x2 = np.random.normal(1, 1, n_points)
y2 = np.random.normal(1, 1, n_points)

plt.figure(figsize=(15, 5))

# 1. 기본 산점도
plt.subplot(1, 3, 1)
plt.scatter(x1, y1, color='blue', alpha=0.5, edgecolor='none')
plt.scatter(x2, y2, color='red', alpha=0.5, edgecolor='none')
plt.title('기본 산점도 (알파 블렌딩)')
plt.grid(True)

# 2. 2D 히스토그램 블렌딩
plt.subplot(1, 3, 2)
plt.hist2d(x1, y1, bins=50, cmap='Blues', alpha=0.7, density=True)
plt.hist2d(x2, y2, bins=50, cmap='Reds', alpha=0.7, density=True)
plt.title('2D 히스토그램 블렌딩')
plt.grid(True)

# 3. 커스텀 컬러맵 사용
plt.subplot(1, 3, 3)
# 두 분포의 밀도 계산
H1, xedges, yedges = np.histogram2d(x1, y1, bins=50, density=True)
H2, _, _ = np.histogram2d(x2, y2, bins=50, density=True)

# 두 밀도의 차이 계산 (-1 ~ 1 범위)
H_diff = (H1 - H2) / np.maximum(H1 + H2, 1e-10)

# 커스텀 컬러맵 생성 (파랑-흰색-빨강)
cmap = LinearSegmentedColormap.from_list('BrWr', ['blue', 'white', 'red'])

# 차이 시각화
plt.pcolormesh(xedges, yedges, H_diff.T, cmap=cmap, vmin=-1, vmax=1)
plt.colorbar(label='분포 차이')
plt.title('분포 차이 시각화')
plt.grid(True)

plt.tight_layout()
plt.show()

블렌딩과 투명도를 활용하면 겹치는 데이터를 효과적으로 시각화할 수 있어요. alpha 매개변수로 투명도를 조절하고, 커스텀 컬러맵을 사용해 데이터 간의 차이를 강조할 수 있답니다! 🎭

10.3 벡터 필드와 스트림 플롯

벡터 필드와 흐름을 시각화하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np

# 그리드 생성
x = np.linspace(-2, 2, 20)
y = np.linspace(-2, 2, 20)
X, Y = np.meshgrid(x, y)

# 벡터 필드 정의 (예: 회전 필드)
U = -Y
V = X

plt.figure(figsize=(15, 5))

# 1. 벡터 필드 (quiver)
plt.subplot(1, 3, 1)
plt.quiver(X, Y, U, V, scale=25)
plt.title('벡터 필드 (Quiver)')
plt.grid(True)
plt.axis('equal')

# 2. 스트림 플롯
plt.subplot(1, 3, 2)
plt.streamplot(X, Y, U, V, density=1.5, color='blue', linewidth=1)
plt.title('스트림 플롯')
plt.grid(True)
plt.axis('equal')

# 3. 색상이 있는 스트림 플롯
plt.subplot(1, 3, 3)
speed = np.sqrt(U**2 + V**2)
plt.streamplot(X, Y, U, V, density=1.5, color=speed, cmap='viridis',
              linewidth=2*speed/speed.max())
plt.colorbar(label='속도')
plt.title('속도로 색상화된 스트림 플롯')
plt.grid(True)
plt.axis('equal')

plt.tight_layout()
plt.show()

quiver()로 벡터 필드를, streamplot()으로 흐름을 시각화할 수 있어요. 이런 그래프는 유체 역학, 전자기학, 기상학 등의 분야에서 아주 유용하답니다! 🌊

10.4 이미지 처리와 시각화

이미지 데이터를 처리하고 시각화하는 방법이에요!

import matplotlib.pyplot as plt
import numpy as np
from skimage import data
from scipy import ndimage

# 샘플 이미지 로드
image = data.camera()

plt.figure(figsize=(15, 10))

# 1. 원본 이미지
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('원본 이미지')
plt.axis('off')

# 2. 히스토그램
plt.subplot(2, 3, 2)
plt.hist(image.ravel(), bins=256, range=(0, 256), color='gray', alpha=0.7)
plt.title('픽셀 값 히스토그램')
plt.xlabel('픽셀 값')
plt.ylabel('빈도')
plt.grid(True)

# 3. 가우시안 블러
blurred = ndimage.gaussian_filter(image, sigma=5)
plt.subplot(2, 3, 3)
plt.imshow(blurred, cmap='gray')
plt.title('가우시안 블러 (sigma=5)')
plt.axis('off')

# 4. 소벨 엣지 검출
sobel_x = ndimage.sobel(image, axis=0)
sobel_y = ndimage.sobel(image, axis=1)
sobel = np.hypot(sobel_x, sobel_y)
sobel = sobel / sobel.max()
plt.subplot(2, 3, 4)
plt.imshow(sobel, cmap='viridis')
plt.title('소벨 엣지 검출')
plt.axis('off')

# 5. 컬러맵 적용
plt.subplot(2, 3, 5)
plt.imshow(image, cmap='hot')
plt.title('Hot 컬러맵')
plt.axis('off')

# 6. 3D 표면 플롯
ax = plt.subplot(2, 3, 6, projection='3d')
x, y = np.mgrid[0:image.shape[0]:5, 0:image.shape[1]:5]
z = image[::5, ::5]
ax.plot_surface(x, y, z, cmap='viridis', edgecolor='none')
ax.set_title('3D 표면 플롯')
ax.set_zlim(0, 255)
ax.view_init(60, 35)

plt.tight_layout()
plt.show()

Matplotlib은 imshow() 함수로 이미지를 표시하고, 다양한 방식으로 이미지 데이터를 시각화할 수 있어요. 히스토그램, 엣지 검출, 3D 표면 플롯 등 다양한 기법을 활용해 이미지 데이터를 분석할 수 있답니다! 📷

10.5 인터랙티브 시각화와 애니메이션

인터랙티브한 시각화와 애니메이션을 만드는 방법이에요!

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
from IPython.display import HTML

# 애니메이션 데이터 준비
fig, ax = plt.subplots(figsize=(10, 6))
x = np.linspace(0, 2*np.pi, 100)
line, = ax.plot(x, np.sin(x))

ax.set_xlim(0, 2*np.pi)
ax.set_ylim(-1.1, 1.1)
ax.set_title('사인 파형 애니메이션')
ax.grid(True)

# 애니메이션 함수
def animate(i):
    line.set_ydata(np.sin(x + i/10))
    return line,

# 애니메이션 생성
ani = animation.FuncAnimation(fig, animate, frames=100, interval=50, blit=True)

# HTML로 변환 (Jupyter Notebook에서 표시)
# HTML(ani.to_jshtml())

# 애니메이션 저장
# ani.save('sine_wave.gif', writer='pillow', fps=20)
# ani.save('sine_wave.mp4', writer='ffmpeg', fps=20)

plt.show()

Matplotlib의 animation 모듈을 사용하면 동적인 시각화를 만들 수 있어요. FuncAnimation 클래스로 프레임별로 데이터를 업데이트하고, GIF나 MP4 파일로 저장할 수 있답니다! 🎬