제멋대로맛 초코볼

Spring Boot openai starter로 ChatGPT 쉽게 사용하기

Ambosing — Mon, 11 Mar 2024 15:00:00 GMT

글을 쓰게 된 동기

스프링으로 ChatGPT API를 사용해서 기능을 사용해야 하는 경우가 생겼습니다..! 그래서 RestTemplate과 WebClient 중 비동기를 사용할 수 있고 Non-Blocking을 지원하는 WebClient로 구현하려고 시도했습니다. 하지만 어떠한 이유 때문인지 WebClient Header에 Api 키를 넣었음에도 불구하고 계속 응답을 BadRequest로 받았습니다.

그러던 와중에 Spring에서 제공해주는 spring.ai.openai 의존성이 있다는 것을 알게 되었고, 하루 꼬박 걸렸던.. 제 오류는 금방 해결할 수 있어서 다른 분들도 쉽게 할 수 있으면 좋겠다라고 생각해서 이렇게 블로그 글을 남깁니다!

Spring AI로 ChatGPT 환경설정

Dependancy 설정하기

pom.xml

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>0.8.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Gradle

dependencies {
  implementation platform("org.springframework.ai:spring-ai-bom:0.8.0")
  implementation 'org.springframework.ai:spring-ai-openai'
}

스프링 공식 홈페이지에서는 Gradle에서는 특정한 버전을 써주지 않아도 문제 없다고 하는데 제가 시도했을 때는 위와 같이 버전을 지정해주니 잘 동작했습니다!
제 환경만 그럴 수도 있으니 한 번 빼고 동작해보시는 것도 추천합니다. (버전은 최신 버전 추천!)

Spring Boot AI ChatGPT Chat 실행해보기

Chat Properties 설정하기

spring:
  ai:
    openai:
      base-url: base-url # 기본 값 : api.openai.com
      api-key: api-key 입력 # 필수 
      chat:
        options:
          model: gpt-4 # 모델 입력 # 필수
          # 아래는 세부 GPT 모델 설정 값
          temperature: 
          frequencyPenalty: 
          presencePenalty: 
          maxTokens: 
          topP:

위에 사용하지 않은 Properties들이 존재하니 아래 링크를 참조하면 좋을 것 같습니다.

스프링 AI Propreties

Spring Boot AI 사용하기

아래는 공식문서에서 사용하는 예제입니다. 아주 간단하게 사용할 수 있게 지원해주는 것 같습니다.

@RestController
public class ChatController {

    private final OpenAiChatClient chatClient;

    @Autowired
    public ChatController(OpenAiChatClient chatClient) {
        this.chatClient = chatClient;
    }

    @GetMapping("/ai/generate")
    public Map generate(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        return Map.of("generation", chatClient.call(message));
    }

    // Stream 형식으로 보내주기
    @GetMapping("/ai/generateStream")
	public Flux<ChatResponse> generateStream(@RequestParam(value = "message", defaultValue = "Tell me a joke") String message) {
        Prompt prompt = new Prompt(new UserMessage(message));
        return chatClient.stream(prompt);
    }
}

위의 방법 말고도 아래와 같이 ChatClient를 직접 만들어 사용하는 것도 가능합니다.

var openAiApi = new OpenAiApi(System.getenv("OPENAI_API_KEY"));

// Properties에 적었던 설정 값들을 직접 명시하여 생성
var chatClient = new OpenAiChatClient(openAiApi)
    .withDefaultOptions(OpenAiChatOptions.builder()
            .withModel("gpt-35-turbo")
            .withTemperature(0.4)
            .withMaxTokens(200)
        .build());

ChatResponse response = chatClient.call(
    new Prompt("Generate the names of 5 famous pirates."));

// Stream 응답으로 보내기
Flux<ChatResponse> response = chatClient.stream(
    new Prompt("Generate the names of 5 famous pirates."));

소감

이렇게 Spring Boot에서 제공해주는 AI 의존성에 대해서 알아보았습니다.
생각보다 저는 삽질을 많이 했는데 모든 정보를 공식문서부터 찾아보는 습관이 아직은 되어 있지 않은 것 같아서 이번에 반성을 하게 되었습니다.
앞으로는 공식문서 위주로 찾아본 뒤에 추가적인 정보들을 다른 채널을 통해서 찾아보는 방식으로 변경할 것 같습니다.

참고

스프링 AI Docs

Java 멀티 스레딩 환경에서 Data Race

Ambosing — Wed, 08 Nov 2023 15:00:00 GMT

오늘은 강의를 듣고 있다가 Data Race라는 용어를 처음들어봐서 이렇게 정리하게 되었습니다.
멀티스레딩 환경에서 발생하는 문제입니다.
일단 이 글에서는 JAVA 기준으로 설명되어 있습니다. :)

멀티스레딩 환경에서의 공유자원

Data Race를 이해하기 위해서는 먼저 멀티스레딩 환경에서 어떤 부분을 공유하고 있는지를 알고 있어야 합니다.
일단 메모리에 있는 Heap영역에 할당된 자원들은 모두 멀티스레딩 환경에서 공유됩니다.

객체들
Class 멤버 변수
Static 변수

위와 같은 요소들이 공유자원이 됩니다.

비순차적 명령어 처리

비순차적 명령어 처리가 Data Race에 원인이 되므로 이것도 먼저 알아봅시다.

먼저 비순차적 명령어 처리는 명령어 파이프라인에서 발생하므로 명령어 파이프라인부터 알아봅시다.

CPU는 병렬적으로 명령어를 실행하는 명령어 파이프라인을 사용합니다. 명령어 파이프라인을 사용하지 않았을 때 아래와 같이 실행시간이 매우 길어지기 때문입니다.

[혼공운체] 명령어 파이프라인 사용 X

명령어 파이프라인을 사용하면 아래와 같이 빠르게 실행할 수 있게 됩니다.

[혼공운체] 명령어 파이프라인 사용 O

비순차적 명령어 처리는 명령어 파이프라인에서 사용되는 명령어 병렬처리 기법입니다. 먼저 예시를 보며 이해를 돕겠습니다.

예를들어 아래와 같은 명령어들로 이루어진 소스 코드가 있다고 해봅시다.

위는 명령어 처리할 때 3번의 명령어가 1번, 2번 명령어에 의존하고 있기 때문에 3번 명령어를 처리하기 위해 나머지 4, 5, 6 명령어들이 기다리고 있게 됩니다.

그래서 CPU는 효율적으로 처리하기 위해 아래와 같이 명령어의 순서를 바꿉니다.

이렇게 되면 4, 5, 6 명령어는 기다리지 않고, 바로 실행할 수 있게 됩니다.

아무 명령어나 순서를 바꾸지는 않고, 코드의 의존성으로 문제가 되지 않을 때만 변경합니다.

Data Race

Data Race란 여러 프로세스/스레드가 공유된 데이터를 읽고 쓰는 작업을 할 때 실행 순서에 따라서 잘못된 값을 읽거나 쓰게 되는 상황입니다.

Data Race가 발생하는 상황

말로만 들으면 이해가 잘 되지 않으니 코드 예시를 보면서 Data Race가 발생하는 상황을 봅시다.

public static class SharedClass {
        private int x = 0; // 공유 자원
        private int y = 0; // 공유 자원

        // Thread1
        public void increment() {
            x++;
            y++;
        }

        // Thread2
        public void checkForDataRace() {
            if (y > x) {
                System.out.println("y > x - 데이터 레이스가 감지됨!!");
            }
        }
    }

클래스 멤버 변수는 공유 자원으로 여기서 x, y는 공유 자원이 됩니다. 그리고 increment 메서드와 checkForDataRace 메서드는 각각의 스레드로 병렬적으로 실행하게 만들겁니다.

여기서 이제 메서드들을 한 번 살펴보면 여러 경우로 결과가 나눠지는 경우가 있습니다.

순차적으로 실행되면 당연히 Y > X보다 큰 경우는 없고, X == Y라는 결과만 갖게 됩니다.

다른 경우가 또 있습니다. 예를 들어, increment를 실행하는 도중에 checkForDataRace 메서드의 조건문이 실행되는 것이죠. 멀티스레딩 환경이기 때문에 병렬적으로 실행이 이루어져 이런 상황도 있습니다.

이 경우에는 X만 1증가한 상태라서 Y < X가 된 상태인거죠.
그래서 checkForDataRace 메서드의 Y > X는 만족하지 않습니다.

그러면 어떠한 경우에도 Y > X는 만족하지 않아서 절대 System.out.println("y > x - 데이터 레이스가 감지됨!!");는 실행되어야 하지 않습니다.

그러면 한 번 실행을 시켜보겠습니다.

public class DataRaceProblem {
    public static void main(String[] args) {
        SharedClass sharedClass = new SharedClass();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                sharedClass.increment();
            }
        } ); // increment Thread

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                sharedClass.checkForDataRace();
            }
        } ); // checkForDataRace Thread

        thread1.start();
        thread2.start();
    }

    public static class SharedClass {
        private int x = 0;
        private int y = 0;

        public void increment() {
            x++;
            y++;
        }

        public void checkForDataRace() {
            if (y > x) {
                System.out.println("y > x - 데이터 레이스가 감지됨!!");
            }
        }
    }
}

y > x - 데이터 레이스가 감지됨!!
y > x - 데이터 레이스가 감지됨!!

실행할 때마다 결과는 달라지긴 하지만 결과를 보면 Y > X를 만족하는 경우가 있다는 것입니다.

어떻게 이런 결과가 나올 수 있을까요?
그 이유는 바로 비순차적 명령어 처리때문입니다.
increment메서드의 내용을 한 번 다시 봅시다.

public void increment() {
    x++;
    y++;
}

increment메서드의 안에 x++, y++은 서로 의존적이지 않습니다. 그래서 컴파일러 최적화 과정에서 비순차적 명령어 처리가 충분히 일어날 수 있는 부분입니다. 그래서 x++, y++ 순서대로 처리가 되는 것이 아닌 비순차적 처리 때문에 y++, x++로 처리가 되는 경우가 있어 Data Race가 발생하게 됩니다.

Data Race 해결 방법

Data Race의 해결 방법에는 두 가지가 있습니다.

메서드에 Synchroized 키워드 사용하기

한 번에 하나의 스레드만이 블록 또는 메서드에 진입할 수 있도록 보장합니다.
임계 영역에 진입하는 스레드는 다른 스레드가 해당 블록 또는 메서드에 접근하지 못하게 합니다.
락을 사용하여 동기화를 구현하므로 상대적으로 무겁고 오버헤드가 큽니다.
코드 블록이나 메서드 내에서 사용되며, 메서드에 적용할 경우 전체 메서드가 동기화됩니다.
```
  public synchronized void synchronizedMethod() {
// 동기화된 메서드 내용
}
```

변수에 Volatile 키워드 사용하기

변수를 메모리에서 읽거나 쓸 때 항상 메인 메모리를 참조하도록 보장합니다.
캐시된 값 사용을 방지하여 변수의 일관성을 제공합니다.
volatile 키워드를 사용한 변수는 원자적으로 읽기 및 쓰기 연산이 수행됩니다.
단순한 변수의 상태를 보장하며, 복합 연산에 대해서는 synchronized가 더 적합합니다.
비순차적 명령어 처리하는 경우,
volatile 변수에 대한 쓰기 명령 이전의 명령들은 reordering 이후에도 volatile 변수에 대한 쓰기 명령 이전에 실행되도록 유지됩니다.
volatile 변수에 대한 읽기 명령 이후의 명령들은 reordeing 이후에도 volatile 변수에 대한 읽기 명령 이후에 실행되도록 유지합니다.
-> 즉, 비순차적 명령어 처리가 발생하지 않는 것을 의미합니다.

volatile int sharedVal;
public void method() {
  .... // volatile 명령어 이전에 있는 명령어들은 volatile 명령어 접근 전에 실행되도록 보장
  read/write(sharedVal);
  ... // volatile 명령어 이후에 있는 명령어들은 volatile 명령어 접근 후에 실행되도록 보장
}

여기서는 두 개의 스레드로 한 메서드를 실행하는 Race Condition이 아니므로 두 메서드에 Synchronize 키워드로 동시 실행을 막지 않아도 됩니다. 그래서 Lock를 덜 잡는 Volatile를 사용해서 Data Race를 해결해보겠습니다.


  public static class SharedClass {
      private volatile int x = 0; // 변경된 부분
      private volatile int y = 0; // 변경된 부분

      public void increment() {
          x++;
          y++;
      }

      public void checkForDataRace() {
          if (y > x) {
              System.out.println("y > x - 데이터 레이스가 감지됨!!");
          }
      }
  }

이렇게 하면 y > x조건을 만족하지 못해System.out.println("y > x - 데이터 레이스가 감지됨!!");을 실행하지 않습니다.

정리

정리하자면, Data Race가 발생하는 이유는 CPU를 효율적으로 활용하기 위해 사용하고 있는 비순차적 명령어 처리가 이유입니다. 이러한 Data Race를 해결하기 위해서는 Synchronized, Volatile을 적용할 수 있습니다.

참고한 사이트
Volatile : 말랑님 블로그
Data Race : Udemy 강의
명령어 파이프라인 : 혼자 공부하는 컴퓨터 구조 및 운영체제

Lazy Evaluation 지연 계산법

Ambosing — Tue, 19 Sep 2023 15:00:00 GMT

들어가며

Lazy Evaluation은 예전에 조건문에서 두 개의 조건이 존재할 때 AND에서는 앞 조건이 False라고 하는 경우 뒤 조건을 안하는 경우를 Early Termination이라고 들은 적이 있었습니다. 그 때 비슷한 최적화의 형태로 Lazy Evaluation가 있다고 들었었는데요.
뭔가 다른 건가 싶기도 했었습니다. 한참 데이터 쪽으로 공부하고 있을 때 spark에 대해서 공부한 적이 있었는데요. spark는 Lazy Evaluation을 지원해서 좋다고 합니다. 아니 그래서 뭐가 좋은건지도 모르지 말고 이번에는 공부하면서 블로그에 정리하려고 합니다. ~~역시 공부는 호기심~~

참고:
Lazy Evaluation 정의
그림 동작 및 예제 : edykim님 블로그

Lazy Evaluation

컴퓨터 프로그래밍에서 느긋한 계산법(Lazy Evaluation)은 계산의 결과값이 필요할 때까지 계산을 늦추는 기법입니다. 반대말로는 Eager Evaluation(즉시 연산, 조급한 연산)이 존재합니다.

먼저 장단점을 알면 편하므로 장단점을 정리해보겠습니다.

장점

효율성: 필요한 값만 계산하므로 불필요한 연산을 피할 수 있습니다. 예를 들어, 무한한 리스트에서 처음 10개의 요소만 필요한 경우, lazy evaluation을 사용하면 실제로 10개의 요소만 계산됩니다.
모듈화와 조합성: 계산을 나중에 실행하게 되면, 프로그램의 여러 부분을 더 쉽게 조합하거나 재사용할 수 있습니다.
무한한 자료구조: Lazy evaluation을 사용하면 무한한 크기의 자료구조를 생성하고, 필요한 부분만 사용할 수 있습니다. 예를 들어, Haskell(프로그래밍 언어)에서 무한한 리스트를 정의하고 사용할 수 있습니다.
가능한 결과 생성: Lazy evaluation은 아직 계산되지 않은 결과를 표현할 수 있어, 연산의 가능한 결과를 모두 나열하고 나중에 특정 결과를 선택할 수 있습니다.

단점

예측하기 어려운 성능: 연산이 언제 실행될지 예측하기가 어렵기 때문에, 프로그램의 성능을 예측하거나 분석하기가 어려울 수 있습니다.
메모리 사용: 연산이 아직 실행되지 않았다는 것을 표시하기 위한 내부 데이터 구조가 추가적인 메모리를 사용할 수 있습니다. 이로 인해 메모리 사용이 증가할 수 있습니다.
디버깅 어려움: Lazy evaluation의 동작 방식 때문에, 오류를 디버깅하기가 어려울 수 있습니다. 오류의 원인이 되는 코드와 오류가 실제로 발생하는 시점 사이에 시간 차이가 있을 수 있기 때문입니다.
부작용: 부작용(side-effects)를 가진 연산과 lazy evaluation이 혼합될 때, 부작용의 발생 시점과 순서를 예측하기 어려울 수 있습니다.

이렇게 장단점을 알아봤습니다. 그런데 이 장점 중 왜 효율적일까, 무한한 자료구조는 어떻게 하는 걸까에 대해서 중점적으로 알아보겠습니다.

Lazy Evaluation은 어떻게 효율적으로 동작하는걸까

자바 예제부터 보겠습니다. 아래의 자바 코드는 정수의 List에서 10보다 작은 것 중 3개만 가져오는 코드입니다.

final List<Integer> list = Arrays.asList(4, 15, 20, 7, 3, 13, 2, 20);

System.out.println(
  list.stream()
    .filter(i -> {
        return i < 10;
    })
    .limit(3)
    .collect(Collectors.toList())
);

모르는 사람이 처음 위의 코드를 접했을 때 위 코드 동작 방식을

반복을 통해 Array에서 요소들 중 10보다 작은 값을 구하고
그 중 3개만 가져옵니다.

라고 생각할 수 있지만 그렇지 않습니다.
그렇지 동작하지 않는 이유를 알기 위해 출력해보겠습니다.

final List<Integer> list = Arrays.asList(4, 15, 20, 7, 3, 13, 2, 20);

System.out.println(
        list.stream()
                .filter(i -> {
                    System.out.println("i: " + i + " < 10");
                    return i < 10;
                })
                .limit(3)
                .collect(Collectors.toList())
);

i: 4 < 10
i: 15 < 10
i: 20 < 10
i: 7 < 10
i: 3 < 10
[4, 7, 3]

위는 출력해본 결과입니다! 이를 통해 조건에 맞는 것을 찾으면 종료한다는 것을 알 수 있습니다.
이 동작을 그림으로 표현한 것이 있어서 가져왔습니다.
출처는 맨 위에 있습니다.

위 코드를 그림으로 나타낸것입니다. 그림을 보면 출력 결과와 같이 동작한다는 것을 알 수 있습니다.
어찌보면 3개를 취했을 때 반복문이 종료되므로 더 효율적으로 종료될 수 있는 것입니다!

이를 메모리 관점에서는 동작이 다르겠지만 로직 처리쪽으로만 본다면 아래의 코드처럼 나타낼 수 있습니다.

final List<Integer> list = Arrays.asList(4, 15, 20, 7, 3, 13, 2, 20);
final List<Integer> newList = new ArrayList<>();

for (int i = 0; i < list.size(); i++) {
    System.out.println("list[i]: " + list.get(i) + " < 10");
    if (list.get(i) < 10) {
        newList.add(list.get(i));
        if (newList.size() == 3) break;
    }
}

System.out.println(newList);

출력결과

list[i]: 4 < 10
list[i]: 15 < 10
list[i]: 20 < 10
list[i]: 7 < 10
list[i]: 3 < 10
[4, 7, 3]

출력결과를 보면 동일한 것을 알 수 있습니다.
Lazy Evaluation을 통해 조건을 만족하면 반복문이 종료되는 것을 알 수 있습니다.
이를 통해 효율성을 챙기는 것입니다.

그럼 이번에는 메모리 관점으로 어떻게 무한한 자료구조를 쓸 수 있는지 보겠습니다.

Lazy Evaluation은 어떻게 무한한 자료구조를 만들 수 있을까?

아래는 파이썬의 제너레이터로 작성한 자료구조와 리스트 컴프리헨션으로 만든 리스트의 메모리를 비교한 것입니다.

import sys

# 제너레이터


def generate_numbers():
    for x in range(1000000):
        yield x


gen = generate_numbers()
print(sys.getsizeof(gen), "bytes")


numbers = [x for x in range(1000000)]
print(sys.getsizeof(numbers), "bytes")

출력 결과

112 bytes
8448728 bytes

출력결과를 보면 알 수 있듯이 Lazy Evaluation을 활용한 제너레이터는 리스트로 만든 결과와는 다르게 메모리 차이가 큽니다. 이는 Lazy Evaluation이 무한한 자료구조를 가질 수 있다는 단서가 됩니다!!

