라즈베리 파이에서 Mistral과 LLaVA로 AI와 함께 중국 설날 즐기는 팁 10가지

<img src="/TIL/assets/img/2024-07-13-UnlockthePowerofCreativeFinancingBuildYourOwnSellerFinancingCalculatorinPython_0.png" />

# 크리에이티브 파이낸스 소개 📊

크리에이티브 파이낸스는 전통적인 은행 대출과 모기지를 넘어 부동산을 사고 판매하는 혁신적인 방법을 가리킵니다. 이러한 방법들은 종종 구매자와 판매자 양쪽에 유연성과 혜택을 제공하여 부동산 투자에서 특히 매력적입니다.

높은 가격, 높은 이자율, 그리고 낮은 재고로 특징 지어지는 현재 시장에서는, 크리에이티브 파이낸싱 전략은 이러한 도전에 대처하고자 하는 부동산 투자자에게 특히 가치 있는 솔루션일 수 있습니다 🚀.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 판매자 융자란 무엇인가요? 🤔

![이미지](/TIL/assets/img/2024-07-13-UnlockthePowerofCreativeFinancingBuildYourOwnSellerFinancingCalculatorinPython_1.png)

판매자 융자는 판매자가 구매자를 위해 구매를 융자하는 거래로, 은행 대출을 받는 대신 구매자가 직접 판매자에게 지불하는 방식을 말합니다 🤝.

이는 구매자가 부동산을 쉽게 구입하고, 판매자가 그렇지 않으면 어려운 부동산을 판매하는 데 도움을 줄 수 있습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 왜 판매자 금융이 부동산 투자자에게 가장 좋은 선택인가요?

- 유연한 조건 📝: 투자자는 이자율, 계약금 및 지불 일정 등 양쪽 모두에게 가장 적합한 조건을 협상할 수 있습니다.
- 쉬운 자격 요건 ✔️: 전통 은행 대출에 자격이 없는 구매자도 부동산을 구매할 수 있습니다.
- 판매자에게 더 높은 수익률 📈: 판매자들은 금융된 금액에 대한 이자를 받아 더 높은 수익을 올릴 수 있습니다.
- 현재 시장 상황 🌟: 높은 가격, 높은 이자율 및 낮은 재고가 특징인 현재 기후 속에서 판매자 금융은 중요한 장점을 제공할 수 있습니다. 이는 투자자들이 여전히 수익성 있는 부동산을 찾고 자금을 조달할 수 있도록 거래를 창의적으로 구조화할 수 있게 해줍니다.

# 실시간 판매자 금융 계산기 ⏱️

파이썬으로 직접 판매자 금융 계산기를 작성하기에 들어가기 전에, Streamlit 앱을 소개하고 싶습니다 💻.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 앱은 여기에서 이용할 수 있으며, 우리가 살펴볼 동일한 코드를 실시간으로 사용할 수 있게 해줍니다. 매개변수를 입력하고 결과를 즉시 확인할 수 있어 잠재적 거래를 분석하는 강력한 도구가 될 것입니다.

# Python으로 판매자 금융 계산기 만들기 🐍

단계별로 판매자 금융 계산기를 만드는 과정을 살펴보겠습니다. Python을 사용하여 기능을 구현할 것입니다. 사용 사례의 매개변수는 다음과 같습니다:

- sale_price = 379900
- down_payment_rate = 10
- annual_interest_rate = 3.5
- loan_term_years = 30
- balloon_due_years = 5
- interest_only_years = False


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 단계 1: 초기 대출 금액 설정 💵

우선, 계산해야 하는 것은 계약금 및 초기 대출 금액입니다.

```js
# 매개변수
sale_price = 379900
down_payment_rate = 10

# 초기 대출 금액 계산
down_payment = int(sale_price * (down_payment_rate / 100))
loan_amount = sale_price - down_payment

# 결과 출력
print(f"계약금: ${down_payment:0,.0f}")
print(f"대출 금액: ${loan_amount:0,.0f}")
```

설명: 우리는 판매 가격과 계약금 비율에 기반하여 계약금을 계산하고, 판매 가격에서 계약금을 뺀 결과를 통해 대출 금액을 결정합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 단계 2: 매월 상환액 계산하기 📅

이제, 매월 지불해야 하는 주택담보 대출 상환액을 계산합니다.

```js
# 추가 매개변수
연간 이자율 = 3.5
대출 기간(년) = 30

# 월 이자율
월 이자율 = 연간 이자율 / 100 / 12
# 총 상환 횟수
총 상환 횟수 = 대출 기간(년) * 12

# 완전 상환 대출의 매월 상환액 계산
if 월 이자율 > 0:
    매월 상환액 = 대출금액 * 월 이자율 / (1 - (1 + 월 이자율) ** -총 상환 횟수)
else:
    매월 상환액 = 대출금액 / 총 상환 횟수

# 결과 출력
print(f"매월 상환액: ${매월 상환액:0,.2f}")
```

해설: 대출금액, 연간 이자율 및 대출 기간을 사용하여 매월 상환액을 계산합니다. 이 단계에서는 월 이자율을 결정하고 완전 상환 대출의 매월 상환액 공식을 사용합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 단계 3: 분할 상환 표 작성하기 📊

이제 대출 기간 동안 지불을 추적하기 위한 분할 상환 표를 생성합니다.

```js
import pandas as pd

# 분할 상환 표 생성
amortization_table = []
balance = loan_amount
for month in range(1, total_payments + 1):
    interest_payment = balance * monthly_interest_rate
    principal_payment = monthly_payment - interest_payment
    balance -= principal_payment
    amortization_table.append([month, round(monthly_payment, 2), round(interest_payment, 2), round(principal_payment, 2), max(round(balance, 2), 0)]

# DataFrame으로 변환하여 분할 상환 표 표시
df_amortization_table = pd.DataFrame(amortization_table, columns=["월", "매월 상환액", "이자", "원금", "잔여 대출 잔액"])

# 분할 상환 표의 처음 몇 행을 출력
df_amortization_table.head()
```

설명: 월별 지불의 이자 및 원금 부분을 계산하고 남은 대출 잔액을 업데이트합니다. 이 정보는 분할 상환 표에 저장되며 DataFrame을 사용하여 표시됩니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 단계 4: 풍선 상환 및 이자 전만기 처리하기 🎈

풍선 상환 또는 이자 전만기가 있는 시나리오를 처리해야 합니다.

```js
# 추가 매개변수
balloon_due_years = 5
interest_only_years = False

# 풍선 상환을 위해 분할상환표 조정
if balloon_due_years:
    total_payments_balloon = balloon_due_years * 12
    amortization_table_balloon = amortization_table[:total_payments_balloon]
    balloon_payment = amortization_table_balloon[-1][-1]
    amortization_table_balloon[-1][-1] = 0  # 풍선 상환 후 잔액은 0으로 설정

    # DataFrame으로 변환
    df_amortization_table = pd.DataFrame(amortization_table_balloon, columns=["월", "월 상환액", "이자", "원금", "잔여 잔액"])

    # 조정된 분할상환표의 처음 몇 행 출력
    print(df_amortization_table.head())
    print(f"풍선 상환금: ${balloon_payment:0,.2f}")

# 총 지급 이자
total_interest_paid = df_amortization_table["이자"].sum()
print(f"총 이자 지급액: ${total_interest_paid:0,.2f}")

# 총 지급액
total_payments_made = df_amortization_table["월 상환액"].sum() + (balloon_payment if balloon_due_years else 0)
print(f"총 지급액: ${total_payments_made:0,.2f}")
```

