Update src/streamlit_app.py

src/streamlit_app.py

@@ -7,274 +7,379 @@ from scipy.stats import norm, skew
 import platform
 import os
 import matplotlib.font_manager as fm
+import warnings
+warnings.filterwarnings('ignore')
 
-def set_korean_font():
-    """한글 폰트 설정 함수 - 강제로 폰트 적용"""
+# 전역 폰트 설정 - 앱 시작 즉시 실행
+def configure_matplotlib_korean():
+    """matplotlib 한글 폰트 강제 설정"""
     
-    # matplotlib 캐시 클리어 (중요!)
+    # matplotlib 백엔드 설정
+    plt.switch_backend('Agg')
+    
+    # 기존 설정 완전 초기화
     plt.rcdefaults()
     
-    # 1. 사용자 지정 폰트 파일 확인
-    font_filename = "NanumGaRamYeonGgoc.ttf"
-    font_path = os.path.join(os.getcwd(), font_filename)
-    selected_font = None
+    # 폰트 캐시 완전 삭제 및 재구성
+    try:
+        fm._load_fontmanager(try_read_cache=False)
+    except:
+        pass
     
-    if os.path.exists(font_path):
-        try:
-            # 폰트 매니저 캐시 클리어
-            fm.fontManager.__init__()
-            # 폰트 파일을 시스템에 등록
-            fm.fontManager.addfont(font_path)
-            font_prop = fm.FontProperties(fname=font_path)
-            selected_font = font_prop.get_name()
-            st.sidebar.success(f"사용자 폰트 '{selected_font}' 로딩 성공!")
-        except Exception as e:
-            st.sidebar.warning(f"사용자 폰트 로딩 실패: {e}")
+    # 운영체제별 한글 폰트 경로 직접 지정
+    korean_font_paths = []
     
-    # 2. 시스템에서 사용 가능한 한글 폰트 찾기
-    if not selected_font:
-        # 실제로 사용 가능한 폰트들 체크
-        system_fonts = fm.findSystemFonts()
-        korean_font_candidates = []
-        
-        for font_path in system_fonts:
+    if platform.system() == 'Windows':
+        korean_font_paths = [
+            'C:/Windows/Fonts/malgun.ttf',
+            'C:/Windows/Fonts/gulim.ttc',
+            'C:/Windows/Fonts/batang.ttc',
+        ]
+        fallback_font = 'Malgun Gothic'
+    elif platform.system() == 'Darwin':  # macOS
+        korean_font_paths = [
+            '/System/Library/Fonts/AppleGothic.ttf',
+            '/System/Library/Fonts/Helvetica.ttc',
+        ]
+        fallback_font = 'AppleGothic'
+    else:  # Linux
+        korean_font_paths = [
+            '/usr/share/fonts/truetype/nanum/NanumGothic.ttf',
+            '/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf',
+        ]
+        fallback_font = 'DejaVu Sans'
+    
+    # 사용자 정의 폰트 파일 경로도 추가
+    user_font = os.path.join(os.getcwd(), "NanumGaRamYeonGgoc.ttf")
+    if os.path.exists(user_font):
+        korean_font_paths.insert(0, user_font)
+    
+    selected_font_path = None
+    selected_font_name = fallback_font
+    
+    # 실제 존재하는 폰트 파일 찾기
+    for font_path in korean_font_paths:
+        if os.path.exists(font_path):
             try:
-                font_name = fm.FontProperties(fname=font_path).get_name()
-                # 한글 폰트 후보들
-                if any(keyword in font_name.lower() for keyword in 
-                      ['nanum', 'malgun', 'gothic', 'gulim', 'dotum', 'batang']):
-                    korean_font_candidates.append(font_name)
-            except:
+                font_prop = fm.FontProperties(fname=font_path)
+                selected_font_name = font_prop.get_name()
+                selected_font_path = font_path
+                
+                # 폰트 매니저에 강제 등록
+                fm.fontManager.addfont(font_path)
+                break
+            except Exception as e:
                 continue