제너레이터의 동작을 보면, 제너레이터는 순차적으로 값이 필요할 때 생성하는 프로세스, 매커니즘에 가깝습니다. 그래서 다음 값이 필요할 때 값에 대한 연산을 하고 가져오기 때문에 메모리를 신경쓰지 않고 자료구조를 만들 수 있는 겁니다!

즉 정리하자면, 리스트로 만든 자료구조는 미리 100만개의 정수 자료형을 메모리에 올리는 것이고 제너레이터는 100만 개를 처리할 프로세스를 만들고 그걸 메모리에 올린 뒤 필요할 때 가져다 쓰는 방식이라고 이해하시면 됩니다.

Lazy Evaluation이 쓰이는 곳

Lazy evaluation은 다양한 컴퓨팅 분야에서 사용되며, 특히 다음과 같은 곳에서 사용됩니다!

함수형 프로그래밍 언어: Haskell(프로그래밍 언어)은 lazy evaluation을 기본 평가 전략으로 사용하는 가장 잘 알려진 함수형 프로그래밍 언어입니다. 여기서 lazy evaluation은 무한한 자료구조 생성, 고차원 함수 조합 등 다양한 표현력을 제공합니다.
스트림 처리: Java 8 이후의 Stream API나 Python의 generator와 같은 프로그래밍 언어의 특성에서 lazy evaluation이 사용됩니다. 이들은 필요할 때만 데이터를 처리하도록 설계되었습니다.
데이터베이스 시스템: 데이터베이스 쿼리의 최적화에서 lazy evaluation이 사용될 수 있습니다. 예를 들면, 특정 조건에 맞는 첫 번째 항목만 필요한 경우 전체 데이터셋을 스캔하지 않고, 조건을 만족하는 첫 번째 항목을 찾자마자 종료할 수 있습니다.
빅 데이터 처리: Apache Spark와 같은 빅 데이터 처리 프레임워크에서는 transformation 작업을 lazy하게 처리하고, 실제로 action이 호출될 때만 연산을 수행합니다. 이렇게 하면 연산의 최적화와 재사용이 가능합니다.
AI 및 기계 학습 프레임워크: Tensorflow나 PyTorch와 같은 딥러닝 프레임워크에서는 연산 그래프를 먼저 정의하고, 실제로 데이터가 흐를 때만 연산을 수행합니다. 이는 lazy evaluation의 일종으로 볼 수 있습니다.
웹 브라우저 렌더링: 웹 페이지의 컨텐츠 중 일부는 사용자가 스크롤하거나 특정 액션을 취할 때까지 로드되지 않을 수 있습니다. 이러한 “lazy loading”은 웹 페이지의 초기 로딩 시간을 단축하고 자원 사용을 최적화하는데 도움을 줍니다.

정리

이렇게 Lazy Evaluation을 알아보았는데요. 저도 이렇게 알아보면서 많이 알게되었습니다.
아무래도 대부분 프로그래밍하실 때는 Eager Evaluation을 생각하고 계실텐데요.
이렇게 Lazy Evaluation으로 동작하는 것인지, Eager Evaluation으로 동작할지 한 번씩은 고민해보는 게 좋을 것 같네요!

[Python] 파이썬 위치인자, 키워드인자

Ambosing — Mon, 11 Sep 2023 15:00:00 GMT

들어가기 전

파이썬에는 함수의 파라미터를 키워드로 받을 수 있는 키워드인자, 위치로 받을 수 있는 위치 인자가 있습니다.
이 두 개의 기능을 잘못 쓰게 되면 함수를 사용할 때 정말 헷갈리게 되는데요.
이 부분을 책이 잘 설명해놓고 있어서 제가 약간 각색하여 정리해보려고 합니다!

이번 글은 파이썬 코딩의 기술을 보고 참조하였습니다.
만약 문제 발생시 글을 삭제처리 하도록 하겠습니다!

예시 코드 소개

여기에 있는 글을 이해하시기 쉽게 먼저 예제코드를 소개하려고 합니다.

예제코드는 한 숫자를 다른 숫자로 나누는 코드입니다.
그래서 어떤 경우에는 ZeroDivisionError 예외를 무시하고 무한대를 반환하고 싶고, 어떨 때는 Overflow 예외를 무시하고 대신 0을 반환하고 싶다고 합시다!

def safe_division(number, divisor,
                  ignore_overflow,
                  ignore_zero_division):
    try:
        return number / divisor
    except OverflowError:
        if ignore_overflow:
            return 0
        else:
            raise
    except ZeroDivisionError:
        if ignore_zero_division:
            return float('inf')
        else:
            raise

ignore_overflow=true한 경우

result = safe_division(1.0, 10**500, True, False)
print(result) # 0

ignore_zero_division=true한 경우

result = safe_division(1.0, 0, False, True)
print(result) # inf

키워드 인자 사용할 때 주의점

저희가 평소 사용하는 인자는 위치인자인데요.
위치로 인자를 결정하다보면 함수를 사용할 때 어떤 값으로 들어가는지 함수의 정의를 봐야 알 수 있는 경우가 많습니다.
이를 보완하기 위해 나온 것이 키워드 인자인데요.
키워드 인자는 명시적으로 인자의 이름을 정해준다는 장점이 있으나, 함수를 사용하는 부분에서 키워드를 작성하다 보니 코드가 길어지는 단점이 존재합니다.
또한, 키워드 인자를 쓰면 주의할 사항이 있는데요. 바로 위치인자 뒤에 키워드 인자가 와야 한다는 것입니다. 바로 코드로 보시죠!!

result = safe_division(1.0, 10**500, ignore_overflow=True) # 1. 에러
result = safe_division(1.0, 10**500, ignore_overflow=True, False) # 2. 에러
result = safe_division(1.0, 10**500, True, ignore_zero_division=False) # 3. 정상
result = safe_division(1.0, 10**500, ignore_overflow=True, ignore_zero_division=False) # 4. 정상

함수는 기존 예시코드 함수를 사용했습니다!
첫 번째 문제 코드의 경우, 키워드 인자를 사용했지만 함수 정의에서 ignore_zero_division가 있는데 인자에서는 값을 정해주지 않아 오류가 발생했습니다. 이 경우 아래와 같이 함수의 기본값을 정해주면 에러가 발생하지 않습니다.

# ignore_zero_division에 기본값 False 적용
def safe_division(number, divisor,
                  ignore_overflow,
                  ignore_zero_division=False):

두 번째 문제 코드의 경우에는 위치 인자가 키워드 인자 뒤에 와서 오류가 발생합니다. 나머지 경우는 정상적으로 잘 동작합니다.

키워드 인자 잘 사용하기!

키워드 인자는 선택적인 사항이므로 호출하는 쪽에서 명확성을 위해 키워드 인자를 꼭 쓸 수 없는 것이 문제입니다!
복잡한 함수의 경우 호출자가 키워드만 사용하는 인자를 통해 의도를 명확히 밝히도록 요구하는 편이 좋습니다.
키워드만 사용하는 인자는 키워드를 반드시 사용해 지정하게 하여, 위치 기반으로 지정할 수 없게 만드는 게 좋습니다.

다음은 safe_division 함수가 키워드만 사용하는 인자만 받도록 만든 코드입니다.
인자 목록에 있는 *기호는 위치 인자의 마지막과 키워드만 사용하는 인자의 시작을 구분해줍니다.

# divisor 전까지 위치 인자 / ignore부터 키워드 인자
# 기본값을 통해 인자를 꼭 받지 않아도 수정
def safe_division(number, divisor, *,
                  ignore_overflow=False,
                  ignore_zero_division=False):

그리고 파라미터 중 마지막 두 개의 파라미터는 ignore 옵션을 기본값으로 False 정해주었습니다!

이제 이 함수를 호출하면 함수의 뒤에 두 개의 인자는 키워드 인자를 사용해야 합니다.
위치 인자를 사용하게 되면 아래처럼 에러가 발생합니다.

safe_division(1.0, 10**500, True, False)

# 출력결과 
# safe_division(1.0, 10**500, True, False)
# TypeError: safe_division() takes 2 positional arguments but 4 were given

result = safe_division(1.0, 0, ignore_zero_division=True) # 정상 동작

위치 인자로 고정하기!

이번에 수정한 safe_division 함수에도 문제가 있습니다.
호출하는 쪽에서 이 함수의 앞에 있는 두 필수 파라미터(number, divisor)를 호출하면서 위치와 키워드를 혼용할 수 있습니다.

assert safe_division(number=2, divisor=5) == 0.4
assert safe_division(divisor=5, number=2) == 0.4
assert safe_division(2, divisor=5) == 0.4

나중에 요구 사항이 바뀌거나 원하는 스타일이 바뀌어서 맨 앞의 두 인자 이름을 변경할 수도 있습니다.

# number -> numerator, divisor -> denominator 변경
def safe_division(numerator, denominator, *,    # 변경
                    ignore_overflow=False,
                    ignore_zero_division=False):

이렇게 단순한 파라미터 이름 변경만으로도 number와 divisor 인자를 키워드로 호출하는 기존 호출 코드가 에러가 발생합니다!

safe_division(number=2, divisor=5) # 에러 발생

## 출력 결과
    safe_division(number=2, divisor=5)
TypeError: safe_division() got an unexpected keyword argument 'number'

파이썬 3.8에는 위치로만 지정하는 인자가 존재합니다.
위치로만 지정하는 인자는 반드시 위치만 사용해 인자를 지정해야 하고 키워드 인자로는 쓸 수 없습니다.

다음은 safe_division 함수를 처음 두 인자를 위치로만 지정하는 인자로 지정합니다.
인자 목록의 / 기호는 위치로만 지정하는 인자의 끝을 표시합니다.

def safe_division(numerator, denominator, /, *, # 변경
                    ignore_overflow=False,
                    ignore_zero_division=False):

위치로만 지정하는 인자를 키워드를 사용해 지정하면 에러가 발생합니다.

safe_division(2, 5) # 1. 정상 동작
safe_division(numerator=2, denominator=5) # 2. 에러 발생

## 출력 결과
safe_division(numerator=2, denominator=5) # 2. 에러 발생
TypeError: safe_division() got some positional-only arguments passed as keyword arguments: 'numerator, denominator'

만드는 API의 스타일이나 필요에 따라 두 인자 전달 방식을 모두 사용하면 가독성을 높이고 잡음도 줄일 수 있습니다.
예를 들어, 다음 코드에서는 결과를 표시할 때 얼마나 많은 자릿수를 사용할지 결정하고자 반올림할 위치를 지정하는 인자를 safe_division에 추가할 수 있습니다.

def safe_division_e(numerator, denominator, /,
                    ndigits=10, *,                 # 변경
                    ignore_overflow=False,
                    ignore_zero_division=False):
    try:
        fraction = numerator / denominator         # 변경
        return round(fraction, ndigits)            # 변경
    except OverflowError:
        if ignore_overflow:
            return 0
        else:
            raise
    except ZeroDivisionError:
        if ignore_zero_division:
            return float('inf')
        else:
            raise

위 함수에서 ndigits는 위치나 키워드를 사용해 전달할 수 있는 선택적인 파라미터이므로 어떤 방식으로든 함수 호출에 사용할 수 있습니다!

result = safe_division_e(22, 7)
print(result)

result = safe_division_e(22, 7, 5)
print(result)

result = safe_division_e(22, 7, ndigits=2)
print(result)

정리

키워드로만 지정해야 하는 * 인자를 사용하면 호출하는 쪽에서 특정 인자를 반드시 키워드를 사용해 호출하도록 강제할 수 있습니다.
위치로만 지정해야 하는 / 인자를 사용하면 호출하는 쪽에서 키워드를 사용해 인자를 지정하지 못하게 만들 수 있습니다.
인자 목록에서 /와 * 사이에 있는 파라미터는 키워드를 사용해 전달해도 되고 위치를 기반으로 전달해도 됩니다.

Docker compose로 띄운 Kafka Log를 docker bindmount 사용해서 로컬에서 보기

Ambosing — Wed, 30 Aug 2023 15:00:00 GMT

하게 된 이유

카프카를 배워보려고 강의를 듣다가 VirtualBox와 Ubuntu로 설치하는 것이 힘들어보여서 Docker로 설치하였습니다.

그러다 보니 강의 개발 환경과 많이 달라졌었는데요. 강의에서 Kafka Log를 보는 일도 있다고 해서 이 때마다 로그를 확인하러 가기가 너무 시간이 오래 걸릴 것 같아서 로그를 docker bindmount을 사용해 로컬에서 바로 볼 수 있도록 해보겠습니다.

해결 과정

먼저 로컬에 logs라는 디렉터리를 먼저 만들어줬습니다.

mkdir logs

이제 이 디렉토리를 도커 안에 있는 kafka log가 쌓이는 폴더와 연결해주겠습니다.

그러려면 일단 confluentinc/cp-kafka 이 이미지 안에 어디에 로그가 쌓이는지 알아야 하는데요.

구글링 후에 /var/lib/kafka/data 여기에 쌓인다는 걸 알게 되었습니다. 그럼 이제 docker compose 파일을 수정해주도록 하겠습니다!

version: '2'

services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_SERVER_ID: 1
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
      ZOOKEEPER_INIT_LIMIT: 5
      ZOOKEEPER_SYNC_LIMIT: 2
    ports:
      - "22181:2181"

  kafka:
    image: confluentinc/cp-kafka:7.1.2
    depends_on:
      - zookeeper
    ports:
      - "29092:29092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
    # 이부분 추가
		volumes:
      - ./logs:/var/lib/kafka/data

이렇게 도커 컴포즈를 띄워보면..

아래와 같은 에러가 발생합니다..!
Command [/usr/local/bin/dub path /var/lib/kafka/data writable] FAILED ! in Kafka

해결 방법을 모색한 결과, root 권한을 넣어주면 잘 된다는 얘기가 있어서

아래와 같이 Root 권한을 추가해주었습니다.

Root 권한을 추가한 docker compose 파일

version: '2'

services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_SERVER_ID: 1
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
      ZOOKEEPER_INIT_LIMIT: 5
      ZOOKEEPER_SYNC_LIMIT: 2
    ports:
      - "22181:2181"

  kafka:
    image: confluentinc/cp-kafka:7.1.2
		# Root 권한 
    user: root
    depends_on:
      - zookeeper
    ports:
      - "29092:29092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
    # Docker bindmount
		volumes:
      - ./logs:/var/lib/kafka/data

이제 잘 되더군요!
docker compose up을 통해 이제 도커 컨테이너를 띄우고 logs 디렉터리를 확인해보겠습니다.

잘 들어가 있습니다!!

배운 점

docker compose에 root 권한을 줄 수 있습니다.
docker compose에 docker bindmount을 추가하는 방법을 깨달았습니다.

파이썬에서 타임존 트러블 슈팅

Ambosing — Fri, 25 Aug 2023 15:00:00 GMT

들어가기 전

회사에서 Timezone을 UTC를 KST로 조작할 일이 있었습니다!
그래서 간단하게 해결할 방법으로 timezone을 KST로 조작해주었습니다.
하지만 예상하는 날짜 값이 도출된 것이 아니라 예상 날짜 값보다 하루가 전 날이 나왔습니다.

왜 예상대로 안됐을까

먼저 일단 예제로 제가 구성한 코드를 보시는 게 이해가 더 빠르실 거라 먼저 코드를 보여드리겠습니다.

from datetime import datetime, timedelta
from dateutil import tz

local_tz = tz.gettz('Asia/Seoul')

a = datetime(2023, 7, 23, 15, 00, 00)
print(a)
b = a.astimezone(local_tz)
print(b)
b -= timedelta(days=1)
print(b.strftime('%Y-%m-%d'))

2023-07-23 15:00:00
2023-07-23 15:00:00+09:00
2023-07-22

저는 일단 처음 15시로 되어 있던 시간을 KST(+9시간)을 함으로써 다음 날이 되게 하려고 했습니다.
하지만 1번과 같이 보시다시피 2023-07-23 15:00:00+09:00 이런 결과가 나왔습니다.
그래서 2번에서 날짜를 하나 빼서 날짜만 String 값으로 변경해보니 예상했던 결과인 2023-07-23이 아닌 2023-07-22가 나왔습니다.

해결 방법

local_tz = tz.gettz('Asia/Seoul')

a = datetime(2023, 7, 23, 15, 00, 00)
print(a) # 1
a = a.replace(tzinfo=tz.UTC) # <- 해결 방법
print(a) # 2
b = a.astimezone(local_tz)
print(b) # 3
b -= timedelta(days=1)
print(b.strftime('%Y-%m-%d')) # 4

2023-07-23 15:00:00 # 1
2023-07-23 15:00:00+00:00 # 2
2023-07-24 00:00:00+09:00 # 3
2023-07-23 # 4

처음에 Datetime을 초기화해주고 a = a.replace(tzinfo=tz.UTC)를 통해 타임존을 replace해주니 위 출력결과 처럼 #1에서 #2처럼 변했습니다.
이 상태에서 KST로 timezone을 변경해주고 하루를 빼주니 원하는 결과가 나왔습니다.

결론

사실 이런 사소한 오류들이 원하는 로직처럼 흘러가지 않는 경우가 있습니다.
특히나 날짜를 가지고 데이터 조작을 하거나 데이터 쿼리 조건을 날린다던지 그랬을 때 쿼리는 또 정상적으로 작동은 합니다만 집계하는 데이터와 전체 데이터의 날짜 범위가 맞지 않는 경우가 발생합니다..!
이런 에러들은 테스트 코드를 통해 잡지 않는 이상 어렵다고 생각합니다. 하지만 이제 일이라는게 언제나 테스트 코드를 짤 수는 없을 수도 있으므로..!

이번에 파이썬에서 처음에 알게 되어 다른 분들에게 제 글이 도움이 되었으면 합니다!

Airflow Backfill 트러블 슈팅

Ambosing — Sat, 05 Aug 2023 15:00:00 GMT

문제 상황

기존 원본 데이터는 크롤링을 통해서 수집하고 있는 상황이었는데 Airflow를 이용한 배치 시스템 자체를 이후에 적용했습니다.
그래서 Airflow에 있는 Backfill 기능을 사용해 기존 원본 데이터를 채웠습니다만..!
데이터가 원하는대로 들어가지 않았습니다..
예시로 들면, 2023-07-23 데이터와 2023-07-24 데이터의 차이가 원래 1000이라고 한다면 막상 2023-07-24 변화량 값의 데이터는 모두 다 기본값인 0으로 들어가 있었던 거죠.

물론 이렇게 구현하지 않았을 수도 있었겠지만.. 저는 하루의 데이터 집계의 저장과 변화량 데이터를 한 번에 구현했었습니다.
만약 하루 집계 데이터와 변화량 데이터를 분리한다면 집계한 데이터를 먼저 Backfill을 실행하고, 변화량 데이터를 나중에 Backfill을 실행했다면 문제가 발생하지 않았을 겁니다만!
위와 같이 실행한다고 하더라도 집계한 데이터의 Backfill을 먼저 실행하고 그 다음 변화량 데이터를 Backfill해야 하는 순서상의 의존은 변하지 않기 때문에 이대로 따로 분리하지는 않았습니다.

단순화한 현재 Airflow의 taskflow

원인 파악하기

이유는 요구사항이 전날 데이터를 기준으로 데이터 차이의 결과를 구해야 했는데 이 때 오늘 데이터는 하루 전날 데이터를 의존하게 됩니다.
저는 병렬로 실행하는 CeleryExecutor를 사용하고 있었고, Backfill의 실행 순서는 랜덤으로 실행이 됩니다.
하지만 이 사실을 모른 저는 Backfill을 진행했고, 위와 같은 문제 상황에 마주한 것입니다.

Backfill했을 때 시간 순서상이 아닌 랜덤

위와 같이 진행이 된다면 2023-07-24에 Dag를 실행할 때 어제 집계데이터가 없으므로 변화량 데이터를 정확하게 나오지 않게 됩니다.

이제 원인을 알았으니!! 해결을 해보러 갑시다!

해결하기!

