이중차분법

광고 캠페인, 가격 인하, 리브랜딩 등 특정 마케팅 개입이 실제로 매출이나 고객 행동에 어떤 영향을 미쳤는지 평가할 때 유용한 분석 기법

마케팅에서 이중차분법이 필요한 이유

• 단순히 캠페인 전후의 매출 변화만 보면, 시장 트렌드나 계절 요인 등의 외부 요인까지 포함되어 있음.
• 이중차분법은 '통제집단'을 기준선으로 삼아, 외부요인을 제거하고 순수한 마케팅 효과만 추정할 수 있도록 도와줌.

*지역별 광고 캠페인 효과 분석 *

✅상황: 한 식음료 브랜드가 서울에서만 TV 광고 캠페인을 시작함. 캠페인을 하지 않은 부산과 캠페인을 한 서울의 광고 전후 매출 데이터를 비교해 광고 효과를 추정해보고 싶음.

✅분석과정

1. 처리집단의 변화: 서울은 광고 후 +500만원 증가
2. 통제집단의 변화: 부산도 +200만원 증가 (광고를 하지 않았는데도)
3. 이중차분법 추정치: (1500-1000) - (1100-900) = 500-200 = +300만원

-> 순수하게 광고 캠페인으로 생긴 매출 증가는 300만원으로 추정 통제집단이 있으면, 마케팅 효과를 더 과학적으로 분석 가능

통제집단 선정 기준

• 통제집단은 가급적 유사한 특정을 가진 집단이어야 함
• 캠페인 전 트렌드가 유사해야 이중차분법이 유효함
• 데이터를 시각화해서 먼저 평행 추세 여부를 확인하는 것이 좋음

예시 코드

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

# 3개월간 수집한 매출 데이터
np.random.seed(42)
campaign_before = np.random.normal(100, 8, 20)  # 서울 캠페인 전
campaign_after = np.random.normal(115, 8, 20)   # 서울 캠페인 후
control_before = np.random.normal(95, 8, 20)    # 부산 캠페인 전
control_after = np.random.normal(100, 8, 20)    # 부산 캠페인 후

data = pd.DataFrame({
    'region':['Seoul']*40 + ['Busan']*40,
    'time': ['before']*20 + ['after']*20 + ['before']*20 + ['after']*20,
    'sales': np.concatenate([campaign_before, campaign_after, control_before, control_after])
})

