https://bit.ly/3HBkMEs

하지만,
이 데이터를 다루는 방식은 여전히 엑셀, 파워쿼리, BI 툴에 의존하고 있습니다.
수기로 데이터를 병합하고, 수식으로 조건을 필터링하며, 보고서를 작성합니다.

이 방식은 익숙하지만, 점점 커지는 데이터의 양과 복잡성을 감당하기에는 점점 버거워지고 있습니다.

이로 인해 발생하는 문제는 명확합니다.

• 속도 저하: 단순한 필터링, 병합에도 수십 분이 걸립니다.

• 오류 위험 증가: 복잡한 수식이나 매뉴얼 조작에서 실수가 빈번합니다.

• 시간 낭비: 반복 작업에 쏟아야 하는 시간과 체력 소모.

• 분석 여력 감소: 중요한 인사이트 도출에 쏟을 시간이 부족해집니다.

예를 들어, 전국 100여 개 지점에서 매일 신규 가입 데이터를 엑셀 파일로 수집하는 업무가 있다고 가정해보자. 각 파일의 구조는 비슷하지만, 지점마다 열 순서나 날짜 포맷이 조금씩 다르다. 이 데이터를 하나로 모아 매일 보고서를 만드는 작업은 단순해 보이지만, 수작업으로는 매번 복사/붙여넣기와 오류 수정의 반복이다.

파이썬에서는 glob를 사용해 특정 폴더 내의 모든 파일을 자동으로 불러오고, pandas로 열 이름을 통일하고 병합한 뒤, 날짜 기준으로 정렬까지 자동 처리할 수 있다.
매일 1~2시간 걸리던 작업이 단 수십 초 안에 끝나는 것이다.

• 지점별, 등급별, 상품별로 세분화한 통계

• 신규 고객 중 특정 행동 패턴을 보이는 그룹 추출

• 연체 가능성 예측을 위한 특성별 필터링

이러한 작업은 단순한 피벗테이블이나 필터로는 다루기 어렵습니다.
다중 조건, 복합 로직, 반복 자동화가 필수인 시대가 온 것입니다.

• 대량 데이터 처리: numpy 기반 연산으로 수십만 ~ 수백만 건도 빠르게 처리

• 복합 조건 적용: pandas로 여러 조건을 간단한 코드로 적용 가능

• 반복 작업 자동화: 매일/매주 반복되는 데이터 작업을 한 번의 실행으로 완료

• 오류 관리와 유연성: try-except 구조로 예외를 관리하고, 데이터 변화에도 유연하게 대응

파이썬은 처음에는 조금 낯설 수 있지만,
한 번 익히면 금융 데이터 실무에서 '시간을 벌어주는 가장 강력한 무기'가 됩니다.

연체 가능성이 있는 고객을 선별해 리스트를 추출하는 작업은 리스크 관리 업무에서 매우 중요합니다.
그런데 그 선별 조건은 생각보다 단순하지 않습니다. 예를 들어,

• 최근 3개월 내 2회 이상 연체

• 평균 거래금액이 50만 원 이하

• VIP 등급이 아닌 고객

이런 조건들을 엑셀에서 구현하려면, 여러 시트를 참조하거나 피벗테이블, 보조열, 수식 조합이 필요해지고 작업 과정이 길고 실수가 발생하기 쉽습니다.

하지만 파이썬에서는 pandas를 활용해 한 줄 조건 필터링으로 이 모든 조건을 적용할 수 있습니다.
여기에 해당 고객 리스트를 자동 저장하거나 특정 담당자에게 메일을 보내는 프로세스까지 연동하면,
반복 수작업이 아닌 리스크 관리 자동화 흐름을 구축할 수 있습니다.

하지만,
복잡하고 반복적인 대량 데이터 작업을 더 빠르고 정확하게 처리할 수 있는 사람과
그렇지 않은 사람 사이에는
업무 속도, 품질, 분석 깊이에서 점점 더 큰 차이가 벌어지고 있습니다.

파이썬은 금융 데이터 실무자의 업무 경쟁력을 결정하는 핵심 도구가 되어가고 있습니다.

이 데이터들을 엑셀이나 파워쿼리로 처리할 때 다음과 같은 상황을 많이 겪게 됩니다:

• 수작업 병합 중 열 순서가 달라서 오류 발생

• 필터링 조건이 많아질수록 수식이 길어지고 가독성 저하

• 10만 건 이상의 데이터 처리 시 프로그램 다운

이럴 때 파이썬을 사용하면,

• 폴더 내 모든 엑셀을 자동으로 불러와 병합하고,

• 조건 필터링과 요약을 한 줄씩 코드로 실행하고,

• 필요한 리포트를 자동으로 저장하고 메일로 보낼 수 있습니다.

• 지점별로 저장된 5개의 엑셀 파일을 자동으로 불러와 병합하여 하나의 DataFrame으로 만들기

• 거래금액이 50만 원 이상인 고객만 필터링하여 새로운 엑셀 파일로 저장하기

이러한 작업은 모두 몇 줄의 코드로 자동화할 수 있으며, 앞으로 실습을 통해 직접 경험하게 됩니다.

• 간단한 데이터 확인

• 소규모 테이블 분석

• 빠른 보고서 작성 이런 작업은 여전히 엑셀이나 파워쿼리, BI 툴이 더 편리합니다.

핵심은 "상황에 따라 가장 효율적인 도구를 쓰는 것"입니다.
파이썬은 필요할 때 꺼낼 수 있는 강력한 무기이지, 무조건 대체해야 하는 도구가 아닙니다.

※ ChatGPT는 단순한 코드 생성기를 넘어,
데이터 작업 전체 흐름과 판단 구조를 함께 설계하는 AI 도우미입니다.

• 작은 규모(수천 건 이내)

• 단순 조건 필터

• 빠른 가시화 필요

반복되는 전처리, 파일 통합 → Power Query 사용

• 정형화된 파일 포맷

• 매일/매주 업데이트되는 데이터

• 파일 이름/형식이 일정할 때

대시보드 구축 및 시각화 → Power BI 사용

• 지표 모니터링

• 비주얼 중심의 경영 리포트

• 다양한 드릴다운/필터링 옵션 필요

대량 데이터 처리, 복합 조건 필터링, 반복 자동화 → Python (pandas, numpy) 사용

• 10만~100만 건 이상의 데이터

• 다중 조건(AND/OR/복합) 필터링

• 파일 분할 저장, 반복 작업 자동화

• 데이터 구조가 수시로 변경될 가능성

특수한 통계 분석 또는 고급 데이터 과학 → R 사용

• 로지스틱 회귀, 시계열 예측, 머신러닝

• 복잡한 통계 모델링

• 특수 분석 프로젝트

코드 자동 생성 + 데이터 업무 설계 + 의사결정 지원 → ChatGPT 사용

• 반복적인 코드 작성 및 예외 처리 자동화

• 데이터 처리 흐름 설계 및 도구 선택 가이드

• 분석 방향 제안, 조건 비교, 작업 순서 추천 등 실무 판단 보조

이런 생각은 실무에서는 오히려 위험할 수 있습니다.

엑셀, 파워쿼리, BI 툴은 각각 필요한 순간이 있습니다.
파이썬은 그 틈을 메우고, 보다 큰 문제를 해결할 수 있도록 확장하는 도구입니다.

핵심은 "도구는 수단일 뿐"이라는 점을 잊지 않는 것입니다.

필요한 곳에는 빠르게 엑셀을 쓰고,
반복적인 곳에는 파워쿼리를 쓰고,
대시보드는 BI를 쓰고,
대량 데이터 자동화에는 파이썬을 쓰는 것.

이런 유연한 접근이 결국 업무 생산성을 가장 크게 높입니다.

파이썬을 활용해 이 업무를 일부 자동화한 이후에는:

• 전날 데이터 자동 병합

• 요약 통계와 시각화 초안 자동 생성

• PDF 저장 및 메일 전송은 담당자가 확인 후 실행

반복적인 작업은 자동 처리되고, 담당자는 결과 검토와 판단 중심의 업무에 집중할 수 있게 되었다.

엑셀/파워쿼리로는

• 조건 수식 복잡

• 시트 분할 수동

• 메일 전송은 별도 작업

파이썬을 활용하면

• 조건 필터링, 등급별 분할 저장, 메일 전송 초안 생성까지 자동화가 가능하며,

• 담당자는 파일 내용을 확인 후 최종 전송만 진행하면 됩니다.

반복 작업은 자동화하고, 민감한 판단은 사람이 직접 확인하는 구조로 효율을 높일 수 있습니다.

아나콘다에는 다음이 포함되어 있습니다.

• 파이썬 언어 실행 환경

• pandas, numpy 등 분석용 라이브러리

• Jupyter Notebook (엑셀처럼 셀 단위로 실행할 수 있는 환경)

✅ 설치 사이트: https://www.anaconda.com/download

윈도우 사용자라면 Anaconda for Windows (64-bit)를 내려받아 설치하면 됩니다.
설치 후 바탕화면에서 Jupyter Notebook 실행 아이콘을 클릭하면 바로 파이썬 분석 환경이 열립니다.

📌 TIP: 새 파일을 만들 때는 메뉴에서 Notebook을 선택하세요.

import pandas as pd

import os

# 현재 작업 디렉토리 확인
print(os.getcwd())

# Working directory 변경
os.chdir(r"C:\Python\data") 
# os.chdir("C:/Python/data")도 가능

# 확인
print("현재 작업 디렉토리:", os.getcwd())

# 엑셀 파일 목록 확인
print(os.listdir())

# 엑셀 파일 불러오기
df = pd.read_excel('고객가입데이터.xlsx')
print(df.head())

• 파일이 다른 위치에 있다면 파일 경로를 절대 경로 또는 상대 경로로 명확히 지정해야 합니다.

• 실습 파일은 Jupyter Notebook 실행 위치와 같은 폴더에 저장해두는 것을 권장합니다.

예시:

df['고객등급']
df # 엑셀 테이블 전체

이 명령어는 ‘고객등급’ 열만 추출합니다.
엑셀에서 열을 복사하는 것과 비슷하지만, 반복성과 확장성 면에서 훨씬 강력합니다.

파이썬에서는 엑셀 불러오기도 자동화할 수 있고, 병합까지 한 번에 처리할 수 있습니다.

• 엑셀 파일을 불러오고 상위 데이터를 확인한다

• 두 개 이상의 엑셀 파일을 병합한다

• 조건 필터링(거래금액, VIP 등급 제외)을 코드로 처리한다

• 등급별로 자동 저장하는 흐름을 구현한다

엑셀에서는 하나하나 기능을 손으로 조작해야 하지만,
파이썬에서는 라이브러리를 불러오기만 하면
분석, 시각화, 통계, 자동화를 손쉽게 실행할 수 있습니다.

import pandas as pd

df = pd.read_excel('가입데이터.xlsx')

df_filtered = df[(df['연체횟수'] >= 2) & (df['거래금액'] < 500000)]

✅ 엑셀의 VLOOKUP, 필터, 수식 → 단 몇 줄로 대체 가능

② numpy – 대량 숫자 연산의 엔진

import numpy as np

x = np.array([100000, 200000, 300000])

x.mean()

✅ 연산 속도 향상, 벡터 계산에 유리

③ matplotlib + seaborn – 보고용 시각화

import matplotlib.pyplot as plt

import seaborn as sns

 sns.histplot(df['거래금액'])

plt.title('거래금액 분포')

plt.show()

✅ 업무 리포트에 바로 쓸 수 있는 그래프 생성

④ glob – 폴더 내 모든 파일 자동 병합

import glob

import pandas as pd

files = glob.glob('data/*.xlsx')

df = pd.concat([pd.read_excel(f) for f in files])

✅ 매일 생성되는 지점별 엑셀 파일을 자동 병합 가능

# 1. 연체 정보와 거래 정보 불러오기

overdue = pd.read_excel("연체정보.xlsx")

transaction = pd.read_excel("거래정보.xlsx")

# 2. 고객별 연체 횟수 집계

# 👉 '연체상태' 컬럼 기준으로 고객별로 몇 건의 연체가 있는지를 count()로 계산

# 👉 agg()는 groupby 이후 여러 개의 요약값(집계값)을 만들 때 사용하는 집계 함수

overdue_summary = overdue.groupby("고객ID").agg(연체횟수=("연체상태", "count")).reset_index()

# 3. 고객별 누적 거래금액 집계

# 👉 출금(-)과 입금(+)을 모두 고려하기 위해 절대값으로 변환 후 합산

transaction["거래금액"] = transaction["거래금액"].abs()

transaction_summary = transaction.groupby("고객ID").agg(거래금액=("거래금액", "sum")).reset_index()

 

# 4. 연체 요약 + 거래 요약 병합

# 👉 고객ID 기준으로 두 집계 테이블을 병합

# 👉 how="inner"는 SQL의 INNER JOIN과 같음: 양쪽에 모두 존재하는 고객만 남김

#     - 예: 연체는 했지만 거래기록이 없는 고객은 제외됨

df = pd.merge(overdue_summary, transaction_summary, on="고객ID", how="inner")

 

# 💡 참고: 병합 방식 요약

# - how="inner" : 양쪽 다 있는 고객만 (교집합)

# - how="left"   : 왼쪽(df1) 기준으로 모두 유지, 오른쪽(df2)은 없으면 NaN

# - how="outer"  : 모든 고객 다 포함 (합집합), 없는 값은 NaN

# - how="right"  : 오른쪽(df2) 기준으로 모두 유지

 

# 5. 조건 필터링: 연체 2회 이상 & 누적 거래금액 50만 원 초과

df_filtered = df[(df['연체횟수'] >= 2) & (df['거래금액'] > 500000)]

 

# 6. 결과 상위 5개 출력

print("✅ 조건을 만족하는 고객 상위 5명:")

