달나라 노트

Python numpy : nan_to_num

CosmosProject — Wed, 20 May 2026 21:59:11 +0900

NumPy `nan_to_num()` — NaN과 무한대를 안전한 값으로 교체하는 함수

nan_to_num()은 배열에서 NaN, 양의 무한대(inf), 음의 무한대(-inf)를 지정한 값으로 교체하는 함수입니다. 수치 연산 전에 배열을 안전한 상태로 만들 때 씁니다.

기본 동작

np.nan_to_num(x)
# NaN  → 0
# inf  → 매우 큰 양수 (시스템 최댓값)
# -inf → 매우 큰 음수 (시스템 최솟값)

기본 문법

numpy.nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None)

파라미터	기본값	설명
`nan`	`0.0`	NaN 대체값
`posinf`	시스템 최댓값	양의 무한대 대체값
`neginf`	시스템 최솟값	음의 무한대 대체값
`copy`	`True`	`False`면 원본 직접 수정

작동 방식

기본 동작

import numpy as np

a = np.array([1.0, np.nan, np.inf, -np.inf, 5.0])

np.nan_to_num(a)
# array([ 1.00e+000,  0.00e+000,  1.80e+308, -1.80e+308,  5.00e+000])
#              ↑ NaN→0      ↑ inf→최댓값    ↑ -inf→최솟값

대체값 직접 지정

np.nan_to_num(a, nan=0, posinf=999, neginf=-999)
# array([  1.,   0., 999., -999.,   5.])

`copy=False` — 원본 직접 수정

a = np.array([1.0, np.nan, np.inf])

np.nan_to_num(a, copy=False)   # 원본 a가 바뀜
print(a)
# array([1., 0., 1.8e+308])

스칼라 입력

np.nan_to_num(np.nan)           # 0.0
np.nan_to_num(np.inf)           # 1.7976931348623157e+308
np.nan_to_num(-np.inf)          # -1.7976931348623157e+308

np.nan_to_num(np.nan, nan=-1)   # -1.0

inf는 언제 생기나?

np.log(0)                                      # -inf  ← 0의 로그
1 / np.array([0.0])                            # inf   ← 0으로 나누기
np.array([np.inf]) - np.array([np.inf])        # nan   ← inf - inf

이런 연산 결과를 그대로 두면 이후 모든 계산이 오염됩니다. nan_to_num으로 선제 처리합니다.

응용 사례 1 — 로그 변환 후 정제

data = np.array([0.0, 1.0, 10.0, 100.0])

log_data = np.log(data)
# array([-inf,  0.,  2.30,  4.60])   ← 0의 로그 = -inf

safe_log = np.nan_to_num(log_data, neginf=0)
# array([0., 0., 2.30, 4.60])

응용 사례 2 — 비율 계산 (0으로 나누기 방지)

a = np.array([10.0, 0.0, 30.0])
b = np.array([2.0,  0.0,  5.0])

# a/b → [5., nan, 6.]  (0/0=nan, x/0=inf 발생 가능)
ratio = np.nan_to_num(a / b, nan=0, posinf=0)
# array([5., 0., 6.])

응용 사례 3 — 머신러닝 피처 전처리

features = np.array([[1.0, np.nan, 3.0],
                     [np.inf, 5.0, -np.inf],
                     [7.0, 8.0, 9.0]])

clean = np.nan_to_num(features, nan=0, posinf=0, neginf=0)
# array([[1., 0., 3.],
#        [0., 5., 0.],
#        [7., 8., 9.]])

모델에 NaN이나 inf가 들어가면 학습이 망가지기 때문에 전처리 단계에서 반드시 처리합니다.

응용 사례 4 — 코사인 유사도 행렬 정제

# 벡터 크기가 0인 경우 코사인 유사도가 NaN이 될 수 있음
similarity = np.array([[1.0, np.nan, 0.8],
                       [np.nan, 1.0, 0.6],
                       [0.8, 0.6, 1.0]])

clean_sim = np.nan_to_num(similarity, nan=0.0)
# NaN 위치를 0(유사도 없음)으로 처리
# array([[1. , 0. , 0.8],
#        [0. , 1. , 0.6],
#        [0.8, 0.6, 1. ]])

`nan_to_num` vs pandas `fillna`

import pandas as pd

s = pd.Series([1.0, np.nan, np.inf])

s.fillna(0)
# 0    1.0
# 1    0.0
# 2    inf   ← inf는 처리 안 됨

np.nan_to_num(s.values, nan=0, posinf=0)
# array([1., 0., 0.])   ← NaN + inf 모두 처리

	`nan_to_num`	pandas `fillna`
NaN 처리	O	O
inf 처리	O	X
대상	NumPy 배열	pandas Series / DataFrame

핵심 직관: nan_to_num은 배열을 수치 연산에 "안전한 상태"로 만드는 안전망입니다. 로그·나눗셈 등 inf가 생길 수 있는 연산 직후, 또는 모델 입력 직전에 씁니다.

Python Pandas : map

CosmosProject — Wed, 20 May 2026 21:54:14 +0900

Pandas `map()` — 딕셔너리·함수·Series로 값을 1:1 변환하는 메서드

map()은 Series의 각 값을 다른 값으로 변환하는 메서드입니다. 딕셔너리, 함수, 또는 다른 Series를 기준으로 element-wise 변환하며, 코드값을 레이블로 바꾸거나 외부 테이블 기준으로 값을 붙이는 작업에 가장 자주 씁니다.

주의: map()은 Series 전용입니다. DataFrame 전체에 적용하려면 apply() 또는 map()(pandas 2.1+)을 씁니다.

기본 문법

Series.map(arg, na_action=None)

파라미터	설명
`arg`	딕셔너리, 함수, Series 중 하나
`na_action`	`None`(기본) 또는 `'ignore'` — NaN을 변환하지 않고 그대로 유지

1. 딕셔너리로 값 치환

딕셔너리에 없는 값은 자동으로 NaN이 됩니다.

import pandas as pd

grade = pd.Series(['A', 'B', 'C', 'A', 'B'])

grade.map({'A': '우수', 'B': '보통', 'C': '미흡'})
# 0    우수
# 1    보통
# 2    미흡
# 3    우수
# 4    보통

grade2 = pd.Series(['A', 'B', 'D'])   # 'D'는 딕셔너리에 없음
grade2.map({'A': '우수', 'B': '보통', 'C': '미흡'})
# 0     우수
# 1     보통
# 2     NaN   ← 매핑 없으면 NaN