# 시각화 그래프
avg_data = data.groupby(['region', 'time'])['sales].mean().reset_index()

plt.figure(figsize=(10, 6))
sns.lineplot(data=avg_data, x='time', y='sales', hue='region', marker='o', linewidth=3, markersize=10)
plt.title('에코프레시 캠페인 전후 매출 변화')
plt.xlabel('시점')
plt.ylabel('매출 (만원)')
plt.legend(title='지역')
plt.show()

평행 추세 가정이 시각적으로는 대체로 만족되는 것으로 보임

# CEO 앞에서 실시간 계산
means = data.groupby(['region', 'time'])['sales'].mean()
print("그룹별 평균 매출:")
print(means)

# DID 계산 - 핵심 순간
campaign_before = means['Seoul', 'before']
campaign_after = means['Seoul', 'after']
control_before = means['Busan', 'before']
control_after = means['Busan', 'after']

diff_campaign = campaign_after - campaign_before
diff_control = control_after - control_before
did_effect = diff_campaign - diff_control

print(f"\n서울 지역 변화: {diff_campaign:.2f}만원")
print(f"부산 지역 변화: {diff_control:.2f}만원")
print(f"DID 효과: {did_effect:.2f}만원")

• 서울 지역 변화량: 112.87−98.63=14.24만원
• 부산 지역 변화량: 99.75−94.79=4.96만원
• 이중차분 효과: (서울 변화)−(부산 변화)=14.24−4.96=9.28만원

• 광고 캠페인 또는 마케팅 개입의 순수한 효과로 해석되는 부분이 9.28만원

*즉, 외부 요인(계절, 전반적 시장 성장 등)을 통제한 순수한 마케팅 효과는 약 9.28만 원이라고 판단 *

AB 테스트란?

• 두 가지 버전(A와 B)을 비교하여 어떤 것이 더 효과적인지를 판단하는 실험 방법

• 예를 들어, 기존 버전에서는 "지금 구매하세요!"라는 광고 문구를 넣고 실험 버전에서는 "오늘 한정 할인!"이라는 광고 문구를 삽입한다. 두 가지 버전 중 어떤 문구에서 클릭률이 높을지 확인하는 것이 AB 테스트이다.

*AB 테스트의 절차 *

1. 가설 수립: “오늘 한정 할인! 이라는 문구에서 클릭률이 높을 것이다.”

2. 테스트 설계: 사용자 집단을 무작위로 나누기

3. 실험 수행: 일정 기간 동안 데이터 수집

4. 분석: 통계적으로 유의미한 차이 있는지 확인

5. 결정: 승자 선택 → 적용

A/B 테스트로 할 수 있는 분석

1. 그룹 간 전환율 비교

• Control 그룹과 Treatment 그룹의 평균 전환율 차이를 비교한다.
• B 그룹의 성과가 더 좋다면, 해당 변경을 정식 도입할 수 있다.

2. 시간 흐름에 따른 변화 분석

• 날짜별 전환율 추이나 적응 곡선을 확인한다.
• A 그룹은 시간이 지나도 꾸준한 성과 유지 / 시간이 지나면서 B 그룹의 전환율이 점점 상승한다.

3. 세그먼트 분석

• 나이, 지역, 디바이스 종류 등 사용자 속성에 따른 실험 효과의 차이를 분석한다.
• 20대에겐 B가 더 효과적, 40대에겐 A가 더 나은 결과가 나온다.

4. 이상치 및 데이터 정합성 확인

• 데이터 오류나 이상치를 찾아낸다.
• Control 그룹인데 신버전 페이지를 본 경우? / 특정 날짜에 전환율이 비정상적으로 급등한 경우?

5. 통계적 유의성 검정

• 실험 결과가 우연이 아닌지를 통계적으로 검증한다.
• z-test: 전환율처럼 비율 비교에 사용
• t-test: 체류 시간이나 구매액 등 평균값 비교에 사용

A/B 테스트 설계 시 고려할 점

1. 무작위 할당

   • 실험군(Treatment)과 대조군(Control)에 랜덤하게 할당해야 한다.

2. 통제 변수 설정

• 실험 외적인 변수(시간대, 브라우저, 캠페인 등)가 결과에 영향을 주지 않도록 조건을 통일하거나 분석 시 통제 변수로 포함시킨다.

3. 충분한 표본 크기 확보

• 너무 적은 사용자로 실험하면 우연에 의한 결과일 가능성이 높다.

4. 지표의 명확한 정의

• 환율, 클릭률, 이탈률, 체류 시간 등 핵심 성과지표(KPI)를 실험 전에 명확히 정해둔다.

5. 실험 기간 설정

• 짧은 기간에는 특정 요일/시간대/이벤트의 영향을 받을 수 있어 대표성이 떨어질 수 있다.

A/B 테스트에서 통계적 유의미성을 도출하는 과정

1. 귀무가설과 대립가설 수립

• 귀무가설(H₀): A와 B 간에 차이가 없다.
• 대립가설(H₁): A와 B 간에 차이가 있다.

2. 적절한 통계 검정 선택

• 측정하려는 지표의 특성에 따라 적절한 검정을 선택한다.
• 전환율 비교: z-test / 평균값 비교: t-test

3. p-value 계산

• p-value는 “귀무가설이 맞다고 가정했을 때, 관측된 결과가 나타날 확률”을 의미한다.
• 일반적으로 p-value < 0.05이면, 귀무가설을 기각하고 “차이가 있다”고 판단한다.

4. 신뢰수준(Confidence Level) 설정

• 보통 95% 신뢰수준을 사용한다. 오차 가능성이 5% 미만이라는 의미이다

5. 효과 크기 (Effect Size)도 함께 고려

• 효과크기는 두 그룹 간 차이의 크기를 나타내는 지표이다.
• 통계적으로 유의미한 차이(p < 0.05)라도 실제로는 미미한 차이일 수 있다. (예: 샘플 수가 너무 많아서) 따라서, "그 차이가 실제로 의미 있는 크기인가?"도 함께 판단해야 한다.

6. 파워 분석(Power Analysis)으로 검정력 확인 (사후 분석 시)

• 실험에서 진짜 차이가 있을 때, 그걸 감지할 수 있는 확률
• 파워가 낮으면 → 실험 결과가 "유의미하지 않다"고 나왔어도 그건 “진짜 효과가 없어서”가 아니라 “검출할 능력이 부족해서” 일 수 있다. (예: 샘플 개수의 부족)
• 실험을 잘 설계하려면 얼마나 많은 샘플이 필요한지 미리 계산해야 한다. (사전 파워 분석)

PV, UV

1. PV (Page View): 웹사이트의 특정 페이지가 사용자에게 열람된 횟수

• 페이지별 관심도 측정
• 사용자가 어떤 페이지에 머무는지 파악 가능

2. UV (Unique Visitor): 웹사이트를 방문한 고유 사용자 수

• 같은 사용자가 여러 번 방문해도 1명으로 카운트
• 실질적으로 몇 명의 고객이 내 사이트에 관심을 가졌는지 보여줌

3. UV/PV 증가 및 감소의 의미

• UV, PV 모두 증가 (인기 상승)
  • 유지 + 강화 전략 필요
• UV감소, PV 증가 (충성고객 중심)
  • 재유입 유도 + 핵심 사용자 강화
• UV증가, PV 감소 (대충보고 떠남)
  • 콘텐츠 품질/관심 유도 필요
    • UV, PV 모두 감소 (관심 하락)
  • 전면적 점검 필요

ARPU와 ARPPU 구하기

1. ARPU (Average Revenue Per User)

• 사용자당 평균 수익
• 전체 매출 / 전체 유저 수

2. ARPPU (Average Revenue Per Paying User)

• 유료 결제 사용자당 평균 수익
• 전체 매출 / 유료 결제 사용자 수

-- ARPU와 ARPPU 구하기
SELECT SUM(revenue) / SUM(user_id) AS ARPU,
SUM(revenue) / SUM(CASE WHEN revenue != 0 THEN user_id ELSE 0 END) AS ARPPU
FROM 테이블명 

퍼널 분석

• 사용자 행동 흐름을 단계별로 추적해서 어디서 이탈하는지, 어디서 전환되는지 파악하는 방법

WITH funnel_count AS(
  SELECT
    COUNT(DISTINCT CASE WHEN action='visit' THEN user_id END) AS visit,
    COUNT(DISTINCT CASE WHEN action='signup' THEN user_id END) AS signup,
    COUNT(DISTINCT CASE WHEN action='add_to_cart' THEN user_id END) AS add_to_cart,
    COUNT(DISTINCT CASE WHEN action='purchase' THEN user_id END) AS purchase
  FROM hardy-aleph-464902-v8.modulabs.funnel
)
SELECT visit,
       signup,
       add_to_cart,
       purchase,
       ROUND(signup/visit *100,2) AS SignupRate,
       ROUND(add_to_cart/visit *100,2) AS AddToCartRate,
       ROUND(purchase/visit *100,2) AS PurchaseRate
FROM funnel_count

*리텐션 분석 *

• 내 서비스나 앱에 유입된 사용자가 일정 기간 후에도 얼마나 다시 돌아오는지를 측정
• 신규 유저 유입만 되고 바로 떠나면 성장 지속이 어려움
• 유지율이 높아야 마케팅 비용이 효율적

1. Classic Retention

   • 특정 기준일에 다시 돌아오는 비율
   • 짧은 주기의 서비스(sns, 게임)에서 중요

2. Rolling Retention

   • 마지막 방문 이후 한 번이라고 돌아오면 유지된 것으로 간주
   • 사용 빈도가 낮은 서비스 (쇼핑몰 등)

3. Range Retention

   • 일정 기간 (설치 후 7~14일 사이) 안에 재방문한 비율

RFM 분석

• Recency: 고객이 마지막으로 구매한 시점

• Frequency: 특정 기간 동안 몇 번 구매

• Monetary: 총 구매 금액

• 분석 절차

1. 데이터 준비

2. 각 지표 점수화 Recency: 최근일수록 점수가 높음 (5=최근 구매) Frequency: 많이 구매할수록 점수가 높음 Monetary: 금액이 클수록 점수가 높음

*3. RFM 점수를 조합해 고객을 여러 그룹으로 나눔 * R F M 세그먼트 5 5 5 VIP (가장 가치 높은 고객) 5 1 1 신규 고객 3 2 2 잠재 이탈 고객 1 1 1 이탈 고객

4. 전략 수립 각 그룹에 맞는 액션 설계

VIP → 프리미엄 혜택, 우선 상담 잠재 이탈 고객 → 리마인드 이메일, 쿠폰 제공 신규 고객 → 온보딩 캠페인, 상품 추천 이탈 고객 → 재유입 유도 프로모션

• "ex4_member", "ex4_review" 라는 이름의 테이블에는 각각 회원에 대한 정보와, 회원이 남긴 리뷰에 대한 정보가 담겨있음
• ex4_member 테이블과 ex4_review 테이블을 사용하여 리뷰를 가장 많이 남긴 회원의 리뷰를 조회
• 회원 이름, 리뷰 텍스트, 리뷰 작성일이 포함되어 있어야 하고 오름차순 정렬

첫 번째 방식 (WITH 구문 사용)

# 각 멤버 별로 몇 번의 리뷰를 남겼는지 확인하기, 상위 1명만 출력 
WITH ReviewCounts AS (
    SELECT MEMBER_ID, COUNT(MEMBER_ID) AS membercount
    FROM hardy-aleph-464902-v8.modulabs.ex4_review
    GROUP BY MEMBER_ID
    ORDER BY membercount DESC
    LIMIT 1
)
# r 데이터와 m 데이터 JOIN
# 그 데이터를 ReviewCounts와 JOIN. 가장 많은 리뷰를 남긴 KEVIN만 남음
# 리뷰 작성일을 기준으로 오름차순 정렬 
SELECT MEMBER_NAME, REVIEW_TEXT, REVIEW_DATE
FROM hardy-aleph-464902-v8.modulabs.ex4_review AS r
JOIN hardy-aleph-464902-v8.modulabs.ex4_member AS m
ON r.MEMBER_ID = m.MEMBER_ID
JOIN ReviewCounts AS rc
ON r.MEMBER_ID = rc.MEMBER_ID
ORDER BY r.REVIEW_DATE

두 번째 방식 (서브쿼리 방식)

SELECT MEMBER_NAME,REVIEW_TEXT, REVIEW_DATE
FROM hardy-aleph-464902-v8.modulabs.ex4_review AS r
JOIN hardy-aleph-464902-v8.modulabs.ex4_member AS m
ON r.MEMBER_ID = m.MEMBER_ID
JOIN (
  SELECT MEMBER_ID, COUNT(MEMBER_ID) AS membercount
  FROM hardy-aleph-464902-v8.modulabs.ex4_member 
  GROUP BY MEMBER_ID
  ORDER BY membercount DESC
  LIMIT 1
) AS rc
ON r.MEMBER_ID = rc.MEMBER_ID
ORDER BY r.REVIEW_DATE

*WITH 구문과 서브쿼리 방식의 차이 *

• 공통점: 임시 테이블의 역할
• 차이점

1. WITH 구문

• 쿼리 맨 앞에 WITH절 선언
• 여러 번 재사용 가능
• 중간 데이터를 여러 번 사용해야 할 때 사용

2. *서브쿼리 방식 *

• FROM / JOIN 안에 바로 SELECT문
• 1회성
• 간단히 한번만 필요할 때 사용

SELECT *
FROM customers

고객번호, 이름, 가입일자 조회

SELECT customerId, customerName, signupDate
FROM customers

탈퇴하지 않고 2023년 이후 가입한 고객 정보 조회

SELECT customerId, customerName, status
FROM customers
WHERE status != 'Withdrawn';
AND signupDate >= '2023-01-01';

가격 30,000원 이하이거나 등록일이 2023년 3월 1일 이후인 상품 조회

SELECT productId, productName, registrationDate, price
FROM products
WHERE price <= 30000
OR registrationDate >= '2023-03-01'

상태(status)가 판매중(On Sale), 품절(Out of Stock)인 상품 조회 (IN 사용)

SELECT productId, productName, status
FROM products
WHERE status IN ('On Sale', 'Out of Stock')

상태(status)가 판매중, 품절이 아닌 상품 조회 (IN 사용)

SELECT productId, productName, status
FROM products
WHERE status NOT IN ('On Sale', 'Out of Stock');

입사일자(hireDate)가 NULL이고 상태(status)가 재직중(Active)인 직원 조회

SELECT employeeId, employeeName, status, department
FROM employees
WHERE hireDate IS NULL
AND status = 'Active'

입사일자가 2022년 4월 1일 ~ 4월 20일인 직원의 급여(salary)를 2로 나눈 값 확인

SELECT employeeId, salary, salary / 2 AS halfSalary
FROM employees
WHERE hireDate BETWEEN '2022-04-01' AND '2022-04-20';

코멘트(comments)가 'Special'로 시작하는 상품, 코멘트에 'limited' 단어를 포함하는 상품 조회

SELECT productId, comments
FROM products
WHERE comments LIKE 'Special%'
AND comments LIKE '%limited%'

가격을 오름차순 정렬하고 별칭 부여

SELECT productId AS 상품번호, price AS 가격
FROM products
ORDER BY price ASC

상품 상태의 중복 제거

SELECT DISTINCT status AS 상태
FROM products

60만원 기준으로 가격에 대한 조건문 (IIF 함수 사용)

SELECT productId, price, IIF(price >= 600000, 'High', 'Low') AS "60만원 기준"
FROM products

주문일자를 기준으로 연도를 분리하여 표시

SELECT
    saleId,
    saleDate,
    CASE WHEN YEAR(saleDate) = 2022 THEN '2022년'
         WHEN YEAR(saleDate) = 2022 THEN '2023년'
         ELSE '기타'
    END AS 판매연도
FROM sales

국가별 판매건수 집계

SELECT c.country, COUNT(s.saleId) AS 판매건수
FROM sales s
JOIN clients c
ON s.clientId = c.clientId
GROUP BY c.country

*Z-Score(표준점수): (관측값 - 데이터의 평균) / 표준편차 *

• 통계적으로 관측값이 평균에서 얼마나 떨어져 있는지를 표준편차 기준으로 나타내는 지표
• 이를 통해 데이터의 상대적인 위치를 파악하고 이상값을 탐지할 수 있음

데이터 탐색

# 컬럼명과 자료형 확인 
cc_df.info()

# 출력:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 491134 entries, 0 to 491133
Data columns (total 22 columns):
 #   Column                 Non-Null Count   Dtype  
---  ------                 --------------   -----  
 0   trans_date_trans_time  491134 non-null  object 
 1   cc_num                 491134 non-null  int64  
 2   merchant               491134 non-null  object 
 3   category               491134 non-null  object 
 4   amt                    491134 non-null  float64
 5   first                  491134 non-null  object 
 6   last                   491134 non-null  object 
 7   gender                 491134 non-null  object 
 8   street                 491134 non-null  object 
 9   city                   491134 non-null  object 
 10  state                  491134 non-null  object 
 11  zip                    491134 non-null  int64  
 12  lat                    491134 non-null  float64
 13  long                   491134 non-null  float64
 14  city_pop               491134 non-null  int64  
 15  job                    491134 non-null  object 
 16  dob                    491134 non-null  object 
 17  trans_num              491134 non-null  object 
 18  unix_time              491134 non-null  int64  
 19  merch_lat              491134 non-null  float64
 20  merch_long             491134 non-null  float64
 21  is_fraud               491134 non-null  int64  

# cc_num 컬럼의 값마다 amt의 평균, 표준편차를 계산하여 amt_info에 저장
# cc_num: account number
# amt: amount
amt_info = cc_df.groupby('cc_num)['amt'].agg(['mean','std']).reset_index()

# cc_num 컬럼을 기준으로 cc_df와 amt_info 데이터 merge
cc_df = cc_df.merge(amt_info, on='cc_num', how='left')

# z-score 계산
cc_df['amt_z'] = (cc_df['amt'] - cc_df['mean']) / cc_df['std']

• 사기 거래 컬럼 (is_fraud)를 살펴봤을 때 사기 거래 기록이 있는 컬럼에서 z-score이 크게 나온 것을 알 수 있었음
• 즉, 정상 거래들과는 다른 패턴을 보이며 이상치임을 알 수 있음

# category와 cc_num 컬럼의 값마다가 mean, std 계산
cat_info = cc_df.groupby(['cc_num', 'category'])['amt'].agg(['mean','std']).reset_index()

# cc_df 데이터와 cat_info 데이터 합치기 
cc_df = cc_df.merge(cat_info, on=['cc_num','category'],how='left')

# 결제금액의 z-score 계산하기
cc_df['cat_amt_z'] = (cc_df['amt'] - cc_df['mean']) / cc_df['std']

✅ 코드 모듈화 & 패키징을 통한 데이터 전처리 효율화

왜 필요할까?

반복되는 전처리 코드를 매번 복사/붙여넣기 하지 말고, 함수화하고 모듈화해서 필요할 때 불러오면 훨씬 효율적이고 깔끔함

이를 위해 총 3개의 파일이 필요:

1. func.py – 전처리 함수를 정의한 파일
2. col_rename.py – func.py에서 만든 함수를 저장할 .py 스크립트 파일
3. test.py – 실제로 함수를 import해서 테스트하는 파일

func.py - 전처리 함수 정의

def col_rename(dating_df):
    new_cols = []
    for i in dating_df.columns:
      if i.startswith('pref_o'):
        i = i.replace('pref_o','o_important')
      elif i.endswith('_o'):
        i = 'o_score_' + i.replace('_o','')
      elif i.endswith ('important'):
        i = 'i_important_' + i.replace('_important','')
      elif i.endswith('_partner'):
        i = 'i_score_' + i.replace('_partner','')
      new_cols.append(i)
     dating_df.columns = new_cols
     return dating_df

script = """
def col_rename(x):
    new_cols = []
    for i in dating_df.columns:
      if i.startswith('pref_o'):
        i = i.replace('pref_o','o_important')
      elif i.endswith('_o'):
        i = 'o_score_' + i.replace('_o','')
      elif i.endswith ('important'):
        i = 'i_important_' + i.replace('_important','')
      elif i.endswith('_partner'):
        i = 'i_score_' + i.replace('_partner','')
      new_cols.append(i)
     dating_df.columns = new_cols
     return dating_df
"""

filename = "./src/col_rename.py"

with open(file, 'w') as file:
    file.write(script)

# 결과: ./src/col_rename.py 파일이 생성됨 

test.py - 실제 적용 테스트

import sys
import pandas as pd

# 모듈이 들어 있는 폴더를 경로에 추가
sys.path.append('./src')

# 데이터 로드
dating_df = pd.read_csv('new_dating.csv')

# 함수 불러와 적용
from col_rename import col_rename
dating_df = col_rename(dating_df)

분류 알고리즘 (Classification)

설명변수를 바탕으로 목표 변수가 가질 수 있는 여러 범주 중 하나를 예측하는 지도학습의 대표적인 방법

- KNN (K-Nearest Neighbors)

핵심 개념: 주변의 '가까운' 데이터를 기준으로 분류 방식:

• 새로운 데이터 포인트가 들어왔을 때, 학습 데이터 중에서 가장 가까운 K개의 데이터를 찾음
• 이 K개 중 다수의 클래스가 새로운 데이터의 클래스가 됨 -> 다수결 튜표 방식

특징

• 장점: 구현이 간단, 이상치에 비교적 강함, 이상치가 있어도 그 값에 크게 영향을 받지 않음
• 단점: 데이터가 많거나 차원이 높아지면 성능 저하

# 속성 변수 선택
X = ndf[['pclass','age','sibsp','parch','female','male','town_C','town_Q','town_S']] # 설명변수 X
y = ndf[['survived']] # 예측 변수 y

# 데이터 전처리 도구들을 모아둔 모듈 preprocessing을 불러옴
# StandardScaler: 표준화(standardization)를 수행하는 도구
# 왜 표준화를 할까? K-Means, SVM, KNN, PCA 같은 알고리즘은 거리 기반 계산을 하기 때문에, 특성들의 스케일이 다르면 성능이 나빠질 수 있음
# fit(X): X의 평균과 표준편차를 계산
# transform(X): 위 통계를 사용해서 실제로 데이터를 변환

from sklearn import preprocessing
X = preprocessing.StandardScaler().fit(X).transform(X)

# train data와 test data를 7:3으로 구분
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=10)

print('train data 개수:', X_train.shape)
print('test data 개수:', X_test.shape)

# sklearn 라이브러리에서 KNN 분류 모형 가져오기
from sklearn.neighbors import KNeighborsClassifier

# 모형 객체 생성 (k=5로 설정)
# 가장 가까운 이웃 5개를 사용하겠다. 보통 k는 홀수로 지정. 짝수로 지정할 경우 동점이 될 수 있음 
knn = KNeighborsClassifier(n_neighbors=5)

# train data를 가지고 모형 학습
knn.fit(X_train, y_train)

# test data를 가지고 y_hat 예측(분류)
y_hat = knn.predict(X_test) # y_hat: 예측된 값 

print(y_hat[0:10]) # 예측된 값 10개 
print(y_test.values[0:10]) # 실제 정답 10개 

# 모형 성능 평가 - Confusion Matrix 계산
from sklearn import metrics
knn_matrix = metrics.confusion_matrix(y_test, y_hat)
print(knn_matrix)

# Confusion Matrix 시각화
# annot=True: 각 셀에 숫자값(정수)을 표시
# fmt='d': 포맷 정수로 입력 
plt.figure(figsize=(8, 6))
sns.heatmap(knn_matrix, annot=True, fmt='d', cmap='Blues',
            xticklabels=['Negative', 'Positive'],
            yticklabels=['Negative', 'Positive'])
plt.title('Confusion Matrix')
plt.ylabel('Actual label')
plt.xlabel('Predicted label')
plt.show()

# 모형 성능 평가 - 평가지표 계산
knn_report = metrics.classification_report(y_test,y_hat)
print(knn_report)

- SVM (Support Vector Machine)

핵심 개념: 클래스 간 최대한 margin을 가능한 한 넓게 벌려서 데이터를 나누는 방법 -> Test data가 그 경계선의 어느 쪽에 있는지 분류하는 알고리즘 방식

• 데이터를 선형 또는 비선형적으로 분리할 수 있는 초평면 찾음
• 가장 가까운 데이터 포인트와의 거리를 최대화하도록 설계

특징

• 장점: 고차원 데이터에 강함 -> 텍스트 분류 (뉴스, 이메일) 등에 강함
• 단점: 대용량 데이터에 느림

- Decision Tree (의사결정나무)

핵심 개념: 데이터 특징을 기준으로 질문을 반복하며 나무 구조로 분기 방식

• 각 노드에서 특정 feature을 기준으로 데이터 분할
• 잎 노드에 최종 클래스 값이 위치

특징

• 장점: 비정형 데이터에서 사용 가능, 전처리 적음
• 단점: 분할을 너무 세세하게 하기 때문에 과적합 우려

# 특성 중요도 계산
features = pd.DataFrame(tree_model.feature_importances_,
                        index=train_features,
                        columns=['Importance'])
features = features.sort_values(by='Importance', ascending=False)
features

*Confusion Matrix와 모델 성능 평가 *

False Positive (FP) = 24: 실제로는 Negative인데 Positive로 잘못 예측 -> 잘못된 경고/오탐 False Negative (FN) = 26: 실제로는 Positive인데 Negative로 잘못 예측 -> 놓친 탐지/누락

📌 Precision (정밀도) 양성이라고 예측한 것 중 실제로 양성인 비율 클래스 0: 0.79 → 예측한 Negative 중 79%가 실제로 Negative 클래스 1: 0.70 → 예측한 Positive 중 70%가 실제로 Positive

📌 Recall (재현율) 실제 양성 중에서 모델이 양성으로 잘 맞춘 비율 클래스 0: 0.80 → 실제 Negative 중 80%를 정확히 Negative로 예측 클래스 1: 0.68 → 실제 Positive 중 68%만을 Positive로 예측 (False Negative 존재)

따라서,

FN 비용이 큰 문제라면 → Recall 향상 필요 FP 비용이 큰 문제라면 → Precision 향상 필요

선형회귀의 정의

• 입력 변수(독립 변수)와 출력 변수(종속 변수) 사이의 선형적인 관계를 모델링하는 기법

• 즉, 데이터를 가장 잘 설명하는 직선을 찾아내는 것

• 광고비, 계절성, 요일 등의 데이터를 바탕으로 매출을 예측 / 수업 출석률, 과제 점수, 시험 점수를 이용해 최종 학점을 예측 / 키, 나이, 식습관 정보를 바탕으로 예상 몸무게 예측 등의 상황에서 선형회귀분석이 사용될 수 있음

수학적 표현

y=wx+b

• y: 예측 값 (종속 변수)
• x: 입력 값 (독립 변수)
• w: 기울기 (slope)
• b: 절편 (bias 또는 y절편)
• 여기서 w와 b는 학습을 통해 결정되는 파라미터

훈련/검증 데이터 분할

# 속성(변수) 선택
X=ndf[['weight']] # 독립변수
Y=ndf[['mpg']] # 종속변수

# train data와 test data로 구분 (7:3 비율)
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X,Y,test_size=0.3,random_state=10)
print('train data 개수:', len(X_train))
print('train data 개수:', len(X_test))