-        
-        if korean_font_candidates:
-            selected_font = korean_font_candidates[0]
-            st.sidebar.info(f"시스템 한글 폰트 '{selected_font}' 발견!")
     
-    # 3. 운영체제별 기본 폰트 설정
-    if not selected_font:
-        if platform.system() == 'Windows':
-            selected_font = 'Malgun Gothic'
-        elif platform.system() == 'Darwin':  # macOS
-            selected_font = 'AppleGothic'
-        else:  # Linux - 나눔폰트가 없으면 기본 Sans 사용
-            selected_font = 'sans-serif'
-        
-        st.sidebar.warning(f"기본 폰트 '{selected_font}' 사용")
-    
-    # 4. matplotlib 설정 강제 적용
+    # matplotlib rcParams 강제 설정
     plt.rcParams.update({
-        'font.family': selected_font,
-        'font.sans-serif': [selected_font, 'DejaVu Sans', 'Arial'],
+        'font.family': 'sans-serif',
+        'font.sans-serif': [selected_font_name, 'DejaVu Sans', 'Arial', 'sans-serif'],
         'axes.unicode_minus': False,
-        'font.size': 10
+        'font.size': 12,
+        'figure.dpi': 100,
+        'savefig.dpi': 100,
+        'figure.facecolor': 'white',
+        'axes.facecolor': 'white'
     })
     
-    # 5. 폰트 설정 검증
-    test_fig, test_ax = plt.subplots(figsize=(1, 1))
-    test_ax.text(0.5, 0.5, '한글테스트', ha='center', va='center')
-    current_font = test_ax.texts[0].get_fontname()
-    plt.close(test_fig)
-    
-    st.sidebar.text(f"적용된 폰트: {current_font}")
+    # 전역 폰트 속성 객체 생성
+    if selected_font_path:
+        global KOREAN_FONT_PROP
+        KOREAN_FONT_PROP = fm.FontProperties(fname=selected_font_path)
+    else:
+        KOREAN_FONT_PROP = fm.FontProperties(family=selected_font_name)
     
-    return selected_font
+    return selected_font_name, selected_font_path
+
+# 앱 시작 시 즉시 폰트 설정
+FONT_NAME, FONT_PATH = configure_matplotlib_korean()
+KOREAN_FONT_PROP = None
+
+def apply_korean_font_to_plot():
+    """개별 플롯에 한글 폰트 직접 적용"""
+    if FONT_PATH and os.path.exists(FONT_PATH):
+        font_prop = fm.FontProperties(fname=FONT_PATH)
+        return font_prop
+    else:
+        return fm.FontProperties(family=FONT_NAME)
 
 def analyze_scores(df):
     """데이터프레임을 받아 분석 결과를 표시하는 함수"""
-    st.subheader("데이터 미리보기 (상위 5개)")
+    st.subheader("📋 데이터 미리보기 (상위 5개)")
     st.dataframe(df.head())
 
-    # 숫자 형식의 열만 선택지로 제공하여 오류 방지
+    # 숫자 형식의 열만 선택지로 제공
     numeric_columns = df.select_dtypes(include=np.number).columns.tolist()
     if not numeric_columns:
-        st.error("데이터에서 분석 가능한 숫자 형식의 열을 찾을 수 없습니다.")
+        st.error("❌ 데이터에서 분석 가능한 숫자 형식의 열을 찾을 수 없습니다.")
         return
 
-    score_column = st.selectbox("분석할 점수 열(column)을 선택하세요:", numeric_columns)
+    score_column = st.selectbox("📊 분석할 점수 열(column)을 선택하세요:", numeric_columns)
 
     if score_column:
         scores = df[score_column].dropna()
         
-        # 유효한 데이터가 있는지 확인
         if len(scores) == 0:
