import numpy as np

# 배열 생성
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 특수 배열 생성
zeros = np.zeros((3, 4))      # 0으로 채워진 3x4 배열
ones = np.ones((2, 3))        # 1로 채워진 2x3 배열
rng = np.arange(0, 10, 0.5)   # 0부터 10까지 0.5 간격 배열
linsp = np.linspace(0, 1, 5)  # 0부터 1까지 5개 균등 분할 배열
rand = np.random.random((2, 2))  # 0~1 사이 난수 2x2 배열

# 배열 연산 (요소별)
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)         # [5, 7, 9]
print(a * b)         # [4, 10, 18]
print(a ** 2)        # [1, 4, 9]
print(np.sin(a))     # 사인 함수 적용

# 행렬 연산
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(np.dot(a, b))  # 행렬 곱
print(a @ b)         # 행렬 곱 (Python 3.5+)
print(np.linalg.inv(a))  # 역행렬
print(np.linalg.det(a))  # 행렬식

# 통계 함수
data = np.array([1, 2, 3, 4, 5])
print(np.mean(data))    # 평균
print(np.median(data))  # 중앙값
print(np.std(data))     # 표준편차
print(np.var(data))     # 분산
print(np.max(data))     # 최댓값
print(np.min(data))     # 최솟값
print(np.sum(data))     # 합계

# 차원 조작
arr = np.array([1, 2, 3, 4, 5, 6])
arr_reshaped = arr.reshape(2, 3)  # 2x3 행렬로 재구성
arr_transposed = arr_reshaped.T  # 전치

import pandas as pd
import numpy as np

# Series 생성 (1차원 데이터)
s = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s)

# DataFrame 생성 (2차원 데이터)
dates = pd.date_range('20230101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
print(df)

# 딕셔너리로부터 DataFrame 생성
data = {
    '이름': ['김철수', '이영희', '박지민'],
    '나이': [25, 28, 22],
    '성별': ['남', '여', '남']
}
df = pd.DataFrame(data)
print(df)

# 파일 읽고 쓰기
# df.to_csv('data.csv')                   # CSV 파일로 저장
# df.to_excel('data.xlsx', sheet_name='Sheet1')  # Excel 파일로 저장
# csv_df = pd.read_csv('data.csv')        # CSV 파일 읽기
# excel_df = pd.read_excel('data.xlsx')   # Excel 파일 읽기

# 데이터 조회
print(df.head(2))      # 처음 2행
print(df.tail(2))      # 마지막 2행
print(df['이름'])      # 특정 열 선택
print(df[0:2])         # 행 슬라이싱
print(df.loc[0])       # 특정 행 선택 (레이블 기준)
print(df.iloc[1:3, 0:2])  # 행/열 슬라이싱 (위치 기준)

# 데이터 필터링
print(df[df['나이'] > 25])    # 조건에 맞는 행 선택
print(df[(df['나이'] > 22) & (df['성별'] == '남')])  # 복합 조건

# 데이터 처리
df['출생년도'] = 2023 - df['나이']  # 새 열 추가
df = df.drop(columns=['출생년도'])  # 열 삭제
df = df.rename(columns={'나이': '연령'})  # 열 이름 변경
df['연령'] = df['연령'] + 1   # 값 수정

# 그룹화 및 집계
grouped = df.groupby('성별')
print(grouped['연령'].mean())   # 성별 기준 평균 연령
print(grouped.size())           # 성별 기준 개수

# 결측치 처리
df_with_na = df.copy()
df_with_na.loc[1, '연령'] = None
print(df_with_na.isna().sum())   # 열별 결측치 개수
df_filled = df_with_na.fillna(0)  # 결측치 0으로 채우기
df_dropped = df_with_na.dropna()  # 결측치 있는 행 삭제

import matplotlib.pyplot as plt
import numpy as np

# 기본 선 그래프
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(10, 6))
plt.plot(x, y, label='sin(x)')
plt.title('사인 함수 그래프')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.grid(True)
plt.legend()
# plt.savefig('sin_graph.png')  # 이미지로 저장
# plt.show()

# 여러 그래프 그리기
plt.figure(figsize=(10, 6))
plt.plot(x, np.sin(x), 'b-', label='sin(x)')  # 파란색 실선
plt.plot(x, np.cos(x), 'r--', label='cos(x)')  # 빨간색 점선
plt.title('삼각함수 그래프')
plt.legend()
# plt.show()

