1. 카이제곱 검정 종류

카이제곱 검정에는 주로 두 가지 유형이 있다.

1) 적합성 검정 (Goodness-of-Fit Test)

• 특정 범주형 데이터가 기대되는 분포를 따르는지 검정
• 예: 주사위를 100번 던졌을 때 각 눈금이 균등하게 나왔는지 확인

2) 독립성 검정 (Test for Independence)

• 두 개의 범주형 변수가 서로 독립적인지 검정
• 예: 성별과 제품 선호도 간의 연관성 분석

2. 카이제곱 검정 가정
   1. 데이터는 범주형이어야 한다.
   2. 각 셀(범주)에서 기대 빈도가 5 이상이어야 한다.
   3. 표본은 독립적이어야 한다.

3. 카이제곱 검정 통계량

   카이제곱 검정에서 사용되는 검정 통계량$$(χ²)$$은 다음과 같이 계산된다.

$$\chi^2 = \sum \frac{(O_i - E_i)^2}{E_i}$$

• $$O_i$$ : 관찰된 값(Observed frequency)

• $$E_i$$ : 기대값(Expected frequency)

  카이제곱 값이 클수록 관찰값과 기대값의 차이가 크다는 의미이며, 유의수준$$(α)$$과 비교하여 귀무가설을 기각할지 결정한다.

4. 카이제곱 검정의 귀무가설과 대립가설 • 귀무가설$$(H₀)$$: 두 범주형 변수는 독립적이다. • 대립가설$$(H₁)$$: 두 범주형 변수는 독립적이지 않다 (즉, 연관성이 있다).

   ---

5. Python을 활용한 카이제곱 검정 예제

   (1) 적합성 검정 예제 예제: 한 가게에서 각 요일별 방문자 수가 동일한지 확인

    import numpy as np
   import scipy.stats as stats
   
    # 요일별 실제 방문자 수 (관측값)
   observed = np.array([50, 55, 45, 60, 40, 50, 65])
   
    # 기대 방문자 수 (균등 분포 가정)
   expected = np.full(len(observed), np.mean(observed))
   
    # 카이제곱 검정 수행
   chi2_stat, p_value = stats.chisquare(observed, expected)
   
   print(f"Chi-Square Statistic: {chi2_stat:.4f}")
   print(f"P-value: {p_value:.4f}")
   
    # 결과 해석
   alpha = 0.05
   if p_value < alpha:
    print("귀무가설 기각: 요일별 방문자 수는 균등하지 않다.")
   else:
    print("귀무가설 채택: 요일별 방문자 수는 유의미한 차이가 없다.")
   

---

(2) 독립성 검정 예제

• 예제: 성별(남성, 여성)과 제품 선호도(A, B, C)가 독립적인지 검정

      import pandas as pd
  import scipy.stats as stats
  
  # 관찰된 데이터 (성별과 제품 선호도)
  observed = np.array([[30, 10, 20],  # 남성
                       [40, 20, 10]]) # 여성
  
  # 카이제곱 검정 수행
  chi2_stat, p_value, dof, expected = stats.chi2_contingency(observed)
  
  print(f"Chi-Square Statistic: {chi2_stat:.4f}")
  print(f"P-value: {p_value:.4f}")
  print(f"Expected Frequencies: \n{expected}")
  
  # 결과 해석
  alpha = 0.05
  if p_value < alpha:
      print("귀무가설 기각: 성별과 제품 선호도 간에는 연관성이 있다.")
  else:
      print("귀무가설 채택: 성별과 제품 선호도는 독립적이다.")

6. 카이제곱 검정 결과 해석 • $$p-value < 0.05$$ → 귀무가설 기각 → 두 변수 간 연관성이 있음 • $$p-value ≥ 0.05$$ → 귀무가설 채택 → 두 변수는 독립적임

카이제곱 검정은 범주형 변수 간의 관계를 분석하는 데 유용하지만, 데이터의 크기와 기대 빈도를 고려해야 한다.

독립표본 T-검정(Independent Samples T-test)은 두 개의 독립된 집단 간 평균 차이가 통계적으로 유의한지를 검정하는 방법이다. 즉, 두 그룹의 평균이 동일한 모집단에서 나왔는지 여부를 확인하는 데 사용된다.

2. 가정 (Assumptions)

독립표본 T-검정을 수행하기 위해 다음과 같은 가정이 충족되어야 한다. 1. 독립성: 두 집단의 데이터가 서로 독립적이어야 한다. 2. 정규성: 각 집단의 데이터가 정규분포를 따라야 한다. (샘플 크기가 충분히 크다면 중심극한정리에 의해 완화될 수 있음) 3. 등분산성: 두 집단의 분산이 동일해야 한다. (Levene’s test를 통해 확인 가능)

3. 검정 가설 (Hypothesis Testing) • 귀무가설 $$(H₀)$$: 두 집단의 평균이 동일하다. $$(\mu_1 = \mu_2)$$ • 대립가설 $$(H₁)$$: 두 집단의 평균이 다르다. $$(\mu_1 \neq \mu_2)$$

4. T-통계량 (Test Statistic) 계산

두 집단의 평균이 같다는 귀무가설 하에서 검정 통계량 $$t$$ 는 다음과 같이 계산된다.

$$t = \frac{\bar{X}_1 - \bar{X}_2}{\sqrt{\frac{s_1^2}{n_1} + \frac{s_2^2}{n_2}}}$$

• $$\bar{X}_1, \bar{X}_2$$ : 두 집단의 표본 평균
• $$s_1^2, s_2^2$$ : 두 집단의 표본 분산
• $$n_1, n_2$$ : 각 집단의 표본 크기

5. 검정 결과 해석 • p-value < 유의수준(α) → 귀무가설 기각 → 두 집단의 평균이 통계적으로 유의하게 다르다. • p-value ≥ 유의수준(α) → 귀무가설 채택 → 두 집단의 평균 차이가 통계적으로 유의하지 않다.

   ---

   Python 코드 예제: 독립표본 T-검정 수행

   import numpy as np
    import scipy.stats as stats
   
    # 두 그룹의 샘플 데이터 생성
    group1 = np.random.normal(loc=50, scale=10, size=30)  # 평균 50, 표준편차 10, 30개 샘플
    group2 = np.random.normal(loc=55, scale=10, size=30)  # 평균 55, 표준편차 10, 30개 샘플
   
    # 독립표본 T-검정 수행
    t_stat, p_value = stats.ttest_ind(group1, group2, equal_var=True)  # 등분산 가정
   
    print(f"T-statistic: {t_stat:.4f}")
    print(f"P-value: {p_value:.4f}")
   
    # 결과 해석
    alpha = 0.05
    if p_value < alpha:
        print("귀무가설 기각: 두 그룹의 평균은 유의미하게 다르다.")
    else:
        print("귀무가설 채택: 두 그룹의 평균 차이는 유의하지 않다.")

1. 정의

다중공선성은 회귀 분석에서 독립 변수들 간 강한 상관관계가 존재하는 현상을 의미한다. 독립 변수 간의 상관성이 높을 경우 회귀 분석의 결과가 왜곡될 수 있다.

2. 발생 원인 • 변수 간 높은 상관관계 • 불필요한 중복 변수 포함 • 데이터 변환 과정에서 유사한 변수 생성 • 표본 크기에 비해 변수 개수가 많을 때

3. 문제점 • 회귀 계수의 신뢰성이 낮아짐 • 회귀 계수의 부호 및 크기가 불안정해짐 • 작은 데이터 변화에도 결과가 크게 변동 • 독립 변수의 영향력을 해석하기 어려움

4. 다중공선성 진단 방법

   1. 상관계수 행렬 (Correlation Matrix) • 독립 변수 간 상관계수가 0.8 이상이면 다중공선성을 의심할 수 있다.
   2. 분산팽창계수 (Variance Inflation Factor, VIF) • VIF = \frac{1}{1 - R^2} • VIF 값이 10을 초과하면 다중공선성이 심각하다고 판단한다.
   3. 조건수 (Condition Number) • 30 이상이면 다중공선성이 의심되며, 100 이상이면 심각한 수준이다.

5. 해결 방법 • 변수 제거: 상관관계가 높은 변수 중 하나를 제거 • 주성분 분석 (PCA): 변수 차원을 축소하여 다중공선성을 완화 • 릿지 회귀 (Ridge Regression): 정규화 기법을 활용해 회귀 계수의 변동성을 줄임 • 데이터 수집 확대: 표본 크기를 늘려 다중공선성 영향을 완화

6. Python을 활용한 다중공선성 확인

    import pandas as pd
    import numpy as np
    from statsmodels.stats.outliers_influence import variance_inflation_factor
    from sklearn.datasets import load_diabetes
   
    # 데이터 불러오기
    data = load_diabetes()
    df = pd.DataFrame(data.data, columns=data.feature_names)
   
    # VIF 계산
    vif_data = pd.DataFrame()
    vif_data["Feature"] = df.columns
    vif_data["VIF"] = [variance_inflation_factor(df.values, i) for i in range(df.shape[1])]
   
    print(vif_data)

03_소인수와 소인수분해

05_최대공약수

07_최소공배수

📌 최소공배수(LCM, Least Common Multiple)

• "공통된 배수 중에서 가장 작은 수를 찾자" 🔹 “두 개 이상의 수의 배수 중에서 가장 작은 공통 배수” 예를 들어, 4와 6의 최소공배수를 구해보자. • 4의 배수: 4, 8, 12, 16, 20, 24, … • 6의 배수: 6, 12, 18, 24, 30, … • 공통 배수: 12, 24, 36, … • 가장 작은 공통 배수: 12 (최소공배수, LCM)

1️⃣ 최소공배수 구하는 방법

✅ 방법 1: 두 수의 배수를 나열하여 찾기 (직접 구하기)

def lcm(a, b):
    max_num = max(a, b)
    while True:
        if max_num % a == 0 and max_num % b == 0:
            return max_num
        max_num += 1

print(lcm(4, 6))  # 출력: 12

✅ while문을 사용하여 공통 배수를 찾을 때까지 증가시키는 방식.

✅ 방법 2: 최대공약수를 이용한 공식

$$ \text{LCM}(a, b) = \frac{a \times b}{\text{GCD}(a, b)} $$

• 최대공약수(GCD): 두 수가 공통으로 나누어지는 가장 큰 수.
• 최소공배수(LCM): 두 수를 곱한 뒤 최대공약수(GCD)로 나누면 최소공배수를 구할 수 있음.

  import math
  

def lcm(a, b): return (a * b) // math.gcd(a, b) # GCD(최대공약수) 활용

print(lcm(4, 6)) # 출력: 12 print(lcm(12, 15)) # 출력: 60

✅ **math.gcd(a, b)**를 사용하면 최대공약수를 쉽게 구할 수 있음!

---
#### ✅ 방법 3: math.lcm() (Python 3.9 이상)
- Python 3.9부터 math.lcm() 함수를 사용하면 최소공배수를 쉽게 구할 수 있음.