Backfill은 실행순서가 랜덤으로 실행되므로 날짜 순으로 실행하게 만든다면 문제가 해결될 것입니다.
그래서 Backfill을 순서대로 실행시키게 만들겠습니다.
DAG의 default_args를 depends_on_past = True로 만든다면 Backfill은 순서대로 실행하게 됩니다.

with DAG(
    dag_id = 'backfill_chronologically',
    start_date = datetime(2023,8,6), 
    ...
    default_args = {
        'depends_on_past': True,
    }

이렇게 DAG를 수정하고 실행하니 문제가 없이 동작하였습니다!!

혹시나 다른 좋은 방법이 있다면 댓글로 알려주시면 감사하겠습니다!

Airflow Execution Date 트러블 슈팅

Ambosing — Sat, 05 Aug 2023 15:00:00 GMT

문제 상황

회사에서 배치 프로세스 작업으로 일단위 데이터 집계를 하기 위해 Airflow를 사용하고 있습니다. 저는 Execution Date를 당연하게 배치 프로세스의 작업 시간이라고 생각하고 스케줄링을 했었습니다..!
그렇지만 무슨일인지 원하는 대로 동작이 되지 않고, 오늘이 만약 8월 6일이면 전날 데이터인 8월 5일 데이터를 집계할 줄 알았지만 8월 4일의 데이터를 집계하고 있었습니다.

왜 이런 문제가 발생할까?

바로 Execution Date를 제가 잘못 알고 있었기 때문입니다.
Execution Date는 제가 생각한대로 실행하고 있지 않았습니다.
제가 착각한 부분은 실행 시각과 execution_date의 시간이 같은 줄 알고 프로그래밍을 했습니다..!

제가 생각했던 execution_date

8월 6일 00시에 실행하는 Execution Time은 print를 해보니 8월 5일 00시에 찍혀있었습니다.

실제 execution_date

Airflow에는 TimeWindow라는 처리해야할 데이터의 기간인 개념이 있습니다.
예를 들어, 8월 5일날 이커머스의 일일 매출을 집계하는 배치 작업이 있다고 합시다.
일일 매출을 계산하려면 4일이 끝나고 8월 5일 자정에 08/04 00:00:00 ~ 08/04 23:59:59까지의 발생한 매출을 계산해야 합니다!
여기서 작업 대상이 되는 데이터는 8월 4일의 데이터(=execution_date)가 되고, 실제 작업이 실행되는 시간은 8월 5일 0시가 됩니다.

즉, execution_date는 해당 Task가 처리해야 할 데이터 기간의 시작 시점인 8월 4일을 의미합니다.
execution_date라는 이름을 직역하면 실행 날짜가 되기 때문에 그 의미와 실제 의미가 달라서 혼란이 유발 됐었습니다..

어떻게 해결해야 할까?

1. execution_date 이해에 따라 수정

이건 해결방법 중 가장 쉬운 방법이지만 저만 오해가 풀린 걸 수도 있으므로 언젠가 코드를 유지보수할 다른 분들께서 또 오해의 소지가 있기 때문에 이 방법 스킵하도록 하겠습니다.

2. execution_date를 대체하기

execution_date를 대체하는 것이 좋은 방법이라고 생각됩니다.
confluence의 AIP39에 보면 execution_date가 너무 오해에 소지가 있으니 새로운 이름을 명칭하는 내용이 있습니다.

새로운 명칭이름

이 위에 표에는 없지만 execution_date와 같은 날짜를 가리키는 logical_date도 존재합니다.

다양한 Date

위와 같이 이외에도 airflow에 정해진 date들이 있습니다.

// pendulum.DateTime 형식
date_time_start = {{data_interval_start}}

execution_date 대신 logical_date나 data_interval_start로 변경하여 코드를 수정하는 이 방법이 조금 더 좋아보여 이렇게 수정하였습니다.

깨달은 점

새로운 기술을 도입할 때 실보다 바늘이 많다고 생각하여 도입을 했지만, 오해할 만한 여지를 계속 내버려두고 데이터 체크를 하지 않았다면 장기적인 에러로 발전했을 것 같습니다..
앞으로도 제 로직이 정확하다고 할지라도 테스트는 무조건 진행해야 한다고 생각합니다.
이번처럼 execution_date가 제가 생각한 방향과 다르게 동작할 수 있으므로.. ㅠㅠ

Amazon-linux2 Docker Compose Airflow 설치와 Git Action 배포 자동화

Ambosing — Mon, 31 Jul 2023 15:00:00 GMT

들어가기 전에

저는 회사에서 데이터를 배치하는 작업을 많이 했었습니다. 그 중에 처음으로 도전한 것은 바로 예전 학생 때 프로젝트했던 Linux Cron 배치 작업으로 배치 데이터를 프로세싱 중이었는데요.
이것보다 더 좋은 것이 없을까하는 생각이 매번 들긴 했었습니다. 그 당시에만 해도 모든 서버를 온프레미스로 돌리고 있는 상황이었습니다!
이렇게 하다보니 컴퓨터가 꺼지거나 배치 작업이 돌아가지 않을 때는 운영팀의 보고를 통해서만 받게 되었습니다.

온프레미스 당시 인프라

회사에서 AWS 사용해보기로 결정이 됐습니다. 기존에 있던 배치 시스템을 변경할 기회였습니다.
그래서 AWS에서 배치 작업을 더 좋게 처리하는 방법이 없을까하다가 Lambda + EventBridge로 처리하게 했었습니다.
이번엔 Severless 서비스인 Lambda를 사용하니깐 컴퓨터가 문제일 경우는 없었습니다만 만약 데이터의 정합성의 문제로 에러가 발생한다면 기존의 배치 작업을 다시 돌려야하는 문제가 생겼습니다.

AWS 당시 인프라

그러다가 데이터 엔지니어링에 대해 관심을 가지고 있었습니다. 그 중 Airflow라는 기술이 있었는데요. Airflow는 이전에 했던 배치 시스템의 단점들을 보완하고 있었습니다..!
그래서 이번 글에서는 Airflow를 설치하는 방법과 Git Action으로 AWS EC2에 배포하는 방법을 알아보겠습니다.
~~왜 AWS EC2냐고 하면 .. 제가 쓰고 있는 환경이라서..~~

참고한 글

Airflow 공식문서

Docker compose로 Airflow 설치하기

저는 Docker compose로 로컬(윈도우)에 설치를 해주었습니다. 로컬 설치과정은 쉽기 때문에 이번 설치 과정은 Amazon linux 환경에서 진행된다는 점을 알고계시면 좋을 것 같습니다. Docker compose로 설치를 진행하도록 하겠습니다!

Amazon linux2 환경에서 Docker 설치하기

Amazone-linux2에 도커를 설치합니다.
sudo는 언제나 필수입니다! (안그러면 권한 없다고 에러를 냅니다! ㅠㅠ)

sudo amazon-linux-extras install docker

그런 다음 도커를 시작합니다.

sudo service docker start

현재 사용자를 docker 그룹에 추가합니다. 이를 통해 sudo를 사용하지 않고도 Docker를 실행할 수 있습니다

sudo usermod -aG docker $USER

Amazon linux2에서 Docker Compose 설치

sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

실행 권한을 부여해줍니다

sudo chmod +x /usr/local/bin/docker-compose

도커 컴포즈가 잘 설치되었는지 확인해봅니다.

docker-compose --version

윈도우에서는 docker compose이었는데 리눅스에서는 docker-compose입니다!

Github Repository를 하나 생성

Github에 들어가 먼저 Repository를 하나 생성해줍니다.
저는 Airflow라고 먼저 해주었습니다!

그런 다음 amazon linux에 Git을 설치합니다.

아래 명령을 실행해 yum을 업데이트 합니다.

sudo yum update

명령어를 실행해 git을 설치합니다.

sudo yum install git

마지막으로 git이 잘 설치되었는지 확인합니다.

git version

이제 아까 만들었던 Git Repository를 Clone 받습니다.

git clone {{Git 주소}}

Amazon-linux2에 Docker-compose로 Airflow 설치하기

먼저 Airflow 폴더를 만들고 폴더에서 작업하겠습니다.
저는 GitRepository 이름이 airflow라고 가정하겠습니다.
curl 명령어를 통해 docker-compose.yaml 파일을 fetching해 주겠습니다.

mkdir airflow
cd airflow

curl -LfO 'https://airflow.apache.org/docs/apache-airflow/2.6.3/docker-compose.yaml'

이렇게 진행하면 현재 진행한 폴더에 yaml 파일이 생기실 겁니다!
docker-compose에 포함되어 있는 기능은 이렇습니다.

airflow-scheduler : 모든 DAG와 task들을 모니터링합니다. task들의 종속성들이 완료되면 task들을 트리거 시킵니다.
airflow-webserver : airflow를 UI로 볼수 있는 웹사이트입니다. 기본적으로 URL은 http://localhost:8080 입니다.
airflow-worker : 스케줄러가 부여한 작업을 실행하는 작업자입니다.
airflow-triggerer : Triggerer는 연기 가능한 작업에 대한 이벤트 루프를 실행합니다.
airflow-init : airflow 서비스를 초기화합니다.
postgres
redis

이외에도 flower는 있지만 이건 설명을 넘어가겠습니다!
또한, 몇 개의 디렉토리는 컨테이너에 마운트됩니다. 그래서 정해진 디렉토리는 컨테이너와 동기화됩니다.

./dags : DAG 파일을 여기에 놓으면 Airflow에서 인식합니다.
./logs : 스케줄러와 task 실행한 로그들이 담깁니다.
./config : 커스텀한 log parser를 추가할 수 있습니다. 그리고 airflow_local_settings.py를 추가하여 클러스터 정책을 구성할 수 있습니다.
./plugins : 커스텀한 plugin들을 여가에 추가할 수 있습니다.

그래서 위와 같은 디렉토리들은 필수적으로 구성되어야 합니다.
폴더들을 모두 만들어줍시다!

mkdir -p ./dags ./logs ./plugins ./config
echo -e "AIRFLOW_UID=$(id -u)" > .env

다른 OS에서는 이렇게 진행했을 때 경고가 나올 수도 있습니다.
그럴 때는 따로 .env 파일을 추가하여

AIRFLOW_UID=50000

이제 docker compose 명령어를 사용하여 airflow를 설치해봅시다.

# Linux, mac
docker-compose up airflow-init
# window
docker compose up airflow-init

docker compose가 초기화 되면 이런 메시지를 보실 수 있습니다.

airflow-init_1       | Upgrades done
airflow-init_1       | Admin user airflow created
airflow-init_1       | 2.6.3
start_airflow-init_1 exited with code 0

그리고 웹에 로그인할 계정이 만들어집니다.
id : airflow
pw : airflow

이제 모든 docker compose로 설치한 모든 서비스를 시작해봅시다.

# Linux, mac
docker-compose up 
# window
docker compose up

정상적으로 잘 동작했는지 docker ps 명령어를 통해 알아봅시다.

$ docker ps
CONTAINER ID   IMAGE                  COMMAND                  CREATED          STATUS                    PORTS                              NAMES
247ebe6cf87a   apache/airflow:2.6.3   "/usr/bin/dumb-init …"   3 minutes ago    Up 3 minutes (healthy)    8080/tcp                           compose_airflow-worker_1
ed9b09fc84b1   apache/airflow:2.6.3   "/usr/bin/dumb-init …"   3 minutes ago    Up 3 minutes (healthy)    8080/tcp                           compose_airflow-scheduler_1
7cb1fb603a98   apache/airflow:2.6.3   "/usr/bin/dumb-init …"   3 minutes ago    Up 3 minutes (healthy)    0.0.0.0:8080->8080/tcp             compose_airflow-webserver_1
74f3bbe506eb   postgres:13            "docker-entrypoint.s…"   18 minutes ago   Up 17 minutes (healthy)   5432/tcp                           compose_postgres_1
0bd6576d23cb   redis:latest           "docker-entrypoint.s…"   10 hours ago     Up 17 minutes (healthy)   0.0.0.0:6379->6379/tcp             compose_redis_1

status에 보면 정상적인 서비스들은 healthy라고 나오게 됩니다.
그런다음에 이제 http://localhost:8080 으로 들어가시게 되면 아래와 같이 로그인 창이 뜹니다.

그리고 로그인을 하고 나면 이러한 example DAGs가 존재합니다. 엄청나게 많은 example DAGs가 보이는데요. 만약 example DAGs가 필요없다면 제거해줄 수 있습니다.

docker-compose.yml 파일에서 AIRFLOW__CORE__LOAD_EXAMPLES가 true로 설정돼있는 것을 false로 변경하였습니다.
AIRFLOW__CORE__LOAD_EXAMPLES: 'false'

그러고 나면 DAGs 페이지에 example DAG들이 모두 사라진 걸 알 수 있습니다. 이로써 일단 EC2에 Docker Compose를 사용해서 Airflow를 띄웠습니다.

현재 구축한 인프라

이제 EC2에는 모두 설정을 해놓았으니 Github Action을 통해 배포자동화를 시켜보겠습니다.

Git Action 배포 자동화

먼저 Git Action에서 EC2를 접근하기 위해서는 SSH 키와 HOST Address가 필요합니다.
이를 먼저 안전하게 저장하기 위해 Github Secrets로 저장해봅시다.

Github에 접속해 Airflow파일들이 담겨있는 Repository를 선택합니다.
그런 다음 아래와 같이 github settings 클릭합니다.

Settings에 들어오면 메인화면 좌측에 메뉴가 나옵니다.
여기서 빨간색으로 칠해진 버튼을 누르면 드롭다운이 됩니다.

그 다음은 버튼을 눌러줍니다!

그러면 Secret키를 등록할 수 있습니다.
여기에 이제 AWS SSH 키와 연결할 AWS HOST를 등록시켜주면 됩니다!

Git Action은 Yaml 파일을 통해 설정합니다.
.github/workflows 폴더 아래 파일이 위치해야 Github에서 워크플로우로 인식을 하도록 약속이 돼 있습니다!
이제 .github/workflows에 하나의 yaml 파일을 등록해 줍니다.
내용은 아래처럼 작성하시면 push 했을 때나 PR이 Closed 되었을 때 동작합니다.

name: CI to AWS EC2 Airflow

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
    types: [closed]

  workflow_dispatch:

jobs:
  build:

    name: Send to ec2-airflow
    runs-on: ubuntu-latest

    steps:
      - name: SSH Commands
        uses: appleboy/ssh-action@v1.0.0
        with:
          host: ${{ secrets.AWS_SSH_HOST }}
          username: ec2-user
          key: ${{ secrets.AWS_SSH_KEY }}
          port: 22
          script_stop: true
          command_timeout: 200m
          script: |
            cd ~/your-airflow-repository
            sudo chown -R $USER:$USER .
            git pull origin main
            docker-compose down
            docker-compose up -d
      # 이 부분은 슬랙이라 추가적으로 슬랙으로 배포를 열람받고 싶은 분은 WEBHOOK 등록해서 쓰시면 됩니다.
      - name: action-slack
        uses: 8398a7/action-slack@v3
        with:
          status: ${{ job.status }}
          author_name: 배포 결과
          fields: repo,message,commit,author,action,eventName,workflow
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }} # required
        if: always()

이렇게 Git Action을 통해 배포 자동화를 해보았습니다.
보통 개발을 하실 때 로컬에서 개발하시고 실제 서버에 배포하실텐데요.
보통 개발 하시는 구조가 이럴 것이라고 생각해서 한 번 만들어봤습니다!

현재 구축한 인프라

제 포스팅이 Airflow를 사용하시는 분들에게 도움이 됐으면 좋겠네요!

파이썬 함수에서 예외 처리 잘하기

Ambosing — Sat, 29 Jul 2023 15:00:00 GMT

들어가기 전

이전에 도커로 웹 크롤링을 도커 위에서 하나의 사이트마다 24시간 동안 돌리기 위해 크롤링 구조를 새로 짠 적이 있습니다. 그 때에 예외 처리는 어떻게 하는 것이 좋을까라는 생각을 많이 했었습니다.
크롤링 같은 경우 에러가 발생한 경우 그 에러 상황을 재현하기가 쉽지 않을 때가 존재합니다..! 해당 URL의 게시물이 사라진 경우.. 또한, 어디에서 에러가 발생했는지 쉽지 않습니다.
그래서 이번에는 예외 처리를 훌륭하게 해보려고 시도했습니다. 그래도 이번에 이렇게 책에서 나온것처럼 처리한 것 같아서 다행입니다..!
다른 분들도 파이썬에서 예외처리를 잘하고 싶다면 이번에 나오는 예제를 잘 참고해보시는 것이 좋을 듯 합니다!!

이번 글은 파이썬 코딩의 기술을 보고 참조 + 저의 생각을 합쳐서 나온 게시글입니다.
만약 저작권의 문제 발생하거나 잘못된 부분이 있는 경우, 글을 삭제/수정처리 하도록 하겠습니다!

❌ 함수에서 예외가 발생했을 때 None을 반환하는 것의 문제점!

갑자기 이게 무슨 이야기인지 싶으실 겁니다.
바로 아래 예제를 확인하시면 이해가 더 잘 되실 겁니다.

def careful_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None


x, y = 1, 0
result = careful_divide(x, y)
if result is None:
    print('잘못된 입력')

함수에서 예외가 발생했을 때 예외 처리로 None을 리턴하는 방식이 있다고 합니다.
보통 코드를 이렇게 쓰지는 않긴 합니다만..! 만약 None으로 쓰고계셨다면 이제 쓰지 않으시는 걸 추천합니다!
그 이유는 바로 현재 함수를 호출하고 있는 호출자에서 if 조건에서 따로 처리를 해주고 있는 모습으로 보입니다.
그런데 이렇게 처리하는 방법은 실수가 유발되기 쉽습니다.

#
x, y = 0, 5
result = careful_divide(x, y)
if not result:
    print('잘못된 입력') # 이 코드가 실행되는데, 사실 이 코드가 실행되면 안된다!

이 코드에서는 result 값이 0으로 반환받게 됩니다.
이렇게 되면 if문 안의 결과가 False로 되어 print를 실행하게 됩니다. 다른 함수와 같은 경우에도 비슷합니다. False를 반환하는 값이라면 이와 같은 실수가 발생할 수 있게 되는거죠.

그러면 어떻게 해야 예외를 잘 처리할 수 있을까요?

✅ Exception에서 다시 한 번 예외를 발생시켜 호출한 쪽에서 처리하기

말 그대로 함수에서 예외를 처리를 한 번 하고, 다시 한 번 예외를 발생시켜 처리하는 방법입니다.

def careful_divide(a: float, b: float) -> float:
    """a를 b로 나눈다.

    Raises:
        ValueError: b가 0이어서 나눗셈을 할 수 없을 때
    """
    try:
        return a / b
    except ZeroDivisionError as e:
        raise ValueError('잘못된 입력')


x, y = 5, 2
try:
    result = careful_divide(x, y)
except ValueError:
    print('잘못된 입력')
else:
    print('결과는 %.1f 입니다' % result)

이렇게 하면 기존의 None은 반환했을 때와 달리 if문 자체를 쓰지 않아도 돼서 실수를 없앨 수 있습니다.

근데 이제 굳이 이렇게까지 try-except를 두 번씩 쓰면서 함수의 Main부분에서 예외처리를 할 필요가 있을까라는 생각이 들게 됩니다..! ~~저도 처음에 불편해서 했던 생각..~~

코드의 Main 함수에서 예외처리를 하는 것을 최상위 예외라고 합니다. 그러면 최상위 예외를 왜 쓰면 좋은지를 알아보기 전에 커스텀한 예외를 써야하는 이유에 대해서 알아보겠습니다! ~~그래야 예제가 이해가 되고.. 또.. 예외를 더 잘할 수 있다구요!~~

새로운 예외 계층 구조를 정의하는 것이 좋은 이유

파이썬 언어와 표준 라이브러리에는 이미 예외 계층 구조가 내장되어 있습니다.

# my_module.py
def determine_weight(volume, density):
    if density <= 0:
        raise ValueError('밀도는 0보다 커야 합니다') # 내장된 예외
    ...

