여러 기간의 시계열 확률 예측을 위한 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. 최적화된 메서드입니다.

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

Python 리스트 내포 List Comprehension 문법의 진정한 강점 단순한 문법 설탕이 아님

파이썬 코드로 알아보는 제품-시장 적합성 계량 분석 방법

iTransformer 최신 시계열 예측 기법 대공개

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

안녕하세요, 우주 여러분! 오늘은 Celery + RabbitMQ와 FastAPI를 사용한 최근 경험을 공유하려고 합니다. 최근에 오디오 분석 관련 프로젝트를 하고 있었어요. 이 프로젝트에서 일부 작업은 완료하는 데 조금 시간이 걸렸어요. 따라서 클라이언트가 서버에 요청을 보내면 이러한 작업 때문에 서버가 잠시 바쁠 거예요. 그래서 클라이언트 요청에 대한 응답을 보내는 데 상당한 시간이 소요되었죠. 이 상황을 방지하기 위해 백그라운드에서 작업을 실행하는 방법을 찾았어요. 결국 해결책인 Celery — 분산 작업 큐를 찾았고, 이 글에서는 어떻게 Celery를 사용해 목표를 이루었는지 설명할 거예요.

Celery는 실시간 처리를 지원하는 작업 큐이며 작업 스케줄링도 지원해요. 간단히 말해, 서버가 시간이 오래 걸리는 작업에 대한 요청을 받으면 해당 작업을 Celery 작업 큐에 추가하고 백그라운드에서 실행될 거예요. Celery는 작업의 상태를 유지하는데, 대기 중인지, 시작된 상태인지, 성공적인지 등을 확인할 수 있어요. Celery에는 메시지 브로커 서비스가 필요해요. 서버(주 어플리케이션)가 작업을 위해 요청을 받으면, celery 워커가 이용 가능할 때까지 작업은 작업 큐에 있어야 해요. 워커가 사용 가능하면 메시지 큐에서 작업을 실행할 거예요. RabbitMQ는 celery의 기본 메시지 브로커인데, Redis, Amazon SQS, Apache Kafka와 같은 다른 솔루션이 있어요. 저는 이를 가장 간단하게 하고자 RabbitMQ를 사용했어요. 이 애니메이션 동영상에서 이 작업이 어떻게 이루어지는지 설명합니다.

# 구현



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

먼저 RabbitMQ를 설정해 봅시다. 프로젝트를 개발하는 환경은 Windows를 사용하고 있어요. RabbitMQ를 설정하기 위해서 Docker 이미지를 사용하고 있어요. 원하신다면 Docker 대신에 RabbitMQ를 설치할 수도 있어요.

```js
docker run -p 15672:15672 -p 5672:5672 rabbitmq:3-management
```

Docker 컨테이너가 시작되면, 브라우저를 통해 127.0.0.1:5672로 RabbitMQ 대시보드에 로그인할 수 있어요. 사용자 이름과 비밀번호는 모두 'guest'에요.

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

이제 Celery를 설치하고 설정해 봅시다. 다음 라이브러리를 설치하세요. 저는 python-dotenv 라이브러리를 사용하여 .env 파일에서 보안 정보를 관리합니다.

```js
pip install celery python-dotenv
```

내 FastAPI 프로젝트는 이와 유사한 폴더 구조를 가지고 있어요.

```js
app/
├── config/
│   ├── __init__.py
│   └── celery_config.py
├── tasks/
│   ├── __init__.py
│   └── celery_tasks.py
├── __init__.py
├── main.py
├── .env
└── requirements.txt
```



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

먼저, .env 파일에서 환경 변수를 만들어봅시다. Celery에는 두 가지가 필요합니다. 첫 번째는 메시지 브로커 URL입니다. 제 경우에는 RabbitMQ 서버 URL입니다. (`USERNAME`, `PASSWORD`를 교체하여 사용자명과 비밀번호를 입력해주세요. 기본값은 guest입니다.) 두 번째는 결과 백엔드입니다. Celery가 작업 실행 결과를 저장하는 곳으로, 작업을 완료한 후에 이 결과를 검색할 수 있습니다.

```js
CELERY_BROKER_URL=amqp://<USERNAME>:<PASSWORD>@localhost:5672//
CELERY_RESULT_BACKEND=rpc://
```

좋아요. 이제 Celery 앱을 생성하고 구성해봅시다. 이를 위해 celery_config.py 파일을 만들겠습니다.

```js
# celery_config.py
# 별도의 파일에서 celery 작업을 정의하기 위한 구성.
import os
from celery import Celery
from dotenv import load_dotenv

load_dotenv() # 환경 변수를 불러오기 위한 코드

celery_app = Celery(__name__, broker=os.getenv("CELERY_BROKER_URL"), backend=os.getenv("CELERY_RESULT_BACKEND"))

celery_app.conf.update(
    imports=['app.tasks.celery_tasks'], # celery 작업 파일 경로
    broker_connection_retry_on_startup=True,
    task_track_started=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>

분리된 파일을 만들어 Celery 작업을 정의했어요. 하지만 그건 꼭 필요하지 않아요. 이 파일 안에 작업들을 정의할 수 있어요. 만약 이 파일 안에 작업을 정의한다면, imports=['app.tasks.celery_tasks'] 라인을 추가할 필요가 없어요. 따라서, 당신의 구성은 이런 식이에요.

```js
# celery_config.py
# 이 파일 안에 Celery 작업을 정의하기 위한 구성.
import os
from celery import Celery
from dotenv import load_dotenv

load_dotenv() # 환경 변수 로드