```python
import math

print(math.lcm(4, 6))   # 출력: 12
print(math.lcm(12, 15)) # 출력: 60

✅ Python 3.9 이상에서만 사용 가능! ✅ 최대공약수(math.gcd())와 최소공배수(math.lcm())를 함께 활용하면 편리함.

🚀 한 줄 요약

• 최소공배수(LCM) = “두 수의 공통 배수 중 가장 작은 값” $$ \text{LCM}(a, b) = \frac{a \times b}{\text{GCD}(a, b)} $$
• Python에서 쉽게 구하는 방법 • math.gcd(a, b)를 사용하여 공식으로 계산 • Python 3.9 이상이면 math.lcm(a, b) 사용 가능

09_진법

📌 프로그래밍에서 사용되는 다양한 진법

컴퓨터는 10진법(Decimal) 대신 2진법(Binary)을 기반으로 동작하지만, 프로그램에서는 2진법(0과 1), 8진법(07), 16진법(0F) 등을 함께 사용한다.

1️⃣ 10진법 (Decimal, 10)

🔹 “우리가 일상에서 사용하는 숫자 시스템”

• 기본 숫자 체계로 0~9까지의 숫자를 사용.
• 자리값이 10씩 증가 (1, 10, 100, 1000…).

📌 예시

345 = (3 × 100) + (4 × 10) + (5 × 1)

✅ 일반적인 숫자 표현 방식이며, 우리가 평소에 사용하는 방식.

2️⃣ 2진법 (Binary, 0b)

🔹 “컴퓨터가 직접 이해하는 숫자 시스템”

• 0과 1만 사용.
• 자리값이 2씩 증가 (1, 2, 4, 8, 16…).

📌 예시

(1011)₂ = (1 × 8) + (0 × 4) + (1 × 2) + (1 × 1) = (11)₁₀

✅ 2진법 변환 (Python)

bin_num = bin(11)  # 10진수 → 2진수 변환
print(bin_num)  # 출력: '0b1011'

decimal_num = int("1011", 2)  # 2진수 → 10진수 변환
print(decimal_num)  # 출력: 11

✅ bin(숫자) → 10진수를 2진수 변환 (0b 접두사 붙음) ✅ int(문자열, 2) → 2진수를 10진수로 변환

3️⃣ 8진법 (Octal, 0o)

🔹 “2진수를 짧게 표현하는 방법”

• 0~7까지만 사용.
• 자리값이 8씩 증가 (1, 8, 64, 512…).
• 2진법보다 사람이 읽기 쉬움.

📌 예시

(17)₈ = (1 × 8) + (7 × 1) = (15)₁₀

✅ 8진법 변환 (Python)

oct_num = oct(15)  # 10진수 → 8진수 변환
print(oct_num)  # 출력: '0o17'

decimal_num = int("17", 8)  # 8진수 → 10진수 변환
print(decimal_num)  # 출력: 15

✅ oct(숫자) → 10진수를 8진수 변환 (0o 접두사 붙음) ✅ int(문자열, 8) → 8진수를 10진수로 변환

4️⃣ 16진법 (Hexadecimal, 0x)

🔹 “메모리 주소, 색상 코드 등에서 많이 사용”

• 09, AF(10~15)까지 사용.
• 자리값이 16씩 증가 (1, 16, 256, 4096…).
• 2진수보다 훨씬 더 짧게 표현 가능.

📌 예시

(2F)₁₆ = (2 × 16) + (F × 1) = (47)₁₀

✅ 16진법 변환 (Python)

hex_num = hex(47)  # 10진수 → 16진수 변환
print(hex_num)  # 출력: '0x2f'

decimal_num = int("2F", 16)  # 16진수 → 10진수 변환
print(decimal_num)  # 출력: 47

✅ hex(숫자) → 10진수를 16진수 변환 (0x 접두사 붙음) ✅ int(문자열, 16) → 16진수를 10진수로 변환

5️⃣ 2진법, 8진법, 16진법 간 변환

📌 10진수 ↔ X진수 변환 (이론 + Python)

• 1️⃣ 10진수 → X진수 변환 (수학 개념) 💡 변환 방법

  1. 10진수 숫자를 X로 나눈다.
  2. 몫과 나머지를 기록한다.
  3. 몫이 0이 될 때까지 반복한다.
  4. 나머지를 역순(뒤집어서) 나열하면 변환된 숫자가 된다.

  ---

  25를 2진법으로 변환해보자.

  25 ÷ 2 = 12 ... 1
  12 ÷ 2 =  6 ... 0
  6 ÷ 2 =  3 ... 0
  3 ÷ 2 =  1 ... 1
  1 ÷ 2 =  0 ... 1  (몫이 0이므로 종료)

  👉 결과: 25₁₀ = 11001₂

  ---

  ✅ 10진수 → 8진수 변환 (예제: 25 → 8진수)

   25 ÷ 8 = 3 ... 1
  3 ÷ 8 = 0 ... 3  (몫이 0이므로 종료)

  👉 결과: 25₁₀ = 31₈

  ---

  ✅ 10진수 → 16진수 변환 (예제: 25 → 16진수)

   25 ÷ 16 = 1 ... 9
  1 ÷ 16 = 0 ... 1  (몫이 0이므로 종료)

  👉 결과: 25₁₀ = 19₁₆

  ---

📌 Python으로 진수 변환 ✅ 내장 함수 사용

num = 25

binary = bin(num)  # 2진수 변환
octal = oct(num)   # 8진수 변환
hexadecimal = hex(num)  # 16진수 변환

print(binary, type(binary))  # 출력: 0b11001 <class 'str'>
print(octal, type(octal))    # 출력: 0o31 <class 'str'>
print(hexadecimal, type(hexadecimal))  # 출력: 0x19 <class 'str'>

✅ 변환 결과는 문자열로 나온다.

✅ 2진수 → 8진수 / 16진수

binary_num = "1011"

# 2진수를 8진수로 변환
octal_value = oct(int(binary_num, 2))
print(octal_value)  # 출력: '0o13'

# 2진수를 16진수로 변환
hex_value = hex(int(binary_num, 2))
print(hex_value)  # 출력: '0xb'

✅ 8진수 / 16진수 → 2진수

octal_num = "17"
hex_num = "2F"

# 8진수를 2진수로 변환
binary_value = bin(int(octal_num, 8))
print(binary_value)  # 출력: '0b1111'

# 16진수를 2진수로 변환
binary_value = bin(int(hex_num, 16))
print(binary_value)  # 출력: '0b101111'

제로베이스 코드

dNum = 30

# 10진수 -> X진수
print('2진수: {}'.format(bin(dNum))) # 2진수: 0b11110
print('8진수: {}'.format(oct(dNum))) # 8진수: 0o36
print('16진수: {}'.format(hex(dNum))) # 16진수: 0x1e


print('Type of bin(dNum): {}'.format(type(bin(dNum)))) # Type of bin(dNum): <class 'str'>
print('Type of oct(dNum): {}'.format(type(oct(dNum)))) # Type of oct(dNum): <class 'str'>
print('Type of oct(dNum): {}'.format(type(hex(dNum)))) # Type of oct(dNum): <class 'str'>


# 10진수 -> X진수(format()함수 이용)
print('2진수: {}'.format(format(dNum, '#b'))) # 2진수: 0b11110
print('8진수: {}'.format(format(dNum, '#o'))) # 8진수: 0o36
print('16진수: {}'.format(format(dNum, '#x'))) # 16진수: 0x1e

print('Type of bin(dNum): {}'.format(type(format(dNum, '#b')))) # Type of bin(dNum): <class 'str'>
print('Type of oct(dNum): {}'.format(type(format(dNum, '#o')))) # Type of oct(dNum): <class 'str'>
print('Type of oct(dNum): {}'.format(type(format(dNum, '#x')))) # Type of oct(dNum): <class 'str'>

print('2진수: {0:#b}, 8진수: {0:#o}, 16진수: {0:#x}'.format(dNum, dNum, dNum)) # 2진수: 0b11110, 8진수: 0o36, 16진수: 0x1e
print('2진수: {0:#b}, 8진수: {0:#o}, 16진수: {0:#x}'.format(dNum)) # 2진수: 0b11110, 8진수: 0o36, 16진수: 0x1e

print('2진수: {}'.format(format(dNum, 'b'))) # 2진수: 11110
print('8진수: {}'.format(format(dNum, 'o'))) # 8진수: 36
print('16진수: {}'.format(format(dNum, 'x'))) # 16진수: 1e

print('Type of bin(dNum): {}'.format(type(format(dNum, 'b')))) # Type of bin(dNum): <class 'str'>
print('Type of oct(dNum): {}'.format(type(format(dNum, 'o')))) # Type of oct(dNum): <class 'str'>
print('Type of oct(dNum): {}'.format(type(format(dNum, 'x')))) # Type of oct(dNum): <class 'str'>

print('2진수: {0:b}, 8진수: {0:o}, 16진수: {0:x}'.format(dNum)) # 2진수: 11110, 8진수: 36, 16진수: 1e


# X진수 -> 10진수
print('2진수(0b11110) -> 10진수({})'.format(int('0b11110', 2))) # 2진수(0b11110) -> 10진수(30)
print('8진수(0o36) -> 10진수({})'.format(int('0o36', 8))) # 8진수(0o36) -> 10진수(30)
print('16진수(0x1e) -> 10진수({})'.format(int('0x1e', 16))) # 16진수(0x1e) -> 10진수(30)



# X진수 -> X진수
print('2진수(0b11110) -> 8진수({})'.format(oct(0b11110))) # 2진수(0b11110) -> 8진수(0o36)
print('2진수(0b11110) -> 10진수({})'.format(int(0b11110))) # 2진수(0b11110) -> 10진수(30)
print('2진수(0b11110) -> 16진수({})'.format(hex(0b11110))) # 2진수(0b11110) -> 16진수(0x1e)


print('8진수(0o36) -> 2진수({})'.format(bin(0o36))) # 8진수(0o36) -> 2진수(0b11110)
print('8진수(0o36) -> 10진수({})'.format(int(0o36))) # 8진수(0o36) -> 10진수(30)
print('8진수(0o36) -> 16진수({})'.format(hex(0o36))) # 8진수(0o36) -> 16진수(0x1e)


print('16진수(0x1e) -> 2진수({})'.format(bin(0x1e))) # 16진수(0x1e) -> 2진수(0b11110)
print('16진수(0x1e) -> 8진수({})'.format(oct(0x1e))) # 16진수(0x1e) -> 8진수(0o36)
print('16진수(0x1e) -> 10진수({})'.format(int(0x1e))) # 16진수(0x1e) -> 10진수(30)

11_수열

📌 수열(數列, Sequence)

1️⃣ 수열의 개념

수열(Sequence)이란 규칙성을 가지고 나열된 수의 집합을 의미한다.

• 수열은 자연수의 집합과 1:1 대응되는 함수로 볼 수도 있다.
• 수열의 각 원소(항, term)는 일반적으로 $$a_n$$으로 표현한다.
• 초항(첫 번째 항)을 $$a_1$$ , 두 번째 항을 $$a_2 , …, n$$ 번째 항을 $$a_n$$ 으로 표기한다.

📌 수열의 예시

• 1. 등차수열: 1, 3, 5, 7, 9, … (각 항이 일정한 차이로 증가)
• 2. 등비수열: 2, 4, 8, 16, 32, … (각 항이 일정한 비율로 증가)
• 3. 피보나치 수열: 1, 1, 2, 3, 5, 8, 13, … (이전 두 항의 합)

     1️⃣.1️⃣ 수열의 합 (부분합, $$S_n$$ )

수열에서 처음부터 n번째 항까지의 합을 부분합(Partial Sum)이라고 한다.

• 보통 $$S_n$$ 으로 표현하며,
• $$S_n = a_1 + a_2 + a_3 + … + a_n$$

2️⃣ 수열의 표현 방법

수열은 일반항 또는 점화식으로 표현할 수 있다.

✅ 일반항(Explicit Formula)

수열의 각 항을 n에 대한 식으로 표현하는 방식. 예: 등차수열
$$ a_n = 2n - 1 $$

n = 1 → a₁ = 2(1) - 1 = 1
n = 2 → a₂ = 2(2) - 1 = 3
n = 3 → a₃ = 2(3) - 1 = 5
(결과: 1, 3, 5, 7, 9, ...)

✅ 점화식(Recursive Formula)

이전 항을 이용하여 현재 항을 구하는 방식. 예: 피보나치 수열 a_n = a_{n-1} + a_{n-2} (단, a_1 = 1 , a_2 = 1 )

a₁ = 1
a₂ = 1
a₃ = a₂ + a₁ = 1 + 1 = 2
a₄ = a₃ + a₂ = 2 + 1 = 3
(결과: 1, 1, 2, 3, 5, 8, 13, ...)

12_등차 수열

📌 등차수열(Arithmetic Sequence)

각 항이 일정한 차이(공차, $$d$$ )로 증가하는 수열

• 일반항: $$a_n = a_1 + (n-1)d$$

• 부분합 공식: $$S_n = \frac{n}{2} (2a_1 + (n-1)d)$$

또는

• $$S_n = \frac{n}{2} (a_1 + a_n)$$

• ✅ 예제: 등차수열 (초항: 1, 공차: 2)의 합 구하기 수열: $$1, 3, 5, 7, 9, …$$ 부분합 예제 $$( S_5 )$$ $$S_5 = 1 + 3 + 5 + 7 + 9 = 25$$ Python 구현

def arithmetic_sum(a1, d, n):
    return (n / 2) * (2 * a1 + (n - 1) * d)

print(arithmetic_sum(1, 2, 5))  # 출력: 25.0

✅ Python에서 공식을 사용하면 빠르게 합을 계산할 수 있음!

2️⃣ 등차중항 (Arithmetic Mean)

등차중항은 두 수 $$a$$ 와 $$b$$ 사이에 위치하는 값으로, 등차수열의 성질을 만족하는 값이다. ✅ 등차중항 공식 두 항 $$a$$ 와 $$b$$ 사이에 한 개의 항 $$x$$ 가 있을 때:

$$x = \frac{a + b}{2}$$ 📌 즉, 등차중항은 두 항의 평균!

3️⃣ 등차수열의 합 (Sum of Arithmetic Sequence)

등차수열의 처음부터 $$n$$번째 항까지의 합을 부분합(Partial Sum, $$S_n$$ )이라고 한다.

• ✅ 등차수열의 합 공식 $$S_n = \frac{n}{2} (2a_1 + (n-1) \cdot d)$$ 또는 $$S_n = \frac{n}{2} (a_1 + a_n)$$ 여기서, $$S_n$$ : 처음부터 $$n$$ 번째 항까지의 합 $$a_1$$ : 초항 $$d$$ : 공차 $$a_n$$ : n번째 항 $$n$$ : 항의 개수

• 💡 예제 등차수열 $$(2, 5, 8, 11, 14, …)$$ 에서 처음 5개 항의 합을 구해보자.
  • 초항: $$a_1 = 2$$
  • 공차: $$d = 3$$
  • 항의 개수: $$n = 5$$
  • $$S_5 = \frac{5}{2} \times (2 \times 2 + (5-1) \times 3)$$
  • $$S_5 = \frac{5}{2} \times (4 + 12) = \frac{5}{2} \times 16 = 40$$

✅ Python 코드

def arithmetic_sum(a1, d, n):
    return (n / 2) * (2 * a1 + (n - 1) * d)

print(arithmetic_sum(2, 3, 5))  # 출력: 40.0

✅ 일반항을 이용하면 특정 항을 쉽게 구할 수 있고, 합 공식을 사용하면 빠르게 부분합을 구할 수 있음!

🚀 정리

일반항 : $$a_n = a_1 + (n-1) d$$

• n번째 항을 구하는 공식

등차중항 : $$x = \frac{a + b}{2}$$

• 두 항 사이의 값 (평균)

등차수열의 합 : $$S_n = \frac{n}{2} (2a_1 + (n-1) d) 또는 S_n = \frac{n}{2} (a_1 + a_n)$$

• 처음부터 n번째 항까지의 합

✅ 등차수열은 일정한 차이로 증가하는 수열! ✅ 일반항을 이용하면 특정 항을 쉽게 구할 수 있음! ✅ 등차수열의 합 공식으로 빠르게 부분합 계산 가능!

15_등비 수열

18_시그마

19_계차 수열

21_피보나치 수열

22_팩토리얼

23_군 수열

25_순열

41_[중급문제풀이] 함수(02)

42_[중급문제풀이] 함수(03)

43_[중급문제풀이] 함수(04)

44_[중급문제풀이] 함수(05)

45_[중급문제풀이] 함수(06)

46_[중급문제풀이] 모듈(01)

47_[중급문제풀이] 모듈(02)

48_[중급문제풀이] 모듈(03)

49_[중급문제풀이] 모듈(04)

50_[중급문제풀이] 모듈(05)

51_[중급문제풀이] 모듈(06)

52_[중급문제풀이] 모듈(07)

53_[중급문제풀이] 클래스(01)

54_[중급문제풀이] 클래스(02)

55_[중급문제풀이] 클래스(03)

56_[중급문제풀이] 클래스(04)

57_[중급문제풀이] 클래스(05)

58_[중급문제풀이] 클래스(06)

59_[중급문제풀이] 클래스(07)

60_[중급문제풀이] 예외처리(01)

61_[중급문제풀이] 예외처리(02)

62_[중급문제풀이] 예외처리(03)

63_[중급문제풀이] 예외처리(04)

64_[중급문제풀이] 예외처리(05)

65_[중급문제풀이] 텍스트 파일(01)

66_[중급문제풀이] 텍스트 파일(02)

67_[중급문제풀이] 텍스트 파일(03)

68_[중급문제풀이] 텍스트 파일(04)

69_[중급문제풀이] 텍스트 파일(05)

1. math 모듈 math 모듈은 수학 관련 함수들을 제공하는 표준 라이브러리다.

import math

print(math.sqrt(16))    # 출력: 4.0 (제곱근) 제곱근 반환 (√x)
print(math.pow(2, 3))   # 출력: 8.0 (거듭제곱) 거듭제곱 (x^y)
print(math.factorial(5)) # 출력: 120 (5!)  팩토리얼 계산 (n!)
print(math.gcd(48, 18)) # 출력: 6 (최대공약수) 최대공약수 (GCD)
print(math.floor(3.9))  # 출력: 3 (내림) 내림 (소수점 이하 버림)
print(math.ceil(3.1))   # 출력: 4 (올림) 올림 (소수점 이하 올림)
print(math.pi)          # 출력: 3.141592653589793 원주율 π 값
print(math.e)           # 출력: 2.718281828459045 자연로그 e 값

2. random 모듈 random 모듈은 난수를 생성하는 기능을 제공한다.

import random

print(random.random())   # 0.0 ~ 1.0 사이 난수
print(random.randint(1, 10))  # 1~10 사이 정수 난수
print(random.uniform(1.5, 5.5))  # 1.5~5.5 사이 실수 난수

lst = [1, 2, 3, 4, 5]
print(random.choice(lst))  # 리스트에서 랜덤 선택
print(random.choices(lst, k=3))  # 중복 가능하게 3개 선택
print(random.sample(lst, 2))  # 중복 없이 2개 선택

random.shuffle(lst)  # 리스트 요소 섞기
print(lst)

3. time 모듈 time 모듈은 시간 관련 기능을 제공한다.

   import time
   

print(time.time()) # 현재 시간(Unix timestamp) time.sleep(2) # 2초 동안 실행 멈춤 print("2초 후 실행됨")

current_time = time.localtime() print(time.strftime("%Y-%m-%d %H:%M:%S", current_time)) # 현재 시간을 YYYY-MM-DD HH:MM:SS 형태로 출력

### 17_객체지향 프로그래밍
1️⃣. 객체(Object)란?
객체는 **속성(데이터)**과 **기능(메서드, 동작)**을 포함하는 독립적인 단위다.

예를 들어 자동차 객체를 생각해보자.
   🚗 자동차 객체의 예시
        •    속성(Attributes, 변수)
        •    색상: 빨강
        •    브랜드: 현대
        •    속도: 60km/h

   기능(Methods, 함수)
    •    가속(): 속도 증가
    •    감속(): 속도 감소
    •    멈춤(): 정지

```python
class Car:
    def __init__(self, color, brand, speed=0):
        self.color = color  # 속성
        self.brand = brand  # 속성
        self.speed = speed  # 속성

    def accelerate(self):  # 기능(메서드)
        self.speed += 10
        print(f"{self.brand} 자동차 속도 증가: {self.speed}km/h")

    def brake(self):  # 기능(메서드)
        self.speed -= 10
        print(f"{self.brand} 자동차 속도 감소: {self.speed}km/h")