모델 학습 및 검증

# sklearn 라이브러리에서 선형회귀분석 모듈 가져오기
from sklearn.linear_model import LinearRegression

# 단순회귀번석 모델 객체 생성
lr = LinearRegression()

# train data를 가지고 모델 학습
lr.fit(X_train, Y_train) # 학습에 사용되는 입력 데이터, 출력 데이터 

# 학습을 마친 모델에 test data를 적용하여 결정계수 계산
r_square = lr.score(X_test, Y_test)
print('결정계수:', r_square)

결정계수: 모델이 전체 데이터의 변동성을 얼마나 잘 설명하는가? 를 나타내는 수치 이때 R² = 0.85 라면, 85%의 연비 변화를 자동차 무게로 설명할 수 있다는 뜻

# 모델에 test data 데이터를 입력하여 예측한 값 y_hat을 실제 y와 비교
y_hat = lr.predict(X_test) # 학습된 모델 lr이 X_test를 보고 예측한 종속변수 

# 오차 계산
test_preds = pd.DataFrame(Y_test)
test_preds.columns = ['Y_test']
test_preds['y_hat'] = y_hat
# 실제값(Y_test)과 예측값(y_hat)을 비교
test_preds['squared_error'] = (test_preds['y_hat'] - test_preds['Y_test']) ** 2
test_preds