2. 함수로 변환

prices = pd.Series([1000, 2500, 800, 3200])

prices.map(lambda x: x * 1.1)   # 10% 인상
# 0    1100.0
# 1    2750.0
# 2     880.0
# 3    3520.0

def grade_label(score):
    if   score >= 90: return 'A'
    elif score >= 80: return 'B'
    else:             return 'C'

scores = pd.Series([95, 82, 74, 88])
scores.map(grade_label)
# 0    A
# 1    B
# 2    C
# 3    B

3. Series로 변환 (인덱스 기준 매핑)

code    = pd.Series(['KR', 'US', 'JP', 'KR'])
mapping = pd.Series({'KR': '한국', 'US': '미국', 'JP': '일본'})

code.map(mapping)
# 0    한국
# 1    미국
# 2    일본
# 3    한국

4. `na_action='ignore'` — NaN 건드리지 않기

s = pd.Series(['A', None, 'B'])

s.map({'A': 1, 'B': 2})
# 0    1.0
# 1    NaN   ← None도 변환 시도 → NaN
# 2    2.0

s.map({'A': 1, 'B': 2}, na_action='ignore')
# 0       1
# 1    None   ← None 그대로 유지
# 2       2

`map` vs `apply` vs `replace`

	`map`	`apply`	`replace`
대상	Series	Series, DataFrame	Series, DataFrame
딕셔너리 미매핑	NaN	—	원래 값 유지
주 용도	값 치환/변환	복잡한 연산	특정 값만 바꾸기

s = pd.Series([1, 2, 3])

s.map({1: 'a', 2: 'b'})      # 3 → NaN
s.replace({1: 'a', 2: 'b'})  # 3 → 3 (그대로)

응용 사례 1 — 코드값을 레이블로 변환

df = pd.DataFrame({
    '이름':   ['철수', '영희', '민준'],
    '성별코드': [1, 2, 1],
    '등급코드': ['A', 'C', 'B']
})

df['성별'] = df['성별코드'].map({1: '남', 2: '여'})
df['등급'] = df['등급코드'].map({'A': '우수', 'B': '보통', 'C': '미흡'})
#    이름  성별코드 등급코드  성별  등급
# 0  철수     1    A      남   우수
# 1  영희     2    C      여   미흡
# 2  민준     1    B      남   보통

응용 사례 2 — 구간별 레이블 (점수 → 등급)

scores = pd.Series([95, 82, 74, 61, 88])

def to_grade(score):
    if   score >= 90: return 'A'
    elif score >= 80: return 'B'
    elif score >= 70: return 'C'
    else:             return 'D'

scores.map(to_grade)
# 0    A
# 1    B
# 2    C
# 3    D
# 4    B

응용 사례 3 — 외부 테이블과 조인 대용

# 지역코드 테이블
region_name = pd.Series({'SEL': '서울', 'PUS': '부산', 'ICN': '인천'})

orders = pd.DataFrame({
    '주문번호': [1, 2, 3, 4],
    '지역코드': ['SEL', 'PUS', 'SEL', 'ICN']
})

orders['지역명'] = orders['지역코드'].map(region_name)
#    주문번호 지역코드  지역명
# 0     1    SEL    서울
# 1     2    PUS    부산
# 2     3    SEL    서울
# 3     4    ICN    인천

응용 사례 4 — 문자열 전처리

raw = pd.Series(['  서울 ', 'BUSAN', '인 천'])

raw.map(str.strip)                       # 앞뒤 공백 제거
raw.map(str.lower)                       # 소문자 변환
raw.map(lambda x: x.replace(' ', ''))   # 내부 공백 제거

핵심 요약

	내용
대상	Series 전용
입력 형태	딕셔너리, 함수, Series
미매핑 값	`NaN` (딕셔너리 사용 시)
`na_action='ignore'`	NaN은 변환 없이 유지
vs `replace`	미매핑 시 NaN 반환 vs 원래 값 유지

핵심 직관: map은 "값 → 값" 1:1 변환 전용입니다. 코드값을 사람이 읽기 좋은 레이블로 바꾸거나, 외부 테이블 기준으로 값을 붙이는 작업에 가장 자주 씁니다.

Python Pandas : agg (열마다 다른 집계함수 적용)

CosmosProject — Wed, 20 May 2026 21:50:34 +0900

Pandas `agg()` — 열마다 다른 집계 함수를 한 번에 적용하는 메서드

agg()는 DataFrame이나 GroupBy 객체에 집계 함수를 적용하는 메서드입니다. 단일 함수는 물론, 열마다 다른 함수를 적용하거나 여러 함수를 한 번에 실행할 수 있습니다.

기본 문법

DataFrame.agg(func, axis=0)
GroupBy.agg(func)

func 형태	예시	결과
문자열	`agg('sum')`	Series
리스트	`agg(['sum', 'mean'])`	DataFrame (함수명이 행)
딕셔너리	`agg({'A': 'sum', 'B': 'mean'})`	DataFrame (열별 다른 함수)
Named agg	`agg(결과명=('열', '함수'))`	깔끔한 DataFrame

1. 단일 함수

import pandas as pd

df = pd.DataFrame({
    '매출': [100, 200, 150, 300],
    '수량': [10,  20,  15,  30]
})

df.agg('sum')
# 매출    750
# 수량     75
# dtype: int64

2. 여러 함수를 리스트로

df.agg(['sum', 'mean', 'max'])
#        매출     수량
# sum   750.0   75.00
# mean  187.5   18.75
# max   300.0   30.00

3. 열마다 다른 함수를 딕셔너리로

df.agg({
    '매출': ['sum', 'mean'],
    '수량': 'max'
})
#        매출    수량
# sum   750.0   NaN
# mean  187.5   NaN
# max    NaN   30.0

4. `groupby` + `agg` — 가장 많이 쓰는 패턴

sales = pd.DataFrame({
    '지역':  ['서울', '서울', '부산', '부산', '서울'],
    '매출':  [100, 200, 150, 300, 120],
    '수량':  [10,  20,  15,  30,  12]
})

sales.groupby('지역').agg({
    '매출': ['sum', 'mean'],
    '수량': 'sum'
})
#        매출              수량
#         sum    mean      sum
# 지역
# 부산    450  225.0       45
# 서울    420  140.0       42

5. Named Aggregation — 결과 컬럼명 직접 지정