print(df_filtered.head())

예제 코드:

import pandas as pd

df = pd.read_excel('고객가입데이터.xlsx')

df.head()

⚠️ 고객가입데이터.xlsx는 Jupyter Notebook 실행 위치의 폴더에 있어야 합니다.

• 거래금액 100만 원 이상 고객만 별도 저장

• 연체 이력이 있는 고객만 따로 정리

• 지점별, 담당자별로 고객 데이터를 분할 저장

엑셀이나 파워쿼리로는 이 작업을 하려면:

• 필터 후 복사 → 새 시트 붙여넣기 → 저장 반복

• 파워쿼리로 시도해도 분할 저장은 번거로운 루틴

👉 파이썬에서는 조건별로 자동 분할 저장이 가능합니다.

    filename = f'{등급}_고객리스트.xlsx'

    group.to_excel(filename, index=False)

이 코드는 고객등급별로 데이터를 나눠 각각 다른 파일로 저장합니다.

filtered = df[df['연체횟수'] >= 1]

for 등급, group in filtered.groupby('고객등급'):

    filename = f'연체고객_{등급}.xlsx'

group.to_excel(filename, index=False)

• groupby()로 원하는 기준으로 나누고

• to_excel()로 자동 저장하는 구조입니다.

이 방식은 반복성과 유연성 측면에서 엑셀보다 월등히 유리합니다.

• groupby를 활용해 데이터를 조건별로 나누어 저장한다

• 필터링 조건을 적용한 뒤 그룹별로 저장하는 구조를 구현한다

• 파일명을 고객 속성(지점명, 등급 등) 기반으로 동적으로 생성해 저장한다

• 여러 시트로 나누어 파일 1개에 조건별 데이터를 저장한다

• 저장 경로를 설정하고, 분할 저장 파일을 정리/압축한다

파이썬으로는 이렇게 작성할 수 있습니다:

vip = df[(df['고객등급'] == 'VIP') & (df['거래기간'] >= 365)]
vip.to_excel('vip_1년이상.xlsx', index=False)

단 한 줄로 보고서 작성이 끝납니다.

• 고객 데이터를 ‘고객등급’ 기준으로 나누어 등급별 .xlsx 파일로 각각 저장해보세요.
  (예: A.xlsx, B.xlsx, VIP.xlsx)

•  ‘지점명’ 기준으로 데이터를 나누어, 각 지점명을 포함한 파일로 저장해보세요.
  (예: 강남지점.xlsx, 분당지점.xlsx 등)

2. 조건 필터 + 그룹 저장

• 거래금액이 100만 원 이상이고, 연체횟수가 1회 이상인 고객만 필터링한 후
  고객등급별로 나누어 저장해보세요.

• VIP 고객 중 연체 이력이 없는 고객만 추출한 후,
  지점명 기준으로 나누어 저장해보세요.

3. 파일명 동적 구성 + 저장

• 각 파일을 지점명_고객등급.xlsx 형식으로 저장해보세요.

• 저장하는 파일명에 오늘 날짜를 포함시켜 지점명_YYYYMMDD.xlsx 형식으로 저장해보세요.
  (예: 대전지점_20240525.xlsx)

4. 시트 분리 저장 (파일 1개에 여러 조건 저장)

• 고객 데이터를 등급별로 나누어 하나의 엑셀 파일에 시트로 저장해보세요.
  (ExcelWriter 활용)

• 지점별로 나누어 각각 파일을 만들고, 그 안에 고객등급별 시트를 구성해 저장해보세요.
  (파일 → 지점별, 시트 → 등급별)

5. 파일 저장 경로 설정 및 정리

• 저장 폴더 경로를 reports/2025/05 형식으로 지정하여 파일을 저장해보세요.

• 조건별로 분할 저장한 파일들을 모두 하나의 폴더에 저장하고,
  작업 완료 후 zip 파일로 압축해보세요. (선택 과제)

• 금융사 고객관리팀은 “VIP 중 연체 이력 없는 고객을 매주 등급별, 지점별로 나눠 리포트”로 저장합니다.

• 지점 매출 분석팀은 “매일 지점별 매출 데이터를 자동 저장하고, 날짜별 폴더에 정리한 뒤 압축 후 업로드”합니다.

• CRM 운영팀은 고객 등급별 대상자 파일을 분리해 캠페인 대상 목록으로 활용합니다.

하지만 엑셀에서는 피벗테이블 만들고, 차트 수정하고, 저장하고…
매번 반복하기엔 너무 번거롭고 자동화하기 어렵습니다.

👉 파이썬에서는 단 몇 줄의 코드로 요약과 시각화까지 자동화가 가능합니다.

# 지점별 평균 거래금액

branch_summary = df.groupby('지점명')['거래금액'].mean()

• 수치형 컬럼 전체 요약 → .describe()

• 특정 기준별 요약 → .groupby() + 집계함수

import matplotlib.pyplot as plt

monthly = df.groupby('가입월')['고객ID'].count().reset_index()

sns.barplot(x='가입월', y='고객ID', data=monthly)

plt.title('월별 신규 고객 수')

plt.show()

• seaborn으로 막대그래프, 선그래프, 박스플롯 등 다양한 시각화 가능

• matplotlib과 함께 사용하면 제목, 저장, 폰트 등 커스터마이징 용이

• 수치형 데이터를 .describe()와 직접 요약 방식으로 통계 분석한다

• groupby()를 활용하여 지점별/등급별 집계를 수행한다

• 연체율 등 파생 지표를 계산하고 새 DataFrame으로 정리한다

• 월별 신규 고객, 연체율 추이를 시각화한다

• 등급/지점별 거래금액 분포를 시각화하고 커스터마이징한다

• 요약 통계 + 그래프를 .xlsx, .png 등으로 저장한다

• 보고서에 활용될 수 있도록 한 엑셀 파일에 통계와 그래프 시트를 분리 저장한다

파이썬에서는 조건 필터 + groupby + 시각화 → 자동 저장까지 한 번에 처리할 수 있습니다.

• .describe()를 사용해 수치형 컬럼의 요약 통계값(평균, 표준편차, 사분위수 등)을 확인해보세요.

• 거래금액, 연체횟수, 거래건수 등의 컬럼을 선택적으로 요약하고,
  통계 결과를 엑셀 파일로 저장해보세요.

2. 기준별 집계

• groupby()를 활용해 지점별 평균 거래금액과 평균 연체횟수를 계산해보세요.

• 고객등급, 지점명, 담당자 기준으로 다중 groupby를 적용해
  거래금액 합계, 고객 수, 연체율 등을 요약해보세요.

3. 특정 지표 계산 (파생 통계)

• 고객등급별 연체율 = 연체고객 수 / 전체 고객 수를 계산해보세요.

• 등급별 연체율을 새로운 DataFrame으로 정리한 뒤,
  높은 순으로 정렬하고 요약 리포트로 저장해보세요.

4. 추이 분석용 시각화

• 월별 신규 고객 수 추이를 seaborn.barplot() 또는 lineplot()으로 시각화해보세요.

• 연체율의 월별 변화를 선형 그래프로 시각화하고,
  최고/최저 구간에 색상 강조나 주석을 추가해보세요.

5. 등급/지점별 비교 시각화

• 등급별 거래금액 분포를 박스플롯으로 그려보세요.

• 지점별 평균 거래금액을 막대그래프로 시각화하고,
  matplotlib으로 제목, 축, 저장 설정을 커스터마이징해보세요.

6. 결과 저장 및 보고서 활용

• 요약된 통계 결과나 그래프를 .png 이미지 또는 .xlsx로 저장해보세요.

• 한 엑셀 파일에 요약 테이블 + 통계 그래프 시트를 함께 구성해 저장해보세요.
  (예: summary.xlsx 파일에 '통계', '그래프' 시트 분리 저장)

• 지점별 실적 리포트 자동화: 평균 거래금액, 연체율, 신규 고객 수를 요약 → 매달 반복 저장

• 등급별 마케팅 대상 추출: 연체율이 높은 고객 등급 우선 검토 및 캠페인 제외 설정

• 시각화 기반 경영회의 자료: 연체율 추이, 고액 거래자 분포 등을 그래프로 제시

data_analytics@naver.com

https://blog.naver.com/data_analytics

주요 경력

• 제일제당(現 CJ) ㈜

• SK Telecom㈜

• SK Communications㈜

• 현대캐피탈㈜

• 베어풋 컴퍼니 주식회사

학력

• 서울대학교 경영학과 학사

• KAIST 대학원 경영과학과 석사 (마케팅 Modeling 전공)

강의 경력 (2008년~ )

• 추계예대, 경희대, 경북대, 경상대, 연세대 , 동국대, 부산대, 한양대, 고려대 등 대학 강의

• 한국 표준 협회(KSA), 생산성본부, aT농수산식품유통교육원, 중부기술교육원, 흑자경영연구소 등 공개 강의

• 삼성전자, KT, SK, CJ대한통운, 이마트, 골프존, KIA, NH, 후성그룹, 수산그룹, 롯데정보통신, 산업은행, 유한양행, MG새마을금고, 동원, 신세계, 롯데마트, 삼성SDS, 일진전기, 우리은행, 현대증권, 롯데삼강, 제주JDC, 서브원 등 기업체 사내 강의

• 여행업 협회 회원 대상 강의, 청년 취업 아카데미 강의, 산업방송 강의, BIO21센터 강의, 대구경북과학기술원(DGIST) 강의, 충남 테크노파크, 대전 테크노파크, 제주 테크노파크 강의, 제주 바이오센터 강의, 제주하이테크산업진흥원 강의, 대구 상공회의소 강의, 능력개발교육원 교강사 대상 강의, 한국관광공사 강의

강의 분야

• 마케팅전략, 신시장/신제품 개발전략

• 마케팅통계분석, 수요예측 데이터 분석, 고객데이터 분석, 구매 데이터 분석, SCM 물류 효율화, 합리적 기획을 위한 데이터 분석, R활용 데이터 분석 실무

저서

• 판단의 기술(2025)

💡 왜 f-string으로 파일명을 저장할까?
→ 자동화된 파일명을 만들기 위해 조건 값을 동적으로 삽입할 수 있습니다.

💡 조건이 2개 이상일 때는 & 와 () 괄호로 논리를 명확히 구분해야 오류를 방지할 수 있습니다.

# 고객 정보 상위 5개 출력
print("✅ 고객 정보 상위 5개:")
print(customer.head())

# 📁 Step 2: 가입정보 + 상품정보 병합 (상품명 붙이기)
subscription = pd.read_excel("subscription.xlsx")
product = pd.read_excel("product.xlsx")

# 상품코드를 기준으로 병합
subscription_merged = pd.merge(subscription, product, on='product_code', how='left')
print("\n✅ 가입정보 + 상품명 병합 결과 상위 5개:")
print(subscription_merged.head())

# 📁 Step 3: 거래 데이터 불러오기 (파일명 변경 반영)
transaction = pd.read_excel("transaction.xlsx")

# 📊 Step 4: 누적 거래금액 계산
trans_summary = transaction.groupby('cust_id', as_index=False)['amount'].sum()
trans_summary.rename(columns={'amount': '누적거래금액'}, inplace=True)

# 📎 Step 5: 고객 정보와 병합
customer_full = pd.merge(customer, trans_summary, on='cust_id', how='left')
customer_full['누적거래금액'] = customer_full['누적거래금액'].fillna(0)

# 💡 Step 6: 실습용 고객 등급 생성 (상위 20% = VIP, 다음 30% = GOLD, 나머지 = NORMAL)
customer_full = customer_full.sort_values('누적거래금액', ascending=False).reset_index(drop=True)
total = len(customer_full)
vip_cut = int(total * 0.2)
gold_cut = int(total * 0.5)

def assign_grade(idx):
    if idx < vip_cut:
        return "VIP"
    elif idx < gold_cut:
        return "GOLD"
    else:
        return "NORMAL"
customer_full['grade'] = customer_full.index.map(assign_grade)

# ✅ 등급 분포 확인
print("\n🎯 고객 등급 분포:")
print(customer_full['grade'].value_counts())

# 🧪 Step 7: 조건 필터링 – 누적거래금액 50만 이상 & VIP 제외

# 💡 조건이 2개 이상일 때는 & 와 괄호로 논리를 명확히 구분해야 오류를 방지할 수 있습니다
filtered = customer_full[
    (customer_full['누적거래금액'] >= 500000) & (customer_full['grade'] != 'VIP')
]

# 🗂️ Step 8: 등급별 파일로 나누어 저장
# 💡 groupby를 사용하는 이유: 등급별로 데이터를 나누는 가장 직관적이면서 반복이 쉬운 방법이기 때문입니다
# 💡 f-string으로 파일명을 저장하는 이유: 자동화된 파일명을 만들기 위해 조건 값을 동적으로 삽입할 수 있습니다
for grade, group in filtered.groupby('grade'):
    filename = f"고객리스트_{grade}.xlsx"
    group.to_excel(filename, index=False)
    print(f"📁 저장 완료: {filename}")

# ✅ Step 9: 최종 결과 미리보기
print("\n🔍 추출된 고객 데이터 예시:")
print(filtered[['cust_id', 'name', 'grade', '누적거래금액']].head())

# 📂 저장된 GOLD, NORMAL 등급 파일 열기
gold_df = pd.read_excel("고객리스트_GOLD.xlsx")
normal_df = pd.read_excel("고객리스트_NORMAL.xlsx")

# 🔍 GOLD 등급 고객 상위 5개
print("\n🟨 GOLD 등급 고객 상위 5개:")
print(gold_df[['cust_id', 'name', 'grade', '누적거래금액']].head())

# 🔍 NORMAL 등급 고객 상위 5개
print("\n🟩 NORMAL 등급 고객 상위 5개:")
print(normal_df[['cust_id', 'name', 'grade', '누적거래금액']].head())

