![링크](/TIL/assets/img/2024-07-13-HowToWriteATypescriptNodeJSMulti-ThreadedFunction_0.png)

TypeScript과 Node.js는 단일 스레드 및 이벤트 기반 모드에서 작동합니다. 그러나 Node.js에는 특정 시나리오를 위해 멀티 스레딩을 가능하게 하는 Worker Threads 모듈이 제공됩니다. Worker Threads 모듈을 사용하면 TypeScript 코드를 병렬로 실행하여 필요할 때 여러 스레드를 활용할 수 있습니다.

# Node.js에서 멀티 스레딩

단일 스레드 형식 — 기본적으로 Node.js는 TypeScript 코드를 실행하는 데 단일 스레드를 사용합니다. 이 설계는 여러 스레드를 관리하는 복잡성을 피하므로 비동기 작업을 간단하게 처리할 수 있습니다.



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

워커 스레드 모듈 - 워커 스레드 모듈은 Node.js의 기능으로, 개발자가 메인 스레드와 별도로 추가 스레드를 생성할 수 있게 합니다. 이러한 워커 스레드는 TypeScript 코드를 독립적으로 실행하여 작업을 병렬로 처리할 수 있는 방법을 제공합니다.

멀티 스레딩의 사용 사례 - 멀티 스레딩은 CPU 집중형 계산이나 병렬 비동기 작업과 같이 특정 작업을 분할하고 동시에 실행할 수 있는 시나리오에서 유용합니다. 이를 통해 여러 스레드의 처리 능력을 활용하여 응용 프로그램의 전반적인 성능을 향상시킬 수 있습니다.

예제로 넘어가기 전에.... 

# 멀티 스레딩에 대한 추가 고려 사항


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

많은 이유로 멀티스레딩을 피하고 Node.js의 싱글 스레드 특성을 활용하는 것이 좋습니다. 전진하기 전에 고려해야 할 몇 가지 중요한 부분이 있습니다.

스레드 관리 오버헤드: 멀티스레딩은 특정 시나리오에서 성능을 향상시킬 수 있지만, 스레드 관리와 관련된 오버헤드도 동반됩니다. 개발자들은 해당 상황에서 멀티스레딩의 이점이 해당 사용 사례에서의 오버헤드를 상회하는지 신중히 검토해야 합니다.

동시성과 동기화: 여러 스레드로 작업할 때, 개발자들은 동시성과 동기화와 관련된 문제들을 다뤄야 합니다. 이는 공유 리소스를 관리하고 경쟁 조건을 방지하며 스레드 간 데이터 일관성을 보장하는 것을 포함합니다.

확장성: 멀티스레딩은 멀티 코어 프로세서에서 사용 가능한 리소스를 효율적으로 활용할 수 있도록 해 확장성을 향상시킬 수 있습니다. 그러나 멀티스레드 애플리케이션을 확장하기 위해서는 부하 분산 및 리소스 경합과 같은 요소들을 신중히 고려하여 최적의 성능을 달성해야 합니다.


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

디버깅 복잡성: 멀티스레드 응용 프로그램을 디버깅하는 것은 단일 스레드 응용 프로그램보다 얽힌 스레드 상호작용과 잠재적 동시성 문제로 인해 더 도전적일 수 있습니다. 개발자는 쓰레딩 관련 문제를 효과적으로 진단하고 해결하기 위해 전문적인 디버깅 도구와 기술을 사용해야 할 수도 있습니다.

자원 관리: 멀티스레드 응용 프로그램은 단일 스레드 응용 프로그램보다 더 많은 시스템 자원(예: 메모리 및 CPU)을 소비할 수 있습니다. 개발자는 성능 저하와 잠재적 병목 현상을 피하기 위해 자원 사용을 주의 깊게 관리해야 합니다.

잠재적 함정: 멀티스레드로 인해 성능 이점을 얻을 수 있지만, 데드락, 라이브락 및 스레드 기아와 같은 잠재적 함정이 소개될 수도 있습니다. 개발자는 이러한 개념을 이해하고 응용 프로그램 신뢰도와 성능에 미치는 영향을 완화하기 위해 최선의 방법을 사용해야 합니다.

다음은 Worker Threads를 사용한 TypeScript 예시를 제공하겠습니다.


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

```typescript
import { Worker, isMainThread, parentPort } from 'worker_threads';

function runWorkerThread() {
  if (isMainThread) {
    // 이것은 메인 스레드입니다

    // 새로운 워커 스레드를 생성합니다
    const worker = new Worker(__filename);

    // 워커 스레드로부터 메시지를 수신합니다
    worker.on('message', (result: any) => {
      console.log('워커로부터 결과:', result);
    });

    // 워커 스레드로 데이터를 보냅니다
    worker.postMessage({ data: '메인 스레드로부터 안녕하세요!' });
  } else {
    // 이것은 워커 스레드입니다

    // 메인 스레드로부터 메시지를 수신합니다
    parentPort?.on('message', (message: any) => {
      console.log('메인 스레드로부터 메시지:', message);

      // 일부 무거운 계산을 수행합니다
      const result = performHeavyComputation();

      // 결과를 다시 메인 스레드로 보냅니다
      parentPort?.postMessage(result);

      // 워커 스레드를 종료합니다
      parentPort?.close();
    });

    function performHeavyComputation() {
      // 무거운 계산을 시뮬레이션합니다
      let result = 0;
      for (let i = 0; i < 1e9; i++) {
        result += i;
      }
      return result;
    }
  }
}

// 워커 스레드 실행을 위해 함수를 호출합니다
runWorkerThread();
```

이 예시는 메인 스레드와 워커 스레드로 구성된 멀티 스레드 설정을 보여줍니다. 무거운 계산은 워커 스레드에서 수행되고, 그 결과가 메인 스레드로 보내집니다.

워커 스레드를 생성하고 관리하는 로직은 runWorkerThread 함수 내에 캡슐화되어 있습니다. 워커 스레드를 시작하려면 이 함수를 필요할 때 호출할 수 있습니다.

