빅데이터분석기사 실기 1유형 마스터 — 데이터 전처리 핵심 함수 총정리
"1유형만 확실히 잡아도 30점을 먹고 들어갑니다."
안녕하세요. 오늘은 빅데이터분석기사 실기시험 1유형 — 데이터 전처리 파트를 집중적으로 다루겠습니다. 실기시험 총 100점 중 1유형이 차지하는 비중은 30점입니다. 숫자만 보면 크지 않게 느껴질 수 있지만, 이 30점을 안정적으로 확보하는 것이 실기 합격의 최소 마지노선을 만드는 핵심입니다.
실기 합격 커트라인이 보통 55~65점 수준이라는 점을 감안하면, 1유형 20점 + 2유형 30점 = 50점만 확보해도 합격에 매우 근접하게 됩니다. 거기서 3유형에서 10점만 더 얻으면 합격입니다.
오늘 글에서는 1유형에서 출제되는 모든 핵심 Pandas 함수를 코드와 함께 정리하고, 실제 기출 패턴을 분석하며, 데이터마님 사이트를 활용한 학습 방법까지 상세하게 안내하겠습니다.
목차
- 실기 1유형이란? — 구조와 출제 방식 이해
- 시험 환경 설정 및 도구 준비
- 데이터 불러오기 — 첫 단추가 중요하다
- 데이터 탐색 함수 — 데이터를 먼저 파악하라
- 결측치 처리 — 빈 값을 다루는 모든 방법
- 이상치 탐지 — 사분위수로 이상값 찾기
- 정규화와 표준화 — 스케일링의 모든 것
- 데이터 변환 및 필터링 — Pandas 고급 함수
- GroupBy 완벽 마스터 — 고빈출 함수
- 날짜 데이터 처리 — datetime 활용법
- 실제 기출 문제 패턴 분석 (7회차~11회차)
- 데이터마님 활용 학습 전략
- 시험장에서의 1유형 풀이 전략
- 자주 하는 실수 TOP 10
- 최종 복습 체크리스트
- 참고 출처
1. 실기 1유형이란? — 구조와 출제 방식 이해
1-1. 실기시험 전체 구조
먼저 실기시험의 전체 그림을 이해해야 합니다.
┌──────────┬───────────────────────────────┬───────┬─────────────┐
│ 유형 │ 평가 내용 │ 배점 │ 시간 비중 │
├──────────┼───────────────────────────────┼───────┼─────────────┤
│ 1유형 │ 데이터 전처리 │ 30점 │ 약 40분 │
│ │ (탐색, 결측치, 이상치, │ │ │
│ │ 정규화, 필터링 등) │ │ │
├──────────┼───────────────────────────────┼───────┼─────────────┤
│ 2유형 │ 머신러닝 모델링 │ 40점 │ 약 50분 │
│ │ (RandomForest 템플릿) │ │ │
├──────────┼───────────────────────────────┼───────┼─────────────┤
│ 3유형 │ 통계 분석 │ 30점 │ 약 40분 │
│ │ (OLS 회귀, 로지스틱 회귀) │ │ │
├──────────┼───────────────────────────────┼───────┼─────────────┤
│ 합계 │ │ 100점 │ 총 150분 │
└──────────┴───────────────────────────────┴───────┴─────────────┘
합격 기준: 총점 60점 이상1-2. 1유형의 특징
┌─────────────────────────────────────────────────────────────────┐
│ 1유형 핵심 특징 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ✓ 하나의 데이터셋에 대해 여러 개의 소문항이 출제됨 │
│ ✓ 각 소문항은 독립적이며, 앞 문제의 답이 뒤 문제에 │
│ 영향을 주지 않는 경우가 대부분 │
│ ✓ 답은 숫자(정수 또는 실수)를 출력하는 형태 │
│ ✓ Pandas 중심의 Python 코드 작성 능력 평가 │
│ ✓ 기출 패턴이 반복되므로 연습 충분히 가능 │
│ ✓ 시간 배분이 핵심 — 너무 오래 걸리면 2·3유형에 지장 │
│ │
└─────────────────────────────────────────────────────────────────┘1-3. 1유형에서 자주 묻는 질문 유형
1유형의 소문항은 대체로 아래와 같은 패턴으로 출제됩니다.
┌──────┬──────────────────────────────────────────────────────────┐
│ 번호 │ 질문 유형 │
├──────┼──────────────────────────────────────────────────────────┤
│ Q1 │ "전체 데이터에서 ○○ 칼럼의 결측치(또는 null이 아닌 │
│ │ 행)의 수는?" │
├──────┼──────────────────────────────────────────────────────────┤
│ Q2 │ "○○ 칼럼에서 이상치의 수는?" │
│ │ (IQR 방식으로 판단) │
├──────┼──────────────────────────────────────────────────────────┤
│ Q3 │ "○○ 칼럼을 Min-Max 정규화한 후 값이 0.5 이상인 │
│ │ 데이터의 수는?" │
├──────┼──────────────────────────────────────────────────────────┤
│ Q4 │ "○○ 칼럼을 Z-score 표준화한 후 값이 1.5 이상인 │
│ │ 데이터의 수는?" │
├──────┼──────────────────────────────────────────────────────────┤
│ Q5 │ "상관관계가 가장 높은 두 칼럼의 이름은?" │
│ │ 또는 "○○와 가장 상관관계가 높은 칼럼명은?" │
├──────┼──────────────────────────────────────────────────────────┤
│ Q6 │ "특정 조건을 만족하는 행의 수는?" │
│ │ (필터링 후 count) │
├──────┼──────────────────────────────────────────────────────────┤
│ Q7 │ "groupby 후 특정 집계값은?" │
│ │ (그룹별 평균, 합계, 최대값 등) │
└──────┴──────────────────────────────────────────────────────────┘
2. 시험 환경 설정 및 도구 준비
2-1. 시험장 환경
실기시험은 PC를 활용하여 진행됩니다. 시험장 컴퓨터에는 Python과 Jupyter Notebook이 기본 설치되어 있습니다. 인터넷은 사용할 수 없으므로, 모든 코드를 암기하고 있어야 합니다.
┌─────────────────────────────────────────────────────────────────┐
│ 시험장 환경 정보 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ OS: Windows │
│ Python 버전: 3.x (시험장마다 상이할 수 있음) │
│ IDE: Jupyter Notebook (기본 설치) │
│ 인터넷: 사용 불가 │
│ 주요 라이브러리: pandas, numpy, sklearn, statsmodels │
│ 파일 형식: .csv (데이터 파일), .ipynb (답안 제출) │
│ │
│ ★ 인터넷이 안 되므로 라이브러리 도움말(help, dir) │
│ 이외에는 어떤 검색도 할 수 없습니다 │
│ │
└─────────────────────────────────────────────────────────────────┘2-2. 사전 학습 환경 구축
시험 준비를 시작하기 전에, 자신의 PC에 학습 환경을 구축해야 합니다.
┌──────────────────────┬──────────────────────────────────────────────┐
│ 방법 │ 상세 설명 │
├──────────────────────┼──────────────────────────────────────────────┤
│ 방법 1: 로컬 설치 │ Python + Jupyter Notebook 설치 │
│ (권장) │ Anaconda 배포판 설치 시 한 번에 가능 │
│ │ → 가장 시험장 환경과 유사 │
├──────────────────────┼──────────────────────────────────────────────┤
│ 방법 2: Google Colab │ 웹 브라우저에서 바로 사용 가능 │
│ (대안) │ 설치 불필요, 인터넷만 있으면 OK │
│ │ → 단, 시험장에서는 사용 불가이므로 │
│ 로컬 환경도 반드시 경험할 것 │
├──────────────────────┼──────────────────────────────────────────────┤
│ 방법 3: 데이터마님 │ 데이터마님 사이트에서 제공하는 │
│ 내장 환경 │ 온라인 코드 실행 환경 활용 │
│ │ → 회원가입 후 바로 실습 가능 │
└──────────────────────┴──────────────────────────────────────────────┘2-3. 라이브러리 import 기본 코드
시험장에서 코드를 작성할 때 가장 먼저 입력하는 부분입니다.
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler, StandardScaler
import warnings
warnings.filterwarnings('ignore')
이 네 줄은 매 문제마다 상단에 입력하는 것이 안전합니다. 특히 warnings.filterwarnings('ignore')는 경고 메시지를 숨겨서 출력 결과를 깔끔하게 만들어 줍니다.
3. 데이터 불러오기 — 첫 단추가 중요하다
3-1. CSV 파일 읽기
실기시험에서는 데이터 파일이 CSV 형식으로 제공됩니다.
# 데이터 불러오기
df = pd.read_csv('data.csv')
# 인코딩이 깨질 경우 (한국어 데이터)
df = pd.read_csv('data.csv', encoding='cp949')
df = pd.read_csv('data.csv', encoding='utf-8')3-2. 인코딩 문제 해결
실기시험에서 한국어 데이터가 포함된 CSV를 읽을 때 인코딩 오류가 발생하는 경우가 있습니다.
┌────────────────────────┬──────────────────────────────────────────┐
│ 인코딩 종류 │ 사용 상황 │
├────────────────────────┼──────────────────────────────────────────┤
│ utf-8 │ 기본 인코딩, 대부분의 경우 여기서 해결 │
│ cp949 │ Windows 한글 환경에서 생성된 CSV │
│ euc-kr │ 일부 한국어 CSV 파일 │
│ latin1 │ 특수 문자 포함 시 │
└────────────────────────┴──────────────────────────────────────────┘
만약 utf-8로 읽었을 때 깨진다면 cp949를 시도하고, 그래도 안 되면 euc-kr을 시도하면 됩니다. 시험장에서는 보통 utf-8 또는 cp949 중 하나로 해결됩니다.
3-3. 데이터 파일 경로
시험장에서는 보통 데이터 파일과 Jupyter Notebook이 같은 폴더에 위치하므로, 파일명만 정확히 입력하면 됩니다. 파일명은 문제에서 제공되므로 빠뜨리지 말고 정확히 복사하세요.
# 문제에서 제공된 파일명을 정확히 사용
df = pd.read_csv('exam_data.csv')
4. 데이터 탐색 함수 — 데이터를 먼저 파악하라
데이터를 불러온 후에는 반드시 데이터의 구조를 파악해야 합니다. 이 과정을 생략하면 이후 코드에서 예상치 못한 오류가 발생합니다.
4-1. 핵심 탐색 함수 목록
┌──────────────────────────┬───────────────────────────────────────────┐
│ 함수 │ 출력 내용 │
├──────────────────────────┼───────────────────────────────────────────┤
│ df.head() │ 처음 5행 출력 │
│ df.tail() │ 마지막 5행 출력 │
│ df.shape │ (행 수, 열 수) 튜플 출력 │
│ df.info() │ 칼럼명, 데이터 타입, 결측치 수 │
│ df.describe() │ 수치형 칼럼의 통계 요약 │
│ df.columns │ 칼럼명 리스트 출력 │
│ df.dtypes │ 각 칼럼의 데이터 타입 │
│ df.isnull().sum() │ 칼럼별 결측치 수 │
│ df.value_counts() │ 특정 칼럼의 범주별 빈도수 │
│ df.nunique() │ 칼럼별 고유값 수 │
│ df.duplicated().sum() │ 중복 행의 수 │
└──────────────────────────┴───────────────────────────────────────────┘4-2. 데이터 탐색 코드 예제
# 데이터 기본 정보 확인
print(df.shape) # 행과 열의 수
print(df.info()) # 데이터 타입과 결측치 확인
print(df.describe()) # 수치형 통계 요약
print(df.isnull().sum()) # 칼럼별 결측치 수4-3. 꼭 기억해야 할 탐색 패턴
실기시험에서 "데이터의 행 수는?", "칼럼 수는?", "○○ 칼럼의 결측치 수는?" 같은 문제가 자주 출제됩니다.
# 데이터의 행 수
len(df)
df.shape[0]
# 칼럼 수
df.shape[1]
# 특정 칼럼의 결측치 수
df['칼럼명'].isnull().sum()
# 특정 칼럼의 결측치가 아닌 행의 수
df['칼럼명'].notnull().sum()
# 특정 칼럼의 고유값 수
df['칼럼명'].nunique()
# 특정 칼럼의 평균
df['칼럼명'].mean()
5. 결측치 처리 — 빈 값을 다루는 모든 방법
결측치(null, NaN) 처리는 1유형에서 가장 자주 출제되는 주제 중 하나입니다. 반드시 익혀야 할 함수들을 정리합니다.
5-1. 결측치 확인
# 전체 결측치 확인
df.isnull().sum()
# 특정 칼럼의 결측치 수
df['칼럼명'].isnull().sum()
# 결측치가 아닌 행의 수
df['칼럼명'].notnull().sum()
# 전체 데이터에서 결측치가 하나라도 있는 행의 수
df.isnull().any(axis=1).sum()5-2. 결측치 삭제
# 결측치가 있는 행 전체 삭제
df.dropna()
# 특정 칼럼의 결측치가 있는 행만 삭제
df.dropna(subset=['칼럼명'])
# 특정 칼럼의 결측치 삭제 (해당 칼럼 기준)
df = df[df['칼럼명'].notnull()]
# 결측치가 있는 열(칼럼) 삭제
df.dropna(axis=1)5-3. 결측치 대체
# 특정 값으로 대체
df['칼럼명'] = df['칼럼명'].fillna(0)
# 평균값으로 대체
df['칼럼명'] = df['칼럼명'].fillna(df['칼럼명'].mean())
# 중앙값으로 대체
df['칼럼명'] = df['칼럼명'].fillna(df['칼럼명'].median())
# 최빈값으로 대체 (범주형 데이터)
df['칼럼명'] = df['칼럼명'].fillna(df['칼럼명'].mode()[0])
# 바로 직전 값으로 대체 (시계열 데이터)
df['칼럼명'] = df['칼럼명'].fillna(method='ffill')
# 바로 다음 값으로 대체
df['칼럼명'] = df['칼럼명'].fillna(method='bfill')5-4. 결측치 처리 방법 비교표
┌─────────────────────┬──────────────────────────┬────────────────────────────┐
│ 방법 │ 장점 │ 적합한 상황 │
├─────────────────────┼──────────────────────────┼────────────────────────────┤
│ dropna (행 삭제) │ 간단하고 빠름 │ 결측치 비율이 낮을 때 │
│ │ │ (전체의 5% 미만) │
├─────────────────────┼──────────────────────────┼────────────────────────────┤
│ 평균값 대체 │ 데이터 수 유지 │ 수치형, 정규분포에 가까울 │
│ fillna(mean) │ 이상치에 민감 │ 때 │
├─────────────────────┼──────────────────────────┼────────────────────────────┤
│ 중앙값 대체 │ 이상치에 강건 │ 수치형, 이상치가 있을 때 │
│ fillna(median) │ 데이터 수 유지 │ │
├─────────────────────┼──────────────────────────┼────────────────────────────┤
│ 최빈값 대체 │ 범주형에 적합 │ 범주형 변수의 결측치 │
│ fillna(mode) │ │ │
├─────────────────────┼──────────────────────────┼────────────────────────────┤
│ 0 대체 │ 가장 간단 │ 결측이 곧 0을 의미할 때 │
│ fillna(0) │ │ (예: 구매 횟수) │
├─────────────────────┼──────────────────────────┼────────────────────────────┤
│ ffill / bfill │ 시간 순서 유지 │ 시계열 데이터 │
│ │ │ │
└─────────────────────┴──────────────────────────┴────────────────────────────┘5-5. 실전 팁
실기시험에서는 보통 "어떤 방식으로 결측치를 처리하라"는 지시가 문제에 명시되어 있습니다. 따라서 문제를 꼼꼼히 읽어서 평균 대체인지, 중앙값 대체인지, 삭제인지를 정확히 파악해야 합니다.
6. 이상치 탐지 — 사분위수로 이상값 찾기
이상치 탐지는 1유형에서 매우 자주 출제되는 유형입니다. 시험에서는 주로 IQR(Interquartile Range) 방식을 사용합니다.
6-1. IQR 방식 원리
┌──────────────────────────────────────────────────────┐
│ │
│ Q1 (1사분위수) = 하위 25% 지점의 값 │
│ Q3 (3사분위수) = 하위 75% 지점의 값 │
│ IQR = Q3 - Q1 │
│ │
│ 하한값 (Lower Bound) = Q1 - 1.5 × IQR │
│ 상한값 (Upper Bound) = Q3 + 1.5 × IQR │
│ │
│ → 하한값 미만이거나 상한값 초과인 데이터 = 이상치 │
│ │
└──────────────────────────────────────────────────────┘6-2. IQR 이상치 탐지 코드
# Q1, Q3 계산
Q1 = df['칼럼명'].quantile(0.25)
Q3 = df['칼럼명'].quantile(0.75)
# IQR 계산
IQR = Q3 - Q1
# 하한값, 상한값 계산
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR
# 이상치 판별
outliers = df[(df['칼럼명'] < lower) | (df['칼럼명'] > upper)]
# 이상치의 수
outlier_count = len(outliers)
print(outlier_count)6-3. 이상치 관련 출제 패턴
┌─────────────────────────────────────────────────────────────────┐
│ 이상치 관련 출제 질문 예시 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Q: "칼럼 A에서 IQR 방식으로 판단한 이상치의 수는?" │
│ │
│ Q: "칼럼 B에서 이상치를 제거한 후 남은 데이터의 수는?" │
│ │
│ Q: "칼럼 C의 상한값(Upper Bound)은?" │
│ │
│ Q: "칼럼 D에서 이상치에 해당하는 값 중 가장 큰 값은?" │
│ │
└─────────────────────────────────────────────────────────────────┘6-4. 이상치 제거 코드
# 이상치가 아닌 데이터만 필터링 (이상치 제거)
df_clean = df[(df['칼럼명'] >= lower) & (df['칼럼명'] <= upper)]
# 제거 후 남은 데이터 수
print(len(df_clean))6-5. IQR 방식 시각화로 이해하기
하한값 Q1 중앙값 Q3 상한값
│ │ │ │ │
────────┼──────────────┼───────┼───────┼──────────────┼────────
│ │ │ │ │
│ ◄─IQR────►│ │ │ │
│ │ │ │ │
이상치 25% 50% 75% 이상치
영역 영역
※ 하한값 = Q1 - 1.5 × IQR
※ 상한값 = Q3 + 1.5 × IQR
※ 하한값 미만 또는 상한값 초과 → 이상치
7. 정규화와 표준화 — 스케일링의 모든 것
정규화(Min-Max Scaling)와 표준화(Z-score Standardization)는 1유형에서 핵심 출제 포인트입니다. 두 개념의 차이를 정확히 이해하고 코드를 자유자재로 작성할 수 있어야 합니다.
7-1. 정규화 vs 표준화 비교표
┌──────────────────┬──────────────────────────┬──────────────────────────┐
│ 구분 │ 정규화 (Min-Max) │ 표준화 (Z-score) │
├──────────────────┼──────────────────────────┼──────────────────────────┤
│ 공식 │ (x - min) / (max - min) │ (x - mean) / std │
├──────────────────┼──────────────────────────┼──────────────────────────┤
│ 결과 범위 │ 0 ~ 1 │ 평균 0, 표준편차 1 │
│ │ │ (실제 범위는 데이터에 │
│ │ │ 따라 다름) │
├──────────────────┼──────────────────────────┼──────────────────────────┤
│ 이상치 영향 │ 이상치에 민감 │ 상대적으로 덜 민감 │
│ │ (min, max가 왜곡됨) │ │
├──────────────────┼──────────────────────────┼──────────────────────────┤
│ 적합한 상황 │ 데이터 범위를 0~1로 │ 정규분포에 가까운 데이터 │
│ │ 통일할 때 │ 이상치가 있을 때 │
├──────────────────┼──────────────────────────┼──────────────────────────┤
│ sklearn 클래스 │ MinMaxScaler │ StandardScaler │
├──────────────────┼──────────────────────────┼──────────────────────────┤
│ 주요 사용 분야 │ 이미지 픽셀 값, 신경망 │ SVM, 회귀분석, PCA │
│ │ 입력 데이터 │ │
└──────────────────┴──────────────────────────┴──────────────────────────┘7-2. Min-Max 정규화 코드
# 방법 1: 직접 계산 (수식 활용)
df['정규화'] = (df['칼럼명'] - df['칼럼명'].min()) / \
(df['칼럼명'].max() - df['칼럼명'].min())
# 방법 2: sklearn MinMaxScaler 사용
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
df['정규화'] = scaler.fit_transform(df[['칼럼명']])7-3. Z-score 표준화 코드
# 방법 1: 직접 계산 (수식 활용)
df['표준화'] = (df['칼럼명'] - df['칼럼명'].mean()) / df['칼럼명'].std()
# 방법 2: sklearn StandardScaler 사용
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df['표준화'] = scaler.fit_transform(df[['칼럼명']])7-4. 시험 출제 패턴
정규화/표준화 관련 문제는 보통 아래와 같은 형태로 출제됩니다.
┌─────────────────────────────────────────────────────────────────┐
│ 정규화/표준화 출제 예시 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Q1: "칼럼 A를 Min-Max 정규화한 결과에서 │
│ 값이 0.5 이상인 데이터의 수는?" │
│ │
│ 풀이 코드: │
│ df['norm'] = (df['A'] - df['A'].min()) / │
│ (df['A'].max() - df['A'].min()) │
│ print(len(df[df['norm'] >= 0.5])) │
│ │
│ ───────────────────────────────────────────────────────────── │
│ │
│ Q2: "칼럼 B를 Z-score 표준화한 결과에서 │
│ 값이 1.5 이상인 데이터의 수는?" │
│ │
│ 풀이 코드: │
│ df['zscore'] = (df['B'] - df['B'].mean()) / df['B'].std() │
│ print(len(df[df['zscore'] >= 1.5])) │
│ │
└─────────────────────────────────────────────────────────────────┘7-5. 주의사항 — std()의 ddof 파라미터
이 부분은 시험장에서 헷갈리기 쉬운 포인트입니다.
┌─────────────────────────────────────────────────────────────────┐
│ std() ddof 차이 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Pandas: df['col'].std() → 기본값 ddof=1 (표본 표준편차) │
│ NumPy: np.std(values) → 기본값 ddof=0 (모집단 표준편차) │
│ │
│ 시험에서는 Pandas를 사용하므로 ddof=1이 기본 │
│ → df['col'].std() 그대로 사용하면 됨 │
│ │
│ ※ sklearn StandardScaler는 ddof=0(모집단) 기준으로 계산 │
│ ※ 시험에서는 직접 계산 시 Pandas std(), sklearn 사용 시 │
│ StandardScaler 중 하나를 선택하면 되며, │
│ 문제에서 명시적으로 지정하는 경우가 많음 │
│ │
└─────────────────────────────────────────────────────────────────┘
8. 데이터 변환 및 필터링 — Pandas 고급 함수
8-1. 필터링 함수
# 특정 조건 필터링
df[df['칼럼명'] > 100]
df[df['칼럼명'] == '특정값']
df[df['칼럼명'] != '특정값']
# 복수 조건 필터링 (AND)
df[(df['A'] > 10) & (df['B'] < 50)]
# 복수 조건 필터링 (OR)
df[(df['A'] > 10) | (df['B'] < 50)]
# 특정 값 목록에 포함되는 행 필터링
df[df['칼럼명'].isin(['값1', '값2', '값3'])]
# 특정 값 목록에 포함되지 않는 행 필터링
df[~df['칼럼명'].isin(['값1', '값2'])]
# 문자열 포함 검색
df[df['칼럼명'].str.contains('키워드')]8-2. 칼럼 선택 및 삭제
# 칼럼 선택
df['칼럼명'] # 단일 칼럼 (Series)
df[['칼럼1', '칼럼2']] # 복수 칼럼 (DataFrame)
# 칼럼 삭제
df.drop(columns=['칼럼명'])
df.drop(['칼럼명'], axis=1)
# 행 삭제 (인덱스 기준)
df.drop(index=[0, 1, 2])8-3. 중복 데이터 처리
# 중복 행 확인
df.duplicated().sum()
# 중복 행 삭제
df.drop_duplicates()
# 특정 칼럼 기준 중복 삭제 (첫 번째 행만 유지)
df.drop_duplicates(subset=['칼럼명'])
# 마지막 행만 유지
df.drop_duplicates(subset=['칼럼명'], keep='last')8-4. 데이터 정렬
# 특정 칼럼 기준 오름차순 정렬
df.sort_values('칼럼명')
# 특정 칼럼 기준 내림차순 정렬
df.sort_values('칼럼명', ascending=False)
# 복수 칼럼 기준 정렬
df.sort_values(['칼럼1', '칼럼2'], ascending=[True, False])
# 인덱스 기준 정렬
df.sort_index()8-5. 데이터 타입 변환
# 숫자형으로 변환
df['칼럼명'] = pd.to_numeric(df['칼럼명'], errors='coerce')
# 날짜형으로 변환
df['칼럼명'] = pd.to_datetime(df['칼럼명'])
# 문자열로 변환
df['칼럼명'] = df['칼럼명'].astype(str)
# 범주형으로 변환
df['칼럼명'] = df['칼럼명'].astype('category')
9. GroupBy 완벽 마스터 — 고빈출 함수
groupby()는 1유형에서 매우 높은 빈도로 출제되는 함수입니다. 시험에서 groupby 문제가 나왔을 때 당황하지 않도록 확실하게 마스터해야 합니다.
9-1. GroupBy 기본 구조
# 기본 구조
df.groupby('그룹칼럼')['대상칼럼'].집계함수()
# 예시: 성별에 따른 평균 나이
df.groupby('성별')['나이'].mean()9-2. 다양한 집계 함수
┌──────────────────────┬──────────────────────────────────────────────┐
│ 집계 함수 │ 설명 │
├──────────────────────┼──────────────────────────────────────────────┤
│ .mean() │ 평균값 │
│ .sum() │ 합계 │
│ .count() │ 개수 (결측치 제외) │
│ .size() │ 크기 (결측치 포함) │
│ .max() │ 최대값 │
│ .min() │ 최소값 │
│ .median() │ 중앙값 │
│ .std() │ 표준편차 │
│ .var() │ 분산 │
│ .first() │ 첫 번째 값 │
│ .last() │ 마지막 값 │
│ .nunique() │ 고유값 수 │
│ .describe() │ 통계 요약 │
└──────────────────────┴──────────────────────────────────────────────┘9-3. GroupBy 실전 코드
# 그룹별 평균
df.groupby('지역')['가격'].mean()
# 그룹별 합계
df.groupby('카테고리')['판매량'].sum()
# 그룹별 개수
df.groupby('등급').size()
# 복수 칼럼 그룹핑
df.groupby(['지역', '카테고리'])['가격'].mean()
# 복수 집계 함수 적용
df.groupby('지역')['가격'].agg(['mean', 'max', 'min'])
# 그룹별 특정 조건 만족 수
df.groupby('성별')['나이'].apply(lambda x: (x > 30).sum())9-4. GroupBy 출제 패턴
┌─────────────────────────────────────────────────────────────────┐
│ GroupBy 출제 질문 예시 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Q1: "지역별 평균 가격이 가장 높은 지역은?" │
│ → df.groupby('지역')['가격'].mean().idxmax() │
│ │
│ Q2: "카테고리별 판매량 합계는?" │
│ → df.groupby('카테고리')['판매량'].sum() │
│ │
│ Q3: "등급별 인원 수는?" │
│ → df.groupby('등급').size() │
│ │
│ Q4: "성별, 지역별 평균 나이는?" │
│ → df.groupby(['성별', '지역'])['나이'].mean() │
│ │
│ Q5: "제품별 최대 가격과 최소 가격의 차이가 │
│ 가장 큰 제품은?" │
│ → diff = df.groupby('제품')['가격'].max() - │
│ df.groupby('제품')['가격'].min() │
│ print(diff.idxmax()) │
│ │
└─────────────────────────────────────────────────────────────────┘9-5. value_counts() — 빈도수 확인
value_counts()는 groupby와 함께 자주 사용되는 함수입니다.
# 특정 칼럼의 범주별 빈도수
df['칼럼명'].value_counts()
# 빈도수 기준 정렬 (내림차순이 기본)
df['칼럼명'].value_counts(ascending=True)
# 비율로 확인
df['칼럼명'].value_counts(normalize=True)
# 특정 값의 빈도수
df['칼럼명'].value_counts()['특정값']
10. 날짜 데이터 처리 — datetime 활용법
날짜 관련 데이터 처리도 1유형에서 간헐적으로 출제됩니다.
10-1. 날짜 변환
# 문자열을 datetime으로 변환
df['날짜'] = pd.to_datetime(df['날짜'])
# 특정 형식 지정
df['날짜'] = pd.to_datetime(df['날짜'], format='%Y-%m-%d')
df['날짜'] = pd.to_datetime(df['날짜'], format='%Y/%m/%d')10-2. 날짜 요소 추출
# 연도 추출
df['연도'] = df['날짜'].dt.year
# 월 추출
df['월'] = df['날짜'].dt.month
# 일 추출
df['일'] = df['날짜'].dt.day
# 요일 추출 (0=월요일, 6=일요일)
df['요일'] = df['날짜'].dt.dayofweek
# 분기 추출
df['분기'] = df['날짜'].dt.quarter10-3. 날짜 필터링
# 특정 날짜 이후 데이터 필터링
df[df['날짜'] >= '2024-01-01']
# 특정 기간 필터링
df[(df['날짜'] >= '2024-01-01') & (df['날짜'] <= '2024-12-31')]
# 특정 연도 데이터만 추출
df[df['날짜'].dt.year == 2024]
# 특정 월 데이터만 추출
df[df['날짜'].dt.month == 6]
11. 실제 기출 문제 패턴 분석
과거 기출문제를 분석하면 출제 패턴이 명확하게 보입니다. 실제 합격자 후기와 기출 분석을 토대로 주요 패턴을 정리했습니다.
11-1. 기출 회차별 1유형 출제 유형 분석
┌────────┬─────────────────────┬─────────────────────┬─────────────────────┐
│ 회차 │ 주요 유형 │ 핵심 함수 │ 난이도 │
├────────┼─────────────────────┼─────────────────────┼─────────────────────┤
│ 7회차 │ null 아닌 행 필터링 │ notnull(), len() │ ★★☆☆☆ │
│ │ 이상치 수 구하기 │ quantile(), IQR │ ★★★☆☆ │
│ │ 표준화 후 조건 필터 │ std(), mean() │ ★★★☆☆ │
│ │ 상관관계 최대 칼럼 │ corr(), idxmax() │ ★★★☆☆ │
├────────┼─────────────────────┼─────────────────────┼─────────────────────┤
│ 8회차 │ 결측치 수 확인 │ isnull().sum() │ ★★☆☆☆ │
│ │ 정규화 후 조건 필터 │ min(), max() │ ★★★☆☆ │
│ │ groupby 평균 │ groupby().mean() │ ★★☆☆☆ │
│ │ 이상치 제거 후 수 │ quantile(), IQR │ ★★★☆☆ │
├────────┼─────────────────────┼─────────────────────┼─────────────────────┤
│ 9회차 │ 데이터 탐색 │ shape, info() │ ★☆☆☆☆ │
│ │ 결측치 대체 후 평균 │ fillna(mean) │ ★★☆☆☆ │
│ │ 표준화 │ StandardScaler │ ★★★☆☆ │
│ │ 상관관계 분석 │ corr() │ ★★★☆☆ │
├────────┼─────────────────────┼─────────────────────┼─────────────────────┤
│ 10회차 │ value_counts │ value_counts() │ ★★☆☆☆ │
│ │ 정규화 후 상위 │ MinMaxScaler │ ★★★☆☆ │
│ │ 이상치 탐지 │ IQR 방식 │ ★★★☆☆ │
│ │ 필터링 후 그룹 평균 │ groupby().mean() │ ★★★☆☆ │
├────────┼─────────────────────┼─────────────────────┼─────────────────────┤
│ 11회차 │ 결측치 확인 및 삭제 │ dropna() │ ★★☆☆☆ │
│ │ 정규화 │ MinMaxScaler │ ★★★☆☆ │
│ │ 이상치 수 │ IQR │ ★★★☆☆ │
│ │ 상관관계 │ corr() │ ★★★☆☆ │
└────────┴─────────────────────┴─────────────────────┴─────────────────────┘11-2. 출제 빈도 분석
출제 빈도가 높은 함수 TOP 10
1위 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ groupby + 집계 함수
2위 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ IQR 이상치 탐지
3위 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 정규화/표준화 (MinMax/Z-score)
4위 ▓▓▓▓▓▓▓▓▓▓▓▓▓ isnull/dropna/fillna (결측치)
5위 ▓▓▓▓▓▓▓▓▓▓▓▓ corr() 상관관계 분석
6위 ▓▓▓▓▓▓▓▓▓▓ 조건 필터링 (boolean indexing)
7위 ▓▓▓▓▓▓▓▓ value_counts() 빈도수
8위 ▓▓▓▓▓▓ sort_values() 정렬
9위 ▓▓▓▓▓ describe() 통계 요약
10위 ▓▓▓▓ shape, info() 데이터 탐색11-3. 상관관계 분석 코드
상관관계 문제도 자주 출제되므로 반드시 익혀두세요.
# 전체 수치형 칼럼 간 상관관계 행렬
corr_matrix = df.corr()
# 특정 칼럼과 다른 칼럼 간 상관관계
corr_with_target = df.corr()['타겟칼럼']
# 상관관계가 가장 높은 칼럼명
corr_with_target.drop('타겟칼럼').idxmax()
# 상관관계가 가장 높은 절대값 기준 칼럼명
corr_with_target.drop('타겟칼럼').abs().idxmax()
# 상관관계 값이 가장 높은 것
corr_with_target.drop('타겟칼럼').abs().max()
12. 데이터마님 활용 학습 전략
실기 준비에 있어 데이터마님 사이트는 가장 중요한 학습 플랫폼입니다. 대부분의 합격자들이 이 사이트를 활용하여 학습했다고 언급할 정도입니다.
12-1. 데이터마님 학습 순서
[1단계] 데이터마님 회원가입
│
▼
[2단계] 전처리 100문제 풀이
│ → Pandas 기본 함수 마스터
│ → 하루 20문제씩 5일 완성
│
▼
[3단계] 작업 1유형 연습문제 풀이
│ → 실제 시험과 유사한 형식
│ → 소문항별 답 출력 연습
│
▼
[4단계] 기출문제 풀이
│ → 7회차~11회차 기출 연습
│ → 시간 재고 실전처럼 풀기
│
▼
[5단계] 오답 복습
│ → 틀린 문제의 관련 함수 재학습
│ → 코드를 손으로 다시 써보기
│
▼
[시험 당일] 확신을 가지고 응시12-2. 학습 단계별 예상 소요 시간
┌──────────┬─────────────────────────────┬──────────────┬──────────────┐
│ 단계 │ 학습 내용 │ 예상 시간 │ 문제 수 │
├──────────┼─────────────────────────────┼──────────────┼──────────────┤
│ 1단계 │ 전처리 100문제 │ 8~10시간 │ 100문제 │
│ 2단계 │ 작업 1유형 연습문제 │ 4~6시간 │ 30~50문제 │
│ 3단계 │ 기출문제 (7~11회차) │ 5~8시간 │ 5회차 │
│ 4단계 │ 오답 복습 │ 3~4시간 │ │
├──────────┼─────────────────────────────┼──────────────┼──────────────┤
│ 합계 │ │ 20~28시간 │ │
└──────────┴─────────────────────────────┴──────────────┴──────────────┘12-3. 데이터마님 학습 시 주의사항
┌─────────────────────────────────────────────────────────────────┐
│ 데이터마님 학습 팁 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ✓ 답을 보기 전에 반드시 스스로 코드를 작성해 보세요 │
│ → 답을 보고 "아 그렇구나" 하고 넘어가면 실전에서 막힙니다 │
│ │
│ ✓ 틀린 문제는 코드를 손으로 다시 써보세요 │
│ → 손으로 쓰는 과정이 암기에 가장 효과적입니다 │
│ │
│ ✓ 비슷한 유형끼리 묶어서 정리하세요 │
│ → 결측치 유형, 이상치 유형, 정규화 유형 등으로 분류 │
│ │
│ ✓ 시간을 재고 푸세요 │
│ → 1유형은 약 40분 안에 풀어야 하므로 │
│ 평소에도 시간 관리 연습이 필요합니다 │
│ │
│ ✓ 모르는 함수는 help()로 확인하세요 │
│ → 시험장에서도 help(pd.DataFrame.groupby) 등으로 │
│ 함수 사용법을 확인할 수 있습니다 │
│ │
└─────────────────────────────────────────────────────────────────┘
13. 시험장에서의 1유형 풀이 전략
13-1. 시간 배분 계획
총 시험 시간: 150분 (2시간 30분)
┌──────────────────────────────────────────────────────┐
│ 1유형: 약 40분 │
│ 2유형: 약 50분 │
│ 3유형: 약 40분 │
│ 검토 : 약 20분 │
└──────────────────────────────────────────────────────┘
※ 1유형에서 40분을 초과하면 2·3유형 시간이 부족해집니다
※ 모르는 문제는 표시해두고 먼저 풀 수 있는 것부터 풀기13-2. 문제 풀이 순서 전략
┌─────────────────────────────────────────────────────────────────┐
│ 1유형 풀이 순서 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STEP 1: 문제 전체를 먼저 훑어보기 (1~2분) │
│ → 어떤 함수가 필요한지 빠르게 파악 │
│ │
│ STEP 2: 쉬운 문제부터 풀기 │
│ → 결측치 수 세기, shape 확인 등 간단한 문제 우선 │
│ │
│ STEP 3: 중간 난이도 문제 풀기 │
│ → groupby, 필터링, value_counts 등 │
│ │
│ STEP 4: 어려운 문제 풀기 │
│ → 이상치 탐지, 상관관계 분석 등 │
│ │
│ STEP 5: 답 출력 확인 │
│ → print()로 결과를 출력했는지 반드시 확인 │
│ → 답이 숫자로 정확히 출력되었는지 점검 │
│ │
└─────────────────────────────────────────────────────────────────┘13-3. 시험장에서 도움이 되는 함수
시험장에서 코드가 기억나지 않을 때 활용할 수 있는 내장 함수입니다. 인터넷이 안 되는 환경에서 유일하게 사용할 수 있는 도움말입니다.
# 함수의 사용법 확인
help(pd.DataFrame.groupby)
help(pd.read_csv)
# 모듈의 속성(함수) 목록 확인
dir(pd)
dir(pd.DataFrame)
# 함수의 문서 문자열 확인
pd.read_csv.__doc__
이 두 함수(help()와 dir())만 알고 있어도 시험장에서 코드가 기억나지 않을 때 큰 도움이 됩니다. 실제로 합격자 중에서도 시험장에서 help()를 활용하여 함수 사용법을 확인한 사례가 있습니다.
13-4. 답안 제출 시 확인 사항
┌─────────────────────────────────────────────────────────────────┐
│ 답안 제출 전 체크리스트 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ □ 각 소문항의 답이 print() 또는 화면에 출력되었는지 확인 │
│ □ 출력된 값이 문제에서 요구하는 형식과 일치하는지 확인 │
│ (정수? 실수? 칼럼명? 행 수?) │
│ □ 최종 .ipynb 파일이 정상 저장되었는지 확인 │
│ □ 불필요한 코드나 오류 메시지가 없는지 확인 │
│ □ 셀 실행 순서가 올바른지 확인 (위에서 아래 순서) │
│ │
└─────────────────────────────────────────────────────────────────┘
14. 자주 하는 실수 TOP 10
실기시험 1유형에서 수험생들이 자주 하는 실수를 정리했습니다. 이 실수들을 미리 알고 있으면 시험장에서의 당황을 줄일 수 있습니다.
┌──────┬──────────────────────────────────┬─────────────────────────────────┐
│ 순위 │ 실수 │ 예방법 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 1 │ 칼럼명 오타 │ df.columns로 정확한 칼럼명 │
│ │ (대소문자, 띄어쓰기 차이) │ 확인 후 복사·붙여넣기 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 2 │ print() 누락 │ 답을 출력하지 않으면 │
│ │ │ 채점 불가 — 반드시 print() │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 3 │ 인덱스 초기화 안 함 │ dropna 후 reset_index(drop=True)│
│ │ (필터링 후 인덱스 꼬임) │ 또는 인덱스 기반 접근 주의 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 4 │ std()의 ddof 차이 혼동 │ Pandas는 ddof=1, NumPy는 ddof=0│
│ │ │ 문제에서 요구하는 방식 확인 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 5 │ groupby 후 reset_index 안 함 │ groupby 결과를 DataFrame으로 │
│ │ │ 사용 시 reset_index() 호출 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 6 │ 정규화 대상 칼럼 실수 │ 수치형 칼럼만 정규화 가능 │
│ │ │ 범주형 칼럼 정규화 시 오류 발생 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 7 │ NaN 비교 시 == 대신 .isna() │ np.nan == np.nan 은 False │
│ │ 사용 안 함 │ → df['col'].isna() 사용 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 8 │ 파일명 오타 │ pd.read_csv('파일명.csv') │
│ │ │ 문제에서 제공된 이름 정확히 │
│ │ │ 복사 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 9 │ 조건 필터링 시 괄호 누락 │ df[(cond1) & (cond2)] │
│ │ │ 각 조건을 ()로 감싸야 함 │
├──────┼──────────────────────────────────┼─────────────────────────────────┤
│ 10 │ 셀 실행 순서 무시 │ 변수 정의 셀을 먼저 실행하지 │
│ │ │ 않고 사용 셀만 실행 → NameError│
└──────┴──────────────────────────────────┴─────────────────────────────────┘14-1. 특히 주의해야 할 함정
┌─────────────────────────────────────────────────────────────────┐
│ ⚠️ NaN 비교 함정 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ # 잘못된 코드 │
│ df[df['col'] == np.nan] ← 이렇게 하면 아무것도 안 나옴! │
│ │
│ # 올바른 코드 │
│ df[df['col'].isna()] ← NaN인 행만 필터링 │
│ df[df['col'].notna()] ← NaN이 아닌 행만 필터링 │
│ │
│ ※ NaN은 자기 자신과도 같지 않습니다 │
│ (IEEE 754 표준에 따라 NaN != NaN) │
│ │
└─────────────────────────────────────────────────────────────────┘┌─────────────────────────────────────────────────────────────────┐
│ ⚠️ 조건 필터링 괄호 함정 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ # 잘못된 코드 │
│ df[df['A'] > 10 & df['B'] < 50] ← 연산자 우선순위 오류 │
│ │
│ # 올바른 코드 │
│ df[(df['A'] > 10) & (df['B'] < 50)] ← 각 조건을 ()로 감싸기 │
│ │
│ ※ & 연산자가 >, < 보다 우선순위가 높기 때문에 │
│ 반드시 각 조건을 괄호로 묶어야 합니다 │
│ │
└─────────────────────────────────────────────────────────────────┘
15. 최종 복습 체크리스트
아래 항목을 하나씩 체크하면서 1유형 준비 상태를 점검하세요.
┌─────────────────────────────────────────────────────────────────┐
│ 1유형 준비 완료 체크리스트 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 기본 함수 │
│ □ pd.read_csv() — CSV 읽기 및 인코딩 처리 │
│ □ df.shape, df.info(), df.describe() — 데이터 탐색 │
│ □ df.head(), df.tail() — 데이터 미리보기 │
│ □ df.columns, df.dtypes — 칼럼 정보 확인 │
│ │
│ 결측치 처리 │
│ □ df.isnull().sum() — 결측치 수 확인 │
│ □ df.dropna() — 결측치 행 삭제 │
│ □ df.dropna(subset=['col']) — 특정 칼럼 기준 삭제 │
│ □ df['col'].fillna(값) — 결측치 대체 │
│ □ df['col'].fillna(df['col'].mean()) — 평균 대체 │
│ □ df['col'].fillna(df['col'].median()) — 중앙값 대체 │
│ │
│ 이상치 탐지 │
│ □ Q1 = df['col'].quantile(0.25) │
│ □ Q3 = df['col'].quantile(0.75) │
│ □ IQR = Q3 - Q1 │
│ □ lower = Q1 - 1.5 * IQR │
│ □ upper = Q3 + 1.5 * IQR │
│ □ 이상치 필터링 및 개수 세기 │
│ │
│ 정규화 / 표준화 │
│ □ Min-Max 정규화 (직접 계산) │
│ □ Min-Max 정규화 (sklearn MinMaxScaler) │
│ □ Z-score 표준화 (직접 계산) │
│ □ Z-score 표준화 (sklearn StandardScaler) │
│ □ 정규화/표준화 결과에서 조건 필터링 │
│ │
│ 필터링 및 변환 │
│ □ boolean indexing 조건 필터링 │
│ □ 복수 조건 (&, |) 필터링 │
│ □ df['col'].isin() — 특정 값 포함 필터링 │
│ □ df.sort_values() — 정렬 │
│ □ df.drop_duplicates() — 중복 제거 │
│ □ pd.to_datetime() — 날짜 변환 │
│ │
│ GroupBy │
│ □ df.groupby('col1')['col2'].mean() — 그룹별 평균 │
│ □ df.groupby('col1')['col2'].sum() — 그룹별 합계 │
│ □ df.groupby('col1').size() — 그룹별 크기 │
│ □ df['col'].value_counts() — 빈도수 확인 │
│ │
│ 상관관계 │
│ □ df.corr() — 상관관계 행렬 │
│ □ df.corr()['col'].abs().idxmax() — 최대 상관 칼럼 │
│ │
│ 시험장 대비 │
│ □ help(), dir() 사용법 숙지 │
│ □ 칼럼명 복사·붙여넣기 습관 │
│ □ print()로 답 출력하는 습관 │
│ □ 시간 배분 연습 (40분 이내) │
│ │
└─────────────────────────────────────────────────────────────────┘
마무리
1유형은 실기시험의 시작이자 기반입니다. 30점이라는 배점은 작아 보이지만, 이 30점을 안정적으로 확보하는 것이 전체 합격의 열쇠입니다.
핵심을 정리하면 다음과 같습니다.
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 1. 1유형은 Pandas 함수 마스터 여부가 점수를 결정한다 │
│ 2. 핵심 함수 15개만 확실히 알면 20점 이상 확보 가능 │
│ 3. groupby, IQR 이상치, 정규화/표준화가 최대 빈출 포인트 │
│ 4. 데이터마님 "전처리 100문제"가 가장 효과적인 학습 자료 │
│ 5. 코드를 손으로 써보는 것이 암기에 가장 효과적 │
│ 6. 시험장에서는 help()와 dir()을 적극 활용 │
│ 7. 시간 배분 — 1유형에 40분 이상 쓰지 말 것 │
│ │
└─────────────────────────────────────────────────────────────────┘
다음 글에서는 실기 2유형 (머신러닝 모델링) — 랜덤포레스트 템플릿을 완벽하게 다루겠습니다. 궁금한 점이 있으시면 댓글로 남겨주세요!
참고 출처
- 큐넷(Q-net) 공식 웹사이트 - 빅데이터분석기사 실기시험 안내: https://www.q-net.or.kr
- 데이터마님 - 빅데이터분석기사 실기 전처리 100문제 및 기출문제: https://www.datamanim.com
- Pandas 공식 문서 - DataFrame 함수 reference: https://pandas.pydata.org/docs/reference/frame.html
- Scikit-learn 공식 문서 - Preprocessing: https://scikit-learn.org/stable/modules/preprocessing.html
- 네이버 블로그 - 빅데이터분석기사 실기 1유형 합격 후기 모음
- YouTube - 빅데이터분석기사 실기 1유형 Pandas 함수 강의 채널
- 이기적 빅데이터분석기사 공식 네이버 카페: https://cafe.naver.com
해시태그
#빅데이터분석기사 #실기1유형 #Pandas전처리 #데이터전처리 #Python자격증 #게시글3번
'자격증 공부 관련 > 그 외 자격증' 카테고리의 다른 글
| 빅데이터분석기사 실기 3유형 + 최종 합격 전략 — 시험 당일 체크리스트 (0) | 2026.08.26 |
|---|---|
| 빅데이터분석기사 실기 2유형 마스터 — 랜덤포레스트 템플릿으로 만점 받기 (0) | 2026.08.26 |
| 빅데이터분석기사 필기 합격 전략 — 비전공자 1개월 공부 플랜 (0) | 2026.08.26 |
| 빅데이터분석기사 완벽 로드맵 — 시험 개요부터 2026년 일정까지 총정리 (0) | 2026.08.26 |
| 정보보안기사 실기(에세이형) 대비 전략 + 기출 해설 — 합격의 최종 관문, 답안 하나로 끝낸다 (0) | 2026.08.25 |