멀티인덱스 컬럼 없이 깔끔한 결과를 얻을 수 있어 실무에서 가장 선호하는 패턴입니다.

sales.groupby('지역').agg(
    매출합계=('매출', 'sum'),
    평균매출=('매출', 'mean'),
    총수량  =('수량', 'sum')
)
#        매출합계  평균매출  총수량
# 지역
# 부산      450   225.0     45
# 서울      420   140.0     42

6. 커스텀 함수 적용

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

sales.groupby('지역').agg(
    매출범위=('매출', range_val),
    매출합계=('매출', 'sum')
)
#        매출범위  매출합계
# 지역
# 부산      150      450
# 서울      100      420

응용 사례 1 — 데이터 품질 점검

df = pd.DataFrame({
    '나이':  [25, None, 30, 22, None],
    '점수':  [80, 90,  None, 70, 85]
})

df.agg(
    건수   =('나이', 'count'),
    결측수  =('나이', lambda x: x.isna().sum()),
    평균나이 =('나이', 'mean'),
    평균점수 =('점수', 'mean')
)
#          나이    점수
# 건수      3.0    4.0
# 결측수    2.0    1.0
# 평균나이  25.7   NaN
# 평균점수   NaN  81.25

응용 사례 2 — 기간별 매출 리포트

report = sales_df.groupby('월').agg(
    총매출  =('매출', 'sum'),
    평균매출 =('매출', 'mean'),
    최대매출 =('매출', 'max'),
    거래건수 =('매출', 'count')
).round(1)
#     총매출  평균매출  최대매출  거래건수
# 월
# 1   1200   240.0    500      5
# 2   1450   290.0    620      5
# 3   1380   276.0    480      5

응용 사례 3 — 다중 그룹 집계

result = sales.groupby(['지역', '카테고리']).agg(
    매출합계=('매출', 'sum'),
    평균단가=('단가', 'mean'),
    판매량  =('수량', 'sum')
)
#               매출합계  평균단가  판매량
# 지역  카테고리
# 부산  식품        350     8.5     42
#      전자        480    24.0     20
# 서울  식품        290     7.2     40
#      전자        620    31.0     20

자주 쓰는 집계 함수 목록

문자열	의미
`'sum'`	합계
`'mean'`	평균
`'median'`	중앙값
`'min'` / `'max'`	최솟값 / 최댓값
`'count'`	비결측 건수
`'nunique'`	고유값 수
`'std'` / `'var'`	표준편차 / 분산
`'first'` / `'last'`	첫 번째 / 마지막 값

핵심 직관: agg는 "여러 집계를 한 번에 정의하는 선언문"입니다. groupby 이후 Named Aggregation 패턴(결과명=('열', '함수'))이 가독성과 편의성 모두 가장 좋습니다.

Python Pandas : div (나눗셈)

CosmosProject — Wed, 20 May 2026 21:47:40 +0900

Pandas `div()` — axis와 fill_value로 나눗셈 방향과 결측치를 제어하는 메서드

div()는 DataFrame의 element-wise 나눗셈 메서드입니다. / 연산자와 기본 동작은 같지만, axis와 fill_value 파라미터로 행/열 방향 제어와 결측치 처리가 가능합니다.

기본 문법

DataFrame.div(other, axis='columns', fill_value=None)

파라미터	설명
`other`	나눌 값 (스칼라, Series, DataFrame)
`axis`	`0`/'index' 또는 `1`/'columns' (기본값 1)
`fill_value`	연산 전 NaN을 대체할 값 (기본값 None)

스칼라 나눗셈

import pandas as pd

df = pd.DataFrame({
    '국어': [80, 60, 90],
    '수학': [70, 85, 95]
})

df.div(100)
#    국어  수학
# 0  0.80  0.70
# 1  0.60  0.85
# 2  0.90  0.95

Series로 나눗셈 — `axis`가 핵심

Series를 기준으로 나눌 때 axis 방향을 반드시 지정해야 합니다.

df:              total (행별 합계):
   국어  수학
0   80   70      0    150
1   60   85      1    145
2   90   95      2    185

total = df.sum(axis=1)   # 행별 합계 → Series [150, 145, 185]

# axis=0: Series 인덱스를 행에 맞춰 정렬 → 각 행을 해당 총점으로 나눔
df.div(total, axis=0)
#        국어      수학
# 0  0.5333    0.4667
# 1  0.4138    0.5862
# 2  0.4865    0.5135

# axis=1 (기본): Series 인덱스를 열에 맞춰 정렬
# → '국어', '수학' 라벨이 없으면 NaN 발생
df.div(total, axis=1)   # 대부분 NaN

axis 선택 기준: 행별 합계로 나눌 때는 axis=0, 열별 합계로 나눌 때는 axis=1. 비율 계산은 거의 항상 axis=0입니다.

`fill_value` — NaN 자리를 채우고 연산

DataFrame끼리 나눌 때 한쪽에만 NaN이 있으면 fill_value로 채운 뒤 연산합니다. 양쪽 모두 NaN이면 여전히 NaN입니다.

a = pd.DataFrame({'A': [10, None], 'B': [20, 30]})
b = pd.DataFrame({'A': [2,  4],    'B': [None, 6]})

a.div(b)
#      A         B
# 0  5.0       NaN   ← b의 B[0]이 NaN → 결과도 NaN
# 1  NaN       5.0   ← a의 A[1]이 NaN → 결과도 NaN

a.div(b, fill_value=1)   # NaN을 1로 채운 뒤 연산
#      A         B
# 0  5.0      20.0   ← b의 B[0]을 1로 채워서 20/1
# 1  NaN       5.0   ← a의 A[1]은 NaN 유지 (둘 다 NaN이면 적용 안 됨)

응용 사례 1 — 행별 비율 계산

scores = pd.DataFrame({
    '국어': [80, 60, 90],
    '수학': [70, 85, 95],
    '영어': [75, 80, 88]
}, index=['철수', '영희', '민준'])

total = scores.sum(axis=1)
ratio = scores.div(total, axis=0).round(3)
#        국어    수학    영어
# 철수  0.356  0.311  0.333
# 영희  0.267  0.378  0.356
# 민준  0.329  0.347  0.321

응용 사례 2 — 열별 최댓값으로 정규화