본 내용을 즐기셨고 이러한 노력을 지원하고 싶으시다면 다음 링크를 방문해주세요: [https://ko-fi.com/jacobmacinnis](https://ko-fi.com/jacobmacinnis)

TypeScript 네트워크 서버 구축법 Nodejs 멀티스레드 함수 작성하기

![Tutorial Image](/TIL/assets/img/2024-07-13-TutorialFunctionalProgramminginActionwithTypescript_0.png)

# 소개

내 커리어 초반에 가르쳐진 한 가지는 JavaScript가 객체지향 언어가 아니라는 것이었습니다. 상속보다는 합성을 사용하고 함수(클래스가 아닌)를 일등 시민으로 다루는 것이 더 나은 접근이라는 것이죠. 전체 스택 역할을 하는 Scala가 백엔드 서비스로 사용되는 회사에 들어가니 정말 놀랍더군요. 프로그래밍에 대한 내가 알고 있던 것을 다시 생각해야 했고 Martin Odersky의 목소리를 듣는 데 많은 시간을 보내야 했습니다. 하지만 익숙해지고 나면 한 번도 되돌아보지 않았습니다. 그 이후로 프론트엔드를 위한 몇 가지 FP 트릭을 발견했는데 이를 공유하고 싶습니다.

이 자습서에서는 RxJS, fp-ts 및 io-ts라는 3가지 라이브러리와 그들과 관련된 함수형 프로그래밍 패러다임을 다룰 것입니다. io-ts의 피어 종속성인 fp-ts를 알아야 합니다. 



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

# FP 리프레셔

함수형 프로그래밍은 대학 대수 수업에서 순수 함수에 대한 강의를 떠올리게 합니다. 출력이 제공된 입력에만 의존하는 것이 이를 의미합니다. 이는 데이터의 변이를 피하고 "부작용"이 없도록 하는 것으로 더 예측 가능한 코드를 작성할 수 있습니다. 이것은 불변 변수의 값이 한 번 설정되면 나중에 변경할 수 없다는 점 때문에 때로는 귀찮음이 될 수도 있습니다.

map과 같은 고차 함수는 한 개 이상의 함수를 인수로 받아 새로운 함수를 반환하는데 함수형 프로그래밍에서 기본적인 역할을 합니다. 재사용성과 모듈성을 통해 기반 함수를 설정하고 확장해 나가는 데 더 빠르게 이동할 수 있습니다. 객체 지향 프로그래밍 (OOP)은 데이터 변환 프로세스를 다룰 때 복잡해지는 반면, 싱글톤, 정적 함수 또는 정적 변수를 사용해야 하는지 여부에 대한 문제가 발생할 수 있는 반면, 함수형 프로그래밍은 평이한 함수의 사용을 옹호함으로써 이러한 시나리오를 단순화합니다. 말 그대로 모든 것이 함수입니다

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

# RxJS

이 라이브러리는 특히 클래스 간에 상태 "반응성"을 제공할 수 있는 반응형 프로그래밍 라이브러리로서 인기가 있습니다. 이 라이브러리는 JS의 어떤 값의 변경에 반응하기 위해 채울 수 있는 컨테이너 또는 구조물로 생각할 수 있습니다. 아마도 예상하신 대로, React와 아주 잘 작동하며 훅을 위한 일등 지원을 제공합니다. RxJS의 주요 개념들 중 일부는 공식 문서에서 쉽게 찾을 수 있지만, 여러분의 편의를 위해 여기에 간단히 기재하였습니다:

- Observables: RxJS는 시간이 지남에 따라 값 스트림을 방출하는 함수인 Observables 개념을 중심으로 구축되었습니다. Observables는 함수형 반응형 프로그래밍의 핵심 개념이며, 비동기 작업을 합성 및 선언적인 방식으로 표현할 수 있습니다.
- Operators: RxJS는 Observables을 변환, 필터링, 결합 및 조작하는 데 사용할 수 있는 다양한 방식의 연산자를 제공합니다. Operators는 하나 이상의 observables을 입력으로 사용하고 새로운 observable을 출력으로 반환하는 순수 함수입니다.
- 함수형 프로그래밍의 원칙들: RxJS는 불변성(한 번 생성되면 변경할 수 없음), 조합성(큰 애플리케이션을 위한 작은 구성 요소), 참조 투명성(동일한 입력은 몇 번 호출되었든 동일한 출력을 생성함)과 같은 많은 함수형 프로그래밍 원칙을 따릅니다. Observables 및 연산자는 부작용이 없는 순수 함수이며, 복합하여 복잡한 비동기 작업을 만들 수 있는 선언적인 방식으로 결합될 수 있습니다.

# fp-ts


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

이 라이브러리는 RxJS만큼 인기가 없고 조금 더 복잡합니다. 이 라이브러리는 사용자가 숫자뿐만 아니라 어떤 데이터 유형이든 연결할 수 있는 미리 작성된 함수를 제공합니다.

특징

- 대수적 데이터 유형: fp-ts는 Option, Either, Task 등의 대수적 데이터 유형을 제공하여 복잡한 데이터 구조를 안전하고 조립 가능한 방식으로 표현할 수 있습니다. 대수적 데이터 유형은 함수형 프로그래밍의 핵심 개념으로, null/undefined 오류 및 기타 일반적인 런타임 오류를 피하는 데 도움이 됩니다.
- 타입 클래스: fp-ts는 Functor, Applicative, Monad 등의 타입 클래스를 제공하여 필요한 인터페이스를 구현한 모든 데이터 유형과 작동하는 일반 함수를 정의할 수 있습니다. 타입 클래스는 추상화와 재사용을 위한 강력한 도구이며, 보다 일반적이고 조립 가능한 코드를 작성하는 데 도움이 됩니다.
- 함수형 프로그래밍 원칙: fp-ts는 불변성, 조합성, 참조 투명성 등 많은 함수형 프로그래밍 원칙을 따릅니다. 대수적 데이터 유형과 타입 클래스는 부작용이 없는 순수 함수로, 안전하고 조립 가능한 방식으로 결합하여 복잡한 프로그램을 만들 수 있습니다.

# io-ts


<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개 중 가장 작은 라이브러리이며 TypeScript 코드에 입력 및 출력 도우미를 제공합니다. 일반적인 사용 사례는 API 호출을 보내고 받는 것이지만 오디오 및 비디오와 같은 것들에도 유용합니다.

특징

- 런타임 유형 유효성 검사: io-ts는 데이터 구조에 대한 런타임 유형을 정의하는 방법을 제공하며 정의된 유형과 일치하는 데이터를 자동으로 유효성 검사하고 디코딩할 수 있습니다. 런타임 유형 유효성 검사는 런타임 오류를 방지하고 데이터 일관성을 보장하는 강력한 도구입니다.
- 유형 추론: io-ts는 런타임 유형 정의에서 TypeScript 유형을 추론할 수 있어 IDE에서 중복되는 유형 주석을 작성하지 않고도 유형 안전성 및 자동완성을 얻을 수 있습니다.
- 함수형 프로그래밍 원칙: io-ts는 불변성, 합성성, 참조 투명성과 같은 많은 함수형 프로그래밍 원칙을 따릅니다. 런타임 유형 정의는 부작용이 없는 순수 함수이며 선언적 방식으로 조합하고 재사용할 수 있습니다.

# 리액트로 데모하기


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

모든 세 가지 라이브러리를 사용하는 일반적인 사례는 API 호출을 필요 이상으로 복잡하게 만드는 것입니다. 우리가 일반적인 React.js 컴포넌트에서 어떻게 작동하는지 살펴봅시다.

```js
import React, { useState, useEffect } from 'react';
import { Observable } from 'rxjs';
import { pipe } from 'fp-ts/lib/pipeable';
import { map, fold } from 'fp-ts/lib/Either';
import * as t from 'io-ts';

const ResponseType = t.type({
  data: t.string,
});

const fetchData = (): Observable<t.TypeOf<typeof ResponseType>> => {
  return Observable.create(({ error, next, complete }) => {
    fetch('https://example.com/api/data')
      .then((response) => response.json())
      .then((data) => {
        const result = ResponseType.decode(data);
        pipe(
          result,
          fold(
            error,
            next,
          ),
        );
        complete();
      })
      .catch(error);
  });
};

const MyComponent = () => {
  const [data, setData] = useState({});

  useEffect(() => {
    const subscription = fetchData().subscribe(({ data }) => setData(data));
    return () => {
      subscription.unsubscribe();
    };
  }, []);

  return <div>{data}</div>;
};
```

이 예제에서는 io-ts를 사용하여 예상되는 API 응답의 형태를 나타내는 런타임 타입 ResponseType를 정의합니다. 그런 다음 API 호출을 수행하고 응답의 Observable을 반환하는 fetchData 함수를 정의합니다.

React 컴포넌트에서 useState 훅을 사용하여 검색한 데이터를 추적합니다. 그런 다음 useEffect 훅을 사용하여 fetchData에 의해 반환된 Observable을 구독합니다. 컴포넌트가 마운트될 때 Observable을 구독하고 데이터가 도착하면 검색된 데이터로 상태를 업데이트합니다. 또한 컴포넌트가 마운트 해제될 때 Observable을 구독 취소하여 메모리 누수를 방지합니다.


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

fp-ts의 pipe 함수를 사용하여 API 응답의 디코딩과 결과를 Either로 폴딩하는 작업을 조합합니다. 이를 통해 디코딩 오류와 API 오류를 기능적이고 조합 가능한 방식으로 처리할 수 있습니다.

이제 더 고급 사용 사례를 살펴보고 GraphQL API와 함께 웹 데이터 테이블을 표시하는 방법을 살펴봅시다:

```js
import React, { useState, useEffect } from 'react';
import { pipe } from 'fp-ts/lib/pipeable';
import { map, fold } from 'fp-ts/lib/Either';
import * as t from 'io-ts';
import { ApolloClient, InMemoryCache, gql } from '@apollo/client';
import { Observable } from 'rxjs';

const ResponseType = t.type({
  data: t.type({
    users: t.array(
      t.type({
        id: t.string,
        name: t.string,
        email: t.string,
        phone: t.string,
      }),
    ),
  }),
});

const fetchData = (): Observable<t.TypeOf<typeof ResponseType>> => {
  const client = new ApolloClient({
    uri: 'https://mygraphqlapi.com/graphql',
    cache: new InMemoryCache(),
  });

  const query = gql`
    query {
      users {
        id
        name
        email
        phone
      }
    }
  `;

  return Observable.create(({ error, next, complete }) => {
    client
      .query({ query })
      .then(({ data }) => {
        const result = ResponseType.decode(data);
        pipe(
          result,
          fold(
            error,
            next,
          ),
        );
        complete();
      })
      .catch(error);
  });
};

const UserTable = () => {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    const subscription = fetchData().subscribe(({ data: { users } }) => setUsers(users));
    return () => {
      subscription.unsubscribe();
    };
  }, []);

  return (
    | 표
    | 머리글
    | 승객
    | 별명
    | 전자 메일
    | 전화번호
    | ------
    | ----------
    | -------- 
    | {users.map(({ id, name, email, phone }) => (
      <tr key={id}>
        <td>{id}</td>
        <td>{name}</td>
        <td>{email}</td>
        <td>{phone}</td>
      </tr>
    ))}
    | 
  );
};
```

이 예제에서는 우리의 GraphQL 응답의 예상 모양을 나타내는 io-ts를 사용하여 런타임 유형인 ResponseType을 정의합니다. ApolloClient를 사용하여 GraphQL API에서 데이터를 가져오고 응답의 Observable을 반환하는 fetchData 함수를 정의합니다.


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

우리의 React 컴포넌트에서는 useState 훅을 사용하여 가져온 데이터를 추적합니다. 그런 다음 useEffect 훅을 사용하여 fetchData에 의해 반환된 Observable을 구독합니다. 컴포넌트가 마운트될 때 Observable을 구독하고 데이터가 도착하면 상태를 업데이트합니다. 또한 컴포넌트가 마운트 해제될 때 Observable을 구독해제하여 메모리 누수를 방지합니다.

마지막으로, 가져온 데이터를 사용하여 웹 데이터 테이블을 렌더링합니다. 사용자 배열을 매핑하고 각 사용자에 대한 행을 렌더링하여 ID, 이름, 이메일 및 전화번호를 표시합니다.

# 결론

제 전문 경력의 대부분에서 프로젝트의 핵심 라이브러리와 기술 스택은 일반적으로 제 입성 전에 구현되었습니다. 새로 합류한 팀에게 다른 방향으로 이주할 것을 설득하는 것은 거의 불가능할 수 있습니다. 이미 있는 것에 헌신하고 나아가야 합니다. 그러나 운이 좋으면 JS 코드베이스에 함수형 프로그래밍 패턴과 라이브러리를 소개할 수있는 경우가 있습니다. 그렇게 하면 훨씬 더 행복할 수 있습니다! 프로그래밍 실수로 인해 버그가 발생할 가능성이 적어진다고 (제 의견으로는) 확신합니다.


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

안녕하세요! 궁금한 점, 의견, 뜨거운 이야기가 있으면 아래에 남겨주세요!

튜토리얼 Typescript로 배우는 함수형 프로그래밍 실전 적용법

![Record Type](/TIL/assets/img/2024-07-13-MasteringTypeScriptsRecordType_0.png)

TypeScript의 Record 타입은 우리가 key-value 쌍 타입을 정의하는 데 도움이 되는 매우 유용한 도구입니다. 이 기사에서는 Record 타입의 다양한 응용 시나리오를 탐구하고, 코드 품질과 유지 관리성을 향상시킬 수 있는 방법에 대해 알아보겠습니다.

# 1. Record Type이란 무엇인가요?

Record 타입은 TypeScript에서 내장된 일반적인 제네릭 타입으로, 키와 값이 지정된 타입인 객체 타입을 구성하는 데 사용됩니다. 다음과 같이 정의됩니다:



<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
유형 레코드`K, T`는 그 키가 유형 K이고 값이 유형 T인 개체를 나타냅니다. 간단한 예제를 살펴봅시다:

유형 사용자 = {
  이름: 문자열;
  나이: 숫자;
};

유형 사용자레코드 = 레코드 <문자열, 사용자>;

상수 사용자: 사용자레코드 = {
  사용자1 : { 이름: "앨리스", 나이: 25 },
  사용자2 : { 이름: "밥", 나이: 30 },
};

이 예제에서 UserRecord는 키가 문자열 형식이고 값이 사용자 형식인 개체를 나타냅니다.


<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. 레코드와 튜플의 차이

레코드와 튜플은 TypeScript에서 객체 구조를 정의하는 데 사용되는 도구입니다. 그러나 사용 용도와 특성이 다릅니다.

- 레코드: 키-값 쌍을 정의하는 데 사용되며, 키와 값의 타입이 임의적일 수 있습니다.
- 튜플: 고정된 길이와 타입의 배열을 정의하는 데 사용됩니다.

## 코드 예제:


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

type UserTuple = [string, number]; // 튜플 타입

const userTuple: UserTuple = ["Alice", 25]; // 유효함
// const invalidUserTuple: UserTuple = [25, "Alice"]; // 오류: 타입 불일치

type UserRecord = Record<string, number>;

const userRecord: UserRecord = {
  Alice: 25,
  Bob: 30,
};

# 3. Record과 Map의 차이점

Record와 Map은 모두 키-값 쌍을 저장하는 데 사용될 수 있지만, 중요한 차이점이 있습니다:

- Record: 컴파일 시간에 타입 체크를 위해 사용되는 타입 정의 도구.
- Map: ES6에서 소개된 데이터 구조로, 런타임에서 키-값 쌍을 저장하는 데 사용됨.


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

## 코드 예시:

// Record를 사용
type UserAges = Record<string, number>;

const userAges: UserAges = {
  Alice: 25,
  Bob: 30,
};

// Map 사용
const userAgeMap = new Map<string, number>();
userAgeMap.set("Alice", 25);
userAgeMap.set("Bob", 30);

console.log(userAgeMap.get("Alice")); // 결과: 25

# 4. 모든 경우 다루기

Record 타입을 사용할 때, 모든 가능한 경우를 다루도록 하여 모든 경우에 대해 처리하도록 할 수 있습니다. 특히 유니언 타입을 다룰 때 유용합니다.


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

## 코드 예시:

type Status = "success" | "error" | "loading";

const statusMessages: Record<Status, string> = {
  success: "작업이 성공적으로 완료되었습니다",
  error: "오류가 발생했습니다",
  loading: "로딩 중...",
};

// getStatusMessage 함수를 사용할 때 모든 경우의 수를 처리하도록 보장
function getStatusMessage(status: Status): string {
  return statusMessages[status];
}

이 예제에서 Record`Status, string`은 statusMessages 객체에서 모든 가능한 Status 값이 처리되도록 보장하며, getStatusMessage 함수에서 각 상태 메시지에 안전하게 접근할 수 있게 합니다.

# 5. 제네릭 애플리케이션에서 타입 체킹 강제화


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

Record 유형은 일반 프로그래밍에서 매우 유용하며 키와 값 사이의 일관성을 보장하고 유형 검사를 강제할 수 있게 해줍니다.

## 코드 예시:

function createRecord<K extends string, T>(keys: K[], value: T): Record<K, T> {
  const record: Partial<Record<K, T>> = {};
  keys.forEach(key => {
    record[key] = value;
  });
  return record as Record<K, T>;
}

const record = createRecord(["Alice", "Bob"], 25);
console.log(record); // 결과: { Alice: 25, Bob: 25 }

이 예시에서 createRecord 함수는 키 배열과 값을 가져와 Record 유형을 사용하여 생성된 객체의 키와 값이 일관되도록 보장합니다.


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

# 6. 선택적 타입 매핑을 위해 Pick 타입과 Record 사용하기

특정 속성만 포함된 객체 타입을 만들기 위해 Pick과 Record 타입을 결합할 수 있습니다.

## 코드 예시:

interface User {
  id: number;
  name: string;
  age: number;
  email: string;
}

type UserInfo = Pick<User, "id" | "name">;

type UserInfoRecord = Record<string, UserInfo>;

const userInfo: UserInfoRecord = {
  user1: { id: 1, name: "Alice" },
  user2: { id: 2, name: "Bob" },
};


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

이 예시에서는 사용자 인터페이스에서 id와 name 속성을 선택하기 위해 Pick 타입을 사용하고, Record 타입을 사용하여 이러한 속성을 포함하는 객체 타입을 생성합니다.

# 7. Record를 사용한 동적 Key-Value 사전 구현

Record 타입은 동적 키-값 사전을 구현하기에 적합하며, 특히 동적 키와 값이 필요할 때 유용합니다.

## 코드 예시:


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

type Dictionary<T> = Record<string, T>;

const stringDictionary: Dictionary<string> = {
  key1: "value1",
  key2: "value2",
};

const numberDictionary: Dictionary<number> = {
  key1: 1,
  key2: 2,
};

이 예시에서 Dictionary 타입은 어떤 타입의 key-value 쌍을 저장하는 데 사용할 수 있어 코드를 더 유연하고 일반적으로 만들어줍니다.

# 8. Record와 함께 ReadOnly 사용하기

ReadOnly와 Record 타입을 함께 사용하여 수정할 수 없는 key-value 쌍 객체를 만들 수 있습니다. 이를 통해 객체의 프로퍼티가 수정될 수 없도록 보장합니다.


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

## 코드 예시:

type ReadOnlyUserRecord = Readonly<Record<string, User>>;

const readOnlyUsers: ReadOnlyUserRecord = {
  user1: { name: "Alice", age: 25 },
  user2: { name: "Bob", age: 30 },
};

// readOnlyUsers.user1 = { name: "Charlie", age: 35 }; // 오류: 'user1'에 할당할 수 없습니다. 읽기 전용 속성이기 때문에

이 예시에서는 Readonly와 Record 타입을 결합하여 수정할 수 없는 사용자 레코드 객체를 만들어 객체의 속성을 수정할 수 없도록 보장합니다.

# 9. Record와 Partial 함께 사용하기


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

부분 및 레코드 유형을 결합하여 모든 속성이 선택적인 객체를 만들 수 있어요.

## 코드 예시:

type PartialUserRecord = Partial<Record<string, User>>;

const partialUsers: PartialUserRecord = {
  user1: { name: "Alice", age: 25 },
  user2: undefined, // 속성이 선택적이므로 유효합니다
};

이 예시에서 Partial 및 Record의 결합을 통해 속성이 선택적인 객체를 정의할 수 있어서 부분적인 데이터를 처리하는 데 매우 유용합니다.


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

# 10. Record를 사용하여 모든 속성을 필수로 강제하는 방법

어떤 경우에는 객체의 모든 속성이 필수임을 보장해야 할 수도 있습니다. Required와 Record 타입을 결합하여 이를 달성할 수 있습니다.

## 코드 예시:

interface Config {
  host?: string;
  port?: number;
}

type RequiredConfig = Required<Config>;

type ConfigRecord = Record<string, RequiredConfig>;

const configs: ConfigRecord = {
  dev: { host: "localhost", port: 8080 },
  prod: { host: "example.com", port: 80 },
};

// 'port'가 필수이기 때문에 에러가 발생합니다
// const invalidConfigs: ConfigRecord = {
//   dev: { host: "localhost" }
// };


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

이 예시에서는 Config 객체의 모든 속성이 필수로 입력되도록 Required 및 Record 유형을 사용하여 구성 객체의 완성도를 보장합니다.

이 글을 통해 TypeScript의 Record 유형의 다양한 응용 프로그램 시나리오를 자세히 살펴보았습니다. Record 유형의 기본 정의, Tuple 및 Map과의 차이점, 그리고 실제 응용프로그램에서 코드 가독성과 유지 관리성을 향상시키기 위해 Record 유형을 사용하는 방법에 대해 배웠습니다. 이러한 예시들이 Record 유형을 더 잘 이해하고 적용할 수 있도록 도와드리고 TypeScript 코드를 더 효율적이고 신뢰할 수 있게 만들기를 바랍니다.

TypeScript의 Record 타입 완벽 마스터하기

Airflow 변수 완전 정복하는 방법

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

데이터 시각화는 데이터 작업을 하는 사람들에게 매우 중요한 기술입니다. 이를 통해 복잡한 데이터 세트를 이해하고 결과를 효과적으로 전달할 수 있습니다. Python에서 데이터 시각화에 가장 인기 있는 라이브러리 중 하나인 Matplotlib을 살펴보겠습니다. 동물원 프로젝트와 관련된 코드 예제들은 이러한 개념을 더 잘 이해할 수 있도록 도와줍니다.

# Matplotlib 개요

Matplotlib은 Python 프로그래밍 언어를 위한 플로팅 라이브러리입니다. 일반 GUI 툴킷인 Tkinter, wxPython, Qt 또는 GTK를 사용하여 응용 프로그램에 플롯을 임베딩하기 위한 객체 지향 API를 제공합니다. Matplotlib은 또한 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>

```js
import matplotlib.pyplot as plt
import numpy as np
# 간단한 그래프 예제
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.plot(x, y)
plt.show()
```

출력

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

이 간단한 예제는 Matplotlib을 사용하여 기본 선 그래프를 만드는 방법을 보여줍니다. 그러나 Matplotlib의 강점은 그 유연성과 복잡한 그래프를 만들 수 있는 능력에서 나옵니다.


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

## 그림과 축

Matplotlib에서 그림은 플롯을 구성하는 모든 요소를 포함하는 컨테이너로 생각할 수 있습니다. 축은 '플롯'으로 일반적으로 생각되는 요소로, 데이터 공간을 나타냅니다.

그림

Matplotlib에서 그림은 모든 것이 그려지는 전체 창 또는 페이지입니다. 이 그림에는 서브 축, 제목, 범례 및 레이블이 포함됩니다.


<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
fig = plt.figure()  # 아무 축이 없는 빈 그림
fig, ax = plt.subplots()  # 하나의 축이 있는 그림
fig, axs = plt.subplots(2, 2)  # 2x2 격자 형태의 축이 있는 그림
```

축

이것은 우리가 '플롯'이라고 생각하는 것으로, 데이터 공간이 있는 이미지의 영역입니다. 하나의 그림에는 여러 축이 포함될 수 있지만, 특정 축 객체는 하나의 그림에만 있을 수 있습니다.

```js
fig = plt.figure()
ax1 = fig.add_subplot(211)  # 2행 1열로 구성된 그림에 서브플롯 추가 및 첫 번째 플롯 참조
ax2 = fig.add_subplot(212)  # 2행 1열로 구성된 그림에 서브플롯 추가 및 두 번째 플롯 참조
``` 



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

이제 동물원 프로젝트를 고려해보겠습니다. 다양한 동물과 그 특성에 관한 데이터가 있습니다. 우리는 Matplotlib을 사용하여 이 데이터를 시각화하고 싶습니다.

```js
import pandas as pd
# 동물원 프로젝트용 DataFrame 'df'가 있다고 가정
import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
    'animal': ['lion', 'tiger', 'bear', 'zebra', 'giraffe'],
    'count': [5, 4, 6, 8, 2],
    'average_weight': [190, 220, 300, 250, 800]
})
fig, ax = plt.subplots()
# 동물 수에 대한 막대 그래프
ax.bar(df['animal'], df['count'], color='blue', alpha=0.7, label='Count')
# 평균 무게에 대한 선 그래프, 보조 y-축 사용
ax2 = ax.twinx()
ax2.plot(df['animal'], df['average_weight'], color='red', label='Average Weight')
# 라벨 및 제목
ax.set_xlabel('동물')
ax.set_ylabel('수')
ax2.set_ylabel('평균 무게 (kg)')
plt.title('동물원 동물 통계')
# 범례 표시
fig.legend(loc="upper left", bbox_to_anchor=(0,1), bbox_transform=ax.transAxes)
plt.show()
```

출력

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

이 예제에서는 각 동물의 수를 나타내는 막대 플롯과 각 동물의 평균 체중을 나타내는 라인 플롯을 만들었습니다. 두 가지 다른 양을 나타내기 위해 두 개의 y-축을 사용했습니다.

## 서브플롯 이해하기

서브플롯(subplots)은 동일한 그림 안에 여러 플롯을 만드는 방법입니다. 이것은 그리드 시스템과 같이 생각해볼 수 있습니다. 각 셀에는 플롯이 들어갈 수 있는 격자가 있습니다. 같은 그림 내에서 다수의 플롯을 구조적으로 표시하고 싶을 때 매우 유용합니다. Matplotlib에서는 plt.subplots() 함수를 사용하여 서브플롯을 만듭니다. 전달한 두 인수는 우리의 그리드의 행과 열의 수입니다. 예를 들어, plt.subplots(2, 3)은 2개의 행과 3개의 열을 가진 그리드를 만들어 총 6개의 서브플롯을 얻게 됩니다.

```js
fig, axs = plt.subplots(2, 3)  # 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>