# 서브플롯 (여러 그래프 배치)
plt.figure(figsize=(12, 8))

plt.subplot(2, 2, 1)  # 2x2 그리드의 첫 번째
plt.plot(x, np.sin(x))
plt.title('sin(x)')

plt.subplot(2, 2, 2)  # 2x2 그리드의 두 번째
plt.plot(x, np.cos(x))
plt.title('cos(x)')

plt.subplot(2, 2, 3)  # 2x2 그리드의 세 번째
plt.plot(x, np.sin(2*x))
plt.title('sin(2x)')

plt.subplot(2, 2, 4)  # 2x2 그리드의 네 번째
plt.plot(x, np.cos(2*x))
plt.title('cos(2x)')

plt.tight_layout()  # 레이아웃 자동 조정
# plt.show()

# 다양한 차트 유형
plt.figure(figsize=(15, 10))

# 막대 그래프
plt.subplot(2, 3, 1)
categories = ['A', 'B', 'C', 'D']
values = [3, 7, 2, 5]
plt.bar(categories, values)
plt.title('막대 그래프')

# 수평 막대 그래프
plt.subplot(2, 3, 2)
plt.barh(categories, values)
plt.title('수평 막대 그래프')

# 산점도
plt.subplot(2, 3, 3)
x = np.random.rand(50)
y = np.random.rand(50)
colors = np.random.rand(50)
sizes = 1000 * np.random.rand(50)
plt.scatter(x, y, c=colors, s=sizes, alpha=0.5)
plt.title('산점도')

# 히스토그램
plt.subplot(2, 3, 4)
data = np.random.randn(1000)
plt.hist(data, bins=30)
plt.title('히스토그램')

# 파이 차트
plt.subplot(2, 3, 5)
plt.pie(values, labels=categories, autopct='%1.1f%%')
plt.title('파이 차트')

# 박스 플롯
plt.subplot(2, 3, 6)
data = [np.random.normal(0, std, 100) for std in range(1, 5)]
plt.boxplot(data)
plt.title('박스 플롯')

plt.tight_layout()
# plt.show()

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# 테마 설정
sns.set_theme(style="whitegrid")  # 스타일 설정

# 샘플 데이터 생성
tips = sns.load_dataset('tips')  # seaborn 내장 데이터
iris = sns.load_dataset('iris')  # 다른 내장 데이터

# 기본 그래프
plt.figure(figsize=(15, 10))

# 막대 그래프 (카운트플롯)
plt.subplot(2, 3, 1)
sns.countplot(x='day', data=tips)
plt.title('요일별 손님 수')

# 산점도 (스캐터플롯)
plt.subplot(2, 3, 2)
sns.scatterplot(x='total_bill', y='tip', hue='time', data=tips)
plt.title('계산서와 팁의 관계')

# 회귀선 포함 산점도
plt.subplot(2, 3, 3)
sns.regplot(x='total_bill', y='tip', data=tips)
plt.title('회귀선 포함 산점도')

# 다변량 산점도 매트릭스
plt.figure(figsize=(10, 8))
sns.pairplot(iris, hue='species')
plt.suptitle('붓꽃 데이터 다변량 분석', y=1.02)
# plt.show()

# 히트맵
plt.figure(figsize=(10, 8))
corr = iris.drop('species', axis=1).corr()
sns.heatmap(corr, annot=True, cmap='coolwarm')
plt.title('상관관계 히트맵')
# plt.show()

# 바이올린 플롯
plt.figure(figsize=(12, 6))
sns.violinplot(x='day', y='total_bill', hue='sex', data=tips, split=True)
plt.title('요일별 계산서 금액 분포 (성별 구분)')
# plt.show()

# 분포도 플롯
plt.figure(figsize=(12, 6))
sns.kdeplot(data=tips, x='total_bill', hue='time', fill=True, common_norm=False)
plt.title('시간대별 계산서 금액 분포')
# plt.show()

from faker import Faker

# 다양한 언어 지원
fake_ko = Faker('ko_KR')    # 한국어
fake_en = Faker('en_US')    # 영어(미국)
fake_jp = Faker('ja_JP')    # 일본어

# 시드 설정 (재현 가능한 데이터)
Faker.seed(1234)
fake = Faker('ko_KR')