경우에 따라 내장된 예외인 ValueError를 사용하는 편이 타당할 때도 있습니다.
하지만, API의 경우 새로운 예외 계층 구조를 정의하는 편이 훨씬 강력합니다.
모듈에 최상위 Exception을 정의하고 모듈이 발생시키는 다른 모든 예가 이 최상위 예외를 상속하게 만듦으로써 API에서 발생하는 예외의 계층 구조를 만들 수 있습니다.

# my_module.py
class Error(Exception):
    """이 모듈에서 발생할 모든 예외의 상위 클래스."""


class InvalidDensityError(Error):
    """밀도 값이 잘못된 경우."""


class InvalidVolumeError(Error):
    """부피 값이 잘못된 경우."""


def determine_weight(volume, density):
    if density < 0:
        raise InvalidDensityError('밀도는 0보다 커야 합니다')
    if volume < 0:
        raise InvalidVolumeError('부피는 0보다 커야 합니다')
    if volume == 0:
        density / volume

이번에는 이렇게 새로운 예외 계층을 정의하면 어떤 점이 좋은지 알아보겠습니다.

✅ 새로운 예외 계층을 정의하면 API를 잘못 사용한 경우를 더 쉽게 이해할 수 있습니다.

try:
    # 호출 코드 버그로 인한 오류가 나야 함
    weight = my_module.determine_weight(-1, 1)
except my_module.InvalidDensityError:
    weight = 0
except Exception: 
    logging.exception('호출 코드에 버그가 있음')

>> ERROR:root:호출 코드에 버그가 있음
Traceback (most recent call last):
  File "C:\Users\user\PycharmProjects\issueKeyword\test.py", line 27, in <module>
    weight = determine_weight(-1, 1)
  File "C:\Users\user\PycharmProjects\issueKeyword\test.py", line 18, in determine_weight
    raise InvalidVolumeError('부피는 0보다 커야 합니다')
InvalidVolumeError: 부피는 0보다 커야 합니다

이렇게 하면 기존에 있었던 InvalidVolumeError를 통해 에러가 발생했구나를 바로 알 수 있고, 에러를 처리하기 쉬워집니다.

그럼 이제 이렇게 커스텀한 예외 구조 계층을 만들어봤으니 다시 최상위 예외가 있으면 왜 좋은지 알아봅시다!@

❓ 최상위 예외와 커스텀한 예외 구조 계층을 쓰면 좋은 점

✅ 최상위 예외가 있으면 예상치 못한 예외를 처리가 가능하고, API 코드의 버그를 발견할 때 도움이 됩니다.

def determine_weight(volume, density):
    if density < 0:
        raise InvalidDensityError('밀도는 0보다 커야 합니다')
    if volume < 0:
        raise InvalidVolumeError('부피는 0보다 커야 합니다')
    if volume == 0:
        density / volume

try:
    # 호출 코드 버그로 인한 오류가 나야 함
    weight = my_module.determine_weight(-1, 1)
except my_module.InvalidDensityError:
    weight = 0
except Exception: 
    logging.exception('호출 코드에 버그가 있음')

현재 코드의 최상위 부분에서는 InvalidDensityError, 즉 밀도만 따로 weight를 0으로 처리하고 있을 뿐, 따로 부피에 대해서는 예외를 처리해주지 않고 있습니다.
이럴 때 라이브러리에 있는 Exception을 사용하면 모든 예외 상황에 대해서 처리해서 프로세스가 종료되지 않게 할 수 있고 로그를 찍어 에러를 쉽게 파악할 수 있습니다.
그리고 Exception의 Stack trace를 통해 따로 InvalidVolumeError에 대한 예외 처리를 InvalidDensityError와 같이 weight = 0으로 처리를 따로 해줄 수 있습니다.

제가 사용했던 커스텀한 예외 계층과 최상위 예외

그리고 저 같은 경우에는 따로 제가 만든 예외 계층을 사용하여 어디에서 에러가 발생했는지를 확실하게 알기 위해 각각의 위치에서 제가 만든 다른 예외 계층을 사용했습니다.

제가 사용했던 코드의 예시를 잠깐 드리면..!

def board_page_crawling():
    try:
        ...
    except TimeoutException:
        raise SeleniumError(f'Selenium 크롤링 {url}에서 도중 Timeout 발생')

def Crawling():
    try:
        crawling_list = board_page_crawling()
        insert(crawling_list)
    except SeleniumError:
        logging.exception('Selenium에서 에러 발생')
    except InsertError:
        logging.exception('Insert에서 에러 발생')
    except Exception:
        logging.exception('알 수 없는 오류 발생')

이런식으로 사용했었습니다. 이렇게 사용하니 에러 파악이 예전보다 손 쉬워졌고 따로 로그DB를 만들어 컬럼에 Type을 붙여 어떤 함수에서 발생했는지 특정할 수 있었습니다. 그리고 특정 웹사이트 게시물에 대해서 에러가 발생해도 프로세스는 종료되지 않고 크롤링을 이어나갈 수 있었습니다.

요약

모듈에서 사용할 최상위 예외를 정의하면 API 프로세스를 종료되지 않고 보호할 수 있습니다.
자신이 사용하는 예외 계층과 최상위 예외를 같이 사용하면 API 코드의 버그를 쉽게 찾을 수 있습니다.
파이썬 Exception을 최상위 예외에 예외 처리를 해준다면 예상치 못한 경우에 대해서도 로그를 남기고 프로세스가 종료되지 않게 할 수 있습니다.

파이썬에서 정렬을 잘 사용하는 법

Ambosing — Mon, 24 Jul 2023 15:00:00 GMT

들어가기 전

코딩테스트 문제를 풀다가 정렬 문제를 마주한 적이 있습니다..!
정렬에서는 sort, key 정도만 알고 있었는데 그 이상의 것들로 푸시는 분들도 있더라구요..!
이번에는 거기서 영감을 받고, 현재 읽고 있는 책 내용에도 존재해서 이번에는 정렬에 대해서 조금 더 깊이 알아보려고 합니다!

이번 글은 파이썬 코딩의 기술을 보고 참조하였습니다.
만약 문제 발생시 글을 삭제처리 하도록 하겠습니다!

sort와 sorted

파이썬 리스트에는 리스트를 제자리에서(in-place) 수정하는 내장 list.sort() 메서드가 존재합니다! 또한, iterable로부터 새로운 정렬된 리스트를 만드는 sorted() 내장 함수도 존재합니다.

먼저 sorted() 내장 함수 사용법을 봅시다.

sorted([5, 2, 3, 1, 4]) # 새로운 리스트 반환
[1, 2, 3, 4, 5]

sorted()메서드와는 달리 sort() 함수는 리스트에만 존재합니다.
list.sort() 메서드를 사용해서 제자리(in-place)에서 수정할 수 있습니다.
list.sort()는 None을 반환합니다.

a = [5, 2, 3, 1, 4]
a.sort()
print(a.sort())
>> None
a
>> [1, 2, 3, 4, 5]

일반적으로 list.sort()는 sorted()보다는 불편합니다..! 하지만 원래 목록이 필요하지 않다면, 새로운 리스트를 하나 더 만드는 sorted()보다 효율적입니다.(공간복잡도가 낮아집니다!) (sorted()는 새로운 리스트를 반환하므로)

또 다른 점은 list.sort() 메서드가 리스트에게만 정의된다는 것입니다. 이와 달리, sorted() 함수는 모든 iterable을 받아들입니다.

sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

복잡한 기준을 사용할 때는 key 파라미터를 사용하자!

class Tool:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __repr__(self):
        return f'Tool({self.name!r}, {self.weight})'

tools = [
    Tool('수준계', 3.5),
    Tool('해머', 1.25),
    Tool('스크류드라이버', 0.5),
    Tool('끌', 0.25),
]

이런 코드가 있다고 가정합시다!
기본적인 list.sort()를 사용하면 어떤 기준으로 정렬할 지 모르기 때문에 에러가 발생합니다.

Traceback (most recent call last):
  File "C:\Users\user\PycharmProjects\issueKeyword\test.py", line 17, in <module>
    tools.sort()
TypeError: '<' not supported between instances of 'Tool' and 'Tool'

정렬을 사용하고 싶은 애트리뷰트가 객체에 들어 있는 경우가 많습니다. 이런 상황을 지원하기 위해 sort에는 key라는 파라미터가 존재합니다.
key는 함수여야 하고, 정렬 중인 리스트의 원소가 전달되어야 합니다.
다음은 이름으로 Tool들을 정렬해 보겠습니다.

print('미정렬:', repr(tools))
tools.sort(key=lambda x: x.name)
print('정렬: ', tools)

>> 미정렬: [Tool('수준계', 3.5), Tool('해머', 1.25), Tool('스크류드라이버', 0.5), Tool('끌', 0.25)]
>> 정렬:  [Tool('끌', 0.25), Tool('수준계', 3.5), Tool('스크류드라이버', 0.5), Tool('해머', 1.25)]

이번에는 Weight로 정렬하는 람다 함수를 만들어서 sort의 key 파라미터로 전달해보겠습니다.

tools.sort(key=lambda x: x.weight)
print('무게순 정렬:', tools)
>> 무게순 정렬: [Tool('끌', 0.25), Tool('스크류드라이버', 0.5), Tool('해머', 1.25), Tool('수준계', 3.5)]

그렇다면 weight로 먼저 정렬한 다음에 name으로 정렬하고 싶다면 어떻게 해야 할까요..!?
-> 바로 키에 Tuple 타입을 사용하는 겁니다.

튜플은 기본적으로 비교가 가능하며 자연스러운 순서가 정해져 있습니다. 이는 sort에 필요한 __lt__정의가 들어 있다는 말과 동일합니다.

먼저 weight로 정렬하고 그 후 name으로 정렬해보겠습니다.

power_tools = [
    Tool('드릴', 4),
    Tool('원형 톱', 5),
    Tool('착암기', 40),
    Tool('연마기', 4),
]
power_tools.sort(key=lambda x: (x.weight, x.name))
print(power_tools)
>> [Tool('드릴', 4), Tool('연마기', 4), Tool('원형 톱', 5), Tool('착암기', 40)]

숫자 값의 경우 - 연산자를 사용해 정렬 방향을 변경할 수 있습니다.

power_tools.sort(key=lambda x: (-x.weight, x.name)) # weight에 - 연산자 (역순 정렬)
print(power_tools)
>> [Tool('착암기', 40), Tool('원형 톱', 5), Tool('드릴', 4), Tool('연마기', 4)]

모든 타입에 부호 반전을 사용할 수는 없습니다. name을 반전시켜서 앞처럼 역순 정렬 해보려고 해도 실패하고 맙니다..!