-            st.error("선택한 열에 유효한 데이터가 없습니다.")
+            st.error("❌ 선택한 열에 유효한 데이터가 없습니다.")
             return
             
-        st.subheader(f"'{score_column}' 점수 분포 분석 결과")
+        st.subheader(f"📈 '{score_column}' 점수 분포 분석 결과")
 
         # 1. 기술 통계량
-        st.write("#### 📈 기술 통계량")
-        st.table(scores.describe())
+        st.write("#### 📊 기본 통계량")
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("평균", f"{scores.mean():.2f}")
+        with col2:
+            st.metric("표준편차", f"{scores.std():.2f}")
+        with col3:
+            st.metric("최솟값", f"{scores.min():.2f}")
+        with col4:
+            st.metric("최댓값", f"{scores.max():.2f}")
+        
+        # 상세 통계
+        st.write("#### 📋 상세 통계량")
+        st.dataframe(scores.describe().to_frame().T)
 
-        # 2. 분포 시각화
+        # 2. 분포 시각화 - 강화된 한글 폰트 적용
         st.write("#### 🎨 점수 분포 시각화")
         
-        # 매번 새로운 figure 생성 시 폰트 설정 재적용
-        plt.rcParams.update({
-            'font.family': plt.rcParams.get('font.family', 'sans-serif'),
-            'axes.unicode_minus': False
-        })
-        
-        fig, ax = plt.subplots(figsize=(12, 7))
-        
         try:
-            # 히스토그램과 KDE 곡선 그리기
-            sns.histplot(scores, kde=True, stat='density', alpha=0.7, ax=ax)
+            # 폰트 속성 객체 생성
+            korean_font = apply_korean_font_to_plot()
+            
+            # Figure 생성 및 설정
+            fig, ax = plt.subplots(figsize=(14, 8))
+            fig.patch.set_facecolor('white')
+            
+            # 히스토그램 생성
+            n, bins, patches = ax.hist(scores, bins=20, density=True, alpha=0.7, 
+                                     color='skyblue', edgecolor='navy', linewidth=0.8)
+            
+            # KDE 곡선 추가
+            try:
+                from scipy.stats import gaussian_kde
+                kde = gaussian_kde(scores)
+                x_range = np.linspace(scores.min(), scores.max(), 200)
+                ax.plot(x_range, kde(x_range), 'orange', linewidth=3, label='실제 분포 곡선')
+            except:
+                pass
             
             # 정규분포 곡선 추가
             mu, std = norm.fit(scores)
-            xmin, xmax = ax.get_xlim()
-            x = np.linspace(xmin, xmax, 100)
-            p = norm.pdf(x, mu, std)
-            ax.plot(x, p, 'r-', linewidth=2, label=f'정규분포 (μ={mu:.1f}, σ={std:.1f})')
+            x_norm = np.linspace(scores.min(), scores.max(), 100)
+            y_norm = norm.pdf(x_norm, mu, std)
+            ax.plot(x_norm, y_norm, 'red', linewidth=2, linestyle='--', 
+                   label=f'정규분포 (평균={mu:.1f}, 표준편차={std:.1f})')
+            
+            # 평균선 추가
+            ax.axvline(mu, color='red', linestyle=':', linewidth=2, alpha=0.8, label=f'평균: {mu:.1f}')
             
-            # 제목과 라벨 설정 (한글 포함)
-            ax.set_title(f'{score_column} 점수 분포 분석', fontsize=16, pad=20)
-            ax.set_xlabel('점수', fontsize=12)
-            ax.set_ylabel('밀도', fontsize=12)
-            ax.legend(fontsize=10)
-            ax.grid(True, alpha=0.3)
+            # 제목과 라벨 - 한글 폰트 직접 적용
+            ax.set_title(f'{score_column} 점수 분포 분석', fontproperties=korean_font, fontsize=18, pad=20)
+            ax.set_xlabel('점수', fontproperties=korean_font, fontsize=14)
+            ax.set_ylabel('밀도', fontproperties=korean_font, fontsize=14)
             