# 객체 생성
my_car = Car("빨강", "현대")

# 기능 실행
my_car.accelerate()  # 출력: 현대 자동차 속도 증가: 10km/h
my_car.brake()       # 출력: 현대 자동차 속도 감소: 0km/h

2️⃣. 객체지향 프로그래밍의 4대 특징

   ✅ 객체(Object) = 속성(데이터) + 기능(메서드)
  ✅ 캡슐화: 데이터를 숨기고 메서드를 통해 접근
  ✅ 상속: 부모 클래스의 기능을 자식 클래스가 재사용
  ✅ 다형성: 같은 메서드 이름이지만 클래스마다 다르게 동작
  ✅ 추상화: 필요한 기능만 노출하고, 세부 사항은 숨김

1) 캡슐화 (Encapsulation)
    •    속성과 메서드를 하나의 객체로 묶고, 외부에서 직접 접근을 제한하는 것.
    •    보통 속성을 private(비공개) 속성으로 만들고, 메서드를 통해 접근한다.

    class BankAccount:
        def __init__(self, owner, balance=0):
            self.owner = owner      # 공개 속성
            self.__balance = balance  # 비공개 속성 (외부에서 접근 불가)

        def deposit(self, amount):
            self.__balance += amount
            print(f"{self.owner}님, {amount}원이 입금되었습니다.")

        def get_balance(self):
            return self.__balance

    # 객체 생성
    account = BankAccount("홍길동", 1000)

    # balance 속성은 직접 접근 불가
    # print(account.__balance)  # 오류 발생

    # 대신 메서드를 통해 접근
    print(account.get_balance())  # 출력: 1000
    account.deposit(500)
    print(account.get_balance())  # 출력: 1500

2) 상속 (Inheritance)
    •    기존 클래스를 재사용하여 새로운 클래스를 만드는 것.
    •    **부모 클래스(기본 클래스)**의 속성과 메서드를 **자식 클래스(파생 클래스)**가 상속받아 사용할 수 있다.
    # 부모 클래스
class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        print("소리를 낸다.")

# 자식 클래스
class Dog(Animal):
    def make_sound(self):
        print(f"{self.name}가 멍멍 짖는다.")

# 객체 생성
dog = Dog("바둑이")
dog.make_sound()  # 출력: 바둑이가 멍멍 짖는다.

3) 다형성 (Polymorphism)
    •    같은 메서드 이름을 사용하지만, 각 클래스에서 다르게 동작하도록 하는 것.
    class Bird:
        def fly(self):
            print("새가 난다.")

    class Airplane:
        def fly(self):
          print("비행기가 난다.")

    # 동일한 fly() 메서드를 호출하지만, 각 객체마다 다르게 동작
    bird = Bird()
    airplane = Airplane()

    bird.fly()      # 출력: 새가 난다.
    airplane.fly()  # 출력: 비행기가 난다.

4) 추상화 (Abstraction)
    •    불필요한 부분은 숨기고, 필요한 부분만 보여주는 것.
    •    추상 클래스를 사용하여 공통적인 기능을 정의하고, 구체적인 구현은 자식 클래스에서 하도록 강제한다.
    from abc import ABC, abstractmethod

    # 추상 클래스
    class Animal(ABC):
        @abstractmethod
        def make_sound(self):
            pass  # 자식 클래스에서 반드시 구현해야 함

    # 자식 클래스
    class Cat(Animal):
        def make_sound(self):
            print("야옹!")

    class Dog(Animal):
        def make_sound(self):
            print("멍멍!")

    # 객체 생성
    cat = Cat()
    dog = Dog()

    cat.make_sound()  # 출력: 야옹!
    dog.make_sound()  # 출력: 멍멍!

18_클래스와 객체 생성