Traceback (most recent call last):
  File "C:\Users\user\PycharmProjects\issueKeyword\test.py", line 16, in <module>
    power_tools.sort(key=lambda x: (x.weight, -x.name),
  File "C:\Users\user\PycharmProjects\issueKeyword\test.py", line 16, in <lambda>
    power_tools.sort(key=lambda x: (x.weight, -x.name),
TypeError: bad operand type for unary -: 'str'

파이썬은 Stable 정렬을 제공한다..!

파이썬은 Stable 정렬 알고리즘을 제공합니다.
아니 갑자기 왜 Stable 정렬이냐구요..?
이유는 바로 뒤에 나옵니다! 리스트 타입의 sort 메서드는 key 함수가 반환하는 값이 서로 같은 경우 리스트에 들어 있던 원래 순서를 그대로 유지해줍니다!
이는 같은 리스트에 대해 서로 다른 기준으로 sort를 여러 번 호출해도 된다는 뜻입니다.

# power_tools.sort(key=lambda x: (x.weight, -x.name))

power_tools.sort(key=lambda x: x.name, reverse=True)  # name 기준 내림차순
power_tools.sort(key=lambda x: x.weight)  # weight 기준 오름차순
print(power_tools)
>> [Tool('연마기', 4), Tool('드릴', 4), Tool('원형 톱', 5), Tool('착암기', 40)]

파이썬의 Stable한 정렬 덕분에 아까 에러가 발생했던 (weight, -name)에 대한 정렬 결과를 위 코드처럼 두 번 정렬함으로써 결과를 도출할 수 있습니다.

cmp_to_key

파이썬에서 key 파라미터로 해결되지 않고, 두 변수를 변경시켜 정렬을 해야하는 경우가 있습니다. 그럴 때는 functools의 cmp_to_key를 사용하면 됩니다.

from functools import cmp_to_key

# 구식 비교 함수
def compare(a, b):
    return a - b  # a < b 이면 음수 반환, a == b 이면 0 반환, a > b 이면 양수 반환

# 키 함수로 변환
key_func = cmp_to_key(compare)

# 이제 sort나 sorted와 함께 사용할 수 있습니다
my_list = [5, 2, 9, 1, 7]
my_list.sort(key=key_func)
print(my_list)  # 출력: [1, 2, 5, 7, 9]

cmp_to_key 예시

프로그래머스의 가장 큰 수라는 문제에서 cmp_to_key를 활용하여 문제를 풀 수 있습니다.

문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.

예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.

0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

제한 사항

numbers의 길이는 1 이상 100,000 이하입니다. numbers의 원소는 0 이상 1,000 이하입니다. 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

입출력 예

numbers	return
[6, 10, 2]	“6210”
[3, 30, 34, 5, 9]	“9534330”

from functools import cmp_to_key


def cmp(a, b):
    ab, ba = a + b, b + a
    if ab > ba:
        return 1
    elif ab < ba:
        return -1
    return 0


def solution(numbers):
    numbers = list(map(str, numbers))
    numbers.sort(key=cmp_to_key(cmp), reverse=True)
    return str(int(''.join(numbers)))

이 문제의 해결 방법은 numbers 리스트에 있는 값들을 적절히 조합하여 가장 큰 수를 만드는 문제입니다.
이 때, cmp_to_key를 사용하여 함수를 정의해 a + b, b + a의 대소 비교를 통해 정렬을 구현한 적이 있습니다!!

요약

list.sort()를 사용하면 제자리에서(in-place)로 정렬을 할 수 있습니다.
sorted() 메서드를 사용하면 편리하지만 새로운 리스트를 반환하므로 비효율적입니다. 하지만 다른 iterable 객체를 모두 정렬시킬 수 있습니다.
sort 메서드의 key 파라미터를 사용하면 리스트의 각 원소 대신 비교에 사용할 객체를 반환하는 도우미 함수를 제공할 수 있습니다.
key 함수에서 튜플을 반환하면 여러 정렬 기준을 하나로 엮을 수 있습니다. - 연산자를 사용하면 숫자 타입인 경우 역순 정렬을 할 수 있습니다.
부호를 바꿀 수 없는 타입의 경우, 여러 정렬 기준을 조합하려면 각 정렬 기준마다 reverse 값으로 정렬 순서를 지정하면서 sort 메서드를 여러 번 사용해야 합니다. 이 때 정렬 기준의 우선순위가 점점 높아지는 순서로 sort를 호출해야 합니다.
ex) 정렬 기준 (a, b, c) -> sort(key=c), sort(key=b), sort(key=a)

파이썬에서 대입식을 통해 코드 중복을 없애는 방법 feat. 왈러스(Walrus)

Ambosing — Wed, 19 Jul 2023 15:00:00 GMT

들어가기 전

책을 읽다가 새로운 기능인 왈러스를 알게되었는데, 이 기능을 다른 분들도 알게 된다면 좋을 것 같아서 정리해봅니다!
아!! 이 기능은 파이썬 3.8이상부터 사용가능합니다!

이번 글은 파이썬 코딩의 기술을 보고 참조하였습니다.
만약 문제 발생시 글을 삭제처리 하도록 하겠습니다!

중복이 되는 문제 상황

주스 바에서 사용할 신선한 과일 바구니를 관리한다고 해봅시다! 고객이 레모네이드를 주문했다면 과즙을 낼 레몬이 바구니에 최소 하나는 있어야 합니다. 다음 코드는 레몬의 개수를 읽어와서 그 값이 0이 아닌지 확인하는 코드입니다.

fresh_fruit = {
    '사과': 10,
    '바나나': 8,
    '레몬': 5,
}

def make_lemonade(count):
    ....

def out_of_stock():
    ...

count = fresh_fruit.get('레몬', 0)
if count:
    make_lemonade(count)
else:
    out_of_stock()

이 코드는 문제점이 있습니다. count 변수는 if 문의 첫 번째 블록 안에서만 쓰인다는 것입니다.
파이썬에서는 이런 식으로 값을 가져와서 그 값이 0이 아닌지 검사한 후 사용하는 패턴이 자주 발생합니다.

왈러스(대입식)을 활용한 해결 방법

왈러스(대입식)이 추가되면서 이런 유형의 코드를 제대로 처리할 수 있게 되었습니다.

if count := fresh_fruit.get('레몬', 0):
	make_lemonade(count)

한 줄 더 짧기도 하지만, count가 if 문의 첫 번째 블록에서만 의미가 있다는 점이 명확히 보이기 때문에 이 코드가 더 읽기 쉽습니다.

if, elif, else 깊게 내포 시키는 문제!

파이썬에는 유연한 switch/case 문이 없다는 점도 파이썬을 처음 접한 프로그래머들을 자주 당황하게 만드는 원인 중 하나입니다. 파이썬에서 이런 유형의 기능을 흉내 내는 일반적인 스타일은 if, elif, else 문을 깊게 내포시키는 방법이 있습니다.

예를 들어, 현재 주스 바에서 만들 수 있는 주스 중 가장 좋은 주스를 고객에게 제공한다고 합시다.

바나나
애플 주스
레모네이드

위의 순서대로 제공하는 로직입니다.

if count >= 2:
    pieces = slice_bananas(count)
    to_enjoy = make_smoothies(pieces)
else:
    count = fresh_fruit.get('사과', 0)
    if count >= 4:
        to_enjoy = make_cider(count)
    else:
        count = fresh_fruit.get('레몬', 0)
        if count:
            to_enjoy = make_lemonade(count)
        else:
            to_enjoy = '아무것도 없음'

왈러스 연산자를 사용하여 해결!

앞에서 봤던 if-else 중첩은 코드를 보는 사람을 어렵게 합니다..!
그래서 이 코드도 왈러스(대입식) 연산자를 사용하여 해결해보겠습니다.

if (count := fresh_fruit.get('바나나', 0)) >= 2:
    pieces = slice_bananas(count)
    to_enjoy = make_smoothies(pieces)
elif (count := fresh_fruit.get('사과', 0)) >= 4:
    to_enjoy = make_cider(count)
elif count := fresh_fruit.get('레몬', 0):
    to_enjoy = make_lemonade(count)
else:
    to_enjoy = '아무것도 없음'

왈러스 연산자를 사용하면 switch/case문 같은 다중 선택 전용 구문과 거의 비슷한 느낌이 드는 우아한 해법을 만들 수 있습니다.

왈러스 연산자로 Do-While 만들기

파이썬에는 Do-While 루프가 없습니다!

먼저 예를 들겠습니다. 신선한 과일이 배달돼서 이 과일을 모두 주스로 만든 후 병에 담기로 했다고 합시다. 다음은 while 루프로 이 로직을 구현한 코드입니다.

bottles = []
fresh_fruit = pick_fruit() # 1
while fresh_fruit:
    for fruit, count in fresh_fruit.items():
        batch = make_juice(fruit, count)
        bottles.extend(batch)
    fresh_fruit = pick_fruit() # 2

print(bottles)

이 코드는 fresh_fruit = pick_fruit() 호출을 두 번하므로 반복적입니다.

호출의 이유

루프 직전에 초기화
루프의 끝에서 배달받은 신선한 과일을 다시 선택

왈러스 연산자를 사용하면 while 루프에서 매번 fresh_fruit 변수에 대입하고 조건을 검사할 수 있습니다.

bottles = []
while fresh_fruit := pick_fruit():
    for fruit, count in fresh_fruit.items():
        batch = make_juice(fruit, count)
        bottles.extend(batch)

print(bottles)

요약

대입식에서는 왈러스 연산자(:=)를 사용해 하나의 식 안에서 변수 이름에 값을 대입하면서 이 값을 평가할 수 있고, 중복을 줄일 수 있습니다.
파이썬에서는 Switch/case 문이나 Do/While 루프를 쓸 수 없지만, 대입식을 사용하면 이런 기능을 더 깔끔하게 흉내 낼 수 있습니다.
대입식, 즉 왈러스 연산자(:=) 파이썬 3.8이상부터 사용할 수 있다는 걸 꼭 기억하세요!!

반복문 파이썬스럽게 쓰는 방법

Ambosing — Sun, 09 Jul 2023 15:00:00 GMT

들어가기 전

다른 언어들도 각각의 특성에 맞게 반복문이 특징이 있을 때가 있는데요.
파이썬은 매우 특이한 케이스라고 저는 생각합니다..!
그래서 이번에는 특이하다고 생각되는 반복문을 조금 더 파이썬스럽게 쓸 수 있는 방법들을 알아보고자 합니다

이번 글은 파이썬 코딩의 기술을 보고 참조하였습니다.
만약 문제 발생시 글을 삭제처리 하도록 하겠습니다!

range보단 enumerate!

range 내장 함수는 어떤 정수 집합을 반복하는 루프가 필요할 때 유용합니다!

for i in range(10):
    print(i, end=' ')
# 0 1 2 3 4 5 6 7 8 9

리스트를 반복하면서 리스트의 몇 번째 원소를 처리 중인지를 알아야 할 때가 있습니다.
예를 들어, 아이스크림 맛의 선호도 순위를 출력하고 싶다고 합시다!

flavor_list = ['바닐라', '초콜릿', '피칸', '딸기']

for i in range(len(flavor_list)):
    flavor = flavor_list[i]
    print(f'{i + 1}: {flavor}')

이 코드는 조금 투박해 보입니다..!
일단 list의 길이를 알아야 하고, 인덱스를 사용해 배열 원소에 접근해야 합니다.
이렇게 단계가 여러 개이므로 코드의 가독성이 떨어집니다.

파이썬은 이런 문제를 해결할 수 있는 enumerate 내장함수를 제공합니다.
enumerate는 이터레이터를 지연 계산 제너레이터(lazy generator) 로 감쌉니다. enumerate는 인덱스와 다음 값으로 이뤄진 쌍을 넘겨줍니다. <= yield 시키는 것과 동일!

it = enumerate(flavor_list)
print(next(it))
print(next(it))

# (0, '바닐라')
# (1, '초콜릿')

enumerate가 넘겨주는 각 쌍을 for문에서 간결하게 언패킹할 수 있습니다.

for i, flavor in enumerate(flavor_list):
    print(f'{i + 1}: {flavor}')

>>
1: 바닐라
2: 초콜릿
3: 피칸
4: 딸기

enumerate는 두 번째 파라미터로 어디부터 수를 세기 시작할지 지정할 수 있습니다.

for i, flavor in enumerate(flavor_list, 1):
    print(f'{i}: {flavor}')

>>
1: 바닐라
2: 초콜릿
3: 피칸
4: 딸기

이 부분에서 주의할점은 1부터 센다고 해서 인덱스 0을 빼고 반복하는 것이 아니라 인덱스에만 +1되는 것을 주의하세요!

~~저는 착각하고 사용해서 당함…~~

여러 이터레이터를 한 번에 zip으로!

names = ['Cecilia', '남궁민수', '毛泽东']
counts = [len(n) for n in names]
print(names)
print(counts)

>>
['Cecilia', '남궁민수', '毛泽东']
[7, 4, 3]

위와 같이 주어졌을 때, 가장 긴 이름과 가장 긴 이름의 길이를 구하고 싶다고 해봅시다.

우리는 바로 위에서 enumerate를 배웠으니 enumerate를 써봅시다!

longest_name = None
max_count = 0

for i, name in enumerate(names):
    count = counts[i]
    if count > max_count:
        longest_name = name
        max_count = count

print(longest_name)
print(max_count)

>>
Cecilia
7

enumerate를 사용하니깐 깔끔해보이긴 하지만 아직 counts의 인덱싱이 마음에 들지 않습니다.
이 때 코드를 더 깔끔하게 만들 수 있는 것이 zip이라는 내장 함수입니다.

zip은 둘 이상의 이터레이터를 지연 계산 제너레이터를 사용해 묶어줍니다!
zip 제너레이터는 각 이터레이터의 다음 값이 들어 있는 튜플을 반환하고, for문에서는 이를 바로 언패킹 할 수 있습니다.

for name, count in zip(names, counts):
    if count > max_count:
        longest_name = name
        max_count = count

이제는 인덱싱 없이 코드가 아주 깔끔해졌습니다.

zip에서는 주의할 점이 있는데요.
바로 서로 다른 길이의 이터레이터가 입력으로 주어졌을 때입니다. names에 하나의 길이를 추가한다고 했을 때, names의 길이는 4가 되고 counts의 길이는 3이 됩니다.

names.append('Rosalind') # len(names) : 3 -> 4
for name, count in zip(names, counts):
    print(f'{name}: {count}')
>> 
Cecilia: 7
남궁민수: 4
毛泽东: 3

결과를 보시면 3개까지만 출력하는 것을 볼 수 있습니다. zip은 자신이 감싼 이터레이터 중 어느 하나가 끝날 때까지 튜플을 내놓습니다. 따라서 출력은 가장 짧은 입력의 길이와 같습니다.

만약 긴 이터레이터의 뒷부분을 찍고 싶다면 itertools 내장 모듈에 있는 zip_longest를 사용하면 됩니다.

import itertools
for name, count in itertools.zip_longest(names, counts):
    print(f'{name}: {count}')
>>
Cecilia: 7
남궁민수: 4
毛泽东: 3
Rosalind: None

for나 while 뒤에 else 블록 사용하지 않기!

파이썬에서는 반복문이 반복 수행하는 내부 블록 바로 다음에 else 블록을 추가할 수 있습니다.

for i in range(3):
    print('Loop', i)
else:
    print('Else block!')


for i in range(3):
    print('Loop', i)
    if i == 1:
        break
else:
    print('Else block!')
>>
Loop 0
Loop 1
Loop 2
Else block!
Loop 0
Loop 1

for/else의 else 부분은 루프가 정상적으로 완료되어야 동작 하는 것을 알 수 있습니다.

빈 이터레이터나 반복문 조건이 처음부터 False였을 경우에도 else 블록이 바로 실행됩니다.

for x in []:
    print('이 줄은 실행되지 않음')
else:
    print('For Else block!')

while False:
    print('이 줄은 실행되지 않음')
else:
    print('While Else block!')
>>
For Else block!
While Else block!

이런 방식으로 동작하는 이유는 break를 했을 때는 동작하지 않고, 모든 반복이 끝날 때만 동작하는 경우가 유용하기 때문입니다! 이렇게 작성하면 가독성이 떨어지고 직관적이지 않습니다.

이를 위해 해결할 방법 중 첫 번째는 원하는 조건을 찾자마자 빠르게 함수를 반환하는 방식입니다.

def check():
    for i in range(3):
        print('Loop', i)
        if i == 1:
            return False
    return True


if check():
    print('if block!')

두 번째 방법은 루프 안에서 원하는 대상을 찾았는지 나타내는 결과 변수를 도입하는 것입니다.

def check2():
    is_not_break = True
    for i in range(3):
        print('Loop', i)
        if i == 1:
            is_not_break = False
            break
    return is_not_break


if check2():
    print('if block!')

파이썬에서 루프와 같은 간단한 구성 요소는 그 자체로 의미가 명확해야 합니다. 따라서 루프 뒤에 else 블록이 직관적이지 않기 때문에 되도록 사용하지 않는게 좋아보입니다!!

요약

enumerate를 사용하면 이터레이터에 대해 루프를 돌면서 이터레이터에서 가져오는 원소의 인덱스까지 얻는 코드를 간결하게 작성할 수 있습니다!
zip 내장 함수를 사용해 여러 이터레이터를 같이 이터레이션할 수 있습니다.
입력 이터레이터의 길이가 서로 다르면 zip은 가장 짧은 이터레이터 길이까지만 튜플을 내놓고 더 긴 이터레이터의 나머지 원소는 무시합니다.
서로 다른 이터레이터에 대해 더 긴 이터레이터까지 루프를 수행하려면 itertools 내장 모듈의 zip_longest 함수를 사용하면 됩니다!
for/while 뒤에 오는 else 블록은 루프가 반복되는 도중에 break를 만나지 않은 경우에만 실행됩니다.
for/while - else는 동작이 직관적이지 않고 혼동을 야기할 수 있으므로 else 블록을 사용하지 않는 게 좋습니다.

파이썬에서 문자열 출력 잘하는 법

Ambosing — Sun, 09 Jul 2023 15:00:00 GMT

들어가기 전

파이썬을 사용하면서 문자열 가공을 가장 많이 처리할 겁니다. 어떤 언어보다도 문자열 처리하기가 제일 좋은 이유가 있기 때문이죠!
그래서 이번에 파이썬에서 다양한 문자열 출력 방법이 있는데 그중 어떤 것이 왜 가장 좋은지 한 번 알아봅시다.
결론이 급하신 분들은 맨 마지막 인터폴레이션만 보시면 될 것 같습니다!

이번 글은 파이썬 코딩의 기술을 보고 참조하였습니다.
만약 문제 발생시 글을 삭제처리 하도록 하겠습니다!

🥉 C 스타일 형식 문자열 출력 방법

C 스타일 형식 문자열은 파이썬에서 문자열을 형식화하는 방법 중 하나입니다.

a = 0b10111011
b = 0xc5f
print('이진수: %d, 십육진수: %d' % (a, b))

# 이진수: 187, 십육진수: 3167

형식 문자열은 연산자 왼쪽에 있는 값을 끼워 넣을 자리를 표현하기 위해 %d 같은 형식 지정자를 사용합니다.
파이썬의 형식 지정자 문법은 printf 함수에서 비롯됐습니다.

하지만 이런 C 스타일 형식 문자열은 문제점이 있습니다.

문제점 1. 형식화 식에서 오른쪽에 있는 tuple 내 데이터 값의 순서를 바꾸거나 값의 타입을 바꾸면 타입 변환이 불가능하므로 오류가 발생할 수 있습니다.

key = 'my_var'
value = 1.234
formatted = '%-10s = %.2f' % (key, value)
print(formatted)

# my_var = 1.23

# key와 value 순서 변경
reordered_tuple = '%-10s = %.2f' % (value, key)
# 에러 발생

형식 문자열도 같이 변경을 하지 않았기 때문에 에러가 발생했습니다. 이와 같이 % 연산자의 좌우가 잘 맞아야 하는 단점이 있습니다.

문제점 2. 형식화를 하기 전에 값을 살짝 변경해야 한다면 식을 읽기가 매우 어렵습니다.

pantry = [
	('아보카도', 1.25),
	('바나나', 2.5),
	('체리', 15),
]

for i, (item, count) in enumerate(pantry):
	print('#%d: %-10s = %.2f' % (i, item, count))

# #0: 아보카도      = 1.25
# #1: 바나나     = 2.50
# #2: 체리     = 15.00

for i, (item, count) in enumerate(pantry):
    print('#%d: %-10s = %d' % (
        i + 1,
        item.title(),
        round(count)))

이렇게 할 경우 형식화 식에 있는 tuple의 길이가 너무 길어져서 여러 줄에 나눠 써야 하는데, 가독성이 나빠집니다.

문제점 3. 형식화 문자열에서 같은 값을 여러 번 사용하고 싶다면 튜플에서 같은 값을 여러 번 반복해야 합니다.

template = '%s는 음식을 좋아해. %s가 요리하는 모습을 봐요.'
name = '철수'
formatted = template % (name, name) # <- 반복되는 부분
print(formatted)

# 철수는 음식을 좋아해. 철수가 요리하는 모습을 봐요.

이런 식으로 같은 값을 반복해야 하면, 형식화할 값을 살짝 변경해야 하는 경우 실수하기도 쉽고 코딩하기에도 성가십니다.

문제점 4. 형식화 식에 딕셔너리를 사용하면 문장이 번잡스러워집니다.

각 키를 최소 두 번 반복하게 되고, 키에 해당하는 값이 변수에 들어 있다면 변수 이름까지 세 번 이상 같은 이름을 반복해서 사용할 수 있습니다.

soup = 'lentil'
formatted = 'Today\'s soup is %(soup)s.' % {'soup': soup} # soup가 4번 반복됨
print(formatted)

이러한 문제점들이 있기 때문에 C 형식화 문자열 출력 방법을 추천하지 않습니다..!

🥈 내장 함수 format과 str.format 문자열 출력 방법

파이썬 3부터는 더 표현력이 좋은 고급 문자열 형식화 기능이 도입됐습니다.

a = 1234.5678
formatted = format(a, ',.2f')
print(formatted)

b = 'my 문자열'
formatted = format(b, '^20s')
print('*', formatted, '*')

# 1,234.57
# *        my 문자열        *

format을 이용한 방법도 형식 지정자를 붙일 수 있습니다.

formatted = '{:<10} = {:.2f}'.format(key, value)
print(formatted)

print('%.2f%%' % 12.5) # C 형식에서 %를 표현할 경우
print('{} replaces {{}}'.format(1.23)) # 중괄호를 표현할 경우

# my_var     = 1.23
# 12.50%
# 1.23 replaces {}

형식화한 값의 출력 순서를 변경할 수도 있습니다.

formatted = '{1} = {0}'.format(key, value)
print(formatted)

문제점 1. 형식화를 하기 전에 값을 변경해야 경우에는 코드 읽기가 어려워집니다.

for i, (item, count) in enumerate(pantry): 
    new_style = '#{}: {:<10s} = {}'.format(
        i + 1,
        item.title(),
        round(count)) # 분리됨
        
    print(new_style)
# #1: 아보카도       = 1
# #2: 바나나        = 2
# #3: 체리         = 15

문제점 2. 딕셔너리의 Key가 반복되는 경우의 중복을 줄여주지는 못합니다.

# C 스타일
old_template = (
    'Today\'s soup is %(soup)s, '
    'buy one get two %(oyster)s oysters, '
    'and our special entrée is %(special)s.')
old_formatted = template % {
    'soup': 'lentil',
    'oyster': 'tongyoung',
    'special': 'schnitzel',
}

# Format 함수 
new_template = (
    'Today\'s soup is {soup}, '
    'buy one get two {oyster} oysters, '
    'and our special entrée is {special}.')
new_formatted = new_template.format(
    soup='lentil',
    oyster='tongyoung',
    special='schnitzel',
)

아직도 문제점이 해결되지 않았으므로 새로운 방법이 필요해 보입니다!

🥇 인터폴레이션을 통한 형식 문자열

앞의 문제들을 한 번에 완전히 해결하기 위해 파이썬 3.6부터는 인터폴레이션(interpolation)을 형식 문자열(짧게 f-문자열이라고 부릅니다.)이 도입됐습니다.

이 새로운 언어 문법에서는 형식 문자열 앞에 f 문자를 붙여야 합니다.
f-문자열은 형식 문자열의 표현력을 극대화하고, 앞에서 설명한 문제점인 형식화 문자열에서 키와 값을 불필요하게 중복 지정해야 하는 경우를 없애줍니다.

key = 'my_var'
value = 1.234

formatted = f'{key!r:<10} = {value:.2f}'
print(formatted)
# 'my_var'   = 1.23

{}안에 !r은 무엇일까요?
!r은 raw String을 의미합니다! {} 안에 있는 표현식을 raw String으로 출력해줍니다

값을 약간 변경하고 싶을 때도 간결한 구문으로 표기할 수 있으므로, 앞에서 설명한 문제점(형식화를 하기 전에 값을 살짝 변경해야 한다면 식을 읽기가 매우 어렵습니다)을 해결할 수 있습니다.

for i, (item, count) in enumerate(pantry):
	# C 형식
	old_style = '#%d: %-10s = %d' % (
			i + 1,
			item.title(),
			round(count))
	
	# format
	new_style = '#{}: {:<10s} = {}'.format(
			i + 1,
			item.title(),
			round(count))
	
	# interpolation
	f_string = f'#{i+1}: {item.title():<10s} = {round(count)}'
			
	assert old_style == new_style == f_string

파이썬 식을 형식 지정자 옵션에 넣을 수도 있습니다.

places = 3
number = 1.23456
print(f'내가 고른 숫자는 {number:.{places}f}')

값을 문자열로 형식화해야 하는 상황을 만나게 되면 다른 대안 대신 f-문자열을 택하면 될 것 같습니다!

요약

% 연산자를 사용하는 C 스타일 형식화 문자열은 여러 가지 단점과 번잡성이라는 문제가 있습니다.
str.format 메서드도 C 스타일 형식 문자열의 문제점을 그대로 가지고 있으므로, 가능하면 str.format 사용을 피하는 것이 좋습니다.
f-문자열은 값을 문자열 안에 넣는 새로운 구문으로, C 스타일 형식화 문자열의 가장 큰 문제점을 해결해줍니다.
f-문자열은 간결하지만, 위치 지정자 안에 임의의 파이썬 식을 직접 포함시킬 수 있으므로 매우 강력합니다.

파이썬에서의 코드 악취 대응하기

Ambosing — Wed, 14 Jun 2023 15:00:00 GMT

들어가기 전

파이썬을 사용하면서 어떻게 하면 파이썬을 더욱 이쁘게 사용할 수 있을까?
내가 정말 파이썬스럽게 코드를 짜고 있는 것인가라는 의문이 들었습니다..ㅠ
그래서 이번에는 파이썬에서 악취나는 코드들을 살펴보고 그에 대한 해결 방안을 찾아보면서 파이썬에서의 클린 코드를 한층 업그레이드 해보려고 합니다!

중복된 코드

가장 흔한 코드는 역시 중복된 코드입니다! 먼저 중복된 코드를 보시고 나쁜 점을 살펴봅시다.

# 중복된 코드 예시

# 사각형의 넓이 계산
length = 5
width = 3
rectangle_area = length * width
print("넓이:", rectangle_area)

# 삼각형의 넓이 계산
base = 4
height = 2
triangle_area = 0.5 * base * height
print("넓이:", triangle_area)

# 원의 넓이 계산
radius = 2
circle_area = 3.14 * radius * radius
print("넓이:", circle_area)

위의 예시에서 넓이를 출력하는 부분이 중복되고 있습니다.

중복된 코드의 나쁜 점은 다음과 같습니다

유지 보수의 어려움: 중복된 코드가 있는 경우, 해당 코드의 수정이 필요한 경우 여러 곳에서 수정해야 합니다. 이는 시간 소모적이며, 실수로 일부 수정을 빠뜨리는 등의 문제가 발생할 수 있습니다.

코드의 가독성 저하: 중복된 코드가 있는 경우, 같은 동작을 하는 코드가 여러 곳에 반복되므로 코드가 복잡해지고 가독성이 떨어집니다.

오류 발생 가능성: 중복된 코드는 여러 곳에서 동일한 동작을 수행하므로, 하나의 버그가 여러 곳에 영향을 미칠 수 있습니다. 또한, 중복된 코드의 복사 및 붙여넣기 작업 시 실수로 오타가 발생할 수 있습니다.

이러한 문제를 해결하기 위해 함수와 반복문을 사용할 수 있습니다.

함수로 중복 제거

def calculate_square_area(side):
    return side * side

def calculate_rectangle_area(length, width):
    return length * width

def calculate_triangle_area(base, height):
    return 0.5 * base * height

side = 5
square_area = calculate_square_area(side)

length = 4
width = 6
rectangle_area = calculate_rectangle_area(length, width)

base = 3
height = 7
triangle_area = calculate_triangle_area(base, height)

반복문으로 중복 제거

shapes = [
    {'type': 'square', 'side': 5},
    {'type': 'rectangle', 'length': 4, 'width': 6},
    {'type': 'triangle', 'base': 3, 'height': 7}
]

areas = []
for shape in shapes:
    if shape['type'] == 'square':
        area = shape['side'] * shape['side']
    elif shape['type'] == 'rectangle':
        area = shape['length'] * shape['width']
    elif shape['type'] == 'triangle':
        area = 0.5 * shape['base'] * shape['height']
    areas.append(area)

print(areas)

위의 예시에서는 도형의 종류와 해당 도형의 속성을 딕셔너리로 나타내고, 함수와 반복문을 사용하여 중복을 제거했습니다. 이를 통해 코드의 가독성이 향상되고, 유지 보수가 용이해집니다.

중첩된 리스트 컴프리헨션

컴프리헨션은 복잡한 리스트, 집합, 딕셔너리 값을 만드는 간결한 방법입니다.

리스트 컴프리헨션

리스트 컴프리헨션은 기존의 리스트를 사용하여 간단하게 새로운 리스트를 생성하는 방법입니다.

먼저 각각의 컴프리헨션 생성 방법부터 보겠습니다!

# 기존 방식
numbers = [1, 2, 3, 4, 5]
squared_numbers = []
for num in numbers:
    squared_numbers.append(num**2)
print(squared_numbers)

# 리스트 컴프리헨션 사용
numbers = [1, 2, 3, 4, 5]
squared_numbers = [num**2 for num in numbers]
print(squared_numbers)

위의 코드는 1부터 5까지의 숫자를 제곱하여 새로운 리스트를 생성하는 예시입니다. 리스트 컴프리헨션을 사용하면 반복문을 사용하지 않고도 간결하게 표현할 수 있습니다.

집합 컴프리헨션

집합 컴프리헨션은 리스트 컴프리헨션과 유사하지만, 중복된 원소를 가지지 않는 집합(set)을 생성합니다.

# 기존 방식
numbers = [1, 2, 2, 3, 3, 4, 5, 5]
unique_numbers = set()
for num in numbers:
    unique_numbers.add(num)
print(unique_numbers)

# 집합 컴프리헨션 사용
numbers = [1, 2, 2, 3, 3, 4, 5, 5]
unique_numbers = {num for num in numbers}
print(unique_numbers)

위의 코드는 중복된 숫자를 제거하여 집합을 생성하는 예시입니다. 집합 컴프리헨션을 사용하면 반복문을 사용하지 않고도 간단하게 중복을 제거할 수 있습니다.

딕셔너리 컴프리헨션

딕셔너리 컴프리헨션은 리스트나 집합과 유사하게, 기존의 딕셔너리를 사용하여 새로운 딕셔너리를 생성하는 방법입니다.

# 기존 방식
numbers = [1, 2, 3, 4, 5]
squared_dict = {}
for num in numbers:
    squared_dict[num] = num**2
print(squared_dict)

# 딕셔너리 컴프리헨션 사용
numbers = [1, 2, 3, 4, 5]
squared_dict = {num: num**2 for num in numbers}
print(squared_dict)

위의 코드는 1부터 5까지의 숫자를 키(key)로 하고, 해당 숫자의 제곱을 값(value)으로 갖는 딕셔너리를 생성하는 예시입니다. 딕셔너리 컴프리헨션을 사용하면 반복문을 사용하지 않고도 간단하게 딕셔너리를 생성할 수 있습니다.

파이썬은 컴프리헨션을 통해 반복문 코드를 한 줄로 줄일 수 있습니다!
또한, 컴프리헨션은 중첩되게 사용될 수도 있습니다.
중첩된 컴프리헨션은 파이썬에서 컴프리헨션을 중첩하여 사용하는 방법입니다. 중첩된 컴프리헨션은 다양한 데이터 구조를 생성하거나 조작할 수 있는 강력한 기능이지만, 가독성과 유지 보수 측면에서 주의해야 할 점이 있습니다.
아래의 예시 코드를 통해 중첩된 컴프리헨션을 보여드리고, 단점에 대해 알려드리겠습니다.

# 중첩된 컴프리헨션 예시
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_matrix = [num for row in matrix for num in row]
print(flattened_matrix)

# 중첩된 컴프리헨션에서의 단점
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
squared_matrix = [[num**2 for num in row] for row in matrix]
print(squared_matrix)

위의 예시 코드에서 첫 번째는 중첩된 컴프리헨션을 사용하여 2차원 리스트인 matrix를 1차원 리스트인 flattened_matrix로 만드는 예시입니다. 두 번째는 matrix의 각 요소들을 제곱하여 새로운 2차원 리스트인 squared_matrix를 생성하는 예시입니다.

중첩된 컴프리헨션의 단점은 다음과 같습니다.

가독성 저하: 중첩된 컴프리헨션을 사용하면 코드가 복잡해지고 가독성이 저하될 수 있습니다. 특히, 여러 단계의 중첩된 컴프리헨션이 있을 경우 이해하기 어려워질 수 있습니다.

디버깅 어려움: 중첩된 컴프리헨션에서 오류가 발생한 경우, 오류를 찾고 수정하기가 어려울 수 있습니다. 오류 발생 지점을 정확히 파악하기 어려우며, 오류가 발생한 중첩 구문을 해체하고 분리하는 작업이 번거로울 수 있습니다.

유지 보수의 어려움: 중첩된 컴프리헨션에서 코드를 수정하거나 기능을 추가하려는 경우, 복잡한 구조로 인해 수정이 어려울 수 있습니다. 새로운 기능을 추가하기 위해 중첩된 컴프리헨션을 수정해야 하므로 코드의 일부를 재구성해야 할 수도 있습니다.

따라서, 중첩된 컴프리헨션을 사용할 때는 코드의 가독성과 유지 보수 가능성을 고려해야 합니다. 너무 복잡한 구조의 중첩된 컴프리헨션은 가독성을 저하시킬 수 있으며, 필요한 경우에는 중첩된 컴프리헨션을 분리하여 가독성을 개선하는 것이 좋습니다.

함수 마지막에는 return 문이 하나만 있어야 한다?

하나의 입구, 하나의 출구 아이디어는 어셈블리어와 포트란 언어로 프로그래밍하던 시절에 나온 조언을 잘못 해석한 데서 비롯된 것입니다.

이러한 언어들은 서브루틴의 어떤 위치에도 진입이 가능하고, 서브루틴 내부에서 어떤 부분이 실행되었는지 디버깅을 하기 어렵게 되어 있습니다.

하지만 파이썬에서나 현재의 프로그래밍 언어들은 함수나 메서드마다 return 문을 하나씩만 유지하려면, 여러 return 문을 유지하는 경우와 비교해 일련의 난해한 if-else 문이 필요하므로 훨씬 더 혼란스럽습니다.

즉! 결론은 함수나 메서드에 return 문이 둘 이상 있어도 괜찮습니다.

플래그 인수는 나쁘다?

무조건적으로 나쁜 것은 아닙니다.

def someFunction(flagArgument):
    if flagArgument:
        # 특정 코드 실행
    else:
        # 완전히 다른 특정 코드 실행

위와 같은 경우에는 함수의 코드의 절반을 실행할지 말지 결정하기보다는 두 개의 함수를 별도로 만드는 것이 좋습니다.
그러나 파이썬의 sorted() 함수는 하나의 정렬 함수에서 오름차순으로 정렬할지, 내림차순으로 정렬하지 결정할 수 있습니다!

바로 플래그 변수를 통해서죠!

class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age
    def __repr__(self):
        return repr((self.name, self.grade, self.age))

student_objects = [
    Student('john', 'A', 15),
    Student('jane', 'B', 12),
    Student('dave', 'B', 10),
]
sorted(student_objects, key=lambda student: student.age)   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

위와 같은 예시 클래스가 주어졌다고 했을 때, 우리는 플래그 변수를 sorted()함수 전달해 오름차순으로 정렬할지, 내림차순으로 정렬할지 결정할 수 있습니다.

sorted(student_tuples, key=itemgetter(2), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sorted(student_objects, key=itemgetter(2), reverse=False)
[('dave', 'B', 10), ('jane', 'B', 12),('john', 'A', 15) ]

reverse의 값을 False로 지정하지 않아도 기본값은 False입니다.

그래서 결론은 플래그 변수가 무조건적으로 나쁜 것은 아니다입니다.

마무리

이렇게 파이썬에 해당되는 코드 악취에 대해서와 오해에 대해서 정리해보았습니다.
제 파이썬 코드 실력도 한 단계 향상됐으면 좋겠습니다.

참고하며 도움을 받은 글

책 - 클린 코드, 이제는 파이썬이다.
파이썬 Document

스프링부트 kotest, mockk

Ambosing — Thu, 01 Jun 2023 15:00:00 GMT

저번에는 테스트를 하는 이유와 좋은 테스트를 하기 위한 조건, 맛보기로 JUnit을 알아보았는데요.
그래도 역시 제가 생각하기엔 코틀린을 사용하시는 분들이라면 kotest를 사용할 것 같습니다.
그래서 이번엔 kotest에 대해서 알아보겠습니다.

TDD, BDD

kotest를 알아보기 앞서 TDD와 BDD의 차이를 알아보겠습니다.
이 차이를 알아보는 것이 앞으로 테스트를 작성하는데 도움이 될 것이기 때문입니다!

아래는 TDD와 BDD의 주요 차이를 마크다운 표로 정리한 것입니다 : )

	TDD (Test-Driven Development)	BDD (Behavior-Driven Development)
목적	코드 품질 향상	소프트웨어 동작 및 행위 강조
중심	개발자 중심	동작 중심
테스트	단위 테스트	기능/행위 테스트
테스트 작성 방식	코드 기반	자연어 스타일
테스트 프레임워크	다양한 테스트 프레임워크 선택 가능	다양한 BDD 프레임워크 선택 가능
테스트 구조화	테스트 스위트, 테스트 그룹 등으로 구조화	시나리오, 스토리 등으로 구조화
테스트 실행 시점	개발 단계 초기에 작성 및 실행	요구사항 및 동작 명세 이해 후 작성 및 실행
대상	코드의 동작 검증	시스템의 행위 및 기능 검증

TDD와 BDD는 접근 방식과 테스트 작성 방법 등에서 차이가 있지만, 상호 보완적인 요소도 많이 가지고 있습니다. 일부 개발자들은 TDD와 BDD를 함께 사용하여 개발하는 경우도 있습니다.

TDD를 했을 때 장점도 분명하지만 아무래도 작성하기 힘들고, 귀찮다는 것이 현실입니다. 그래서 BDD를 사용하면 조금 더 쉽게 테스트를 작성할 수 있습니다.

BDD로 테스트를 작성하는 것은 기획서를 읽어봤을 때 요구사항을 충족시키는 방향으로 작성하면 돼서 TDD보다 작성하기 수월합니다.

그래서 실무에서는 이렇게 사용한다고 합니다.

위의 그림과 같이 BDD와 TDD는 상호보완적으로 그려지는데요. 이는 BDD와 TDD를 함께 활용할 수 있음을 의미합니다.

보통은 Integration 테스트에는 BDD를 사용하게 되고 TDD는 유닛테스트에서 사용한다고 합니다.

Kotest

Kotest는 코틀린(Kotlin) 프로그래밍 언어로 작성된 테스트 프레임워크입니다. 테스트 프레임워크는 개발자가 소프트웨어의 품질을 검증하기 위해 작성하는 테스트 코드를 관리하고 실행하는 데 도움을 주는 도구입니다.

Kotest는 코틀린의 강력한 기능을 활용하여 테스트 코드를 작성하고 실행하는 데 유연성과 간편함을 제공합니다. 다양한 기능을 제공하여 단위 테스트, 통합 테스트, 행위 주도 개발(Behavior-Driven Development, BDD) 스타일의 테스트 등을 지원합니다.

Kotest는 다양한 확장 기능을 제공하여 테스트 환경을 커스터마이징하고 확장할 수 있습니다. 예를 들어, MockK를 사용하여 모의 객체(mock object)를 생성하고 테스트에 활용할 수 있습니다.

Kotest는 개발자 커뮤니티와 지속적으로 발전하고 있으며, 코틀린 생태계에서 인기 있는 테스트 프레임워크 중 하나입니다.

간단한 TDD 예제 코드

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe

class CalculatorTest : StringSpec({

    "더하기 테스트" {
        val calculator = Calculator()
        val result = calculator.add(2, 3)
        result shouldBe 5
    }

    "빼기 테스트" {
        val calculator = Calculator()
        val result = calculator.subtract(5, 3)
        result shouldBe 2
    }
})

class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }

    fun subtract(a: Int, b: Int): Int {
        return a - b
    }
}