col_max = scores.max(axis=0)                   # 열별 최댓값
normalized = scores.div(col_max, axis=1)       # axis=1: 열 방향 정렬
#         국어       수학       영어
# 철수  0.8889    0.7368    0.8523
# 영희  0.6667    0.8947    0.9091
# 민준  1.0000    1.0000    1.0000

응용 사례 3 — 전월 대비 증감률

sales = pd.DataFrame({
    '서울': [100, 120, 110],
    '부산': [80,   75,  90]
}, index=['1월', '2월', '3월'])

# 현재 / 이전 → 전월 대비 비율
growth = sales.div(sales.shift(1)).round(3)
#        서울   부산
# 1월     NaN    NaN   ← 이전 달 없음
# 2월    1.20   0.938
# 3월    0.917  1.200

응용 사례 4 — 카테고리별 매출 비중

data = pd.DataFrame({
    '식품': [200, 180, 220],
    '전자': [500, 620, 480]
}, index=['1월', '2월', '3월'])

row_total = data.sum(axis=1)
share = data.div(row_total, axis=0).mul(100).round(1)
#     식품    전자
# 1월  28.6   71.4
# 2월  22.5   77.5
# 3월  31.4   68.6

`div()` vs `/` 연산자

	`df / other`	`df.div(other)`
axis 지정	불가	가능
fill_value 지정	불가	가능
Series로 행별 나눗셈	불가 (NaN 발생)	`axis=0`으로 가능

핵심 직관: axis=0은 "각 행마다 Series 값 하나씩 대응", axis=1은 "각 열마다 Series 값 하나씩 대응"입니다. / 대신 div()를 써야 하는 순간은 행 방향(axis=0) 연산이 필요할 때입니다.

Python Pandas : stack, unstack (pivot하기, pivot 풀기)

CosmosProject — Wed, 20 May 2026 21:39:21 +0900

Pandas `stack()` / `unstack()` — 데이터를 넓은 형태와 긴 형태로 변환하는 메서드

열을 행으로 접거나(stack), 행 인덱스를 열로 펼치는(unstack) 메서드입니다. MultiIndex 데이터를 다룰 때 핵심이 되는 한 쌍의 역함수입니다.

핵심 개념 — 넓은 형태 vs 긴 형태

데이터는 넓은 형태(wide)와 긴 형태(long) 두 가지로 표현할 수 있습니다.

넓은 형태 (wide)          긴 형태 (long)
─────────────────         ──────────────────────
분기   Q1   Q2            지역  분기  매출
지역                      부산  Q1    80
부산   80  120     ←→     부산  Q2   120
서울  100  150            서울  Q1   100
                          서울  Q2   150

      unstack() ←
      → stack()

	`stack()`	`unstack()`
방향	열 → 행 인덱스	행 인덱스 → 열
결과 형태	긴 형태 (long)	넓은 형태 (wide)
반환 타입	MultiIndex Series	DataFrame
주 사용처	분석/집계용 변환	피벗 테이블, 시각화 준비

기본 문법

DataFrame.stack(level=-1)                        # 가장 안쪽 열 레벨을 행으로
DataFrame.unstack(level=-1, fill_value=None)     # 가장 안쪽 행 레벨을 열로

`stack()` — 열을 행으로 접기

import pandas as pd

wide = pd.DataFrame({
    'Q1': [80, 100],
    'Q2': [120, 150]
}, index=['부산', '서울'])

print(wide)
#       Q1   Q2
# 부산   80  120
# 서울  100  150

long = wide.stack()
print(long)
# 부산  Q1     80
#      Q2    120
# 서울  Q1    100
#      Q2    150
# dtype: int64

열(Q1, Q2)이 행 인덱스의 안쪽 레벨로 내려와 MultiIndex Series가 됩니다.

`unstack()` — 행을 열로 펼치기

stack()의 결과를 다시 원래대로 되돌립니다.

wide_again = long.unstack()
print(wide_again)
#       Q1   Q2
# 부산   80  120
# 서울  100  150

`level` 파라미터 — 어떤 레벨을 올릴지 선택

MultiIndex가 여러 레벨일 때 어떤 레벨을 열로 올릴지 지정합니다. groupby로 집계한 결과가 대표적인 예입니다.

# groupby로 만든 MultiIndex Series
grouped = df.groupby(['지역', '분기'])['매출'].sum()
# 지역  분기
# 부산  Q1     80
#      Q2    120
# 서울  Q1    100
#      Q2    150

grouped.unstack()          # level=-1 (기본): 분기 → 열
# 분기   Q1   Q2
# 지역
# 부산   80  120
# 서울  100  150

grouped.unstack(level=0)   # level=0: 지역 → 열
# 지역  부산  서울
# 분기
# Q1     80   100
# Q2    120   150

`fill_value` — 빈 자리 채우기

데이터에 없는 조합이 생기면 기본적으로 NaN이 채워집니다.

# 부산 Q2 데이터가 없는 경우
grouped.unstack()
# 분기      Q1     Q2
# 지역
# 부산     80.0   NaN   ← 빈 자리
# 서울    100.0  150.0

grouped.unstack(fill_value=0)
# 분기   Q1   Q2
# 지역
# 부산   80    0
# 서울  100  150

응용 사례 1 — 월별 카테고리 매출 피벗

sales = pd.DataFrame({
    '월':      [1, 1, 2, 2, 3, 3],
    '카테고리': ['식품', '전자', '식품', '전자', '식품', '전자'],
    '매출':    [200, 500, 180, 620, 220, 480]
})

# groupby 집계 → unstack으로 피벗
pivot = sales.groupby(['월', '카테고리'])['매출'].sum().unstack(fill_value=0)
# 카테고리  식품  전자
# 월
# 1        200  500
# 2        180  620
# 3        220  480

# 다시 긴 형태로 되돌리고 싶을 때
pivot.stack().reset_index()
#    월 카테고리  매출
# 0   1     식품   200
# 1   1     전자   500
# ...

피벗 형태는 .plot()으로 바로 시각화가 가능합니다.

응용 사례 2 — 교차 분석 및 비율 계산

survey = pd.DataFrame({
    '성별':   ['남', '남', '여', '여', '남', '여'],
    '만족도': ['만족', '불만', '만족', '만족', '만족', '불만'],
})

# 성별 × 만족도 카운트
count = survey.groupby(['성별', '만족도']).size().unstack(fill_value=0)
# 만족도  만족  불만
# 성별
# 남       2    1
# 여       2    1