이제 axs는 우리가 조작할 수있는 축 (개별 플롯)를 보유하고있는 2D 배열입니다. 예를 들어, axs[0, 1]은 첫 번째 행과 두 번째 열의 서브플롯에 액세스할 수 있습니다.

## 여러 축

가끔은 서로 다른 스케일이나 단위를 가진 서로 다른 데이터 세트를 동일한 플롯에 그리고 싶을 수 있습니다. 그럴 때 다중 축이 유용합니다.

Matplotlib에서는 twinx() 또는 twiny() 메서드를 사용하여 플롯에 두 번째 축을 추가할 수 있습니다. twinx()는 두 번째 y 축을, twiny()는 두 번째 x 축을 생성합니다.


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

```js
fig, ax1 = plt.subplots()
# 첫 번째 y축에 그리기
ax1.plot(x, y1, color='blue')
ax1.set_ylabel('Y1', color='blue')
# 두 번째 y축 생성 및 그리기
ax2 = ax1.twinx()
ax2.plot(x, y2, color='red')
ax2.set_ylabel('Y2', color='red')
```

결과

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

이 예시에서는 y1과 y2가 동일한 그래프에 표시되지만 각자의 y축을 가지고 있어 서로 다른 척도로 측정할 수 있습니다.


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

## 파이플롯 인터페이스