위의 코드에서는 Calculator 클래스의 add와 subtract 메서드를 테스트하는 예제입니다. StringSpec을 상속받은 테스트 스펙에서 테스트 케이스를 작성하고, shouldBe 함수를 사용하여 예상 결과와 실제 결과를 비교합니다.

간단한 BDD 예제 코드

import io.kotest.core.spec.style.BehaviorSpec
import io.kotest.matchers.shouldBe

class BankAccountTest : BehaviorSpec({

    given("잔고가 100인 계좌") {
        val bankAccount = BankAccount(100)

        `when`("100을 입금하면") {
            bankAccount.deposit(100)

            then("잔고는 200이어야 한다") {
                bankAccount.balance shouldBe 200
            }
        }

        `when`("50을 출금하면") {
            bankAccount.withdraw(50)

            then("잔고는 50이어야 한다") {
                bankAccount.balance shouldBe 50
            }
        }
    }
})

class BankAccount(initialBalance: Int) {
    var balance: Int = initialBalance

    fun deposit(amount: Int) {
        balance += amount
    }

    fun withdraw(amount: Int) {
        balance -= amount
    }
}

위의 코드에서는 BankAccount 클래스를 BDD 스타일로 테스트하는 예제입니다. BehaviorSpec을 상속받은 테스트 스펙에서 given, when, then을 사용하여 테스트 시나리오를 구조화합니다. 각 시나리오에서 예상 결과와 실제 결과를 shouldBe 함수로 비교합니다.

BDD는 Behavior Spec이나 Feature Spec으로 많이 작성합니다.

간단한 Spring Web Test

Kotest와 Mockk를 사용하여 Controller, Service, 그리고 Repository 레이어의 테스트 코드를 작성하는 예제입니다. 프레임워크는 Spring Boot를 사용했습니다

아래와 같이 UserController, UserService 그리고 UserRepository의 간단한 코드가 있다고 가정하고 테스트 코드를 작성하겠습니다.

class User(val id: Int, val name: String)

interface UserRepository {
    fun getUser(id: Int): User?
}

class UserService(private val userRepository: UserRepository) {
    fun getUser(id: Int): User? {
        return userRepository.getUser(id)
    }
}

@RestController
class UserController(private val userService: UserService) {

    @GetMapping("/user/{id}")
    fun getUser(@PathVariable id: Int): ResponseEntity<User> {
        val user = userService.getUser(id) ?: return ResponseEntity.notFound().build()
        return ResponseEntity.ok(user)
    }
}

이제 각 레이어에 대한 테스트 코드를 작성해 봅시다.

UserControllerTest:

import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity

class UserControllerTest: StringSpec({
    val userService = mockk<UserService>()
    val userController = UserController(userService)

    "만약 유저가 존재한다면 getUser()메서드는 user객체를 반환합니다. " {
        val mockUser = User(id = 1, name = "John Doe")

        every { userService.getUser(1) } returns mockUser

        val response = userController.getUser(1)

        response.statusCode shouldBe HttpStatus.OK
        response.body shouldBe mockUser
    }

    "만약 유저가 존재하지 않다면 getUser() 메서드는 404 에러 메시지를 전달합니다." {
        every { userService.getUser(2) } returns null

        val response = userController.getUser(2)

        response.statusCode shouldBe HttpStatus.NOT_FOUND
    }
})

UserServiceTest:

class UserServiceTest: StringSpec({
    val userRepository = mockk<UserRepository>()
    val userService = UserService(userRepository)

    "getUser() 메서드는 userId에 맞는 user를 반환해야 합니다." {
        val mockUser = User(id = 1, name = "John Doe")

        every { userRepository.getUser(1) } returns mockUser

        userService.getUser(1) shouldBe mockUser
    }

    "getUser() 메서드는 존재하지 않는 유저에 대해서 null을 반환합니다." {
        every { userRepository.getUser(2) } returns null

        userService.getUser(2) shouldBe null
    }
})

UserRepositoryTest: 이것은 보통 데이터베이스와 연결되는 객체이므로, 해당 데이터베이스에서 제공하는 테스트 도구나 라이브러리를 사용하는 것이 일반적입니다. Mocking은 이 경우에는 적합하지 않을 수 있습니다.

추가로, 레포지토리 테스트는 데이터베이스의 연결 상태, 쿼리의 정확성 등에 대한 테스트를 주로 담당하므로 mocking이 아닌 실제 데이터베이스 환경에서의 테스트가 필요할 수 있습니다.

실제 DB 연결하는 Repository Test

아래는 Spring Boot와 Kotest를 사용하여 UserRepository의 테스트를 작성하는 예시입니다! 이번에는 StringSpec이 아닌 FunSpec으로 작성해보겠습니다.

import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.ContextConfiguration

@DataJpaTest
@ContextConfiguration(classes = [UserRepository::class])
class UserRepositoryTest(@Autowired val userRepository: UserRepository): FunSpec({
    test("getUser() 메서드는 userId에 맞는 user를 반환해야 합니다.") {
        val user = User(1, "John Doe") 

        val result = userRepository.getUser(1) // DB에도 User(1, "John Doe")객체가 있다고 가정합니다.
        result shouldBe user
    }

    test("getUser() 메서드는 존재하지 않는 유저에 대해서 null을 반환합니다.") {
        val result = userRepository.getUser(2)
        result shouldBe null
    }
})

이 예제에서는 Kotest의 FunSpec을 사용하여 테스트를 작성했습니다. FunSpec은 각 테스트를 test 함수 내부에 작성하며, 이는 각 테스트를 독립적으로 정의할 수 있게 해줍니다.

또한, Kotest의 matchers 중 하나인 shouldBe를 사용하여 테스트 결과를 검증합니다. 이 matcher는 첫 번째 인자가 두 번째 인자와 같아야 함을 의미합니다.

마지막으로, @DataJpaTest와 @ContextConfiguration 애노테이션을 사용하여 JPA 관련 설정을 로드하고 UserRepository 인터페이스를 통해 데이터베이스와의 상호작용을 테스트합니다.

간단한 통합 BDD 통합 테스트

import io.kotest.core.spec.style.BehaviorSpec
import io.kotest.matchers.shouldBe
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.http.HttpStatus
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest(@Autowired val mockMvc: MockMvc) : BehaviorSpec({

    Given("UserController's `/user/{id}` endpoint") {
        When("유저가 존재할 때") {
            val user = User(1, "John Doe") // DB에 있다고 가정합니다!

            Then("UserId에 해당하는 유저를 반환합니다.") {
                val result = mockMvc.perform(get("/user/1"))
                    .andExpect(status().isOk)
                    .andReturn()

                val responseBody = result.response.contentAsString
                responseBody shouldBe "{\"id\":1,\"name\":\"John Doe\"}"
            }
        }

        When("유저가 존재하지 않을때") {
            Then("404 상태코드를 보냅니다.") {
                val result = mockMvc.perform(get("/user/2"))
                    .andExpect(status().isNotFound)
                    .andReturn()

                result.response.status shouldBe HttpStatus.NOT_FOUND.value()
            }
        }
    }
})

이 예제에서는 Spring Boot의 MockMvc를 사용하여 HTTP 요청을 가상으로 수행하고 응답을 검증합니다. 이를 이용하여 UserController의 /user/{id} 엔드포인트에 GET 요청을 보내고, 사용자가 존재하는 경우와 존재하지 않는 경우에 대해 적절한 응답이 반환되는지 확인합니다.

BDD 스타일의 테스트에서는 Given, When, Then을 이용하여 테스트의 전제조건, 실행할 액션, 그리고 예상 결과를 명시하게 됩니다. 이는 테스트 코드를 읽는 사람이 테스트의 목적과 내용을 이해하는데 도움을 줍니다.

마지막으로, 이 테스트는 실제 데이터베이스에 의존하며 서버를 실행하지 않고 MVC 레이어만을 테스트하기 때문에 통합 테스트에 가깝습니다. 통합 테스트에서는 개별적인 유닛 테스트보다는 더 넓은 범위의 코드를 테스트하게 됩니다.

끝으로