-            # 통계 정보 텍스트 박스 추가
-            stats_text = f'평균: {mu:.2f}\n표준편차: {std:.2f}\n샘플 수: {len(scores)}'
+            # 범례 설정
+            legend = ax.legend(prop=korean_font, fontsize=11, loc='upper right')
+            legend.get_frame().set_alpha(0.9)
+            
+            # 격자 추가
+            ax.grid(True, alpha=0.3, linestyle='-', linewidth=0.5)
+            
+            # 통계 정보 박스
+            stats_text = f'샘플 수: {len(scores)}\n평균: {mu:.2f}\n표준편차: {std:.2f}\n최솟값: {scores.min():.1f}\n최댓값: {scores.max():.1f}'
             ax.text(0.02, 0.98, stats_text, transform=ax.transAxes, 
-                   fontsize=10, verticalalignment='top',
-                   bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))
+                   fontproperties=korean_font, fontsize=10, verticalalignment='top',
+                   bbox=dict(boxstyle='round,pad=0.5', facecolor='lightblue', alpha=0.8))
             
             plt.tight_layout()
             st.pyplot(fig)
             
         except Exception as e:
-            st.error(f"그래프 생성 중 오류 발생: {e}")
-            # 에러 발생 시 간단한 히스토그램으로 대체
+            st.error(f"❌ 상세 그래프 생성 중 오류: {e}")
+            
+            # 대체 그래프 (영어만 사용)
+            st.write("**Alternative Chart (English only):**")
             fig2, ax2 = plt.subplots(figsize=(10, 6))
-            ax2.hist(scores, bins=20, alpha=0.7, edgecolor='black')
-            ax2.set_title('Score Distribution (Fallback)', fontsize=14)
+            ax2.hist(scores, bins=15, alpha=0.7, color='lightcoral', edgecolor='black')
+            ax2.set_title(f'Distribution of {score_column}', fontsize=14)
             ax2.set_xlabel('Score')
             ax2.set_ylabel('Frequency')
+            ax2.grid(True, alpha=0.3)
             st.pyplot(fig2)
             plt.close(fig2)
         finally:
-            plt.close(fig)  # 메모리 누수 방지
+            if 'fig' in locals():
+                plt.close(fig)
 
-        # 3. 왜도(Skewness) 분석
-        st.write("#### 📐 왜도 (Skewness) 분석")
+        # 3. 왜도 분석
+        st.write("#### 📐 분포 형태 분석 (왜도)")
         try:
             skewness = skew(scores)
-            st.metric(label="왜도 (Skewness)", value=f"{skewness:.4f}")
+            col1, col2 = st.columns([1, 2])
+            
+            with col1:
+                st.metric("왜도 (Skewness)", f"{skewness:.4f}")
+            
+            with col2:
+                if skewness > 0.5:
+                    st.success("🔴 **양의 왜도 (Right Skewed)**: 대부분 학생이 낮은 점수대에 분포하고, 소수의 고득점자가 존재합니다.")
+                elif skewness < -0.5:
+                    st.success("🔵 **음의 왜도 (Left Skewed)**: 대부분 학생이 높은 점수대에 분포하고, 소수의 저득점자가 존재합니다.")
+                else:
+                    st.success("🟢 **대칭 분포**: 점수가 평균을 중심으로 고르게 분포되어 있습니다.")
+                    
+        except Exception as e:
+            st.error(f"왜도 계산 중 오류: {e}")
 