• 왼쪽 테이블의 행은 무조건 포함

• 오른쪽 테이블은 조건(on)이 일치할 때만 붙음

how='right' ⇒ 오른쪽 테이블을 기준으로 정보 보존

• 오른쪽 테이블의 행은 무조건 포함

• 왼쪽 테이블은 조건(on)이 일치할 때만 붙음

how='inner' ⇒  교집합 (공통 키가 있을 때만 병합)

• 양쪽 모두에 존재하는 키만 포함

how='outer' ⇒ 일치하지 않으면 NaN으로 채움 (합집합)

• 양쪽 테이블의 키 전체를 포함

# 예제 데이터: 고객 마스터 테이블 (왼쪽)

df_left = pd.DataFrame({

    '고객ID': [1, 2, 3],

    '이름': ['김철수', '이영희', '박민수']

})

# 예제 데이터: 거래 요약 테이블 (오른쪽)

df_right = pd.DataFrame({

    '고객ID': [2, 3, 4],

    '거래금액': [100000, 250000, 300000]

})

# LEFT JOIN: 왼쪽(df_left)을 기준으로 병합

left_join = pd.merge(df_left, df_right, on='고객ID', how='left')

print("📌 [LEFT] 왼쪽 기준 병합 결과:")

print(left_join)

print("-" * 40)

# RIGHT JOIN: 오른쪽(df_right)을 기준으로 병합
right_join = pd.merge(df_left, df_right, on='고객ID', how='right')
print("📌 [RIGHT] 오른쪽 기준 병합 결과:")
print(right_join)
print("-" * 40)

# INNER JOIN: 양쪽 모두 있는 고객만 남김
inner_join = pd.merge(df_left, df_right, on='고객ID', how='inner')
print("📌 [INNER] 교집합 병합 결과:")
print(inner_join)
print("-" * 40)

# OUTER JOIN: 모든 고객 포함 (합집합)
outer_join = pd.merge(df_left, df_right, on='고객ID', how='outer')
print("📌 [OUTER] 합집합 병합 결과:")
print(outer_join)

# 1. 파일 경로 설정

sales_file = "지점별_상품별_일별매출.csv"

rate_file = "환율.csv"

# 2. 데이터 불러오기

sales_df = pd.read_csv(sales_file, encoding="cp949")

rate_df = pd.read_csv(rate_file, encoding="utf-8")

# 3. 환율값만 추출 (첫 행 사용, 'no' 컬럼 제거)

rate_values = rate_df.drop(columns=["no"]).iloc[0].astype(float)

# 4. 국가별 환산매출 열 생성 (벡터 연산으로 한 번에)

환산매출_df = pd.DataFrame()
for col in rate_values.index:
    환산매출_df[f"국가{col}_환산매출"] = (sales_df["원화금액"] * rate_values[col]).round(2)

# 5. 원본 데이터와 합치기
result = pd.concat([sales_df, 환산매출_df], axis=1) 

# 6. 결과 저장
result.to_excel("국가별_환산매출_결과.xlsx", index=False)

# 7. 상위 5행 확인 (옵션)
print(result.head())

• 엑셀: 수식이 복잡하거나 다중 열에 퍼지면 계산 시간 급증, 셀 변경 시 전체 재계산 발생

• numpy: 배열 전체 연산은 1~2초 안에 완료

2. 수식이 복잡할 때 (IF, INDEX, VLOOKUP 등)

• 엑셀: 복잡한 수식이 많을수록 처리 지연, 중간 셀 수정 시 재계산 부담

• numpy: 벡터 조건식이나 np.where()는 훨씬 빠름

3. 대용량 저장/불러오기 반복

• 엑셀은 파일 크기가 10MB만 넘어도 느려지며, 읽기/쓰기 성능도 한계가 있음

• pandas + numpy는 .csv, .parquet, .npy 등 빠른 포맷을 통해 효율적 처리 가능

4. 정규화, 지수변환, 회귀선 계산 등 과학적 연산

• 엑셀: 고급 수학/통계 수식은 구현이 번거롭고 느림

• numpy: 내장 함수로 빠르고 정확하게 가능

💬 정리 포인트

“단일 열 연산은 엑셀도 충분히 빠릅니다.
하지만 열이 많아지고 수식이 복잡해질수록 numpy의 속도와 안정성이 두드러집니다.”

import matplotlib.pyplot as plt

import math 

# 한글 폰트 설정

plt.rcParams['font.family'] = 'Malgun Gothic'

plt.rcParams['axes.unicode_minus'] = False 

# 데이터 로드

df = pd.read_csv('지점별_상품별_일별매출.csv', encoding='cp949')

df.columns = df.columns.str.strip()

# 상품 리스트

products = df['상품'].unique()

n = len(products)

# 서브플롯 행, 열 자동 결정

cols = 10

rows = math.ceil(n / cols)
# 화면 사이즈 조정

fig, axs = plt.subplots(rows, cols, figsize=(4*cols, 3*rows))
axs = axs.flatten()

# 히스토그램 Binning 기준 (예: 0~5만원 단위)
bins = range(0, int(df['원화금액'].max()) + 50000, 50000)

# 상품별 히스토그램 그리기
for i, product in enumerate(products):
    sub = df[df['상품'] == product]

    axs[i].hist(sub['원화금액'], bins=bins, edgecolor='black', color='skyblue')

    axs[i].set_title(product, fontsize=9)

    axs[i].set_xticks([])

    axs[i].set_yticks([])

# 남은 빈 서브플롯 숨기기
for j in range(i+1, len(axs)):

    axs[j].axis('off')

plt.tight_layout()

plt.suptitle('상품별 일별 매출액 분포 (히스토그램)', fontsize=16, y=1.02)

plt.show()

import glob

import os

# 원본 폴더와 저장 폴더 경로 설정

source_folder = './지점실적데이터'

target_folder = './지점실적데이터1'

# 저장 폴더가 없으면 새로 생성

os.makedirs(target_folder, exist_ok=True)

# 엑셀 파일 목록 가져오기

excel_files = glob.glob(os.path.join(source_folder, '*.xlsx'))

# 변환 및 저장

for file in excel_files:

    df = pd.read_excel(file)
# 파일 이름만 추출하고, csv 확장자로 지정
    base_name = os.path.splitext(os.path.basename(file))[0]
    csv_path = os.path.join(target_folder, base_name + '.csv')

    # CSV 저장 (한글 깨짐 방지용 encoding 설정)
    df.to_csv(csv_path, index=False, encoding='utf-8-sig')
    print(f'✅ 저장 완료: {csv_path}')

import glob

import os

# 원본 폴더와 저장 폴더 경로 설정

source_folder = './지점실적데이터'

target_folder = './지점실적데이터1'

# 저장 폴더가 없으면 새로 생성

os.makedirs(target_folder, exist_ok=True)

# 엑셀 파일 목록 가져오기

excel_files = glob.glob(os.path.join(source_folder, '*.xlsx'))

# 변환 및 저장

for file in excel_files:

    df = pd.read_excel(file)

    # 파일 이름만 추출하고, csv 확장자로 지정

    base_name = os.path.splitext(os.path.basename(file))[0]

    csv_path = os.path.join(target_folder, base_name + '.csv')
    # CSV 저장 (한글 깨짐 방지용 encoding 설정)

    df.to_csv(csv_path, index=False, encoding='utf-8-sig')

    print(f'✅ 저장 완료: {csv_path}')

import glob

import os

# 원본 폴더 경로

folder_path = './지점실적데이터'

# 모든 엑셀 파일 경로 가져오기

excel_files = glob.glob(os.path.join(folder_path, '*.xlsx'))

for file in excel_files:

    df = pd.read_excel(file)

    # '지점명' 컬럼이 있으면 제거

    if '지점명' in df.columns:

        df = df.drop(columns=['지점명'])

        # 원래 파일에 덮어쓰기

        df.to_excel(file, index=False)

        print(f'✅ 지점명 컬럼 제거 완료: {file}')

    else:

        print(f'ℹ️ 이미 지점명 컬럼 없음: {file}')

오히려 중요한 건
“이런 작업이 가능하다”는 걸 알고,
필요할 때 찾아서 쓰는 습관을 들이는 것입니다.

파이썬에서는 seaborn으로 단 2줄의 코드로 히스토그램, 박스플롯 등을 그릴 수 있습니다.

• pandas로 고객 데이터를 필터링하고, 집계한 값을 저장한다

• os, glob을 활용해 파일 경로를 자동으로 탐색하고 처리한다

• datetime을 이용해 최근 가입자를 추출한다

• matplotlib, seaborn으로 가입자 분포 및 추이 시각화를 수행한다

• numpy로 평균·표준편차를 계산하고 이상치를 제거해본다

• openpyxl로 엑셀 시트와 셀을 직접 조작해본다

• re를 사용해 텍스트 패턴을 탐지하거나 수정한다

1. pandas

• 고객 데이터 엑셀 파일을 불러오고, ‘등급’이 ‘VIP’인 고객만 추출해보세요.

• 등급별 평균 거래금액을 계산하고, 그 결과를 새로운 엑셀 파일로 저장해보세요.

2. os

• 현재 작업 디렉토리 경로를 확인하고, 폴더 안의 파일 목록을 출력해보세요.

• 지정 폴더에서 ‘2025’라는 이름이 포함된 엑셀 파일만 분류해 다른 폴더로 복사해보세요.

3. glob

• 특정 폴더 내의 모든 .xlsx 파일 경로를 불러와 리스트로 출력해보세요.

• 여러 개의 엑셀 파일을 불러와 하나의 DataFrame으로 병합한 뒤, VIP 고객을 제외하고 저장해보세요.

4. datetime

• 가입일자를 날짜형으로 변환하고, 오늘 날짜와 비교해보세요.

• 가입일 기준으로 최근 3개월 이내 고객만 추출해 파일로 저장해보세요.

5. matplotlib

• 일별 가입자 수를 선형 그래프로 시각화해보세요.

• 가입자 수와 평균 거래금액을 이중축 그래프로 시각화하고, 이미지로 저장해보세요.

6. seaborn

• 거래금액 분포를 히스토그램과 박스플롯으로 시각화해보세요.

• 고객 등급별 거래금액 분포를 바이올린 플롯으로 시각화하고, 상관관계를 heatmap으로 표현해보세요.

7. numpy

• 거래금액 리스트에서 평균과 표준편차를 구해보세요.

• 이상치(평균 ± 2표준편차 초과)를 제거하고 거래금액을 0~1 범위로 정규화해보세요.

8. openpyxl

• 새로운 엑셀 파일을 만들고, 특정 셀에 텍스트를 입력한 후 저장해보세요.

• 고객 등급별로 시트를 나눠 데이터를 기록하고, 서식을 적용해 저장해보세요.

9. re

• 고객 ID 중 'C-'로 시작하는 코드만 추출해보세요.

• 고객 데이터에서 휴대전화 번호 형식이 잘못된 항목을 정규표현식으로 찾아 수정해보세요.

• pandas + glob 조합은 “매일 폴더에 쌓이는 파일 자동 통합”에 활용됩니다.

• datetime은 "3개월 이내 고객 추출"처럼 특정 기간 조건 필터링 업무에 자주 쓰입니다.

• seaborn은 “거래금액 이상치 시각화”, “등급별 분포 비교” 등을 보고서에 넣을 때 유용합니다.

• openpyxl은 “자동 리포트 작성 후 시트 서식까지 자동 반영”하는 데 유용합니다.

df.columns      # 열 이름 확인

df.info()       # 데이터 구조와 결측치 확인

df.describe()   # 숫자형 요약 통계

✅ 실무에서는 데이터가 정제되지 않은 상태로 오는 경우가 많기 때문에 이 기본 점검이 매우 중요합니다.

df = df.drop(columns=['열1', '열2'])  # 열 제거

df.columns = df.columns.str.strip()            # 열 이름 공백 제거

df = df.rename(columns={'이름 ': '이름'})        # 열 이름 수정

💡 열 이름에 공백이나 특수문자가 있으면 오류가 자주 발생하므로
반드시 미리 정리해주는 습관을 들이는 것이 좋습니다.

• &는 AND 조건, |는 OR 조건

• 괄호로 각 조건을 감싸야 오류가 없습니다

예: 연체 2회 이상 & 거래금액 50만 원 이하

✅ 엑셀의 필터 기능보다 빠르고 유연합니다. 특히 다중 조건이 많을수록 파이썬의 장점이 두드러집니다.

df = df.dropna()          # 결측치 행 제거

df = df.fillna(0)         # 결측치 0으로 채우기

📌 실무에서는 일부 열만 결측치 제거하거나 특정 열만 채우는 방식이 일반적입니다.

# 1. 데이터 불러오기

df = pd.read_excel('가입데이터.xlsx')

# 2. 구조 점검

df.info()

# 3. 열 이름 정리

df.columns = df.columns.str.strip()

# 4. 필요 없는 열 제거

df = df.drop(columns=['열1', '열2'])

# 5. 조건 필터링

df_filtered = df[df['거래금액'] > 1000000]

# 6. 결측치 처리

df_filtered = df_filtered.dropna()

📌 이 흐름은 모든 분석 자동화의 기본 골격이 됩니다.

• 엑셀 파일을 불러와 구조(df.columns, df.info)를 점검한다

• 열 이름을 정리하고, 필요한 열만 추려 DataFrame을 구성한다

• 결측값과 이상치를 처리한다 (0 대체, 평균±2표준편차 이상 제거 등)

• 중복 및 오류 데이터를 찾아 제거하거나 수정한다

• 복합 논리 조건 필터링을 수행하고 결과를 저장한다

• 새로운 파생 열을 만들어 고객 특성을 분류한다

• 등급별로 파일을 나눠 저장하는 자동화를 구현한다