객체지향 프로그래밍(OOP)에서 클래스(Class)는 객체를 생성하기 위한 설계도(청사진)이고, 객체(Object)는 그 설계도를 기반으로 만들어진 실제 인스턴스(Instance)이다.

1. 클래스(Class)

• 클래스는 속성(변수)과 메서드(함수)를 포함하는 템플릿(설계도)이다.
• 객체를 생성하기 위한 틀 역할을 한다.

클래스 정의 방법

class 클래스이름:
    # 생성자 (객체 생성 시 실행되는 특수한 메서드)
    def __init__(self, 속성1, 속성2):
        self.속성1 = 속성1
        self.속성2 = 속성2

    # 메서드 정의
    def 메서드이름(self):
        print("이것은 메서드입니다.")

2. 객체(Object) 생성

• 클래스를 이용해 객체를 만들려면 클래스이름()을 호출하면 된다.
• 객체를 생성할 때 init() 메서드가 실행되어 초기 값을 설정한다.

# 클래스 정의
class Person:
    def __init__(self, name, age):  # 생성자 (객체 생성 시 실행)
        self.name = name  # 속성 (name)
        self.age = age    # 속성 (age)

    def introduce(self):  # 메서드
        print(f"안녕하세요, 제 이름은 {self.name}이고, 나이는 {self.age}살입니다.")

# 객체 생성
person1 = Person("홍길동", 25)
person2 = Person("김철수", 30)

# 메서드 호출
person1.introduce()  # 출력: 안녕하세요, 제 이름은 홍길동이고, 나이는 25살입니다.
person2.introduce()  # 출력: 안녕하세요, 제 이름은 김철수이고, 나이는 30살입니다.

3. 클래스의 주요 개념

(1) 생성자 (init)

• __ __ init__ __()는 객체가 생성될 때 자동으로 실행되는 초기화 메서드이다.
• 객체의 속성(변수)을 설정하는 역할을 한다.

    class Car:
      def __init__(self, brand, color):
          self.brand = brand
          self.color = color

    car1 = Car("현대", "빨강")  # 객체 생성 (자동으로 __init__ 실행)
    print(car1.brand)  # 출력: 현대
    print(car1.color)  # 출력: 빨강

(2) 인스턴스 변수와 클래스 변수

🔹 인스턴스 변수 - self.변수명 형태로 선언된 변수. - 각 객체(인스턴스)마다 개별적으로 저장된다.

class Dog:
    def __init__(self, name):
        self.name = name  # 인스턴스 변수

dog1 = Dog("바둑이")
dog2 = Dog("초코")

print(dog1.name)  # 출력: 바둑이
print(dog2.name)  # 출력: 초코

🔹 클래스 변수 - 클래스이름.변수명 형태로 선언된 변수. - 클래스에 속한 모든 객체가 공유한다.

    class Animal:
    species = "포유류"  # 클래스 변수

    dog = Animal()
    cat = Animal()

    print(dog.species)  # 출력: 포유류
    print(cat.species)  # 출력: 포유류

(3) 메서드(Method)

• 클래스 내부에서 정의된 함수로, 특정 기능을 수행한다.

• self를 첫 번째 인자로 받으며, 이는 현재 객체(인스턴스)를 의미한다.

    class Calculator:
        def add(self, a, b):
            return a + b
  
        def subtract(self, a, b):
            return a - b
  
    calc = Calculator()  # 객체 생성
    print(calc.add(10, 5))  # 출력: 15
    print(calc.subtract(10, 5))  # 출력: 5

(4) 클래스 메서드와 정적 메서드

🔹 클래스 메서드 (@classmethod)

• 클래스 변수를 다룰 때 사용되며, 클래스 자체에 접근할 수 있다.

• 첫 번째 인자로 cls를 받는다.

  class Animal:
    species = "포유류"  # 클래스 변수
  
    @classmethod
    def set_species(cls, new_species):
        cls.species = new_species
  

Animal.set_species("파충류") print(Animal.species) # 출력: 파충류

🔹 정적 메서드 (@staticmethod)

- self나 cls를 사용하지 않고 독립적으로 동작하는 함수.
- 일반 함수와 비슷하지만 클래스 내부에서 정의되는 차이점이 있다.
```python
class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

print(MathUtils.add(3, 7))  # 출력: 10

📌 정리

✅ 클래스: 객체를 생성하는 설계도 ✅ 객체: 클래스를 기반으로 만들어진 실제 인스턴스 ✅ 생성자 (init): 객체가 생성될 때 실행되는 초기화 함수 ✅ 인스턴스 변수: 각 객체별로 개별 저장 ✅ 클래스 변수: 모든 객체가 공유 ✅ 메서드: 클래스 내부에서 정의된 함수 ✅ 클래스 메서드 (@classmethod): 클래스 자체를 조작할 때 사용 ✅ 정적 메서드 (@staticmethod): 독립적인 함수 역할 수행

19_객체 속성 변경

객체를 생성한 후, 속성을 변경하는 방법과 객체가 메모리에 어떻게 관리되는지

1. 객체 속성 변경 (Attribute Modification)

🔹 (1) 직접 속성 변경

• 객체의 속성값은 객체명.속성명 = 새로운 값 형태로 직접 변경할 수 있다.

  class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
  

객체 생성

p1 = Person("홍길동", 25)

속성 변경

p1.age = 30 print(p1.age) # 출력: 30

🔹 (2) 메서드를 통한 속성 변경
- 속성 변경을 직접 하지 않고, 메서드를 통해 변경하는 것이 더 안전한 방법이다.
```python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def set_age(self, new_age):  # 나이 변경 메서드
        if new_age > 0:
            self.age = new_age
        else:
            print("나이는 0보다 커야 합니다.")

# 객체 생성
p1 = Person("김철수", 20)

# 메서드를 통한 속성 변경
p1.set_age(35)
print(p1.age)  # 출력: 35

p1.set_age(-5)  # 출력: 나이는 0보다 커야 합니다.

🔹 (3) setattr() 함수로 속성 변경

• 파이썬 내장 함수 setattr(객체, "속성명", 값)을 사용하면 속성을 변경할 수 있다.

  class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
  

객체 생성

car = Car("현대", "빨강")

setattr()을 이용한 속성 변경

setattr(car, "color", "파랑") print(car.color) # 출력: 파랑

🔹 (4) __dict__로 속성 변경

- 객체의 속성들을__ __ dict__ __()속성을 이용해 딕셔너리 형태로 확인하고 변경할 수 있다.
```python
class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

dog = Animal("바둑이", "강아지")

# 객체의 속성 출력
print(dog.__dict__)  # 출력: {'name': '바둑이', 'species': '강아지'}

# 속성 변경
dog.__dict__["name"] = "초코"
print(dog.name)  # 출력: 초코

20_객체와 메모리

객체와 메모리 관리 : 파이썬에서는 객체가 메모리에 어떻게 관리되는지 이해하는 것이 중요하다.

🔹 (1) 객체의 메모리 할당

• 객체가 생성되면, 힙(Heap) 메모리에 저장된다.
• 변수는 객체의 참조(Reference)를 저장하며, 변수 자체는 스택(Stack) 메모리에 저장된다.

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

p1 = Person("홍길동") # p1은 '홍길동' 객체의 참조를 저장함

📌 메모리 구조
- p1은 스택 메모리에 저장됨 (객체의 참조값 저장)
- Person("홍길동") 객체는 힙 메모리에 저장됨

----
🔹 (2) 여러 변수가 같은 객체를 참조할 경우

- 두 개의 변수가 같은 객체를 참조하면, 하나의 변수를 변경해도 다른 변수에도 영향을 준다.
```python
a = [1, 2, 3]
b = a  # b는 a와 같은 객체를 참조함

b.append(4)

print(a)  # 출력: [1, 2, 3, 4]
print(b)  # 출력: [1, 2, 3, 4]

📌 a와 b는 같은 메모리 주소를 참조하므로 b를 변경하면 a도 변경됨.

✅ 확인 방법 (id()) 객체의 메모리 주소(참조 ID)를 확인하려면 id() 함수를 사용하면 된다.

print(id(a))  # a의 메모리 주소 출력
print(id(b))  # b의 메모리 주소 출력 (a와 동일)

🔹 (3) 얕은 복사 vs 깊은 복사

얕은 복사 (Shallow Copy)

• 복사본이 원본과 같은 객체를 참조하므로, 하나를 변경하면 다른 것도 영향을 받음.

  import copy
  

lst1 = [1, 2, [3, 4]] lst2 = copy.copy(lst1) # 얕은 복사

lst2[2].append(5) print(lst1) # 출력: [1, 2, [3, 4, 5]] print(lst2) # 출력: [1, 2, [3, 4, 5]]

#### 깊은 복사 (Deep Copy)
-  원본과 독립적인 복사본을 만든다.
```python
lst1 = [1, 2, [3, 4]]
lst2 = copy.deepcopy(lst1)  # 깊은 복사

lst2[2].append(5)
print(lst1)  # 출력: [1, 2, [3, 4]]
print(lst2)  # 출력: [1, 2, [3, 4, 5]]

Immutable과 Mutable 🔹 (4) 가비지 컬렉션 (Garbage Collection)

• 파이썬은 자동으로 메모리를 관리하며, 사용되지 않는 객체는 가비지 컬렉터(GC)가 자동 삭제한다.
• 객체의 참조(reference) 개수가 0이 되면 자동으로 메모리에서 삭제됨.

  import gc
  

class Test: def del(self): print("객체가 메모리에서 삭제됨")

obj = Test() # 객체 생성 del obj # 객체 삭제 (가비지 컬렉터가 실행되면 del이 호출됨)

gc.collect() # 가비지 컬렉터 수동 실행

---

#### 📌 정리

#### ✅ 객체 속성 변경
    •    객체.속성 = 값 방식으로 직접 변경
    •    setattr(객체, "속성", 값)으로 변경
    •    __dict__를 활용한 속성 변경

#### ✅ 객체의 메모리 관리
    •    객체는 힙(Heap) 메모리에 저장되고, 변수가 이를 참조
    •    id(객체)를 사용하면 객체의 메모리 주소 확인 가능
    •    copy.copy()(얕은 복사)와 copy.deepcopy()(깊은 복사) 차이 이해 필요
    •    참조 카운트가 0이 되면 가비지 컬렉션(GC)에 의해 자동 삭제됨
### 21_얕은복사와 깊은복사

### 22_클래스 상속
#### 📌 클래스 상속 (Inheritance)
 클래스 상속은 기존 클래스를 재사용하여 새로운 클래스를 만드는 기법이다.
부모 클래스(기본 클래스)의 속성(변수)과 메서드(함수)를 자식 클래스(파생 클래스)가 물려받아 사용할 수 있다.

Class 1

#### 1. 상속의 개념

- 부모 클래스 (Super Class, Base Class): 기존의 클래스
- 자식 클래스 (Sub Class, Derived Class): 부모 클래스를 상속받아 확장한 클래스
---
#### 2. 상속 기본 문법

🔹 기본적인 상속

```python
# 부모 클래스 정의
class Parent:
    def parent_method(self):
        print("부모 클래스 메서드")

# 자식 클래스 정의 (Parent를 상속)
class Child(Parent):
    def child_method(self):
        print("자식 클래스 메서드")

# 객체 생성
child = Child()
child.parent_method()  # 부모 클래스 메서드 호출 가능
child.child_method()   # 자식 클래스 메서드 호출

✅ Child 클래스는 Parent 클래스를 상속받았으므로, parent_method()를 직접 사용할 수 있다.

3. 생성자 (__ init __()) 상속

부모 클래스의__ init __()을 자식 클래스에서 재사용하거나, 확장할 수 있다. 🔹 부모의 생성자 사용하기 (super())

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"이름: {self.name}, 나이: {self.age}")