# 행별 비율 계산
ratio = count.div(count.sum(axis=1), axis=0).round(2)
# 만족도  만족  불만
# 성별
# 남      0.67  0.33
# 여      0.67  0.33

`stack()` / `unstack()` 역함수 관계

original  = pivot               # 넓은 형태
stacked   = pivot.stack()       # 긴 형태로 접기
restored  = stacked.unstack()   # 다시 넓은 형태로 복원

# original == restored  (완전히 동일)

핵심 직관: stack은 표를 세로로 접고, unstack은 가로로 펼칩니다. 둘은 완전한 역함수 관계라 df.stack().unstack()은 원본과 동일합니다.

Python numpy : sum, mean

CosmosProject — Wed, 20 May 2026 21:30:58 +0900

NumPy `sum()` / `mean()` — 합계와 평균을 axis 방향으로 계산하는 메서드

배열 전체 또는 특정 축(axis) 방향으로 합계와 평균을 구합니다. axis 개념만 이해하면 행/열 단위 집계가 자유로워집니다.

axis 개념 이해

NumPy 연산의 핵심은 axis입니다. axis=0은 행을 따라 아래 방향(↓)으로, axis=1은 열을 따라 가로 방향(→)으로 연산합니다.

2D array:
        col0  col1  col2
row0  [[ 1,    2,    3 ],
row1   [ 4,    5,    6 ],
row2   [ 7,    8,    9 ]]

axis=0 → 행 방향(↓): 각 열을 따라 내려가며 연산 → 결과는 열마다 1개
axis=1 → 열 방향(→): 각 행을 따라 가로로 연산  → 결과는 행마다 1개

기본 문법

numpy.sum(a, axis=None, keepdims=False)
numpy.mean(a, axis=None, keepdims=False)

`np.sum()` 작동 방식

import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

np.sum(a)           # 45  ← 전체 합계
np.sum(a, axis=0)   # array([12, 15, 18])  ← 열별 합계 (1+4+7, 2+5+8, 3+6+9)
np.sum(a, axis=1)   # array([ 6, 15, 24])  ← 행별 합계 (1+2+3, 4+5+6, 7+8+9)

`np.mean()` 작동 방식

np.mean(a)          # 5.0  ← 전체 평균
np.mean(a, axis=0)  # array([4., 5., 6.])  ← 열별 평균
np.mean(a, axis=1)  # array([2., 5., 8.])  ← 행별 평균

주의: mean()은 항상 float을 반환합니다. sum()은 입력 배열의 dtype을 그대로 따릅니다.

`keepdims` 옵션 — shape 유지

연산 후에도 원본과 같은 차원 수를 유지합니다. 브로드캐스팅과 함께 쓸 때 유용합니다.

np.sum(a, axis=1)
# array([ 6, 15, 24])  ← shape (3,)  1차원으로 축소됨

np.sum(a, axis=1, keepdims=True)
# array([[ 6],         ← shape (3, 1)  2차원 유지
#        [15],
#        [24]])

응용 사례 1 — 학생 성적 처리

# shape: (학생수, 과목수)
scores = np.array([[85, 90, 78],
                   [70, 65, 88],
                   [92, 88, 95]])

student_avg = np.mean(scores, axis=1)  # 학생별 평균 → [84.3, 74.3, 91.7]
subject_avg = np.mean(scores, axis=0)  # 과목별 평균 → [82.3, 81.0, 87.0]
total       = np.sum(scores)           # 전체 합계   → 751

응용 사례 2 — 이미지 흑백 변환

# RGB 이미지: shape (H, W, 3)
img_rgb = np.random.randint(0, 256, (100, 100, 3))

gray = np.mean(img_rgb, axis=2)  # R, G, B 평균 → shape (100, 100)

응용 사례 3 — 정규화 (Mean Centering)

각 feature(열)의 평균을 빼서 데이터를 중앙 정렬합니다. 이때 keepdims 없이도 브로드캐스팅이 자동 적용됩니다.

data = np.array([[10, 20, 30],
                 [40, 50, 60]])

col_mean = np.mean(data, axis=0)   # [25., 35., 45.]
centered = data - col_mean         # 브로드캐스팅 자동 적용
# array([[-15., -15., -15.],
#        [ 15.,  15.,  15.]])

NaN 처리 — `np.nansum()` / `np.nanmean()`

기본 sum() / mean()은 NaN이 하나라도 있으면 결과가 NaN이 됩니다. nan 버전은 NaN을 무시하고 계산합니다.

data = np.array([1.0, 2.0, np.nan, 4.0])

np.sum(data)      # nan   ← NaN 전파
np.nansum(data)   # 7.0   ← NaN 무시

np.mean(data)     # nan   ← NaN 전파
np.nanmean(data)  # 2.33  ← NaN 무시 (1+2+4) / 3

핵심 요약

	`np.sum()`	`np.mean()`
반환값	합계	평균 (항상 float)
axis 없음	전체 합산	전체 평균
axis=0	열 방향 합산 (↓)	열 방향 평균 (↓)
axis=1	행 방향 합산 (→)	행 방향 평균 (→)
NaN 처리	`np.nansum()`	`np.nanmean()`

핵심 직관: axis는 "이 방향을 따라서 연산한다"는 뜻입니다. axis=0은 행을 따라 내려가며(→ 열별 결과), axis=1은 열을 따라 옆으로 가며(→ 행별 결과) 계산합니다.

Python numpy : minimum() / maximum() — 두 array를 element-wise로 비교해 작은/큰 값을 선택하는 메서드

CosmosProject — Thu, 14 May 2026 20:21:56 +0900

NumPy `minimum()` / `maximum()` — 두 array를 element-wise로 비교해 작은/큰 값을 선택하는 메서드

두 array의 같은 위치 값을 비교해서, 더 작은(또는 큰) 값만 골라 새 array를 만듭니다.

기본 문법

numpy.minimum(x1, x2)   # 각 위치에서 더 작은 값 선택
numpy.maximum(x1, x2)   # 각 위치에서 더 큰 값 선택

`np.min()` vs `np.minimum()` — 헷갈리기 쉬운 차이

이름이 비슷하지만 완전히 다릅니다.

arr = np.array([3, 1, 4, 1, 5])

np.min(arr)         # 1  ← array 전체에서 최솟값 하나 반환
np.minimum(arr, 3)  # array([3, 1, 3, 1, 3])  ← 각 위치를 3과 비교

	`np.min(arr)`	`np.minimum(x1, x2)`