파이썬에서는 논리 조건을 조합해 한 줄로 조건을 설정할 수 있고, 필터링 결과를 바로 저장할 수 있습니다.

• 고객가입데이터.xlsx 파일을 불러오고, 상위 5개 행을 출력해보세요.

• 열 이름 목록과 데이터 형식을 확인해보세요 (df.columns, df.info() 활용).

2. 열 이름 및 열 구성 정리

• 열 이름의 공백을 제거하고, 모두 소문자로 통일해보세요.

• 분석에 필요한 열만 추려서 새로운 DataFrame으로 구성해보세요.

• ‘고객등급’ 같은 열 이름을 {"고객등급": "grade"}와 같은 매핑으로 바꿔보세요.

3. 결측값 및 이상치 처리

• 결측값이 포함된 행의 수를 확인해보고, 제거해보세요.

• 거래금액이 없는 경우 0으로 채우고, 고객등급이 비어있는 경우 ‘일반’으로 바꿔보세요.

• 거래금액에서 평균 ± 2표준편차를 벗어난 값을 이상치로 간주하고 제거해보세요.

4. 중복 및 오류 데이터 제거

• 전체 행 중 중복 데이터를 제거해보세요.

• 고객 ID + 가입일 기준으로 중복된 경우만 제거해보세요.

• vmfha‘C-’로 시작하지 않는 고객 ID는 오류 데이터일 수 있습니다. 해당 항목을 확인한 후, 수정하거나 제거해보세요.
  

5. 조건 필터링

• 거래금액이 50만 원 미만이고 연체횟수가 2회 이상이며 VIP가 아닌 고객을 추출해보세요.

• 가입일 기준으로 최근 3개월 이내 고객만 따로 필터링해보세요.

• 등급이 ‘A’ 또는 ‘B’인 고객만 추출해 파일로 저장해보세요.

6. 정렬 및 파생 열 생성

• 거래금액을 기준으로 내림차순 정렬해보세요.

• 등급(‘A’ → ‘B’ → ‘C’) 우선 + 거래금액 내림차순으로 정렬해보세요.

• 거래금액을 기준으로 ‘고액 고객’(100만 원 이상), ‘일반 고객’ 구분 열을 새로 만들어보세요.

• 가입일로부터 경과된 개월 수를 계산하는 ‘가입연차’ 열을 만들어보세요.

7. 저장

• 정제한 결과를 새로운 엑셀 파일로 저장해보세요.

• 고객 등급별로 파일을 나눠 저장해보세요 (예: grade_A.xlsx, grade_B.xlsx 등).

• 카드사 고객관리팀에서는 “VIP가 아닌 연체 고객 중 거래금액이 낮은 대상”만 분류하여 캠페인 제외 대상을 추출합니다.

• 증권사 리서치팀은 “최근 3개월 내 가입한 고액 거래자”만 따로 분석 대상으로 삼기 위해 필터링 자동화를 적용합니다.

• 고객분석 보고서 자동화 팀은 정제된 데이터를 등급별 리포트로 분할 저장하여 일일 보고에 사용합니다.

“엑셀로 된 고객 리스트에서 연체 2회 이상인 고객만 뽑아서 등급별로 엑셀 파일을 나눠 저장하는 파이썬 코드를 짜줘.”

ChatGPT는 파이썬 코드 전체를 생성해줍니다. 여기서 중요한 건:

• 프롬프트(명령문)를 명확히 전달하는 것

• 생성된 코드를 이해하고, 수정·확장할 수 있는 감각을 기르는 것

df = pd.read_excel('고객리스트.xlsx')

filtered = df[df['연체횟수'] >= 2]

for 등급, group in filtered.groupby('고객등급'):

    filename = f'{등급}_연체고객.xlsx'

    group.to_excel(filename, index=False)

• 이 코드는 ChatGPT가 한 번에 생성해줄 수 있습니다.

→ ChatGPT는 날짜 필터를 추가한 코드로 자동 수정해줍니다.

→ try/except 구문을 넣어서 안정적인 실행 코드를 생성해줍니다.

• 실무 상황을 자연어로 설명하고 GPT에게 코드를 생성해보자

• 조건 변경 요청에 따라 코드가 어떻게 바뀌는지 확인해보자

• 파일명, 저장 방식 변경 등 자동화 요청을 다양하게 해보자

• 예외처리를 요청하고, GPT가 작성한 코드를 이해해보자

• 전체 업무 흐름을 통합적으로 설명하고 자동화 코드를 받아보자

ChatGPT는 실무 자동화에 있어 ‘자동화 비서’ 역할을 할 수 있습니다.

• 전체 코드를 대신 짜주고

• 조건이나 저장 방식 등을 바로바로 수정해줍니다.

• “엑셀로 된 고객 리스트에서 연체 2회 이상인 고객만 추출해서, 등급별로 나눠 저장하는 파이썬 코드를 짜줘.” → 생성된 코드를 붙여넣고 실행해보세요.

• 포인트: ChatGPT에게 요청할 때 “입력 파일”, “조건”, “저장 방식”을 명확히 설명하는 법 체득

2. 조건 변경 요청

• “VIP 고객만 저장하게 바꿔줘.”

• “거래금액이 100만 원 이상인 경우만 저장하게 바꿔줘.”

→ 변경된 조건이 코드에 어떻게 반영되는지 확인해보세요.

• 포인트: if, query, df[df[조건]] 등이 자동 수정되는 구조 이해

3. 저장 방식 변경 요청

• “등급명을 파일명에 포함시켜 저장되도록 바꿔줘.”

• “파일명을 ‘VIP_20240525.xlsx’ 형식으로 저장해줘.”

→ f-string 등 동적 파일명 구성 코드로 바뀌는 과정을 확인해보세요.

• 포인트: f"{변수}_{날짜}.xlsx" 형태의 자동화 구조 익히기

4. 예외 처리 요청

• “파일이 없거나 열 이름이 다를 때 에러가 나지 않도록 예외처리를 넣어줘.”

→ ChatGPT가 try/except, if not os.path.exists() 등을 넣는 구조를 확인해보세요.

• 포인트: 에러 방지 코드가 어떻게 작성되는지 감 잡기

5. 실무 흐름 생성 요청

• “매일 저장되는 지점별 고객 파일을 모두 불러와서, 등급별로 요약하고 저장하는 코드를 짜줘.”

• “고객 등급별 연체율을 계산하고 막대그래프로 저장하는 보고서 코드 짜줘.”

→ ChatGPT가 전체 업무 흐름을 설계하는 방식을 실습해보세요.

• 포인트: 조건 필터 → groupby 요약 → 시각화 → 저장까지 통합 설계

• 매일 저장되는 고객 파일 자동 요약: “GPT에게 지점별 고객 요약 자동 저장 코드를 요청 → 반복 실행”

• 보고서 자동 생성: “고객 등급별 연체율 계산 + 그래프 저장 요청 → 바로 리포트 구성 가능”

• 예외처리 포함된 자동화: “파일이 없는 날은 패스하도록 GPT가 자동 처리하게 설계”

• RPA 대체 수준의 자동화: 반복적이고 표준화된 작업은 GPT 코드로 더 빠르게 대응 가능

• 이 코드, 매일 실행할 수 있는가?

• 파일명이 바뀌어도 작동하는가?

• 오류가 나면 어떻게 대응할 것인가?

이런 질문에 답하면서, 유지보수가 가능한 자동화를 설계해야 합니다.

1. 입력파일 읽기 →

2. 조건별 필터링 →

3. 요약 집계 및 시각화 →

4. 파일로 저장 또는 전송 →

5. 로그 기록 또는 예외처리

이 구조로 업무를 ‘함수화’하거나, ‘모듈화’하면 장기적으로 유용합니다.

    df = pd.read_excel('고객데이터.xlsx')

except FileNotFoundError:

    print("파일이 존재하지 않습니다.")

exit()

예외처리를 넣으면 자동화의 안정성이 높아집니다. 특히 금융 업무는 오류 발생 시 대응 전략이 매우 중요합니다.

또한,

• 파일명을 날짜 기준으로 바꾸는 방법

• 저장 경로를 자동으로 지정하는 방법

• 매일 자동 실행할 수 있는 스케줄링 방법 (예: Task Scheduler, cron)
  등을 함께 고려해야 합니다.

• 입력 파일 존재 여부를 자동으로 체크하고 예외 상황을 처리할 수 있다

• 날짜 기반 폴더 및 파일명을 자동 생성하고 정리할 수 있다

• 반복되는 작업(조건 필터링, 저장 등)을 함수로 구성하고 재사용할 수 있다

• 전체 작업 흐름을 main() 함수 구조로 설계할 수 있다

• 조건, 경로, 파일명 등을 외부 변수(config)로 관리하는 구조를 만들 수 있다

• 유지보수와 확장성이 뛰어난 자동화 스크립트 흐름을 설계할 수 있다

• 파라미터 분리, 경로 자동 구성, 조건 유연화가 핵심입니다.

• '고객가입데이터.xlsx' 파일이 현재 폴더에 존재하지 않을 경우
  “파일이 없습니다”라는 메시지를 출력하고 프로그램을 종료해보세요.
  → os.path.exists() + if not + print() 또는 raise

2. 날짜별 경로 및 파일명 자동 생성

• 오늘 날짜 기준으로 output/20240525/ 폴더를 생성한 뒤,
  파일을 고객리포트_20240525.xlsx 형식으로 저장해보세요.
  → datetime, os.makedirs(), f-string 활용

3. 자동화 흐름을 함수 단위로 구성

•  “고객 등급별로 분할 저장” 과정을 함수로 만들어보세요.
  → def save_by_grade(df): ... 형식

• 조건(예: 연체 2회 이상, 금액 100만 이상)을 함수 인자로 받아,
  조건에 따라 다른 고객 그룹을 저장할 수 있도록 구조화해보세요.
  → filter_and_save(df, 조건1, 조건2, 저장경로)

4. 전체 작업 흐름을 순서대로 연결

• 아래의 작업을 하나의 스크립트 흐름으로 구성해보세요:

  1. 입력 파일 존재 여부 확인

  2. 조건 필터링

  3. 통계 요약

  4. 시각화

  5. 자동 저장 (날짜 포함 파일명)

→ 단계별 함수로 구성하고, main() 함수로 실행해보세요.

5. 유연성과 유지보수 구조 설계

• config = {...} 딕셔너리에서 필터 조건, 경로, 저장 파일명을 설정하고,
  코드 내에서 이 값을 불러와 자동화 흐름을 제어해보세요.

→ 실무에서 흔히 쓰는 “파라미터 설정 + 코드 분리” 방식입니다.

• 일간 보고서 자동 생성 스크립트: 날짜별 폴더 생성 → 데이터 필터 → 요약 → 그래프 생성 → 저장 자동화

• 운영 자동화의 RPA 대체용 코드: 예외처리 + 설정 파일(config) 조합으로 누구나 실행 가능한 스크립트 작성

• 유지보수 가능한 분석 자동화 템플릿: 조건/경로만 바꾸고 재사용 가능한 구조 설계

파이썬 자동화 흐름:

• 고객 등급과 거래일 조건 필터링

• 조건 만족 고객 추출 → 담당자별 엑셀 저장

• 파일 전송 로그 기록

파이썬 자동화 흐름:

• 복합 조건 필터링 (연체, 금액, 등급)

• 리스트 생성 및 저장 → 부서별 분할 저장

• 누적 연체율 계산 및 시각화 보고서 포함

파이썬 자동화 흐름:

• glob로 파일 수집 → 파일명 기준 날짜 추출

• 기준 열 단위로 병합 → 중복 제거

• 전체 통합 리포트 생성 및 저장

• 실무 시나리오를 코드 흐름으로 구상하고 GPT 또는 직접 구현해본다

• 조건 필터링, 파일 분할 저장, 시각화 등 실무 자동화 작업을 단계별로 수행한다

• 실무 문장(요구사항)을 파이썬 흐름(입력 → 조건 → 저장)으로 자연스럽게 전환한다

• 실습 완료 후 자동화 구조를 팀원에게 설명할 수 있을 정도로 이해한다

• “VIP 고객 중 최근 거래가 없는 고객을 주기적으로 추출해,
  담당자별로 보고서를 분리해 보내야 한다.”

• 고객 데이터에서 VIP 등급이면서 최근 30일간 거래 이력이 없는 고객만 추출하여 저장해보세요.

• 담당자별로 분리 저장(groupby)하고, 저장한 파일명을 로그로 기록해보세요.
  → datetime, groupby, to_excel, with open(log.txt, 'a') 등 활용

2. 연체 고객 리스트 추출 및 관리

• “3개월 내 연체 2회 이상 & 거래금액 낮고 & 비VIP인 고객을 리스크 관리팀에 전달해야 한다.”

• 고객 데이터에서 연체 2회 이상, 거래금액 100만 원 이하, VIP 제외 조건에 맞는 고객을 추출해 저장해보세요.

• 추출한 고객 데이터를 부서별로 나누어 저장하고,
  등급별 연체율을 계산해 막대그래프로 저장해보세요.
  → query, groupby, barplot, to_excel, matplotlib

3. 신규 지점 가입 내역 통합 리포트

• “신규 지점 가입 데이터를 매일 수집하여 기존 통합 데이터와 병합해야 한다.”

• 특정 폴더에서 엑셀 파일을 glob로 수집하고, 파일명에서 날짜를 추출해 하나의 데이터프레임으로 병합해보세요.

• 기존 통합 데이터와 병합(concat), 중복 제거 후 지점명_YYYYMMDD.xlsx 형식으로 통합 보고서를 저장해보세요.
  → glob, os, datetime, drop_duplicates, f-string 활용

• 조건 + 분할 + 저장 흐름은 대부분의 금융 실무 보고서 자동화 패턴과 동일합니다

• 실무에서는 "VIP 제외", "최근 30일 이내", "100만 원 이상" 같은 조건이 자주 바뀌므로 이를 변수화하면 유리합니다