# 오차 분석
fig, axes = plt.subplots(1,2, figsize=(10,5)) # 1행 2열 구조 
sns.regplot(x='Y_test', y='y_hat', data=test_preds, ax=axes[0]);
# 그래프가 왼쪽에 뾰족하게 치우쳐 있으면 → 예측이 전반적으로 정확하다는 뜻
# 커널 밀도 추정을 이용해 데이터 분포를 부드럽게 표현
sns.kdeplot(x='squared_error', data=test_preds, ax=axes[1]);

# 앞의 10줄만 입력
data.head()
# 뒤의 10줄만 입력 
data.tail()

# 데이터 정보 확인
data.info()
# 데이터의 통계적 요약 (object 형태는 제외)
data.describe()

# series를 강제로 DataFrame으로 만들어야 할 때
pd.DataFrame(data['Name'])

데이터 클리닝

# Name 컬럼을 제거
# inplace=True: 기존의 데이터 대체 
data.drop('Name', axis=1, inplace=True)

# 2 인덱스의 행 지우기
data.drop(2, axis=0)

# 두 개의 컬럼을 동시에 지우기
data.drop(['Pcalss','Age']), axis=1)

# 특정 행 불러오기
data.loc[[4,5,6]]

# 결측치가 있는 열 확인
data.insa().sum()

# 특정 컬럼의 결측치 확인
data['Age'].isna()

# 결측치 True에 해당하는 인덱스만 출력
age_na_index = data[data['Age'].isna()].index

# 특정 컬럼의 결측치 제거
data.drop(subset = ['Embarked'])

# 평균값으로 Age의 결측치를 채움
data['Age'].mean()
data['Age'] = data['Age'].fillna(data['Age'].mean())

이상치 탐지 및 처리 (Outlier)

 # 나이 데이터 오름차순/내림차순 정리
 data['Age'].sort_values()
 data['Age'].sort_values(ascending=False)

 # 이상치: 나이 중 100보다 큰 값
 data = data[data['Age'] <= 100]

 # 80보다 큰 나이는 80으로 대체, 그렇지 않으면 원래값 (함수 사용)
 def age_func(x):
     if x > 80:
        return 80
    else:
        return x
 age_func(77)
 # Age 컬럼에 age_func 함수 적용
 data['Age'].apply(age_func)

 # lambda 함수 사용
 data['Age'].apply(lambda x : 70 if x > 70 else x)

중복 데이터 처리 및 데이터 형태 반환처리

# 중복 데이터 추출
data[data.duplicated()]

# 중복 데이터 삭제 
data = data.drop_duplicates()

# Gendr 열 이름 변경
data.rename({'Gendr':'Gender'}, axis=1)

# replace를 활용해 값 바꾸기
data['Embarked'].replace({'S':'South', 'C':'Chernourg', 'Q':'Queenstown'})

# map: replace와 동일한 기능을 수행하지만 series에만 적용 가능
data['Embarked'].map({'S':'South','C':'Chernourg','Q':'Queenstown'})

텍스트 처리

# 인덱싱을 활용해 특정 문자열 추출
sample_txt[0]
# 0이상 3 미만
sample_txt[0:3]
sampe_txt[:3]
sample_txt[4:]
# 뒤에서부터 추출
sample_txt[-1]

# 대문자를 소문자로 변경 
sample_txt.lower()
# 소문자를 대문자로 변경 
sample_txt.lower().upper()

# 문자열 띄어쓰기 기준으로 쪼개기, 리스트 형태로 반환
sample_txt.split()
# / 기준으로 쪼개기
sample_txt.split('/')

# 앞에 띄어쓰기 들어간 예시
new_txt = ' 안녕 하세요 '
# 앞의 띄어쓰기 없애기, 중간의 띄어쓰기는 그대로 유지 
new_txt.strip()
# Ticket 컬럼의 문자열에 대한 인덱싱 후 추출
data['Ticket'].str[-5:]
# Ticket 컬럼의 문자열을 분할 후 그 결과를 여러 컬럼에 나눠줌
data['Ticket'].str.split(expand=True)
# # Ticket 값들을 띄어쓰기 기준으로 분할 후 마지막 것들만 가져옴
data['New Ticket'] = data['Ticket'].str.split().apply(lambda x : x[-1])