입력	array 1개	array 2개 (또는 array + scalar)
출력	스칼라 값 1개	array
역할	전체 최솟값 찾기	element-wise 비교

예시 1 — 두 array 비교

import numpy as np

a = np.array([1, 5, 3, 8, 2])
b = np.array([4, 2, 6, 1, 7])

np.minimum(a, b)
# array([1, 2, 3, 1, 2])
#  min(1,4) min(5,2) min(3,6) min(8,1) min(2,7)

np.maximum(a, b)
# array([4, 5, 6, 8, 7])
#  max(1,4) max(5,2) max(3,6) max(8,1) max(2,7)

예시 2 — scalar와 비교 (상한/하한 설정)

arr = np.array([-3, 5, -1, 8, 2])

np.maximum(arr, 0)   # 하한 0 설정 (음수 제거)
# array([0, 5, 0, 8, 2])

np.minimum(arr, 5)   # 상한 5 설정
# array([-3, 5, -1, 5, 2])

`np.clip()`과의 관계

상한과 하한을 동시에 설정할 때 clip()이 더 간결하지만, 내부적으로 minimum과 maximum의 조합입니다.

arr = np.array([-3, 5, -1, 8, 2])

# 아래 두 코드는 같은 결과
np.clip(arr, 0, 5)
np.minimum(np.maximum(arr, 0), 5)
# array([0, 5, 0, 5, 2])

NaN 처리

np.minimum / np.maximum은 NaN이 있으면 결과도 NaN이 됩니다. NaN을 무시하려면 np.fmin / np.fmax를 씁니다.

a = np.array([1, np.nan, 3])
b = np.array([2, 2,      1])

np.minimum(a, b)
# array([ 1., nan,  1.])  ← NaN이 있으면 결과도 NaN

np.fmin(a, b)
# array([1., 2., 1.])     ← NaN 무시하고 다른 값 선택

`np.fmin()` / `np.fmax()` — NaN을 무시하는 버전

np.minimum / np.maximum과 동작이 같지만, NaN을 결측값으로 취급해서 무시합니다.

a = np.array([1, np.nan, 3, np.nan])
b = np.array([2, 2,      1, np.nan])

np.minimum(a, b)
# array([ 1., nan,  1., nan])  ← NaN이 하나라도 있으면 결과도 NaN

np.fmin(a, b)
# array([ 1.,  2.,  1., nan])  ← 한쪽만 NaN이면 다른 값 선택
#                        ↑ 둘 다 NaN이면 그때만 NaN

NaN 처리 규칙: 한쪽만 NaN → NaN이 아닌 값 선택 / 둘 다 NaN → NaN 반환

데이터에 결측값이 섞여 있을 때, NaN 때문에 비교 결과 전체가 오염되는 걸 막고 싶을 때 씁니다.

# 센서 데이터 — 일부 측정값이 누락(NaN)된 상황
sensor_a = np.array([23.1, np.nan, 19.8, 21.0])
sensor_b = np.array([22.0, 20.5,   np.nan, 21.5])

# 두 센서 중 낮은 값을 기록하되, 한쪽이 누락이면 다른 쪽 값 사용
np.fmin(sensor_a, sensor_b)
# array([22. , 20.5, 19.8, 21. ])

	`np.minimum`	`np.fmin`
한쪽 NaN	NaN 반환	다른 값 반환
둘 다 NaN	NaN 반환	NaN 반환
용도	NaN 전파가 필요할 때	NaN을 무시하고 싶을 때

Python numpy : where() — 조건에 따라 두 값 중 하나를 선택하는 메서드

CosmosProject — Thu, 14 May 2026 20:13:07 +0900

NumPy `where()` — 조건에 따라 두 값 중 하나를 선택하는 메서드

조건이 True인 위치에는 x값, False인 위치에는 y값을 선택해서 새 array를 만듭니다.

기본 문법

# 형태 1 — 조건에 따라 값 선택 (가장 많이 쓰는 형태)
numpy.where(condition, x, y)

# 형태 2 — 조건이 True인 인덱스 반환
numpy.where(condition)

형태 1 — 조건에 따라 값 선택

import numpy as np

arr = np.array([1, -2, 3, -4, 5])

np.where(arr > 0, arr, 0)
# array([1, 0, 3, 0, 5])
#           ↑     ↑
#        -2, -4 → 0으로 대체

조건이 True인 위치 → arr 값 그대로, False인 위치 → 0

x, y 자리에 값 대신 array도 가능

a = np.array([1, 2, 3, 4, 5])
b = np.array([10, 20, 30, 40, 50])

np.where(a > 3, a, b)
# array([10, 20, 30,  4,  5])
#         ↑   ↑   ↑   ↑   ↑
# 1≤3→b  2≤3→b  3≤3→b  4>3→a  5>3→a

형태 2 — True인 인덱스 반환

인수를 하나만 넘기면 조건을 만족하는 위치의 인덱스를 반환합니다.

arr = np.array([10, 50, 30, 80, 20])

np.where(arr > 40)
# (array([1, 3]),)  ← 인덱스 1, 3이 조건 만족 (50, 80)

# 인덱스로 값 추출할 때
arr[np.where(arr > 40)]
# array([50, 80])

`pandas.where` vs `numpy.where` — 헷갈리기 쉬운 차이

이름은 같지만 동작 방향이 반대입니다.

s = pd.Series([1, -2, 3, -4, 5])

# pandas.where → True면 원래 값 유지, False면 대체
s.where(s > 0, 0)
# [1, 0, 3, 0, 5]   ← 양수는 유지, 음수는 0

# numpy.where → True면 x, False면 y
np.where(s > 0, s, 0)
# [1, 0, 3, 0, 5]   ← 결과는 같지만 사고방식이 다름

	`pandas.where(cond, other)`	`numpy.where(cond, x, y)`
True일 때	원래 값 유지	x 선택
False일 때	other로 대체	y 선택

Python numpy : polyfit() — 점들의 패턴에 가장 잘 맞는 다항식 계수를 추정하는 메서드

CosmosProject — Thu, 14 May 2026 19:58:08 +0900

NumPy `polyfit()` — 점들의 패턴에 가장 잘 맞는 다항식 계수를 추정하는 메서드

여러 (x, y) 좌표 쌍을 받아서, 그 점들을 가장 잘 설명하는 다항식의 계수를 반환합니다.

기본 문법