설명: 풍선 상환금이 있을 경우, 분할상환표를 이에 맞게 조정합니다. 풍선 상환 후 잔금은 0으로 설정됩니다. 또한 총 지급 이자와 총 지급액을 계산합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 완성된 코드 구현 🖥️

판매자 금융 계산기의 전체 코드입니다:

```js
import pandas as pd

# 매개변수
sale_price = 379900
down_payment_rate = 10
annual_interest_rate = 3.5
loan_term_years = 30
balloon_due_years = 5
interest_only_years = False

# 초기 대출액 계산
down_payment = int(sale_price * (down_payment_rate / 100))
loan_amount = sale_price - down_payment

# 월 이자율
monthly_interest_rate = annual_interest_rate / 100 / 12
# 총 상환 횟수
total_payments = loan_term_years * 12

# 완전상환 대출의 월 상환액 계산
if monthly_interest_rate > 0:
    monthly_payment = loan_amount * monthly_interest_rate / (1 - (1 + monthly_interest_rate) ** -total_payments)
else:
    monthly_payment = loan_amount / total_payments

# 분할 상환 테이블 생성
amortization_table = []
balance = loan_amount
for month in range(1, total_payments + 1):
    interest_payment = balance * monthly_interest_rate
    if interest_only_years and month <= interest_only_years * 12:
        principal_payment = 0
        monthly_payment_during_interest_only = loan_amount * monthly_interest_rate
        amortization_table.append([month, monthly_payment_during_interest_only, interest_payment, principal_payment, balance])
    else:
        principal_payment = monthly_payment - interest_payment
        balance -= principal_payment
        amortization_table.append([month, round(monthly_payment, 2), round(interest_payment, 2), round(principal_payment, 2), max(round(balance, 2), 0)])
    if balloon_due_years and month == balloon_due_years * 12:
        balloon_payment = balance
        amortization_table.append([month, round(monthly_payment, 2), round(interest_payment, 2), round(principal_payment, 2), 0])
        break

# 표시를 위해 분할 상환 테이블을 DataFrame으로 변환
df_amortization_table = pd.DataFrame(amortization_table, columns=["Month", "Monthly Payment", "Interest", "Principal", "Remaining Balance"])

# 결과 출력
print(df_amortization_table.head())

# 지불된 총 이자
total_interest_paid = df_amortization_table["Interest"].sum()
print(f"지불된 총 이자: ${round(total_interest_paid, 2)}")

# 총 지불액
total_payments_made = df_amortization_table["Monthly Payment"].sum() + (balloon_payment if balloon_due_years else 0)
print(f"총 지불 금액: ${round(total_payments_made, 2)}")
```

# 결론


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 단계를 따라가면 Python에서 강력한 판매자 금융 계산기를 만들 수 있어요.

이 도구는 여러 금융 시나리오를 분석하고 부동산 투자에 있어 판단력 있는 결정을 내릴 수 있게 도와줄 거예요.

# Cash Flowing Seller Finance 거래 찾기

창조적인 금융 전략을 활용할 기회를 찾고 다음 투자를 성공적으로 이루는 Coffee Clozers Creative을 확인해보세요! 👉


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 노트북 복제

# 커뮤니티에 참여하세요

부동산 기술 페이스북 그룹에 가입하여 기술, 데이터 및 부동산 관련 토론에 참여해 보세요.

파이썬으로 셀러 파이낸싱 계산기 만들기 창의적 금융의 힘을 활용하는 방법 

Moirai 모든 예측을 위한 시계열 기초 모델

<img src="/TIL/assets/img/2024-07-13-SolvingaTennisRefactoringChallengeinPythonusingSOLID_0.png" />

## 소개

코드 리팩터링 도전 과제는 소프트웨어 엔지니어들에게 잘 알려져 있지만, 데이터 과학자들에게는 그렇지 않을 수도 있습니다. 그러나 데이터 과학자들 또한 이러한 도전들을 연습함으로써 상당한 혜택을 받을 수 있습니다. 특히 SOLID 원칙을 적용할 때, 이를 연습함으로써 모듈화되고 품질이 높으며 객체지향적인 훨씬 나은 코드를 작성하는 방법을 배울 수 있습니다. 데이터 과학자로서 SOLID 원칙을 습득하면 데이터 과학 프로젝트의 품질과 관리 용이성을 상당히 향상시킬 수 있습니다. 이는 특히 대부분의 데이터 과학자가 통계학자 및 수학자 출신으로, 소프트웨어 엔지니어보다 프로그래밍 기본 원리에 대한 익숙함이 적은 팀에서 중요합니다.

온라인에서는 많은 리팩터링 도전 과제가 제공되고 있습니다. 아마 가장 유명한 것 중 하나는 길드 로즈 카타일 것입니다. 또 다른 재미있는 리팩터링 카타는 테니스 리팩터링 카타인데, 이를 이 글에서 다루겠습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


![이미지](/TIL/assets/img/2024-07-13-SolvingaTennisRefactoringChallengeinPythonusingSOLID_1.png)