맷플롯립의 파이플롯 인터페이스는 많은 사람들에게 플로팅의 세계로 들어가는 게이트웨이입니다. MATLAB의 플로팅 기능에서 영감을 받아 직관적이고 사용하기 쉽도록 설계되었습니다. 파이플롯을 사용하면 요소에 대한 정교한 제어가 중요하지 않은 빠르고 간단한 플로팅에 적합한 방식으로 도형과 축을 암시적으로 생성할 수 있습니다.

```python
import matplotlib.pyplot as plt
# 간단한 파이플롯 예시
plt.figure()
plt.plot([1, 2, 3, 4], [10, 20, 25, 30])
plt.title('간단한 플롯')
plt.show()
```

이 코드 조각은 최소한의 번거로움으로 기본 선 플롯을 생성합니다. 그러나 플로팅 요구 사항이 더 복잡해지면 파이플롯 인터페이스의 제약을 느낄 수 있습니다.


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

## 객체 지향 접근 방식

객체 지향(OO) 접근 방식을 소개합니다. 이 방법론은 우리에게 자유를 주며, 플롯의 세부적인 사용자 정의가 가능합니다. Pyplot의 상태 지향에 의존하는 대신, figure 및 axes 객체와 직접 작업합니다. 이는 여러 개의 플롯을 다루거나 플롯 요소를 정확하게 제어해야 할 때 특히 유리합니다.