• 파일명에 날짜나 조건 삽입, 로그 저장은 보고용 자동화에서 반드시 필요합니다

• 시각화는 단순한 그림이 아니라, 의사결정의 증거자료로 기능합니다

• 어떤 엑셀 파일을 매일 열고 필터링하는가?

• 반복해서 붙여넣거나, 저장하거나, 복사하는 작업은 무엇인가?

• 매주/매월 같은 양식으로 보고서를 만드는가?

• 반복성: 주기적으로 같은 형식의 작업이 발생한다

• 정형성: 데이터 구조가 일정하며, 처리 조건이 명확하다

• 확장성: 향후 조건이 변경되어도 수정이 용이하다

예: 매주 고객 리스트 저장, 월말 KPI 리포트 생성, 일일 연체율 계산 등

• 1단계: 단순 필터링 자동화 (조건 필터 + 저장)

• 2단계: 병합 및 요약 자동화 (groupby + 시각화)

• 3단계: 반복 실행 환경 구성 (폴더 내 일괄 처리, 예외처리 포함)

• 4단계: GPT 연동 또는 스케줄링 도입 (자동 코드 생성, 매일 자동 실행 등)

• 반복적으로 수행 중인 엑셀 기반 업무를 구체적으로 적어본다

• 각 업무의 반복성·정형성·판단 필요 여부를 기준으로 자동화 가능성을 평가한다

• GPT에게 실무 설명을 전달하고 자동화 가능 여부를 진단받는다

• 자동화 흐름을 직접 구조화해보고, GPT에게 코드 생성을 요청한다

• 조건 변경, 예외 처리 등 다양한 수정 요청을 해본다

• 어떤 파일을 자주 열고, 어떤 조건으로 필터링하나요?

• 매주/매달 같은 보고서를 만들고 있나요?

• 붙여넣기, 복사, 저장을 반복하는 작업이 있나요?

📄 예시 답안

1. 매일 거래내역에서 VIP 고객만 추출해 저장 

2. 월초마다 등급별 고객 수 통계 내고 파워포인트 보고서 작성 

3. 매주 부서별 연체 고객 리스트 추출 및 메일 전송

📢 예시 프롬프트:

"제가 매일 거래내역 엑셀에서 VIP 고객만 추출해 저장하고 있는데, 

이 작업을 파이썬으로 자동화할 수 있을까요? 

파일명은 매일 다르고, 저장은 등급별로 해야 합니다."

GPT는 다음 중 하나로 대답할 수 있습니다:

• ✅ 가능: 코드 흐름 제안 → 바로 코드 요청 가능

• ⚠️ 조건 정리 필요: 사람이 판단할 부분, 양식 적용 등

• ❌ 비정형이 많아 자동화 부적합

📄 자동화 설계 템플릿:

(업무명) VIP 거래고객 정리

1. 입력 데이터:

- 지점별 거래내역 (엑셀)

2. 반복되는 작업:

- VIP 등급 필터 → 저장 → 등급별 분할

3. 자동화 목표:

- 매일 자동으로 VIP만 저장, 등급별 파일 생성

4. 고려 조건:

- 파일명 매일 다름, 일부 시트 누락 가능성

📢 예시 프롬프트:

VIP 고객만 필터해서 등급별로 저장하는 업무입니다. 

파일명은 매일 다르고, 일부 시트가 누락될 수 있습니다.
예외처리 포함해서 전체 파이썬 코드 짜주세요.

→ 결과 코드를 검토하고,

• 조건 수정

• 저장 방식 변경

• 예외처리 추가
  도 추가로 요청해보세요.

• 학습자는 본인의 반복 업무를 바탕으로 자동화 가능성 판단표를 작성해보고, GPT에게 묻고, 직접 흐름을 설계합니다.

·         “자동화는 도구가 아니라 사고방식입니다.”
파이썬을 잘 쓰는 사람은 코드를 잘 짜는 사람이 아니라,
구조를 명확히 파악하고 GPT나 도구에게 잘 설명할 수 있는 사람입니다.

import pandas as pd  # pandas 라이브러리를 불러옵니다 (데이터 분석용)

# 1. 고객 데이터 엑셀 파일을 읽어옵니다

df = pd.read_excel("고객데이터_실습용.xlsx")  # 현재 작업 디렉토리에 있는 파일명 기준

# 1-1. '등급'이 'VIP'인 고객만 추출합니다

vip_customers = df[df["등급"] == "VIP"]  # 조건 필터링으로 VIP 고객만 선택

print("🔹 VIP 고객 리스트:")

print(vip_customers)  # 결과 출력

# 2. 등급별 평균 거래금액을 계산합니다

avg_by_grade = df.groupby("등급")["거래금액"].mean().reset_index()  # groupby + mean으로 평균 계산

# 2-1. 계산된 결과를 새로운 엑셀 파일로 저장합니다

avg_by_grade.to_excel("등급별_평균거래금액.xlsx", index=False)  # 결과를 저장 (인덱스 제외)

# 2-2. 평균 거래금액 결과를 출력합니다

print("\n🔹 등급별 평균 거래금액:")

print(avg_by_grade)

# 천 단위 콤마 형식으로 포맷 적용하여 출력 (소수점 없이 정수로 표시)

avg_by_grade["거래금액"] = avg_by_grade["거래금액"].apply(lambda x: f"{int(x):,}")

# 출력

print("🔹 등급별 평균 거래금액:")

print(avg_by_grade)

# os 모듈과 shutil 모듈을 불러옵니다 (파일 탐색 및 복사 기능을 사용하기 위해 필요합니다)

import os

import shutil

# 1. 현재 작업 디렉토리 경로를 출력합니다

print("✅ 현재 작업 디렉토리:")

print(os.getcwd())  # 현재 디렉토리를 출력해줍니다

# 2. 지정된 폴더(여기서는 ./qtr)의 파일 목록을 가져옵니다

print("\n📁 './qtr' 폴더 내의 파일 목록:")

file_list = os.listdir('./qtr')  # qtr 폴더에 있는 파일들을 리스트로 가져옵니다

print(file_list)

# 3. '2025'가 파일명에 포함되고 확장자가 .xlsx인 파일만 추출합니다

target_files = [f for f in file_list if '2025' in f and f.endswith('.xlsx')]

# 결과 확인

print("\n🔍 '2025'가 포함된 엑셀 파일 목록:")

print(target_files)

# 4. 복사할 대상 폴더 (backup)가 없으면 새로 생성합니다

backup_path = './backup'

os.makedirs(backup_path, exist_ok=True)  # 이미 있어도 에러 없이 넘어갑니다

# 5. 해당 파일들을 backup 폴더로 복사합니다

for f in target_files:

    source = f'./qtr/{f}'          # 원본 파일 경로

    destination = f'{backup_path}/{f}'  # 복사될 위치

    shutil.copy(source, destination)    # 파일 복사

    print(f"📄 복사 완료: {f} → backup 폴더")

# 최종 결과 요약

print(f"\n✅ 총 {len(target_files)}개의 파일이 'backup' 폴더로 복사되었습니다.")

import pandas as pd

import glob

import os

# 1. ./branch 폴더 내 모든 .xlsx 파일 경로 가져오기

file_list = glob.glob('./branch/*.xlsx')

# 파일 리스트 출력

print("📂 불러온 파일 목록:")

for file in file_list:

    print(file)

# 2. 컬럼명 통일 매핑 정의

# ➤ 서로 다른 엑셀 파일의 필드명이 다를 때,

# ➤ 이처럼 '바꿔야 할 항목만' 명시한 매핑 딕셔너리를 사용하는 것이 가장 관리가 편함

# ➤ 새로운 파일 구조가 등장할 경우, 여기에 항목을 추가만 하면 되므로 유지보수에 강한 구조

col_mapping = {

    '이름': '고객명',

    'Name': '고객명',

    '회원등급': '등급',

    'Grade': '등급',

    '금액': '거래금액',

    'Amount': '거래금액'

}

# 3. 파일별 처리 및 병합

df_list = []

for file in file_list:

    df = pd.read_excel(file)

    # 컬럼명 통일

    df.rename(columns=col_mapping, inplace=True)

    # 지점명 필드 추가 (파일명에서 추출)

    branch_name = os.path.splitext(os.path.basename(file))[0]

    df['지점명'] = branch_name

    df_list.append(df)

# 4. 전체 병합

merged_df = pd.concat(df_list, ignore_index=True)

# 5. VIP 고객 제외

filtered_df = merged_df[merged_df['등급'] != 'VIP']

# 6. 결과 확인 및 저장

print("\n✅ VIP 고객 제외한 병합 결과 미리보기:")

print(filtered_df.head())

# 저장 경로 지정

output_path = './branch/전체_병합_비VIP고객.xlsx'

filtered_df.to_excel(output_path, index=False)

print(f"\n💾 저장 완료: {output_path}")

for file in file_list:

    df = pd.read_excel(file)

    print(f"\n📄 {file} 컬럼명:", list(df.columns))

import glob

# 1. 폴더 내 모든 .xlsx 파일 경로 불러오기

file_list = glob.glob('./branch_variation/*.xlsx')

# 2. 모든 컬럼명을 수집

all_columns = []

for file in file_list:

    df = pd.read_excel(file, nrows=1)  # 컬럼명만 확인하므로 첫 줄만 읽기

    all_columns.extend(df.columns.tolist())

# 3. 중복 제거하고 정렬된 컬럼명 리스트 생성

unique_columns = sorted(set(all_columns))

# 4. 결과 출력: ChatGPT에 던질 수 있도록 쉼표로 연결된 문자열 형태로 출력

print("🧾 고유 컬럼명 목록 (중복 제거됨):\n")

print(", ".join(unique_columns))

import glob

import os

# 1. 폴더 내 파일 경로 수집

file_list = glob.glob('./branch_variation/*.xlsx')

# 2. 컬럼명 표준화 매핑 딕셔너리

col_mapping = {

    '이름': '고객명',

    '고객이름': '고객명',

    'Name': '고객명',

    '회원등급': '등급',

    '고객등급': '등급',

    'Grade': '등급',

    '금액': '거래금액',

    'Amount': '거래금액',

    '이용금액': '거래금액'

}

# 3. 파일별 처리 및 병합 준비

df_list = []

for file in file_list:

    df = pd.read_excel(file)

    # 컬럼명 표준화 (필요한 항목만 변경됨)

    df.rename(columns=col_mapping, inplace=True)

    # 지점명 필드 추가 (파일명에서 추출)

    branch_name = os.path.splitext(os.path.basename(file))[0]

    df['지점명'] = branch_name

    df_list.append(df)

# 4. 전체 병합

merged_df = pd.concat(df_list, ignore_index=True)

# 5. VIP 고객 제외

filtered_df = merged_df[merged_df['등급'] != 'VIP']

# 6. 결과 저장

output_path = './branch_variation/통합_비VIP고객.xlsx'

filtered_df.to_excel(output_path, index=False)

# 7. 결과 확인

print("✅ 통합 완료. 저장된 파일:", output_path)

print(filtered_df.head())

import pandas as pd

from datetime import datetime, timedelta

# 1. 엑셀 파일 불러오기

df = pd.read_excel("가입일_기준_고객데이터.xlsx")

# 2. '가입일자' 컬럼을 문자열에서 날짜형으로 변환

df['가입일자'] = pd.to_datetime(df['가입일자'])

# 확인: 변환된 날짜형 데이터 상위 5개

print("✅ 가입일자 컬럼을 날짜형으로 변환한 결과:")

print(df[['고객ID', '가입일자']].head())

# 3. 오늘 날짜 기준으로 최근 3개월 이내(90일 이내) 고객만 추출

today = datetime.today()

three_months_ago = today - timedelta(days=90)

# 가입일자가 최근 3개월 이내인 고객 필터링

recent_customers = df[df['가입일자'] >= three_months_ago]

# 결과 확인

print(f"\n📌 최근 3개월 이내 가입 고객 수: {len(recent_customers)}명")

print(recent_customers.head())

# 4. 최근 3개월 이내 고객 데이터를 새 엑셀 파일로 저장

output_file = "최근3개월_가입고객.xlsx"

recent_customers.to_excel(output_file, index=False)

print(f"\n💾 최근 3개월 이내 고객 데이터를 '{output_file}' 파일로 저장했습니다.")

❗ 왜 months는 안될까?

월(month)은 일(day)처럼 고정된 길이가 아니기 때문입니다.

• 1월 = 31일, 2월 = 28일 또는 29일, 4월 = 30일 …
  → 따라서 단순히 "3개월 전"은 정확히 며칠 전인지 애매합니다.

import pandas as pd

import matplotlib.pyplot as plt

import matplotlib.font_manager as fm

import matplotlib as mpl

# ✅ 한글 폰트 설정: Windows 기준 'Malgun Gothic' 사용

plt.rcParams['font.family'] = 'Malgun Gothic'

# ✅ 마이너스 깨짐 방지

mpl.rcParams['axes.unicode_minus'] = False

# 엑셀 파일 불러오기

df = pd.read_excel('가입자_거래금액_일별데이터.xlsx')

# 날짜를 인덱스로 설정

df['날짜'] = pd.to_datetime(df['날짜'])

# 1️⃣ 일별 가입자 수를 선형 그래프로 시각화

plt.figure(figsize=(12, 6))  # 그래프 크기 설정

plt.plot(df['날짜'], df['일별_가입자수'], marker='o', linestyle='-', label='가입자 수')

plt.title('일별 가입자 수')

plt.xlabel('날짜')

plt.ylabel('가입자 수')

plt.grid(True)

plt.tight_layout()

plt.show()

# 2️⃣ 가입자 수와 평균 거래금액을 이중축 그래프로 시각화

fig, ax1 = plt.subplots(figsize=(12, 6))

