Pandas의 모든 것

함수·메서드 101개 | 독립 실행 코드 · 출력 결과 · 핵심 설명

Python 3 / pandas 2.x 기준 · 실습용 학습 자료

각 항목은 공통 데이터 생성부터 포함하므로 따로 복사하여 실행할 수 있습니다. pip install pandas numpy로 설치하세요. Excel/SQL/그리기 기능은 추가 의존성이 필요할 수 있어 여기서는 대표적인 데이터 분석 함수들을 다룹니다.

001. Series 생성 — 생성·입출력

기능 · Series 생성 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.Series([10,20,30], index=["가","나","다"])
print(result)

실행 결과 (Pandas 환경 기준)

가    10
나    20
다    30
dtype: int64

해설: 위 코드에서 Series 생성의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

002. DataFrame 생성 — 생성·입출력

기능 · DataFrame 생성 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.DataFrame({"name":["Kim","Lee","Park"],"score":[90,80,95]})
print(result)

실행 결과 (Pandas 환경 기준)

   name  score
0   Kim     90
1   Lee     80
2  Park     95

해설: 위 코드에서 DataFrame 생성의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

003. date_range — 생성·입출력

기능 · date_range 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.date_range("2026-01-01", periods=4, freq="D")
print(result)

실행 결과 (Pandas 환경 기준)

DatetimeIndex(['2026-01-01', '2026-01-02', '2026-01-03', '2026-01-04'], dtype='datetime64[ns]', freq='D')

해설: 위 코드에서 date_range의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

004. read_csv — 생성·입출력

기능 · read_csv 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.read_csv(StringIO("name,score\nKim,90\nLee,80"))
print(result)

실행 결과 (Pandas 환경 기준)

  name  score
0  Kim     90
1  Lee     80

해설: 위 코드에서 read_csv의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

005. read_json — 생성·입출력

기능 · read_json 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.read_json(StringIO('{"name":{"0":"Kim"},"score":{"0":90}}'))
print(result)

실행 결과 (Pandas 환경 기준)

  name  score
0  Kim     90

해설: 위 코드에서 read_json의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

006. json_normalize — 생성·입출력

기능 · json_normalize 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.json_normalize([{"id":1,"info":{"city":"Seoul"}}])
print(result)

실행 결과 (Pandas 환경 기준)

   id info.city
0   1     Seoul

해설: 위 코드에서 json_normalize의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

007. to_csv — 생성·입출력

기능 · to_csv 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.to_csv(index=False)
print(result)

실행 결과 (Pandas 환경 기준)

name,score,age,city
Kim,90,17.0,Seoul
Lee,80,18.0,Busan
Park,95,17.0,Seoul
Choi,85,,Incheon

해설: 위 코드에서 to_csv의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

008. to_json — 생성·입출력

기능 · to_json 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.to_json(orient="records", force_ascii=False)
print(result)

실행 결과 (Pandas 환경 기준)

[{"name":"Kim","score":90,"age":17.0,"city":"Seoul"},{"name":"Lee","score":80,"age":18.0,"city":"Busan"},{"name":"Park","score":95,"age":17.0,"city":"Seoul"},{"name":"Choi","score":85,"age":null,"city":"Incheon"}]

해설: 위 코드에서 to_json의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

009. to_dict — 생성·입출력

기능 · to_dict 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.to_dict(orient="records")
print(result)

실행 결과 (Pandas 환경 기준)

[{'name': 'Kim', 'score': 90, 'age': 17.0, 'city': 'Seoul'}, {'name': 'Lee', 'score': 80, 'age': 18.0, 'city': 'Busan'}, {'name': 'Park', 'score': 95, 'age': 17.0, 'city': 'Seoul'}, {'name': 'Choi', 'score': 85, 'age': nan, 'city': 'Incheon'}]

해설: 위 코드에서 to_dict의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

010. to_numpy — 생성·입출력

기능 · to_numpy 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.to_numpy()
print(result)

실행 결과 (Pandas 환경 기준)

[['Kim' 90 17.0 'Seoul']
 ['Lee' 80 18.0 'Busan']
 ['Park' 95 17.0 'Seoul']
 ['Choi' 85 nan 'Incheon']]

해설: 위 코드에서 to_numpy의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

011. head — 조회·선택

기능 · head 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.head(2)
print(result)

실행 결과 (Pandas 환경 기준)

  name  score   age   city
