Kafka, Redis, Postgres, Kubernetes를 활용한 실시간 파이프라인 마이크로서비스 프로젝트 방법

![Quantile Regression for Time Series Probabilistic Forecasting](/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_0.png)

가끔 우리는 유일한 확실한 것은 불확실함이라는 것을 듣습니다. 우리는 불확실성을 좋아하지 않습니다. "내일 날씨는 50% 폭염, 50% 허리케인일 것이다"라는 말을 듣고 싶지 않습니다. 그러나 반대로 불확실성을 양적으로 나타내기 위해 가능한 예측 범위를 요청하기도 합니다. 불확실성 속에서도 확실성을 원하는 건데요. 미래를 위해 계획을 세우는 데 도움을 주기 위해서입니다. 조직의 재정 계획을 수행 중이라고 상상해 봅시다. 두 가지 중 어느 것이 더 나을까요:

- 예상 평균 재정 손실은 4000만 달러이거나
- 재정 손실이 약 1000만 달러부터 7000만 달러 사이일 것으로 95% 확신하며, 약 4000만 달러 정도일 것입니다. 더불어, 재정 손실이 약 3000만 달러부터 5000만 달러 사이일 것으로 68% 확신합니다.

분위 회귀(Quantile 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>

![Quantile Regression for Time Series Probabilistic Forecasting](/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_1.png)

"Monte Carlo Simulation for Time Series Probabilistic Forecasts"에서 몬테카를로 시뮬레이션 기술을 배웠습니다. 양분위 회귀(Quantile regression)가 몬테카를로 시뮬레이션보다 어떤 장점을 가지고 있는지 알아보았습니다. 첫째로, 양분위 회귀는 예측 변수가 주어졌을 때 종속 변수의 조건부 양분위를 직접 추정합니다. 이는 몬테카를로 시뮬레이션에서와 같이 많은 가능한 결과를 생성하는 대신에 양분위 회귀는 종속 변수의 분포의 특정 양분위를 추정해줍니다. 이는 중앙값, 사분위 또는 극단적 양분위에서 예측 불확실성을 이해하는 데 특히 유용할 수 있습니다. 둘째로, 양분위 회귀는 예측 불확실성을 추정하기 위한 모델 기반 접근 방식을 제공합니다. 이는 관찰 데이터를 이용하여 변수 간의 관계를 추정하고, 이 관계를 기반으로 예측을 수행합니다. 반면에 몬테카를로 시뮬레이션은 입력 변수에 대한 확률 분포를 지정하고 무작위 샘플링을 통해 결과를 생성하는 데 의존합니다.

NeuralProphet를 사용하여 시계열 모델을 구축하는 방법을 다음 장(chapter)에서 배웠습니다:

- Chapter 3: Tutorial I: Trend + seasonality + holidays & events
- Chapter 4: Tutorial II: Trend + seasonality + holidays & events + auto-regressive (AR) + lagged regressors + future regressors



<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>

Neural Prophet은 두 가지 통계 기법을 제공합니다: (1) 분위수 회귀 및 (2) 일치 분위수 예측입니다. 일치 분위수 예측 기법은 회귀를 측정하기 위한 보정 프로세스를 추가합니다. 이 장에서는 Neural Prophet의 분위수 회귀 모듈을 실행할 것입니다. 다음 장에서 일치 분위수 예측을 배울 예정입니다. Python 노트북은 이 Github 링크를 통해 다운로드할 수 있습니다.

소프트웨어 요구 사항

NeuralProphet를 설치하기 위해 표준 설치 방법인 pip install NeuralProphet를 따를 것입니다.

```js
!pip install neuralprophet
```



<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>

만약 Google Colab을 사용하는 경우, NeuralProphet은 numpy 1.23.5를 사용하지 않으면 작동하지 않는다는 점 유의해 주세요. numpy를 제거하고 numpy 1.23.5를 설치해야 합니다.

```js
# neuralprophet은 numpy1.23.5를 사용하지 않으면 Colab에서 작동하지 않습니다: https://github.com/googlecolab/colabtools/issues/3752
!pip uninstall numpy
!pip install git+https://github.com/ourownstory/neural_prophet.git numpy==1.23.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>

```js
%matplotlib inline
from matplotlib import pyplot as plt
import pandas as pd
import numpy as np
import logging
import warnings
logging.getLogger('prophet').setLevel(logging.ERROR)
warnings.filterwarnings("ignore")
```

이전 장에서 소개한 NeuralProphet을 계속 사용할 것입니다. Kaggle의 Bike Share Daily 데이터를 사용할 건데요 (여기나 여기서 다운로드 가능합니다). 이 데이터셋은 매일의 대여 수요와 온도, 풍속 등 다른 기상 정보가 있는 다중 변수 데이터셋입니다.

```js
from google.colab import drive
drive.mount('/content/gdrive')
path = '/content/gdrive/My Drive/data/time_series'
data = pd.read_csv(path + '/bike_sharing_daily.csv')
data.tail()
```

<img src="/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_2.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>

자전거 대여량을 그래프로 플롯해 봅시다. 두 번째 해에 수요가 증가하고 계절적 패턴이 있는 것을 관찰할 수 있어요.

```js
# 문자열을 datetime64로 변환하기
data["ds"] = pd.to_datetime(data["dteday"])

# 대여량 데이터의 선 그래프 만들기
plt.plot(data['ds'], data["cnt"])
plt.xlabel("날짜")
plt.ylabel("수량")
plt.show()
```

![그림](/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_3.png)

모델링을 위해 매우 기본적인 데이터 준비를 할 거에요. NeuralProphet에서는 칼럼 이름을 “ds”와 “y”로 지정해야 해요. Prophet과 동일하죠.



<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
df = data[['ds','cnt']]
df.columns = ['ds','y']
```

지금부터 NeuralProphet에서 분위 회귀를 구축하러 바로 가봅시다. 5번, 10번, 50번, 90번, 95번 분위의 값을 얻고 싶다고 가정해봅시다. quantile_list = [0.05, 0.1, 0.5, 0.9, 0.95]로 지정하고, quantile_list를 켜려면 "parameter quantiles = quantile_list"를 사용합니다. 나머지 매개변수는 Chapter 3: Tutorial I: Trend + seasonality + holidays & events에서와 동일합니다.

```python
from neuralprophet import NeuralProphet, set_log_level

quantile_list=[0.05,0.1,0.5,0.9,0.95]
# Model and prediction
m = NeuralProphet(
    quantiles=quantile_list,
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False
)
m = m.add_country_holidays("US")
m.set_plotting_backend("matplotlib")  # Use matplotlib

df_train, df_test = m.split_df(df, valid_p=0.2)
metrics = m.fit(df_train, validation_df=df_test, progress="bar")
metrics.tail()
```

작업이 완료되면 prophet에서 상속받은 .make_future_dataframe()을 사용하여 예측을 위한 새 데이터 프레임을 만들 것입니다. n_historic_predictions 매개변수는 지난 100개 데이터 포인트만 포함하도록 설정됩니다. "True"로 설정하면 전체 기록이 포함됩니다. "periods=50"를 설정하여 다음 50개 데이터 포인트를 예측합니다.



<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
미래 = m.make_future_dataframe(df, periods=50, n_historic_predictions=100) #, n_historic_predictions=1)

# 훈련된 모델로 예측 수행
예측 = m.predict(df=미래)
예측.tail(60)
```

예측값은 "forecast" 데이터 프레임에 저장됩니다.

![이미지](/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_4.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>

```js
m.plot(
    forecast,
    plotting_backend="plotly-static"
    #plotting_backend = "matplotlib"
)
```

아래와 같이 플롯이 표시됩니다. 예측 구간은 분위값으로 제공됩니다!

<img src="/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_5.png" />

분위 회귀에 의한 예측 구간과 OLS에 의한 신뢰 구간은 다릅니다.



<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>

예측 구간이 인기를 얻으면, 분위수 회귀와 최소 자승법(OLS)에서의 신뢰 구간의 차이를 구별하는 것이 도움이 될 것입니다. 그림 (F)에서 좌측에는 선형 회귀를 그리고 우측에는 분위수 회귀를 표시했습니다.

![그림](/TIL/assets/img/2024-07-09-QuantileRegressionforTimeSeriesProbabilisticForecasting_6.png)

우선, 이들의 목표는 다릅니다:

- 선형 회귀: 주요 목표는 종속 변수의 조건부 평균과 가능한 한 가까운 예측 값을 찾는 것입니다.
- 분위수 회귀: 목표는 특정 신뢰 수준에서 예상되는 미래 관측값이 위치할 범위를 제공하는 것입니다. 종속 변수 Y의 조건부 분포의 다양한 분위수에서 독립 변수(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>

다음으로, 그들의 계산방법이 다릅니다:

- 선형 회귀에서 신뢰구간은 독립변수의 계수에 대한 구간 추정입니다. 예를 들어 b ± 1.96 \* b의 표준 오차(Figure F)와 같이 표시됩니다. 이는 주로 최소 총 거리를 찾기 위해 최소제곱법(OLS)을 사용하여 데이터 포인트와 선 간의 거리를 최소화합니다. 계수가 변할 수 있기 때문에 예측된 조건부 평균값도 변할 수 있습니다. Figure F의 왼쪽 그래프에서, 계수 b가 변하기 때문에 예측된 평균값이 약간씩 다를 수 있습니다.
- 분위 회귀에서는 종속 변수의 25번째, 50번째 또는 75번째 분위와 같은 분위수 수준을 선택하여 회귀 계수를 추정합니다. 분위 회귀는 일반적으로 절대 편차의 가중 합을 최소화하지만 OLS를 사용하지는 않습니다.

세 번째로, 그들의 응용이 다릅니다:

- 선형 회귀에서는 "예측된 조건부 평균은 95% 신뢰구간 내에 있다"라고 말합니다. 신뢰구간은 전체 범위가 아닌 조건부 평균이기 때문에 예측 구간보다 좁습니다.
- 분위 회귀에서는 "예측값이 예측 구간의 범위 내에 들어갈 가능성이 95%입니다."라고 말합니다.



<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>

결론

이 장에서는 예측 구간을 위한 분위수 회귀의 개념을 배웠습니다. NeuralProphet을 사용하여 예측 구간을 생성하는 방법을 보여주었습니다. 또한 비즈니스 응용 프로그램에서 흔히 혼동되는 예측 구간과 신뢰 구간의 차이를 구별했습니다. 다음 장에서는 예측 불확실성에 대한 다른 중요한 기술인 준수 역분위 회귀(CQR)를 계속 공부할 것입니다.

샘플 eBook 장(무료): [링크](https://github.com/dataman-git/modern-time-series/blob/main/20240522beauty_TOC.pdf)

- 아름다운 형식으로 책을 재현하여 즐거운 독서 경험을 제공해준 The Innovation Press, LLC 직원들에게 감사드립니다. eBook을 분배하기 위해 Teachable 플랫폼을 선택했습니다. 이를 통해 부담스럽지 않은 경비와 전 세계 독자들에게 배포할 수 있었습니다. 신용카드 거래는 Teachable.com에서 기밀이지키며 안전하게 처리됩니다.



<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>

eBook on Teachable.com: $22.50
[링크](https://drdataman.teachable.com/p/home)

The print edition on Amazon.com: $65 [링크](https://a.co/d/25FVsMx)

- 프린트 판은 광택 처리된 표지, 컬러 출력물, 아름다운 Springer 글꼴 및 레이아웃을 채택하여 즐거운 독서 경험을 제공합니다. 7.5 x 9.25 인치의 크기는 서재에 있는 대부분의 책들과 어울립니다.
- “이 책은 부오파이의 시계열 분석에 대한 깊은 이해와 예측 분석 및 이상 감지 분야에서의 응용을 검증하는 것입니다. 이 책은 독자들이 실제 세상의 도전 과제에 대처할 수 있는 필수적인 기술을 제공합니다. 데이터 과학으로의 전환을 원하는 사람들에게 특히 가치 있는 자료입니다. 부오파이는 전통적인 기술과 최신 기술 모두에 대해 상세하게 탐구합니다. 부오파이는 신경망 및 기타 고급 알고리즘에 대한 토론을 통합하여 최신 트렌드와 발전 상황을 반영합니다. 이는 독자가 확립된 방법뿐만 아니라 데이터 과학 분야의 가장 최신 및 혁신적인 기술과도 상호작용할 준비가 되어 있는지를 보장합니다. 부오파이의 생생하고 접근 가능한 글쓰기 스타일 때문에 이 책의 명료함과 접근성은 높아졌습니다. 그는 복잡한 수학 및 통계 개념을 풀어내어 엄밀성을 희생하지 않으면서도 접근 가능하게 만들어냅니다.”

# 모던 시계열 예측: 예측 분석 및 이상 감지를 위한



<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>

Chapter 0: 서문

Chapter 1: 소개

Chapter 2: 비즈니스 예측을 위한 선지자

Chapter 3: 튜토리얼 I: 트렌드 + 계절성 + 휴일 및 이벤트



<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 형식으로 변경된 내용입니다:

- Chapter 4: Tutorial II: Trend + seasonality + holidays & events + auto-regressive (AR) + lagged regressors + future regressors

- Chapter 5: Change Point Detection in Time Series

- Chapter 6: Monte Carlo Simulation for Time Series Probabilistic Forecasting

- Chapter 7: Quantile Regression for Time Series Probabilistic Forecasting



<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>

# Chapter 8: 시계열 확률 예측을 위한 조화형 예측

# Chapter 9: 시계열 확률 예측을 위한 조화화된 분위 회귀

# Chapter 10: 자동 ARIMA!

# Chapter 11: 시계열 데이터 형식 만들기 쉽게



<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>

# Chapter 12: 다기간 확률 예측을 위한 선형 회귀

## Chapter 13: Tree-based 시계열 모델을 위한 피처 엔지니어링

### Chapter 14: 다기간 시계열 예측을 위한 두 가지 기본 전략

#### Chapter 15: 다기간 시계열 확률 예측을 위한 Tree-based XGB, LightGBM, 및 CatBoost 모델



<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>

# 16 장: 시계열 모델링 기법의 진보

# 17 장: 시계열 확률 예측을 위한 딥러닝 기반 DeepAR

# 18 장: 주가에 대한 확률 예측 응용

# 19 장: RNN에서 Transformer 기반 시계열 모델로



<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>

# 20장: 해석 가능한 시계열 예측을 위한 시간 퓨전 트랜스포머

# 21장: 시계열 예측을 위한 오픈 소스 Lag-Llama 튜토리얼

시계열 확률 예측을 위한 분위 회귀 방법 

요즘의 디지털 시대에, 챗봇은 간단한 자동응답 도구에서 복잡하고 맥락을 이해하는 대화를 수행할 수 있는 가상 보조로 진화했습니다. 이 글에서는 파이썬과 허깅페이스의 트랜스포머 라이브러리를 사용하여 생성 모델인 GPT-2와 같은 고급 모델을 활용해 AI 챗봇을 구축하는 방법을 살펴보겠습니다.

# 생성식 AI 챗봇 소개

생성식 AI 챗봇은 인공 지능의 중요한 발전을 나타내며, 기업이 고객 지원을 자동화하고 사용자-시스템 상호작용을 향상시키는 데 기여합니다. 미리 정의된 응답에 제한된 규칙 기반 챗봇과는 달리, 생성식 챗봇은 자연어를 이해하고 생성하는 더 현실적인 대화를 할 수 있습니다.

# 사용된 도구 및 라이브러리



<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: 다재다능하고 배우기 쉬운 프로그래밍 언어.
- Transformers: 사전 학습된 언어 모델 구현을 제공하는 허깅페이스 라이브러리.
- Flask: Python으로 웹 응용 프로그램을 구축하기 위한 가볍고 효율적인 웹 프레임워크.
- PyTorch: 인공지능 모델을 훈련하고 평가하는 데 사용되는 머신러닝 라이브러리.

# 단계 1: 환경 설정

시작하기 전에 시스템에 Python과 pip이 설치되어 있는지 확인하세요. 그런 다음 터미널에서 다음 명령을 실행하여 필요한 라이브러리를 설치하세요:



<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>

![2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_0.png](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_0.png)

# Step 2: Loading GPT-2 Model and Tokenizer

To begin, import the required libraries and load the pretrained GPT-2 model and its corresponding tokenizer:

![2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_1.png](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_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>

# 단계 3: 응답 함수 생성

사용자 입력을 가져와 인코딩하고 GPT-2 모델을 사용하여 응답을 생성하는 함수를 정의하세요:

![image](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_2.png)

# 단계 4: Flask 어플리케이션 설정



<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>

다음으로 웹 요청을 처리하고 챗봇을 위한 직관적 인터페이스를 제공하기 위해 Flask 애플리케이션을 설정하세요:

![image1](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_3.png)

![image2](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_4.png)

![image3](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_5.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-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_6.png)

# 단계 5: Flask 앱 실행 및 상호 작용

챗봇 애플리케이션을 실행하려면:

- 위의 Python 코드를 파일에 저장하세요. 예를 들어, chatbot_app.py로 저장합니다.
- 터미널이나 명령 프롬프트를 엽니다.
- chatbot_app.py 파일이 위치한 디렉토리로 이동합니다.
- Flask 애플리케이션을 시작하려면 다음 명령을 실행하세요:



<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>

![Image](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_7.png)

- 어플리케이션이 시작되면 웹 브라우저를 열고 챗봇과 상호 작용하기 위해 http://127.0.0.1:5000/ 로 이동하세요.

![Image](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_8.png)

![Image](/TIL/assets/img/2024-07-09-CreatingaGenerativeAIChatbotwithPythonandTransformers_9.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>

# 결론

생성형 AI 챗봇은 기업과 사용자가 상호 작용하는 방식을 혁신하고 있습니다. Hugging Face의 Transformers와 같은 고급 도구를 활용하면 자연스럽고 맥락 있는 대화를 이어나갈 수 있는 챗봇을 만들 수 있으며, 이는 사용자 경험을 크게 향상시킵니다.

파이썬과 트랜스포머로 생성형 AI 챗봇 만들기 방법

![image](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_0.png)

인공 일반 지능(AGI)을 향한 탐구는 몇십 년 동안 연구 커뮤니티의 관심을 사로 잡아 왔습니다.

AGI는 인간이 하는 것과 비슷하게 프로그래밍되지 않은 상태에서도 다양한 작업을 수행할 수 있는 AI 시스템의 능력을 나타냅니다. 이는 우리가 학습, 추론 및 새로운 상황에 적응할 수 있는 능력을 갖춘 시스템을 찾고 있다는 것을 의미합니다.

그러나 분야에서 중요한 발전이 있었음에도 불구하고, 대부분의 AI 시스템은 아직도 좁은 작업과 영역에 제한되어 있어 AGI는 여전히 애매한 목표로 남아 있습니다.



<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>

`<table>`태그를 Markdown 형식으로 변경해 주세요.

그 이유가 무엇인가요?

# 인공지능이 잘하지 못하는 것

AGI에 대한 주요 장애물 중 하나는 현대 인공지능 시스템이 추론보다는 기억에 의존하고 있다는 것입니다. 우리가 모두 아는 이 시스템들인 Language Large Models (LLMs)는 학습 데이터의 패턴을 암기하고 인접한 맥락에서 적용하는 데 능숙합니다.

하지만 새로운 경우를 바탕으로한 새로운 추론을 생성하는 능력이 부족합니다.



<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>

LLM은 독창적이거나 혁신적인 상황에 기반한 새로운 추론을 생성할 수 없으며 기억에 의존한다는 제한이 있습니다.

또 다른 문제는 AI 시스템이 학습 데이터를 넘어서 일반화할 수 없는 점입니다. 예를 들어, 체스를 하는 방법을 학습한 AI 시스템은 사람들보다 더 잘 체스를 둘 수 있지만, 체커 또는 바둑과 같은 다른 보드 게임에 해당 지식을 전이시키는 것은 불가능합니다.

이러한 일반화 실패는 AGI를 달성하는 데 중요한 장애물이며, 시스템이 새로운 상황에 지식을 적용하는 능력을 제한합니다.

![이미지](https://miro.medium.com/v2/resize:fit:1400/1*_LbxAoOCs7Ed8ThxzsC_eQ.gif)



<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>

# 새로운 패러다임과 새로운 기준

2019년, Keras의 창시자 인 프랑수아 쇌레(François Chollet)는 2.5백만 명 이상의 개발자가 채택한 오픈 소스 딥 러닝 라이브러리인 Keras의 창시자이자 Google의 소프트웨어 엔지니어 및 AI 연구원으로서, 영향력 있는 논문 "지능의 측정에 관하여"을 발표했습니다. 이 논문에서 그는 알려지지 않은 작업에 대한 AI 기술 습득의 효율을 측정하기 위한 기준인 추상화 및 추론 코퍼스(ARC-AGI)를 소개했습니다.

마침내, 모든 좋은 과학이 해야 할 것처럼, 우리는 정의로부터 시작해야 합니다. AGI에 대한 일반적인 합의는 "경제적 가치가 있는 작업의 대부분을 자동화할 수 있는 시스템"으로 정의된다는 것입니다. 이것이 유용한 목표로 간주될 수 있지만... 이것은 지능의 부정확한 측정입니다.

보다 지능적이고 인간과 유사한 시스템을 위한 고의적인 진보를 이루기 위해, 우리는 적절한 피드백 신호를 따라야 합니다: 우리는 지능을 정의하고 평가해야 합니다.



<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>

## 기술, 암기 및 지능

기술은 이전 지식과 경험에 크게 영향을 받습니다. 무제한의 사전 지식이나 무제한의 교육 데이터는 개발자들에게 시스템의 기술 수준을 "구매"할 수 있는 기회를 제공합니다. 이것은 시스템 자체의 일반화 능력을 가리게 합니다.

현대 인공지능 (LLM)은 뛰어난 암기 엔진으로 입증되었습니다. 그들은 훈련 데이터에서 고차원의 패턴을 기억하고 해당 패턴을 인접한 문맥에 적용할 수 있습니다.

이것은 그들의 겉보기 추론 능력이 작동하는 방식입니다. LLM은 실제로 추론하지 않습니다. 대신, 그들은 추론 패턴을 암기하고 해당 추론 패턴을 인접한 문맥에 적용합니다. 그러나 그들은 새로운 상황에 기반한 새로운 추론을 만들어 내지 못합니다.



<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>

지능은 넓거나 일반적인 능력에 있습니다; 훈련 데이터 외에도 새로운 기술을 효율적으로 습득할 수 있는 시스템으로 AGI를 정의하는 방식을 조정해야 합니다. 아니, 더 나아가...

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

# 이러한 종류의 지능을 어떻게 측정할 수 있을까요?

대부분의 AI 벤치마크는 기술을 측정합니다. 하지만 기술은 지능이 아니라는 것을 방금 보았죠?



<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>

2019년 같은 연구에서 탄생한 **인공 일반 지능(AGI)**을 위한 추상화 및 추론 말뭉치 (ARC-AGI)는 AGI의 유일한 공식 벤치마크로 여겨집니다.

**추상화 및 추론 말뭉치(ARC)**는 AI 시스템의 작업 범위에 걸쳐 습득 능률을 테스트하도록 특별히 설계된 벤치마크입니다.

![이미지](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_2.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>

여기에는 명확한 의도가 있습니다. 즉, AI 시스템이 예시로부터 학습하고 그 지식을 새로운, 보지 못한 문제를 해결하는 데 적용할 수 있는 능력을 검증하는 것입니다. 이는 인간과 유사한 지능의 중요한 측면으로, 종종 "유동적 지능"이라고 합니다.

ARC 벤치마크는 중요한 이유가 있습니다.

- 이는 이러한 추상적 추론을 필요로 하는 작업에 어려움을 겪는 현재의 기계 학습 방법에 도전합니다.
- 이것은 연구자들이 인간 수준의 지능을 달성하기에 더 가까운 AI 시스템을 개발하는 데 도움이 됩니다.

![이미지](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_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>

# 다분야 접근

인공 일반 지능(AGI)으로 나아가는 진전이 멈춰있습니다. 엄청나게 방대한 양의 데이터로 훈련된 LLM은 그럼에도 불구하고, 훈련받지 않은 간단한 문제에 적응하거나 새로운 발명을 할 수 없는 상황입니다.

Chollet이 만든 2019년 Abstraction and Reasoning Corpus for Artificial General Intelligence (ARC-AGI)는 AGI의 유일한 공식적인 벤치마크입니다.

최근 NYU 교수이자 Meta의 최고 AI 과학자인 야얀 르쿤은 AGI 분야에서 진전하려면 LLM에 집중해서는 안된다고 공개적으로 언급했습니다...



<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>

![image](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_4.png)

저는 이 도발을 좋아하고, 모든 AI 연구자가 이 도전에 대해 잘 알고 있다고 믿습니다. 대학 연구자들이 이 분야에서 몇 발자국 앞서 나가야 한다고 생각합니다. 학계는 보통 문제에 대해 다학제적 접근에 숙달되어 있지만, 그들은 자금과 컴퓨팅 파워 등 자원이 부족합니다.

그러나 현재 AI 연구의 추세는 소스코드를 공개하지 않는 연구 방향으로 이동하고 있어서 아이디어와 지식의 공유를 제한하고 있습니다. 이 추세는 "스케일만 있으면 충분하다"는 믿음과 경쟁 우위를 보호하려는 욕심에서 나온 것이죠. 이 방식은 혁신을 억불하며 AGI로의 진전속도를 제한합니다.

언제나 예외는 있습니다...



<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>

오픈 소스 연구는 협력과 지식 공유를 촉진하여 AGI로의 진전 속도를 가속화합니다. 연구를 공개로 접근 가능하게 함으로써 전 세계의 연구자들이 더 지능적인 AI 시스템의 개발에 기여할 수 있으며, 다양한 시각에서 새로운 아이디어와 혁신이 탄생할 수 있습니다.

AI 연구에서의 투명성 부족과 협력은 AGI가 임박했다는 오도된 인식에 기여하고 있으며, 이는 AI 규제 환경에 영향을 미치고 있습니다. 규제 당국은 AGI가 임박했다는 잘못된 가정 하에 길잡이 AI 연구에 대한 장애물을 고려하고 있습니다.

오픈 소스 연구는 더 지능적인 AI 시스템의 개발을 이끌어주고 일반 지능의 더 정확한 측정 지표를 제공할 수 있습니다.

ARC Challenge는 대규모 경쟁을 진행하는 역사가 있으며, 2020년 Kaggle에서 시작된 첫 번째 ARC-AGI 대회를 시작으로 2022년과 2023년에는 ARCathon이 열렸으며, 가장 최근에는 상금 총액이 1.1백만달러가 넘는 ARC Prize 2024가 있습니다.



<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>

![2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_5.png](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_5.png)

# 결론…

AGI를 위한 탐험은 복잡하고 도전적인 목표이지만 불가능한 것은 아닙니다.

현대 AI의 제한을 극복하고 AGI를 준비하기 위해, 우리는 오픈소스 연구의 적극적 지지자가 되어야 합니다.



<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>

하지만 그보다 중요한 것은 우리가 어떤 지적인 것이란 것에 대한 오픈 토론의 일부가 되어야 한다는 것입니다. 다양한 분야의 시각에서 바라봤을 때 어떤 지능인지에 대한 토론을 펼쳐야 합니다.

그렇게 함으로써 누구라도 프로그래밍 전문가가 아니더라도 더 지적인 AI 시스템의 개발에 기여할 수 있게 되어 AGI로의 발전속도를 높일 수 있습니다.

만약 이 이야기가 가치있었다면 조금이라도 지원을 보여주고 싶다면 다음과 같은 방법을 사용할 수 있습니다:

- 이 이야기에 대해 많이 박수를 치기
- 기억하기에 더 중요한 부분을 강조하기 (나중에 그것들을 찾는 데 더 편리하고 나에게는 더 나은 기사를 쓸 수 있습니다)
- '자체 AI 구축하기' 시작하는 방법 배우기, 무료 eBook 다운로드하기
- 저를 Medium에서 팔로우하기
- 내 최신 기사 읽기 https://medium.com/@fabio.matricardi



<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>

자료 및 참고 자료:

![Generative AI](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_6.png)

이 이야기는 Generative AI에서 게시되었습니다. LinkedIn에서 저희와 연락을 유지하고 최신 AI 이야기에 대해 최신 정보를 얻으려면 Zeniteq를 팔로우하세요.

저희의 뉴스레터를 구독하여 generative AI의 최신 뉴스와 업데이트를 받아보세요. 함께 AI의 미래를 함께 만들어가요!



<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>

![Image](/TIL/assets/img/2024-07-09-ProgresstowardstrueArtificialGeneralIntelligenceAGIhashitawall_7.png)

진정한 인공지능의 벽에 부딪힌 AGI의 발전 현황

여러 기간의 시계열 확률 예측을 위한 XGB, LightGBM, CatBoost 모델 비교 분석

![이미지](/TIL/assets/img/2024-07-09-12PythonListThingsIRegretNotKnowingEarlier_0.png)

파이썬 여행을 하면서 몇 가지를 좀 늦게 알게 되었는데, 아마 당신이 이것들을 더 빨리 배울 수 있을 거에요.

### 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>

```js
a = [1, 2]
b = [3, 4]

c = [*a, *b, 5]

print(c) # [1, 2, 3, 4, 5]
```

- 첫 번째 \*는 a의 요소를 c에 풀어 헤친다
- 두 번째 \*는 b의 요소를 c에 풀어 헤친다
- 이것이 왜 1, 2, 3, 4, 5가 동일한 목록 c에 들어 있는지 이유입니다

```js
a = [1, 2]
b = [3, 4]
c = [5, 6]
d = [7, 8]

x = [*a, b, *c, d]

print(x) # [1, 2, [3,4], 5, 6, [7, 8]]
```

^ \*이 붙은 리스트(a와 c)만 풀어 헤쳐진다는 것을 주목해 주세요. b와 d는 일반 요소처럼 처리됩니다.



<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
mylist = ['apple', 'orange', 'pear', 'pineapple', 'durian']

a, b, *others = mylist

print(a)       # apple
print(b)       # orange
print(others)  # ['pear', 'pineapple', 'durian']
```

- a는 mylist의 첫 번째 요소에 할당됩니다.
- b는 mylist의 두 번째 요소에 할당됩니다.
- others는 mylist의 모든 다른 요소를 받는 리스트에 할당됩니다.



<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>

노트 - a와 b가 반드시 가장 앞에 있을 필요는 없습니다.

```js
mylist = ['apple', 'orange', 'pear', 'pineapple', 'durian']

a, *others, b = mylist

print(a)       # apple
print(b)       # durian
print(others)  # ['orange', 'pear', 'pineapple']
```

- a는 mylist의 첫 번째 요소에 할당됩니다.
- b는 mylist의 마지막 요소에 할당됩니다.
- others는 mylist 사이에 모든 다른 요소를 캐치하는 리스트에 할당됩니다.

# 3) 리스트를 함수 인수로 언패킹하는 방법



<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>

함수 이름, 나이, 성별을 받는 test 함수가 있다고 가정해보죠. 이 함수를 사용하려면 test(이름, 나이, 성별)와 같이 전달해주어야 합니다.

```js
def test(name, age, gender):
    print(name, age, gender)

test('rocky', 5, 'male') # rocky 5 male
```

만약 올바른 함수 인수를 포함하는 리스트 x = ['rocky', 5, 'male']가 있다면, \*를 사용하여 해당 인수를 함수에 전달할 수 있습니다.

```js
x = ['rocky', 5, 'male']

test(*x) # rocky 5 male
```



<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
test("rocky", 5, "male");
```

# 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>

만약 우리가 [1, 2, 3, 4, 5]라는 리스트가 있고, 각 요소를 10씩 곱해서 [10, 20, 30, 40, 50] 리스트를 만들고 싶다면, 리스트 컴프리헨션 없이는 어떻게 할 수 있을까요:

```js
numbers = [1, 2, 3, 4, 5]

newlist = []
for number in numbers:
    newlist.append(number * 10)

print(newlist)  # [10, 20, 30, 40, 50]
```

리스트 컴프리헨션을 사용하여 훨씬 더 우아하게 할 수 있는 방법은 다음과 같습니다:

```js
numbers = [1, 2, 3, 4, 5]

newlist = [n * 10 for n in numbers]

print(newlist)  # [10, 20, 30, 40, 50]
```



<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>

# 5) 중첩된 리스트에 대한 리스트 컴프리헨션

하지만 중첩된 for 루프는 어떻게 할까요? 걱정하지 마세요. 리스트 컴프리헨션은 이를 쉽게 처리할 수 있습니다. 리스트 컴프리헨션을 사용하지 않은 예시를 통해 살펴보겠습니다:

```js
newlist = []

for i in [1, 2]:
    for j in [3, 4]:
        t = (i, j)
        newlist.append(t)

print(newlist) # [(1, 3), (1, 4), (2, 3), (2, 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
newlist = [(i,j) for i in [1,2] for j in [3,4]]

print(newlist) # [(1, 3), (1, 4), (2, 3), (2, 4)]
```

^ 중첩된 for 루프를 리스트 내포로 변환할 때는 외부 for 루프가 먼저 오고, 그 다음에 내부 for 루프가 옵니다.

# 6) 튜플 대 리스트

비기너였을 때 저는 꽤 오랫동안 튜플을 무시했습니다.



<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
# 리스트는 변경할 수 있습니다. .append를 사용하여 만든 후에도 요소를 추가할 수 있습니다.

mylist = [1, 2, 3]

mylist.append(4)
print(mylist)      # [1, 2, 3, 4]
```

```js
# 튜플은 변경할 수 없습니다. 만든 후에는 아무것도 추가할 수 없습니다

mytuple = (1, 2, 3)

mytuple.append(4) # ERROR
```

그래서 튜플은 목록의 안 좋은 버전으로 보입니다. 왜 튜플을 사용해야 할까요?



<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
# 리스트는 1) 사전 키로 사용할 수 없으며 2) 집합에 추가할 수 없음

d = {
    [1, 2, 3]: 4,
    [5, 6, 7]: 8
}

# ERROR
```

```js
# 하지만 튜플은 가능합니다

d = {
    (1, 2, 3): 4,
    (5, 6, 7): 8
}

# OK
```



<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>

# 7) .insert()을 사용하여 특정 인덱스에 새 요소를 삽입합니다.

.append()은 리스트의 뒷부분에만 새 요소를 추가할 수 있습니다.

하지만 .insert()을 사용하면 새 요소를 어떤 인덱스에든 추가할 수 있습니다.

```js
mylist = [1, 2, 3]

# 새 값 100을 인덱스 0에 추가
mylist.insert(0, 100)

print(mylist) # [100, 1, 2, 3]
```



<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>

^ 기존 요소가 모두 오른쪽으로 이동해야 하므로 이 작업은 O(n) 시간이 걸립니다.

```js
mylist = [1, 2, 3]

# 인덱스 2에 새로운 요소 150 추가
mylist.insert(2, 150)

print(mylist) # [1, 2, 150, 3]
```

^ 1과 2는 그대로 있지만, 3은 오른쪽으로 이동해야 합니다.

# 8) .pop()을 사용하여 요소 제거



<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>

.pop() 메소드를 사용하면 2가지 작업을 동시에 할 수 있습니다:

- 리스트의 마지막 요소를 삭제합니다.
- 삭제된 이 요소를 반환합니다.

```js
mylist = [1, 2, 3]

# 마지막 요소 제거하고 x에 할당
x = mylist.pop()

print(x)      # 3
print(mylist) # [1, 2]
```

.pop()에 인덱스를 전달하면 해당 인덱스의 요소를 제거할 수 있습니다.



<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
내목록 = [1, 2, 3]

# 인덱스 0의 요소를 제거하고 x에 할당
x = 내목록.pop(0)

print(x)       # 1
print(내목록)  # [2, 3]
```

.pop(n)은 모두 n 이후에 위치한 인데스의 요소를 좌측으로 이동해야 하므로 O(n) 시간이 걸린다는 것을 알아두세요. 이것은 우리 목록이 매우 큰 경우 비효율적일 수 있다는 것을 의미합니다.

# 9) .extend()를 사용하여 목록 결합

.extend()는 한 목록의 모든 요소를 다른 목록에 추가할 수 있게 해줍니다.



<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
a = [1, 2, 3]
b = [4, 5, 6]

# b의 모든 요소를 a에 추가합니다.
a.extend(b)

print(a)  # [1, 2, 3, 4, 5, 6]
print(b)  # [4, 5, 6]
```

^ b가 변경되지 않았음에 유의해주세요

# 10) sort() vs sorted()

- `.sort()`은 리스트 자체를 정렬합니다.



<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
mylist = [1, 3, 2]

mylist.sort()

print(mylist) # [1, 2, 3]
```

sorted() 함수는 리스트를 정렬한 복사본을 생성합니다. 원본 리스트는 그대로 유지됩니다. 원본 리스트의 순서를 보존하고 싶을 때 이것을 사용합니다.

```js
mylist = [1, 3, 2]

newlist = sorted(mylist)

print(newlist)  # [1, 2, 3]
print(mylist)   # [1, 3, 2]
```

# 11) 사용자 정의 조건으로 .sort()하기



<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>

**참고— 이것은 .sort()와 sorted()에 대해 동일하게 작동합니다.**

기본 .sort()는 문자열을 알파벳 순서대로 정렬합니다:

```js
fruits = ['orange', 'apple', 'pear']

fruits.sort()

print(fruits) # ['apple', 'orange', 'pear']
```

우리는 .sort()에서 key 인자에 함수를 전달하여 사용자 정의 정렬 조건을 정의할 수 있습니다. 예: list.sort(key=your_function)



<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>

- 함수는 전체 요소를 가져와서
- 우리가 정렬하려는 값을 반환합니다.

문자열 내의 p의 개수로 정렬하고 싶다고 가정해 봅시다.

- 따라서 사용자 정의 함수는 여전히 전체 요소를 가져와서
- p 문자의 개수를 반환합니다.

```js
def your_condition(element: str) -> int:
    return element.count('p')

fruits = ['orange', 'apple', 'pear']

fruits.sort(key=your_condition)

print(fruits) # ['orange', 'pear', 'apple']
```



<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 형식으로 변경하세요.



<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>

노트 - 이 코드는 .sort()와 sorted() 모두에 작동합니다.

학생을 나타내는 각각의 사전이 포함된 목록이 있다고 가정해 봅시다.

```js
students = [
  { name: "A", math: 100, science: 81 },
  { name: "B", math: 100, science: 71 },
  { name: "C", math: 100, science: 91 },
  { name: "D", math: 80, science: 91 },
  { name: "E", math: 80, science: 93 },
  { name: "F", math: 80, science: 92 },
];
```

그리고 그들의 수학 점수에 따라 정렬한다고 가정합시다:



<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
students.sort(key=lambda x:x['math'])

print(students)

'''
[
  {'name': 'D', 'math': 80, 'science': 91},
  {'name': 'E', 'math': 80, 'science': 93},
  {'name': 'F', 'math': 80, 'science': 92},
  {'name': 'A', 'math': 100, 'science': 81},
  {'name': 'B', 'math': 100, 'science': 71},
  {'name': 'C', 'math': 100, 'science': 91}
]
'''

^ math=80 at the front, math=100 at the back. But notice that their science score is not sorted.

And what if we want to sort by math first, then science?

- first sort by math score
- for students with the same math score, sort by science score
```



<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
students.sort(key=lambda x:(x['math'], x['science']) )

print(students)

'''
[
  {'name': 'D', 'math': 80, 'science': 91},
  {'name': 'F', 'math': 80, 'science': 92},
  {'name': 'E', 'math': 80, 'science': 93},
  {'name': 'B', 'math': 100, 'science': 71},
  {'name': 'A', 'math': 100, 'science': 81},
  {'name': 'C', 'math': 100, 'science': 91}
]
'''
```

그리고 여기서, 수학 점수가 동일한 학생들은 과학 점수에 의해 정렬됨을 주목해 보세요.

참고 — 3가지 조건에 따라 정렬하려면, 단순히 (첫 번째 조건, 두 번째 조건, 세 번째 조건)의 튜플을 반환하면 됩니다.



<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 농담

# 만약에 제작자로서 저를 지원하고 싶다면



<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>

- 제 책을 구입해 주세요! — 101 Things I Never Knew About Python
- 확인할 수 있는 곳: [여기](https://payhip.com/b/vywcf)
- 이 이야기를 위해 50번 클랩을 해주세요
- 댓글로 당신의 생각을 남겨주세요
- 이야기 중 가장 좋아하는 부분을 강조해주세요

감사합니다! 이런 작은 행동이 큰 도움이 되고, 정말 감사드립니다!

YouTube: [여기](https://www.youtube.com/@zlliu246)

LinkedIn: [여기](https://www.linkedin.com/in/zlliu/)

알아두었으면 좋았을 Python 리스트 방법 12가지

다중 기간 확률 예측을 위한 선형 모델 이해하기

![Advanced String Manipulations in Python](/TIL/assets/img/2024-07-09-AdvancedStringManipulationsinPython_0.png)

파이썬에서 문자열은 기본적이며 거의 모든 파이썬 애플리케이션에서 널리 사용됩니다. 연결 및 슬라이싱과 같은 기본적인 문자열 작업은 간단하지만, 파이썬은 코드를 보다 효율적이고 가독성 있게 만들어주는 다양한 고급 문자열 조작 기술을 제공합니다. 이 기사는 파이썬에서의 고급 문자열 조작에 대해 자세히 설명하고 있으며, 중급 개발자들이 문자열 처리 능력을 향상할 수 있도록 예제와 함께 제공합니다.

# 문자열 포매팅

## format() 사용하기



<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>

`format()` 메서드는 더 다양한 문자열 포맷팅을 가능하게 합니다.

```js
name = "Alice";
age = 30;
formatted_string = "Name: {}, Age: {}".format(name, age);
print(formatted_string);
```

결과:

```js
Name: Alice, Age: 30
```



<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>

이 방법은 다양한 형식 요구에 유연하게 대응할 수 있도록 위치 및 키워드 인수를 포함할 수 있습니다.

## f-Strings 사용하기

Python 3.6에서 소개된 f-strings는 문자열 리터럴 내부에 표현식을 잘 포함하는 간결한 방법을 제공합니다.

```js
name = "Alice"
age = 30
formatted_string = f"Name: {name}, Age: {age}"
print(formatted_string)
```



<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
이름: Alice, 나이: 30
```

f-Strings는 format()보다 읽기 쉬우면서 더 빠릅니다.

# 문자열 메서드



<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()

join() 메서드는 지정된 구분자로 문자열의 이터러블을 연결하는 데 사용됩니다.

```js
words = ["Python", "is", "awesome"];
sentence = " ".join(words);
print(sentence);
```

결과:



<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
파이썬은 멋지다
```

이 방법은 루프에서 + 연산자를 사용하는 것보다 효율적입니다.

## split()

split() 메서드는 지정된 구분기호를 사용하여 문자열을 리스트로 분할합니다.



<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
sentence = "Python is awesome";
words = sentence.split(" ");
print(words);
```

결과:

```js
["Python", "is", "awesome"];
```

기본적으로 split()은 모든 공백을 구분자로 사용합니다.



<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>

# 문자열 변환

## replace()

replace() 메서드는 문자열에서 지정된 부분 문자열을 다른 부분 문자열로 대체합니다.

```js
text = "Hello, world!";
new_text = text.replace("world", "Python");
print(new_text);
```



<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
안녕하세요, 파이썬!
```

이 방법은 원본 문자열에서 부분 문자열의 모든 발생을 대체할 수 있습니다.

## translate()



<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>

더 복잡한 대체 작업을 위해서는 str.maketrans()와 결합된 translate()가 강력합니다.

```python
translation_table = str.maketrans("aeiou", "12345")
text = "Hello, world!"
translated_text = text.translate(translation_table)
print(translated_text)
```

결과:

```python
H2ll4, w4rld!
```



<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>

이 방법은 한 번의 패스로 여러 문자를 교체하는 데 유용합니다.

# 고급 패턴 매칭

## startswith() 및 endswith() 사용

이러한 메서드는 문자열이 지정된 부분 문자열로 시작하거나 끝나는지 확인합니다.



<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
텍스트 = "Python 프로그래밍";
print(텍스트.startswith("Python"));
print(텍스트.endswith("프로그래밍"));
```

결과:

```js
True;
True;
```

이 메서드들은 간단한 패턴 매칭에 정규식을 사용하는 것보다 더 빠릅니다.



<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>

# 문자열 정렬

## ljust(), rjust(), center() 사용하기

이러한 메서드들은 지정된 너비 내에서 문자열을 정렬합니다.

```js
text = "Python";
print(text.ljust(10, "-"));
print(text.rjust(10, "-"));
print(text.center(10, "-"));
```



<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
Python----
----Python
--Python--
```

이 방법들은 텍스트 기반 UI나 보고서에서 서식이 있는 출력을 만드는 데 유용합니다.

# 원치 않는 문자 제거



<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>

## strip(), lstrip(), 그리고 rstrip()

이 메서드들은 선행하거나 후행에 있는 문자들을 제거합니다.

```js
text = "   Python   ";
print(text.strip());
print(text.lstrip());
print(text.rstrip());
```

결과:



<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
Python;
Python;
Python;
```

기본적으로 이러한 메소드들은 공백을 제거하지만, 다른 문자를 지정할 수도 있어요.

# 대소문자 변환

## upper(), lower(), title(), capitalize()



<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
text = "python programming";
print(text.upper());
print(text.lower());
print(text.title());
print(text.capitalize());
```

결과:

```js
PYTHON PROGRAMMING
python programming
Python Programming
Python programming
```



<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 코드를 작성할 수 있습니다. 이 글에서 다룬 기술은 중급 Python 개발자가 익숙해져야 하는 기본 도구로, 더 복잡한 텍스트 처리 작업에 대비할 수 있는 견고한 기반을 제공합니다.

파이썬 고급 문자열 조작 기법들

아마 수많은 기사들을 보면, 파이썬에서 for-loop 대신 리스트 컴프리헨션을 사용하는 것을 권장하는 내용이 많다는 것을 이미 알아차렸을 것 같아요. 저도 많이 봤어요. 그런데 놀랍게도 그 이유에 대해 설명한 기사는 거의 찾아보기 힘들었죠.

"파이썬 다운"이라거나 "가독성"과 같은 이유들만으로는 제가 같은 사람들을 쉽게 설득할 수 없을 거에요. 이런 "이유"들은 실제로는 파이썬 초보자들에게 잘못된 인상을 줄 수 있어요. 즉, 파이썬 리스트 컴프리헨션이 단순히 문법적 설탕에 불과하다는 거죠.

사실, 리스트 컴프리헨션은 파이썬에서 큰 최적화 중 하나에요. 이 기사에서는 이러한 메커니즘에 대해 심층적으로 살펴볼 거에요. 아래 질문들에 대한 답을 얻을 수 있습니다.

- 파이썬의 리스트 컴프리헨션은 무엇인가요?
- 왜 리스트 컴프리헨션의 성능이 일반적으로 for-loop보다 우수한가요?
- 언제 리스트 컴프리헨션을 사용해서는 안 되나요?



<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. 간단한 성능 비교

![image](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_0.png)

우리는 간단한 프로그램을 작성할 것이다. 먼저 for 루프와 리스트 컴프리헨션을 사용한 방법으로 각각의 성능을 비교해보자.

```js
factor = 2
results = []

for i in range(100):
    results.append(i * factor)
```



<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>

위 코드는 100번 실행되는 for 루프를 정의합니다. range(100) 함수는 100개의 정수를 생성하고 각각은 요소와 곱해집니다. 이전에 정의된 요소는 2입니다.

이제 리스트 컴프리헨션 버전을 살펴봅시다.

```js
factor = 2
results = [i * factor for i in range(100)]
```

이 예제에서는 훨씬 더 쉽고 가독성이 좋습니다. 이 두 개의 동일한 코드 스니펫을 실행해보고 성능을 비교해봅시다.



<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>

![image](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_1.png)

결과는 리스트 컴프리헨션이 일반 for-loop보다 거의 2배 빠르다는 것을 보여줬어.

놀라운 건 아무것도 없어, 많은 기사들이 이미 말해줬던 내용이야. 하지만, 이 기사에서는 리스트 컴프리헨션이 왜 더 빠른지에 대해 집중적으로 다루고 있고, 내부에서 어떤 주요 차이가 있는지에 대해 논의할 거야.

이 기사의 나머지 내용을 설명할 수 있는 모든 설명의 근거와 기준을 얻기 위해, 위의 두 구현, 즉 for-loop와 리스트 컴프리헨션의 bytecode를 얻기 위해 Python 내장 dis 모듈을 사용해보자.



<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 dis

dis.dis("""
factor = 2
results = []

for i in range(100):
    results.append(i * factor)
""")

dis.dis("""
factor = 2
results = [i * 2 for i in range(100)]
""")
```

실행 결과는 다음과 같습니다. 바이트 코드를 이해할 필요는 없습니다. 단지 바이트 코드의 "작업"은 "운영 코드" 또는 간단히 "opcode"라고 불립니다. 나중에 해당 내용을 참조하겠습니다.

![Python List Comprehension](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_2.png)

![Python List Comprehension](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_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>

# 2. 전역 변수 대 로컬 변수

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

가장 큰 차이점은 변수의 범위입니다. 위의 바이트 코드에서 다음과 같이 나타납니다.

- for 루프의 LOAD_NAME 대 리스트 함축의 LOAD_FAST
- for 루프의 STORE_NAME 대 리스트 함축의 STORE_FAST



<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>

확실하게 말씀드리자면, for-loop 버전의 변수 i는 전역 범위에 있지만, 리스트 컴프리헨션의 변수 i는 지역 범위에 있어 실행 중에만 존재합니다.

## 변수의 범위(scopes)를 어떻게 확인할까요?

Python, Jupyter 또는 Google Colab과 같은 노트북 환경에서 이를 쉽게 확인할 수 있습니다. 새로운 세션을 시작한 후에 for-loop 버전을 실행한 다음 %whos 매직 명령어를 실행하면 현재 세션에 정의된 모든 사용자 변수가 나열됩니다.

```python
factor = 2
results = []

for i in range(100):
    results.append(i * factor)
```

```python
%whos
```



<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-09-PythonListComprehensionIsNotJustSyntacticSugar_5.png)

여기에는 for 루프가 끝난 후에도 변수 i가 여전히 남아 있는 것을 보여줍니다. 지금 global() 메소드를 실행하면 거기에도 변수 i를 찾을 수 있습니다.

그러나 세션을 재시작하고 리스트 내포를 실행하면 변수 i가 표시되지 않습니다.

![이미지](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_6.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>

이는 변수 i가 리스트 내포 구현에서 로컬 변수임을 증명했습니다.

## 왜 성능이 다를까요?

작업이 전역 네임스페이스에 있는 변수에 액세스해야 할 때, 전역 네임스페이스의 모든 객체 목록을 통과해야 합니다. 전역 네임스페이스에 무엇이 있는지 궁금하다면 세션에서 globals() 메서드를 실행해 보세요.

![이미지](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_7.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>

내 경우에는 Google Colab에서 새 세션을 시작했습니다. for 루프를 실행한 후 전역 네임스페이스 사전에 이미 26개의 객체가 있습니다. 더 복잡한 Python 애플리케이션을 실행한다고 상상해보면, 성능이 더 나빠질 수도 있습니다.

반면에 "로컬 변수"는 어떤가요?

안타깝게도, 리스트 내포에서 로컬 변수를 실행 중에 보여주는 것은 쉽지 않습니다. 따라서 간단한 함수를 사용하여 설명해보겠습니다. 함수 내부에 print() 메서드를 추가할 수 있기 때문이죠.

```js
def my_function(x, y):
    z = x + y
    print("로컬 변수:", locals())
    return z

my_function(1, 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>

아래 예시에서 x, y 및 z는 지역 변수입니다. 컴파일 시간에는 모든 지역 변수를 보유할 배열이 생성되며 각 변수에 고정된 인덱스가 지정됩니다. 개념적으로, 지역 변수 배열은 다음과 같이 나타낼 수 있습니다:

- x는 인덱스 0에 있음
- y는 인덱스 1에 있음
- z는 인덱스 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>

## 변수 대비 상수

변수 i를 제외하고 또 하나의 최적화는 로컬 변수 때문에 발생하고 있습니다.

변수 요소에 주의해주세요. 실제로, 요소 변수를 리스트 내포 밖에서 정의했지만, 그것은 로컬 상수로 리스트 내포에 로드될 것입니다.

![이미지](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_9.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>

위의 바이트 코드에서. 변수 factor를 모든 루프에서 전역 변수로 로드해야 합니다.

![image](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_10.png)

그러나 리스트 컴프리헨션에서는 컴파일러가 factor의 값을 변경할 수 없는 상수로 로드하고 지역 범위에 유지해도 충분히 안전합니다. 따라서 전역 네임스페이스에서 변수를 검색할 필요가 없습니다.

물론, 이것은 리스트 컴프리헨션의 성능에 기여하는 다른 요소입니다.



<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. 일반 메소드 vs 최적화된 메소드

![image](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_11.png)

또 다른 주요한 차이점은 append() 메소드에서 나타납니다. 두 가지 구현 방법의 단계를 보여드리겠습니다.

for 루프 버전에서:



<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>

- LOAD_METHOD은 리스트 객체 결과에서 append() 메서드를 로드합니다.
- LOAD_NAME은 변수 i를 로드합니다.
- LOAD_NAME은 변수 factor를 로드합니다.
- BINARY_MULTIPLY는 수학 연산을 수행합니다.
- CALL_METHOD은 append() 메서드를 호출하여 실행하고, 즉 결과를 결과 목록에 추가합니다.

리스트 컴프리헨션 버전에서:

- LOAD_FAST는 로컬 변수에서 변수 i를 로드합니다.
- LOAD_CONST는 변수 factor의 값인 상수 2를 로드합니다.
- BINARY_MULTIPLY는 수학 연산을 수행합니다.
- LIST_APPEND는 결과를 로컬 변수에서도 있는 목록에 추가합니다.

리스트 컴프리헨션 버전의 성능이 더 우수한 이유는 단순히 한 단계가 덜 있기 때문만이 아니라 내부적인 메커니즘 때문입니다.



<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>

## LOAD_METHOD과 LIST_APPEND가 왜 다른가요?

우리는 결과 목록에서 append() 메서드를 호출합니다. 즉, results.append(...)입니다. 이를 실행할 때 Python 런타임은 List 객체 공간에서 메서드를 찾아야 합니다. 이는 객체에 대해 dir() 메서드를 호출하는 것과 거의 동일합니다.

```js
print(dir(results));
```

<img src="/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_12.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>

당연히 이 "검색" 작업은 모든 루프에서 발생할 것입니다.

그러나 리스트 내포 버전에서 결과 리스트도 로컬 변수입니다. 이 메커니즘은 리스트가 생성될 것이고, 리스트 내포 실행과 함께 만들어진다는 것입니다.

비유를 들어보겠습니다. 작은 항목을 큰 컨테이너에 정리하는 것으로 상상해 보겠습니다.

for 루프 버전은 append() 메서드를 사용하는 것이 매번 우리가 항목과 상자를 다른 사람에게 주고, 이 사람이 항목을 넣은 후에 우리에게 컨테이너를 다시 돌려주는 것처럼합니다.



<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. 리스트 내포를 사용해서는 안 되는 경우

![Python List Comprehension](/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_13.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>

한 가지 전형적인 시나리오는 필터 조건이 너무 복잡하다는 것입니다. 다음 예를 고려해보세요. 학생들의 이름과 시험 점수가 들어있는 튜플 목록이 있습니다.

```js
students = [("Alice", 85), ("Bob", 95), ("Cindy", 100), ("David", 65), ("Eva", 70)];
```

그런 다음, 특정 조건에 따라 이름을 필터링하려고 합니다. 점수는 80보다 커야하고, 이름은 "A" 또는 "C"로 시작해야 합니다. 아래는 for 루프 구현입니다.

```js
filtered_names = []

for name, score in students:
    if score > 80 and name.startswith(("A", "C")):
        filtered_names.append(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>

여기에 리스트 컴프리헨션 구현방법이 있습니다.

```js
filtered_names = [name for name, score in students if score > 80 and name.startswith(("A", "C"))]
```

<img src="/TIL/assets/img/2024-07-09-PythonListComprehensionIsNotJustSyntacticSugar_14.png" />

음, 리스트 컴프리헨션의 성능은 여전히 for 루프보다 조금 더 나은 편이에요. 그러나 복잡한 조건 때문에 리스트 컴프리헨션은 가독성이 많이 떨어지기 시작했다고 말씀드려야 할 것 같아요.



<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-09-PythonListComprehensionIsNotJustSyntacticSugar_15.png)

이 글에서는 리스트 컴프리헨션의 성능이 일반 for-loop보다 우수한 이유에 대해 소개했습니다. 그것이 단순히 구문적인 설탕이 아니라 성능 최적화임을 증명했습니다.



<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>

두 구현의 바이트 코드를 표시하여 증거가 발굴되었습니다. 주요 차이점은 지역 vs. 전역 네임스페이스와 일반 메서드 vs. 최적화된 메서드입니다.

물론, 모든 시나리오에서 리스트 내포를 사용하는 것이 권장되지는 않습니다. 예를 들어, 조건이 매우 많은 계층과 보다 복잡한 조건을 갖는 경우입니다. 여전히 리스트 내포를 사용할 가치가 있는지 고려해야 합니다.

Posts