```js
import matplotlib.pyplot as plt
# 객체 지향 예시
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [10, 20, 25, 30])
ax.set_title('OO 접근 방식 플롯')
plt.show()
```

이 코드 조각에서 우리는 명시적으로 figure와 axes 객체를 생성하여 플롯의 모든 측면을 조정할 수 있습니다.


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

## 왜 Pyplot보다 객체 지향을 선택해야 하는가?

OO 접근 방식은 프로젝트가 더 높은 수준의 정교함을 요구할 때 빛을 발합니다. 예를 들어, 서로 다른 동물들의 식이 요구사항을 시각화해야 하는 동물원 프로젝트에서는 OO 접근 방식을 통해 하위그림을 생성하고 범례를 사용자 정의하며 주석을 쉽게 추가할 수 있습니다.

또한 OO 접근 방식은 확장 가능합니다. 프로젝트가 성장함에 따라 시각화를 유지하고 업데이트하는 것이 더 관리하기 쉬워집니다. 우리는 플롯을 포함한 함수를 만들 수 있고, GUI 애플리케이션에 플롯을 삽입할 수 있으며 등등 많은 기능들을 추가할 수 있습니다.

## Matplotlib의 API: 중추부분


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

Matplotlib의 API는 시각화를 만들기 위한 유연한 접근 방식을 제공하는 클래스의 집합입니다. 객체 지향적이기 때문에 플롯을 마치 작업실의 물리적 객체처럼 거의 그대로 조작할 수 있습니다. 우리는 조정하고 세밀하게 다듬을 수 있어서, 정보를 전달하는 데 그치지 않고 매력적인 시각화를 만들 수 있습니다.