# 첫 번째 축: 가입자 수

ax1.plot(df['날짜'], df['일별_가입자수'], 'b-', label='가입자 수')

ax1.set_xlabel('날짜')

ax1.set_ylabel('가입자 수', color='b')

ax1.tick_params(axis='y', labelcolor='b')

# 두 번째 축: 평균 거래금액

ax2 = ax1.twinx()

ax2.plot(df['날짜'], df['평균_거래금액'], 'r--', label='평균 거래금액')

ax2.set_ylabel('평균 거래금액 (원)', color='r')

ax2.tick_params(axis='y', labelcolor='r')

# 제목 및 레이아웃

plt.title('가입자 수와 평균 거래금액 이중축 그래프')

fig.tight_layout()

# 이미지로 저장

plt.savefig('가입자_거래금액_이중축그래프.png')  # 같은 폴더에 PNG 파일로 저장

plt.show()

# 이미지 저장 확인용 메시지

print("✅ '가입자_거래금액_이중축그래프.png' 파일로 그래프 저장 완료되었습니다.")

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

import matplotlib as mpl

# ✅ 한글 폰트 설정 (Windows: Malgun Gothic)

plt.rcParams['font.family'] = 'Malgun Gothic'

mpl.rcParams['axes.unicode_minus'] = False

# 엑셀 파일 불러오기

df = pd.read_excel('거래금액_분포_등급별상관분석_데이터.xlsx')

# 1️⃣ 거래금액 분포 히스토그램

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

sns.histplot(df['거래금액'], bins=30, kde=True)

plt.title('거래금액 분포 (히스토그램)')

plt.xlabel('거래금액')

plt.ylabel('빈도')

plt.tight_layout()

plt.show()

# 2️⃣ 거래금액 박스플롯

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

sns.boxplot(x=df['거래금액'])

plt.title('거래금액 분포 (박스플롯)')

plt.tight_layout()

plt.show()

# 3️⃣ 고객등급별 거래금액 바이올린 플롯

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

sns.violinplot(x='고객등급', y='거래금액', data=df)

plt.title('고객등급별 거래금액 분포 (바이올린 플롯)')

plt.tight_layout()

plt.show()

# 4️⃣ 상관관계 히트맵

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

corr = df[['거래금액', '나이', '가입기간', '거래횟수']].corr()

sns.heatmap(corr, annot=True, cmap='YlGnBu', fmt=".2f")

plt.title('수치형 변수 간 상관관계 (Heatmap)')

plt.tight_layout()

plt.show()

import pandas as pd

import numpy as np

# 1. 엑셀 파일에서 거래금액 데이터 불러오기

df = pd.read_excel("numpy_거래금액_실습파일.xlsx")  # 파일 경로는 실행 위치 기준

print("원본 데이터 미리보기:")

print(df.head())

# 2. 평균과 표준편차 계산

mean = df['거래금액'].mean()

std = df['거래금액'].std()

print("\n평균:", mean)

print("표준편차:", std)

# 3. 이상치 기준값 설정 (평균 ± 2 * 표준편차)

lower_bound = mean - 2 * std

upper_bound = mean + 2 * std

# 4. 이상치를 제거 (조건에 해당하는 행만 추출)

# ⚠ 이때, pandas는 슬라이싱 결과가 'view'인지 'copy'인지 불확실하여 경고를 발생시킴

# ✅ 따라서 .copy()를 붙여 "나는 완전히 독립된 복사본이야"라고 명시적으로 선언함

filtered_df = df[(df['거래금액'] >= lower_bound) & (df['거래금액'] <= upper_bound)].copy()

print("\n이상치 제거 후 데이터 수:", len(filtered_df))

# 5. 이상치 제거된 데이터의 최소값과 최대값을 구함 (정규화를 위해)

min_val = filtered_df['거래금액'].min()

max_val = filtered_df['거래금액'].max()

# 6. 거래금액을 0~1 사이로 정규화 (Min-Max Scaling)

# ✅ 이 부분에서 경고 없이 수정 가능 (filtered_df는 복사본이므로 안전함)

filtered_df['정규화된금액'] = (filtered_df['거래금액'] - min_val) / (max_val - min_val)

# 7. 결과 미리보기 출력

print("\n정규화된 데이터 미리보기:")

print(filtered_df.head())

# 8. 정규화된 결과를 새로운 엑셀 파일로 저장

filtered_df.to_excel("정규화_결과파일.xlsx", index=False)

print("\n[정규화_결과파일.xlsx] 파일로 저장 완료")

import pandas as pd

from openpyxl import Workbook

from openpyxl.styles import Font

# 1. 엑셀에서 고객 데이터 불러오기

df = pd.read_excel("실습용_고객데이터.xlsx")  # 같은 폴더에 있어야 함

# 2. 엑셀 워크북 생성

wb = Workbook()

# 3. 요약 시트 작성

ws_summary = wb.active

ws_summary.title = "요약"

# 전체 고객 수

total_customers = len(df)

# 등급별 통계 계산

summary_stats = df.groupby('등급')['거래금액'].agg(['count', 'mean', 'sum']).reset_index()

summary_stats['비율'] = (summary_stats['count'] / total_customers * 100).round(1).astype(str) + '%'

# 제목 입력

ws_summary['A1'] = "2025년 6월 고객 등급별 보고서"

ws_summary['A1'].font = Font(bold=True, size=14)

# 요약 정보 입력

ws_summary.append([""])

ws_summary.append(["전체 고객 수", total_customers])

ws_summary.append([""])

# 통계 테이블 헤더

ws_summary.append(["등급", "고객 수", "평균 거래금액", "누적 거래금액", "비율"])

# 통계 데이터 행 입력

for row in summary_stats.itertuples(index=False):

    ws_summary.append(list(row))

# 4. 등급별 시트 생성 및 데이터 입력

for grade in df['등급'].unique():

    sheet = wb.create_sheet(title=grade)

    sheet.append([f"{grade} 등급 고객 목록"])  # 제목 행

    sheet.append(["고객명", "등급", "거래금액"])  # 헤더 행

    grade_df = df[df['등급'] == grade].sort_values(by='거래금액', ascending=False).reset_index(drop=True)

    for i, row in grade_df.iterrows():

        values = list(row)

        sheet.append(values)

        # 상위 5명의 고객은 굵은 글씨로 강조

        if i < 5:

            for cell in sheet[sheet.max_row]:

                cell.font = Font(bold=True)

# 5. 보고서 엑셀 파일 저장

wb.save("고객등급별_보고서_완성본.xlsx")

print("보고서가 생성되었습니다: 고객등급별_보고서_완성본.xlsx")

import pandas as pd

import re

# 엑셀 파일 불러오기

df = pd.read_excel("re_실습용_고객데이터_수정포함.xlsx")

# 'C-'로 시작하는 고객만 필터링

df_c = df[df['고객ID'].astype(str).str.startswith('C-')].copy()

# 전화번호 분석 함수

def analyze_phone(phone):

    try:

        original = phone

        phone_str = str(phone).strip()

        if not phone_str or phone_str.lower() in ["nan", "none"]:

            return original, "", "확인 필요", "공란 또는 공백 문자"

        if re.match(r'^010-\d{4}-\d{4}$', phone_str):

            return original, phone_str, "정상", "정상 형식"

        digits = ''.join(re.findall(r'\d', phone_str))

        if len(digits) == 11 and digits.startswith("010"):

            fixed = f"{digits[:3]}-{digits[3:7]}-{digits[7:]}"

            if '-' not in phone_str:

                reason = "구분자 없음"

            elif '.' in phone_str:

                reason = "구분자로 . 사용"

            elif ' ' in phone_str:

                reason = "공백 구분자"

            else:

                reason = "기타 형식 오류"

            return original, fixed, "수정됨", reason

        if not phone_str.startswith("010"):

            reason = "앞자리 오류"

        elif len(digits) < 11:

            reason = "자리수 부족"

        elif re.search(r'\D', phone_str.replace('-', '')):

            reason = "숫자 외 문자 포함"

        else:

            reason = "기타"

        return original, "", "확인 필요", reason

    except Exception as e:

        return phone, "", "확인 필요", f"예외 발생: {e}"

# 처리 결과 리스트 생성

results = [analyze_phone(phone) for phone in df_c['휴대폰번호']]

# 결과 열 할당

df_c = df_c.assign(

    원본번호=[r[0] for r in results],

    수정후번호=[r[1] for r in results],

    처리결과=[r[2] for r in results],

    처리사유=[r[3] for r in results],

)

# 저장

df_c.to_excel("C고객_전화번호_전체결과_입력보존_정상화.xlsx", index=False)

print("✅ 결과 저장 완료: C고객_전화번호_전체결과_입력보존_정상화.xlsx")

# pandas 라이브러리를 불러옵니다. (엑셀 파일 작업을 위한 필수 라이브러리)

import pandas as pd

# 엑셀 파일을 읽어옵니다. 파일명은 '고객가입데이터.xlsx'라고 가정합니다.

df = pd.read_excel('고객가입데이터.xlsx')

# 불러온 데이터의 상위 5개 행을 출력해 봅니다.

print("📌 상위 5개 행 미리보기:")

print(df.head())

# 열 이름(컬럼명) 목록을 확인해 봅니다.

print("\n📌 열 이름 목록:")

print(df.columns)

# 각 열의 데이터 타입 및 null 값 여부, 전체 정보 확인

print("\n📌 데이터프레임 전체 정보:")

df.info()

import pandas as pd

# 1. 엑셀 파일 불러오기

df = pd.read_excel("고객가입데이터.xlsx")

# 2. 열 이름의 공백 제거 + 소문자로 통일

df.columns = [col.strip().lower() for col in df.columns]

# 3. 확인용 출력: 정리된 열 이름 확인

print("📌 정리된 열 이름:", df.columns.tolist())

# 4. 필요한 열만 선택 (정리된 열 이름 기준으로 정확히 지정)

selected_columns = ['이름', '고객등급', '가입일', '가입금액']  # ✅ 수정된 열 이름

# 5. 선택한 열로 새로운 데이터프레임 생성

df_selected = df[selected_columns].copy()  # ✅ .copy() 추가로 경고 방지

# 6. 열 이름 매핑 (한글 → 영어로 변경)

rename_dict = {

    '이름': 'name',

    '고객등급': 'grade',

    '가입일': 'join_date',

    '가입금액': 'amount'

}

df_selected.rename(columns=rename_dict, inplace=True)

# 7. 최종 확인 출력

print("\n📌 최종 열 이름 변경 후 데이터프레임:")

print(df_selected.head())

import pandas as pd

import numpy as np

# 1. 엑셀 파일 불러오기

df = pd.read_excel('고객데이터_결측_이상치포함.xlsx')

# 2. 열 이름 정리: 공백 제거 + 소문자로 변환

df.columns = [col.strip().lower() for col in df.columns]

# 3. 결측값 확인

print("📌 결측값 포함 행 수:", df.isnull().any(axis=1).sum())

# 4. 결측값 처리

df['거래금액'] = df['거래금액'].fillna(0)

df['고객등급'] = df['고객등급'].fillna('일반')

# 5. 이상치 기준 계산 (평균 ± 2표준편차)

mean = df['거래금액'].mean()

std = df['거래금액'].std()

lower = mean - 2 * std

upper = mean + 2 * std

print(f"\n📌 거래금액 평균: {mean:.2f}, 표준편차: {std:.2f}")

print(f"   → 이상치 기준: {lower:.2f} ~ {upper:.2f}")

# 6. 이상치 제거

df_cleaned = df[(df['거래금액'] >= lower) & (df['거래금액'] <= upper)]

# 7. 최종 결과 출력

print("\n✅ 최종 처리 결과 미리보기 (상위 5개):")

print(df_cleaned.head())

print(f"\n✅ 최종 행 수: {len(df_cleaned)}")

# 8. 파일로 저장

output_path = '고객데이터_클린버전.xlsx'

df_cleaned.to_excel(output_path, index=False)

print(f"\n📁 최종 파일 저장 완료: {output_path}")

import pandas as pd

# 1. 엑셀 파일 불러오기

df = pd.read_excel("중복_및_오류_데이터_실습용.xlsx")

# 원본 데이터 확인

print("원본 데이터 행 수:", len(df))

# 2. 전체 중복 행 제거

df_no_full_dup = df.drop_duplicates()

print("전체 중복 제거 후 행 수:", len(df_no_full_dup))

# 3. '고객ID' + '가입일' 기준 중복 제거

# 기본 동작은 keep='first'로, 중복되는 경우 '가장 먼저 등장한 행'을 남깁니다.

# 예를 들어, C-0012 고객이 같은 가입일로 두 번 기록되었을 경우 먼저 기록된 것만 남고 나중 것은 삭제됩니다.

# 만약 최근 데이터를 남기고 싶다면 keep='last'로 변경하면 됩니다.

df_no_id_date_dup = df.drop_duplicates(subset=['고객ID', '가입일'], keep='first')

print("고객ID + 가입일 기준 중복 제거 후 행 수:", len(df_no_id_date_dup))

# 4. 'C-'로 시작하지 않는 고객ID 확인

invalid_id_df = df[~df['고객ID'].str.startswith("C-")]

print("C-로 시작하지 않는 고객ID 개수:", len(invalid_id_df))

print(invalid_id_df[['고객ID', '고객명']].head())  # 오류 데이터 일부 출력

# 5. 'C-'로 시작하지 않는 고객ID 제거

df_valid_ids = df[df['고객ID'].str.startswith("C-")]

print("유효한 고객ID만 남긴 후 행 수:", len(df_valid_ids))

# 6. 최종 결과 저장

df_valid_ids.to_excel("중복_오류제거_결과.xlsx", index=False)

print("최종 결과 파일이 저장되었습니다: 중복_오류제거_결과.xlsx")

import pandas as pd