numpy.polyfit(x, y, deg)

파라미터	설명
`x`	x 좌표값들의 array
`y`	y 좌표값들의 array
`deg`	다항식의 차수
반환값	계수 array. 높은 차수부터 순서대로 반환

deg에 따라 추정하는 다항식의 형태가 달라집니다.

deg=1  →  y = ax + b                     (직선)
deg=2  →  y = ax² + bx + c              (포물선)
deg=3  →  y = ax³ + bx² + cx + d        (S자 곡선)
deg=4  →  y = ax⁴ + bx³ + cx² + dx + e

"가장 잘 맞는"이 뭔 뜻인가 — 최소제곱법

점들이 완벽하게 하나의 선 위에 있는 경우는 거의 없습니다. 대신 각 점과 추정한 곡선 사이의 오차(거리)의 제곱 합이 최소가 되는 계수를 찾습니다. 이걸 최소제곱법(Least Squares)이라 합니다.

실제 y값과 추정 y값의 차이  →  오차
오차² 의 합이 가장 작아지는 계수를 선택

예시 1 — 1차 (직선 피팅)

import numpy as np

x = np.array([1, 2, 3, 4, 5])
y = np.array([2.1, 3.9, 6.2, 7.8, 10.1])
# 대략 y = 2x 패턴

coeffs = np.polyfit(x, y, deg=1)
# array([2.02, 0.02])
#         ↑      ↑
#         a      b   →  y = 2.02x + 0.02

deg=1이면 y = ax + b 형태. 반환값은 [a, b].

예시 2 — 2차 (곡선 피팅)

import numpy as np

x = np.array([1, 2, 3, 4, 5])
y = np.array([1.1, 3.9, 9.2, 15.8, 25.1])
# 대략 y = x² 패턴

coeffs = np.polyfit(x, y, deg=2)
# array([0.99, 0.01, 0.05])
#         ↑      ↑     ↑
#         a      b     c   →  y = 0.99x² + 0.01x + 0.05

deg=2이면 y = ax² + bx + c 형태. 반환값은 [a, b, c].

계수로 예측값 구하기 — `np.polyval()`

polyfit()이 계수를 구해줬다면, np.polyval()로 새로운 x에 대한 y를 예측할 수 있습니다.

coeffs = np.polyfit(x, y, deg=1)

# x=6일 때 예측값
np.polyval(coeffs, 6)
# 12.14

# 여러 x에 대해 한 번에
np.polyval(coeffs, [6, 7, 8])
# [12.14, 14.16, 16.18]

차수(deg) 선택 주의

deg가 너무 낮으면  →  패턴을 못 잡음 (underfitting)
deg가 너무 높으면  →  노이즈까지 외워버림 (overfitting)

# 점이 5개인데 deg=4로 하면
# 모든 점을 정확히 지나는 곡선이 나오지만
# 실제 패턴과는 거리가 멀어질 수 있음

일반적으로 데이터의 실제 관계를 고려해서 deg=1(선형) 또는 deg=2(2차)를 먼저 시도합니다.

Python Pandas : std() — 표준편차를 계산하는 메서드

CosmosProject — Thu, 14 May 2026 19:47:13 +0900

Pandas `.std()` — 표준편차를 계산하는 메서드

데이터가 평균에서 얼마나 퍼져 있는지를 수치로 나타냅니다. 값이 클수록 데이터가 들쭉날쭉하고, 작을수록 고르게 모여 있습니다.

기본 문법

Series.std(ddof=1)
DataFrame.std(ddof=1, axis=0)

파라미터	설명
`ddof`	기본값 `1`은 표본 표준편차, `0`으로 바꾸면 모 표준편차
`axis`	`0`이면 열 방향(각 컬럼의 std), `1`이면 행 방향

예시 1 — Series 기본

import pandas as pd

s = pd.Series([2, 4, 4, 4, 5, 5, 7, 9])
s.std()
# 2.0

예시 2 — DataFrame (axis=0, 기본)

import pandas as pd

df = pd.DataFrame({
    '국어': [80, 90, 70, 100],
    '수학': [60, 95, 55, 90],
})

df.std()
# 국어    12.91
# 수학    19.76
# 수학이 국어보다 점수 편차가 크다는 뜻

ddof=1 vs ddof=0

표준편차를 계산할 때 분모가 달라집니다.

ddof=1  →  분모: n - 1   (표본 표준편차, pandas 기본값)
ddof=0  →  분모: n       (모 표준편차, numpy 기본값)

s = pd.Series([2, 4, 4, 4, 5, 5, 7, 9])

s.std(ddof=1)  # 2.0   ← 표본, 일반적으로 이걸 씀
s.std(ddof=0)  # 1.87  ← 모집단 전체를 갖고 있을 때

표본(설문 응답자, 실험 측정값 등 일부 데이터)을 다룰 때는 ddof=1, 모집단 전체 데이터를 갖고 있을 때는 ddof=0을 씁니다.

실무 활용 — 이상치 탐지

정규분포에서 표준편차 범위별 포함 비율은 다음과 같습니다.

±1σ  →  약 68.27%  포함  →  약 31.73% 가 바깥
±2σ  →  약 95.45%  포함  →  약  4.55% 가 바깥
±3σ  →  약 99.73%  포함  →  약  0.27% 가 바깥

평균 ± 2σ를 벗어나면 전체의 약 4.55%에 해당하는 극단값, ± 3σ를 벗어나면 약 0.27%에 해당하는 극단값입니다.

mean = df['매출'].mean()
std  = df['매출'].std()

# ±2σ 기준 — 조금 더 공격적으로 outlier를 잡음
outliers = df[(df['매출'] < mean - 2*std) | (df['매출'] > mean + 2*std)]

# ±3σ 기준 — 정말 극단적인 값만 잡음
outliers = df[(df['매출'] < mean - 3*std) | (df['매출'] > mean + 3*std)]

실무에서는 ±2σ 또는 ±3σ 기준을 가장 많이 씁니다.

pandas vs numpy — ddof 기본값이 다르다

numpy에도 np.std()가 있지만, ddof 기본값이 달라서 같은 데이터에 아무 설정 없이 쓰면 결과가 다르게 나옵니다.

import numpy as np
import pandas as pd

s   = pd.Series([2, 4, 4, 4, 5, 5, 7, 9])
arr = np.array([2, 4, 4, 4, 5, 5, 7, 9])