0  Kim     90  17.0  Seoul
1  Lee     80  18.0  Busan

해설: 위 코드에서 head의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

012. tail — 조회·선택

기능 · tail 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.tail(2)
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
2  Park     95  17.0    Seoul
3  Choi     85   NaN  Incheon

해설: 위 코드에서 tail의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

013. sample — 조회·선택

기능 · sample 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.sample(n=2, random_state=42)
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
1   Lee     80  18.0    Busan
3  Choi     85   NaN  Incheon

해설: 위 코드에서 sample의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

014. info — 조회·선택

기능 · info 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.info()
print(result)

실행 결과 (Pandas 환경 기준)

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   name    4 non-null      object 
 1   score   4 non-null      int64  
 2   age     3 non-null      float64
 3   city    4 non-null      object 
dtypes: float64(1), int64(1), object(2)
memory usage: 260.0+ bytes

해설: 위 코드에서 info의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

015. describe — 조회·선택

기능 · describe 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.describe(include="all")
print(result)

실행 결과 (Pandas 환경 기준)

       name      score        age   city
count     4   4.000000   3.000000      4
unique    4        NaN        NaN      3
top     Kim        NaN        NaN  Seoul
freq      1        NaN        NaN      2
mean    NaN  87.500000  17.333333    NaN
std     NaN   6.454972   0.577350    NaN
min     NaN  80.000000  17.000000    NaN
25%     NaN  83.750000  17.000000    NaN
50%     NaN  87.500000  17.000000    NaN
75%     NaN  91.250000  17.500000    NaN
max     NaN  95.000000  18.000000    NaN

해설: 위 코드에서 describe의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

016. dtypes — 조회·선택

기능 · dtypes 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.dtypes
print(result)

실행 결과 (Pandas 환경 기준)

name      object
score      int64
age      float64
city      object
dtype: object

해설: 위 코드에서 dtypes의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

017. shape — 조회·선택

기능 · shape 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.shape
print(result)

실행 결과 (Pandas 환경 기준)

(4, 4)

해설: 위 코드에서 shape의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

018. columns — 조회·선택

기능 · columns 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.columns.tolist()
print(result)

실행 결과 (Pandas 환경 기준)

['name', 'score', 'age', 'city']

해설: 위 코드에서 columns의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

019. index — 조회·선택

기능 · index 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.index.tolist()
print(result)

실행 결과 (Pandas 환경 기준)

[0, 1, 2, 3]

해설: 위 코드에서 index의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

020. loc — 조회·선택

기능 · loc 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.loc[df.score >= 85, ["name","score"]]
print(result)

실행 결과 (Pandas 환경 기준)

   name  score
0   Kim     90
2  Park     95
3  Choi     85

해설: 위 코드에서 loc의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

021. iloc — 조회·선택

기능 · iloc 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.iloc[:2, :2]
print(result)

실행 결과 (Pandas 환경 기준)

  name  score
0  Kim     90
1  Lee     80

해설: 위 코드에서 iloc의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

022. at — 조회·선택

기능 · at 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.at[0,"score"]
print(result)

실행 결과 (Pandas 환경 기준)

90

해설: 위 코드에서 at의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

023. iat — 조회·선택

기능 · iat 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.iat[0,1]
print(result)

실행 결과 (Pandas 환경 기준)

90

해설: 위 코드에서 iat의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

024. query — 조회·선택

기능 · query 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.query("score >= 85")
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0    Seoul
2  Park     95  17.0    Seoul
3  Choi     85   NaN  Incheon

해설: 위 코드에서 query의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

025. filter — 조회·선택

기능 · filter 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.filter(items=["name","score"])
print(result)

실행 결과 (Pandas 환경 기준)

   name  score
0   Kim     90
1   Lee     80
2  Park     95
3  Choi     85

해설: 위 코드에서 filter의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

026. isin — 조회·선택

기능 · isin 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df[df.name.isin(["Kim","Lee"])]
print(result)

실행 결과 (Pandas 환경 기준)

  name  score   age   city
0  Kim     90  17.0  Seoul
1  Lee     80  18.0  Busan

해설: 위 코드에서 isin의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

027. between — 조회·선택

기능 · between 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df[df.score.between(80,90)]
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0    Seoul
1   Lee     80  18.0    Busan
3  Choi     85   NaN  Incheon

해설: 위 코드에서 between의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

028. nlargest — 조회·선택