-            if skewness > 0.5:
-                st.info("🔴 꼬리가 오른쪽으로 긴 분포 (Positive Skew): 대부분의 학생들이 평균보다 낮은 점수에 몰려있고, 일부 고득점자들이 평균을 높이고 있습니다.")
-            elif skewness < -0.5:
-                st.info("🔵 꼬리가 왼쪽으로 긴 분포 (Negative Skew): 대부분의 학생들이 평균보다 높은 점수에 몰려있고, 일부 저득점자들이 평균을 낮추고 있습니다.")
-            else:
-                st.info("🟢 대칭에 가까운 분포: 점수가 평균을 중심으로 비교적 고르게 분포되어 있습니다.")
+        # 4. 추가 분석
+        st.write("#### 📋 구간별 분포")
+        
+        # 점수 구간 나누기
+        if scores.max() <= 100:  # 100점 만점 가정
+            bins_labels = ['0-60', '61-70', '71-80', '81-90', '91-100']
+            bins_edges = [0, 60, 70, 80, 90, 100]
+        else:
+            # 동적 구간 생성
+            min_score, max_score = scores.min(), scores.max()
+            interval = (max_score - min_score) / 5
+            bins_edges = [min_score + i * interval for i in range(6)]
+            bins_labels = [f'{bins_edges[i]:.0f}-{bins_edges[i+1]:.0f}' for i in range(5)]
+        
+        try:
+            score_counts = pd.cut(scores, bins=bins_edges, labels=bins_labels, include_lowest=True).value_counts().sort_index()
+            score_percentages = (score_counts / len(scores) * 100).round(1)
+            
+            result_df = pd.DataFrame({
+                '구간': score_counts.index,
+                '학생 수': score_counts.values,
+                '비율 (%)': score_percentages.values
+            })
+            st.dataframe(result_df)
+            
         except Exception as e:
-            st.error(f"왜도 계산 중 오류 발생: {e}")
+            st.warning(f"구간 분석 중 오류: {e}")
 
 def main():
     st.set_page_config(
-        page_title="학생 점수 분석",
+        page_title="학생 점수 분석 도구",
         page_icon="📊",
-        layout="wide"
+        layout="wide",
+        initial_sidebar_state="expanded"
     )
     
-    # 폰트 설정을 먼저 실행하고 설정된 폰트명 받기
-    selected_font = set_korean_font()
-    
-    st.title("학생 점수 분포 분석 도구 📊")
-    st.write("CSV 파일을 직접 업로드하거나 Google Sheets URL을 붙여넣어 학생 점수 분포를 분석합니다.")
+    # 제목
+    st.title("📊 학생 점수 분포 분석 도구")
+    st.markdown("**CSV 파일을 업로드하거나 Google Sheets URL을 입력하여 점수 분포를 분석하세요**")
     
-    # 폰트 테스트 (디버깅용)
-    if st.sidebar.checkbox("폰트 테스트 보기"):
-        test_fig, test_ax = plt.subplots(figsize=(8, 4))
-        test_ax.text(0.5, 0.7, f'한글 폰트 테스트: {selected_font}', 
-                    ha='center', va='center', fontsize=14)
-        test_ax.text(0.5, 0.5, '가나다라마바사 ABCD 1234', 
-                    ha='center', va='center', fontsize=12)
-        test_ax.text(0.5, 0.3, '점수, 분포, 분석, 그래프', 
-                    ha='center', va='center', fontsize=12)
-        test_ax.set_xlim(0, 1)
-        test_ax.set_ylim(0, 1)
-        test_ax.axis('off')
-        st.pyplot(test_fig)
-        plt.close(test_fig)
+    # 폰트 정보 표시
+    with st.expander("🔧 폰트 설정 정보"):
+        st.write(f"**현재 폰트**: {FONT_NAME}")
+        st.write(f"**폰트 경로**: {FONT_PATH if FONT_PATH else '시스템 기본'}")
+        
+        # 폰트 테스트
+        if st.button("폰트 테스트"):
+            try:
+                test_fig, test_ax = plt.subplots(figsize=(8, 3))
+                korean_font = apply_korean_font_to_plot()
+                test_ax.text(0.5, 0.7, '한글 폰트 테스트', ha='center', va='center', 
+                           fontproperties=korean_font, fontsize=16)
+                test_ax.text(0.5, 0.3, '점수 분포 분석 그래프', ha='center', va='center', 
+                           fontproperties=korean_font, fontsize=14)
+                test_ax.set_xlim(0, 1)
+                test_ax.set_ylim(0, 1)
+                test_ax.axis('off')
+                st.pyplot(test_fig)
+                plt.close(test_fig)
+            except Exception as e:
+                st.error(f"폰트 테스트 실패: {e}")
     