저의 글을 통해서 kotest에 대해서 조금이라도 알게되셨다면 좋겠습니다.
아직은 미숙하지만 앞으로도 좋은 글을 통해서 찾아볼 수 있었으면 좋겠습니다!

참고하며 도움을 받은 글

남경호님의 kotest 글
Kotest docs:Assertions
ifkakao-2020: kotest가 있다면 TDD 묻고 BDD로 가!

저도 공부하면서 적은것이라 행여나 잘못된 것이 있으면 알려주세요!
잘못된 지식을 전파하고 싶지 않습니다!

스프링부트 테스트 이론 & 맛보기 편

Ambosing — Thu, 01 Jun 2023 15:00:00 GMT

테스트 코드의 필요성을 느꼈을 때

회사에서 개발을 하고 있다가 기존 기획과 달라지는 부분이 있어서 기능을 다시 새롭게 만들어야 하는 부분이 있었습니다. 이렇게 수정하면서 리팩토링도 같이 진행을 했었는데 변경된 수정 사항이 엣지 케이스에 동작을 하지 않고 오류가 발생하는 경우가 발생했습니다!
앞으로는 이러한 일이 더 빈번하게 일어날텐데 어떻게 해야할까 고민하던 중에 예전에 리팩토링 책을 읽었을 때 리팩토링을 할 때는 언제나 테스트 코드가 존재해야한다고 들었던 것이 기억이 났습니다.

우리는 왜 테스트 코드를 작성하는가?

바로 이러한 장점들이 있기 때문!!

품질 확인: 테스트 코드는 소프트웨어의 기능이 예상대로 작동하는지 확인하게 해줍니다. 이를 통해 개발자는 버그나 예상치 못한 동작을 빠르게 발견하고 수정할 수 있습니다.
회귀 테스트: 테스트 코드는 새로운 기능을 추가하거나 기존 코드를 변경했을 때 이전에 작동하던 기능이 여전히 잘 작동하는지 확인하는 데 도움이 됩니다. 이를 회귀 테스트라고 하며, 테스트 코드가 없다면 이러한 테스트를 수동으로 수행해야 할 수도 있습니다.
리팩토링: 코드베이스를 정리하거나 개선하는 작업을 리팩토링이라고 합니다. 테스트 코드는 개발자가 리팩토링하는 동안 기능이 여전히 올바르게 작동하는지 확인하는 데 도움이 됩니다.
문서화: 테스트 코드는 종종 코드의 사용법을 설명하는 데 사용됩니다. 개발자가 어떻게 API를 사용해야 하는지 또는 특정 기능이 어떻게 동작하는지 이해하려면 테스트 코드를 읽을 수 있습니다.
신뢰성: 테스트 코드는 사용자와 다른 개발자에게 소프트웨어의 신뢰성을 보여주는 좋은 방법입니다. 테스트 커버리지가 높을수록 코드의 신뢰성이 높다고 간주되며, 이는 개발자와 사용자 모두에게 중요한 특성입니다.
개발 속도 증가: 처음에는 테스트 코드를 작성하는 데 시간이 들 수 있지만, 장기적으로 보면 개발 과정을 가속화할 수 있습니다. 테스트 코드를 통해 빠르게 버그를 발견하고 수정할 수 있으며, 코드 변경의 영향을 쉽게 이해할 수 있습니다.

이러한 이유들로 인해 많은 개발자와 조직들이 테스트 코드 작성을 중요하게 여기며, 테스트 주도 개발(TDD)과 같은 방법론을 따르기도 합니다.

테스트를 작성할 때 꼭 TDD는 해야할까?

언제나 테스트 코드를 작성할 때면 테스트 주도 개발(TDD:Test Driven Development)가 따라오고는 합니다..! 과연 TDD는 꼭 해야하는 걸까요?

테스트 주도 개발(TDD)는 소프트웨어 개발의 하나로, 테스트를 먼저 작성하고 그 테스트를 통과하는 코드를 작성하는 방법을 가르킵니다. 이는 테스트의 중요성을 강조하며, 테스트가 요구 사항의 정의와 동시에 품질을 보장하는 역할을 수행한다는 것을 나타냅니다.

그러나 TDD가 항상 적절한 것은 아닙니다. TDD의 적용 여부는 여러 요인에 따라 달라집니다!

프로젝트의 복잡성: 복잡한 프로젝트에서는 TDD가 매우 유용할 수 있습니다. 테스트를 먼저 작성함으로써 요구 사항을 명확히 이해하고, 코드의 구조와 설계를 개선하며, 향후 버그를 줄일 수 있습니다.
프로젝트의 수명: 장기 프로젝트에서는 TDD가 유용합니다. 코드 변경에 따른 회귀 테스트를 자동화하고, 리팩토링을 용이하게 하며, 코드베이스의 유지 보수를 돕습니다.
팀의 경험: TDD는 적절히 수행하려면 경험이 필요합니다. 팀원들이 TDD에 익숙하지 않다면, 이를 배우고 적용하는데 시간이 필요하며 이로 인해 초기 개발 속도가 느려질 수 있습니다.
프로토타입 개발: 빠르게 프로토타입을 만들어야 하는 경우에는 TDD가 항상 가장 좋은 방법이 아닐 수 있습니다. 이러한 경우에는 프로토타입이 만족스러운 결과를 보일 때까지 빠르게 반복하는 것이 중요하며, 이후에 안정된 버전을 개발하는 동안 TDD를 적용할 수 있습니다.

이처럼 TDD는 유용한 도구이지만, 항상 적용해야 하는 것은 아닙니다. 프로젝트의 특성과 요구 사항, 팀의 경험 등을 고려하여 TDD가 적절한지를 판단해야 합니다.

코틀린 스프링부트 라이브러리

스프링 부트에서 Kotlin을 사용하여 테스트를 작성할 때 주로 사용하는 테스트 라이브러리는 JUnit, Mockito, 그리고 Spring Boot Test입니다. 이 라이브러리들을 사용하면 단위 테스트, 통합 테스트, 그리고 애플리케이션의 전체 라이프사이클을 테스트 할 수 있습니다.
먼저 JUnit부터 간단히 알아봅시다!

JUnit

Java 진영의 대표적인 Test Framework
단위 테스트(Unit Test)를 위한 도구를 제공합니다.

단위 테스트란?
- 코드의 특정 모듈이 의도된대로 동작하는지 테스트하는 절차를 의미합니다.
- 모든 함수와 메소드에 대한 각각의 테스트 케이스를 작성하는 것입니다.

어노테이션을 기반으로 테스트를 지원합니다.
단정문(Assert)으로 테스트 케이스의 기대값에 대해 수행 결과를 확인할 수 있습니다.
JUnit5는 Spring Boot 2.2버전부터 사용합니다.
JUnit5는 Jupiter, Platform, Vintage 모듈로 구성됩니다.

JUnit LifeCycle Annotation

JUnit5는 아래와 같은 테스트 라이프 사이클을 가지고 있습니다.

Annotation	Description
@Test	테스트용 메소드를 표현하는 어노테이션
@BeforeEach	각 테스트 메소드가 시작되기 전에 실행되어야 하는 메소드를 표현
@AfterEach	각 테스트 메소드가 시작된 후 실행되어야 하는 메소드를 표현
@BeforeAll	테스트 시작 전에 실행되어야 하는 메소드를 표현 (static 처리 필요)
@AfterAll	테스트 종료 후에 실행되어야 하는 메소드를 표현 (static 처리 필요)

예시 코드

package com.example.Test

import org.junit.jupiter.api.*
import org.springframework.boot.test.context.SpringBootTest

class TestLifeCycle {
	@BeforeEach
	fun beforeEach() {
		println("## beforeEach 호출")
		println()
	}

	@AfterEach
	fun afterEach() {
		println("## afterEach 호출")
		println()
	}

	@Test
	fun test1() {
		println("## test1 시작")
		println()
	}

	@Test
	@DisplayName("Test 2")
	fun test2() {
		println("## test2 시작")
		println()
	}

	@Test
	@Disabled
	 // Disabled Annotation : 테스트를 실행하지 않게 설정하는 어노테이션
	fun test3() {
		println("## test3 시작")
		println()
	}

	companion object {
		@BeforeAll
		@JvmStatic // 코틀린에서 BeforeAll을 사용하려면 이 어노테이션을!
		fun beforeAll() {
			println("## BeforeAll호출 ")
			println()
		}

		@AfterAll
		@JvmStatic
		fun afterAll() {
			println("## afterAll 호출")
			println()
		}
	}
}

출력 결과

## BeforeAll호출 

## beforeEach 호출

## test1 시작

## afterEach 호출

## beforeEach 호출

## test2 시작

## afterEach 호출

## afterAll 호출

테스트 3는 Disable Annotation 때문에 실행이 되지 않았습니다!

좋은 테스트를 위한 이론!

본격적으로 테스트를 하기 전에 우리는 먼저 알아야되는 것들이 있습니다.
예를들어, BDD라던가 FIRST라던가.. 말이죠!
이를 먼저 이해하는 것이 좋은 테스트를 작성할 때 도움이 될 겁니다!

BDD(Behavior Driven Development, 행위주도개발)

BDD란 행위 주도 개발입니다!

BDD는 TDD를 근간으로 파생된 개발 방법입니다.
TDD에서 한발 더 나아가 테스트 케이스 자체가 요구사항이 되도록 하는 개발 방법입니다.
개발자, 테스터 및 비즈니스 이해 관계자 간의 의사 소통을 강화하고, 기능의 동작과 예상 결과를 예측 가능하게 만듭니다.
테스트 주도 개발(Test-Driven Development, TDD) 및 도메인 주도 설계(Domain-Driven Design, DDD)과 같은 다른 개발 방법론과도 잘 조합될 수 있습니다.

BDD 패턴 및 요소

스토리 (Story): BDD에서는 비즈니스 요구사항을 “스토리”로 표현합니다. 이는 사용자의 관점에서 소프트웨어 기능에 대한 설명이며, 주어진 상황에서 어떤 행동이 기대되는지를 나타냅니다.
시나리오 (Scenario): 각 스토리에는 하나 이상의 시나리오가 포함됩니다. 시나리오는 특정한 상황에서 소프트웨어의 기능과 행위에 대한 구체적인 예시를 제시합니다.
Given-When-Then 구조: BDD에서 시나리오는 “Given-When-Then” 구조로 작성됩니다. 이 구조는 다음과 같이 세 가지 부분으로 나뉩니다
Given: 테스트 환경의 초기 상태를 설정합니다.
When: 사용자의 특정한 행동이 발생했을 때를 정의합니다.
Then: 예상되는 결과를 기술합니다.

@Test
fun `BDD behavior driven development`() {
    // given
    given(calculatorService.add(20.0, 10.0)).willReturn(30.0)

    // when
    val result = calculatorService.add(20.0, 10.0)

    // then
    Assert.assertThat(30.0, CoreMatchers.`is`(result))
}

FIRST

FIRST는 소프트웨어 테스트를 효과적으로 설계하고 구성하기 위한 가이드라인을 제공하는 약어입니다. FIRST는 “Fast, Independent, Repeatable, Self-validating, Timely”의 첫 글자로 구성됩니다. 각각의 원칙은 다음과 같은 의미를 가지고 있습니다..!

Fast (빠르게): 테스트는 빠르게 실행되어야 합니다. 테스트가 느리게 실행되면 개발자들이 테스트를 자주 실행하지 않을 수 있으며, 이는 버그를 빠르게 식별하고 수정하기 어렵게 만들 수 있습니다. 빠른 테스트는 빠른 피드백과 빠른 개발을 가능하게 합니다.
Independent (독립적으로): 각 테스트는 다른 테스트와 독립적으로 실행되어야 합니다. 한 테스트가 다른 테스트에 의존하면 테스트 간에 상호작용이 생기고, 테스트를 이해하고 유지 관리하기가 어려워집니다. 독립적인 테스트는 테스트의 신뢰성을 높이고, 수정 및 재구성이 용이하게 만듭니다.
Repeatable (반복 가능하게): 테스트는 어떤 환경에서도 반복 가능해야 합니다. 테스트가 실행될 때마다 동일한 결과가 나와야 하며, 외부 요소에 의해 영향을 받지 않아야 합니다. 반복 가능한 테스트는 버그를 신속하게 재현하고, 테스트 환경을 변경할 때도 안정적으로 동작합니다.
Self-validating (자체 검증 가능하게): 테스트는 자동으로 판단 가능해야 합니다. 테스트가 수동으로 실행되거나 개발자의 주관에 의존하는 것은 신뢰성과 일관성을 저하시킬 수 있습니다. 자체 검증 가능한 테스트는 예상된 결과를 자동으로 확인하고 판단합니다.
Timely (적시에): 테스트는 적시에 작성되어야 합니다. 테스트는 개발 과정의 초기부터 작성되어야 하며, 개발과 함께 진행되어야 합니다. 테스트를 미루면 버그를 발견하고 수정하는 데 더 많은 비용과 시간이 소요될 수 있습니다.

FIRST 원칙을 따르는 테스트는 신뢰성이 높고 유지 보수가 쉬우며, 효과적인 소프트웨어 개발을 지원합니다. 이러한 원칙을 따르면 테스트의 품질과 가치를 높일 수 있습니다.

Right-BICEP

“RIGHT-BICEP”는 소프트웨어 테스트를 설계하는 데 사용되는 기법 중 하나입니다. 이 기법은 테스트 케이스를 작성하고 실행할 때 고려해야 할 다양한 요소를 나타내는 약어입니다. 각 알파벳은 다음과 같은 의미를 가지고 있습니다!!

Right: 올바른 결과를 얻는지 확인합니다. 이는 소프트웨어가 예상대로 동작하고 정확한 출력을 생성하는지 확인하는 것을 의미합니다.
BICEP:
- Boundary conditions (경계 조건): 입력 데이터의 경계 값을 테스트하여 소프트웨어가 경계 조건에서 올바르게 작동하는지 확인합니다. 이는 최소값, 최대값, 경계값 등과 같이 입력 범위의 경계에 해당하는 값을 테스트하는 것을 의미합니다.
- Incorrect values (잘못된 값): 잘못된 또는 부적절한 값으로 소프트웨어를 테스트하여 예외 상황이나 오류 처리 기능을 확인합니다.
- Inverse relationships (역 관계): 입력 값 사이의 역 관계를 테스트하여 소프트웨어가 정확한 상호 작용을 수행하는지 확인합니다. 예를 들어, A와 B라는 입력 값이 서로 역 관계에 있을 때, A를 변경하면 B에도 적절한 변화가 있는지 테스트합니다.
- Cross-check results (결과 교차 확인): 소프트웨어의 다른 부분 또는 동일한 기능의 대안 구현을 사용하여 결과를 교차 확인합니다. 이를 통해 독립적인 구현 간의 결과 일치성을 검증할 수 있습니다.
- Performance characteristics (성능 특성): 소프트웨어의 성능 요구사항에 맞게 테스트를 수행하여 응답 시간, 처리량, 자원 사용 등과 같은 성능 특성을 확인합니다.

RIGHT-BICEP 기법을 사용하면 다양한 시나리오와 테스트 케이스를 고려하여 소프트웨어를 더 철저하게 테스트할 수 있습니다. 이를 통해 소프트웨어의 정확성, 예외 처리, 상호 작용, 일관성, 성능 등을 평가하고 개선할 수 있습니다.

CORRECT

테스트 이론 중 “CORRECT”는 소프트웨어 테스트를 계획하고 수행하는 데 도움이 되는 가이드라인을 제공하는 메모 기법입니다. 이 기법은 테스트 케이스를 작성하고 검증할 때 고려해야 할 다양한 요소를 나타냅니다. “CORRECT”는 다음과 같은 의미를 가지는 약어입니다

Conformance (일치): 소프트웨어가 요구사항과 규격에 따라 정확하게 동작하는지 확인합니다. 이는 소프트웨어가 정확한 입력에 대해 올바른 결과를 생성하는지를 평가합니다.
Ordering (순서): 소프트웨어의 동작이 올바른 순서로 이루어지는지 확인합니다. 이는 시간, 우선순위, 종속성 등과 같은 다양한 상황에서 소프트웨어가 예상된 순서로 동작하는지를 테스트합니다.
Range (범위): 소프트웨어가 허용된 범위 내에서 정확한 결과를 생성하는지 확인합니다. 이는 입력값의 범위, 데이터 타입의 제약 등과 같은 다양한 조건에서 소프트웨어가 올바른 동작을 수행하는지를 평가합니다.
Reference (참조): 소프트웨어의 동작이 외부 참조나 연관된 구성 요소와 일치하는지 확인합니다. 이는 외부 라이브러리, API, 데이터베이스 등과 같은 참조 요소와의 상호작용을 테스트하여 예상된 동작을 수행하는지를 평가합니다.
Errors (오류): 소프트웨어의 오류 처리 기능을 평가합니다. 이는 잘못된 입력, 예외 상황, 예측할 수 없는 상황 등에 대한 소프트웨어의 오류 처리 능력을 확인하는 것을 의미합니다.
Combinations (조합): 다양한 입력 값의 조합에 대해 소프트웨어가 예상된 동작을 수행하는지 확인합니다. 이는 입력값의 조합이 다양한 경우에 대한 테스트를 수행하여 소프트웨어의 동작을 검증하는 것을 의미합니다.
Tests (테스트): 모든 테스트 케이스가 적절하게 작성되어 소프트웨어를 충분히 커버하는지 확인합니다. 이는 테스트 커버리지를 확인하고 빠뜨린 테스트 케이스가 없는지를 평가합니다.

CORRECT 기법은 테스트의 완전성과 정확성을 높이기 위해 다양한 측면을 고려하여 테스트를 계획하고 수행하는 데 도움을 줍니다. 이를 통해 소프트웨어의 신뢰성과 품질을 향상시킬 수 있습니다.

저도 공부하면서 적은것이라 행여나 잘못된 것이 있으면 알려주세요! 잘못된 지식을 전파하고 싶지 않습니다!

kotest에 대해서 조금 더 알고 싶다면 초코볼의 kotest

Python 정규표현식 정복하기!

Ambosing — Tue, 09 May 2023 15:00:00 GMT

왜 정규표현식을 알아야 하나!?

정규표현식은 문자열을 가공할 때 많이 사용됩니다.
정규표현식을 모르고 사용했을 때 문자열을 파싱하는게 매우 어려웠습니다..
그러므로 모르고 고생하지 말고 이번에 제대로 정복해봅시다!

정규표현식

정규표현식이란?

정규표현식(Regular Expression)은 문자열 패턴을 검색하거나 변경하기 위한 문자열 표현 방법입니다. 문자열 패턴은 일련의 문자열과 특수 문자(메타 문자)로 정의됩니다. 이러한 패턴은 문자열에서 일치하는 문자열 또는 패턴을 찾거나 변경하는 데 사용됩니다.

🟢 정규표현식의 장점

유연성: 정규표현식은 다양한 문자열 패턴을 정의할 수 있으므로, 문자열을 검색하거나 변경할 때 매우 유연합니다.
표현력: 정규표현식은 간결하고 강력합니다. 간단한 패턴에서부터 복잡한 패턴까지 표현할 수 있으며, 이를 통해 효과적인 문자열 처리를 가능하게 합니다.
효율성: 정규표현식은 문자열 처리를 위해 최적화되어 있으므로, 매우 빠르게 문자열을 처리할 수 있습니다.
다양한 언어에서 지원: 대부분의 프로그래밍 언어와 Unix/Linux 명령어에서 정규표현식을 지원하므로, 다양한 환경에서 사용할 수 있습니다.

🔴 정규표현식의 단점

학습 곡선: 정규표현식은 처음에는 이해하기 어려울 수 있습니다. 복잡한 패턴을 작성하려면 일정한 수준의 학습이 필요합니다.
가독성: 매우 복잡한 정규표현식은 이해하기 어려울 수 있습니다. 따라서 코드를 작성할 때 가독성이 저하될 수 있습니다.
불안정성: 매우 복잡한 정규표현식은 정규표현식 엔진에서 불안정성을 유발할 수 있습니다. 이는 처리 속도가 느리거나, 충돌이 발생할 수 있음을 의미합니다.
적용 범위: 정규표현식은 특정한 패턴을 찾는 데 효과적이지만, 모든 문제에 적용할 수 있는 것은 아닙니다. 때로는 다른 방법이 더 효과적일 수 있습니다.