기능 · nlargest 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.nlargest(2,"score")
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age   city
2  Park     95  17.0  Seoul
0   Kim     90  17.0  Seoul

해설: 위 코드에서 nlargest의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

029. nsmallest — 조회·선택

기능 · nsmallest 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.nsmallest(2,"score")
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
1   Lee     80  18.0    Busan
3  Choi     85   NaN  Incheon

해설: 위 코드에서 nsmallest의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

030. assign — 정리·변환

기능 · assign 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.assign(bonus=df.score+5)
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city  bonus
0   Kim     90  17.0    Seoul     95
1   Lee     80  18.0    Busan     85
2  Park     95  17.0    Seoul    100
3  Choi     85   NaN  Incheon     90

해설: 위 코드에서 assign의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

031. rename — 정리·변환

기능 · rename 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.rename(columns={"score":"점수"})
print(result)

실행 결과 (Pandas 환경 기준)

   name  점수   age     city
0   Kim  90  17.0    Seoul
1   Lee  80  18.0    Busan
2  Park  95  17.0    Seoul
3  Choi  85   NaN  Incheon

해설: 위 코드에서 rename의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

032. drop — 정리·변환

기능 · drop 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.drop(columns="city")
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age
0   Kim     90  17.0
1   Lee     80  18.0
2  Park     95  17.0
3  Choi     85   NaN

해설: 위 코드에서 drop의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

033. drop_duplicates — 정리·변환

기능 · drop_duplicates 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.drop_duplicates(subset="city")
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0    Seoul
1   Lee     80  18.0    Busan
3  Choi     85   NaN  Incheon

해설: 위 코드에서 drop_duplicates의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

034. sort_values — 정리·변환

기능 · sort_values 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.sort_values("score", ascending=False)
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
2  Park     95  17.0    Seoul
0   Kim     90  17.0    Seoul
3  Choi     85   NaN  Incheon
1   Lee     80  18.0    Busan

해설: 위 코드에서 sort_values의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

035. sort_index — 정리·변환

기능 · sort_index 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.sort_index(ascending=False)
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
3  Choi     85   NaN  Incheon
2  Park     95  17.0    Seoul
1   Lee     80  18.0    Busan
0   Kim     90  17.0    Seoul

해설: 위 코드에서 sort_index의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

036. set_index — 정리·변환

기능 · set_index 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.set_index("name")
print(result)

실행 결과 (Pandas 환경 기준)

      score   age     city
name                      
Kim      90  17.0    Seoul
Lee      80  18.0    Busan
Park     95  17.0    Seoul
Choi     85   NaN  Incheon

해설: 위 코드에서 set_index의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

037. reset_index — 정리·변환

기능 · reset_index 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.set_index("name").reset_index()
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0    Seoul
1   Lee     80  18.0    Busan
2  Park     95  17.0    Seoul
3  Choi     85   NaN  Incheon

해설: 위 코드에서 reset_index의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

038. astype — 정리·변환

기능 · astype 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.astype({"score":"float64"})
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim   90.0  17.0    Seoul
1   Lee   80.0  18.0    Busan
2  Park   95.0  17.0    Seoul
3  Choi   85.0   NaN  Incheon

해설: 위 코드에서 astype의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

039. replace — 정리·변환

기능 · replace 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.replace({"city":{"Seoul":"서울"}})
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0       서울
1   Lee     80  18.0    Busan
2  Park     95  17.0       서울
3  Choi     85   NaN  Incheon

해설: 위 코드에서 replace의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

040. map — 정리·변환

기능 · map 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.map({"Kim":"김","Lee":"이","Park":"박","Choi":"최"})
print(result)

실행 결과 (Pandas 환경 기준)

0    김
1    이
2    박
3    최
Name: name, dtype: object

해설: 위 코드에서 map의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

041. apply — 정리·변환

기능 · apply 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.apply(lambda x: "합격" if x>=85 else "보충")
print(result)

실행 결과 (Pandas 환경 기준)

0    합격
1    보충
2    합격
3    합격
Name: score, dtype: object

해설: 위 코드에서 apply의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

042. pipe — 정리·변환

기능 · pipe 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.pipe(lambda d: d.assign(double=d.score*2))
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city  double
0   Kim     90  17.0    Seoul     180
1   Lee     80  18.0    Busan     160
2  Park     95  17.0    Seoul     190
3  Choi     85   NaN  Incheon     170

해설: 위 코드에서 pipe의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