-    st.write("---")
+    st.markdown("---")
 
+    # 사이드바 - 데이터 입력
     st.sidebar.title("📁 데이터 가져오기")
     source_option = st.sidebar.radio(
-        "데이터 소스를 선택하세요:", 
-        ("CSV 파일 업로드", "Google Sheets URL")
+        "데이터 소스 선택:", 
+        ("📤 CSV 파일 업로드", "🔗 Google Sheets URL", "🎲 샘플 데이터")
     )
     
     df = None
 
-    if source_option == "CSV 파일 업로드":
+    if source_option == "📤 CSV 파일 업로드":
         uploaded_file = st.sidebar.file_uploader(
-            "CSV 파일을 업로드하세요.", 
+            "CSV 파일을 선택하세요", 
             type=["csv"],
-            help="UTF-8 또는 CP949 인코딩된 CSV 파일을 선택하세요."
+            help="UTF-8, CP949 등 다양한 인코딩을 자동으로 감지합니다"
         )
         if uploaded_file:
-            try:
-                # 여러 인코딩 방식으로 시도
-                encodings = ['utf-8-sig', 'utf-8', 'cp949', 'euc-kr']
-                for encoding in encodings:
-                    try:
-                        df = pd.read_csv(uploaded_file, encoding=encoding)
-                        st.sidebar.success(f"파일 읽기 성공! (인코딩: {encoding})")
-                        break
-                    except UnicodeDecodeError:
-                        continue
-                
-                if df is None:
-                    st.error("파일 인코딩을 인식할 수 없습니다. UTF-8 또는 CP949로 저장된 파일을 사용해주세요.")
-                    
-            except Exception as e:
-                st.error(f"파일을 읽는 중 오류가 발생했습니다: {e}")
+            encodings = ['utf-8-sig', 'utf-8', 'cp949', 'euc-kr', 'latin1']
+            for encoding in encodings:
+                try:
+                    df = pd.read_csv(uploaded_file, encoding=encoding)
+                    st.sidebar.success(f"✅ 파일 로딩 성공! (인코딩: {encoding})")
+                    break
+                except UnicodeDecodeError:
+                    continue
+                except Exception as e:
+                    st.sidebar.error(f"파일 읽기 오류: {e}")
+                    break
+            
+            if df is None:
+                st.sidebar.error("❌ 파일 인코딩을 인식할 수 없습니다.")
 
-    elif source_option == "Google Sheets URL":
-        st.sidebar.info("Google Sheets를 '웹에 게시'하고 CSV 형식의 URL을 입력하세요.")
-        sample_url = "https://docs.google.com/spreadsheets/d/e/2PACX-1vQ2Z8kzJq2sM7w2_9gXo-jZ-mO5o-BvC-w5p2nJ6oJ7oJ9xL-w3kZ9j5Z3kX7vN1aQ4mB1cW8jB7fR/pub?gid=0&single=true&output=csv"
+    elif source_option == "🔗 Google Sheets URL":
+        st.sidebar.info("💡 Google Sheets를 '웹에 게시'한 후 CSV URL을 입력하세요")
         url = st.sidebar.text_input(
             "Google Sheets CSV URL", 
-            value="",
             placeholder="https://docs.google.com/spreadsheets/d/..."
         )
         