from datetime import datetime, timedelta

# 1. 엑셀 파일 불러오기

df = pd.read_excel("조건_필터링_실습용.xlsx")

# 오늘 날짜 기준 설정

today = datetime.today()

# -----------------------------------------------

# 조건 1: 거래금액이 50만 원 미만이고, 연체횟수가 2회 이상이며, 등급이 VIP가 아닌 고객

cond1 = (df['거래금액'] < 500000) & (df['연체횟수'] >= 2) & (df['등급'] != 'VIP')

filtered1 = df[cond1]

print("조건 1 - 거래금액 < 50만, 연체 ≥ 2, VIP 제외 고객 수:", len(filtered1))

print(filtered1.head())  # 결과 일부 출력

# -----------------------------------------------

# 조건 2: 가입일 기준으로 최근 3개월 이내 고객

three_months_ago = today - timedelta(days=90)

cond2 = df['가입일'] >= three_months_ago

filtered2 = df[cond2]

print("\n조건 2 - 최근 3개월 이내 가입 고객 수:", len(filtered2))

print(filtered2[['고객ID', '가입일']].head())

# -----------------------------------------------

# 조건 3: 등급이 A 또는 B인 고객만 추출해서 파일로 저장

cond3 = df['등급'].isin(['A', 'B'])

filtered3 = df[cond3]

print("\n조건 3 - 등급 A 또는 B 고객 수:", len(filtered3))

print(filtered3[['고객ID', '등급']].head())

# 결과 저장

filtered3.to_excel("등급_A_or_B_고객.xlsx", index=False)

print("\n등급 A 또는 B 고객 데이터를 등급_A_or_B_고객.xlsx 파일로 저장했습니다.")

import pandas as pd

import numpy as np

from datetime import datetime

from dateutil.relativedelta import relativedelta  # 개월 수 계산을 위해 사용

# 1. 엑셀 파일 불러오기

df = pd.read_excel("고객데이터_정렬및파생열실습용.xlsx")

# 2. 거래금액 기준 내림차순 정렬

sorted_by_amount = df.sort_values(by='거래금액', ascending=False)

print("📌 거래금액 기준 내림차순 정렬 결과:")

print(sorted_by_amount.head())

# 3. 등급 기준 정렬을 위한 Categorical 설정 (A > B > C)

df['등급'] = pd.Categorical(df['등급'], categories=['A', 'B', 'C'], ordered=True)

# 4. 등급 + 거래금액 기준 정렬

sorted_by_grade_amount = df.sort_values(by=['등급', '거래금액'], ascending=[True, False])

print("\n📌 등급 → 거래금액 기준 복합 정렬 결과:")

print(sorted_by_grade_amount.head())

# 5. 고액 고객 / 일반 고객 구분

df['고객분류'] = df['거래금액'].apply(lambda x: '고액 고객' if x >= 1_000_000 else '일반 고객')

# 6. 가입연차 계산 (경과된 개월 수)

today = pd.Timestamp.today()

df['가입일'] = pd.to_datetime(df['가입일'])  # 날짜형 변환

def calculate_months(start_date, end_date):

    delta = relativedelta(end_date, start_date)

    return delta.years * 12 + delta.months

df['가입연차'] = df['가입일'].apply(lambda d: calculate_months(d, today))

# 7. 최종 결과 출력

print("\n✅ 최종 파생 열 포함된 고객 데이터:")

print(df.head())

# (선택) 엑셀로 저장

# df.to_excel("고객데이터_정렬_파생열포함.xlsx", index=False)

import pandas as pd

# 1. 엑셀 파일 불러오기

file_path = '고객데이터_정제필요.xlsx'

df = pd.read_excel(file_path)

# 결과 확인

print("📌 원본 데이터 미리보기:")

print(df.head())

# 2. 정제: 고객명 공백 제거, 고객등급 대문자로 통일 (예시 정제)

df['고객명'] = df['고객명'].str.strip()

df['고객등급'] = df['고객등급'].str.upper()

# 3. 정제된 전체 데이터 저장

cleaned_file = '고객데이터_정제완료.xlsx'

df.to_excel(cleaned_file, index=False)

print(f"\n✅ 정제된 전체 데이터를 다음 파일로 저장했습니다: {cleaned_file}")

# 4. 고객 등급별로 분할 저장

grade_list = df['고객등급'].unique()  # A, B, C 등의 등급 추출

print("\n📂 고객 등급별 파일 저장:")

for grade in grade_list:

    df_grade = df[df['고객등급'] == grade]

    grade_file = f"grade_{grade}.xlsx"

    df_grade.to_excel(grade_file, index=False)

    print(f" - {grade} 등급 고객 {len(df_grade)}명 → 저장 완료: {grade_file}")

import pandas as pd

# 1. 엑셀 파일 불러오기

df = pd.read_excel("고객데이터_실습1.xlsx")

print("전체 데이터 행 수:", len(df))

print("열 목록:", df.columns.tolist())

# 2. 고객등급별로 분할 저장

for grade, group in df.groupby('고객등급'):

    filename = f"{grade}.xlsx"

    group.to_excel(filename, index=False)

    print(f"저장 완료: {filename} (행 수: {len(group)})")

# 3. 지점명별로 분할 저장

for branch, group in df.groupby('지점명'):

    filename = f"{branch}.xlsx"

    group.to_excel(filename, index=False)

    print(f"저장 완료: {filename} (행 수: {len(group)})")

import pandas as pd

import os

# 1. 엑셀 파일 불러오기

df = pd.read_excel("조건필터_그룹저장_실습데이터.xlsx")

# 2-1. 거래금액 ≥ 100만 원 & 연체횟수 ≥ 1 → 고객등급별로 저장

filtered_df1 = df[(df['거래금액'] >= 1000000) & (df['연체횟수'] >= 1)]

print(f"💡 거래금액 ≥ 100만 원 & 연체횟수 ≥ 1인 고객 수: {len(filtered_df1)}명")

# 고객등급별로 나누어 저장

output_folder1 = "등급별저장_조건1"

os.makedirs(output_folder1, exist_ok=True)

for grade, group in filtered_df1.groupby("고객등급"):

    filename = f"{output_folder1}/grade_{grade}.xlsx"

    group.to_excel(filename, index=False)

    print(f"✅ 저장 완료: {filename} (행 수: {len(group)})")

# 2-2. VIP 고객 중 연체 이력 없는 고객 → 지점명 기준으로 저장

filtered_df2 = df[(df['고객등급']  'VIP') & (df['연체횟수']  0)]

print(f"\n💡 연체 이력이 없는 VIP 고객 수: {len(filtered_df2)}명")

# 지점명 기준으로 나누어 저장

output_folder2 = "지점별저장_조건2"

os.makedirs(output_folder2, exist_ok=True)

for branch, group in filtered_df2.groupby("지점명"):

    filename = f"{output_folder2}/vip_{branch}.xlsx"

    group.to_excel(filename, index=False)

    print(f"✅ 저장 완료: {filename} (행 수: {len(group)})")

import pandas as pd

from datetime import datetime

import os

# 엑셀 파일 불러오기

df = pd.read_excel("고객정보_지점등급별_파일명구성실습.xlsx")

# 오늘 날짜를 YYYYMMDD 형식으로 생성

today = datetime.today().strftime('%Y%m%d')

# 저장할 디렉토리 생성 (없으면 새로 생성)

output_dir = "./저장결과"

os.makedirs(output_dir, exist_ok=True)

# 1. 지점명 + 고객등급 형식으로 저장

print("\n[1] 지점명_고객등급 형식으로 파일 저장:")

grouped1 = df.groupby(['지점명', '고객등급'])

for (branch, grade), group in grouped1:

    filename = f"{branch}_{grade}.xlsx"

    filepath = os.path.join(output_dir, filename)

    group.to_excel(filepath, index=False)

    print(f"저장 완료 → {filename}")

# 2. 지점명 + 날짜 형식으로 저장 (지점명 기준)

print("\n[2] 지점명_YYYYMMDD 형식으로 파일 저장:")

grouped2 = df.groupby('지점명')

for branch, group in grouped2:

    filename = f"{branch}_{today}.xlsx"

    filepath = os.path.join(output_dir, filename)

    group.to_excel(filepath, index=False)

    print(f"저장 완료 → {filename}")

import pandas as pd

import os

# 엑셀 파일 불러오기

df = pd.read_excel("고객데이터_시트분리실습용.xlsx")

# 1️⃣ 등급별로 시트를 나누어 하나의 파일에 저장

with pd.ExcelWriter("등급별_시트저장.xlsx") as writer:

    for grade, group in df.groupby("고객등급"):

        group.to_excel(writer, sheet_name=grade, index=False)

print("✅ 등급별 시트 저장 완료: 등급별_시트저장.xlsx")

# 2️⃣ 지점별로 파일을 만들고, 그 안에 등급별 시트를 저장

output_dir = "지점별_등급시트저장"

os.makedirs(output_dir, exist_ok=True)

for branch, branch_df in df.groupby("지점명"):

    file_name = f"{output_dir}/{branch}_등급시트.xlsx"

    with pd.ExcelWriter(file_name) as writer:

        for grade, group in branch_df.groupby("고객등급"):

            group.to_excel(writer, sheet_name=grade, index=False)

    print(f"✅ 저장 완료: {file_name}")

import pandas as pd

import os

import zipfile

# ✅ 1. 데이터 불러오기

df = pd.read_excel("고객데이터_예제.xlsx")

# ✅ 2. 가입일을 연-월 기준으로 변환

df['가입일'] = pd.to_datetime(df['가입일'])

df['연'] = df['가입일'].dt.year

df['월'] = df['가입일'].dt.month

# ✅ 3. 연-월별 → 고객등급별 그룹 저장

base_dir = "reports"

zip_paths = []

for (year, month), group_by_date in df.groupby(['연', '월']):

    folder_path = os.path.join(base_dir, f"{year}/{month:02d}")

    os.makedirs(folder_path, exist_ok=True)

    saved_files = []

    for 등급, group in group_by_date.groupby("고객등급"):

        filename = f"{등급}_고객리스트.xlsx"

        file_path = os.path.join(folder_path, filename)

        group.to_excel(file_path, index=False)

        saved_files.append(file_path)

    # ✅ 4. 폴더별 압축 파일 생성 (선택 과제)

    zip_file = os.path.join(folder_path, "분할저장_리스트.zip")

    with zipfile.ZipFile(zip_file, 'w') as zipf:

        for f in saved_files:

            zipf.write(f, arcname=os.path.basename(f))

    zip_paths.append(zip_file)

# ✅ 5. 완료 메시지

print("✅ 월별 등급 파일 저장 및 압축 완료:")

for path in zip_paths:

    print("-", path)

import pandas as pd

# ✅ 1. 엑셀 파일 불러오기

# 실습용 고객 데이터 파일 경로

file_path = "실습_요약통계_파일.xlsx"

df = pd.read_excel(file_path)

# ✅ 2. 전체 수치형 컬럼 요약

# describe() 함수는 평균, 표준편차, 최소값, 4분위수, 최대값 등을 자동 계산

summary_all = df.describe()

# ✅ 3. 요약 결과를 보기 좋게 출력

print("📊 전체 수치형 컬럼 요약 통계:")

print(summary_all)

# ✅ 4. 선택한 컬럼만 요약

# 거래금액, 연체횟수, 거래건수 컬럼에 대해 평균, 표준편차, 최소값, 최대값, 중앙값 계산

summary_selected = df[['거래금액', '연체횟수', '거래건수']].agg(['mean', 'std', 'min', 'max', 'median'])

# ✅ 5. 결과를 엑셀 파일로 저장

# ExcelWriter를 사용하면 여러 시트를 하나의 파일에 저장할 수 있음

output_path = "요약통계_결과.xlsx"

with pd.ExcelWriter(output_path) as writer:

    summary_all.to_excel(writer, sheet_name='전체통계')

    summary_selected.to_excel(writer, sheet_name='선택통계')

# ✅ 6. 완료 메시지 출력

print("요약 통계 결과가 저장되었습니다:", output_path)

import pandas as pd

# ✅ 엑셀 파일 불러오기 (현재 워킹 디렉토리에 있다고 가정)

df = pd.read_excel("실습_요약통계_파일.xlsx")  # 파일명이 다르면 적절히 수정하세요

# ✅ 1. 지점별 평균 거래금액과 평균 연체횟수 계산

# groupby로 '지점명' 기준 집계, '거래금액'과 '연체횟수' 컬럼에 대해 평균(mean) 계산

branch_grouped = df.groupby('지점명')[['거래금액', '연체횟수']].mean()

# 결과 출력

print("✅ [1] 지점별 평균 거래금액과 평균 연체횟수")

print(branch_grouped)

print("\n")  # 줄바꿈

# ✅ 2. 고객등급, 지점명, 담당자 기준으로 다중 groupby

# 거래금액의 합계(sum), 고객 수(count), 평균 연체횟수(mean) 집계

multi_grouped = df.groupby(['고객등급', '지점명', '담당자']).agg({

    '거래금액': 'sum',        # 거래금액 합계

    '고객ID': 'count',       # 고객 수

    '연체횟수': 'mean'       # 평균 연체횟수 = 연체율 대체 지표

}).rename(columns={'고객ID': '고객수', '연체횟수': '평균연체율'})  # 열 이름 보기 좋게 변경

# ✅ 결과 출력

print("✅ [1] 지점별 평균 거래금액과 평균 연체횟수")

print(branch_grouped)

print("\n✅ [2] 고객등급, 지점명, 담당자 기준 집계 결과")

print(multi_grouped)

# ✅ 결과를 엑셀 파일로 저장

output_file = "기준별_집계결과.xlsx"

with pd.ExcelWriter(output_file) as writer:

    branch_grouped.to_excel(writer, sheet_name="지점별_평균")

    multi_grouped.to_excel(writer, sheet_name="다중기준_집계")