s.std()         # 2.0   ← ddof=1 기본 (표본 표준편차)
np.std(arr)     # 1.87  ← ddof=0 기본 (모 표준편차)

# ddof를 맞춰주면 결과가 같아짐
np.std(arr, ddof=1)  # 2.0  ← pandas와 동일

	`pandas .std()`	`numpy np.std()`
ddof 기본값	1 (표본)	0 (모집단)
대상	Series, DataFrame	ndarray

달나라 노트

Python numpy : nan_to_num

NumPy nan_to_num() — NaN과 무한대를 안전한 값으로 교체하는 함수

기본 동작

기본 문법

작동 방식

기본 동작

대체값 직접 지정

copy=False — 원본 직접 수정

스칼라 입력

inf는 언제 생기나?

응용 사례 1 — 로그 변환 후 정제

응용 사례 2 — 비율 계산 (0으로 나누기 방지)

응용 사례 3 — 머신러닝 피처 전처리

응용 사례 4 — 코사인 유사도 행렬 정제

nan_to_num vs pandas fillna

Python Pandas : map

Pandas map() — 딕셔너리·함수·Series로 값을 1:1 변환하는 메서드

기본 문법

1. 딕셔너리로 값 치환

2. 함수로 변환

3. Series로 변환 (인덱스 기준 매핑)

4. na_action='ignore' — NaN 건드리지 않기

map vs apply vs replace

응용 사례 1 — 코드값을 레이블로 변환

응용 사례 2 — 구간별 레이블 (점수 → 등급)

응용 사례 3 — 외부 테이블과 조인 대용

응용 사례 4 — 문자열 전처리

핵심 요약

Python Pandas : agg (열마다 다른 집계함수 적용)

Pandas agg() — 열마다 다른 집계 함수를 한 번에 적용하는 메서드

기본 문법

1. 단일 함수

2. 여러 함수를 리스트로

3. 열마다 다른 함수를 딕셔너리로

4. groupby + agg — 가장 많이 쓰는 패턴

5. Named Aggregation — 결과 컬럼명 직접 지정

6. 커스텀 함수 적용

응용 사례 1 — 데이터 품질 점검

응용 사례 2 — 기간별 매출 리포트

응용 사례 3 — 다중 그룹 집계

자주 쓰는 집계 함수 목록

Python Pandas : div (나눗셈)

Pandas div() — axis와 fill_value로 나눗셈 방향과 결측치를 제어하는 메서드

기본 문법

스칼라 나눗셈

Series로 나눗셈 — axis가 핵심

fill_value — NaN 자리를 채우고 연산

응용 사례 1 — 행별 비율 계산

응용 사례 2 — 열별 최댓값으로 정규화

응용 사례 3 — 전월 대비 증감률

응용 사례 4 — 카테고리별 매출 비중

div() vs / 연산자

Python Pandas : stack, unstack (pivot하기, pivot 풀기)

Pandas stack() / unstack() — 데이터를 넓은 형태와 긴 형태로 변환하는 메서드

핵심 개념 — 넓은 형태 vs 긴 형태

기본 문법

stack() — 열을 행으로 접기

unstack() — 행을 열로 펼치기

level 파라미터 — 어떤 레벨을 올릴지 선택

fill_value — 빈 자리 채우기

응용 사례 1 — 월별 카테고리 매출 피벗

응용 사례 2 — 교차 분석 및 비율 계산

stack() / unstack() 역함수 관계

Python numpy : sum, mean

NumPy sum() / mean() — 합계와 평균을 axis 방향으로 계산하는 메서드

axis 개념 이해

기본 문법

np.sum() 작동 방식

np.mean() 작동 방식

keepdims 옵션 — shape 유지

응용 사례 1 — 학생 성적 처리

응용 사례 2 — 이미지 흑백 변환

응용 사례 3 — 정규화 (Mean Centering)

NaN 처리 — np.nansum() / np.nanmean()

핵심 요약

Python numpy : minimum() / maximum() — 두 array를 element-wise로 비교해 작은/큰 값을 선택하는 메서드

NumPy minimum() / maximum() — 두 array를 element-wise로 비교해 작은/큰 값을 선택하는 메서드

기본 문법

np.min() vs np.minimum() — 헷갈리기 쉬운 차이

NumPy `nan_to_num()` — NaN과 무한대를 안전한 값으로 교체하는 함수

`copy=False` — 원본 직접 수정

`nan_to_num` vs pandas `fillna`

Pandas `map()` — 딕셔너리·함수·Series로 값을 1:1 변환하는 메서드

4. `na_action='ignore'` — NaN 건드리지 않기

`map` vs `apply` vs `replace`

Pandas `agg()` — 열마다 다른 집계 함수를 한 번에 적용하는 메서드

4. `groupby` + `agg` — 가장 많이 쓰는 패턴

Pandas `div()` — axis와 fill_value로 나눗셈 방향과 결측치를 제어하는 메서드

Series로 나눗셈 — `axis`가 핵심

`fill_value` — NaN 자리를 채우고 연산

`div()` vs `/` 연산자

Pandas `stack()` / `unstack()` — 데이터를 넓은 형태와 긴 형태로 변환하는 메서드

`stack()` — 열을 행으로 접기

`unstack()` — 행을 열로 펼치기

`level` 파라미터 — 어떤 레벨을 올릴지 선택

`fill_value` — 빈 자리 채우기

`stack()` / `unstack()` 역함수 관계

NumPy `sum()` / `mean()` — 합계와 평균을 axis 방향으로 계산하는 메서드

`np.sum()` 작동 방식

`np.mean()` 작동 방식

`keepdims` 옵션 — shape 유지

NaN 처리 — `np.nansum()` / `np.nanmean()`

NumPy `minimum()` / `maximum()` — 두 array를 element-wise로 비교해 작은/큰 값을 선택하는 메서드

`np.min()` vs `np.minimum()` — 헷갈리기 쉬운 차이

`np.clip()`과의 관계

`np.fmin()` / `np.fmax()` — NaN을 무시하는 버전

NumPy `where()` — 조건에 따라 두 값 중 하나를 선택하는 메서드

`pandas.where` vs `numpy.where` — 헷갈리기 쉬운 차이

NumPy `polyfit()` — 점들의 패턴에 가장 잘 맞는 다항식 계수를 추정하는 메서드

계수로 예측값 구하기 — `np.polyval()`

Pandas `.std()` — 표준편차를 계산하는 메서드