# 열의 데이터가 숫자인지 문자인지 확인
# ~을 사용하면 True/False 반대로 확인
data[data['new_ticket'].str.isdigit()]
# data 타입을 'int'로 바꿔줌
data['new_ticket'].astype('int')
# to_numeric을 사용해 int로 변환
data['new_ticket'] = pd.to_numerice(data['new_ticket'])

** 결측치, 이상치 처리 **

# CPI 컬럼 object -> float으로 바꾸기
salary_df['CPI'] = pd.to_numberic(salary['CPI']

# 결측치 확인
salary_df.isna().sum()

# Age의 결측치 확인
salary_df[salary_df['Age'].isna()]

결측치가 있는 행을 출력할 수 있음

# 결측치가 있는 행은 지우기 
salary_df['Age'] = salary['Age'].dropna()

Years of Experience 컬럼에서 -1 이상치 발견

# Years of Experience가 -1이 아닌 행들만 salary_df 에 넣어주기 
salary_df = salary_df[salary_df['Years of Experience'] != -1]

# 오름차순 정렬
salary_df['Years of Experience'].sort_values()

# 나이보다 경력이 많은 경우 제외
# ~: True와 False를 반대로 
salary_df = salary_df[~(salary_df['Years of Experience'] > salary_df['Age'] - 18)]

*groupby(): 그룹화하여 집계, 변환, 필터링 가능 *

# 젠더 별 샐러리의 최대 
salary_df.groupby('Gender')['Salary'].max()

# # Gender와 Country 별 Salary의 평균
salary_df.groupby(['Gender','Country'])['Salary'].mean()

# agg 함수 사용해 sum과 mean 한번에 구하기
salary_df.groupby('Gender')['Salary'].agg(['sum','mean'])

# 피벗테이블 만들기 
df = pd.DataFrame({
    'Department': ['Sales', 'Sales', 'HR', 'HR', 'IT'],
    'Gender': ['M', 'F', 'M', 'F', 'M'],
    'Salary': [50000, 55000, 48000, 52000, 60000]
})
df.pivot_table(values='Salary', index='Department', aggfunc='mean')
# 출력
             Salary
Department         
HR           50000.0
IT           60000.0
Sales        52500.0

# 부서 & 성별 기준으로 평균 급여
df.pivot_table(values='Salary', index='Department', columns='Gender', aggfunc='mean')
# 출력
Gender         F       M
Department              
HR        52000.0  48000.0
IT            NaN  60000.0
Sales     55000.0  50000.0

#여러 함수 한번에 사용
df.pivot_table(values='Salary', index='Department', aggfunc=['mean', 'max'])
# 출력
            mean     max
Salary                    
Department              
HR         50000  52000
IT         60000  60000
Sales      52500  55000

원-핫 인코딩: 범주형(categorical) 데이터를 수치형(numerical) 데이터로 변환하는 대표적인 방법

• 예를 들어, Red, Green, Blue의 컬러가 있다고 했을 때 해당 범주일 경우 1, 아니면 0을 부여하는 방식
• pandas의 경우에는 pd.get_dummies()를 사용
• 하지만 범주가 많을수록 열이 많아진다는 문제점이 있음

import pandas as pd

df = pd.DataFrame({'Color': ['Red', 'Green', 'Blue', 'Green']})
encoded = pd.get_dummies(df, columns=['Color'])
print(encoded)
# 출력
   Color_Blue  Color_Green  Color_Red
0           0            0          1
1           0            1          0
2           1            0          0
3           0            1          0

# 각각 컬럼의 고유값이 몇 개인지 확인하는 방법
df[['Color_Blue', 'Color_Green', 'Color_Red']].nunique()

데이터 병합: concat, merge, join

• concat(): 단순한 연결, 위아래로 합치기 (axis=0)

  # concat 
  import pandas as pd
  

df1 = pd.DataFrame({'A' : ['A0', 'A1'], 'B': ['B0', 'B1']}) df2 = pd.DataFrame({'A': ['A2', 'A3'], 'B': ['B2', 'B3']})

result = pd.concat([df1, df2]) print(result)

출력

A B 0 A0 B0 1 A1 B1 0 A2 B2 1 A3 B3

- merge(): 공통된 컬럼이나 인덱스를 기준으로 테이블 병합

merge inner: 교집합

df_a = pd.DataFrame({'key': ['K0', 'K1', 'K2'], 'A': ['A0', 'A1', 'A2']}) df_b = pd.DataFrame({'key': ['K0', 'K2', 'K3'], 'B': ['B0', 'B2', 'B3']})

result = df_a.merge(df_b, how='inner') print(result)

출력

key A B 0 K0 A0 B0 1 K2 A2 B2

merge outer: 합집합

result = pd.merge(df_a, df_b, on='key', how='outer') print(result)

출력

key A B 0 K0 A0 B0 1 K1 A1 NaN 2 K2 A2 B2 3 K3 NaN B3

merge left: 왼쪽 기준 병합

result = pd.merge(df_a, df_b, on='key', how='left') print(result)

출력

key A B 0 K0 A0 B0 1 K1 A1 NaN 2 K2 A2 B2

merge right: 오른쪽 기준 병합

result = pd.merge(df_a, df_b, on='key', how='right') print(result)

출력

key A B 0 K0 A0 B0 1 K2 A2 B2 2 K3 NaN B3

- join(): 데이터프레임의 인덱스를 기준으로 병합 

df3 = pd.DataFrame({'A' : ['A0', 'A1'], 'B': ['B0', 'B1']}) df4 = pd.DataFrame({'A': ['A2', 'A3'], 'B': ['B2', 'B3']})

df_3.join(df_4, lsuffix='_3', rsuffix='_4')

출력

A_3 B_3 A_4 B_4 0 A0 B0 A2 B2 1 A1 B1 A3 B3

df_3 = df_3.set_index('key') df_4 = df_4.set_index('key')

df_3.join(df_4, how='inner')

#출력 A_3 B_3 A_4 B_4 key
K0 A0 B0 A2 B2

- 데이터 합칠 때 생길 수 있는 문제

salary_df = pd.concat([salary_1, salary_2]) salary_df.loc[0]

![](https://velog.velcdn.com/images/jisukim_28/post/fa7e4e6f-454c-47a0-8be5-f35cdb411550/image.png)
0번째 인덱스가 2개가 생겼음. 이처럼 모든 인덱스가 2개씩 존재하는 문제 발생

해결방법

인덱스 리셋

salary_df.reset_index(drop=True)

![](https://velog.velcdn.com/images/jisukim_28/post/22fd2450-1d91-418f-aec1-5ec1efefad10/image.png)

국가 이름 통일시키기

cpi['Country'] = cpi['Country'].replace({'United States':'USA','United Kingdom':'UK'})

기존의 데이터를 기준으로 새로운 cpi 데이터 merge

salary_df = salary_df.merge(cpi, on='Country', how='left')

컬럼 지우기

inplace=True: 원본이 수정됨

salary_df.drop(['Reference','Previous','Units','Frequency'],axis=1, inplace=True) ```

np.arange(): Numpy 라이브러리의 함수로 숫자 배열을 생성할 때 사용

# start부터 stop 미만의 값, step의 간격으로 출력 
np.arange(start, stop, step)

print(np.arange(10,30,5))
# 출력: [10, 15, 20, 25]

print(np.arange(0,2,0.3))
# 출력: [0.  0.3 0.6 0.9 1.2 1.5 1.8]

np.linspace(): 시작과 끝값 사이를 지정된 개수만큼 균등하게 나눈 값을 만듬

np.linspace(0,5,6)
# 출력: [0., 1., 2., 3., 4., 5.]

np.linspace(0,1,5)
#출력: [0.   0.25  0.5  0.75  1.] 

• np.arange(): 일정한 간격으로 나누고 싶을 때
• np.linspace(): 정확히 몇 개의 값이 필요한 경우

np.arange(0, 1, 0.3)  
# → [0.  0.3  0.6  0.9] (소수 오차로 인해 1 포함 안 됨)

np.linspace(0, 1, 5)  
# → [0.   0.25  0.5  0.75  1.] (정확하게 나눠짐)

기본 연산

a = np.array([20,30,40,50])
b = np.arange(4)
print(a)
prnit(b)

# 출력: [20 30 40 50]
[0 1 2 3]

c=a-b
print(c)
# 출력: [20 29 38 47]

print(b**2)
# 출력: [0 1 4 9]

print(10*a)
# 출력: [200 300 400 500]

print(a < 35)
# 출력: [ True  True False False]

• .sum(): 합계
• .min(): 최소값
• .max(): 최댓값
• .argmax(): 모든 요소 중 최댓값 인덱스
• .cumsum(): 모든 요소의 누적합

a = np.arange(8).reshape(2,4) **2 
print(a)
# 출력: [[ 0  1  4  9]
 [16 25 36 49]]

print(a.sum()) # 140
print(a.min()) # 0
print(a.max()) # 49
print(a.argmax()) # 7
print(a.cumsum()) # [  0   1   5  14  30  55  91 140]

• axis=1: 열
• axis=0: 행

b = np.arange(12).reshape(3,4)
print(b)
# [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

 print(b.sum(axis=0))
 # [12 15 18 21]

 print(b.sum(axis=1))
 # [ 6 22 38]

데이터 합치기, 쪼개기 - stack, split

• np.stack(): 배열 합치기
• np.slpit(): 배열 쪼개기

# 합치기 
a = np.array([1,2,3,4]).reshape(2,2)
print(a)
# [[1 2]
 [3 4]]

b = np.array([5,6,7,8]).reshape(2,2)
print(b)
# [[5 6]
 [7 8]]

print(np.vstack((a,b)))
# [[1 2]
 [3 4]
 [5 6]
 [7 8]]

print(np.hstack((a,b)))
# [[1 2 5 6]
 [3 4 7 8]] 

# 쪼개기
a = np.arange(12).reshape(2,6)
print(a)
# [[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

print(np.hsplit(a,3))
[array([[0, 1],
       [6, 7]]), array([[2, 3],
       [8, 9]]), array([[ 4,  5],
       [10, 11]])]

# a를 3번째 열 ~ 4번째 열 미만 기준으로 분할 
print(np.hsplit(a,(3,4)))
[array([[0, 1, 2],
       [6, 7, 8]]), array([[3],
       [9]]), array([[ 4,  5],
       [10, 11]])]

*클래스와 객체란? *

• 클래스: 설계도
• 객체: 설계도를 바탕으로 만들어진 실체
• 속성: 클래스 안의 변수
• 메소드: 클래스 안의 함수

  # 클래스 Recipe 생성 
  class Recipe:
    def cook(self):
        print("오리가 완성되었습니다!")
  # 객체 생성
  pasta = Recipe()
  pasta.cook() #출력: 요리가 완성되었습니다!

생성자(Init)와 속성

• 생성자: 객체가 생성될 때 자동으로 호출되는 메서드
• 속성: 객체가 가지는 변수들

class Book:
    # 인스턴스 속성: title, author
    # 생성자: __init__()
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def info(self):
        print(f"책 제목: {self.title}, 저자: {self.author}")
book1 = Book("파이썬 입문", "홍길동")
book.info() # 출력: 책 제목: 파이썬 입문, 저자: 홍길동

*메소드와 생성자(init)의 차이 *

• 메소드: 객체의 기능/동작 수행, 객체 생성 이후 필요할 때 호출
• 생성자: 초기 속성값 설정, 객체가 생성될 때 자동 호출

# 생성자의 예제
class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
    # 메소드의 예제
    def drive(self):
        print(f"{self.color}색 {self.brand} 자동차가 달립니다")

상속 (Inheritance)

• 부모 클래스의 속성과 메소드를 자식 클래스가 물려받음
• 자식 클래스에서 부모의 생성자를 호출하려면 super() 사용

class Employee:
    def __init__(self, name):
        self.name = name

    def work(self):
        print(f"{self.name}이 일을 합니다.")

class Manager(Employee):
    def __init__(self, name, department):
        super().__init__(name)
        self.department = department

    def manage(self):
        print(f"{self.name}이 {self.department} 부서를 관리합니다.")

m = Manager ("이영희", "영업")
m. work()  # 출력: 이영희이 일을 합니다.
m. manage()  # 출력: 이영희이 영업 부서를 관리합니다.

*파이썬 자료형 *

1. 숫자형 (int, float)

• int: 정수형 (예: 1, -5, 100)
• float: 실수형 (예: 3.14, -0.5)

*2. 연산자: *

• // : 몫 (정수 나눗셈)
• % : 나머지
• ** : 거듭제곱

a = 7
b = 3
print(a // b)  # 2
print(a % b)   # 1
print(a ** b)  # 343

#복합대입연산자 
x = 10
x += 5  # x = x + 5
print(x)  # 15

3. 문자형 (String)

• 이스케이프 코드

  \n : 줄바꿈 \t : 탭 \ : 역슬래시 ' 또는 " : 따옴표 출력

print("Hello\nWorld")
print("나는 \"파이썬\"을 좋아해")

# 문자열 길이
s = "Python"
print(len(s)) #6

4. 자료형의 종류: type()

x = 10
print(type(x)) # <class 'int'>

5. 문자열 슬라이싱

# 끝은 포함되지 않음 
s = "Python"
print(s[0:2])     #Py
print(s[:3])    # 'Pyt'
print(s[::2])   # 'Pto'

자료형들

1. List (리스트)

• 변경 가능
• 순서 O, 중복 O

  리스트명 = [1, 2, 3, 4, 5]
  리스트명.append(6)
  print(리스트명) #[1,2,3,4,5,6]

2. Tuple (튜플)

• 변경 불가
• 순서 O, 중복 O
• del 불가

  튜플명 = (1, 2, 3)
  print(튜플명)

3. Set (집합)

• 중복 X, 순서X

  집합명 = {1, 2, 3, 3, 4}
  print(집합명)  # {1, 2, 3, 4}

4. Dictionary (딕셔너리)

• Key와 Value 로 구성

  딕셔너리명 = {"이름": "홍길동", "나이": 30}
  print(딕셔너리명["이름"])

5. Bool (불린형)

• 참(True), 거짓(False)

파이썬 기초문법

1. 반복문

# while + 조건문
i = 0
while i < 5:
    print(i)
    i += 1

# continue와 break
i = 0
while i < 5:
    i += 1
    if i == 3:
        continue # 3은 건너뜀
    if i == 5:
        break # 5에서 종료 
    print(i)

# for + range()
for i in range(1,6,1)
    print(i)

2. 연산자

• 비교 연산자 = (대입) == (같다) != (다르다)

• 논리 연산자 and (그리고) or (또는) not (부정)

• 기타 연산자 in, not in (포함 여부 확인)

  x = 5
  print(x == 5)  # True
  print(not x == 5)  # False
  print(3 in [1, 2, 3, 4])  # True

3. 조건문

score = 85
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C")

4. 함수 (def)

def add(a, b):
    return a + b

result = add(3, 4)
print(result)  # 7

Lambda는 언제 쓸까?

1. 짧고 간단한 함수를 만들고 싶을 때

   • 함수를 매번 def로 정의하기 귀찮을 때
   • 일회성으로 쓸 때 -> 굳이 이름을 붙일 필요 없을 때

2. 고차 함수 (map, filter, reduce 등)과 함께 사용할 때

Lambda 표현식 (익명함수)

• lambda 매개변수 : 표현식

• 이름이 없는 간단한 함수를 만들 때 사용

• Lambda 작성 규칙

  1. 람다 내부에서는 새로운 변수를 만들 수 없음
  2. 람다 외부의 변수는 참조 가능

add = lambda x, y : x + y
print(add(2,3)) #출력: 5

# 람다 작성 규칙
# 외부에서 새로운 변수 만듬 
n = 10
# 람다 외부의 변수 n 참조 가능 
f = lambda x : x+n
print(f(5)) # 출력: 15

고차 함수와 Lambda 활용

1. map(): 모든 요소에 함수 적용

nums = [1,2,3,4]
doubled = list(map(lambda x : x * 2, nums))
print(doubled)  # 출력: [2, 4, 6, 8]

2. filter(): 조건에 맞는 요소만 추출

nums = [1, 2, 3, 4, 5, 6]
even = list(filter(lambda x : x % 2 ==0, nums))
print(even)  # 출력: [2, 4, 6]

3. reduce(): 누적 결과 생성 (import 필요)

from functools import reduce

nums = [1, 2, 3, 4]
total = reduce(lambda x,y : x + y, nums)
print(total) # 출력: 10

변수 범위 (Variable Scope)

• 전역 변수: 함수 바깥에서 선언된 변수
• 지역 변수: 함수 안에서 선언된 변수

# 전역 변수
name = '지수'
def print_name():
    print(name)
print_name() # 출력: 지수

# 지역 변수
def hello():
    user = '지수'
    print(user)
hello() #출력: 지수

*변수 범위 수정하기 global vs nonlocal *

1. global: 함수 안에서 전역 변수를 수정하고 싶을 때

count = 0 # 전역 변수
def increase():
    global count
    count += 1
increase()
print(count) #출력: 1

2. nonlocal: 중첩 함수에서 바깥 변수를 수정하고 싶을 때

def outer():
    x = 10 #바깥 함수의 지역 변수
    def inner():
        nonlocal x
        x += 5
    inner()
    print(x)
outer() # 출력: 15

모듈, 패키지, 라이브러리 비교

모듈: 파이썬 코드가 들어가 있는 단일 파일 (.py파일) 패키지: 여러 모듈을 폴더로 묶은 것 라이브러리: 모듈과 패키지를 포함한 전체적인 기능 집합

포준모듈: 파이썬 내장 모듈

1. random 모듈: 난수 생성을 위한 함수 제공

# random 모듈 불러오기
import random

# 모듈 r이라는 키워드로 지정도 가능 
#import random as r 

# randint(a,b): a 이상 b 이상의 정수 무작위로 변환 
num = random.randint(1,10)
print(num)

# random(): 0 이상 1 미만의 실수 반환
num = r.random(1,10)
print(num)

# seed(): 난수 생성의 초기값을 고정
random.seed(42)
print(random.randint(1,10)) # 항상 같은 값 출력

2. math 모듈: 수학적 함수 및 상수 제공

import math

# pi: 원주율
print(math.pi)

# e: 자연상수 제공 
print(math.e)

# pow(n,x): n의 x 제곱 반환, 항상 실수형 결과를 반환 
result = math.pow(2,3)
print(result) #8.0

# ceil(): 올림 함수, 수직선 상에서 우측의 값 반환
result = ceil(3.14)
print(result) # 4

# floor(): 내림 함수, 수직전 상에서 좌측의 값 반환
result = math.floor(3.14)
print(result) #3

# round(숫자, 소수점_자리수): 반올림 함수
result = round(3.14159, 2)
print(result) #3.14

3. time 모듈: 시간과 관련된 기능

   import time
   

time.sleep(secs)

print("3초 대기 시작" time.sleep(3) print("3초 대기 후 출력")

time.localtime(): 현지 시간 반환

now = time.localtime() print(now) # ime.struct_time(tm_year=2025, tm_mon=5, tm_mday=30, tm_hour=14, tm_min=25, tm_sec=10, ...)

4. **keyword 모듈**: 예약어와 관련된 기능 제공 

import keyword

print(keyword.kwlist) # 현재 사용되는 모든 예약어 리스트 반환

print(keyword.iskeyword("for")) # for이 파이썬의 예약어인지 여부를 True/False로 반환

> **import로 모듈 불러오기 **

from import로 모듈 일부분만 가져오기

from math import pi pi

여러 개의 변수, 함수를 가져올 때

from math import e, pi, pow pi, e, pow(2, 6)

from import as: 모듈 일부분만 가져오기 + 키워드

case1

from 모듈 import 변수 as 이름 from 모듈 import 함수 as 이름 from 모듈 import 클래스 as 이름

case2

from 모듈 import 변수 as 이름1, 함수 as 이름2, 클래스 as 이름3

#모두 import from math import * ceil (6.3)

#모듈만 import import math math.ceil(6.3)

> 실습: 계산기 만들기

while True: try: # 두 개의 정수를 받을 때는 나눠서 입력해야됨. num1 = int(input("첫 번째 정수를 입력하세요:")) num2 = int(input("두 번째 정수를 입력하세요:")) cal = input("연산자를 입력하세요:")

except ValueError:
    print("잘못된 입력입니다. 정수를 입력해주세요.")
    num1 = int(input("첫 번째 정수를 입력하세요:"))
    num2 = int(input("두 번째 정수를 입력하세요:"))
    cal = input("+, -, *, /, ** 중 연산자를 한 개 입력하세요:")

#문자열과 리스트는 다르다 
    #if cal not in ['+','-','*','/','**']:
    #print("지원하지 않는 연산자를 입력하여 오류가 발생했습니다.")

else:
    if cal == '+':
        result1 = num1 + num2
        print (f'계산된 값은:{result1}입니다.')
    elif cal == '-':
        result2 = num1 - num2
        print (f'계산된 값은:{result2}입니다.')
    elif cal == '*':
        result3 = num1 * num2
        print (f'계산된 값은:{result3}입니다.')
    elif cal == '/':
        if num2 == 0:
            raise ZeroDivisionError('나눗셈 연산 시 두 번째 정수가 0이 될 수 없습니다.')
        else:
            result4 = num1 / num2
            print (f'계산된 값은:{result4}입니다.')
    # 처음에 else 를 썼는데, else 뒤에는 조건문 쓸 수 없음 
    elif cal == '**':
        from math import pow
        result5 = pow(num1,num2)
        print (f'계산된 값은:{result5}입니다.')
    #오류 메시지는 항상 모든 정상 케이스를 처리한 맨 마지막 else문 안에 넣어야 한다.
    else:
        print("지원하지 않는 연산자를 입력하여 오류가 발생했습니다.")

파이썬 오류 종류

1. 구문 오류 (Syntax Error)

• 코드가 문법적으로 잘못됨. 따라서, 프로그램 실행 자체가 안 됨

2. 런타임 오류 (Runtime Error)

• 문법적으로 문제는 없지만 프로그램 실행 중 발생하는 오류

예외처리 ((Exceptional Handling)

런타임 오류가 발생했을 때 프로그램이 중단되지 않고 정상적으로 이어서 동작하도록 만들어주기 위함 예외 처리 방법에는 크게 두 가지 방식이 있음

1. 조건문 사용 (사전처리)

• 오류가 발생하기 이전에 미리 검사해서 오류 피하는 방식. 따라서, 모든 상황을 예측하고 모두 조건문으로 처리해야 함

2. try-excpet (사후처리)

• 실제로 오류가 발생했을 때 이를 처리하는 방식. 조건문과 달리 모든 상황을 예측하지 못해도 예외를 처리할 수 있음

try-except 구문을 구체적으로 알아보자

1. try + except

• 가장 기본적인 예외 처리

  #오류가 발생할 수 있는 코드
  try:
    x = int(input("숫자를 입력하세요:"))
    result = 10 / x
  

오류가 발생했을 때 처리할 코드

except ZeroDivisionError: print("0으로 나눌 수 없습니다!")

여러 개의 except로 다양한 예외를 처리 가능

except ValueError: print("숫자를 입력해야 합니다.")

**2. try + except + else**
- 오류가 발생하지 않았을 때만 실행할 코드 추가 

try: x = int(input("숫자를 입력하세요:")) result = 10 / x

except ZeroDivisionError: print("0으로 나눌 수 없습니다!")

except ValueError: print("숫자를 입력해야 합니다.")

예외가 발생하지 않았을 때 실행됨

else: print("계산 결과:", result)

**3. try + except + finally**
- 예외가 발생하든 말든 항상 실행되는 finally

try: x = int(input("숫자를 입력하세요: ")) result = 10 / x

except ZeroDivisionError: print("0으로 나눌 수 없습니다!")

except ValueError: print("숫자를 입력해야 합니다.")

#예외 발생 여부와 상관없이 항상 실행
finally: print("프로그램이 종료됩니다.")

> **오늘 새롭게 배운 개념 **

**1. f-string(formatted string literal)**
- 문자열 앞에 f 또는 F를 붙이고, 문자열 안에 중괄호 {}를 사용하여 변수를 직접 넣을 수 있는 기능 

name = '지수' age = 25 print(f'안녕하세요. 제 이름은 {name}이고, 나이는 {age}살입니다.')

**2. isdigit() 함수**
- 문자열이 정수인지 검사할 때 사용 
- 문자열이 전부 숫자이면 True, 아니면 False

간단한 사용

s = "12345" print(s.isdigit()) #True

입력값 검증

user_input = input("숫자를 입력하세요:")

if user_input.isdigit(): num = int(user_input) print("입력한 숫자:", num) else: print("숫자가 아닙니다.")

**3. lstrip()**
- 문자열의 왼쪽에서 특정한 문자들을 제거하는 함수

s = "abcabcHello" result = s.lstrip("abc") print(result) # "Hello" ```텍스트

리스트

✅ 1차원 리스트

• 한 줄로 된 목록

  # 1차원 리스트
  a = [10, 20, 30, 40, 50]
  

1차원 리스트 인덱싱

print (a[0]) #10 print (a[4]) #50

✅** 2차원 리스트**
- 리스트 안에 리스트가 포함된 형태
- 행과 열로 표 형태의 데이터 표현 가능

2차원 리스트

b = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]

2차원 리스트의 len함수 -> 행의 길이로 출력

len(b) #3

2차원 리스트 인덱싱

b[2][0] # [7] b[0][2] # [3] b[1] #[4, 5, 6]

✅ **3차원 리스트**
- 2차원 리스트가 리스트 안에 들어간 형태

3차원 리스트

c = [ [ # 첫 번째 블록 [1, 2], [3, 4] ], [ # 두 번째 블록 [5, 6], [7, 8] ] ]

3차원 리스트 인덱싱

print(c[0][0][1]) # 2 print(c[1][1][0]) # 7 print(c[1][1][:]) # 7,8

3차원 리스트의 길이

len(c) #2 (depth)

✅ **리스트 주요 함수**
- min(): 리스트 함수에서 가장 작은 요소 반환
-  max(): 리스트에서 가장 큰 요소 반환
- sum(): 리스트 안의 요소들을 모두 더해 반환
- enumerate(): 리스트를 반복할 때, 인덱스 번호와 값을 함께 가져옴
- zip(): 여러 리스트를 같은 인덱스끼리 묶어 반환

min()

numbers = [5, 8, 1, 9, 3] print(min(numbers)) # 1

max()

numbers = [5, 8, 1, 9, 3] print(max(numbers)) # 9

#sum() scores = [70, 80, 90] print(sum(scores)) # 240

#enumerate() fruits = ['apple', 'banana', 'cherry'] for i in enumerate(fruits): print(i) #0 apple 1 banana 2 cherry

#zip() fruits = ['apple', 'banana', 'cherry'] colors = ['red', 'yellow', 'pink']

for i in zip(fruits, colors): print(i) #('apple', 'red') ('banana,' 'yellow') ('cherry', 'pink')

> **딕셔너리 **

✅ **딕셔너리 주요 함수**

1. setdefault()
키가 존재하지 않으면 새로 추가하고, 있으면 기존 값을 반환

person = {'name': '지수'} person.setdefault('age', 25) # age가 없으므로 추가됨 person.setdefault('name', '지영') # name은 이미 있으므로 무시됨

print(person) # {'name': '지수', 'age': 25}

2. update()
딕셔너리에 키-값 쌍을 추가하거나 수정

person = {'name': '지수', 'age': 25} person.update({'age': 30, 'city': 'Seoul'}) # age는 수정, city는 추가

print(person) # {'name': '지수', 'age': 30, 'city': 'Seoul'}

3. pop()
특정 키의 값을 꺼내고 삭제

person = {'name': '지수', 'age': 25} age = person.pop('age')

print(age) # 25 print(person) # {'name': '지수'}

4. popitem()
딕셔너리에서 마지막 항목을 제거하고 (key, value) 튜플로 반환

person = {'name': '지수', 'age': 25} item = person.popitem()

print(item) # ('age', 25) print(person) # {'name': '지수'}

5. fromkeys()
리스트나 튜플을 넣으면 자동으로 딕셔너리를 만들어주는 함수

keys = ['name', 'age', 'city'] defaults = dict.fromkeys(keys, '미정')

print(defaults)

{'name': '미정', 'age': '미정', 'city': '미정'}

6. in/not in
딕셔너리에 특정 키가 있는지 확인
value가 있는지 확인하고 싶으면 values()를 붙이기 

person = {'name': '지수', 'age': 25}

print('name' in person) # True print('city' not in person) # True

#value 확인할 때 print('25' in person.values()) # True

> **컴프리헨션**

✅ **컴프리헨션이란?**

파이썬의 대표적인 문법 중 하나
대괄호 [ ] 안에 if문, for문, in의 조건과 반복문을 활용

for 반복문

squares = [] for x in range(1, 6): squares.append(x**2)

print(squares) # [1, 4, 9, 16, 25]

#리스트 컴프리헨션 squares = [x**2 for x in range(1, 6)] print(squares) # [1, 4, 9, 16, 25]

#for 조건문 evens = [] for x in range(10): if x % 2 == 0: evens.append(x)

print(evens) # [0, 2, 4, 6, 8]

#반복문 조건문 컨프리헨션 evens = [x for x in range(10) if x % 2 == 0] print(evens) # [0, 2, 4, 6, 8]

#이중 if문 컨프리헨션 nums = [x for x in range(1, 21) if x % 2 == 0 if x % 3 == 0] print(nums)

> **예제문제 풀이 **

국, 영, 수, 사, 과 점수 입력 후 최저 점수, 최고 점수, 평균 점수 출력

score = input("성적을 입력하세요. (국어 영어 수학 사회 과학):") score_list = list(map(int, score.split()))

average = sum(score_list) / len(score_list)

print("최저 점수:", min(score_list), "최고 점수:", max(score_list), "평균 점수:", average)

✅ score.split()

score은 문자열

split()을 하면 공백을 기준으로 문자열을 나눠 리스트로 만듬

score = "80 90 100 70" score.split() # 👉 ['80', '90', '100', '70'] → 문자열 리스트

✅ map(int, ...)

리스트의 각 요소에 int() 함수를 적용해서 정수로 바꿈

map(int, ['80', '90', '100', '70'])

👉 [80, 90, 100, 70] (map 객체)

✅ list(...)

score_list = [80, 90, 100, 70] # 문자열 → 정수 리스트

```

Github를 사용하는 목적은?

• 협업 여러 사람이 같은 프로젝트를 동시에 작업할 때, 서로의 작업 내용을 공유하기에 용이
• 버전 관리 프로젝트의 내용을 업데이트 하기 쉬움 파일의 변경 히스토리를 확인하고, 이전 버전으로 되돌릴 수 있음
• 백업 로컬 컴퓨터 외에 클라우드 상에 저장하여 안전하게 보관 노트북이 고장나도 Github에 업로드된 파일은 그대로 유지

*Github 계정 등록, 로컬 저장소 만들기, add/commit/push *

✅ 여기서 잠깐! Git과 Github의 차이점은?

• Git: 로컬에서 버전 관리하는 도구
• Github: Git에서 사용하는 프로젝트를 클라우드에서 협업하고 관리하는 플랫폼

쉽게 말하면, Git은 그림을 그릴 때마다 어떤 변화가 있었는지 기억해주고 저장해주는 똑똑한 공책, Github는 그림을 올려 친구들과 함께 그릴 수 있는 웹사이트

✅ 아래의 코드를 따라 기본적인 Github세팅을 시작해보자!

# 로컬 Git에 Github 계정 정보 등록하기
# Github 가입 시 사용한 email과 username 입력 
$ git config --global user.email "my-email@gmail.com"
$ git config --global user.name "my-username"

# 내 컴퓨터에 'workplace'라는 로컬 저장소 만들기
# mkdir는 make directory라는 뜻
$ mkdir workplace

# '이 폴더 안의 파일들을 Git으로 관리할거야!' 라는 명령
$ git init

# workplace 내에 README.md 파일 생성하기,
# #first-repository라는 문구를 README.md 파일 내에 추가
$ echo "#first-repository" >> README.md

# Git에 변경사항 저장하기 (add, commit)
$ git add README.md
$ git commit -m "커밋에 대한 설명메시지"

✅ Add와 Commit의 차이점은?

파일을 Github에 업로드하기 위해서는 Add->Commit->Push 의 과정이 필요

• Add: 로컬에서 수정한 파일을 스테이징 영역으로 올리는 명령어. Add를 해야만 "이 파일을 다음 commit에 포함시켜 주세요" 라고 알릴 수 있음

• Commit: 스테이징 영역에 있는 파일들을 로컬 저장소에 버전 기록으로 저장, 변경 히스토리도 함께 저장

• git add 👉 "이 파일들 저장할 거야!" 라고 표시해두는 단계

• git commit 👉 "좋아, 이제 진짜 저장할게!" 라고 Git에게 확정시키는 단계

# 로컬 저장소와 원격 저장소 연결하기
# xxx에는 자신의 username, first-repository 에는 자신의 레파지토리 이름
$ git remote add origin https://github.com/xxx/first-repository.git

# 로컬 저장소의 기록 원격 저장소로 전송하기
$ git config credential.helper store
$ git push origin main

원격 저장소를 로컬로 가져오기 - clone

#새로운 디렉토리 project 생성
$ mkdir project

# 깃허브의 레파지토리 project라는 파일 안에 복제
# xxx에는 자신의 username, first-repository 에는 자신의 레파지토리 이름
$ git clone https://github.com/xxx/first-repository.git

# 로컬로 가져온 레파지토리의 내용 수정
$ echo "새로운 내용을 추가합니다" >> README.md

# 수정된 내용을 원격 저장소에 다시 add, commit, push
$ git add README.md
$ git commit -m "커밋에 대한 설명메시지"
$ git push origin main

# 원격 저장소로부터 내용을 불러와 workplace 저장소에도 수정 내용 업데이트 (pull)
$ git pull origin main

그 이외에 도움이 되는 기본 명령어들

1. cd: change directory
# project 디렉토리로 변경해주라는 의미
$ cd project

2. pwd: print working directory
# 현재 작업 중인 디렉토리의 전체 경로 출력
$ pwd

3. ls: list
# 현재 디렉토리에 있는 파일과 폴더 목록을 보여줌
$ ls

4. cat README.md
# README.md 파일의 내용을 출력함 
$ cat README.md

5. git status
# 현재 git 저장소의 상태를 보여줌
$ git status