print(f"\n📁 집계 결과가 '{output_file}' 파일로 저장되었습니다.")

import pandas as pd

# ✅ 엑셀 파일 불러오기
df = pd.read_excel("실습_요약통계_파일.xlsx")  # 파일명이 다르면 적절히 수정하세요

# ✅ 1. 지점별 평균 거래금액과 평균 연체횟수
pivot_branch = pd.pivot_table(
    df,
    index='지점명',
    values=['거래금액', '연체횟수'],
    aggfunc='mean',
    margins=True,  # 전체합(평균) 행 추가
    margins_name='전체평균'  # 기본 이름은 'All'
)

# ✅ 2. 고객등급 + 지점명 + 담당자 기준 피벗
pivot_multi = pd.pivot_table(
    df,
    index=['고객등급', '지점명'],
    columns='담당자',
    values='거래금액',
    aggfunc='sum',
    fill_value=0,
    margins=True,
    margins_name='합계'
)

# ✅ 결과 출력
print("✅ [1] 지점별 평균 피벗 테이블")
print(pivot_branch)
print("\n✅ [2] 고객등급-지점명 기준, 담당자별 거래금액 합계 피벗 테이블")
print(pivot_multi)

# ✅ 엑셀 저장
with pd.ExcelWriter("기준별_피벗테이블_결과.xlsx") as writer:
    pivot_branch.to_excel(writer, sheet_name="지점별_평균")
    pivot_multi.to_excel(writer, sheet_name="다중기준_합계")
print("\n📁 피벗테이블 결과가 '기준별_피벗테이블_결과.xlsx'로 저장되었습니다.")

import pandas as pd

# 1. 엑셀 파일 불러오기

df = pd.read_excel('고객등급별_연체율_실습파일.xlsx')  # 같은 폴더에 파일이 있다고 가정

# 2. 고객등급별 연체율 계산

# 전체 고객 수

total = df.groupby('고객등급').size()

# 연체 고객 수

delinquent = df[df['연체여부'] == 1].groupby('고객등급').size()

# 연체율 계산 (결측값은 0으로 처리)

rate = (delinquent / total).fillna(0) * 100  # % 단위

# 3. DataFrame으로 정리

summary_df = pd.DataFrame({

    '전체고객수': total,

    '연체고객수': delinquent.fillna(0).astype(int),

    '연체율(%)': rate.round(2)

}).sort_values(by='연체율(%)', ascending=False)

# 4. 결과 출력

print("📊 고객등급별 연체율 요약:")

print(summary_df)

# 5. 엑셀로 저장

summary_df.to_excel('고객등급별_연체율_요약리포트.xlsx')

print("\n✅ '고객등급별_연체율_요약리포트.xlsx' 파일로 저장 완료!")

# 필요한 라이브러리 불러오기

import pandas as pd

import numpy as np

from datetime import datetime

import random

import matplotlib.pyplot as plt

import seaborn as sns

# 시각화 한글 깨짐 방지 설정 (윈도우 기준)

plt.rcParams['font.family'] = 'Malgun Gothic'  # '맑은 고딕'

plt.rcParams['axes.unicode_minus'] = False     # 마이너스 기호 깨짐 방지

# 시드 고정 (재현 가능성 확보)

random.seed(42)

np.random.seed(42)

# ✅ 1. 가상의 고객 데이터 생성

num_records = 1000

date_range = pd.date_range(start="2023-01-01", end="2025-05-31", freq='D')

data = {

    '고객ID': [f'C{1000+i}' for i in range(num_records)],

    '가입일': np.random.choice(date_range, num_records),

    '고객등급': np.random.choice(['A', 'B', 'C', 'VIP'], num_records, p=[0.3, 0.3, 0.3, 0.1]),

    '연체횟수': np.random.poisson(lam=0.8, size=num_records),

    '거래금액': np.random.gamma(shape=2, scale=500000, size=num_records).astype(int)

}

df = pd.DataFrame(data)

# ✅ 2. 가입 월 파생 열 생성

df['가입월'] = df['가입일'].dt.to_period('M').astype(str)

# ✅ 3. 월별 신규 고객 수 계산

monthly_new = df.groupby('가입월').size().reset_index(name='신규고객수')

print("\n[월별 신규 고객 수]")

print(monthly_new.head())

# ✅ 4. 월별 연체율 계산

df['연체여부'] = df['연체횟수'] > 0

monthly_delay = df.groupby('가입월').agg(

    총고객수=('고객ID', 'count'),

    연체고객수=('연체여부', 'sum')

).reset_index()

monthly_delay['연체율'] = (monthly_delay['연체고객수'] / monthly_delay['총고객수']) * 100

print("\n[월별 연체율]")

print(monthly_delay.head())

# ✅ 5. 시각화: 월별 신규 고객 수

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

sns.barplot(x='가입월', y='신규고객수', data=monthly_new, color='skyblue')

plt.title('월별 신규 고객 수')

plt.xticks(rotation=45)

plt.tight_layout()

plt.savefig('월별_신규고객수_추이.png')  # 이미지 저장

plt.show()  # 바로 화면에 출력

# ✅ 6. 시각화: 월별 연체율 변화 (선형 그래프 + 최고/최저 강조)

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

sns.lineplot(x='가입월', y='연체율', data=monthly_delay, marker='o')

plt.title('월별 연체율 변화')

plt.xticks(rotation=45)

# 최고/최저값 위치 찾기

max_idx = monthly_delay['연체율'].idxmax()

min_idx = monthly_delay['연체율'].idxmin()

# 최고값 강조

plt.annotate('최고 연체율',

             xy=(max_idx, monthly_delay['연체율'][max_idx]),

             xytext=(max_idx, monthly_delay['연체율'][max_idx] + 3),

             arrowprops=dict(facecolor='red', shrink=0.05))

# 최저값 강조

plt.annotate('최저 연체율',

             xy=(min_idx, monthly_delay['연체율'][min_idx]),

             xytext=(min_idx, monthly_delay['연체율'][min_idx] + 3),

             arrowprops=dict(facecolor='green', shrink=0.05))

plt.tight_layout()

plt.savefig('월별_연체율_추이.png')  # 이미지 저장

plt.show()  # 바로 화면에 출력

# ✅ 7. 엑셀 파일 저장

df.to_excel('추이분석_실습데이터.xlsx', index=False)

print("\n✅ 데이터와 시각화 결과가 모두 저장되었습니다.")

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

# ✅ 1. 엑셀 파일에서 데이터 불러오기

df = pd.read_excel("고객거래데이터_등급_지점별비교실습.xlsx")

# 데이터 미리보기

print("데이터 미리보기:")

print(df.head())

# ✅ 2. 등급별 거래금액 분포 박스플롯

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

# ⚠️ hue를 명시하지 않으면 palette 사용 시 FutureWarning 발생함 (Seaborn 0.14부터)

# → hue='고객등급'으로 색상 기준을 명시하고, legend=False로 범례는 표시 안함

sns.boxplot(

    x='고객등급',

    y='거래금액',

    data=df,

    hue='고객등급',         # 색상을 등급별로 다르게

    palette='pastel',       # 색상 스타일

    dodge=False             # 같은 값이므로 분리 표시 안함

)

plt.title('등급별 거래금액 분포', fontsize=14)

plt.xlabel('고객등급')

plt.ylabel('거래금액')

plt.grid(axis='y', linestyle='--', alpha=0.7)

# 범례 제거 (hue 때문에 생긴 것 숨기기)

plt.legend([], [], frameon=False)

plt.tight_layout()

plt.savefig("등급별_거래금액_박스플롯.png")

plt.show()

# ✅ 3. 지점별 평균 거래금액 막대그래프

branch_avg = df.groupby('지점명')['거래금액'].mean().sort_values()

# 평균값 확인용 출력

print("\n지점별 평균 거래금액:")

print(branch_avg)

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

bars = plt.bar(branch_avg.index, branch_avg.values, color='orange')  # color 직접 지정

plt.title('지점별 평균 거래금액', fontsize=14)

plt.xlabel('지점명')

plt.ylabel('평균 거래금액')

plt.xticks(rotation=45)

plt.grid(axis='y', linestyle='--', alpha=0.7)

# 막대 위에 수치 라벨 표시

for bar in bars:

    yval = bar.get_height()

    plt.text(bar.get_x() + bar.get_width()/2.0, yval, f'{yval:,.0f}', ha='center', va='bottom', fontsize=9)

plt.tight_layout()

plt.savefig("지점별_평균거래금액_막대그래프.png")

plt.show()

import pandas as pd

import matplotlib.pyplot as plt

from openpyxl import Workbook

from openpyxl.drawing.image import Image as XLImage

from openpyxl.utils.dataframe import dataframe_to_rows

# 1. 엑셀 파일 불러오기

df = pd.read_excel('고객데이터_RAW_예제.xlsx')

# 2. 수치형 컬럼 요약 통계 계산

summary = df[['거래금액', '연체횟수']].describe()

# 3. 거래금액 분포 그래프 저장

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

plt.hist(df['거래금액'], bins=20, color='skyblue', edgecolor='black')

plt.title('거래금액 분포')

plt.xlabel('거래금액')

plt.ylabel('빈도수')

plt.tight_layout()

plt.savefig('거래금액_분포.png')

plt.close()

# 4. 엑셀 파일로 저장 (통계 + 그래프 시트 포함)

wb = Workbook()

ws1 = wb.active

ws1.title = "통계"

# 요약 통계 입력

for row in dataframe_to_rows(summary, index=True, header=True):

    ws1.append(row)

# 그래프 시트 추가

ws2 = wb.create_sheet(title="그래프")

img = XLImage('거래금액_분포.png')

img.anchor = 'A1'

ws2.add_image(img)

# 최종 저장

wb.save("summary_report.xlsx")

https://bit.ly/43GGvSW

4.0점 (①, ⑦): 완전 자동화 적합 업무 — 조건 명확, 반복적, 판단 불필요

3.5점 (③, ⑥): 매우 높은 자동화성 — 데이터 병합이나 메일 전송 포함 업무

2.5점 이하: 수작업 해석·포맷 조정 등 사람 개입이 필요한 단계 존재

• 완전 자동화는 이론상 가능해 보여도, 실무에서는 예외 관리 여부가 핵심입니다.

• 즉, 완전 자동화가 아닌 '협업형 자동화 + 판단 구조화'가 실무에서 지속 가능한 해답입니다.

• Power Query / Power BI의 핵심 기능들을 대부분 대체할 수 있습니다.

• 반복 작업, 조건별 저장, 다중 집계, 시각화 등에서 더 유연합니다.

• 특히 복잡한 조건 처리에 매우 강합니다.
  → 조건 조합, 함수화, 고급 필터링 등 실무에 최적화

연체정보: 고객ID, 연체여부, 연체일자

거래정보: 고객ID, 거래금액, 거래일자

이 두 파일을 사용해서,

① 고객별 연체횟수를 계산 (연체여부 기준)
② 고객별 거래금액 합계는 거래금액의 절대값으로 계산
③ 고객ID를 기준으로 병합하고
④ 연체횟수 ≥ 2 & 거래금액 > 500000 조건의 고객을 추출한 뒤
⑤ 거래금액 기준 상위 5명의 정보를 보여줘.

• 거래정보.xlsx: 고객ID, 거래금액, 거래일자

• 연체정보.xlsx: 고객ID, 연체여부, 연체일자

이걸 바탕으로 고객ID별 연체횟수와 거래금액 합계를 계산해 병합하고,
연체횟수 ≥ 2 & 거래금액 > 500000 인 고객을 추출해
상위 5명 정보를 보여주는 코드를 만들어주세요.

필드구조: 지점, 날짜, 상품, 원화금액

이 데이터에서 상품별 원화금액의 분포를 히스토그램으로 시각화하고자 해.

원화금액을 50000원단위로 범주화해서 작업해줘.

그리고 상품별 히스토그램을 열개 10로 분할해서 멀티 미니 차트 형태로 시각화하는 코드를 제시해줘

그리고 저장했다는 메시지를 프린트하는 부분도 추가해줘.

필드구조: 고객ID, 이름, 성별, 나이, 등급, 거래금액

1. 이 파일에서 VIP 고객 리스트 추출해서 거래금액 기준 상위 5명 내용을 보여줘

2. 등급별 평균 거래금액을 계산해서 등급, 평균거래금액 필드로 테이블을 만들고 파일로 저장해줘.

3. 그 내용을 보여줘.

이 작업을 수행하는 코드를 제시해줘

을 불러와서 각 파일의 필드명을 모두 추출해줘.

이 작업을 수행하는 코드 제시해줘.

필드명을 통일하자.

2. 네가 제안한 것 처럼 고객명, 고객등급, 거래금액 으로 필드명을 통일해주고

3. 파일명에 있는 지점명을 별도 지점명 필드를 만들고 그 값으로 추가해서

4. 3개 지점 파일을 하나의 파일로 통합해줘.

5. 그리고 VIP 등급을 제외해줘.

이 작업을 코드로 제시해줘

필드구조: 고객명, 등급, 거래금액

1. 위의 데이터를 읽어서 등급별 고객수, 평균 거래금액, 거래금액 합계, 인원수 기준 전체 대비 비율을 계산하고

2. 요약 시트 생성해서 "2025년 6월 고객 등급별 보고서"를 제목으로 하고

별도 행으로 전체 고객수를 보여주고

등급별 고객수, 평균 거래금액, 거래금액, 합계, 비율(인원수 기준)을 표로 작성

3. 등급별 시트를 생성해서 고객, 등급, 거래금액 합계를 표시

그리고 이 시트에서 거래금액 상위 5명까지는 bold체로 표시

그리고 이 전체 결과를 "고객등급별_보고서_완성본1.xlsx"로 저장하는

코드 제시해줘