API는 방대하지만, 핵심은 Figure와 Axes 클래스입니다.

가상의 동물원 프로젝트에서 Matplotlib의 API를 적용해 보겠습니다. 다양한 동물들의 일주일 동안의 급식 일정을 시각화해야 한다고 상상해 보세요. 이 작업은 다수의 데이터 시리즈를 처리하고 한눈에 통찰을 제공할 수 있는 세심한 접근이 필요합니다.

Matplotlib의 API로 무대를 설정해 봅시다.


<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 matplotlib.pyplot as plt
import numpy as np
animals = ['사자', '코끼리', '기린', '원숭이']
consumption = np.array([
    [30, 35, 28, 40, 42, 37, 35],  # 사자
    [50, 55, 52, 58, 56, 60, 59],  # 코끼리
    [20, 22, 25, 23, 26, 24, 22],  # 기린
    [10, 15, 12, 17, 16, 14, 13]   # 원숭이
])
```

시각화 만들기

데이터가 준비되었으면, subplots 함수를 사용하여 Figure 및 여러 Axes를 만듭니다. 각 Axes는 일주일의 하루를 나타내며, 각 동물의 식량 소비량을 플롯합니다.


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


fig, axs = plt.subplots(1, 7, figsize=(20, 5), sharey=True)
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
colors = ['red', 'green', 'blue', 'orange']
for i, ax in enumerate(axs):
    for j, animal in enumerate(animals):
        ax.bar(animal, consumption[j][i], color=colors[j])
    ax.set_title(days[i])
fig.suptitle('Zoo Animal Feeding Schedule')
plt.show()


위 코드 블록에서는 매일의 동물별 소비량을 보여주는 막대 차트를 작성했습니다. 공유 y축을 통해 플롯 간 일관성을 유지하고 색상을 사용하여 동물을 구분합니다.

마무리

시각화를 눈에 띄게 만들기 위해 레이블, 범례, 그리고 디자인을 미세조정합니다. Matplotlib의 API를 사용하여 이 작업을 수행할 수 있습니다.



<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
# y 축 레이블 추가
fig.text(0.04, 0.5, '음식 소비량 (kg)', va='center', rotation='vertical')
# 범례 추가
fig.legend(animals, loc='upper right')
# 가독성을 위한 레이아웃 조정
plt.tight_layout(rect=[0.03, 0.03, 1, 0.95])
# 최종 플롯 표시
plt.show()
```

출력

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

더 많은 기사: Seaborn으로 데이터 시각화

Matplotlib를 사용한 데이터 시각화 방법

![Getting Started With Python as a Geoscientist](/TIL/assets/img/2024-07-13-GettingStartedWithPythonasaGeoscientistHereAre5WaysYouCanImproveYourCode_0.png)