043. explode — 정리·변환

기능 · explode 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.DataFrame({"x":[[1,2],[3]]}).explode("x")
print(result)

실행 결과 (Pandas 환경 기준)

   x
0  1
0  2
1  3

해설: 위 코드에서 explode의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

044. melt — 정리·변환

기능 · melt 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.melt(id_vars="name", value_vars=["score","age"])
print(result)

실행 결과 (Pandas 환경 기준)

   name variable  value
0   Kim    score   90.0
1   Lee    score   80.0
2  Park    score   95.0
3  Choi    score   85.0
4   Kim      age   17.0
5   Lee      age   18.0
6  Park      age   17.0
7  Choi      age    NaN

해설: 위 코드에서 melt의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

045. pivot — 정리·변환

기능 · pivot 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.pivot(index="name",columns="city",values="score")
print(result)

실행 결과 (Pandas 환경 기준)

city  Busan  Incheon  Seoul
name                       
Choi    NaN     85.0    NaN
Kim     NaN      NaN   90.0
Lee    80.0      NaN    NaN
Park    NaN      NaN   95.0

해설: 위 코드에서 pivot의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

046. get_dummies — 정리·변환

기능 · get_dummies 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.get_dummies(df.city, dtype=int)
print(result)

실행 결과 (Pandas 환경 기준)

   Busan  Incheon  Seoul
0      0        0      1
1      1        0      0
2      0        0      1
3      0        1      0

해설: 위 코드에서 get_dummies의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

047. cut — 정리·변환

기능 · cut 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.cut(df.score,bins=[0,80,90,100],include_lowest=True)
print(result)

실행 결과 (Pandas 환경 기준)

0      (80.0, 90.0]
1    (-0.001, 80.0]
2     (90.0, 100.0]
3      (80.0, 90.0]
Name: score, dtype: category
Categories (3, interval[float64, right]): [(-0.001, 80.0] < (80.0, 90.0] < (90.0, 100.0]]

해설: 위 코드에서 cut의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

048. qcut — 정리·변환

기능 · qcut 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.qcut(df.score,q=2,duplicates="drop")
print(result)

실행 결과 (Pandas 환경 기준)

0      (87.5, 95.0]
1    (79.999, 87.5]
2      (87.5, 95.0]
3    (79.999, 87.5]
Name: score, dtype: category
Categories (2, interval[float64, right]): [(79.999, 87.5] < (87.5, 95.0]]

해설: 위 코드에서 qcut의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

049. rank — 정리·변환

기능 · rank 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.rank(ascending=False)
print(result)

실행 결과 (Pandas 환경 기준)

0    2.0
1    4.0
2    1.0
3    3.0
Name: score, dtype: float64

해설: 위 코드에서 rank의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

050. isna — 결측치·문자열

기능 · isna 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.isna().sum()
print(result)

실행 결과 (Pandas 환경 기준)

name     0
score    0
age      1
city     0
dtype: int64

해설: 위 코드에서 isna의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

051. notna — 결측치·문자열

기능 · notna 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.notna().sum()
print(result)

실행 결과 (Pandas 환경 기준)

name     4
score    4
age      3
city     4
dtype: int64

해설: 위 코드에서 notna의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

052. fillna — 결측치·문자열

기능 · fillna 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.fillna({"age":0})
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0    Seoul
1   Lee     80  18.0    Busan
2  Park     95  17.0    Seoul
3  Choi     85   0.0  Incheon

해설: 위 코드에서 fillna의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

053. dropna — 결측치·문자열

기능 · dropna 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.dropna()
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age   city
0   Kim     90  17.0  Seoul
1   Lee     80  18.0  Busan
2  Park     95  17.0  Seoul

해설: 위 코드에서 dropna의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

054. interpolate — 결측치·문자열

기능 · interpolate 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.Series([1,None,3]).interpolate()
print(result)

실행 결과 (Pandas 환경 기준)

0    1.0
1    2.0
2    3.0
dtype: float64

해설: 위 코드에서 interpolate의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

055. str.lower — 결측치·문자열

기능 · str.lower 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.str.lower()
print(result)

실행 결과 (Pandas 환경 기준)

0     kim
1     lee
2    park
3    choi
Name: name, dtype: object

해설: 위 코드에서 str.lower의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

056. str.upper — 결측치·문자열

기능 · str.upper 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.str.upper()
print(result)

실행 결과 (Pandas 환경 기준)