celery_app = Celery(__name__, broker=os.getenv("CELERY_BROKER_URL"), backend=os.getenv("CELERY_RESULT_BACKEND"))

celery_app.conf.update(
    broker_connection_retry_on_startup=True,
    task_track_started=True
)
```

이제 Celery 작업을 만들어봐요. celery_tasks.py 파일을 만들고 그 안에 작업들을 정의했어요. Celery 작업을 정의하기 위해 데코레이터를 사용해요.

```js
# celery_tasks.py
import asyncio
from app.config.celery_config import celery_app


@celery_app.task
def my_task(x, y):
    ans = x + y
    print(ans)
    return ans


async def my_async_task(x, y):
    await asyncio.sleep(3)
    ans = x + y
    print(ans)
    return ans


@celery_app.task
def my_second_task(x, y):
    result = asyncio.run(my_async_task(x, y))
    return result
```



<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
# celery_config.py
# 이 파일 안에서 Celery 작업을 정의하는 설정입니다.
import os
import asyncio
from celery import Celery
from dotenv import load_dotenv

load_dotenv() # 환경 변수를 불러오기

celery_app = Celery(__name__, broker=os.getenv("CELERY_BROKER_URL"), backend=os.getenv("CELERY_RESULT_BACKEND"))

celery_app.conf.update(
    broker_connection_retry_on_startup=True,
    task_track_started=True
)

@celery_app.task
def my_task(x, y):
   ans = x + y
   print(ans)
   return ans

async def my_async_task(x, y):
   await asyncio.sleep(3)
   ans = x + y
   print(ans)
   return ans

@celery_app.task
def my_second_task(x, y):
   result = asyncio.run(my_async_task(x, y))
   return result
```

이제 라우트 핸들러에서 이러한 작업을 사용할 수 있어요. 아래는 예시 라우트 핸들러입니다. 여기서 GET 엔드포인트를 만들었어요. 이 엔드포인트 핸들러 내부에서 Celery 작업을 사용해요.

```python
from fastapi import FastAPI

from app.tasks.celery_tasks import my_task

app = FastAPI()

@app.get("/run")
def handle_run():
   task_response = my_task.delay(5, 6)
   return {"message": "작업 실행이 시작됐어요!"}

if __name__ == '__main__':
    uvicorn.run(app, port=8080)
```



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

알겠어요. 코딩 부분은 끝났습니다. 이제 세럴리 워커를 실행해봅시다. 이 세럴리 워커는 RabbitMQ의 메시지 대기열에 있는 작업을 실행할 것입니다. 만약 RabbitMQ 서버를 시작하지 않았다면, 세럴리 워커를 시작하기 전에 RabbitMQ를 시작해주세요.

```js
celery --app app.config.celery_config.celery_app worker --loglevel=info --pool=solo
```

만약 세럴리가 어떠한 오류 없이 실행된다면, 터미널에서 다음과 유사한 출력을 확인할 수 있습니다.

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

위 이미지에서 [작업] 섹션 아래에서 celery_tasks.py 파일에 정의한 celery 작업을 볼 수 있습니다. 작업 대기열이 새 작업을 받으면 celery가 해당 작업을 실행합니다. 이제 FastAPI 서버를 실행해 봅시다.

```js
uvicorn app.main:app --port 8000
```

Swagger 문서 페이지에서 엔드포인트를 시도해 봅시다. 엔드포인트에 요청을 보낸 후 celery 터미널을 확인하면 다음과 같은 출력을 볼 수 있습니다.

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

작업을 받았고, 작업을 실행하기 시작했습니다. 그리고 실행이 완료된 후에는 작업이 성공했다고 합니다. 이는 우리의 작업이 FastAPI 서버에 의해 실행되는 것이 아닌 celery 워커에 의해 실행된다는 것을 의미합니다.

## 작업 모니터링

Celery 작업과 워커를 모니터링하기 위해 Flower를 사용할 수 있습니다. Flower를 설치해보겠습니다.

```js
pip install flower
```



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

로컬 머신에서 flower를 실행하세요.

```js
celery flower --app app.config.celery_config.celery_app --broker:amqp://localhost//
```

웹 브라우저에서 flower 모니터링 도구를 확인할 수 있습니다. http://localhost:5555/ 으로 이동하세요.

![Flower Monitoring Tool](/TIL/assets/img/2024-07-09-UsingCeleryRabbitMQWithFastAPI_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>

요즘 FastAPI 프로젝트에서 Celery + RabbitMQ를 사용하는 방법을 소개했어. 여기서 어떤 일이 벌어지는지 이해할 수 있을 거야. 이건 이 작업을 수행하는 가장 간단한 방법이야. 나는 기본 작업 대기열을 사용했어. 원한다면 더 많은 작업 대기열을 생성할 수도 있어. 그리고 더 많은 구성 가능한 사항들도 있어. 그들의 설명서를 확인해봐. 작업 완료 상태를 클라이언트에게 알리기 위해 WebSocket을 사용할 수도 있어. 이게 전부야. 다음 블로그에서 만나자. 즐거운 코딩이 되길!

# Stackademic 🎓

끝까지 읽어주셔서 감사해요. 떠나시기 전에 이런 점 유의해주세요:

- 박수를 치고 작가를 팔로우해주시면 감사하겠어요! 👏
- 저희를 팔로우해주세요 X | LinkedIn | YouTube | Discord
- 다른 플랫폼도 방문해보세요: In Plain English | CoFeed | Differ
- Stackademic.com에서 더 많은 콘텐츠를 만나보세요

Posts