# 개인 정보 생성
print(fake.name())           # 이름
print(fake.address())        # 주소
print(fake.postcode())       # 우편번호
print(fake.phone_number())   # 전화번호
print(fake.email())          # 이메일
print(fake.company())        # 회사명
print(fake.job())            # 직업

# 인터넷 관련 데이터
print(fake.user_name())      # 사용자 이름
print(fake.password())       # 비밀번호
print(fake.ipv4())           # IPv4 주소
print(fake.url())            # URL
print(fake.user_agent())     # 사용자 에이전트

# 날짜/시간 데이터
print(fake.date_of_birth(minimum_age=20, maximum_age=80))  # 생년월일
print(fake.date_this_decade())       # 이번 10년 내 날짜
print(fake.future_date())            # 미래 날짜
print(fake.time())                   # 시간

# 텍스트 데이터
print(fake.text(max_nb_chars=200))   # 텍스트 생성
print(fake.paragraph())              # 문단 생성
print(fake.sentence())               # 문장 생성

# 커스텀 데이터 생성기
from faker.providers import BaseProvider

class MyProvider(BaseProvider):
    def korean_food(self):
        foods = ['김치찌개', '된장찌개', '비빔밥', '불고기', '김밥', '떡볶이', '삼겹살']
        return self.random_element(foods)

# 프로바이더 추가
fake.add_provider(MyProvider)
print(fake.korean_food())

# 대량 데이터 생성 예제
users = [
    {
        'id': i,
        'name': fake.name(),
        'email': fake.email(),
        'address': fake.address(),
        'phone': fake.phone_number(),
        'join_date': fake.date_this_year()
    }
    for i in range(1, 51)  # 50명 데이터 생성
]

import sympy as sp

# 기본 대수 연산
x, y, z = sp.symbols('x y z')  # 기호 변수 정의
expr = x**2 + 2*x*y + y**2
print(expr)

# 식 전개 및 인수분해
expanded = sp.expand((x + y)**3)
print(expanded)
factored = sp.factor(x**3 - y**3)
print(factored)

# 방정식 풀기
eq1 = sp.Eq(x**2, 4)  # x^2 = 4
solution = sp.solve(eq1, x)
print(solution)  # [-2, 2]

# 연립방정식
eq1 = sp.Eq(x + y, 6)
eq2 = sp.Eq(x - y, 4)
solution = sp.solve((eq1, eq2), (x, y))
print(solution)  # {x: 5, y: 1}

# 행렬 연산
A = sp.Matrix([[1, 2], [3, 4]])
B = sp.Matrix([[5, 6], [7, 8]])
print(A + B)  # 행렬 덧셈
print(A * B)  # 행렬 곱셈
print(A.det())  # 행렬식
print(A.inv())  # 역행렬
print(A.eigenvals())  # 고유값

# 미분
f = x**3 + 2*x**2 - 5*x + 3
derivative = sp.diff(f, x)
print(derivative)  # 3*x^2 + 4*x - 5

# 부분 미분
f_multi = x**2 * y + y**2 * z
df_dx = sp.diff(f_multi, x)
df_dy = sp.diff(f_multi, y)
print(df_dx)  # 2*x*y
print(df_dy)  # x^2 + 2*y*z

# 적분
integral = sp.integrate(x**2, x)
print(integral)  # x^3/3

# 정적분
def_integral = sp.integrate(x**2, (x, 0, 1))
print(def_integral)  # 1/3

# 극한
limit_expr = sp.limit((sp.sin(x))/x, x, 0)
print(limit_expr)  # 1

# 급수 전개
series = sp.series(sp.exp(x), x, 0, 5)
print(series)  # 테일러 급수 전개

# 라플라스 변환
t = sp.symbols('t', positive=True)
s = sp.symbols('s')
f_t = t**2
F_s = sp.laplace_transform(f_t, t, s)
print(F_s)  # (2/s^3, s, True)

# 미분방정식 풀기
f = sp.Function('f')
diffeq = sp.Eq(f(x).diff(x, 2) + f(x), 0)
solution = sp.dsolve(diffeq, f(x))
print(solution)

import requests

# 기본 GET 요청
response = requests.get('https://api.github.com/events')
print(response.status_code)    # 상태 코드 (200, 404 등)
print(response.headers)        # 응답 헤더
print(response.encoding)       # 인코딩
print(response.text[:100])     # 응답 내용 (처음 100자)
print(response.json())         # JSON 응답 파싱