0     KIM
1     LEE
2    PARK
3    CHOI
Name: name, dtype: object

해설: 위 코드에서 str.upper의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

057. str.contains — 결측치·문자열

기능 · str.contains 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.str.contains("i",case=False)
print(result)

실행 결과 (Pandas 환경 기준)

0     True
1    False
2    False
3     True
Name: name, dtype: bool

해설: 위 코드에서 str.contains의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

058. str.replace — 결측치·문자열

기능 · str.replace 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.str.replace("i","I",regex=False)
print(result)

실행 결과 (Pandas 환경 기준)

0     KIm
1     Lee
2    Park
3    ChoI
Name: name, dtype: object

해설: 위 코드에서 str.replace의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

059. str.len — 결측치·문자열

기능 · str.len 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.str.len()
print(result)

실행 결과 (Pandas 환경 기준)

0    3
1    3
2    4
3    4
Name: name, dtype: int64

해설: 위 코드에서 str.len의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

060. str.slice — 결측치·문자열

기능 · str.slice 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.name.str.slice(0,2)
print(result)

실행 결과 (Pandas 환경 기준)

0    Ki
1    Le
2    Pa
3    Ch
Name: name, dtype: object

해설: 위 코드에서 str.slice의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

061. str.split — 결측치·문자열

기능 · str.split 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.Series(["a-b","c-d"]).str.split("-",expand=True)
print(result)

실행 결과 (Pandas 환경 기준)

   0  1
0  a  b
1  c  d

해설: 위 코드에서 str.split의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

062. str.extract — 결측치·문자열

기능 · str.extract 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.Series(["A12","B34"]).str.extract(r"([A-Z])(\d+)")
print(result)

실행 결과 (Pandas 환경 기준)

   0   1
0  A  12
1  B  34

해설: 위 코드에서 str.extract의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

063. sum — 통계·집계

기능 · sum 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.sum()
print(result)

실행 결과 (Pandas 환경 기준)

350

해설: 위 코드에서 sum의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

064. mean — 통계·집계

기능 · mean 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.mean()
print(result)

실행 결과 (Pandas 환경 기준)

87.5

해설: 위 코드에서 mean의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

065. median — 통계·집계

기능 · median 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.median()
print(result)

실행 결과 (Pandas 환경 기준)

87.5

해설: 위 코드에서 median의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

066. min — 통계·집계

기능 · min 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.min()
print(result)

실행 결과 (Pandas 환경 기준)

80

해설: 위 코드에서 min의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

067. max — 통계·집계

기능 · max 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.max()
print(result)

실행 결과 (Pandas 환경 기준)

95

해설: 위 코드에서 max의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

068. std — 통계·집계

기능 · std 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.std()
print(result)

실행 결과 (Pandas 환경 기준)

6.454972243679028

해설: 위 코드에서 std의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

069. var — 통계·집계

기능 · var 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.var()
print(result)

실행 결과 (Pandas 환경 기준)

41.666666666666664

해설: 위 코드에서 var의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

070. count — 통계·집계

기능 · count 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.count()
print(result)

실행 결과 (Pandas 환경 기준)

4

해설: 위 코드에서 count의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

071. nunique — 통계·집계

기능 · nunique 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.city.nunique()
print(result)

실행 결과 (Pandas 환경 기준)

3

해설: 위 코드에서 nunique의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

072. unique — 통계·집계

기능 · unique 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.city.unique()
print(result)

실행 결과 (Pandas 환경 기준)

['Seoul' 'Busan' 'Incheon']

해설: 위 코드에서 unique의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

073. value_counts — 통계·집계

기능 · value_counts 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.city.value_counts()
print(result)

실행 결과 (Pandas 환경 기준)

city
Seoul      2
Busan      1
Incheon    1
Name: count, dtype: int64

해설: 위 코드에서 value_counts의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

074. quantile — 통계·집계

기능 · quantile 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.quantile([.25,.5,.75])
print(result)

실행 결과 (Pandas 환경 기준)

0.25    83.75
0.50    87.50
0.75    91.25
Name: score, dtype: float64

해설: 위 코드에서 quantile의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

075. corr — 통계·집계

기능 · corr 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df[["score","age"]].corr()
print(result)

실행 결과 (Pandas 환경 기준)

          score       age
score  1.000000 -0.944911
age   -0.944911  1.000000

해설: 위 코드에서 corr의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

076. cov — 통계·집계