여러 해 동안 지질 과학 및 암페트로물리컬 분야에서 다양한 Python 스크립트를 보고 작업해왔습니다. 그동안 다양한 코딩 스타일을 보았고(또는 작성한 적도 있습니다), 잘 구성된 코드에서 문서화가 잘 되어 있는 것부터 모든 내용이 하나의 Python 파일에 있고 거의 구조화되지 않은 것까지 다양합니다. 후자의 경우, 코드를 몇 달 후에 다시 살펴보면 유지, 디버그 및 이해가 어려울 수 있습니다. 적용된 스타일을 결정하는 요구 사항이 종종 코드 작성 목적을 결정합니다.

한 번 또는 두 번 사용될 수 있는 스크립트를 생성하거나 엄격한 시간 제약과 압박 하에 작업할 때는 원하는 만큼 아름답고 조직적으로 작성할 수 없을 수도 있습니다. 그러나 여러 차례 사용하거나 다른 사용자에게 배포하는 코드를 작성하거나 시간이 허락된다면 나중에 확장할 수 있는 방식으로 코드나 앱을 구조화하고 싶을 것입니다. 이렇게 하면 코드를 다시 확인할 때 시간과 머리 아픈 일을 절약할 수 있을 뿐만 아니라 코드가 무엇을 하는지 혹은 무엇을 하려고 했는지 잊는 딜레마를 피할 수도 있습니다.

지질 과학자로서 코딩이 자연스럽지 않을 수 있습니다. 그러나 동료나 친구들이 만들었거나 얘기하는 앱을 보고 시도해보기를 원하는 영향을 받았을 수 있습니다.


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

이 글에서는 몇 년 동안 배운 다섯 가지의 조언을 공유하려고 합니다. 이 조언들은 제 지구과학 Python 애플리케이션을 개선하는 데 도움이 되었고, 처음으로 Python과 머신러닝의 세계로 진입하는 사람들에게도 도움이 될 것입니다.

이 조언은 지구과학자가 아닌 누구에게나 동일하게 적용될 수 있으며, Python을 처음 배우기 시작하는 사람들에게 유용할 것입니다.

# 애플리케이션 폴더 구조 설정

Python 앱을 처음 만들 때 코드를 하나의 폴더에 모두 보관하는 것이 편리하고 쉬울 수 있습니다. 그러나 프로젝트가 성장하고 복잡해지면 코드 베이스를 유지하고 탐색하기가 어려워질 수 있습니다.


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

이 작업을 손쉽게 정리하는 방법은 효과적인 폴더 구조를 만드는 것입니다. 프로젝트가 작은 경우라도 데이터 파일과 출력 또는 임시 파일을 각각의 폴더로 분리하는 것이 유용합니다.

예를 들어, 다음 구조는 데이터 처리, 시각화 및 분석을 위한 특정 기능이 분리된 폴더 집합을 유지합니다. 이를 통해 특정 기능을 자체 파일 내에 저장할 수 있습니다. 이러한 기능들은 main.py 파일에서 필요할 때마다 호출할 수 있습니다.

또한, 데이터 파일은 데이터 하위 디렉토리에 배치할 수 있습니다.


# 간단한 프로젝트 구조 예시
your_project/
├── data_processing/
│   └── data_cleaner.py
├── visualisation/
│   └── plotter.py
├── analysis/
│   └── statistical_model.py
├── data/
│   └── raw_data.csv
└── main.py



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

만약 라이브러리나 플랫폼 전용 어플리케이션(예: Dash)을 개발 중이라면 Cookiecutter와 같은 프레임워크를 살펴볼 가치가 있습니다. 이를 사용하면 여러 미리 정의된 템플릿을 통해 프로젝트 구조를 매우 빠르게 설정할 수 있습니다.

마지막으로, 여러 어플리케이션에서 코드를 재사용할 계획이라면 해당 기능 및 클래스를 저장할 파이썬 라이브러리를 작성하는 것도 고려해보세요.

# 함수와 클래스를 사용하여 재사용 가능한 코드 만들기

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>

함수와 클래스를 통해 코드를 구성하고 기능을 분리하여 반복되는 코드를 줄일 수 있습니다.

## 모듈화된 코드를 위한 함수

함수를 사용하면 호출될 때 실행할 수 있는 코드를 캡슐화할 수 있습니다. 함수에 매개변수를 전달할 수 있으며, 결과를 반환할 수 있습니다.

Python에서 함수를 만들려면 def 키워드를 사용하고, 함수의 이름을 작성한 후, 마지막으로 사용할 매개변수/인수를 지정하면 됩니다.


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

예를 들어, 아래 함수는 대용량 밀도 층의 측정값을 바탕으로 밀도 퇴적률을 계산합니다. 이 함수는 세 개의 매개변수( rho_matrix, rho_bulk 및 rho_fluid )를 입력으로 받아 계산을 수행하고 퇴적률 값을 반환합니다.

```js
def calculate_density_porosity(rho_matrix, rho_bulk, rho_fluid):

    return (rho_matrix - rho_bulk) / (rho_matrix - rho_fluid)
```

## 복잡한 데이터 구조를 다루는 클래스

애플리케이션이 커지거나 복잡한 데이터 구조를 처리해야 하는 경우에는 클래스를 고려할 만한 유용한 도구가 될 수 있습니다.


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

파이썬에서 클래스는 객체(블루프린트와 유사한 것)를 생성하고 객체의 동작 방식을 정의하는 데 사용됩니다. 이는 상태(멤버 변수)의 초기 값과 동작(멤버 함수 또는 메소드의 구현)을 제공함으로써 이루어집니다.

## 재사용 가능한 코드를 위한 최상의 관행

여러분의 애플리케이션에서 재사용 가능한 코드를 만들 때 몇 가지 최상의 관행을 소개합니다.

- 단일 책임 원칙: 각 함수 또는 클래스는 단일 책임 또는 목적을 가져야 합니다. 이렇게 하면 코드가 테스트와 유지보수가 더 쉬워집니다.
- 명확한 명명: 함수나 클래스를 생성할 때 명확한 이름을 가져야 합니다. 이 이름은 그들이 무엇을 하는지 또는 무엇을 나타내는지 명확히 보여주어야 합니다. 명명 규칙에 대한 pep-8 가이드라인을 참고하세요.
- 문서화: 함수와 클래스의 목적과 사용법을 문서화하기 위해 독스트링을 사용하고 최소한의 계산 또는 방법론 출처에 대한 참조를 포함하세요. 이것은 특히 지구과학 분야에서 함수가 복잡한 계산을 수행하는 데 사용될 때 특히 중요합니다. 문서화는 블록 주석, 인라인 주석 및 문서화 문자열을 포함할 수 있습니다. 자세한 내용은 pep- 지침을 확인하세요.
- 모듈화된 디자인: 각 부분(함수 또는 클래스)이 개별적으로 테스트 및 사용될 수 있도록 코드를 설계해야 합니다. 이로 인해 한 두 줄짜리 함수가 나올 수도 있지만 이는 더 큰 코드 조각에 감춰진 코드를 가지는 것보다 낫습니다.