-        if url:
-            if "docs.google.com" not in url:
-                st.sidebar.warning("올바른 Google Sheets URL인지 확인해주세요.")
-            else:
-                try:
-                    with st.spinner("데이터를 불러오는 중..."):
-                        df = pd.read_csv(url)
-                    st.sidebar.success("Google Sheets 데이터 로딩 성공!")
-                except Exception as e:
-                    st.error(f"URL로부터 데이터를 읽는 중 오류가 발생했습니다: {e}")
-                    st.warning("올바른 Google Sheets '웹 게시' CSV URL인지 확인해주세요.")
+        if url and "docs.google.com" in url:
+            try:
+                with st.spinner("📥 데이터 로딩 중..."):
+                    df = pd.read_csv(url)
+                st.sidebar.success("✅ Google Sheets 로딩 성공!")
+            except Exception as e:
+                st.sidebar.error(f"❌ URL 로딩 실패: {e}")
+        elif url:
+            st.sidebar.warning("⚠️ 올바른 Google Sheets URL을 입력하세요")
 
-    # 데이터가 성공적으로 로드된 경우에만 분석 함수 실행
+    elif source_option == "🎲 샘플 데이터":
+        if st.sidebar.button("샘플 데이터 생성"):
+            np.random.seed(42)
+            sample_size = st.sidebar.slider("샘플 크기", 50, 500, 100)
+            
+            df = pd.DataFrame({
+                '학생번호': range(1, sample_size + 1),
+                '수학점수': np.random.normal(75, 15, sample_size).clip(0, 100).round(1),
+                '영어점수': np.random.normal(80, 12, sample_size).clip(0, 100).round(1),
+                '과학점수': np.random.normal(70, 18, sample_size).clip(0, 100).round(1),
+                '국어점수': np.random.normal(77, 14, sample_size).clip(0, 100).round(1)
+            })
+            st.sidebar.success(f"✅ {sample_size}명의 샘플 데이터 생성!")
+
+    # 메인 분석
     if df is not None and not df.empty:
-        st.success(f"데이터 로딩 완료! (행: {len(df)}, 열: {len(df.columns)})")
+        st.success(f"🎉 데이터 로딩 완료! **{len(df)}개 행, {len(df.columns)}개 열**")
         analyze_scores(df)
     else:
-        st.info("👈 사이드바에서 데이터 소스를 선택하고 데이터를 불러와주세요.")
+        st.info("👈 **사이드바에서 데이터를 선택하세요**")
         
-        # 샘플 데이터 생성 버튼
-        if st.button("🎲 샘플 데이터로 테스트"):
-            np.random.seed(42)
-            sample_data = {
-                '학생번호': range(1, 101),
-                '수학점수': np.random.normal(75, 15, 100).clip(0, 100).round(1),
-                '영어점수': np.random.normal(80, 12, 100).clip(0, 100).round(1),
-                '과학점수': np.random.normal(70, 18, 100).clip(0, 100).round(1)
-            }
-            df = pd.DataFrame(sample_data)
-            st.success("샘플 데이터가 생성되었습니다!")
-            analyze_scores(df)
+        # 기능 안내
+        st.markdown("""
+        ### 🔍 주요 기능
+        - **📊 기본 통계**: 평균, 표준편차, 최솟값, 최댓값 등
+        - **📈 분포 시각화**: 히스토그램, KDE 곡선, 정규분포 비교
+        - **📐 왜도 분석**: 분포의 비대칭성 측정
+        - **📋 구간별 분포**: 점수 구간별 학생 수 및 비율
+        
+        ### 📝 지원 형식
+        - **CSV 파일**: UTF-8, CP949, EUC-KR 등 자동 인코딩 감지
+        - **Google Sheets**: 웹에 게시된 시트의 CSV URL
+        - **샘플 데이터**: 테스트용 가상 점수 데이터
+        """)
 
 if __name__ == '__main__':
     main()