기능 · cov 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df[["score","age"]].cov()
print(result)

실행 결과 (Pandas 환경 기준)

           score       age
score  41.666667 -4.166667
age    -4.166667  0.333333

해설: 위 코드에서 cov의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

077. cumsum — 통계·집계

기능 · cumsum 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.cumsum()
print(result)

실행 결과 (Pandas 환경 기준)

0     90
1    170
2    265
3    350
Name: score, dtype: int64

해설: 위 코드에서 cumsum의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

078. cummax — 통계·집계

기능 · cummax 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.cummax()
print(result)

실행 결과 (Pandas 환경 기준)

0    90
1    90
2    95
3    95
Name: score, dtype: int64

해설: 위 코드에서 cummax의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

079. diff — 통계·집계

기능 · diff 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.diff()
print(result)

실행 결과 (Pandas 환경 기준)

0     NaN
1   -10.0
2    15.0
3   -10.0
Name: score, dtype: float64

해설: 위 코드에서 diff의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

080. pct_change — 통계·집계

기능 · pct_change 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.pct_change()
print(result)

실행 결과 (Pandas 환경 기준)

0         NaN
1   -0.111111
2    0.187500
3   -0.105263
Name: score, dtype: float64

해설: 위 코드에서 pct_change의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

081. groupby mean — 통계·집계

기능 · groupby mean 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.groupby("city")["score"].mean()
print(result)

실행 결과 (Pandas 환경 기준)

city
Busan      80.0
Incheon    85.0
Seoul      92.5
Name: score, dtype: float64

해설: 위 코드에서 groupby mean의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

082. groupby agg — 통계·집계

기능 · groupby agg 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.groupby("city").agg(평균=("score","mean"),인원=("name","count"))
print(result)

실행 결과 (Pandas 환경 기준)

           평균  인원
city             
Busan    80.0   1
Incheon  85.0   1
Seoul    92.5   2

해설: 위 코드에서 groupby agg의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

083. transform — 통계·집계

기능 · transform 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.groupby("city")["score"].transform("mean")
print(result)

실행 결과 (Pandas 환경 기준)

0    92.5
1    80.0
2    92.5
3    85.0
Name: score, dtype: float64

해설: 위 코드에서 transform의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

084. pivot_table — 통계·집계

기능 · pivot_table 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.pivot_table(index="city",values="score",aggfunc="mean")
print(result)

실행 결과 (Pandas 환경 기준)

         score
city          
Busan     80.0
Incheon   85.0
Seoul     92.5

해설: 위 코드에서 pivot_table의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

085. crosstab — 통계·집계

기능 · crosstab 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.crosstab(df.city,df.score>=85)
print(result)

실행 결과 (Pandas 환경 기준)

score    False  True 
city                 
Busan        1      0
Incheon      0      1
Seoul        0      2

해설: 위 코드에서 crosstab의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

086. concat — 결합·시계열·창

기능 · concat 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.concat([df.head(2),df.tail(2)],ignore_index=True)
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city
0   Kim     90  17.0    Seoul
1   Lee     80  18.0    Busan
2  Park     95  17.0    Seoul
3  Choi     85   NaN  Incheon

해설: 위 코드에서 concat의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

087. merge — 결합·시계열·창

기능 · merge 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.merge(df, pd.DataFrame({"name":["Kim","Lee"],"club":["A","B"]}),on="name",how="left")
print(result)

실행 결과 (Pandas 환경 기준)

   name  score   age     city club
0   Kim     90  17.0    Seoul    A
1   Lee     80  18.0    Busan    B
2  Park     95  17.0    Seoul  NaN
3  Choi     85   NaN  Incheon  NaN

해설: 위 코드에서 merge의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

088. join — 결합·시계열·창

기능 · join 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.set_index("name").join(pd.DataFrame({"club":["A","B"]},index=["Kim","Lee"]))
print(result)

실행 결과 (Pandas 환경 기준)

      score   age     city club
name                           
Kim      90  17.0    Seoul    A
Lee      80  18.0    Busan    B
Park     95  17.0    Seoul  NaN
Choi     85   NaN  Incheon  NaN

해설: 위 코드에서 join의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

089. to_datetime — 결합·시계열·창

기능 · to_datetime 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.to_datetime(pd.Series(["2026-01-01","2026-02-03"]))
print(result)

실행 결과 (Pandas 환경 기준)

0   2026-01-01
1   2026-02-03
dtype: datetime64[ns]