<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 개발자로 시작하는 방법: 지질학자로 시작하기](/TIL/assets/img/2024-07-13-GettingStartedWithPythonasaGeoscientistHereAre5WaysYouCanImproveYourCode_1.png)

스크립트, 함수 또는 클래스를 작성할 때 문서화가 중요합니다. 코드 내에 주석과 문서화 문자열(docstrings)을 작성하면 몇 달 후에 애플리케이션을 다시 방문했을 때 머리 아픔을 예방하는 데 큰 도움이 될 수 있습니다. 또한, 다른 사람들이 코드를 살펴보는 경우에도 코드를 이해하는 데 도움이 될 수 있습니다.

문서화를 통해 코드의 가독성을 개선하는 세 가지 간단한 방법이 있습니다:


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

주석은 코드 섹션 뒤에 있는 아이디어를 설명하거나 복잡한 논리를 분해하거나 코드에 대한 컨텍스트를 제공하는 데 사용됩니다. 주석을 추가하는 아이디어는 코드가 어떻게 작동하는지 설명하는 것이 아니라 코드와 논리 뒤에 있는 '왜'를 설명하는 것입니다.

도움말 문자열은 함수나 클래스가 무엇을 하는지와 함수나 클래스가 요구하는 매개변수가 무엇인지 설명하는 데 사용됩니다. 이는 코드를 사용하는 사람에게 매우 유용합니다.

타입 힌팅은 사용자가 코드를 더 잘 이해할 수 있게 합니다. 이는 주어진 함수나 클래스의 각 매개변수에 대한 데이터 유형이 무엇인지 사용자에게 알려줌으로써 그렇게 합니다.

이전에 본 예제에서는 도움말 문자열을 추가하여 문서를 확장했습니다. 이로써 함수가 무엇을 하는지, 예상되는 각 매개변수가 무엇인지, 예상하는 데이터 유형이 무엇인지 설명합니다.


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

```js
def calculate_density_porosity(rho_matrix: float, rho_bulk: float, rho_fluid: float) -> float:
    """
    Calculates porosity based on bulk density measurements.

    Parameters:
      rho_matrix (float): The rock matrix density.
      rho_bulk (float): The bulk density value.
      rho_fluid (float): The fluid density.
    
    Returns:
      float: The calculated density porosity.
    """
    return (rho_matrix - rho_bulk) / (rho_matrix - rho_fluid)
```

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>

지구과학자로서 학업 과정에서 여러 버전의 에세이 및 논문을 저장하고 dissertation_version1.docx, dissertation_final.docx 또는 dissertation_final_final.docx와 같은 파일 이름을 만드는 데 익숙할 것으로 확신합니다. 이렇게 하면 매우 혼란스러워지고 나중에 파일을 다시 확인할 때 어떤 것이 진정 최종 버전인지 제대로 추적할 수 없게 됩니다.

Git 또는 GitHub와 같은 온라인 시스템과 같은 시스템을 도입하면 미친 듯한 이름의 여러 파일을 만들지 않고도 다른 버전을 추적할 수 있습니다.

또한 프로젝트 작업 중에 만든 변경 사항을 추적하고 싶을 수 있습니다. 이렇게 하면 이전에 작동했던 함수인데도 변경으로 인해 작동이 멈춘 경우 이전에 작동했던 코드로 롤백할 수 있는 가능성이 있습니다.

버전 관리를 도입하면 다음과 같은 작업을 수행할 수 있습니다:


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

- 시간이 지남에 따라 변경 사항을 추적할 수 있습니다.
- 다른 사람과 효과적으로 협력할 수 있습니다.
- 기존 코드를 망가뜨리지 않고 실험할 수 있습니다.
- 그리고 더 많은 기능들

버전 관리의 개념을 이해하고 탐구하기 위한 좋은 안내서를 확인해보세요:

# 작업하는 동안 테스트 생성하기

코드나 애플리케이션을 개발할 때 함수를 수정하는 경우 특히 예상대로 작동하는지 확인해야 합니다.


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

함수를 변경하거나 이에 의존하는 기타 함수들에 대한 어떠한 변경이든 안정성을 확인하는 한 가지 방법은 해당 코드 주변에 테스트를 작성하는 것입니다.

PyTest나 unittest와 같은 여러 Python 테스팅 프레임워크를 사용하면 쉽게 사용할 수 있으며 연속적인 통합 워크플로의 일부로서 자동화할 수도 있습니다.

예를 들어, 아래 코드는 unittest를 사용하고 이전에 본 포로시티 방정식을 감싸는 예시입니다.

```python
import unittest
from your_project.geoscience_calculations import calculate_density_porosity

class TestDensityPorosityCalculation(unittest.TestCase):
    def test_calculate_density_porosity(self):
        self.assertAlmostEqual(calculate_density_porosity(2.65, 2.0, 1.0), 0.39)

if __name__ == '__main__':
    unittest.main()
```


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

이 테스트는 calculate_density_porosity 함수가 rho_matrix, rho_bulk, rho_fluid에 대한 특정 값이 주어졌을 때 밀도 산소포도를 올바르게 계산하는지 확인합니다.

그런 다음 assertAlmostEqual 메서드를 사용하여 예상 값이 반환된 값과 근사하게 일치하는지 확인합니다. 부동 소수점 숫자의 특성 때문에 정확한 동일성을 항상 보장할 수 없을 수 있기 때문입니다.

테스팅에 대해 더 알아보려면 다음 기사를 확인해보세요:

# Summary


<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에 익숙하지 않을 수도 있고, 경력이나 학업 중에 가볍게 다뤄본 적이 있을 수도 있습니다. 하지만 애플리케이션을 개발하는 데 더 능숙해지고 싶어하는 경우에 이 다섯 가지 팁이 도움이 될 것입니다.

파이썬 코딩을 배우는 초기 단계에 있을 때나 현재 기술과 지식을 확장할 때에는 코드가 적절히 문서화되어 있고, 주변에는 테스트가 작성되어 있으며, 조직화된 구조 내에 포함되어 있는지 확인하는 것이 중요합니다. 코드의 규모와 복잡성이 증가할 때, 이후에 발생할 수 있는 시간 손실과 머리 아픔을 줄일 수 있습니다. 버전 관리를 사용하여 모든 변경 사항을 추적하고 친구나 동료들과 쉽게 협업할 수 있도록 할 수 있습니다.

읽어 주셔서 감사합니다. 이 글을 마치시기 전에 꼭 저의 콘텐츠를 구독하고 제 글을 이메일로 받아보세요. 이 곳에서 확인하실 수 있습니다! 또한, 이 콘텐츠를 즐기셨다면 감사의 표시로 몇 번 클랩을 눌러주시면 감사하겠습니다.

Posts