# URL 쿼리 파라미터
params = {'q': 'python', 'sort': 'stars'}
response = requests.get('https://api.github.com/search/repositories', params=params)
print(response.url)  # 최종 URL 출력

# 커스텀 헤더
headers = {'User-Agent': 'my-app/0.0.1'}
response = requests.get('https://api.github.com/user', headers=headers)

# POST 요청
data = {'username': 'user', 'password': 'pass'}
response = requests.post('https://httpbin.org/post', data=data)

# JSON POST 요청
json_data = {'name': 'user', 'repos': ['repo1', 'repo2']}
response = requests.post('https://httpbin.org/post', json=json_data)

# 파일 업로드
# files = {'file': open('report.pdf', 'rb')}
# response = requests.post('https://httpbin.org/post', files=files)

# 세션 사용 (쿠키 유지)
session = requests.Session()
session.get('https://httpbin.org/cookies/set/sessioncookie/123456789')
response = session.get('https://httpbin.org/cookies')
print(response.json())

# 타임아웃 설정
try:
    response = requests.get('https://httpbin.org/delay/5', timeout=3)
except requests.exceptions.Timeout:
    print("요청이 타임아웃되었습니다.")

# 에러 처리
try:
    response = requests.get('https://httpbin.org/status/500')
    response.raise_for_status()  # 4XX, 5XX 에러 시 예외 발생
except requests.exceptions.HTTPError as err:
    print(f"HTTP 에러 발생: {err}")

from flask import Flask, request, jsonify, render_template, redirect, url_for

# 애플리케이션 생성
app = Flask(__name__)

# 기본 라우트
@app.route('/')
def home():
    return 'Hello, Flask!'

# 변수가 있는 라우트
@app.route('/user/<username>')
def show_user(username):
    return f'User: {username}'

# 타입 변환 (정수)
@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f'Post ID: {post_id}'

# 여러 HTTP 메서드 처리
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form.get('username')
        password = request.form.get('password')
        # 로그인 로직 처리
        return f'로그인 시도: {username}'
    else:
        return '''
            <form method="post">
                <input type="text" name="username">
                <input type="password" name="password">
                <input type="submit" value="Login">
            </form>
        '''

# JSON 응답
@app.route('/api/data')
def get_data():
    data = {
        'name': 'John',
        'age': 30,
        'items': ['item1', 'item2']
    }
    return jsonify(data)

# 쿼리 파라미터
@app.route('/search')
def search():
    query = request.args.get('q', '')
    return f'검색어: {query}'

# 템플릿 렌더링
@app.route('/hello/<name>')
def hello(name):
    # 실제로는 templates/hello.html 파일 필요
    # return render_template('hello.html', name=name)
    return f'<h1>Hello, {name}!</h1>'

# 리다이렉션
@app.route('/redirect')
def redirect_example():
    return redirect(url_for('home'))

# 에러 핸들러
@app.errorhandler(404)
def page_not_found(e):
    return '404 - 페이지를 찾을 수 없습니다', 404

# 애플리케이션 실행
if __name__ == '__main__':
    # app.run(debug=True)
    pass  # 실제 실행을 막기 위해 pass 사용

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# 데이터셋 로드
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)

# 데이터 전처리 (스케일링)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 모델 초기화
models = {
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(),
    'SVM': SVC()
}

# 모델 학습 및 평가
results = {}
for name, model in models.items():
    # 모델 학습
    model.fit(X_train_scaled, y_train)
    
    # 예측
    y_pred = model.predict(X_test_scaled)
    
    # 평가
    accuracy = accuracy_score(y_test, y_pred)
    report = classification_report(y_test, y_pred)
    
    results[name] = {
        'accuracy': accuracy,
        'report': report
    }
    
    print(f"모델: {name}")
    print(f"정확도: {accuracy:.4f}")
    print(f"분류 보고서:\n{report}\n")

# 비지도 학습 예제 - K-means 클러스터링
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)

# 차원 축소 - PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 시각화 (클러스터링 결과)
plt.figure(figsize=(12, 5))

# 실제 클래스
plt.subplot(1, 2, 1)
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.title('실제 클래스')

# K-means 클러스터
plt.subplot(1, 2, 2)
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=clusters, cmap='viridis')
plt.title('K-means 클러스터링')

# plt.savefig('clustering.png')
# plt.show()