class Student(Person):  # Person 클래스를 상속
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 부모 클래스의 __init__() 호출
        self.student_id = student_id  # 자식 클래스만의 속성 추가

    def introduce(self):
        super().introduce()  # 부모 클래스의 introduce() 호출
        print(f"학번: {self.student_id}")

# 객체 생성
s1 = Student("김철수", 20, "2024001")
s1.introduce()

📌 실행 결과

이름: 김철수, 나이: 20
학번: 2024001

✅ super().__ init __(...)을 호출하여 부모 클래스의 생성자를 실행한 후, 추가적인 속성을 설정한다.

4. 메서드 오버라이딩 (Method Overriding)

• 부모 클래스의 메서드를 자식 클래스에서 재정의(덮어쓰기)하는 것을 오버라이딩(Overriding)이라고 한다.
• 같은 이름의 메서드를 자식 클래스에서 다시 정의하면 부모의 메서드를 덮어씀.

class Animal:
    def make_sound(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def make_sound(self):  # 부모 메서드 재정의 (오버라이딩)
        print("멍멍!")

# 객체 생성
dog = Dog()
dog.make_sound()  # 출력: 멍멍!

✅ Dog 클래스에서 make_sound()를 재정의했기 때문에, 부모의 메서드가 아니라 자식 클래스의 메서드가 실행된다.

🔹 부모의 메서드도 호출하고 싶다면?

class Dog(Animal):
    def make_sound(self):
        super().make_sound()  # 부모 메서드 호출
        print("멍멍!")

dog = Dog()
dog.make_sound()

📌 실행 결과

동물이 소리를 냅니다.
멍멍!

5. 다중 상속 (Multiple Inheritance)

파이썬에서는 하나의 클래스가 여러 개의 부모 클래스를 상속받을 수 있다.

class Parent1:
    def method1(self):
        print("Parent1의 메서드")

class Parent2:
    def method2(self):
        print("Parent2의 메서드")

# 다중 상속
class Child(Parent1, Parent2):
    def child_method(self):
        print("자식 클래스 메서드")

# 객체 생성
child = Child()
child.method1()  # Parent1에서 상속받은 메서드
child.method2()  # Parent2에서 상속받은 메서드
child.child_method()  # 자식 클래스 메서드

✅ Child 클래스는 Parent1, Parent2 두 개의 부모 클래스를 상속받았으므로 모두 사용 가능하다.

6. 상속 관계 확인 (issubclass(), isinstance())

🔹 issubclass(자식클래스, 부모클래스)

• 특정 클래스가 다른 클래스를 상속받았는지 확인

print(issubclass(Student, Person))  # True
print(issubclass(Dog, Animal))  # True
print(issubclass(Dog, Person))  # False

🔹 isinstance(객체, 클래스)

• 객체가 특정 클래스의 인스턴스인지 확인

  s = Student("이영희", 21, "2024002")
  

print(isinstance(s, Student)) # True print(isinstance(s, Person)) # True (Student가 Person을 상속했으므로) print(isinstance(s, Dog)) # False

---
#### 📌 정리
✅ 상속(Inheritance): 기존 클래스(부모 클래스)의 속성과 메서드를 새로운 클래스(자식 클래스)가 물려받음
✅ super(): 부모 클래스의 생성자(__init__)나 메서드를 호출할 때 사용
✅ 메서드 오버라이딩(Method Overriding): 부모 클래스의 메서드를 자식 클래스에서 재정의
✅ 다중 상속(Multiple Inheritance): 하나의 클래스가 여러 부모 클래스를 상속받을 수 있음
✅ issubclass(), isinstance(): 클래스 상속 관계 확인

---
### 23~ 24_생성자 (01, 02)
#### 🌱 1. __ __init__ __()(생성자)란?
📌 “객체가 생성될 때 자동으로 실행되는 특수한 메서드!”

- 객체가 생성될 때, 생성자를 호출하면, 자동으로 __ __init__ __()이 호출됨
- __ __init__ __()가 속성을 초기화함. 
- 객체를 만들 때(클래스이름()) 자동으로 실행돼서 초기값(속성)을 설정함
- 생성자가 없으면 기본값을 가진 객체가 생성됨.

✅ 예제: __ __init__ __( ) 사용하기

```python
class Person:
    def __init__(self, name, age):  # 생성자
        self.name = name  # 속성 설정
        self.age = age

# 객체 생성 (생성자 실행됨!)
p1 = Person("홍길동", 25)
p2 = Person("김철수", 30)

print(p1.name, p1.age)  # 출력: 홍길동 25
print(p2.name, p2.age)  # 출력: 김철수 30

✅ p1과 p2를 만들 때 __ init __( )이 실행되어 자동으로 name과 age 속성이 설정됨!

🏠 2. 객체 속성 (self.속성명)

📌 “객체마다 고유한 정보를 저장하는 변수!”

• 객체 속성은 각 객체마다 독립적으로 저장됨.
• self.속성명 = 값 형태로 선언.
• self는 현재 객체 자신을 가리킴.

✅ 예제: 객체 속성

class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 자동차 브랜드
        self.color = color  # 자동차 색상

# 객체 생성
car1 = Car("현대", "빨강")
car2 = Car("기아", "파랑")

print(car1.brand, car1.color)  # 출력: 현대 빨강
print(car2.brand, car2.color)  # 출력: 기아 파랑

✅ car1과 car2는 각각 다른 속성 값(브랜드, 색상)을 가진 독립적인 객체야.

🔗 3. super()란?

📌 “부모 클래스의 기능을 자식 클래스에서 가져올 때 사용!”

• 상속받은 부모 클래스의 __ init __() 또는 메서드를 그대로 실행하고 싶을 때 사용.
• 상위 클래스의 속성을 초기화 하기위해서 super()을 사용
• 코드를 중복 없이 깔끔하게 유지할 수 있음.

✅ 예제: super()를 사용한 상속

class Animal:
    def __init__(self, species):
        self.species = species  # 동물 종류 설정

class Dog(Animal):  # Animal을 상속받음
    def __init__(self, species, name):
        super().__init__(species)  # 부모 클래스의 생성자 호출
        self.name = name  # 추가 속성

dog = Dog("포유류", "바둑이")

print(dog.species)  # 출력: 포유류 (부모 클래스에서 상속)
print(dog.name)     # 출력: 바둑이 (자식 클래스에서 추가)

✅ super()._ init __ __(species)를 사용해서 부모 클래스의 __ __init __()을 실행! ✅ Dog 클래스는 부모 속성 + 추가 속성을 가짐.

25_다중 상속

📌 다중 상속 (Multiple Inheritance)

🔹 “하나의 클래스가 두 개 이상의 부모 클래스를 상속받는 것” ✔ 일반적인 상속은 부모 클래스 하나만 상속받지만, 다중 상속은 여러 부모 클래스로부터 기능을 물려받을 수 있음. ✔ 여러 클래스를 조합해서 더 강력한 클래스를 만들 때 유용함. ✔ 다중 상속을 사용하면 여러 부모 클래스의 속성과 메서드를 모두 활용할 수 있음.

1️⃣ 다중 상속 기본 구조

class Parent1:
    def feature1(self):
        return "👨‍👩‍👧 부모1의 기능"

class Parent2:
    def feature2(self):
        return "🧑‍🎨 부모2의 기능"

# 다중 상속
class Child(Parent1, Parent2):
    def feature3(self):
        return "👶 자식 클래스의 기능"

# 객체 생성
child = Child()

print(child.feature1())  # 👨‍👩‍👧 부모1의 기능
print(child.feature2())  # 🧑‍🎨 부모2의 기능
print(child.feature3())  # 👶 자식 클래스의 기능

✅ Child 클래스는 Parent1과 Parent2의 기능을 모두 상속받아 사용할 수 있음.

2️⃣ super()를 활용한 다중 상속

super()는 부모 클래스의 메서드를 호출할 때 사용되는데, 다중 상속에서는 어느 부모 클래스의 메서드가 먼저 실행될지 중요함.

💡 다중 상속에서 super() 사용

class Parent1:
    def __init__(self):
        print("👨‍👩‍👧 Parent1 생성자 호출")

class Parent2:
    def __init__(self):
        print("🧑‍🎨 Parent2 생성자 호출")

class Child(Parent1, Parent2):
    def __init__(self):
        super().__init__()  # 부모 생성자 호출
        print("👶 Child 생성자 호출")

child = Child()

👨‍👩‍👧 Parent1 생성자 호출
👶 Child 생성자 호출

✅ super()는 첫 번째 부모(Parent1)의 init()만 호출되었음! ✅ 다중 상속에서는 MRO(Method Resolution Order)라는 규칙을 따름.

4️⃣ super()를 다중 호출하려면? 위 예제에서는 super()를 사용했을 때 Parent1만 호출되고 Parent2는 호출되지 않았음. ➡ 이를 해결하려면 모든 부모 클래스에서 super()를 호출해야 함!

class Parent1:
    def __init__(self):
        super().__init__()
        print("👨‍👩‍👧 Parent1 생성자 호출")

class Parent2:
    def __init__(self):
        super().__init__()
        print("🧑‍🎨 Parent2 생성자 호출")

class Child(Parent1, Parent2):
    def __init__(self):
        super().__init__()
        print("👶 Child 생성자 호출")

child = Child()

🧑‍🎨 Parent2 생성자 호출
👨‍👩‍👧 Parent1 생성자 호출
👶 Child 생성자 호출

✅ 모든 부모 클래스에서 super().init()을 호출하면 MRO 순서에 따라 모든 부모 클래스의 생성자가 실행됨!

5️⃣ 다이아몬드 상속 문제 (Diamond Problem) 다중 상속을 사용할 때, 부모 클래스가 같은 조상을 공유하면 메서드가 중복 호출될 수 있음. 💡 다이아몬드 상속 예제

class A:
    def show(self):
        print("A 클래스")

class B(A):
    def show(self):
        print("B 클래스")

class C(A):
    def show(self):
        print("C 클래스")

class D(B, C):  # B와 C는 둘 다 A를 상속
    pass

d = D()
d.show()

B 클래스

✅ D는 B와 C를 상속받았지만, MRO에 따라 왼쪽의 B가 먼저 실행됨! ✅ 다이아몬드 문제 해결 방법: super()를 올바르게 사용하면 해결됨.

📌 다중 상속 정리

✔다중 상속 :하나의 클래스가 여러 부모 클래스를 상속

    class C(A, B):

✔super() :부모 클래스의 메서드를 호출할 때 사용

    super().__init__()

✔MRO :메서드 탐색 순서

    Class.mro()

✔다이아몬드 문제 :같은 조상을 공유하는 다중 상속 문제

    class D(B, C):

🚀 한 줄 요약! ✔ 다중 상속은 여러 부모 클래스의 기능을 자식 클래스에서 동시에 사용할 수 있도록 해줌! ✔ super()를 사용하면 MRO 순서에 따라 부모 클래스가 호출됨. ✔ 다이아몬드 문제를 해결하려면 super()를 모든 부모 클래스에서 올바르게 호출해야 함.

26_오버라이딩

🔥 오버라이딩 (Overriding)

✔ “부모 클래스로부터 물려받은 메서드를 자식 클래스에서 재정의(덮어쓰기)하는 것” ✔ 부모 클래스와 같은 이름, 같은 매개변수를 가지지만 동작을 다르게 변경 ✔ 상속 관계에서만 발생

class Parent:
    def say_hello(self):
        return "👴 부모: 안녕하세요!"

class Child(Parent):
    def say_hello(self):  # 부모의 메서드를 재정의 (오버라이딩)
        return "👦 자식: 안녕!"

child = Child()
print(child.say_hello())  # 출력: 👦 자식: 안녕!

🔥 오버로딩 (Overloading)

✔ “같은 이름의 메서드를 여러 개 정의하는 것” ✔ 매개변수 개수나 타입이 다를 때, 다른 방식으로 동작 ✔ 파이썬에서는 직접 지원되지 않음!

🚨 파이썬에서는 오버로딩을 직접 지원하지 않음!

C++, Java 같은 언어에서는 가능하지만, 파이썬에서는 같은 이름의 메서드를 여러 개 만들면 덮어씌워진다.

class Example:
    def add(self, a, b):
        return a + b

    def add(self, a, b, c):  # 이전 `add`를 덮어씌움 (오버로딩 불가)
        return a + b + c

ex = Example()
print(ex.add(1, 2))  # 오류 발생! (오버로딩이 안됨)

✅ 해결 방법: 기본값을 설정하거나, *args 사용

class Example:
    def add(self, a, b, c=0):  # 기본값 설정으로 오버로딩처럼 구현
        return a + b + c

ex = Example()
print(ex.add(1, 2))    # 출력: 3
print(ex.add(1, 2, 3)) # 출력: 6

class Example:
    def add(self, *args):  # 여러 개의 인자 처리 가능
        return sum(args)

ex = Example()
print(ex.add(1, 2))      # 출력: 3
print(ex.add(1, 2, 3))   # 출력: 6
print(ex.add(1, 2, 3, 4)) # 출력: 10

🚀 오버라이딩 vs 오버로딩 차이 정리 오버라이딩 (Overriding) ✔ 개념: 부모 클래스의 메서드를 자식 클래스에서 덮어쓰기 ✔ 어디서 사용?: 상속에서만 사용 가능 ✔ 메서드 이름: 같아야 함 ✔ 매개변수: 같음 (변경 불가) ✔ 파이썬 지원 여부: ✅ 지원

오버로딩 (Overloading) ✔ 개념: 같은 이름의 메서드를 여러 개 정의 ✔ 어디서 사용?: 일반적으로 같은 클래스 내에서 사용 ✔ 메서드 이름: 같아야 함 ✔ 매개변수: 개수, 타입이 다를 수 있음 ✔ 파이썬 지원 여부: ❌ 직접 지원 안됨 (대체 방법 필요)

📌 한 줄 요약

• 오버라이딩 = 부모 메서드를 덮어씀(재정의) (상속 필수)
• 오버로딩 = 같은 이름의 메서드를 여러 개 만들기 (파이썬에서는 직접 지원 안됨)

27_추상클래스

📌 추상 클래스 (Abstract Class)란?

🔹 “객체를 직접 생성할 수 없고, 반드시 상속해서 사용해야 하는 클래스” ✔ 공통적인 기능을 정의하지만, 구체적인 구현은 자식 클래스에서 강제하도록 하는 클래스 ✔ “틀(템플릿)” 역할을 하며, 상속받은 클래스는 반드시 특정 메서드를 구현해야 함 ✔ abc (Abstract Base Class) 모듈을 사용하여 구현

1️⃣ 추상 클래스 기본 문법

✅ ABC 모듈을 사용해 추상 클래스 만들기

from abc import ABC, abstractmethod  # 추상 클래스 관련 모듈

# 추상 클래스 정의
class Animal(ABC):  
    @abstractmethod  # 추상 메서드 (반드시 구현해야 함)
    def make_sound(self):
        pass  # 구현 X → 자식 클래스에서 구현해야 함

# 자식 클래스에서 반드시 추상 메서드를 구현해야 함!
class Dog(Animal):
    def make_sound(self):  
        return "🐶 멍멍!"

class Cat(Animal):
    def make_sound(self):
        return "🐱 야옹!"

# 객체 생성
dog = Dog()
cat = Cat()

print(dog.make_sound())  # 출력: 🐶 멍멍!
print(cat.make_sound())  # 출력: 🐱 야옹!

✅ Animal 클래스는 추상 클래스이므로 직접 객체를 생성할 수 없음! ✅ Dog와 Cat 클래스는 반드시 make_sound() 메서드를 구현해야 함.

2️⃣ 추상 클래스를 상속받아 구현하기

자식 클래스에서 추상 메서드를 반드시 구현해야 함!

class Dog(Animal):  # Animal을 상속받음
    def make_sound(self):  # 반드시 구현해야 함!
        return "🐶 멍멍!"

class Cat(Animal):
    def make_sound(self):  # 반드시 구현해야 함!
        return "🐱 야옹!"

# 객체 생성
dog = Dog()
cat = Cat()

print(dog.make_sound())  # 출력: 🐶 멍멍!
print(cat.make_sound())  # 출력: 🐱 야옹!

✅ Dog, Cat 클래스는 Animal을 상속받아 반드시 make_sound()를 구현해야 함. ✅ 만약 구현하지 않으면 에러 발생! (TypeError: Can't instantiate abstract class)

3️⃣ 추상 클래스의 특징 🚨 (1) 추상 클래스는 직접 객체를 생성할 수 없음

a = Animal()  # 오류 발생! (TypeError: Can't instantiate abstract class Animal)

✅ 추상 클래스는 “설계도” 역할을 하기 때문에 직접 객체 생성이 불가능! ✅ 반드시 자식 클래스에서 상속 후, 추상 메서드를 구현해야 사용 가능!

4️⃣ 추상 클래스에서 일반 메서드도 포함 가능

추상 클래스는 추상 메서드뿐만 아니라 일반 메서드도 가질 수 있음.

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

    def sleep(self):  # 일반 메서드 (자식 클래스에서 그대로 사용 가능)
        return "😴 동물이 잠을 잔다."

class Dog(Animal):
    def make_sound(self):
        return "🐶 멍멍!"

dog = Dog()
print(dog.make_sound())  # 출력: 🐶 멍멍!
print(dog.sleep())       # 출력: 😴 동물이 잠을 잔다.

✅ sleep()은 일반 메서드이므로 자식 클래스에서 그대로 사용할 수 있음.

5️⃣ 추상 클래스를 활용하는 이유 💡 “강제성 부여 & 코드 일관성 유지” ✔부모 클래스를 상속받은 모든 자식 클래스가 반드시 특정 메서드를 구현하도록 강제함. ✔공통적인 기능을 추상 클래스로 정의하면, 유지보수가 쉬워짐. ✔다형성(Polymorphism)을 활용할 수 있음.

animals = [Dog(), Cat()]  # 리스트에 여러 객체 저장 가능 (다형성)

for animal in animals:
    print(animal.make_sound())  # 서로 다른 객체가 같은 메서드를 호출

✅ make_sound()를 모든 자식 클래스가 구현해야 하므로, animals 리스트에서 일관된 방식으로 호출 가능.

📌 정리 ✔ 추상 클래스 : 직접 객체를 만들 수 없는 클래스 (ABC 사용) ✔ 추상 메서드 : 자식 클래스에서 반드시 구현해야 하는 메서드 (@abstractmethod) ✔ 일반 메서드 포함 가능 : 추상 클래스에서도 일반 메서드를 정의할 수 있음 ✔ 객체 생성 불가 : TypeError 발생 (Animal()처럼 직접 인스턴스화 불가) ✔ 사용 이유 : 코드 강제성 부여, 유지보수 편리, 다형성 활용

🚀 한 줄 요약! ✅ 추상 클래스는 “설계도” 같은 역할을 하며, 자식 클래스에서 반드시 구현해야 하는 메서드를 정해줌! ✅ 객체를 직접 만들 수 없고, 상속받은 자식 클래스에서만 사용 가능! ✅ 추상 클래스를 사용하면 코드의 일관성이 유지되고, 유지보수가 편리해짐!

28_예외란?

29_예외처리

30_try ~ except ~ else

31_finally

32_Exception 클래스

33_사용자 Exception 클래스

34_텍스트 파일 쓰기

35_텍스트 파일 읽기

36_텍스트 파일 열기

37_with ~ as문

38_writelines()

39_readlines(), readline()

40_[중급문제풀이] 함수(01)

41_[중급문제풀이] 함수(02)

42_[중급문제풀이] 함수(03)

52_[기초문제풀이] 연산자(05)

53_[기초문제풀이] 조건문(01)

54_[기초문제풀이] 조건문(02)

55_[기초문제풀이] 조건문(03)

56_[기초문제풀이] 조건문(04)

57_[기초문제풀이] 조건문(05)

58_[기초문제풀이] 조건문(06)

59_[기초문제풀이] 반복문(01)

60_[기초문제풀이] 반복문(02)

61_[기초문제풀이] 반복문(03)

62_[기초문제풀이] 반복문(04)

63_[기초문제풀이] 반복문(05)

64_[기초문제풀이] 반복문(06)

01_함수란?

02_함수 선언과 호출

03_함수 내에서 또 다른 함수 호출

04_인수와 매개변수

05_데이터 반환

06_지역변수와 전역변수

07_중첩함수

08_lambda 함수

09_모듈

10_모듈 제작

11_모듈 사용

12_실행(메인) 파일 (01)

13_실행(메인) 파일 (02)

14_패키지

15_site-packages

22_비교 연산자(문자 비교)

23_논리 연산자

24_operator 모듈

25_조건식

26_조건문(if문)

27_양자택일 조건문(if~else문)

28_if~else문과 조건식

29_다자택일 조건문(if~elif문)

30_다자택일 조건문 사용 시 주의할 점

31_중첩 조건문

32_반복문

33_횟수에 의한 반복(for문)

34_반복 범위 설정(range() 함수)

35_조건에 의한 반복(while문)

36_for문과 while문 비교

37_무한 루프

38_반복문 제어(continue)

39_반복문 제어(break)

40_중첩 반복문

41_[기초문제풀이] 파이썬 개요 및 기본 사용방법

42_[기초문제풀이] PyCharm 설치 및 기본 사용방법

43_[기초문제풀이] 데이터와 변수(01)

44_[기초문제풀이] 데이터와 변수(02)

45_[기초문제풀이] 데이터와 변수(03)

46_[기초문제풀이] 데이터와 변수(04)

47_[기초문제풀이] 데이터와 변수(05)

48_[기초문제풀이] 연산자(01)

49_[기초문제풀이] 연산자(02)

50_[기초문제풀이] 연산자(03)

1991년 개발자 귀도 반 로섬이 만듦. 
처음 소규모 프로젝트에 사용 위해서 만듦. 
몬티파이튼의 성배 라는 프로그램에 영향받아 Python 명명

파이썬의 특징 
- 무한 정수를 처리 할 수 있다.
- 문법 구조가 쉽다.
- 다양하고 뛰어난 모듈이 많다. 

02_처음 만들어 보는 프로그램

파이썬 IDLE를 실행, 
파이썬의 shell 은 간단한 코드를 작성 할 때 사용된다. 
IDLE (Integrated Development and Environment) =>통합 개발 환경 
통합 개발 환경 툴이란 프로그램 개발에 필요한 코드 작성, 디버깅, 실행 등을 위한 툴을 말하는 것으로 쉽게 생각해서 코딩 툴 이라 생각하면 된다.

03_프로그램 실행 과정

소스파일 (xxx.py) ---컴파일---> 기계어 (binary code) ->기계(PC)에서 실행 
> 컴파일러 : 우리가 작성한 코드를 컴퓨터가 이해할 수 있는 기계어로 바꿈 

필요할 때 마다 바로바로 소스파일을 오는대로, 실시간으로 기계어로 바꾼다 
> 인터프리터 :  컴파일러와 달리 실행파일을 만들지 않고, 실행이 필요 할 때 기계어로 변환 

> 컴파일러와 인터프리터 차이 
- 컴파일 언어는 소스 전체를 실행 파일로 만들고 기계에서 실행 (번역과 같다 ex. C/C++, java)
- 인터프리터 언어는 필요한 소스소드만 그때 그때 실행함, (동시 통역과 같음. ex. Python)

04_PyCharm 설치

05_데이터와 메모리 그리고 데이터 출력

    데이터가 저장되어있는 메모리 공간을 변수라 한다. 
    변수를 이용해 데이터에 접근해 데이터를 수정하거나, 삭제 등을 할 수 있다. 

06_변수

변수란? 데이터가 저장되어 있는 메모리 공간 
메모리의 주소를 직접 사용하지 않고, 변수에 이름을 붙여 변수명이라 한다 

 number        =    10 
(변수선언)<--변수 초기화--(변수 초깃값)

🔹 = (대입 연산자)

    ✔ 변수에 값을 저장할 때 사용
    ✔ 오른쪽 값을 왼쪽 변수에 할당(저장)함

x = 10
y = "hello"

🔹 == (비교 연산자)

    ✔ 두 값이 같은지 비교할 때 사용
    ✔ 결과는 True(참) 또는 False(거짓) 반환

x = 10
y = 20

print(x == y)  # False (10과 20은 다르다)
print(x == 10) # True (x는 10이므로 참)

07_변수를 사용하는 이유

변수를 사용하는 이유는 데이터를 효율적으로 저장하고 재사용하기 위해서다.
만약 변수를 사용하지 않으면, 같은 값을 계속 반복해서 입력해야 하고, 코드가 길고 관리하기 어렵다. 

    print(10 + 5)
    print(10 * 2)
    print(10 - 3)

    x = 10  # 10을 x라는 변수에 저장
    print(x + 5)
    print(x * 2)
    print(x - 3)

🔹 1. 값을 저장하고 관리하기 위해
🔹 2. 코드 재사용성과 가독성 증가
🔹 3. 유지보수와 확장성 증가
🔹 4. 메모리 효율적인 사용
🔹 5. 동적인 값 처리 가능

08_변수명은 이렇게 하세요

1️⃣ 변수명 작성 규칙 (Syntax Rules)
    #     1. 영문자(소문자, 대문자), 숫자, 밑줄(_)만 사용할 수 있음

        print(x + 5)
        print(x * 2)
        print(x - 3)

    #     2. 숫자로 시작할 수 없음

        1st_variable = 100  # ❌ 오류 발생 (변수명은 숫자로 시작할 수 없음)    

    #     3. 공백(스페이스) 포함 불가

        my variable = 10  # ❌ 오류 발생 (변수명에 공백 포함 불가)

    #     4. 파이썬의 예약어(keyword)는 변수명으로 사용할 수 없음

        def = 5  # ❌ 오류 발생 (예약어 사용 불가)
        class = 10  # ❌ 오류 발생

    #     5. 대소문자 구분됨

2️⃣ 변수명 권장 스타일 (Naming Conventions)
    #     1. 소문자와 밑줄(_)을 사용하여 작성 (snake_case)

        user_name = "Alice"  # ✅ 권장 방식
        total_price = 1500   # ✅ 권장 방식

    #     2. 클래스명은 PascalCase 사용

        class Person:
            pass

    #     3.    상수(Constant)는 대문자로 작성

        PI = 3.141592
        MAX_VALUE = 100    

    #     4.    밑줄 두 개(__)로 시작하는 변수는 내부적으로 사용되는 변수

        class Test:
            def __init__(self):
                self.__private = 10  # 클래스 내부에서만 접근 가능 (private 변수)

    #     5.    밑줄 하나(_)로 시작하는 변수는 내부적으로 사용되는 변수

        _internal_value = 42  # 암묵적으로 내부에서만 사용한다는 의미

    #     6.    밑줄 하나(_)로 끝나는 변수는 파이썬의 예약어와 구분할 때 사용

        class_ = "Python"  # `class`는 예약어이므로 `_`를 붙여 사용

    #     7.    밑줄 하나(_)만 사용하면 최근 연산 결과를 임시 저장하는 용도로 사용

        >>> 10 + 5
        15
        >>> _
        15

3️⃣ 변수명 작성 시 권장되지 않는 스타일
    # 알아보기 어려운 변수명

    a = 10  # 의미 없는 변수명
    b = 20  # 가독성이 떨어짐

    # 혼동될 수 있는 변수명

    l = 1  # 소문자 L (숫자 1과 헷갈릴 수 있음)
    O = 0  # 대문자 O (숫자 0과 헷갈릴 수 있음)

    # 이름이 너무 길거나 불필요하게 복잡한 변수명

    this_is_a_very_long_variable_name = "Too long"  
    # 길고 복잡함

09_자료형

파이썬에서 사용되는 자료형 중 기본자료형
------------------------------------------------------------
1️⃣ 기본 자료형 (Primitive Types)
    🔹 정수형 (int)
        정수를 나타내는 자료형
        크기의 제한이 없음 (C나 Java처럼 오버플로우가 발생하지 않음)

          a = 10
          b = -5    
          c = 0
          print(type(a))  # <class 'int'>

    🔹 실수형 (float)
        소수점을 포함하는 숫자
        실수는 대략 소수점 이하 17~18번째에서 데이터 손실이 일어남
        지수 표현(Exponential notation) 가능 (1.2e3 → 1.2 × 10³)

            x = 3.14
            y = -2.71
            z = 1.2e3  # 1200.0

            print(type(x))  # <class 'float'>

    🔹 문자열 (str)
        문자들의 집합 (유니코드 지원)
        작은따옴표(') 또는 큰따옴표(")로 감싸서 표현

        s1 = "Hello"
        s2 = 'Python'

        print(type(s1))  # <class 'str'>

         여러 줄 문자열 (Triple Quotes)

         text = """이것은
        여러 줄로 된
        문자열이다."""

     🔹 불리언 (bool)
         True(참) 또는 False(거짓) 값을 가짐
        0, "", [], {}, None은 False로 평가됨

        is_active = True
        is_logged_in = False

        print(type(is_active))  # <class 'bool'>

        숫자와의 관계
        print(bool(1))  # True
        print(bool(0))  # False

     🔹 NoneType (None)

        값이 없음을 나타냄 (null과 유사)

        result = None
        print(type(result))  # <class 'NoneType'>

10_자료형 변환(문자)

자료형을 변환하는 방법.
------------------------------------------------------------
1️⃣ 자료형 변환 (Type Casting)
    x = 10  # int
    y = "20"  # str

    print(int(y))  # 20 (문자열 → 정수)
    print(str(x))  # "10" (정수 → 문자열)
    print(float(x))  # 10.0 (정수 → 실수)

    🔹 타입 확인 및 변환

    •    자료형 확인

        print(type(100))  # <class 'int'>
        print(type("hello"))  # <class 'str'>
        print(type([1, 2, 3]))  # <class 'list'>

    •    자료형 변환

        print(str(10))  # "10"
        print(list("abc"))  # ['a', 'b', 'c']
        print(set([1, 2, 2, 3]))  # {1, 2, 3}

    🔹 파이썬의 동적 타이핑 (Dynamic Typing)
        파이썬은 변수의 자료형을 명시적으로 선언할 필요가 없음 (동적 타이핑).
        변수에 할당된 값에 따라 자동으로 자료형이 결정됨.

            x = 10  # int
            x = "hello"  # str (자료형 변경 가능)
            x = [1, 2, 3]  # list

        하지만 타입을 일관되게 유지하는 것이 코드 유지보수에 좋음.
        필요하면 type hints 사용 가능 (파이썬 3.5+)

            def add(a: int, b: int) -> int:
                return a + b

11_자료형 변환(숫자)

12_자료형 변환(그외 데이터)

     빈문자 vs 공백문자 
    --------------------------------------------------------
    1️⃣ 빈 문자열("")의 bool 값

         •    아무 문자도 포함하지 않은 문자열 ("")
        •    bool("")의 결과는 False

    2️⃣ 공백 문자열(" ")의 bool 값

            •    공백 문자(Space, " "), 탭("\t"), 개행문자("\n") 등은 문자로 인식
        •    bool(" ")의 결과는 True

13_데이터 입력

     파이썬에서 사용자의 입력을 받을 때는 input() 함수를 사용하며,
    입력받은 데이터의 자료형을 변환하려면 형 변환 함수
    (int(), float(), str() 등)를 사용한다.
    --------------------------------------------------------
    1️⃣ 데이터 입력받기 (input() 함수)

        input() 함수는 사용자가 입력한 값을 문자열(str) 형태로 반환한다.

        data = input("입력하세요: ")
        print("입력된 값:", data)
        print("데이터 타입:", type(data)) # <class 'str'>

    2️⃣ 입력받은 데이터 형 변환 (Type Casting)
        🔹 int() : 문자열 → 정수형 변환
        --------------------------------------------
        입력받은 값을 정수(int)로 변환하려면 int()를 사용한다.

        num = int(input("정수를 입력하세요: "))
        print("입력된 값:", num)
        print("데이터 타입:", type(num))
        ⚠ 주의:
        문자열이 정수로 변환될 수 없는 값이면 오류(ValueError)가 발생한다.

        🔹 float() : 문자열 → 실수형 변환
        ----------------------------------------------
        입력값을 실수(float)로 변환할 때는 float()를 사용한다.

        num = float(input("실수를 입력하세요: "))
        print("입력된 값:", num)
        print("데이터 타입:", type(num)) # <class 'float'>

        🔹 str() : 숫자 → 문자열 변환
        -----------------------------------------------
        숫자를 문자열로 변환할 때는 str()을 사용한다.

        num = 123
        text = str(num)
        print("변환된 값:", text)
        print("데이터 타입:", type(text))
        ------------------------------------------------

     3️⃣ 여러 개의 값 입력받기 (split())
         사용자가 여러 개의 값을 입력할 때는 split()을 활용할 수 있다.

        🔹 공백 기준으로 여러 값 입력받기

          data = input("공백으로 구분하여 입력하세요: ").split()
          # 공백으로 구분하여 입력하세요: 10 20 30
          print("입력된 값:", data)
          # 입력된 값: ['10', '20', '30']
          print("데이터 타입:", type(data))
          # 데이터 타입: <class 'list'>

        📌 split()을 사용하면 리스트(list)로 변환되며, 리스트 요소는 문자열(str)이다.

        🔹 입력값을 정수 리스트로 변환 (map() 활용)

          numbers = list(map(int, input("공백으로 구분하여 정수를 입력하세요: ").split()))
          # 공백으로 구분하여 정수를 입력하세요: 5 10 15
          print("입력된 값:", numbers)
          # 입력된 값: [5, 10, 15]
          print("데이터 타입:", type(numbers))
          # 데이터 타입: <class 'list'>
        📌 map(int, input().split())을 사용하면 입력값을 int로 변환하여 리스트로 저장할 수 있다.

        🔹 쉼표(,)로 구분된 입력값 받기

          쉼표(,)로 입력된 값을 리스트로 변환할 때 split(",")을 사용한다.

          data = input("쉼표로 구분하여 입력하세요: ").split(",")
          # 쉼표로 구분하여 입력하세요: apple,banana,grape
          print("입력된 값:", data)
          # 입력된 값: ['apple', 'banana', 'grape']     

14_데이터 출력

    1️⃣  콤마(,)를 이용한 데이터 연속 출력

        파이썬에서 print() 함수는 여러 개의 값을 쉼표(,)로 구분하여 연속 출력할 수 있다. 
        기본적으로 쉼표(,)를 사용하면 값 사이에 공백( )이 자동으로 추가된다.

        print("이름:", "홍길동", "나이:", 25, "직업:", "개발자")
        # 출력: 이름: 홍길동 나이: 25 직업: 개발자

        공백을 없애거나 다른 구분자를 넣고 싶다면 sep 옵션을 사용할 수 있다.

        print("이름:", "홍길동", "나이:", 25, "직업:", "개발자", sep=", ")
        # 출력: 이름:, 홍길동, 나이:, 25, 직업:, 개발자

    2️⃣  포맷 문자열을 이용한 데이터 출력
        🔹 f-string (Python 3.6 이상)

        name = "홍길동"
        age = 25
        job = "개발자"
        print(f"이름: {name}, 나이: {age}, 직업: {job}")
        # 출력: 이름: 홍길동, 나이: 25, 직업: 개발자

        🔹 format() 함수

        print("이름: {}, 나이: {}, 직업: {}".format(name, age, job))
        # 출력: 이름: 홍길동, 나이: 25, 직업: 개발자

        🔹 % 포맷팅 (구식 방법)

        print("이름: %s, 나이: %d, 직업: %s" % (name, age, job))
        # 출력: 이름: 홍길동, 나이: 25, 직업: 개발자



     3️⃣ 특수문자: 탭(\t)과 개행(\n)

         - 개행 문자 (\n)
        줄 바꿈을 할 때 사용한다.

        print("첫 번째 줄\n두 번째 줄\n세 번째 줄")
        # 첫 번째 줄
        # 두 번째 줄
        # 세 번째 줄

        - 탭 문자 (\t)
        탭 간격을 추가하여 정렬할 때 사용한다.

        print("이름\t나이\t직업") 
        # 이름    나이    직업
        print("홍길동\t25\t개발자")
        # 홍길동    25    개발자
        print("김철수\t30\t디자이너")
        # 김철수    30    디자이너

        - 문자열 내에서 \n, \t 등의 특수문자를 문자 그대로 
        출력하려면 백슬래시(\)를 한 번 더 사용한다.

        print("개행문자: \\n, 탭문자: \\t")
        # 출력: 개행문자: \n, 탭문자: \t

15_format()와 형식문자

    1️⃣  format() 함수
        format() 함수는 {}(중괄호)를 사용하여 문자열 내에서 변수를 삽입할 수 있다.

           name = "홍길동"
        age = 25
        job = "개발자"

        print("이름: {}, 나이: {}, 직업: {}".format(name, age, job))
        # 출력: 이름: 홍길동, 나이: 25, 직업: 개발자

        위치 인덱스를 사용하면 같은 변수를 여러 번 활용할 수 있다.
        print("이름: {0}, 나이: {1}, 직업: {0}".format(name, age))
        # 출력: 이름: 홍길동, 나이: 25, 직업: 홍길동

        키워드 인자를 사용할 수도 있다.
        print("이름: {name}, 나이: {age}, 직업: {job}".format(name="이영희", age=22, job="디자이너"))
        # 출력: 이름: 이영희, 나이: 22, 직업: 디자이너

    2️⃣  형식문자 (% 포맷팅)

        printf 스타일 포맷팅으로, % 기호를 사용하여 데이터를 삽입할 수 있다.

        형식문자    설명
          %d    정수 (decimal)
          %f    실수 (float)
          %s    문자열 (string)
          %x    16진수 (hex)
          %o    8진수 (octal)

    3️⃣ 소수점 자릿수 정하기
        소수점 이하 자리수를 조절하려면 format() 또는 f-string을 사용할 수 있다.

        1) format() 함수 활용

          pi = 3.1415926535
          print("원주율: {:.2f}".format(pi))  # 소수점 2자리까지 출력
          # 출력: 원주율: 3.14

        2) f-string 활용 (Python 3.6 이상)

            print(f"원주율: {pi:.3f}")  # 소수점 3자리까지 출력
            # 출력: 원주율: 3.142

        3) % 포맷팅 활용

            print("원주율: %.4f" % pi)  # 소수점 4자리까지 출력
            # 출력: 원주율: 3.1416

        4) 정수와 실수를 정렬하여 출력

            print("정수: {:5d}, 실수: {:8.2f}".format(42, 3.14159))
            # 출력: 정수:    42, 실수:     3.14
           {:5d}: 정수를 최소 5자리 너비로 출력 (앞에 공백 추가)
        {:8.2f}: 실수를 최소 8자리 너비로 출력, 소수점 이하 2자리까지 표시

16_산술 연산자(덧셈, 뺄셈)

    1️⃣  format() 함수
        format() 함수는 {}(중괄호)를 사용하여 문자열 내에서 변수를 삽입할 수 있다.

           name = "홍길동"
        age = 25
        job = "개발자"

        print("이름: {}, 나이: {}, 직업: {}".format(name, age, job))
        # 출력: 이름: 홍길동, 나이: 25, 직업: 개발자

        위치 인덱스를 사용하면 같은 변수를 여러 번 활용할 수 있다.
        print("이름: {0}, 나이: {1}, 직업: {0}".format(name, age))
        # 출력: 이름: 홍길동, 나이: 25, 직업: 홍길동

        키워드 인자를 사용할 수도 있다.
        print("이름: {name}, 나이: {age}, 직업: {job}".format(name="이영희", age=22, job="디자이너"))
        # 출력: 이름: 이영희, 나이: 22, 직업: 디자이너

    2️⃣  형식문자 (% 포맷팅)

        printf 스타일 포맷팅으로, % 기호를 사용하여 데이터를 삽입할 수 있다.

        형식문자    설명
          %d    정수 (decimal)
          %f    실수 (float)
          %s    문자열 (string)
          %x    16진수 (hex)
          %o    8진수 (octal)

    3️⃣ 소수점 자릿수 정하기
        소수점 이하 자리수를 조절하려면 format() 또는 f-string을 사용할 수 있다.

        1) format() 함수 활용

          pi = 3.1415926535
          print("원주율: {:.2f}".format(pi))  # 소수점 2자리까지 출력
          # 출력: 원주율: 3.14

        2) f-string 활용 (Python 3.6 이상)

            print(f"원주율: {pi:.3f}")  # 소수점 3자리까지 출력
            # 출력: 원주율: 3.142

        3) % 포맷팅 활용

            print("원주율: %.4f" % pi)  # 소수점 4자리까지 출력
            # 출력: 원주율: 3.1416

        4) 정수와 실수를 정렬하여 출력

            print("정수: {:5d}, 실수: {:8.2f}".format(42, 3.14159))
            # 출력: 정수:    42, 실수:     3.14
           {:5d}: 정수를 최소 5자리 너비로 출력 (앞에 공백 추가)
        {:8.2f}: 실수를 최소 8자리 너비로 출력, 소수점 이하 2자리까지 표시

17_산술 연산자(곱셈과 나눗셈)

18_산술 연산자(나머지와 몫)

19_산술 연산자(거듭제곱)

20_복합연산자

나는 이제는 정말로 뒤가 없다 ...

https://school.programmers.co.kr/learn/courses/30/lessons/147355?language=python3

오늘의 학습 키워드

• 문자열 처리와 슬라이싱
• 슬라이딩 윈도우를 이용한 부분 문자열 탐색
• Python 형 변환(int) 및 비교 연산
• 시간 복잡도를 고려한 효율적인 코드 작성

시간 복잡도를 고려한 효율적인 코드 작성

오늘은 문자열을 일정한 길이로 자르고,

각 부분 문자열을 정수로 변환해 비교하는 작업을 배웠다.

문제 요구에 맞게 슬라이딩 윈도우 기법을 사용하여 문자열을 효율적으로 처리했다.

Python에서는 슬라이싱 기능을 활용해 손쉽게 부분 문자열을 추출할 수 있었다.

아래 코드처럼 for문을 통해 범위 내의 인덱스를 순차적으로 슬라이싱해 비교하는 방식이다.

추가로, Python의 int() 함수로 문자열을 정수로 변환하고 비교하는 작업을 통해 조건을 체크했다.

코드와 설명

def solution(t, p):
    # p의 길이와 정수 값을 구해 놓음
    p_len = len(p)      # 문자열 p의 길이
    p_value = int(p)     # 문자열 p를 정수로 변환

    # 조건을 만족하는 부분 문자열의 개수를 세기 위한 변수
    count = 0

    # t에서 p와 같은 길이의 부분 문자열을 하나씩 추출하여 비교
    for i in range(len(t) - p_len + 1):
        substring = t[i:i + p_len]    # 길이가 p_len인 부분 문자열 추출
        if int(substring) <= p_value: # 부분 문자열을 정수로 변환 후 비교
            count += 1    # 조건을 만족하면 count 증가

    return count

코드 설명과 까다로운 처리

슬라이딩 윈도우:

만약 문자열 t = "3141592"와 p = "271"이 있을 때, 
p와 같은 길이의 부분 문자열을 t에서 찾아 비교한다고 가정하겠습니다.
    1.    처음 윈도우 설정: 처음 윈도우는 문자열의 처음부터 p의 길이까지 잡습니다.
            예를 들어, t의 처음 3자리 "314"입니다.
    2.    윈도우 이동: 그다음에는 한 글자씩 오른쪽으로 이동해
             "141", "415", "159", "592" 등의 다음 윈도우를 설정합니다.
        각 구간에서 동일한 길이로 문자열을 비교할 수 있으므로, 
        연속적인 구간을 이동하면서 처리하는 데 용이합니다.

•    p_len = len(p) → p_len = 3  (p의 길이)
•    p_value = int(p) → p_value = 271 (p의 정수형 변환)
•    count = 0 (조건을 만족하는 부분 문자열의 개수를 세기 위한 변수)

반복문은 for i in range(len(t) - p_len + 1)으로 진행되며, i가 0에서 시작해 t에서 부분 문자열을 순서대로 추출한다.

t = "3141592"와 p = "271"인 경우

어떤 문제가 있었고, 나는 어떤 시도를 했는지:

처음에는 모든 문자열을 일일이 비교하는 방식으로 접근했으나, p_len 길이로 슬라이싱해 비교하는 것이 더 효율적이라는 것을 깨달았다. 불필요한 연산을 줄이고자 int() 함수의 반복 사용을 줄이는 방법도 고민했다.

• 어떻게 해결했는지:

슬라이딩 윈도우를 통해 반복 횟수를 줄이고, 변수 변환을 한 번만 수행하도록 처리하여 효율성을 높였다. 또한, 문자열 슬라이싱을 통해 반복문의 범위를 제어했다.

• 무엇을 새롭게 알았는지:

Python의 문자열 슬라이싱과 int() 함수의 활용, 그리고 슬라이딩 윈도우 기법이 간단한 문자열 문제에서도 큰 도움이 된다는 것을 배웠다. 특히 슬라이싱을 이용한 윈도우 기법은 앞으로도 자주 사용될 수 있을 것이다.

• 내일 학습할 것은 무엇인지:

내일은 다양한 문자열 처리 기법과 알고리즘을 학습해 코딩 테스트에 대비할 예정이다.

• 오늘의 학습 키워드 • Python에서 문자열 처리 • 대소문자 구분 없이 문자열 비교하기 • 조건에 따른 Boolean 값 반환

• 공부한 내용 본인의 언어로 정리하기 오늘은 문자열에서 특정 문자의 개수를 비교하는 방법을 배웠다. 주어진 문자열에서 ‘p’와 ‘y’의 개수를 각각 세어, 두 값이 같으면 True, 다르면 False를 반환하는 문제였다. 대소문자를 구분하지 않기 위해 .lower() 메서드를 사용하여 모든 문자를 소문자로 변환했다. .count() 메서드를 활용해 ‘p’와 ‘y’의 개수를 구해 비교하였다.

• 오늘의 회고

  • 어떤 문제가 있었고, 나는 어떤 시도를 했는지 처음에는 반복문을 통해 각 문자를 하나씩 확인하며 개수를 세려고 했지만, 파이썬 내장 함수인 .lower()와 .count()가 더 간편하고 효율적임을 알게 되었다.

  • 어떻게 해결했는지 s.lower()로 문자열을 소문자로 변환한 후, s.count('p')와 s.count('y')로 ‘p’와 ‘y’의 개수를 각각 구해 비교했다.

  • 무엇을 새롭게 알았는지 파이썬의 문자열 메서드가 매우 강력하다는 것을 다시 한번 느꼈고, 특히 .count()와 .lower()를 결합해 사용하면 조건에 맞는 비교를 쉽게 수행할 수 있다는 점을 알게 되었다.

  • 내일 학습할 것은 무엇인지