해설: 위 코드에서 to_datetime의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

090. dt.month — 결합·시계열·창

기능 · dt.month 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.to_datetime(pd.Series(["2026-01-01","2026-02-03"])).dt.month
print(result)

실행 결과 (Pandas 환경 기준)

0    1
1    2
dtype: int32

해설: 위 코드에서 dt.month의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

091. resample — 결합·시계열·창

기능 · resample 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.Series([1,2,3,4],index=pd.date_range("2026-01-01",periods=4,freq="D")).resample("2D").sum()
print(result)

실행 결과 (Pandas 환경 기준)

2026-01-01    3
2026-01-03    7
Freq: 2D, dtype: int64

해설: 위 코드에서 resample의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

092. shift — 결합·시계열·창

기능 · shift 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.shift(1)
print(result)

실행 결과 (Pandas 환경 기준)

0     NaN
1    90.0
2    80.0
3    95.0
Name: score, dtype: float64

해설: 위 코드에서 shift의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

093. rolling — 결합·시계열·창

기능 · rolling 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.rolling(2).mean()
print(result)

실행 결과 (Pandas 환경 기준)

0     NaN
1    85.0
2    87.5
3    90.0
Name: score, dtype: float64

해설: 위 코드에서 rolling의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

094. expanding — 결합·시계열·창

기능 · expanding 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.expanding().mean()
print(result)

실행 결과 (Pandas 환경 기준)

0    90.000000
1    85.000000
2    88.333333
3    87.500000
Name: score, dtype: float64

해설: 위 코드에서 expanding의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

095. ewm — 결합·시계열·창

기능 · ewm 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.ewm(span=2).mean()
print(result)

실행 결과 (Pandas 환경 기준)

0    90.000000
1    82.500000
2    91.153846
3    87.000000
Name: score, dtype: float64

해설: 위 코드에서 ewm의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

096. stack — 결합·시계열·창

기능 · stack 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df[["score","age"]].stack()
print(result)

실행 결과 (Pandas 환경 기준)

0  score    90.0
   age      17.0
1  score    80.0
   age      18.0
2  score    95.0
   age      17.0
3  score    85.0
dtype: float64

해설: 위 코드에서 stack의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

097. unstack — 결합·시계열·창

기능 · unstack 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.set_index(["city","name"])["score"].unstack("city")
print(result)

실행 결과 (Pandas 환경 기준)

city  Busan  Incheon  Seoul
name                       
Choi    NaN     85.0    NaN
Kim     NaN      NaN   90.0
Lee    80.0      NaN    NaN
Park    NaN      NaN   95.0

해설: 위 코드에서 unstack의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

098. factorize — 결합·시계열·창

기능 · factorize 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = pd.factorize(df.city)
print(result)

실행 결과 (Pandas 환경 기준)

(array([0, 1, 0, 2]), Index(['Seoul', 'Busan', 'Incheon'], dtype='object'))

해설: 위 코드에서 factorize의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

099. clip — 결합·시계열·창

기능 · clip 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.clip(lower=80,upper=90)
print(result)

실행 결과 (Pandas 환경 기준)

0    90
1    80
2    90
3    85
Name: score, dtype: int64

해설: 위 코드에서 clip의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

100. where — 결합·시계열·창

기능 · where 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.where(df.score>=85,other=0)
print(result)

실행 결과 (Pandas 환경 기준)

0    90
1     0
2    95
3    85
Name: score, dtype: int64

해설: 위 코드에서 where의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.

101. mask — 결합·시계열·창

기능 · mask 연산을 예제 데이터에 적용하여 결과를 확인합니다. 출력의 인덱스·자료형·결측값 변화도 관찰하세요.

실행 가능한 파이썬 코드

import pandas as pd
from io import StringIO
import numpy as np

df = pd.DataFrame({
    "name": ["Kim", "Lee", "Park", "Choi"],
    "score": [90, 80, 95, 85],
    "age": [17, 18, 17, np.nan],
    "city": ["Seoul", "Busan", "Seoul", "Incheon"]
})

result = df.score.mask(df.score<85,other=0)
print(result)

실행 결과 (Pandas 환경 기준)

0    90
1     0
2    95
3    85
Name: score, dtype: int64

해설: 위 코드에서 mask의 입력과 반환값을 비교하세요. Series와 DataFrame의 인덱스 정렬 및 NaN 처리에 유의합니다.