[여기](https://github.com/emilybache/Tennis-Refactoring-Kata)로 이동하여 녹색 상단 오른쪽 버튼에서 "템플릿으로 사용"을 선택해주세요.

템플릿을 클론하고 터미널에서 해당 저장소로 이동하세요. 그런 다음 python 디렉토리로 이동하여 가상 환경을 생성하고 필수 의존성을 설치해주세요. 모든 것이 정상적으로 작동하는지 테스트하려면 pytest를 실행하세요. 아래 명령어를 터미널에 복사하여 붙여넣을 수 있습니다.

```js
cd python
python -m venv .venv
source .venv/bin/activate # 맥 또는 리눅스에서
# .venv\Scripts\activate # 윈도우에서
pip install -r requirements.txt
pytest
``` 



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


![Tennis Refactoring Challenge](/TIL/assets/img/2024-07-13-SolvingaTennisRefactoringChallengeinPythonusingSOLID_2.png)

터미널의 출력 결과는 위의 스크린샷과 유사해야 합니다.

시작 시, 총 6개의 tennis.py 파일이 있습니다. 각 파일은 테니스 경기의 점수를 표시하는 다른 솔루션을 나타냅니다. 테니스는 약간 독특한 점수 표현 방식을 갖고 있습니다. 테니스 경기는 세트로 이루어지며, 세트는 게임으로 이루어지며, 게임에서는 점수를 획득할 수 있습니다. 이 도전 과제는 단일 게임 내에서 점수를 나타내는 것에 관한 것입니다.

- 점수를 획득하지 않은 상태에서는 '러브'라고 부릅니다.
- 한 점을 획득한 후에는 '피프틴'이 됩니다.
- 두 점을 획득한 후에는 '서티'가 됩니다.
- 세 점을 획득한 후에는 '포티'가 되며, 상대방이 세 점을 획득한 경우에는 '듀스'라고 부릅니다.
- 네 점 이상을 획득했을 때, 상대와 2점 이상 차이가 나면 게임에 승리합니다.
- 네 점 이상을 획득했을 때, 상대와 1점 차이가 나면 어드밴티지를 얻습니다.
- 네 점 이상을 획득했을 때, 상대와 같은 점수를 가지면 '듀스'라고 부릅니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

테니스 테스트를 확인할 수 있는 tennis_test.py 및 tennis_unittest.py 두 파일도 있습니다. 이 파일들은 tennis.py 파일의 로직이 올바른지 확인하는 테스트를 제공합니다. 처음에는 모든 테스트가 통과해야 합니다 (이전에 pytest를 실행했을 때 본 것과 같이).

일반적으로는 각 tennis.py 파일을 다시 설계하는 것이 목표입니다. 그러나 한 문서에서 여섯 개의 Python 파일을 다시 설계하는 것은 너무 방대하기 때문에, 적절한 코딩 구조의 기반인 SOLID 원칙을 준수하는 하나의 해결책을 다룰 것입니다.

## 테니스 게임 정의

테니스 게임을 높은 추상화로 정의해 봅시다. 테니스 게임은 두 팀 게임의 형태입니다. 여기서는 두 플레이어가 아닌 두 팀을 사용합니다. 왜냐하면 테니스는 더블즈로도 (예: 패들은 기본적으로 두 팀으로 플레이되는) 할 수 있기 때문입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

다음은 테이블 태그를 마크다운 형식으로 변경하세요:


We can define a two-team game as follows:

```js
from abc import ABC, abstractmethod


class TwoTeamGame(ABC):
    def __init__(
        self,
        team1_name: str,
        team2_name: str,
        team1_points: float = 0,
        team2_points: float = 0,
    ):
        self.team1_name = team1_name
        self.team2_name = team2_name
        self.team1_points = team1_points
        self.team2_points = team2_points
```

Next, let’s define a tennis game:

```js
class TennisGame1(TwoTeamGame):
    def __init__(self, team1_name: str, team2_name: str):
        super().__init__(team1_name, team2_name)
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

테니스 경기에는 won_point(team_name: str)과 score() 두 가지 메서드가 있어야 합니다.

```js
class TennisGame1(TwoTeamGame):
    def __init__(self, team1_name: str, team2_name: str):
        super().__init__(team1_name, team2_name)

    def won_point(self, team_name: str):
        ...

    def score(self) -> str:
        ...
```

## 점수 계산 전략 구현

won_points(team_name)부터 시작해보죠. 이 메서드는 매우 간단합니다. team_name으로 팀 이름을 전달하면 해당 플레이어의 점수가 하나 증가해야 합니다. 그러나 SOLID 원칙을 적용하기 위해 더 높은 추상화 수준에 대해 고려해야 합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


won_points를 스코어링 전략을 사용하는 것으로 생각할 수 있습니다.

```python
from abc import ABC, abstractmethod

class TwoTeamScoringStrategy(ABC):
    @abstractmethod
    def update_score(
        self, game: TwoTeamGame, team_name: str,
    ):
        pass
```

won_points에서 스코어링 전략을 추출한 이유는 SOLID의 개방/폐쇄 원칙을 지키기 위한 것입니다. won_points에서 스코어링 전략을 분리함으로써, won_points 자체를 수정하지 않고도 스코어링 전략을 쉽게 교체하거나 변경할 수 있습니다.

이제 StandardTennisScoring을 만들어봅시다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
class StandardTennisScoring(TwoTeamScoringStrategy):
    def update_score(
        self,
        game: TwoTeamGame,
        team_name: str,
    ):
        if game.team1_name == team_name:
            game.team1_points += 1
        elif game.team2_name == team_name:
            game.team2_points += 1
        else:
            raise ValueError("Invalid team name")
```

위의 코드를 won_point 메서드에 구현하려면 TennisGame 클래스에 스코링 전략을 전달하고 won_point에서 StandardTennisScoring의 update_score 메서드를 호출해야 합니다:

```js
# 주의:
# 절대로 클래스 인스턴스를 기본 인수로 초기화해서는 안 됩니다.
# 기사에서는 이 문제를 수정하지 않고 주어진 테스트를 통과하기 위해 이를 수행합니다.

class TennisGame1(TwoTeamGame):
    def __init__(
        self,
        team1_name: str,
        team2_name: str,
        score_strategy: TwoTeamScoringStrategy = StandardTennisScoring(),
        score_reperesentation: TwoTeamScoreRepresentation = TennisScoreRepresentation(),
    ):
        super().__init__(team1_name, team2_name)
        self.score_strategy = score_strategy
        self.score_representation = score_representation

    def won_point(
        self,
        team_name: str,
    ):
        if team_name == self.team1_name:
            self.score_strategy.update_score(game=self, team_name=team_name)
        elif team_name == self.team2_name:
            self.score_strategy.update_score(game=self, team_name=team_name)
        else:
            raise ValueError("Invalid team name")

     def score(self):
        ...
```

## 스코어 표현 구현하기



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

지금 남은 작업은 score() 메서드를 구현하는 것뿐입니다. 먼저 두 팀 게임의 점수를 표현하는 추상 클래스를 생각해 봅시다. 점수를 나타내려면 게임의 점수에 액세스할 수 있어야 하므로 represent_score 메서드의 game이 매개변수인지 확인해 봅시다.

```js
class TwoTeamScoreRepresentation(ABC):
    @abstractmethod
    def represent_score(self, game: TwoTeamGame) -> str:
        pass
```

빠르게 어떤 단어가 어떤 점수에 관련된지 요약해보겠습니다:

- 0: Love
- 1: Fifteen
- 2: Thirty
- 3: Forty or Deuce
- 4: Deuce, Advantage or win (최다 점수를 획득한 플레이어의 점수만 나타내기 때문에)


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

테니스 게임을 생각해볼 때, 점수를 나타내는 세 가지 유형의 상황이 있습니다:

- 두 플레이어가 동일한 점수를 가지고 있는 경우.
- 두 플레이어가 동일한 점수를 가지고 있거나 한 플레이어가 더 많은 점수를 가지고 있지만 적어도 한 플레이어가 세 점보다 많은 점수를 가지고 있다 (그러면 우승 가능성이 있고, 이기거나 지는 장단점이 있을 수 있다).
- 한 플레이어가 다른 플레이어보다 더 많은 점수를 가지고 있지만 두 플레이어 모두 세 점보다 많은 점수를 가지고 있지 않은 경우

```js
class TennisScoreRepresentation(TwoTeamScoreRepresentation):
    def represent_score(self, game: TwoTeamGame) -> str:
        if game.team1_points == game.team2_points:
            return ...
        if max(game.team1_points, game.team2_points) >= 4:
            return ...
        return ...
```

우리가 지정한 세 가지 상황에 대해 클래스를 만들어 봅시다. 어떻게 점수를 나타내는지 확인하려면 tennis_unittest.py에서 테스트가 어떻게 지정되어 있는지 살펴봐야 합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
#(team1_score, team2_score, score_representation, team1_name, team2_name)
(2, 2, "Thirty-All", 'player1', 'player2'),
(3, 3, "Deuce", 'player1', 'player2'),
(4, 4, "Deuce", 'player1', 'player2'),
(1, 0, "Fifteen-Love", 'player1', 'player2'),
(4, 2, "Win for player1", 'player1', 'player2')
(4, 3, "Advantage player1", 'player1', 'player2'),
(14, 15, "Advantage player2", 'player1', 'player2'),
(14, 16, "Win for player2", 'player1', 'player2'),
```

```js
class TennisTieRepresentation(TwoTeamScoreRepresentation):
    def __init__(self, score_names: set[str] = ("Love", "Fifteen", "Thirty")):
        super().__init__()
        self.score_names = score_names

    def represent_score(self, game: TwoTeamGame) -> str:
        return {
            0: f"{self.score_names[0]}-All",
            1: f"{self.score_names[1]}-All",
            2: f"{self.score_names[2]}-All",
        }.get(game.team1_points, "Deuce")


class TennisEndGameRepresentation(TwoTeamScoreRepresentation):
    def represent_score(self, game: TwoTeamGame) -> str:
        point_difference = game.team1_points - game.team2_points
        leader = game.team1_name if point_difference > 0 else game.team2_name
        if abs(point_difference) == 1:
            return f"Advantage {leader}"
        else:
            return f"Win for {leader}"


class TennisNormalRepresentation(TwoTeamScoreRepresentation):
    def __init__(self, score_names: set[str] = ("Love", "Fifteen", "Thirty", "Forty")):
        super().__init__()
        self.score_names = score_names

    def represent_score(self, game: TwoTeamGame) -> str:
        return f"{self.score_names[game.team1_points]}-{self.score_names[game.team2_points]}"
```

If we implement these classes in the TennisScoreRepresentation we’ll get the following code:

```js
class TennisScoreRepresentation(TwoTeamScoreRepresentation):
    def __init__(
        self,
        tie_score: TwoTeamScoreRepresentation = TennisTieRepresentation(),
        end_game_score: TwoTeamScoreRepresentation = TennisEndGameRepresentation(),
        normal_score: TwoTeamScoreRepresentation = TennisNormalRepresentation(),
    ):
        self.tie_score = tie_score
        self.end_game_score = end_game_score
        self.normal_score = normal_score

    def represent_score(self, game: TwoTeamGame) -> str:
        if game.team1_points == game.team2_points:
            return self.tie_score.represent_score(game)
        if max(game.team1_points, game.team2_points) >= 4:
            return self.end_game_score.represent_score(game)
        return self.normal_score.represent_score(game)
```



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 모든 것을 합쳐보기

이제 완료했어요! 코드를 모두 결합한 것을 살펴봅시다. 만약 이 코드를 tennis1.py 파일에 넣고 터미널에서 pytest를 실행하면 모든 테스트가 여전히 통과해야 합니다.

아마 궁금할 것입니다. tennis_unittest.py에 쓰인 테스트를 준수하는 모든 기능과 규칙을 구현한 한 클래스를 작성할 수 있는데, 왜 이런 클래스들이 필요한 걸까요? 이유는, SOLID 원칙을 준수함으로써, 전체 구현의 어떤 부분이든 손쉽게 교체할 수 있고 기존 코드를 변경하거나 망가뜨리지 않을 수 있습니다. 우리가 바꾸고 싶은 부분에 대해 약간의 새 코드만 작성하면 됩니다. 이는 거의 모든 코드 부분에 적용되며, 각 클래스가 교체 가능하기 때문입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


# 새로운 점수 표현 방식
class FrenchScoreRepresentation(TwoTeamScoreRepresentation):
    # 프랑스어 점수 표현에 대한 구현
    ...

# 게임에 새 전략 주입
french_game = TennisGame1(
                    team1_name="T1", 
                    team2_name="T2", 
                    score_representation=FrenchScoreRepresentation()
)


## 결론

SOLID 원칙을 적용하여, 우리는 프로덕션 수준의 코드 구조를 사용하여 이 리팩터링 카타를 해결했습니다. 이제 SOLID 원칙을 어떻게 적용해야 하는지 더 잘 이해할 수 있을 것입니다. 클래스의 더 높은 추상화를 정의하여 시작하고, 각 클래스의 서브클래스를 교환 가능하도록 만들어 의존성 주입을 사용하여 새 기능을 쉽게 조정하고 적용할 수 있도록 했습니다.

높은 품질의 Python 코드에 대해 더 배우고 싶으세요? 이 다른 기사들도 꼭 확인하세요!

SOLID 원칙으로 테니스 리팩토링 도전 과제 해결하기 Python 사용

파이썬으로 AI 노래 목소리 클로닝 하는 방법

취업을 찾고 계신가요? 무료 5페이지 프로젝트 아이데이션 가이드를 활용하여 개인 프로젝트를 개발하여 경쟁력을 확보하세요.

데이터 엔지니어링 튜토리얼에서 s-단어에 대해 충분히 다루지 않습니다. 제안을 제출하고 잘못 처리되면 반사적으로 터지는 네 글자의 욕설을 말하는 것이 아닙니다. 또는 스키마가 대상 테이블과 일치하지 않을 때 중얼거리는 말을 의미하지 않습니다.

저는 스테이징에 대해 이야기합니다.

왜냐하면 "언제 (데이터 소스)가 프로덕션에서 이용 가능해질까요?" 라는 스테이크홀더들로부터 받는 모든 질문에 대해 멈추고 "먼저 스테이징 테이블로 로드되어야 합니다." 라고 말하기 때문입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

그리고 지나치게 명료해질 위험이 있지만, 스테이징 환경이란 단순히 당신의 코드를 테스트하는 모래 상자가 아닙니다. 이것은 데이터 페이로드가 "스위치를 누르고" 제품 끝점, 테이블 및 대시보드를 가리키는 우리의 파이프 라인을 향하는 마지막 과정입니다.

이상적으로, 당신의 스테이징 환경은 생산 테이블을 흉내 내며 다음과 같은 높은 데이터 엔지니어링 표준을 유지해야 합니다:

- 클러스터링
- 파티셔닝
- 중복 제거

이런 식으로 스테이징 테이블은 당신의 관리자, 팀 리더 또는 이해 관계자가 "이 데이터가 이 형식으로 제공될 수 있다고 자신 있습니다." 라고 말하기 전에 검토할 최종 초안을 나타냅니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

무대 테이블을 세심하게 조사하는 동안에는 스키마와 파이프라인 기준을 세련된 상태로 개선하는 기회가 될 수 있지만, 그보다 중요한 것은 스위치를 뒤집는 시점에 발생하는 오류를 최소화하는 시간입니다.

무대 테이블에 대해 800단어를 더 읽고 싶어할지도 모르겠지만, 저의 목표는 스테이징→프로덕션 전환을 원활하게 만들 수 있는 전략을 공유하는 것입니다.

그리고 당신이 아마 존재한다는 명령어와 함께 빅쿼리 SQL의 1줄만 있을 뿐입니다.

참고: 아래 과정은 특정 시나리오에 해당합니다 - 기존 테이블의 스키마를 편집하여 어떤 이유로든 끝에 추가할 수 없는 필드를 추가하는 것입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


<img src="/TIL/assets/img/2024-07-13-GoFromStagingTableToProductionDataWith1StupidSimpleSQLLine_0.png" />

저는 새로운 직업에서 3년이 지난 지금도 데이터 엔지니어링 분야에 관심을 가지고 있는 행운아라 생각합니다. 이야기하고자 하는 것은 앞으로 하지 않으면 안 될 작업이 없다는 것은 아니라는 점입니다.

그 중 한 가지 작업이 데이터 엔지니어링의 기초에 관련되어 있습니다: 프로덕션 테이블을 덮어씌우는 것입니다.

명확하게 말하면, 저는 테이블에 DML을 사용하는 것을 두렵게 여기지는 않습니다. 단지 파괴를 최소화하는 방법을 사용하려고 노력하는 것 뿐입니다.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

일반적으로 테이블 중간에 새 열을 삽입해야 한다면, 다음 단계를 따릅니다:

- 기존 열을 모두 선택합니다.
- 모든 열이 포함되었는지 확인하기 위해 UNION ALL 문을 작성합니다.
- 새 열(또는 유형 변경을 위해 기존 열을 CAST())을 SELECT 문에 추가합니다.
- BigQuery UI의 설정으로 전환합니다.
- "테이블 덮어쓰기"를 선택합니다.
- 원본 테이블의 데이터셋/이름을 입력합니다.
- 실행합니다.
- 변경 사항을 확인합니다.

이렇게 들리겠지만, 조금의 연습을 통해 이 과정은 5분 이하로 완료할 수 있습니다.

하지만, 전 상사에 따르면 더 짧게 할 수 있다고 하네요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

생산 테이블의 구조를 편집하는 대신에는 위험이 따르므로 스테이징 테이블을 만들고 그 스테이징 테이블을 생산 테이블의 이름으로 다시 별칭을 지정해야 합니다.

만약 이 최종 결과물을 생성하기 위해 테이블을 생성/대체하거나 삭제해야 한다고 생각한다면, 예의를 갖추어 말씀드리면 틀린 판단일 것입니다.

BigQuery는 다양한 유용한 DML 함수를 제공하는데, 그 중에서도 잘 알려지지 않은 함수 중 하나는 ALTER와 함께 사용되는 RENAME 명령입니다.

이것을 함께 사용하면 다음과 같습니다:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


ALTER TABLE `dataset.table` RENAME TO table

스키마를 건드리지 않은 채 이 프로세스는 다음과 같습니다:

- 스테이징 테이블을 생성합니다 (이미 생성된 경우 제외)
- 전환할 준비가 되면 원본 테이블의 이름을 다르게 변경하여 두 개의 테이블을 가지고 있도록 합니다. 두 테이블 중 하나도 원본 테이블 이름을 가지지 않도록 합니다. 일반적으로 "og"를 추가하여 태그를 달아요. 예를 들어, financial_data_eom 테이블의 경우 financial_data_eom_og 및 financial_data_eom_test를 사용하겠습니다.

3. 변경사항에 대해 자신감을 갖고 (이와 같이 이해 관계자들도) 된다면 ALTER TABLE 문을 실행합니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>


ALTER TABLE financial_data_eom_test RENAME TO financial_data_eom

4. Run a few quality assurance (QA) queries and merge the PR that contains a pipeline with the updated schema

Functionally, this provides you the ability to not only assure you’ve tested your changes, but also to preserve your original data and schema, should you need to revert to the “_og” table.

Think of it like a save point or respawn in a video game. Or, if you want a more developer-centric explanation: The “_og” table contains your version history.



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

스테이징 테이블에서 전환하는 것이 위험이 적지만, 위험이 없다는 뜻은 아닙니다.

다음 사항을 염두에 두시기 바랍니다:

- 스테이징 테이블을 생성할 때, 프로덕션 테이블과 동일한 클러스터링/파티셔닝 사양이 있어야 합니다.
- 원본 테이블에서 데이터를 보존했더라도 업데이트된 테이블은 새로운 테이블입니다. 생성 시 메타데이터에는 새로운 생성 날짜와 최종 수정 날짜가 표시됩니다.
- 새 테이블을 생성하면 추가 비용이 발생합니다. 이 방법을 시도할 경우 크기와 보관 기간을 고려해야 합니다.

이 방법은 꽤 복잡한 것에 초보적으로 보일 수 있지만, 제 경험 상 스테이징 테이블을 통해 주요 변경 사항을 푸시하는 것이 프로덕션 편집보다 훨씬 편하고 확실하다고 느꼈습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 팁을 배운 지 얼마 지나지 않아서 역으로 해야 할 일이 발생했습니다. 코드가 불완전한 스키마를 포함하여 받은 후에 밤늦게 이전 버전의 테이블로 되돌려야 했죠.

제출 마감이 몇 분 남았음에도 압박을 느꼈지만, 백업할 스테이징 테이블 덕분에 전환이 매우 원활하게 진행되었습니다. 테이블 이름 변경과 레포지토리의 커밋 이력에서 코드를 다시 커밋하는 사이에 3분만에 작업이 완료되었습니다.

생산 스위치를 뒤집을 때는 두 가지 위치가 있는 것이 정말 다행입니다.

도와주셔야 해요. 이 블로그 외에 어떻게 도와드릴 수 있는지 말씀해 주실 3가지 질문 설문에 응해주세요. 응답한 모든 분들께 무료 선물을 보내드릴게요.

1줄짜리 SQL로 스테이징 테이블 데이터를 프로덕션 데이터로 이동하는 방법

<table>
    <tr>
        <td><img src="/TIL/assets/img/2024-07-13-PythonforDataScience_0.png" /></td>
    </tr>
</table>

데이터 과학 분야에서 Python이 인기 있는 이유를 살펴보겠습니다. Python은 그 간결함과 강력한 라이브러리로 인해 데이터 과학 분야에서 가장 많이 사용되는 언어 중 하나가 되었습니다.

# 데이터 과학을 위한 Python의 장점

- 학습 용이성: Python의 문법은 간단하고 가독성이 좋아 초심자부터 숙련된 프로그래머까지 모두 사용할 수 있습니다.
- 다양한 라이브러리: 데이터 과학을 위해 특별히 설계된 다양한 라이브러리가 존재합니다.
- 커뮤니티 지원: 큰 활성화된 커뮤니티가 많은 자료, 튜토리얼, 문제 해결 및 새로운 기술 습득을 지원해줍니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 데이터 과학을 위한 주요 라이브러리

- NumPy: 대규모 다차원 배열과 행렬을 지원하며, 이러한 배열에 작용하는 수학 함수 모음을 제공합니다.

```python
import numpy as np
arr = np.array([1, 2, 3, 4])
```

- Pandas: 데이터 조작과 분석에 꼭 필요한 DataFrames와 같은 데이터 구조를 제공하여 탭 형식의 데이터를 처리합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```python
import pandas as pd
df = pd.read_csv('data.csv')
```

3. Matplotlib: 정적, 대화식 및 애니메이션 시각화를 생성하는 데 사용되는 도표 라이브러리입니다.

```python
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.show()
```

4. Seaborn: Matplotlib을 기반으로 한 Seaborn은 매력적인 통계 그래픽을 그리기 위한 고수준 인터페이스를 제공합니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
import seaborn as sns
sns.set(style="darkgrid")
```

5. SciPy: 과학 및 기술 계산에 사용되며 NumPy의 기능을 확장합니다.

```js
from scipy import stats
```

6. Scikit-Learn: 데이터 마이닝 및 데이터 분석에 유용한 간단하고 효율적인 도구를 제공하는 머신러닝 라이브러리입니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
from sklearn.ensemble import RandomForestClassifier
```

# 예시 워크플로우

파이썬에서의 전형적인 데이터 과학 워크플로우는 다음과 같은 단계를 포함할 수 있습니다:

- 데이터 수집: Pandas를 사용하여 CSV, 데이터베이스 또는 API에서 데이터를 읽기
- 데이터 정제: Pandas를 사용하여 결측값 및 중복 처리 및 데이터 변환
- 탐색적 데이터 분석 (EDA): Pandas, Matplotlib 및 Seaborn을 사용하여 데이터 시각화 및 요약
- 모델 구축: Scikit-Learn을 사용하여 머신러닝 알고리즘 적용
- 평가: Scikit-Learn에서 제공하는 메트릭을 사용하여 모델 성능 평가



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 결론

파이썬은 가독성, 라이브러리 다양성 및 강력한 커뮤니티 지원이 결합되어 데이터 과학에 이상적인 선택지입니다. 처음 시작하거나 경험 많은 데이터 과학자이든, 파이썬은 다양한 데이터 관련 문제에 대처할 도구와 유연성을 제공합니다.

데이터 과학을 위한 Python 완벽 가이드

<img src="/TIL/assets/img/2024-07-13-12EssentialTipsforMasteringPythonConcurrency_0.png" />

## 파이썬 동시성이 프로그래밍 병목 현상을 해결하는 방법

오늘은 파이썬에서 동시성을 탐색할 거에요 — 프로그램을 더 빠르게 실행할 수 있는 마법 같은 열쇠!

걱정하지 마세요, 초심자라도 동시성을 마스터할 수 있도록 단계별로 안내할게요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

# 1. 스레딩 소개: 멀티 스레딩 기초

카페에서 이메일 처리, 채팅 및 코딩을 동시에 하는 상황을 상상해보세요 — 그것이 멀티 스레딩입니다.

Python에서는 `threading` 모듈이 여러분의 유용한 도우미입니다.

```python
import threading
import time

def say_hello(name):
    print(f"Hello, {name}!")
    time.sleep(2)  # 시간이 오래 걸리는 작업을 모방

# 스레드 생성
thread1 = threading.Thread(target=say_hello, args=("World",))
thread2 = threading.Thread(target=say_hello, args=("Python",))

# 스레드 시작
thread1.start()
thread2.start()

# 모든 스레드가 완료될 때까지 대기
thread1.join()
thread2.join()

print("모든 작업 완료.")
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

이 코드는 서로 다른 인사말을 인쇄하는 두 개의 스레드를 만들고, 그들이 완료될 때까지 기다립니다. `join()`을 기억하세요, 스레드가 완료될 때까지 기다립니다.

# 2. 동시성 함정: 전역 인터프리터 잠금(GIL)

멀티스레딩을 논의할 때, 파이썬의 GIL에 대해 언급해야 합니다. CPU 코어가 파이썬 바이트코드를 실행하는 것에 차례를 가져가도록 하는 것인데, 이는 CPU 바운드 작업에 대해 멀티스레딩이 항상 더 빠르지는 않다는 의미입니다. 하지만 걱정하지 마세요, I/O 바운드 작업의 경우에는 멀티스레딩이 여전히 유용합니다!

# 3. 병렬 처리: GIL 우회


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

다중 코어 CPU를 최대한 활용하려면 `multiprocessing` 모듈을 사용하세요. 이 모듈은 각 프로세스에 대해 별도의 Python 해석기를 생성하여 GIL을 우회합니다.

```python
from multiprocessing import Process
import time

def worker(num):
    print(f'Worker: {num}')
    time.sleep(2)

if __name__ == '__main__':
    processes = []
    for i in range(4):
        p = Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
```

각 `Process`는 GIL과 독립적으로 실행됩니다.

# 4. 동시성이 모든 문제를 해결해 주지는 않습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

동시성은 데이터 동기화 문제와 함께 복잡할 수 있습니다. 자원 충돌을 피하기 위해 잠금을 사용하면 마치 주방에서 하나의 전자 레인지를 공유하는 것처럼 자원 충돌을 피할 수 있습니다.

```python
from threading import Lock

lock = Lock()

def safe_print(number):
    with lock:
        print(f'Safe print: {number}')

safe_print(1)
safe_print(2)
```

`with`를 사용하면 잠금을 자동으로 관리하여 안전을 보장합니다.

# 5. 큐의 지혜: `queue.Queue`


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

편리하게 생각해보면 공장 조립 라인과 비슷한데, `Queue`는 스레드/프로세스 간 데이터 교환을 조율하는 조정자입니다.

```python
from queue import Queue
from threading import Thread

def producer(queue):
    queue.put('Product')

def consumer(queue):
    print(queue.get())

q = Queue()
producer_thread = Thread(target=producer, args=(q,))
consumer_thread = Thread(target=consumer, args=(q,))

producer_thread.start()
consumer_thread.start()

producer_thread.join()
consumer_thread.join()
```

큐는 혼란을 방지하고 안전한 데이터 전송을 보장합니다.

# 6. 비동기의 마법: `asyncio`


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

기다리기 싫어요? `asyncio`가 `async`/`await`으로 비동기 프로그래밍 세계로 안내합니다. 당신의 코드를 날아다니게 만들어줍니다.

```python
import asyncio

async def hello(i):
    print(f'Hello {i}')
    await asyncio.sleep(1)  # 비동기 대기

async def main():
    tasks = [hello(i) for i in range(3)]
    await asyncio.gather(*tasks)

# Python 3.7+
asyncio.run(main())
```

비동기 대기를 통해 다른 작업을 수행하면서 대기할 수 있어 효율성을 향상시킬 수 있어요.

# 7. 비동기 프로그래밍에 대한 오해


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

`asyncio`는 강력하지만 하드웨어와 직접 상호 작용하는 저수준 API와 같은 모든 함수를 비동기적으로 실행할 수 없습니다. 올바른 방법을 선택하고 강제로 async를 적용하지 마세요.

# 8. `concurrent.futures`: 간편한 Future 처리

간단한 동시 작업의 경우, 동기적 또는 비동기적으로, `concurrent.futures`를 활용하세요.

```js
from concurrent.futures import ThreadPoolExecutor

def worker(n):
    return n * n

with ThreadPoolExecutor() as executor:
    results = executor.map(worker, range(5))
    print(list(results))  # 제곱 출력
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

 ThreadPoolExecutor를 사용하여 스레드 풀을 쉽게 관리할 수 있습니다. 이를 통해 작업 실행이 음식 주문하는 것만큼 간단해집니다.

# 9. 오류 처리의 기술: 예외 gracefully 처리하기

동시성에서 오류 처리는 중요합니다. 코드를 보호하기 위해 `try-except`를 사용하여 한 작업의 실패가 전체 프로그램에 영향을 미치지 않도록합니다.

```js
try:
    # 실패할 수도 있는 동시성 코드
except Exception as e:
    print(f"예외를 잡았습니다: {e}")
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

침착하게 유지하고 오류를 세련되게 처리하여 견고한 프로그램을 만들어봐요.

# 10. 리소스 관리: 컨텍스트 관리자와 `with`

`with` 문은 파일, 락과 같은 리소스가 올바르게 해제되어 경쟁 상태에서 리소스 누출을 방지해줘요.

```js
with Lock():
    # 공유 리소스를 안전하게 조작해요
```  


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

표 태그를 마크다운 형식으로 변경해 드릴게요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

실제 예시를 통해 동시에 이미지를 다운로드하여 동시성의 힘을 느껴보는 연습을 해보세요.

```python
import os
import requests
from threading import Thread

def download_image(url, filename):
    response = requests.get(url)
    with open(filename, 'wb') as f:
        f.write(response.content)
    print(f'{filename} 다운로드 완료.')

urls = ['img_url1', 'img_url2']  # 예시 URL
threads = []

for url in urls:
    t = Thread(target=download_image, args=(url, os.path.basename(url)))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print('모든 이미지 다운로드 완료.')
```

동시 다운로드는 프로세스를 크게 가속시킵니다!

이 12가지 실용적인 팁으로 파이썬 동시성 능력을 향상시켰습니다. 진실을 확인하기 위해 연습해보세요. 프로그램을 실행시켜 빠르게 동작시켜 보세요!


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

Substack에서 최신 AI 이야기를 따라가며 연락을 유지해보세요. 함께 AI의 미래를 함께 만들어요!

Substack에서 Python 이야기를 최신 상태로 유지하기 위해 연락을 유지해보세요. 함께 Python을 배워봐요!

파이썬 동시성 완벽 정복을 위한 12가지 필수 팁

Python을 사용한 리스크 온 vs 리스크 오프 주식 시장 대시보드 만들기 - Part IV 동적 시간 왜곡 Dynamic Time Warping 방법

<img src="/TIL/assets/img/2024-07-13-FindHiddenLawsWithinYourDatawithSymbolicRegression_0.png" />

기계 학습 전문가로서, 보통 데이터셋(X, y)을 갖고 있고, M이라고도 불리는 함수를 찾고 싶어합니다. M(X) ≈ y를 만족하는 함수입니다. 보통, 우리는 M의 함수 형태에 크게 신경 쓰지 않습니다. 우리 관점에서는, 모델이 신경망, 트리 기반 알고리즘 또는 완전히 다른 것이든 간에 테스트 세트에서 좋은 성능을 보이면 만족합니다.

하지만, 이러한 복잡한 모델을 사용하면 흥미로운 패턴이나 때로는 데이터 내에 잠재된 물리학이나 경제법칙을 놓칠 수 있습니다. 더 나은 결과를 얻기 위해, Symbolic Regression을 사용하여 모델을 구축하는 방법을 보여드리겠습니다. 이러한 모델은 소수의 항만으로 구성되어 어디서든 쉽게 구현할 수 있습니다. 이것이 무엇인지 살펴볼까요?

# 물리학 실험


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

실험 물리학자로서 지정한 높이 h에서 물체를 떨어뜨렸을 때 땅에 도달하는 데 얼마나 걸리는지 알아보고 싶습니다. 예를 들어, h = 1.5m의 높이에서 (공기 저항에 영향받지 않을만큼 충분히 무거운) 물체를 떨어뜨린다면, 땅에 도달하는 데 약 0.55초가 걸립니다. 한 번 시도해보세요!

그러나 이는 지구나 중력 가속도가 9.8067m/s²인 다른 천체에만 해당됩니다. 예를 들어, 달은 1.625m/s²의 중력 가속도를 갖고 있어 같은 물체를 1.5m에서 떨어뜨리면 약 1.36초가 더 걸립니다. 영화에서 보던 것과 일치할 것입니다.

이제, 우리의 작업은 땅에 도달하는 데 필요한 시간을 알려주는 일반적인 공식 t(h, g)를 찾는 것입니다. 이는 단순히 높이 h와 중력 가속도 g 값을 가져와 시간 t를 예측하는 모델을 만드는 것에 불과합니다. 나에게 참아주십시오, 친애하는 물리학자분들. 😃

## 데이터 수집 및 모델 훈련


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

우주선을 타고 날아다닌 다음 다양한 높이와 행성에서 몇 가지 물건을 떨어뜨렸고, 항상 땅에 도달하는 데 걸리는 시간을 측정했다고 가정해 봅시다. 측정값의 첫 번째 행들은 다음과 같습니다:

| 높이 (h) | 중력 (g) | 시간 (t) |
| ------- | ------- | ------- |
| 10      | 9.81    | 1.43    |
| 20      | 9.81    | 2.01    |
| 30      | 3.72    | 2.67    |

이제 이를 훈련 세트와 테스트 세트로 나누어 표준 기계 학습 모델을 훈련시켜 볼 수 있습니다.

```python
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split

data = pd.read_csv("https://raw.githubusercontent.com/Garve/towards_data_science/main/Symbolic%20Regression/free_fall.csv")
X = data[["h", "g"]]
y = data["t"]
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123)

rf = RandomForestRegressor(random_state=123).fit(X_train, y_train)
print(rf.score(X_test, y_test))

# 출력:
# 0.9874788707086176
```

언제든지 궁금한 점이 있으면 물어봐 주세요!


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

좋아요, 매우 잘 숨겨진 패턴을 학습하는 모델을 만들었네요. 근데... 그 패턴이 뭘까요?

## 모델 해석

실제로 모델 내부에 존재하는 복잡한 공식 때문에 알아내기 어렵습니다. Shapley 값들을 사용하여 모델이 무엇을 배웠는지 살펴볼 수 있습니다. 이 기사에서는 그들이 무엇인지 정말로 알 필요는 없지만, 여전히 관심이 있다면 제 다른 글을 확인하는 것을 추천합니다:

기본적으로, 다양한 특징이 모델의 결과에 어떤 영향을 미치는지를 결정할 수 있게 해줍니다. 멋진 shap 라이브러리를 사용하여 다음을 할 수 있어요:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

```js
# !pip install shap
import shap

te = shap.TreeExplainer(rf, feature_names=["h", "g"])
shapley_values = te(X)
shap.plots.scatter(shap_values=shapley_values)
```

![FindHiddenLawsWithinYourDatawithSymbolicRegression_2](/TIL/assets/img/2024-07-13-FindHiddenLawsWithinYourDatawithSymbolicRegression_2.png)

왼쪽에서는 높은 h 값이 더 높은 모델 출력, 즉 더 높은 t 값을 초래한다는 것을 볼 수 있습니다. 오른쪽에서는 g 값이 낮을수록 모델에 따르면 더 높은 t 값을 얻는 것을 볼 수 있습니다. 두 관측 결과는 모두 이해하기 쉽습니다: 높은 곳에서 물체를 떨어뜨리면 땅에 닿을 때까지 더 오래 걸립니다. 그리고 지면 쪽으로 강한 힘으로 끌려오게 되면 그것은 더 빨리 땅에 닿을 것입니다.

보통 이러한 결과가 나오면 만족하고 모델을 배포할 수 있습니다. 그럼에도 불구하고, 이 접근 방식에는 몇 가지 문제가 있다고 주장할 수도 있습니다:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 모델이 꽤 복잡하므로 이론적 통찰이 전혀 없습니다.
- 그래서 우리는 scikit-learn 모델로 배포해야 하는데, 우리의 배포 서비스가 scikit-learn 모델을 좋아하지 않을 때 쉽게 다시 구현할 수 없습니다.

이 두 문제를 해결하는 다른 모델을 어떻게 구축할 수 있는지 살펴봅시다.

# 기호 회귀

기호 회귀라는 기술을 활용할 수 있습니다. 이 기술은 데이터를 설명하는 간단한 대수적 표현을 찾으려고 합니다. 예를 들어, 특성 x₁, x₂ 및 x₃ 및 타겟 y로 구성된 데이터 세트에서 모델 학습 결과는 y = √x₁ + sin(x₂/(x₃+1)) 또는 y = exp(x₁²) - x₂ 와 같을 수 있습니다. "자유 낙하" 데이터 세트에서 이 모델이 어떻게 수행되는지 확인해봅시다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

심볼릭 회귀를 위한 많은 패키지가 있습니다. 예를 들어 gplearn과 PySR이 있어요. 여기서는 gplearn을 사용할 거에요. 살짝 더 쉽게 사용할 수 있어서요. 하지만 안타깝게도 2년 동안 업데이트되지 않았어요. PySR은 활발히 개발 중이지만 밑바닥에는 Julia를 사용하기 때문에 또 다른 종속성이 생기는 거에요.

## 심볼릭 회귀 맞춤

먼저 gplearn을 설치해볼게요. pip install gplearn을 통해 간단하게 설치할 수 있어요. 그리고 SymbolicRegressor를 정의하고, 덧셈이나 로그 취하기와 같은 연산을 공식 내에서 사용할 수 있도록 설정해보아요.

```python
from gplearn.genetic import SymbolicRegressor

sr = SymbolicRegressor(
    function_set=(
        "add",
        "sub",
        "mul",
        "div",
        "sqrt",
        "log",
        "abs",
        "neg",
    ),
    random_state=0,
)

sr.fit(X_train, y_train)
```


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

지금 모델은 다음과 같은 공식을 찾으려고 노력합니다:

- 간단하면서도
- 데이터를 잘 설명하는 즉, 손실이 적은 공식

제 경우에는 다음과 같은 결과가 나왔어요:

![이미지](/TIL/assets/img/2024-07-13-FindHiddenLawsWithinYourDatawithSymbolicRegression_3.png)


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

아래는


![Physical laws rediscovered by PySR authors](/TIL/assets/img/2024-07-13-FindHiddenLawsWithinYourDatawithSymbolicRegression_4.png)

since x₀ = h and x₁ = g. Apart from having a test r² of over 0.999, this is actually the correct physics formula that describes falling objects without air resistance! You might also find the equivalent formula h = 0.5 · g · t² in literature.

And don’t only take it from me. The authors of PySR published a paper in which they show how many more physical laws could be rediscovered. On page 16, you can see this table:



<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

표 태그를 Markdown 형식으로 변경하세요.

열을 보면 심볼릭 회귀 라이브러리들이 나와 있어요. 왼쪽에는 물리 법칙이 있구요. 셀 안의 분수는 올바른 표현을 찾은 횟수를 전체 시도 횟수로 나눈 것이에요. 다음은 수식들이에요:

Planck의 법칙과 Rydberg 공식은 어떤 라이브러리도 발견하기 어려웠어요. 그래도 PySR만 다른 경우에 잘하고 있었어요. gnlearn은 비교 대상이 아니었어요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

## 어떻게 이 마법이 작동할까요?

우리 모델의 기능 형태는 완전히 미친 것일 수 있습니다. 이는 신경망에서 일어나는 일과 근본적으로 다릅니다. 신경망에서는 공식 자체가 고정되어 있고 매개변수만 조정됩니다. 또는 그라디언트 부스팅과 같은 트리 기반 알고리즘에서는 결과가 언제나 조각별 상수 함수가 됩니다.

길게 말하면, 이 기사에서 다루기에는 너무 길 것인 내재하는 진화 알고리즘을 사용합니다. 이들은 매우 무작위하고 휴리스틱한 프로세스이며, 극도로 분석하기 어렵습니다. 그래도 실전에서는 상당히 잘 작동할 수 있습니다. 만약 진화 알고리즘에 대해 초보자를 위한 기사를 읽고 싶다면, 제 다른 기사를 확인해 보세요:

지금 읽기 싫다면, 현재 사용 사례에 대한 핵심 아이디어는 여기에 있습니다:


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

- 간단한 무작위 수식들로 시작해보세요, 예를 들어 t = h, t = g², t = g + h, t = √h, ...
- 평가 지표로 예를 들어 평균 제곱 오차를 사용해 그들이 얼마나 좋은지 확인해보세요.
- 가장 좋은 수식들을 선택하여 결합해보세요, 예를 들어 t = h와 t = g²를 결합하면 t = h + g²가 될 수 있습니다. 또는 t = √h와 t = h · g를 결합하면 t = √(h · g)가 될 수 있습니다.
- 그들을 변형할 수도 있습니다. 예를 들어, t = √(h·g)를 약간 변경하여 t = √(h + g)로 변형할 수 있습니다.
- 이제 새로운 수식 집합이 있으므로 다시 1단계로 돌아갈 수 있습니다. 또는 이미 아주 좋은 수식을 찾은 경우 중단할 수도 있습니다.

이러한 절차를 구현하는 방법은 사용하는 라이브러리에 따라 다를 수 있습니다. 이러한 알고리즘을 작성하는 것이 정말 재미있는 일이 될 수 있도록 이러한 단계를 설계하는 데 많은 자유가 주어집니다. PySR 저자들은 논문에서 그들만의 진화 알고리즘 특정 버전을 설명하고 있습니다.

# 결론

이 글에서는 의미 있는 수식으로 모델을 구축하는 것이 얼마나 쉬운지 살펴보았습니다. 예를 들어, 우리의 예제에서는 테스트 세트의 성능뿐만 아니라, 더 나았습니다.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

예를 들어, SQL로 이동하여 다음과 같이 작성할 수 있어요:

```js
SELECT
  h,
  g,
  SQRT(2 * h / g) AS t_pred
FROM
  your_table
```

그럼 이제 시작해봅시다! 이 공식을 선택하는 어떤 프로그래밍 언어에서도 쉽게 다시 구현할 수 있어요.

물론 공식이 항상 간단하거나 데이터를 잘 설명하지는 않을 수 있어요. 이 경우에는 항상 사인, 지수 함수와 같은 다른 연산을 추가하거나, 자체 작은 빌딩 블록을 만들 수 있어요. 이것은 다시 명확한 공식을 만드는 데 도움이 될 수 있어요.


<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-4877378276818686"
     data-ad-slot="1549334788"
     data-ad-format="auto"
     data-full-width-responsive="true"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>

오늘 새롭고 흥미로운, 가치있는 것을 배우셨기를 바랍니다. 읽어 주셔서 감사합니다!

그리고 알고리즘의 세계로 더 깊이 파고들고 싶다면, 제 새로운 출간물 '알고리즘에 관한 모든 것'을 한 번 살펴보세요! 아직 작가를 모집 중입니다!

Posts