정규표현식을 쓸 때 유용한 곳

문자열 검색: 특정한 문자열을 찾는데 매우 유용합니다. 예를 들어, 이메일 주소, 전화번호, URL 등의 패턴을 검색할 때 사용할 수 있습니다.
문자열 대체: 문자열에서 특정한 문자열을 다른 문자열로 대체할 때 유용합니다. 예를 들어, 특정한 단어나 문장을 다른 단어나 문장으로 대체할 때 사용할 수 있습니다.
입력 유효성 검사: 입력값이 특정한 규칙을 만족하는지 검사할 때 사용됩니다. 예를 들어, 이메일 주소나 비밀번호 등의 입력값이 유효한지 검사할 때 사용할 수 있습니다.
로그 분석: 로그 파일에서 특정한 패턴을 검색하거나, 원하는 정보를 추출할 때 사용됩니다.
데이터 추출: 문자열에서 특정한 데이터를 추출할 때 매우 유용합니다. 예를 들어, HTML 태그에서 특정한 데이터를 추출하는데 사용할 수 있습니다.
파일 이름 필터링: 특정한 파일 이름 패턴을 필터링할 때 사용됩니다. 예를 들어, 특정한 확장자를 가진 파일이나 특정한 파일 이름 패턴을 가진 파일을 찾을 때 사용할 수 있습니다.

자주 쓰이는 정규표현식 패턴

먼저 자주쓰이는 패턴을 학습하고 그 패턴이 어떻게 구성되어 있는지 보겠습니다.
정규표현식 기호 모음은 아래에 서술했으니 아래로 가시면 확인하실 수 있습니다!

📞 전화번호 정규표현식 패턴

import re

# 한국 휴대폰 전화번호 정규표현식 패턴
import re

# 한국 휴대폰 전화번호 정규표현식 패턴
pattern = re.compile(r'010[-]?(\d{3,4})[-]?(\d{4})')

# 텍스트에서 한국 휴대폰 전화번호 찾기
text = "안녕하세요! 저의 전화번호는 010-1234-5678입니다."
match = pattern.search(text)

if match:
    print("찾은 전화번호:", match.group()) # 찾은 전화번호: 010-1234-5678
else:
    print("전화번호를 찾지 못했습니다.")

이 코드는 대시(-)나 공백 문자를 구분자로 사용한 경우도 포함한 휴대폰 전화번호를 찾을 수 있습니다. 텍스트에서 찾은 전화번호를 출력하거나 다른 작업을 수행할 수 있습니다.

이걸 이제 하나씩 뜯어보겠습니다!물론이죠. 정규표현식은 복잡해 보일 수 있지만, 각 부분을 따로 살펴보면 이해하기 쉽습니다. 아래에서 해당 정규표현식 패턴을 하나씩 설명하겠습니다:

r'010[-]?(\d{3,4})[-]?(\d{4})'

r: Python에서 정규표현식 앞에 r 문자를 붙이는 것은 이 문자열이 raw string임을 나타냅니다. 이것은 문자열 내에서 역슬래시\가 이스케이프 문자로 해석되지 않게 하기 위함입니다.
'010: 문자열이 ‘010’으로 시작해야 함을 나타냅니다.
[-]?: 대괄호 [] 내의 문자 중 하나와 일치하며, 이 경우에는 대시 -만 있습니다. 뒤의 물음표 ?는 바로 앞의 문자나 그룹이 0번 또는 1번 나타남을 의미합니다. 즉, 이 표현식은 대시 -가 없거나 한 번만 나타날 수 있음을 나타냅니다.
(\d{3,4}): \d는 숫자를 의미하고, {3,4}는 앞의 문자가 3번 또는 4번 반복될 수 있음을 의미합니다. 따라서 이 부분은 3자리 또는 4자리 숫자를 의미합니다. 괄호 ()는 이 부분을 그룹으로 만들어서, 나중에 이 부분을 따로 참조할 수 있게 합니다.
[-]?: 앞서 설명한 것과 동일하게, 대시 -가 없거나 한 번만 나타날 수 있음을 나타냅니다.
(\d{4}): 이 부분은 4자리 숫자를 의미합니다. 마찬가지로 괄호 ()는 이 부분을 그룹으로 만들어서, 나중에 이 부분을 따로 참조할 수 있게 합니다.

따라서 이 정규표현식은 ‘010’으로 시작하고, 그 다음에는 대시 -가 없거나 있을 수 있고, 그 다음에는 3자리 또는 4자리 숫자가 있으며, 다시 대시 -가 없거나 있을 수 있고, 마지막으로 4자리 숫자가 있는 문자열을 찾습니다.

✉ 이메일 정규표현식 패턴

import re

email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(?:\.[a-zA-Z]{2,})?$'


def is_valid_email(email):
    if re.match(email_pattern, email):
        return True
    else:
        return False


if is_valid_email('example@example.com'):
    print('Valid email') # Valid email
else:
    print('Invalid email')

이메일 주소의 정규표현식 패턴을 하나씩 설명해보겠습니다.

email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(?:\.[a-zA-Z]{2,})?$'

^: 문자열의 시작
[a-zA-Z0-9._%+-]+: 1글자 이상의 영문 대소문자, 숫자, 밑줄(_), 마침표(.), 퍼센트(%), 더하기(+), 하이픈(-)으로 이루어진 문자열
@: @ 기호
[a-zA-Z0-9.-]+: 1글자 이상의 영문 대소문자, 숫자, 마침표(.), 하이픈(-)으로 이루어진 문자열
\.: 마침표(.) 문자
[a-zA-Z]{2,}: 2글자 이상의 영문 대소문자로 이루어진 문자열 (TLD)
(?:\.[a-zA-Z]{2,})?: [a-zA-Z]{2,} 패턴을 또 반복하는데, ?는 0회 또는 1회 반복을 의미합니다. 이를 통해 도메인 이름이 co.kr과 같은 형태일 경우도 매칭할 수 있습니다.
$: 문자열의 끝

이 패턴을 사용하여 검증하려는 이메일 주소가 정규표현식 패턴과 일치하는지 검사할 때는 re 모듈의 search()나 match() 메서드 등을 사용할 수 있습니다.

수식 분리하기

이번에는 제가 코딩테스트 문제를 풀다가 마주했던 문제에 대해서 잠시 설명하겠습니다.
수식이 100-200*300-500+20으로 주어졌을 때 ['100', '-', '200', '*', '300', '-', '500', '+', '20']으로 분리하는 과정이 필요했습니다.
이 때도 정규표현식을 생각하지 못해서 상당히 어렵게 구현했습니다.

import re

expression = '100-200*300-500+20'

tokens = re.split(r'(\D)', expression)
print(tokens)
# ['100', '-', '200', '*', '300', '-', '500', '+', '20']

정규표현식에서 괄호는 그룹을 나타내는 역할을 합니다. 따라서 괄호로 괄호로 둘러싼 부분은 하나의 그룹으로 처리되며, split() 메소드는 그룹을 포함한 구분자를 기준으로 문자열을 분리합니다.
위 코드에서는 \D를 그룹으로 둘러싸서 하나의 그룹으로 처리하였습니다. 따라서 숫자와 숫자가 아닌 문자가 번갈아가면서 그룹을 처리되게 하며, split() 메소드는 이를 구분자로 문자열을 분리합니다.
결과적으로 리스트의 요소는 숫자와 숫자가 아닌 문자가 번갈아가면서 저장됩니다.

위의 코딩테스트 문제

파이썬 정규표현식 re 모듈

Python에서 정규표현식을 사용하기 위해서는 re 모듈을 import하여 사용합니다. 이 모듈에서 제공하는 메서드들과 각 메서드의 예시를 함께 정리해보겠습니다.

문자열의 시작부분부터 패턴이 매치되는지 확인하는 함수(re.match)

re.match(pattern, string)

import re
print(re.match('abc', 'abcdef'))  # <re.Match object; span=(0, 3), match='abc'>
print(re.match('abc', 'abcdefabc'))  # <re.Match object; span=(0, 3), match='abc'>
print(re.match('abc', 'abcdefabcabc'))  # <re.Match object; span=(0, 3), match='abc'>
print(re.match('abc', 'ababcdef'))  # None

이 함수는 매치되면 match 객체를 반환하고, 그렇지 않으면 None을 반환합니다.

문자열 전체에서 패턴이 매치되는 부분을 찾는 함수(re.search)

re.search(pattern, string)

import re
print(re.search('abc', 'abcdef'))  # <re.Match object; span=(0, 3), match='abc'>
print(re.search('abc', 'abcdefabc'))  # <re.Match object; span=(0, 3), match='abc'>
print(re.search('abc', 'ababcdefabc'))  # <re.Match object; span=(2, 5), match='abc'>

처음으로 매치되는 부분의 match 객체를 반환합니다. 매치되는 부분이 없으면 None을 반환합니다.

문자열 전체에서 패턴에 매치되는 모든 부분을 찾아 리스트로 반환하는 함수(re.findall)

re.findall(pattern, string)

import re
print(re.findall('abc', 'abcdefabcabc'))  # ['abc', 'abc', 'abc']

문자열 내에서 패턴에 매치되는 부분을 다른 문자열로 교체하는 함수(re.sub)

re.sub(pattern, repl, string)

import re
print(re.sub('abc', '123', 'abcdefabcabc'))  # '123def123123'

이 외에도 다른 함수들이 많지만 나머지는 python Document를 보시면 될 것 같습니다.

정규식 플래그

파이썬 re 모듈에서 사용되는 주요 정규식 플래그는 다음과 같습니다

플래그	설명
`re.IGNORECASE` 또는 `re.I`	대소문자를 구분하지 않습니다.
`re.MULTILINE` 또는 `re.M`	`^`와 `$` 메타문자를 각각 문자열의 시작과 끝, 그리고 개행문자로 구분된 각 줄의 시작과 끝으로 인식합니다.
`re.DOTALL` 또는 `re.S`	`.` 메타문자가 개행문자를 포함한 모든 문자와 매치되도록 합니다.
`re.VERBOSE` 또는 `re.X`	정규표현식을 더 읽기 쉽게 만들 수 있도록 해주며, 라인을 분리하고 주석을 추가하는 것이 가능합니다.
`re.ASCII` 또는 `re.A`	`\b`, `\B`, `\d`, `\D`, `\s`, `\S`, `\w`, `\W` 등과 같은 특수 문자 시퀀스가 ASCII 문자에 대해서만 작동하도록 합니다.

각 플래그는 re.compile(pattern, flags) 형식의 선택적 flags 매개변수로 전달할 수 있으며, re.match(), re.search() 등의 메소드에서도 사용될 수 있습니다. 또한 플래그를 | 연산자를 사용하여 결합할 수 있습니다. 예를 들어, 대소문자를 구분하지 않으며 여러 줄의 텍스트를 처리하려면 다음과 같이 사용할 수 있습니다:

import re

pattern = re.compile('abc', re.I | re.M)
matches = pattern.findall('ABC\nabc\nAbC')
print(matches)  # ['ABC', 'abc', 'AbC']

정규식 특정 문자 숫자 매칭 패턴

정규식에서 특정 문자나 숫자를 매치하는 데 사용되는 주요 패턴들은 다음과 같습니다

패턴	설명
`\d`	모든 숫자와 일치합니다. `[0-9]`와 동일합니다.
`\D`	숫자를 제외한 모든 문자와 일치합니다. `[^0-9]`와 동일합니다.
`\s`	공백 문자(스페이스, 탭, 줄바꿈 등)와 일치합니다.
`\S`	공백 문자를 제외한 모든 문자와 일치합니다.
`\w`	모든 알파벳 문자, 숫자, 밑줄과 일치합니다. `[a-zA-Z0-9_]`와 동일합니다.
`\W`	`\w`에 해당하는 문자를 제외한 모든 문자와 일치합니다. `[^a-zA-Z0-9_]`와 동일합니다.
`^`	문자열이나 행의 시작 부분과 일치합니다.
`$`	문자열이나 행의 끝 부분과 일치합니다.
`[abc]`	괄호 안의 문자 중 하나와 일치합니다. `a`, `b`, `c` 중 어느 하나와 일치하는 패턴을 의미합니다.
`[^abc]`	괄호 안의 문자들을 제외한 모든 문자와 일치합니다. `a`, `b`, `c`를 제외한 모든 문자와 일치하는 패턴을 의미합니다.
`[a-z]`	지정된 범위 내의 문자 중 하나와 일치합니다. 이 경우 소문자 `a`에서 `z`까지 모든 문자와 일치합니다.
`[A-Z]`	지정된 범위 내의 문자 중 하나와 일치합니다. 이 경우 대문자 `A`에서 `Z`까지 모든 문자와 일치합니다.
`[0-9]`	지정된 범위 내의 문자 중 하나와 일치합니다. 이 경우 숫자 `0`에서 `9`까지 모든 숫자와 일치합니다.

이러한 패턴들을 조합하여 복잡한 문자열 검색 및 처리 작업을 수행할 수 있습니다. 예를 들어, 이메일 주소나 전화번호와 같은 특정 패턴을 가진 문자열을 찾거나, 텍스트에서 특정 형태의 정보를 추출하는 데 이러한 패턴들이 사용됩니다.

정규식 갯수 반복 패턴

정규식에서 검색 기준을 설정하는데 사용되는 주요 패턴들은 다음과 같습니다

패턴	설명
`*`	앞선 문자나 그룹이 0번 이상 반복되는 것과 일치합니다.
`+`	앞선 문자나 그룹이 1번 이상 반복되는 것과 일치합니다.
`?`	앞선 문자나 그룹이 0번 또는 1번 등장하는 것과 일치합니다.
`{n}`	앞선 문자나 그룹이 정확히 `n`번 반복되는 것과 일치합니다.
`{n,}`	앞선 문자나 그룹이 `n`번 이상 반복되는 것과 일치합니다.
`{,n}`	앞선 문자나 그룹이 `n`번 이하 반복되는 것과 일치합니다.
`{n,m}`	앞선 문자나 그룹이 최소 `n`번 이상, 최대 `m`번 이하 반복되는 것과 일치합니다.
`a\|b`	`a` 또는 `b`와 일치합니다.

이러한 패턴들은 텍스트에서 특정 패턴을 가진 문자열을 찾거나 텍스트를 분석하는 데 사용됩니다. 예를 들어, 이메일 주소의 형식이나 전화번호와 같은 특정 패턴을 찾을 때 사용할 수 있습니다. 또한 텍스트에서 특정 형식의 데이터를 추출하는 데도 사용됩니다.

아래는 이 패턴들을 사용한 예제입니다:

import re

# '+'를 사용한 예제
print(re.findall('a+', 'aaaaaabcaaa'))  # ['aaaaaa', 'a', 'aaa']

# '*'를 사용한 예제
print(re.findall('a*', 'aaaaaabcaaa'))  # ['aaaaaa', '', '', '', '', 'a', 'aaa', '']

# '?'를 사용한 예제
print(re.findall('a?', 'aaaaaabcaaa'))  # ['a', 'a', 'a', 'a', 'a', 'a', '', 'a', 'a', 'a', '']

# '{n}'를 사용한 예제
print(re.findall('a{2}', 'aaaaaabcaaa'))  # ['aa', 'aa', 'aa', 'aa']

# '{n,}'를 사용한 예제
print(re.findall('a{2,}', 'aaaaaabcaaa'))  # ['aaaaaa', 'aaa']

# '{,n}'를 사용한 예제
print(re.findall('a{,2}', 'aaaaaabcaaa'))  # ['', 'aa', 'aa', 'aa', '', '', 'aa', 'a', '']

# '{n,m}'를 사용한 예제
print(re.findall('a{2,4}', 'aaaaaabcaaa'))  # ['aaaa', 'aaa']

# '|'를 사용한 예제
print(re.findall('a|b', 'abcd'))  # ['a', 'b']

정규식 그룹화 패턴

정규식에서 그룹을 생성하고 참조하는 데 사용되는 주요 패턴들은 다음과 같습니다

패턴	설명
`( )`	괄호 안의 패턴을 그룹으로 만들어줍니다. 이를 통해 패턴의 일부분을 하나의 단위로 취급할 수 있게 해줍니다.
`\n`	`n`번째 그룹에 해당하는 부분과 동일한 문자열에 일치합니다. `n`은 1부터 시작하는 그룹의 인덱스입니다.
`(?P<name> )`	이름이 `name`인 그룹을 생성합니다.
`(?P=name)`	이름이 `name`인 그룹에 해당하는 부분과 동일한 문자열에 일치합니다.

아래는 이 패턴들을 사용한 예제입니다:

import re

# '( )'를 사용한 예제
pattern = re.compile('(a)(b)(c)')
match = pattern.match('abc')
print(match.group(0))  # 'abc'
print(match.group(1))  # 'a'
print(match.group(2))  # 'b'
print(match.group(3))  # 'c'

# '\n'를 사용한 예제
pattern = re.compile('(a)\\1')
match = pattern.match('aa')
print(match.group(0))  # 'aa'
print(match.group(1))  # 'a'

# '(?P<name> )'와 '(?P=name)'을 사용한 예제
pattern = re.compile('(?P<first>a)(?P=first)')
match = pattern.match('aa')
print(match.group(0))  # 'aa'
print(match.group('first'))  # 'a'

끝으로 마지막 정규표현식을 연습할 수 있는 간단한 문제와 문제집을 남겨놓고 가겠습니다.
백준 모음의 개수
백준 피카츄
정규표현식 문제집

참고 게시글: 인파님 블로그

마크다운 문법 모음집

Ambosing — Mon, 27 Mar 2023 15:00:00 GMT

개인적으로 마크다운 문법 정리 및 블로그 디자인을 하기 위해 올린 게시글입니다.

This is a H1

게시글 제목이 h1이니까 내용 안에서 소제목 작성할땐 h2부터 사용할 것

This is a H2

This is a H3

This is a H4

첫번째
두번째
1. 두번째 안의 첫번째
2. 두번째 안의 두번째
  1. 두번째 안의 두번째 안의 첫번째
세번째
네번째

빨강
분홍
보라
- 녹색
  - 파랑
검정

1단계
- 2단계
  - 3단계
    - 4단계

This is a first blockquote.

This is a second blockquote.

This is a third blockquote.

이것은 인용구입니다

첫번째 각주¹ 두번째 각주²

각주는 어디에 작성하든 페이지 맨 밑에 표시됨, 가로선도 알아서 들어감

ol이랑 ul 섞어 쓰려면 들여쓰기 두번씩 해야됨
순서있는 항목
- 그 안에 순서 없는 항목1
  - 그 안에 또 순서 없는 항목
- 순서 없는 항목2
순서 있는 항목2
1. 그 안에 순서 있는 항목1
  1. 그 안에 또 순서 있는 항목
2. 그 안에 순서 있는 항목2

한줄 this is code 코드

this is code block

this is code block too

기울임꼴 기울임꼴 강조하기 강조하기 ~~취소선~~ 기울이면서 강조하기 기울이면서 강조하기 형광펜 배경

_아래첨자텍스트 ^위첨자텍스트

테이블1	테이블2	테이블3
내용1	내용2	내용3
내용1	내용2	내용3
내용1	내용2	내용3

이건 줄바꿈 안한 문장

줄 바꿈을 하기 위해서는 앞줄 마지막에서 2칸이상을 띄어쓰기해야 한다.
이렇게

리스트에서 줄바꿈 하려면 앞줄 마지막을 2칸 이상 띄우고,
다음 줄도 2칸 이상 들여쓰기 해야함
이렇게!

이미지랑 이미지 캡션넣기

링크 걸기
- 마크다운 문법 참고 사이트1
- 마크다운 문법 참고 사이트2

첫번째 각주↩
두번째 각주 - 각주를 여러줄로 넣고 싶으면,
앞줄 끝에는 2칸, 뒷줄 앞에는 4칸의
공백을 넣을것!↩