DEVELOPER

[Unity 오류해결] No cloud project ID was found by the Analytics SDK.

gogo5911 — Mon, 26 Feb 2024 13:32:35 +0900

No cloud project ID was found by the Analytics SDK 오류 해결 방법

No cloud project ID was found by the Analytics SDK.This means Analytics events will not be sent. Please make sure to link your cloud project in the Unity editor to fix this problem. 오류가 나타나도 실행에 문제는 없다.

필자는 해당 오류가 2021.3.15f1 3D URP 버전에서 프로젝트를 생성하거나, 다운로드 받은 프로젝트를 열 때 발생했다. 해당 오류는 Unity 프로젝트를 사용하기 위해 프로젝트 ID를 연결하라는 오류이다.

오류 해결 방법은 상당히 간단하다.

1. File > Build Setting > Project Settings > Services 섹션에 들어간다.

2. Organizations의 드롭 박스에서 자신의 ID를 선택한다.

3. Create project ID를 버튼을 클릭한다.

아래와 같이 Services General Settings 화면이 나타나면, 오류가 해결된다.

참고자료

Unity 서비스를 위한 프로젝트 설정 - Unity 매뉴얼

Unity 서비스를 사용하려면 먼저 Unity 프로젝트를 프로젝트 ID에 연결해야 합니다. Unity 에디터 내에서 또는 Unity 개발자 대시보드에서 새로운 프로젝트 ID를 생성할 수 있습니다.

docs.unity3d.com

[Unity 이론] 유니티에 HTTP 통신하는 방법(POST, GET)

gogo5911 — Thu, 15 Feb 2024 20:59:45 +0900

1. www 클래스

WWW 클래스는 유니티에서 제공하는 간단한 방법으로 웹 서버와 통신할 수 있게 해주는 클래스입니다. 웹 페이지의 데이터를 다운로드하거나, 이미지 등을 불러올 때 사용됩니다. 현재 WWW는 유니티에서 권장하지 않고 있습니다.

2. UnityWebRequest 클래스

UnityWebRequest 클래스는 유니티에서 HTTP 통신을 할 수 있게 해주는 클래스입니다. GET, POST 등 다양한 HTTP 요청 방식을 지원하며, 파일 다운로드, 업로드와 같은 작업에도 사용됩니다. 유니티에서 WWW를 사용하기 보다는 UnityWebRequest를 사용하는 권장합니다.

2.1 GET 방식

GET 방식은 주로 서버로부터 정보를 조회하기 위해 사용되는 메서드입니다. 데이터를 요청할 때 필요한 매개변수를 URL의 일부로 포함시켜 서버에 전송합니다. URL에 데이터가 붙기 때문에, 전송할 수 있는 데이터의 크기가 제한적이며, 보안상 민감한 데이터를 전송하기에는 부적합할 수 있습니다.

아래 코드는 UnityWebRequest를 사용하여 GET 요청을 보내는 방법을 보여줍니다. 요청이 성공하면 응답 데이터를 로그로 출력합니다.

using UnityEngine.Networking;

IEnumerator GetRequest(string uri)
{
    using (UnityWebRequest webRequest = UnityWebRequest.Get(uri))
    {
        // 요청 보내기
        yield return webRequest.SendWebRequest();

        if (webRequest.isNetworkError || webRequest.isHttpError)
        {
            Debug.LogError(webRequest.error);
        }
        else
        {
            Debug.Log(webRequest.downloadHandler.text);
        }
    }
}

2.2 POST 방식

POST 방식은 서버의 상태나 데이터를 생성하거나 업데이트하기 위해 사용되는 메서드입니다. 데이터는 요청 본문(body)에 포함되어 서버로 전송되며, URL에는 데이터가 노출되지 않습니다. 이 방식은 더 많은 양의 데이터를 안전하게 전송할 수 있으며, 파일 업로드와 같은 작업에 주로 사용됩니다.

아래 코드는 UnityWebRequest를 사용하여 POST 요청을 보내는 방법을 보여줍니다. postData에는 서버에 전송할 데이터가 포함됩니다.

using UnityEngine.Networking;
using System.Collections;

IEnumerator PostRequest(string uri, string postData)
{
    using (UnityWebRequest webRequest = UnityWebRequest.Post(uri, postData))
    {
        // 요청 보내기
        yield return webRequest.SendWebRequest();

        if (webRequest.isNetworkError || webRequest.isHttpError)
        {
            Debug.LogError(webRequest.error);
        }
        else
        {
            Debug.Log("Form upload complete!");
        }
    }
}

3. UploadHandler

UploadHandler는 UnityWebRequest 시스템 내에서 데이터를 서버로 전송하는 역할을 합니다. 클라이언트에서 서버로 데이터를 "업로드"할 때 사용됩니다. 예를 들어, 사용자가 입력한 데이터를 서버에 POST 요청으로 전송하고자 할 때 UploadHandler를 구성합니다. 또한 유니티에서는 서로 다른 유형의 데이터 업로드를 지원합니다. 여기에는 UploadHandlerRaw, UploadHandlerFile, UploadHandlerFormData가 있습니다. UploadHandlerRaw는 주로 JSON이나 텍스트 데이터를 전송할 때, UploadHandlerFile은 파일을 전송할 때, 그리고 UploadHandlerFormData는 폼 데이터와 파일을 함께 전송할 때 사용됩니다.

3.1 UploadHandlerRaw

UploadHandlerRaw는 바이트 배열 데이터를 원시 형태로 업로드할 때 사용됩니다. 주로 JSON 데이터나 텍스트 데이터를 서버에 전송할 때 사용됩니다. contentType을 설정하여 HTTP 헤더의 Content-Type을 지정할 수 있습니다.

using UnityEngine;
using UnityEngine.Networking;

public class UploadRawDataExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Upload());
    }

    IEnumerator Upload()
    {
        byte[] myData = System.Text.Encoding.UTF8.GetBytes("이것은 테스트 데이터입니다.");
        UnityWebRequest www = new UnityWebRequest("http://www.your-server.com/upload", "POST");
        UploadHandlerRaw uhr = new UploadHandlerRaw(myData);
        uhr.contentType = "application/json";
        www.uploadHandler = uhr;
        www.downloadHandler = new DownloadHandlerBuffer();

        yield return www.SendWebRequest();

        if (www.result != UnityWebRequest.Result.Success)
        {
            Debug.Log(www.error);
        }
        else
        {
            Debug.Log("Upload complete!");
        }
    }
}

3.2 UploadHandlerFile

UploadHandlerFile은 파일을 서버로 업로드할 때 사용됩니다. 이 핸들러를 사용하면 파일의 경로를 지정하여 파일 데이터를 직접 업로드할 수 있습니다.

using UnityEngine;
using UnityEngine.Networking;

public class UploadFileExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Upload());
    }

    IEnumerator Upload()
    {
        string filePath = "path/to/your/file.txt";
        UnityWebRequest www = UnityWebRequest.Put("http://www.your-server.com/upload", filePath);
        www.uploadHandler = new UploadHandlerFile(filePath);

        yield return www.SendWebRequest();

        if (www.result != UnityWebRequest.Result.Success)
        {
            Debug.Log(www.error);
        }
        else
        {
            Debug.Log("File upload complete!");
        }
    }
}

3.3 UploadHandlerFormData

UploadHandlerFormData`는 폼 데이터나 파일을 멀티파트 폼 데이터 형식으로 업로드할 때 사용됩니다. 주로 사용자가 입력한 데이터나 업로드할 파일을 함께 서버에 전송할 때 사용합니다.

using UnityEngine;
using UnityEngine.Networking;
using System.Collections.Generic;

public class UploadFormDataExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Upload());
    }

    IEnumerator Upload()
    {
        List<IMultipartFormSection> formData = new List<IMultipartFormSection>();
        formData.Add(new MultipartFormDataSection("field1=foo&field2=bar"));
        formData.Add(new MultipartFormFileSection("myFile", "이것은 파일 데이터입니다.", "text/plain"));

        UnityWebRequest www = UnityWebRequest.Post("http://www.your-server.com/upload", formData);
        yield return www.SendWebRequest();

        if (www.result != UnityWebRequest.Result.Success)
        {
            Debug.Log(www.error);
        }
        else
        {
            Debug.Log("Form upload complete!");
        }
    }
}

4. DownloadHandler

DownloadHandler는 서버로부터 데이터를 받아 클라이언트로 "다운로드"하는 역할을 합니다. 서버의 응답 데이터를 처리하고, 필요한 형태로 변환하여 애플리케이션에 제공합니다. 또한 유니티에서는 특정 유형의 데이터 처리에 최적화되어 있는 다운로드 핸들러를 제공하고 있습니다. 여기에는 DownloadHandlerBuffer, DownloadHandlerFile, DownloadHandlerAssetBundle 가 있습니다. DownloadHandlerBuffer는 텍스트나 바이너리 데이터 처리에, DownloadHandlerFile은 파일 다운로드에, 그리고 DownloadHandlerAssetBundle은 애셋 번들 다운로드와 관리에 적합합니다.

4.1 DownloadHandlerBuffer

DownloadHandlerBuffer는 서버의 응답을 메모리 버퍼에 저장합니다. 이는 주로 텍스트나 바이너리 데이터를 처리할 때 사용됩니다. 저장된 데이터는 문자열이나 바이트 배열로 추출할 수 있습니다.

using UnityEngine;
using UnityEngine.Networking;

public class DownloadBufferExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Download());
    }

    IEnumerator Download()
    {
        UnityWebRequest www = UnityWebRequest.Get("http://www.your-server.com/data");
        www.downloadHandler = new DownloadHandlerBuffer();

        yield return www.SendWebRequest();

        if (www.result != UnityWebRequest.Result.Success)
        {
            Debug.Log(www.error);
        }
        else
        {
            // 텍스트 데이터로 추출
            string textData = www.downloadHandler.text;
            Debug.Log(textData);
            // 또는 바이트 배열로 추출
            byte[] binaryData = www.downloadHandler.data;
        }
    }
}

4.2 DownloadHandlerFile

DownloadHandlerFile은 서버의 응답을 직접 파일로 저장합니다. 이는 대용량 데이터나 파일을 다운로드할 때 유용합니다. 다운로드 과정에서 메모리 사용량을 최소화할 수 있습니다.

using UnityEngine;
using UnityEngine.Networking;

public class DownloadFileExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Download());
    }

    IEnumerator Download()
    {
        string filePath = "path/to/save/the/file.txt";
        UnityWebRequest www = new UnityWebRequest("http://www.your-server.com/file", UnityWebRequest.kHttpVerbGET);
        www.downloadHandler = new DownloadHandlerFile(filePath);

        yield return www.SendWebRequest();

        if (www.result != UnityWebRequest.Result.Success)
        {
            Debug.Log(www.error);
        }
        else
        {
            Debug.Log("File download complete!");
        }
    }
}

4.3 DownloadHandlerAssetBundle

DownloadHandlerAssetBundle은 애셋 번들을 다운로드하고, 애셋 번들로부터 애셋을 로드할 때 사용됩니다. 애셋 번들은 여러 애셋을 묶어 놓은 컨테이너로, 게임 리소스를 효율적으로 관리할 수 있게 해줍니다.

using UnityEngine;
using UnityEngine.Networking;

public class DownloadAssetBundleExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Download());
    }

    IEnumerator Download()
    {
        string bundleUrl = "http://www.your-server.com/assetbundle";
        UnityWebRequest www = UnityWebRequestAssetBundle.GetAssetBundle(bundleUrl);
        yield return www.SendWebRequest();

        if (www.result != UnityWebRequest.Result.Success)
        {
            Debug.Log(www.error);
        }
        else
        {
            AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(www);
            // 애셋 번들에서 애셋 로드하기
            // 예: bundle.LoadAsset<GameObject>("MyAsset");
        }
    }
}

5. UnityWebRequest의 작업 흐름

클라이언트 설정(Create/Configure) : UnityWebRequest 인스턴스를 생성하고, GET이나 POST 등의 HTTP 메서드를 설정합니다. 필요한 경우 요청 헤더를 추가하고, UploadHandler를 통해 전송할 데이터를 구성합니다.

전송(Send/Abort) : 구성된 요청을 서버로 전송합니다. 전송 과정은 비동기적으로 진행되므로, 게임의 메인 루프에 영향을 주지 않습니다. 전송 중에 요청을 중단할 수도 있습니다.

처리(Receive/Buffer/Process) : 서버로부터의 응답을 받습니다. DownloadHandler를 사용하여 서버의 응답을 적절한 형태로 처리합니다.

완료 : 모든 통신 과정이 완료되면, UnityWebRequest 객체는 사용한 자원을 해제하고, 결과를 반환합니다.

[Unity 입문 강좌 - 9] 유니티 배열과 반복문

gogo5911 — Wed, 7 Feb 2024 15:46:01 +0900

유니티에서 게임 개발을 하면서 다양한 데이터를 관리하고 조작하는 일은 필수적입니다. 이때 배열을 사용하게 되는데, 이는 여러 데이터를 효율적으로 저장하고 관리할 수 있도록 도와줍니다.

1. Array

배열은 동일한 타입의 여러 요소를 순서대로 저장합니다. 배열의 크기는 생성 시 정해지며, 변경할 수 없습니다. 따라서 배열을 사용할 때는 저장하려는 데이터의 개수를 미리 알고 있어야 합니다. 배열 첫 번째 요소의 인덱스는 0, 두 번째 요소의 인덱스는 1, 세 번째 요소의 인덱스는 2, ...이러한 순서로 부여됩니다.

배열의 구조는 아래와 같습니다.

타입 : 배열에 저장할 데이터의 타입입니다. (ex : int, float, string, GameObject..)
배열 이름 : 배열의 이름입니다. 변수 이름 규칙을 따릅니다.
배열 크기 : 배열에 저장할 수 있는 요소의 총 개수입니다. 배열의 크기는 선언 시에 정해지며, 나중에 변경할 수 없습니다.

타입[] 배열이름 = new 타입[배열크기];

아래는 배열에 대한 예시 코드로 int[] array = new int[5];는 크기가 5인 정수형 배열을 선언하고 초기화하는 과정입니다. 이 배열은 array[0]에서 array[4]까지, 총 5개의 정수를 저장할 수 있습니다. 배열의 각 위치에는 array[index] = value; 형태로 특정 값을 할당할 수 있습니다. 배열의 크기 보다 큰 index에 value를 할당하면 오류가 납니다. 그렇기 때문에 꼭 배열의 크기에 맞게 값을 할당해야합니다.

// 배열 선언과 초기화
int[] array = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;

for 반복문을 사용한 순회 방식에서는 배열의 길이(array.Length)를 이용하여 각 요소에 접근합니다. foreach 문을 사용하면 배열의 각 요소에 보다 간결하게 접근할 수 있습니다. 이 방식은 배열의 길이를 직접 관리할 필요가 없어 코드가 더욱 간단하고 가독성이 높아집니다.

// 배열 순회
for (int i = 0; i < array.Length; i++) {
    Debug.Log(array[i]);
}

foreach (int item in array) {
    Debug.Log(item); 
}

배열은 고정된 크기를 가지고 있기 때문에, 일단 생성되면 실행 중에 크기를 변경하는 것이 불가능합니다. 따라서 배열에 직접적으로 요소를 추가하거나 제거하는 작업은 지원되지 않습니다. 만약 배열로 꼭 요소를 추가하거나, 제거하려면 다음과 같은 방법을 사용할 수 있습니다. 그러나, 이 방법은 효율적이지 않습니다.

요소 추가하기 : 새로운 배열을 생성하고, 기존 배열의 모든 요소를 새 배열로 복사한 다음, 새 요소를 마지막 위치에 추가합니다.

// 기존 배열
int[] array = new int[5] { 1, 2, 3, 4, 5 };
// 새로운 요소
int newElement = 6;
// 새 배열 생성: 기존 배열 길이 + 1
int[] newArray = new int[array.Length + 1];
// 기존 배열 요소를 새 배열로 복사
for (int i = 0; i < array.Length; i++) {
    newArray[i] = array[i];
}
// 새 요소 추가
newArray[newArray.Length - 1] = newElement;

요소 제거하기 : 새로운 배열을 생성하고, 제거하고 싶지 않은 요소만을 새 배열에 복사합니다.

// 기존 배열
int[] array = new int[5] { 1, 2, 3, 4, 5 };
// 제거할 요소의 인덱스 (예: 첫 번째 요소)
int removeIndex = 0;
// 새 배열 생성: 기존 배열 길이 - 1
int[] newArray = new int[array.Length - 1];
// 새 배열에 복사할 때 제거할 인덱스를 건너뛰기
for (int i = 0, j = 0; i < array.Length; i++) {
    if (i != removeIndex) {
        newArray[j++] = array[i];
    }
}

1.1 다차원 배열

다차원 배열은 데이터를 행렬이나 그 이상의 다차원 구조로 저장하고 관리할 수 있게 해줍니다. 유니티에서도 다차원 배열을 사용하여 더 복잡한 데이터 구조를 표현할 수 있습니다. 다차원 배열은 주로 2차원 배열과 3차원 배열을 사용합니다.

1.2 2차원 배열

2차원 배열은 데이터를 행과 열의 형태로 구성하여 관리합니다. 예를 들어 게임 맵의 그리드나 스프레드시트 데이터를 저장할 때 사용할 수 있습니다.

타입 : 배열에 저장할 데이터의 타입입니다.
배열이름 : 배열의 이름입니다.
행의수, 열의수 : 배열의 행과 열의 개수입니다.

타입[,] 배열이름 = new 타입[행의수, 열의수];

아래 예제에서 배열은 2행 3열의 정수를 저장할 수 있도록 했습니다. 배열의 각 위치에는 array[index, index] = value; 형태로 특정 값을 할당할 수 있습니다. 다차원 배열을 사용할 때는 반복문을 중첩하여 각 차원을 순회할 수 있습니다.

int[,] matrix = new int[2, 3];

matrix[0, 0] = 1; // 첫 번째 행, 첫 번째 열
matrix[0, 1] = 2; // 첫 번째 행, 두 번째 열
// 나머지 요소에도 값을 할당할 수 있습니다.

for(int i = 0; i < matrix.GetLength(0); i++) // 행을 순회
{
    for(int j = 0; j < matrix.GetLength(1); j++) // 열을 순회
    {
        Debug.Log(matrix[i, j]);
    }
}

1.3 3차원 배열

3차원 이상의 다차원 배열도 비슷한 방식으로 선언하고 사용할 수 있습니다. 이러한 배열은 더 복잡한 데이터 구조를 표현할 때 사용됩니다. 예를 들어 3D 게임의 공간 데이터를 저장하는데 사용될 수 있습니다.

타입[,,] 배열이름 = new 타입[깊이, 행의수, 열의수];

이 배열은 2개의 깊이, 각 깊이에 3행 4열의 정수를 저장할 수 있습니다.

// 3차원 배열을 선언합니다. 예를 들어, 2x3x4 크기의 배열
int[,,] matrix3D = new int[2, 3, 4];

// 배열에 값을 할당합니다.
// 예를 들어, 첫 번째 "깊이"에 값을 할당합니다.
matrix3D[0, 0, 0] = 1;
matrix3D[0, 0, 1] = 2;
matrix3D[0, 0, 2] = 3;
matrix3D[0, 0, 3] = 4;

matrix3D[0, 1, 0] = 5;
matrix3D[0, 1, 1] = 6;
matrix3D[0, 1, 2] = 7;
matrix3D[0, 1, 3] = 8;

matrix3D[0, 2, 0] = 9;
matrix3D[0, 2, 1] = 10;
matrix3D[0, 2, 2] = 11;
matrix3D[0, 2, 3] = 12;

// 다른 "깊이"에도 유사하게 값을 할당할 수 있습니다.
// 예를 들어, 두 번째 "깊이"
// 이를 위해 반복문을 사용하는 것이 효율적입니다.

// 모든 요소를 순회하여 값을 출력합니다.
for (int i = 0; i < matrix3D.GetLength(0); i++) // 첫 번째 차원 (2)
{
    for (int j = 0; j < matrix3D.GetLength(1); j++) // 두 번째 차원 (3)
    {
        for (int k = 0; k < matrix3D.GetLength(2); k++) // 세 번째 차원 (4)
        {
            Debug.Log($"Value at ({i}, {j}, {k}) = {matrix3D[i, j, k]}");
        }
    }
}

[Unity 이론] 유니티에서 ref와 out 키워드 사용방법과 차이점

gogo5911 — Tue, 6 Feb 2024 22:47:26 +0900

유니티 개발에서 C#의 ref와 out 키워드는 함수 인자를 다룰 때 중요한 역할을 합니다. 이 두 키워드를 이해하고 올바르게 사용하는 것은 유니티 게임 개발의 효율성을 크게 향상시킬 수 있습니다. 이 글에서는 ref와 out 키워드의 개념을 설명합니다.

1. ref 키워드

ref 키워드는 메서드에 변수를 참조로 전달할 때 사용됩니다. 이를 통해 메서드 내에서 인자의 값을 변경하면, 그 변경사항이 메서드를 호출한 곳에서도 반영됩니다. 즉, ref를 사용하면 메서드가 인자로 받은 변수 자체를 직접 수정할 수 있습니다.(참조로 전달한다는 것은 변수의 실제 메모리 위치를 전달한다는 의미로, 메서드 내에서 변수의 값을 변경하면 원본 변수에도 그 변경사항이 반영됩니다.)

아래 예제에서 보면 TakeDamage 메서드는 health 변수를 참조로 받아, 실제 변수의 값을 변경합니다. 따라서 메서드 호출 후 health 변수의 값은 70으로 감소된 것을 볼 수 있습니다.

using UnityEngine;

public class RefExample : MonoBehaviour
{
    void Start()
    {
        int health = 100;
        TakeDamage(ref health, 30);

        Debug.Log($"After taking damage: {health}"); // health 값은 70이 됩니다.
    }

    void TakeDamage(ref int health, int damage)
    {
        health -= damage;
    }
}

2. out 키워드

out 키워드는 메서드에서 값을 반환할 때 사용되며, 주로 메서드가 여러 값을 반환해야 할 때 유용합니다. out을 사용하는 변수는 메서드 내에서 반드시 초기화되어야 합니다.

아래 예제에서 보면 TryMultiply 메서드는 두 수의 곱셈 결과를 out 파라미터를 통해 반환합니다. 이 방식을 사용하면, 메서드가 성공적으로 실행되었는지를 나타내는 부울 값과 함께 추가적인 결과값을 반환할 수 있습니다.

using UnityEngine;

public class OutExample : MonoBehaviour
{
    void Start()
    {
        int result;
        if(TryMultiply(10, 5, out result))
        {
            Debug.Log($"Multiplication result: {result}"); // 결과는 50입니다.
        }
    }

    bool TryMultiply(int a, int b, out int result)
    {
        result = a * b;
        return true; // 단순 예제를 위해 항상 true를 반환합니다.
    }
}

3. ref와 out의 주요 차이점

ref는 메서드로 전달되기 전에 초기화되어야 합니다. 반면, out 파라미터는 메서드 내에서 초기화되어야 합니다.
ref는 기존 변수의 데이터를 메서드 내부로 가져와서 변경할 수 있도록 합니다. out은 메서드가 결과를 외부로 출력하는 데 사용됩니다.

[Unity 이론] 유니티에서 new 키워드를 사용하는 이유

gogo5911 — Mon, 5 Feb 2024 21:32:22 +0900

유니티(Unity)에서 new 키워드를 사용하는 이유는 객체 지향 프로그래밍(OOP)의 핵심 원리 중 하나인 인스턴스화를 구현하기 위함입니다. new 키워드는 새로운 객체를 생성하고, 해당 객체의 메모리를 할당하는 데 사용됩니다.

메모리와 객체 생성

프로그래밍에서 메모리는 작업 공간으로 이해할 수 있습니다. 이 작업 공간에 데이터를 저장하고, 필요할 때마다 접근하여 사용합니다. new 키워드의 사용은 메모리 상에 새로운 객체, 즉 인스턴스를 생성한다는 의미입니다. 예를 들어, Dog라는 클래스의 인스턴스를 생성하기 위해 new Dog()라고 작성하면, 유니티는 메모리 상에 Dog 객체를 위한 공간을 할당하고, 그 객체를 사용할 수 있게 됩니다. 이 과정에서 dog라는 변수에 객체의 메모리 주소가 저장되며, 이 변수를 통해 객체에 접근할 수 있습니다.

기본형 타입과 참조형 타입

프로그래밍 언어는 크게 기본형 타입(primitive types)과 참조형 타입(reference types)으로 데이터 타입을 구분합니다. int, float와 같은 기본형 타입은 new를 사용하지 않아도 자동으로 지역 메모리에 할당되며, 이들은 값 자체를 저장합니다. 반면, Dog와 같은 사용자 정의 타입은 참조형 타입에 속하며, 이 경우 new를 사용하여 명시적으로 메모리에 할당해야 합니다. 참조형 타입은 메모리 상의 객체에 대한 참조, 즉 주소를 저장합니다.

기본형 타입 예시 (C#)

코드에서 int와 float는 기본형 타입으로, 변수 number와 rate에 각각의 값이 직접 저장됩니다. 여기서 new 키워드는 필요하지 않습니다.

int number = 10;
float rate = 5.5f;

참조형 타입 예시 (C#)

여기서 Dog는 사용자가 정의한 클래스이며, new Dog()를 통해 Dog 타입의 객체를 메모리에 할당하고, myDog 변수에 그 주소를 저장합니다. 이를 통해 myDog 변수를 사용하여 Dog 객체에 접근할 수 있습니다.

Dog myDog = new Dog();

Static 멤버와 메모리 할당

클래스 내의 메서드나 변수가 static으로 선언된 경우, 이들은 프로그램 시작 시 자동으로 메모리에 할당됩니다. 이는 Dog.Bark()와 같이 타입 이름만으로 해당 메서드를 호출할 수 있음을 의미합니다. static 멤버는 클래스의 인스턴스가 아니라 클래스 자체에 속하며, 모든 인스턴스가 공유하는 하나의 공간에 할당됩니다.

Static 멤버 예시 (C#)

예제에서 Bark 메서드는 static으로 선언되어 있기 때문에, Dog 클래스의 인스턴스를 생성하지 않고도 Dog.Bark()를 호출할 수 있습니다.

public static void Bark()
{
    Debug.Log("Woof!");
}

void Start()
{
    Dog.Bark(); // 인스턴스 생성 없이 직접 호출
}

선택적 탐색(Selective Search) 알고리즘 : 컴퓨터 비전에서의 물체 탐색 알고리즘

gogo5911 — Sun, 4 Feb 2024 20:15:51 +0900

1. Selective Search란?

선택적 탐색(Selective Search)은 컴퓨터 비전에서 사용되는 알고리즘 중 하나로, 이미지 내에서 물체를 탐색하는데 사용됩니다. 이 알고리즘은 이미지 내의 가능한 모든 물체의 위치를 찾아내는 '영역 제안(Region Proposal)' 과정을 통해 작동합니다.

선택적 탐색은 다음과 같은 순서로 작동합니다.

이미지 세그멘테이션 : 먼저, 이미지는 작은 지역들로 분할(세그멘테이션)됩니다. 이러한 세그멘테이션은 이미지의 각 부분이 어떻게 서로 연관되어 있는지를 파악하는데 도움을 줍니다.
영역 제안 생성 : 다음으로, 유사한 세그먼트들이 그룹화되어 더 큰 영역을 형성합니다. 이러한 영역은 물체가 위치할 수 있는 잠재적인 위치를 나타냅니다.
유사성 계산 : 마지막으로, 각 영역 간의 유사성이 계산됩니다. 이를 통해 각 영역이 얼마나 유사한지를 파악하고, 유사한 영역들을 병합하여 더 큰 영역을 형성합니다. 이렇게 생성된 영역들은 물체 탐지 알고리즘에 전달되어 사용됩니다.

2. 선택적 탐색의 작동 원리

2.1 이미지 세그멘테이션

이미지 세그멘테이션은 디지털 이미지를 여러 세그먼트(부분)으로 나누는 과정을 의미합니다. 이러한 세그먼트는 의미있는 정보를 포함하는 이미지의 영역을 나타냅니다. 즉, 세그멘테이션은 이미지 내의 관심 영역을 정의하거나 표시하는 데 사용됩니다.

선택적 탐색에서의 이미지 세그멘테이션은 '과잉 세그멘테이션'(over-segmentation)이라고도 불리는 초기 단계입니다. 이 단계에서 이미지는 아주 작은 지역들로 분할되며, 이들 각각은 개별 픽셀 또는 픽셀 그룹을 나타냅니다. 이러한 과잉 세그멘테이션의 목표는 가능한 모든 물체와 그 배경을 포착하는 것입니다.

이런 과정에서 사용하는 알고리즘은 Felzenszwalb and Huttenlocher의 방법이나 Mean-Shift와 같은 방법이 일반적입니다. 이러한 방법들은 각각의 픽셀이나 픽셀 그룹에 대해 색상, 질감, 방향 등의 특징을 이용하여 유사한 특징을 가진 그룹들을 세그먼트로 묶습니다. 따라서 이미지 세그멘테이션은 이미지의 전체적인 구조를 이해하고, 그 안에 있는 물체나 특징을 식별하는 데 근본적으로 중요한 단계입니다.

2.2 영역 제안 생성

영역 제안 생성은 이미지 세그멘테이션 후에 이루어지는 과정입니다. 이 과정에서는 초기에 생성된 세그먼트들을 조합하여 이미지의 보다 큰 부분을 나타내는 "영역 제안" 또는 "영역 후보"를 만들어냅니다. 이러한 영역 제안들은 원래 이미지에서 물체가 존재할 가능성이 있는 위치와 크기를 나타냅니다.

선택적 탐색에서는 유사한 세그먼트들을 하나의 그룹으로 병합하는 방식으로 이를 수행합니다. 이 때 유사성은 색상, 질감, 크기 및 형태 등의 특징을 기반으로 계산됩니다. 예를 들어, 두 세그먼트가 비슷한 색을 가지고 있다면 이 둘은 같은 그룹에 속하는 것으로 간주될 수 있습니다. 이 과정은 더 이상 병합할 유사한 세그먼트가 없을 때까지 반복적으로 수행됩니다.

병합 과정에서 생성되는 각각의 영역 제안은 물체 탐지 알고리즘에 사용될 수 있습니다. 이렇게 생성된 영역 제안들을 사용하면 전체 이미지를 검색하는 대신에, 이들 제안 영역 내에서만 물체를 탐색하므로 계산 효율성이 크게 향상됩니다. 이런 방식은 실제로 물체가 존재할 수 있는 영역을 정확하게 식별하는 데 도움을 주며, 이는 물체 탐지의 정확성을 높이는 데 중요한 요소입니다.

2.3 유사성 계산

선택적 탐색 알고리즘에서 유사성 계산은 영역 제안 생성 과정의 핵심 부분입니다. 이 과정에서는 서로 다른 세그먼트 또는 그룹간의 유사성을 계산하여, 그들을 병합할지 여부를 결정합니다. 유사성 계산은 다양한 요소를 기반으로 합니다. 선택적 탐색에서는 색상, 질감, 크기, 그리고 모양을 고려하여 유사성을 계산합니다.

색상: 색상 분포가 유사한 세그먼트들은 높은 유사성 점수를 가집니다.
질감: 질감(예: 세그먼트 내의 미세한 패턴 또는 변화)이 유사한 세그먼트들 역시 높은 유사성 점수를 가집니다.
크기: 크기가 작은 세그먼트들은 먼저 병합됩니다. 이는 물체의 작은 부분이나 노이즈를 처리하기 위함입니다.
모양: 서로 인접하며 비슷한 형태를 가진 세그먼트들은 높은 유사성을 가집니다.

유사성 계산은 이미지 내의 물체와 배경을 구분하고, 이미지에서 물체를 탐색하는 데 중요한 역할을 수행합니다. 이를 통해 물체 탐지 알고리즘의 효율성과 정확도를 향상시킬 수 있습니다.

3. 장, 단점

선택적 탐색(Selective Search) 알고리즘은 컴퓨터 비전에서 물체 탐지에 있어 다양한 장점을 가지고 있지만, 동시에 몇 가지 단점도 있습니다.

3.1 장점

효율성: 전체 이미지를 탐색하는 대신, 선택적 탐색은 이미지 내의 특정 영역만을 집중적으로 검사합니다. 이를 통해 계산 효율성을 크게 향상시킬 수 있습니다.
다양성: 선택적 탐색은 다양한 스케일과 모양의 물체를 잘 탐색할 수 있습니다. 이는 물체의 색상, 크기, 질감 등 다양한 특징을 고려하기 때문입니다.
과잉 세그멘테이션: 초기 세그멘테이션 단계에서 모든 가능한 물체와 배경을 포착하려는 '과잉 세그멘테이션' 접근 방식을 사용합니다. 이를 통해 세부적인 물체 구조까지 포착할 수 있습니다.

3.2 단점

정확성: 선택적 탐색은 영역 제안이라는 방법을 사용하므로, 어떤 물체를 완전히 놓치거나 부분적으로만 포착하는 경우가 있을 수 있습니다. 또한, 실제 물체가 아닌 배경을 물체로 잘못 탐지할 수도 있습니다.
최적의 파라미터 설정: 선택적 탐색의 성능은 세그멘테이션 방법, 유사성 측정 기준 등 다양한 파라미터에 크게 의존합니다. 따라서, 특정 상황에 최적화된 파라미터를 찾는 것은 어려울 수 있습니다.

4. Selective Search 코드 구현

Selective Search에서는 픽셀 유사성에 따라 초기 세그먼트를 형성하고, 그런 다음 이 세그먼트를 병합하여 더 큰 region proposals를 형성하는 방식으로 작동합니다. 이 병합은 'fast' 모드와 'quality' 모드 중에서 선택할 수 있는데, 'quality' 모드는 보통 더 크고, 복잡한 region proposals를 생성합니다.

(좌) quality 모드, (우) Search 모드

import cv2
import matplotlib.pyplot as plt

# 이미지 로드
img = cv2.imread('image_path.jpg')

# Selective Search 시작
ss = cv2.ximgproc.segmentation.createSelectiveSearchSegmentation()
ss.setBaseImage(img)

# Selective Search 모드 설정
#ss.switchToSelectiveSearchFast()

# Selective Search 모드를 'quality'로 변경
ss.switchToSelectiveSearchQuality()

# Region Proposals 생성
rects = ss.process()
print('Total Number of Region Proposals: {}'.format(len(rects)))

# 이미지에 Region Proposals 그리기
out_img = img.copy()

# 상위 100개의 Region Proposals만 그리기
for i, rect in enumerate(rects):
    if (i < 100):
        x, y, w, h = rect
        cv2.rectangle(out_img, (x, y), (x+w, y+h), (0, 255, 0), 1, cv2.LINE_AA)

plt.imshow(out_img)
plt.show()

[Unity 입문 강좌 - 8] C# for, while문 / 반복문

gogo5911 — Sun, 4 Feb 2024 00:06:25 +0900

반복문이란?

반복문은 게임 개발 시 자주 사용되는 프로그래밍 구조 중 하나입니다. 반복문은 특정 조건이 만족될 때까지 또는 지정된 횟수만큼 코드 블록을 반복 실행하도록 합니다. 이는 게임 개발에서 다양한 상황에서 활용될 수 있습니다, 예를 들어, 적들을 생성하거나, 인벤토리 아이템을 검사하거나, 플레이어가 특정 조건을 충족할 때까지 이벤트를 반복하는 등의 작업을 수행할 때 유용합니다.

1. for 반복문

for 반복문은 가장 많이 사용되는 반복문 중 하나입니다. for 반복문은 반복의 횟수가 명확할 때 주로 사용됩니다. for 반복문은 다음과 같은 구조를 가지고 있습니다.

초기화 : 반복문이 시작될 때 딱 한 번 실행되는 코드입니다.
조건 : 반복문이 실행될 때마다 검사하는 코드입니다. 조건이 true일 경우 반복문이 실행됩니다.
증감 : 반복문이 한 번 실행될 때마다 실행되는 코드입니다.

for (초기화; 조건; 증감) {
    반복할 코드
}

아래 코드는 for문의 예시 코드로 10번 반복하여 콘솔에 숫자를 출력합니다. for반복문은 지정된 조건이 참인 동안, 즉 조건이 true인 동안 코드 블록을 반복해서 실행합니다.

'int i =0'은 반복문이 시작하기 전에 한 번만 실행됩니다. int는 변수 i의 타입을 정의합니다. i = 0는 변수 i를 0으로 초기화하는 것을 나타냅니다.
' i < 10'은 반복문이 각 반복을 시작하기 전에 평가되는 조건입니다. 이 조건이 true, 즉 i의 값이 10보다 작을 경우, 반복문의 코드 블록이 실행됩니다. i가 10이 되는 순간, 조건이 false가 되어 반복문의 실행이 중단됩니다.
i++는 각 반복의 끝에서 실행되어 i의 값을 1씩 증가시킵니다. 이는 다음 반복을 위해 i의 값을 업데이트하는 것으로, 반복문이 언젠가는 중단되도록 보장합니다. 이렇게 반복문을 돌리면 결과적으로, 0부터 9까지의 숫자가 콘솔에 출력됩니다.

for (int i = 0; i < 10; i++) {
    Debug.Log(i);
}

2. while 반복문

while 반복문은 조건이 true일 때 계속해서 반복하는 반복문입니다. while 반복문은 다음과 같은 구조를 가지고 있습니다. 아래 구조에서 조건은 while 반복문이 실행될 때마다 검사하는 코드입니다.

while (조건) {
    반복할 코드
}

아래 코드는 while문의 예시 코드로 특정조건(health가 0보다 클 때)까지 반복하여 플레이어의 health를 감소시키는 예시입니다. 먼저 health라는 이름의 변수를 선언하고, 그 값을 10으로 초기화합니다. 이는 플레이어의 초기 체력을 나타냅니다.

while반복문은 괄호 안의 조건이 참(true)인 동안 반복해서 코드블록을 실행합니다. 여기서 조건은 health > 0 즉, 플레이어의 체력이 0보다 클 경우입니다. 이 조건이 참인 동안, 즉 체력이 0보다 큰 동안 반복문 내부의 코드가 반복적으로 실행됩니다.
health --는 health 변수의 값을 1씩 감소시키는 연산입니다. 이는 health = health -1과 동일한 작업을 수행합니다. 반복문이 실행될 때마다 체력이 감소하고, 각각의 새로운 체력 값이 출력됩니다. 최종적으로 플레이어의 체력이 0이되면 반복문이 중단되고, 프로그램은 종료됩니다.

int health = 10;

while (health > 0) {
    health--;
    Debug.Log("플레이어의 현재 체력: " + health);
}

3. do-while 반복문

do-while 반복문은 while 반복문과 비슷하지만, 조건을 검사하기 전에 코드 블록을 최소 한 번 실행하고, 그 후에 주어진 조건에 따라 추가 실행 여부를 결정합니다. 이는 최소한 한 번은 코드가 실행되어야 할 때 유용합니다. do-while 반복문은 다음과 같은 구조를 가지고 있습니다.

do {
    반복할 코드
} while (조건);

아래 코드는 do-while문의 예시 코드로 사용자가 '3. 종료' 옵션을 선택할 때까지 메뉴를 반복해서 표시합니다. 메뉴 옵션은 1. 게임 시작, 2. 설정, 3. 종료로 구성되어 있습니다.

사용자 입력 대신 Random().Next(1, 4)를 사용하여 1부터 3 사이의 임의의 숫자를 생성하고, 이를 menuOption 변수에 할당합니다. 실제 게임이나 애플리케이션에서는 사용자로부터 입력을 받는 방식을 구현해야 합니다.

switch문을 사용하여 사용자의 선택에 따라 다른 메시지를 출력합니다.
사용자가 '3. 종료'를 선택하기 전까지는 do-while 반복문이 계속해서 메뉴를 표시합니다.
'3. 종료'가 선택되면, 반복문이 종료되고 프로그램 종료 메시지를 출력합니다.

int menuOption = 0;

do {
    // 메뉴 옵션을 사용자에게 표시
    Debug.Log("1. 게임 시작");
    Debug.Log("2. 설정");
    Debug.Log("3. 종료");

    // 여기서는 예시를 위해 사용자 입력 대신 임의의 값을 할당합니다.
    // 실제 유니티 프로젝트에서는 사용자 입력을 받는 방법(예: UI 버튼 클릭)을 사용해야 합니다.
    menuOption = new Random().Next(1, 4); // 1, 2, 3 중 하나를 임의로 선택

    Debug.Log($"선택한 메뉴 옵션: {menuOption}");

    // 선택한 메뉴 옵션에 따른 동작 처리
    switch (menuOption) {
        case 1:
            Debug.Log("게임을 시작합니다.");
            break;
        case 2:
            Debug.Log("설정 메뉴로 이동합니다.");
            break;
        case 3:
            Debug.Log("게임을 종료합니다.");
            break;
        default:
            Debug.Log("잘못된 선택입니다. 다시 선택해주세요.");
            break;
    }
} while (menuOption != 3); // 사용자가 '3. 종료'를 선택할 때까지 반복

Debug.Log("프로그램을 종료합니다.");

4. foreach 반복문

foreach 반복문은 컬렉션(예: 배열, 리스트 등)의 각 요소에 대해 반복 실행을 하고자 할 때 매우 유용합니다. foreach는 컬렉션의 시작부터 끝까지 순차적으로 요소를 하나씩 참조하여, 해당 요소에 대한 처리를 수행합니다. 아래 구조에서 반복문이 실행될 때마다 배열의 요소를 하나씩 가져와서 변수에 대입합니다.

타입: 컬렉션에 저장된 요소의 데이터 타입.
변수명: 반복 중 현재 요소를 참조하는 변수의 이름.
컬렉션명: 순회할 컬렉션의 이름.

foreach (타입 변수명 in 컬렉션명) {
    // 반복 실행할 코드
}

아래 코드는 foreach 문의 예시 코드로 배열의 각 요소를 순회하며, 그 값을 콘솔에 출력하는 예제입니다.

int[] numbers = {1, 2, 3, 4, 5}; 이 부분은 int 타입의 배열 numbers를 선언하고, 동시에 1부터 5까지의 숫자로 초기화합니다. 이 경우, 배열 numbers는 총 5개의 요소를 갖게 됩니다.
foreach (int number in numbers) 구문에서, int number는 반복문이 현재 순회하고 있는 배열의 요소를 가리키는 변수입니다. numbers는 순회될 배열의 이름입니다. foreach 반복문의 바디({ ... }) 내에 있는 코드는 배열의 각 요소에 대해 한 번씩 실행됩니다.

int[] numbers = {1, 2, 3, 4, 5};

foreach (int number in numbers) {
    Debug.Log(number);
}

5. for문, While문 중첩

5.1 for문 중첩

for 문 중첩은 하나의 for 문 안에 다른 for 문을 포함시키는 것을 말합니다. 주로 2차원 배열이나 리스트를 다룰 때, 또는 복잡한 데이터 구조를 순회할 때 사용됩니다. 이때 문법은 동일합니다. 변수는 보통 i, j, k, l ... 순으로 지정합니다. 다른 변수명으로 지정해도 문제는 없습니다.

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 2; j++) {
        Debug.Log($"i: {i}, j: {j}");
        if (j == 1) break; // j가 1일 때 내부 for 문 중단
    }
}

5.2 while문 중첩

while 문 중첩은 한 while 문 안에 다른 while 문을 포함시키는 것입니다. 이것은 더 복잡한 반복 조건이나 다양한 상황에서의 반복 처리에 유용하게 사용됩니다. 이때 문법은 동일합니다.

int i = 0;
while (i < 3) {
    int j = 0;
    while (j < 2) {
        Debug.Log($"i: {i}, j: {j}");
        j++;
        if (j == 1) break; // j가 1일 때 내부 while 문 중단
    }
    i++;
}

5.3 for문과 while문 중첩

for 문과 while 문을 서로 중첩하여 사용하는 것도 가능합니다. 이러한 중첩은 다양한 반복 조건을 조합할 때 유용합니다.

for (int i = 0; i < 3; i++) {
    int j = 0;
    while (j < 2) {
        Debug.Log($"i: {i}, j: {j}");
        j++;
        if (j == 1) break; // j가 1일 때 while 문 중단
    }
}

6. 반복문에서의 제어문

반복문에는 break, continue, return, goto와 같이 반복문의 흐름을 제어하는 제어문이 있습니다.

6.1 break문

break 문은 중첩된 반복문에서 사용될 때 가장 가까운 반복문만을 종료시킵니다.

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        // i가 5일 때 반복문 종료
        break;
    }
    Debug.Log(i);
}

6.2 continue

continue 문은 현재 반복을 중단하고 반복문의 다음 반복으로 즉시 이동하게 합니다. for, while, do-while 반복문에서 사용할 수 있으며, 주로 특정 조건 하에서 남은 코드의 실행을 건너뛰고 싶을 때 사용됩니다.

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) continue; // i가 짝수면 아래 코드를 실행하지 않고 다음 반복으로 넘어감
    Debug.Log(i); // 홀수만 출력됨
}

6.3 return

return 문은 현재 실행 중인 함수에서 즉시 탈출합니다. 반복문 내에서 return을 사용하면, 해당 반복문 뿐만 아니라 그 반복문을 포함하는 함수의 실행도 종료됩니다. 이는 특정 조건이 만족되었을 때 더 이상의 실행이 불필요하거나 원하는 결과를 얻었을 때 함수를 즉시 종료시키고 싶을 때 유용합니다.

void CheckNumbers() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) return; // i가 5에 도달하면 함수 실행을 중단
        Debug.Log(i);
    }
    // i가 5에 도달하면 여기에 도달하지 않음
}

6.4 goto

goto 문은 지정된 레이블로 즉시 점프합니다. goto는 다른 제어 흐름 구조를 사용하기 어려운 특수한 경우에 한하여 제한적으로 사용됩니다. goto의 사용은 일반적으로 권장되지 않으며, 코드의 가독성과 유지보수성을 떨어뜨릴 수 있기 때문에 가능한 피하는 것이 좋습니다.

for (int i = 0; i < 10; i++) {
    if (i == 5) goto customLabel; // i가 5에 도달하면 customLabel로 점프
    Debug.Log(i);
}

customLabel:
Debug.Log("i가 5에 도달하여 레이블로 점프함");

[Unity 입문 강좌 - 7] C# 유니티 if, else, switch문 / 조건문

gogo5911 — Sat, 3 Feb 2024 02:59:55 +0900

1. if 문 구조

C#에서 가장 기본적인 조건문은 if 문입니다. if 문은 조건이 참일 때 실행되는 구문입니다. 아래는 if 문의 구조입니다. 코드에서 조건식은 참 또는 거짓을 반환하는 식(expression)입니다. 조건식이 참이면 중괄호 '{}' 내부의 코드가 실행되고, 거짓이면 실행되지 않습니다.

if (조건식)
{
    // 조건이 참일 때 실행할 코드
}

아래는 유니티에서 간단한 if 문 사용 예시입니다. 플레이어의 체력(playerHealth)이 특정 수준 이하로 떨어졌을 때 경고 메시지를 출력하는 코드입니다. 해당 코드에서는 체력이 20 이하라면, 콘솔에 "Warning: Low health!"라는 메시지가 출력되는 코드입니다.

public int playerHealth = 100;

// 플레이어의 체력이 20 이하일 때 경고 메시지 출력
if (playerHealth <= 20)
{
    Debug.Log("Warning: Low health!");
}

2. if-else 문 구조

if 문은 조건이 참일 때 실행되는 구문이므로, 조건이 거짓일 때 실행될 코드가 필요할 때는 if-else 문을 사용합니다. 아래 코드는 if-else 문의 구조입니다.

if (조건식)
{
    // 조건이 참일 때 실행할 코드
}
else
{
    // 조건이 거짓일 때 실행할 코드
}

아래는 유니티에서 간단한 if-else 문 사용 예시입니다. 코드에서 num 변수의 값은 -5입니다. if 문에서는 num 변수의 값이 0보다 큰지 비교하고, 조건이 거짓이므로 else 구문이 실행됩니다. 따라서 Debug.Log 함수를 호출하여 "num은 0보다 작거나 같습니다." 라는 메시지를 출력합니다.

int num = -5;

if (num > 0)
{
    Debug.Log("num은 0보다 큽니다.");
}
else
{
    Debug.Log("num은 0보다 작거나 같습니다.");
}

3. else if 문 구조

else if 문은 여러 개의 조건을 검사할 때 사용합니다. 각 조건이 참일 때 해당 코드가 실행되고, 조건이 모두 거짓일 때는 else 구문이 실행됩니다. 아래는else if 문의 구조입니다.

if (조건식1)
{
    // 조건식1이 참일 때 실행할 코드
}
else if (조건식2)
{
    // 조건식1이 거짓이고, 조건식2가 참일 때 실행할 코드
}
else
{
    // 모든 조건식이 거짓일 때 실행할 코드
}

아래는 유니티에서 간단한 else if 문 사용 예시입니다. 코드에서 num 변수의 값은 0입니다. if 문에서는 num 변수의 값이 0보다 큰지 비교하고, 조건이 거짓이므로 다음 else if 문으로 이동합니다. else if 문에서는 num 변수의 값이 0보다 작은지 비교하고, 조건이 거짓이므로 else 구문이 실행됩니다. 따라서 Debug.Log 함수를 호출하여 "num은 0입니다." 라는 메시지를 출력합니다.

int num = 0;

if (num > 0)
{
    Debug.Log("num은 0보다 큽니다.");
}
else if (num < 0)
{
    Debug.Log("num은 0보다 작습니다.");
}
else
{
    Debug.Log("num은 0입니다.");
}

4. if문 논리 연산자

논리 연산자는 조건식에서 여러 개의 조건을 조합할 때 사용됩니다. C#에서는 다음과 같은 논리 연산자가 있습니다.

&&논리곱(and) 연산자 : 양쪽 조건식이 모두 참일 때 참을 반환합니다.
|| 논리합(or) 연산자 : 양쪽 조건식 중 하나 이상이 참일 때 참을 반환합니다.
!논리부정(not) 연산자 : 조건식의 결과를 반대로 반환합니다.

아래 코드는 논리 연산자를 사용한 예제입니다. 코드에서 첫 번째 if 문은 num1 변수와 num2 변수가 모두 0보다 큰지 비교하고, 논리곱 연산자인 &&를 사용하여 두 조건이 모두 참일 때 Debug.Log 함수를 호출하여 "num1과 num2는 모두 0보다 큽니다." 라는 메시지를 출력합니다.

두 번째 if 문은 num1 변수와 num2 변수 중 하나 이상이 0보다 큰지 비교하고, 논리합 연산자인 ||를 사용하여 두 조건 중 하나 이상이 참일 때 Debug.Log 함수를 호출하여 "num1과 num2 중 적어도 하나는 0보다 큽니다." 라는 메시지를 출력합니다.

세 번째 if 문은 num1 변수가 0보다 큰지 비교하고, 논리부정 연산자인 !를 사용하여 조건식의 결과를 반대로 바꾸어 비교합니다. 따라서 num1 변수가 0보다 크지 않으므로 Debug.Log 함수를 호출하여 "num1은 0보다 작거나 같습니다." 라는 메시지를 출력합니다.

int num1 = 5;
int num2 = 10;

if (num1 > 0 && num2 > 0)
{
    Debug.Log("num1과 num2는 모두 0보다 큽니다.");
}

if (num1 > 0 || num2 > 0)
{
    Debug.Log("num1과 num2 중 적어도 하나는 0보다 큽니다.");
}

if (!(num1 > 0))
{
    Debug.Log("num1은 0보다 작거나 같습니다.");
}

5. 중첩 조건문

중첩 조건문은 조건문 내부에 다른 조건문이 포함된 구문입니다. 중첩 조건문은 복잡한 조건식을 작성할 때 사용됩니다. 아래는 중첩 조건문의 구조입니다.

if (조건식1)
{
    // 조건식1이 참일 때 실행할 코드

    if (조건식2)
    {
        // 조건식2가 참일 때 실행할 코드
    }
}
else
{
    // 조건식1이 거짓일 때 실행할 코드
}

아래 코드는 중첩 조건문을 사용한 예제입니다. 이 코드는 플레이어가 미션을 수행하기 위한 두 가지 주요 조건, 즉 레벨과 장비를 검사합니다. 첫 번째 if 문은 플레이어의 레벨이 10 이상인지를 확인하고, 이 조건이 참일 경우 내부의 두 번째 if 문으로 진입하여 플레이어가 필요한 장비를 보유하고 있는지를 확인합니다. 만약 플레이어의 레벨이 10 미만이라면, else 블록이 실행되어 레벨이 미션 요구 조건에 부합하지 않음을 알립니다.

int playerLevel = 10;
bool hasRequiredEquipment = false;

if (playerLevel >= 10)
{
    // 플레이어 레벨이 10 이상일 때 실행할 코드
    Debug.Log("Player level is sufficient for the mission.");

    if (hasRequiredEquipment)
    {
        // 필요한 장비를 갖추고 있을 때 실행할 코드
        Debug.Log("Player has the required equipment for the mission.");
    }
    else
    {
        // 필요한 장비를 갖추고 있지 않을 때 실행할 코드
        Debug.Log("Player does not have the required equipment for the mission.");
    }
}
else
{
    // 플레이어 레벨이 10 미만일 때 실행할 코드
    Debug.Log("Player level is not sufficient for the mission.");
}

6. switch문

switch 문은 다양한 case 중 하나를 선택하여 코드를 실행할 때 사용되는 조건문입니다. switch 문은 특정 변수나 표현식의 값에 따라 다양한 코드 블록 중 하나를 실행할 수 있게 해줍니다. 이는 if-else 문을 사용할 때보다 많은 조건을 보다 깔끔하게 처리할 수 있게 해줍니다.

expression : 비교할 변수나 값.
case value : expression이 특정 값과 일치할 때 실행될 코드 블록을 정의합니다.
break : 현재 case를 종료하고 switch 문을 빠져나갑니다.
default : 어떤 case에도 해당되지 않을 때 실행될 코드 블록을 정의합니다. default는 선택적입니다.

switch (expression)
{
    case value1:
        // value1 일 때 실행할 코드
        break;
    case value2:
        // value2 일 때 실행할 코드
        break;
    ...
    default:
        // 어떤 case도 매치되지 않을 때 실행할 코드
        break;
}

아래 코드는 switch문을 사용한 예제입니다. characterState 변수는 캐릭터의 상태를 나타내며, 각 숫자 값(1, 2, 3)은 각각 '대기(Idle)', '걷기(Walking)', '달리기(Running)' 상태를 의미합니다. switch 문을 사용하여 characterState의 값에 따라 캐릭터의 현재 상태를 나타내는 다른 메시지를 콘솔에 출력합니다. 현재 characterState의 값은 1이므로, Debug.Log 함수를 호출하여 " Character is idle " 라는 메시지를 출력합니다.

현재 enum(열거형)에 대해 배우지 않았기 때문에 숫자를 이용한 방법을 사용했습니다.

public int characterState = 1;

switch (characterState)
{
    case 1:
        Debug.Log("Character is idle.");
        break;
    case 2:
        Debug.Log("Character is walking.");
        break;
    case 3:
        Debug.Log("Character is running.");
        break;
    default:
        Debug.Log("Unknown state.");
        break;
}

numpy, pandas, matplotlib 강좌

gogo5911 — Thu, 1 Feb 2024 23:36:08 +0900

1. Numpy 강좌

넘버	제목[링크]
1	Numpy란? [링크]
2	Numpy 배열 속성, 생성과 데이터타입 [링크]
3	Numpy 배열의 인덱싱(indexing)과 슬라이싱(Slicing) [링크]
4	효율적인 수학 연산 처리(기본 연산, 브로드캐스팅, 행렬 연산) [링크]
5	넘파이(Numpy) 집계, 정렬 및 분할, 수학 함수를 통한 데이터 처리 [링크]
6	파일 입출력 [링크]
7	벡터화 연산과 메모리 접근 패턴 [링크]
8	난수 생성과 랜덤 샘플링 [링크]

2. Pandas 강좌

넘버	제목[링크]
1	Pandas기본 이해와 Series와 DataFrame 생성 방법 [링크]
2	CSV, Excel, SQL 데이터 불러오고 저장하기 [링크]
3	데이터 조회 및 선택 (loc, iloc) [링크]
4	데이터 정렬(값과 인덱스를 통한 정렬) [링크]
5	데이터 조작 및 변형(결측치 처리, 데이터 타입 변환 등) [링크]
6	데이터 병합하기 (Concat, Merge, Join 사용법) [링크]
7	데이터 그룹화하기 (Grouphy 함수 이해와 활용) [링크]
8	시계열 데이터 처리 (Date TimeIndex, Reasampling) [링크]
9	성능 향상을 이용한 대용량 데이터 처리 방법 [링크]

3. Matplotlib 강좌

넘버	제목[링크]
1	파이썬 데이터 시각화 [링크]
2	단순 그래프부터 세부 설정까지 [링크]
3	그래프 종류 마스터하기 [링크]
4	Figure와 Subplot 이해하기: 복잡한 그래프 구성하기 [링크]
5	고급 기법 활용 : 텍스트와 주석 추가, 축 변경 ... [링크]
6	eaborn 사용방법과 데이터 시각화 [링크]

[Matplotlib 강좌 – 6] seaborn 사용방법과 데이터 시각화

gogo5911 — Tue, 19 Dec 2023 00:07:33 +0900

1. Seaborn 소개

Seaborn은 Matplotlib을 기반으로 한 파이썬 데이터 시각화 라이브러리입니다. Seaborn은 통계를 중심으로 설계되어 있으며, 좀 더 복잡한 그래프를 간단한 코드로 구현할 수 있게 해줍니다. 또한, Seaborn은 보다 퀄리티 있는 그래픽과 복잡한 그래프 기능을 제공하며, Pandas 데이터프레임과 잘 연동됩니다.

2. Matplotlib와 Seaborn의 차이점

디자인 : Seaborn은 Matplotlib를 기반으로 하여 통계용 그래프를 그리는데 특화되어 있습니다. 기본적인 테마와 색상 팔레트가 있어 그래프를 향상시키며, 이는 Matplotlib보다 시각적으로 매력적인 그래프를 생성합니다.
코드 길이 : Seaborn의 통계 그래픽 함수는 Matplotlib에 비해 코드를 줄일 수 있습니다.
데이터 핸들링 : Seaborn은 Pandas 데이터프레임과 잘 작동하며, 데이터프레임 내의 문자열 변수를 자동으로 인식하여 범주형 변수로 처리합니다.

3. Seaborn 내장 데이터셋 사용하기

Seaborn은 다양한 예제 데이터 세트를 포함하고 있습니다. 이들은 다양한 유형의 데이터 시각화를 실습하거나, 새로운 시각화 방법을 실험하는 데 유용합니다.

아래는 Seaborn에서 사용 가능한 내장 데이터셋으로 anagrams, anscombe, attention, brain_networks, car_crashes, diamonds, dots, dowjones, exercise, flights, fmri, geyser, glue, healthexp, iris, mpg, penguins, planets, seaice, taxis, tips, titanic 총 22가지가 있습니다. 이 중 많이 사용되는 데이터셋은 아래와 같습니다.

3.1 iris

Iris 종에 따른 꽃잎과 꽃받침의 길이와 폭을 측정한 데이터셋입니다. 아래 코드는 iris 데이터 셋을 불러오는 코드입니다.

import seaborn as sns

# 내장 데이터셋 'iris' 로드
df = sns.load_dataset('iris')

#iris dataset:
#   sepal_length  sepal_width  petal_length  petal_width species
#0           5.1          3.5           1.4          0.2  setosa
#1           4.9          3.0           1.4          0.2  setosa
#2           4.7          3.2           1.3          0.2  setosa
#3           4.6          3.1           1.5          0.2  setosa
#4           5.0          3.6           1.4          0.2  setosa

3.2 mpg

1998년부터 2008년까지 출시된 여러 가지 자동차 모델에 대한 연비, 실린더, 배기량 등의 데이터를 포함하는 데이터셋입니다. 아래 코드는 mpg 데이터 셋을 불러오는 코드입니다.

import seaborn as sns

# 내장 데이터셋 'mpg' 로드
df = sns.load_dataset('mpg')

#mpg dataset:
#    mpg  cylinders  displacement  ...  model_year  origin                       name
#0  18.0          8         307.0  ...          70     usa  chevrolet chevelle malibu
#1  15.0          8         350.0  ...          70     usa          buick skylark 320
#2  18.0          8         318.0  ...          70     usa         plymouth satellite
#3  16.0          8         304.0  ...          70     usa              amc rebel sst
#4  17.0          8         302.0  ...          70     usa                ford torino

3.3 penguins

Palmer Archipelago의 펭귄들의 bill 길이, bill depth, flipper length, body mass 등에 대한 데이터셋입니다.

import seaborn as sns

# 내장 데이터셋 'penguins' 로드
df = sns.load_dataset('penguins')

#penguins dataset:
#  species     island  bill_length_mm  ...  flipper_length_mm  body_mass_g     sex
#0  Adelie  Torgersen            39.1  ...              181.0       3750.0    MALE
#1  Adelie  Torgersen            39.5  ...              186.0       3800.0  FEMALE
#2  Adelie  Torgersen            40.3  ...              195.0       3250.0  FEMALE
#3  Adelie  Torgersen             NaN  ...                NaN          NaN     NaN
#4  Adelie  Torgersen            36.7  ...              193.0       3450.0  FEMALE

3.4 tips

식사 금액, 팁, 성별, 흡연 여부, 요일, 시간, 사람 수 등에 대한 정보를 담고 있는 레스토랑 데이터셋입니다.

import seaborn as sns

# 내장 데이터셋 'tips' 로드
df = sns.load_dataset('tips')

#tips dataset:
#   total_bill   tip     sex smoker  day    time  size
#0       16.99  1.01  Female     No  Sun  Dinner     2
#1       10.34  1.66    Male     No  Sun  Dinner     3
#2       21.01  3.50    Male     No  Sun  Dinner     3
#3       23.68  3.31    Male     No  Sun  Dinner     2
#4       24.59  3.61  Female     No  Sun  Dinner     4

3.5 titanic

타이타닉호의 승객들에 대한 나이, 성별, 클래스, 생존 여부 등의 정보를 포함하는 데이터셋입니다.

import seaborn as sns

# 내장 데이터셋 'titanic' 로드
df = sns.load_dataset('titanic')

#titanic dataset:
#   survived  pclass     sex   age  ...  deck  embark_town  alive  alone
#0         0       3    male  22.0  ...   NaN  Southampton     no  False
#1         1       1  female  38.0  ...     C    Cherbourg    yes  False
#2         1       3  female  26.0  ...   NaN  Southampton    yes   True
#3         1       1  female  35.0  ...     C  Southampton    yes  False
#4         0       3    male  35.0  ...   NaN  Southampton     no   True

4. Seaborn 그래프 스타일

4.1 set_style()

Seaborn에서는 set_style()을 통해 스타일 테마를 설정할 수 있습니다. Seaborn에서 제공하는 스타일 테마는 Darkgrid, Whitegrid, Dark, White가 있습니다. 아래 코드는 set_style()을 사용하여 스타일 테마를 적용하는 예제입니다. 아래 이미지는 Darkgrid, Whitegrid, Dark 이미지입니다.

import seaborn as sns
import matplotlib.pyplot as plt

# 테마 설정
sns.set_style("darkgrid")

# 임의의 데이터를 이용해 그래프 그리기
tips = sns.load_dataset("tips")
sns.boxplot(x=tips["total_bill"])
plt.show()

4.2 set_context()

set_context() 함수는 그래프의 스케일(scale)을 설정하는데 사용됩니다. 이는 플롯의 요소 크기를 제어합니다. Seaborn은 paper, notebook, talk, poster로 총 4개의 context를 제공하고 있으며, 각각 다른 프로그램에 최적화되어 있습니다. 아래 이미지는 paper, notebook, poster 이미지 입니다.

paper : 가장 작은 스케일로 출판물용으로 적합합니다.
notebook : 주피터 노트북 등에서 그래프를 그릴 때 일반적으로 사용합니다.
talk : 큰 그림을 필요로 하는 강연이나 프레젠테이션에 적합합니다.
poster : 큰 포스터와 같이 매우 큰 그림에 적합합니다.

import seaborn as sns
import matplotlib.pyplot as plt

# 컨텍스트 설정
sns.set_context('poster')

# 이후에 그래프를 그릴 때, 설정한 컨텍스트가 적용됩니다.
sns.boxplot(data=sns.load_dataset('tips'), x='day', y='total_bill')
plt.show()

4.3 set_palette()

sns.color_palette() 함수를 사용해 색상 팔레트를 설정할 수 있습니다. 이 함수는 색상 리스트를 반환하며, 이를 sns.set_palette() 함수에 전달하여 전역 색상 팔레트를 설정할 수 있습니다. Seaborn은 다양한 색상 팔레트를 제공합니다. 대표적인 것들은 deep, muted, bright, pastel, dark, colorblind와 같습니다. 또한, Seaborn은 색상의 구성 요소를 명시적으로 지정하여 커스텀 색상 팔레트를 생성하는 것도 가능하게 합니다. 이를 위해서는 아래 코드 처럼 set_palette() 함수에 색상 문자열의 리스트를 전달하면 됩니다. 아래 이미지는 Seaborn에서 제공하는 husl 팔레트와 명시적으로 지정한 커스텀 팔레트를 통한 결과물입니다.

import seaborn as sns
import matplotlib.pyplot as plt

# 컨텍스트 설정
sns.set_context('poster')

#Seaborn 팔레트 사용
#sns.set_palette(sns.color_palette("husl"))

#커스텀 팔레트 사용
custom_palette = ['#A239CA', '#DCD5E4', '#3CBB75', '#D4752E']
sns.set_palette(custom_palette)

# 이후에 그래프를 그릴 때, 설정한 컨텍스트가 적용됩니다.
sns.boxplot(data=sns.load_dataset('tips'), x='day', y='total_bill')
plt.show()

5. Seaborn 다양한 그래프

5.1 Relational Plots

relplot(), scatterplot(), lineplot() 등의 함수를 통해 관계형 그래프를 그릴 수 있습니다. 이러한 그래프는 두 변수 사이의 관계를 시각적으로 표현합니다.

5.1.1 relplot()

relplot()는 멀티 플롯 그리드를 활용하여 여러 개의 관계형 그래프를 그리는 데 유용합니다. relplot() 함수의 주요 매개변수는 아래와 같습니다.

x, y : x축 및 y축에 그릴 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
style : 마커 스타일로 구분할 카테고리 변수의 이름입니다.
size : 마커 크기로 구분할 카테고리 변수의 이름입니다.
data : 그래프에 사용할 데이터프레임입니다.
row, col : 각각의 행과 열에 표시할 카테고리 변수의 이름입니다. 이를 이용해 그리드를 만들 수 있습니다.
kind : 그래프의 종류를 지정합니다. 'scatter'와 'line' 두 가지 중 선택할 수 있습니다.
palette : 색상 팔레트를 지정합니다.
height : 각 그래프의 높이를 설정합니다.
aspect : 각 그래프의 가로 세로 비율을 설정합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a relplot
sns.relplot(x="total_bill", y="tip", hue="day", style="time", size="size", data=tips, kind="scatter", palette="viridis", height=5, aspect=1.2)

5.1.2 scatterplot()

scatterplot()은 두 변수 간의 관계를 보여주는 산점도를 그리는 함수입니다. scatterplot() 함수의 주요 매개변수는 아래와 같습니다.

x, y : x축 및 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
style : 마커 스타일로 구분할 카테고리 변수의 이름입니다.
size : 마커 크기로 구분할 수치형 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
palette : 색상 팔레트를 지정합니다. 문자열, 리스트, 딕셔너리 등 다양한 형태로 지정할 수 있습니다.
markers : 마커의 모양을 지정합니다. 문자열, 리스트, 딕셔너리 등으로 지정할 수 있습니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a scatterplot
sns.scatterplot(x="total_bill", y="tip", hue="day", style="time", size="size", data=tips, palette="viridis")

5.1.3 lineplot()

lineplot() 함수는 하나의 변수가 다른 변수에 대해 어떻게 변하는지 보여주는 선 그래프를 그립니다. 이 함수는 시간에 따른 변화나 순서가 있는 카테고리 변수 등의 데이터를 시각화하는데 유용합니다. lineplot() 함수의 주요 매개변수는 다음과 같습니다.

x, y : x축 및 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
style : 선 스타일로 구분할 카테고리 변수의 이름입니다.
size : 선 두께로 구분할 수치형 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
palette : 색상 팔레트를 지정합니다. 문자열, 리스트, 딕셔너리 등 다양한 형태로 지정할 수 있습니다.
markers : 각 데이터 포인트에 마커를 그릴지 여부를 지정합니다. 기본적으로 False로 설정되어 있습니다.
dashes : 각 선에 대해 dash pattern을 사용할지 여부를 지정합니다. 기본적으로 True로 설정되어 있습니다.

import seaborn as sns

# Load the example flights dataset
flights = sns.load_dataset("flights")
flights = flights.pivot("month", "year", "passengers")

# Draw a lineplot
sns.lineplot(data=flights)

5.2 Categorical Plots

catplot(), boxplot(), violinplot(), countplot(), barplot() 등의 함수를 통해 범주형 그래프를 그릴 수 있습니다. 이러한 그래프는 범주형 변수에 대한 분포를 시각화합니다.

5.2.1 catplot()

catplot() 함수는 범주형 변수와 하나 이상의 수치형 변수 간의 관계를 그리는 함수로, 여러 서브플롯을 그릴 수 있습니다.

x, y : x축 및 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
row, col : 서브플롯을 나누는 기준이 될 컬럼의 이름입니다.
kind : 그래프의 종류를 지정합니다. 'strip', 'swarm', 'box', 'violin', 'boxen', 'point', 'bar', 'count' 중에서 선택할 수 있습니다.
height : 각 서브플롯의 높이를 설정합니다.
aspect : 각 서브플롯의 가로 세로 비율을 설정합니다.
palette : 색상 팔레트를 지정합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a catplot
sns.catplot(x="day", y="total_bill", hue="sex", data=tips, kind="bar", palette="viridis", height=5, aspect=1)

5.2.2 boxplot()

boxplot() 함수는 주어진 데이터셋에 대한 다섯 가지 요약 통계량(최솟값, 하위 사분위수(Q1), 중위수(Q2 또는 중앙값), 상위 사분위수(Q3), 최댓값)을 나타내는 박스 플롯을 그립니다. 이를 통해 데이터의 전체적인 분포를 확인하거나 이상치를 찾는 등의 용도로 사용할 수 있습니다.

x, y : x축 및 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
order, hue_order : 그래프에 표시될 범주들의 순서를 지정할 수 있습니다.
color : 모든 박스의 색상을 지정합니다.
palette : 색상 팔레트를 지정합니다. 문자열, 리스트, 딕셔너리 등 다양한 형태로 지정할 수 있습니다.
width : 각 박스의 너비를 지정합니다.
fliersize : 이상치의 마커 크기를 지정합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a boxplot
sns.boxplot(x="day", y="total_bill", hue="smoker", data=tips, palette="Set3")

4.2.3 violinplot()

violinplot() 함수는 박스 플롯과 커널 밀도 추정(KDE)을 결합하여 데이터의 분포와 밀도를 한 번에 표시하는 그래프를 그립니다. violinplot() 함수의 주요 매개변수는 다음과 같습니다.

x, y : x축 및 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
order, hue_order : 그래프에 표시될 범주들의 순서를 지정할 수 있습니다.
bw : 커널 밀도 추정에 사용될 밴드폭입니다. 이 값이 클수록 부드러운 곡선이 그려집니다.
cut : 바이올린 그래프의 테일을 얼마나 길게 그릴 것인지 결정합니다.
scale : 바이올린 그래프의 너비를 결정하는 방식입니다. 'area', 'count', 'width' 중 하나를 선택할 수 있습니다.
inner : 바이올린 내부에 그려질 그래프를 선택합니다. 'box', 'quartile', 'point', 'stick', None 중 하나를 선택할 수 있습니다.
split : 각 바이올린을 두 개의 카테고리에 따라 나눌 것인지 결정합니다. hue 매개변수가 주어져야 사용할 수 있습니다.
palette : 색상 팔레트를 지정합니다. 문자열, 리스트, 딕셔너리 등 다양한 형태로 지정할 수 있습니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a violinplot
sns.violinplot(x="day", y="total_bill", hue="smoker", data=tips, palette="muted", split=True)

5.2.4 countplot()

countplot() 함수는 범주형 열에 대한 빈도수를 막대 그래프 형태로 표시하는 함수입니다. countplot() 함수의 주요 매개변수는 다음과 같습니다.

x, y : x축 혹은 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다. 이 둘 중 하나만 지정해야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
order, hue_order : 그래프에 표시될 범주들의 순서를 지정할 수 있습니다.
palette : 색상 팔레트를 지정합니다. 문자열, 리스트, 딕셔너리 등 다양한 형태로 지정할 수 있습니다.
saturation : 막대의 색상 채도를 설정합니다. 0부터 1 사이의 값을 지정합니다.
dodge : hue 매개변수가 지정되었을 때, 막대를 분리하여 그릴 것인지, 하나로 합쳐서 그릴 것인지 결정합니다. 기본값은 True입니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a countplot
sns.countplot(x="day", hue="smoker", data=tips, palette="viridis")

5.2.5 barplot()

barplot() 함수는 범주형 데이터에 대한 막대 그래프를 그리는 함수입니다. 각 범주에 대해 데이터의 평균과 신뢰 구간을 계산하고 표시합니다.

x, y : x축 및 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
data : 그래프를 그리는 데 사용할 pandas 데이터프레임입니다.
order, hue_order : 그래프에 표시될 범주들의 순서를 지정할 수 있습니다.
palette : 색상 팔레트를 지정합니다. 문자열, 리스트, 딕셔너리 등 다양한 형태로 지정할 수 있습니다.
saturation : 막대의 색상 채도를 설정합니다. 0부터 1 사이의 값을 지정합니다.
ci : 신뢰 구간을 계산하는 데 사용되는 신뢰 수준입니다. None으로 설정하면 신뢰 구간이 그려지지 않습니다.
capsize : 신뢰 구간을 나타내는 막대(caps)의 너비를 설정합니다.
dodge : hue 매개변수가 지정되었을 때, 막대를 분리하여 그릴 것인지, 하나로 합쳐서 그릴 것인지 결정합니다. 기본값은 True입니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a barplot
sns.barplot(x="day", y="total_bill", hue="smoker", data=tips, palette="Set2", capsize=.2)

5.3 Distribution Plots

kdeplot(), histplot(), rugplot() 등의 함수를 통해 분포 그래프를 그릴 수 있습니다. 이러한 그래프는 변수의 분포를 시각화합니다.

5.3.1 kdeplot()

kdeplot() 함수는 커널 밀도 추정(Kernel Density Estimation, KDE)을 사용하여 데이터의 밀도를 표시하는 그래프를 그립니다. 이는 데이터의 분포를 시각적으로 나타내는 데 유용합니다. kdeplot() 함수의 주요 매개변수는 다음과 같습니다.

data : 그래프를 그리는 데 사용할 데이터입니다. 일차원 배열이나 리스트를 입력합니다.
data2 : 두 번째 데이터 세트입니다. data2가 주어지면 2차원 KDE를 그립니다.
shade : True로 설정하면, KDE 곡선 아래의 영역이 색칠됩니다.
vertical : True로 설정하면, y축에 대한 KDE를 그립니다.
kernel : 커널 종류를 설정합니다. 가능한 값은 {‘gau’ | ‘cos’ | ‘biw’ | ‘epa’ | ‘tri’ | ‘triw’ }입니다.
bw : 커널의 밴드폭을 설정합니다. 이 값이 클수록 부드러운 KDE를 얻습니다.
gridsize : KDE를 계산할 그리드의 크기를 설정합니다.
cut : KDE 곡선을 얼마나 멀리 확장할지 결정합니다. 커널의 지원 범위 밖에서 값을 계산하는 데 사용되는 것보다 더 넓게 KDE를 그립니다.
clip : KDE를 계산할 범위를 설정합니다.
legend : True로 설정하면, 범례가 그려집니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a KDE plot
sns.kdeplot(tips["total_bill"], shade=True)

5.3.2 histplot()

histplot() 함수는 데이터의 분포를 나타내는 히스토그램을 그립니다. 이는 데이터의 빈도수를 시각화하는 데 매우 유용한 도구입니다. histplot() 함수의 주요 매개변수는 다음과 같습니다.

data : 그래프를 그리는 데 사용할 pandas 데이터프레임, numpy 배열, 리스트 등입니다.
x, y : x축 혹은 y축에 표시할 데이터의 이름입니다. 이는 문자열로 제공되어야 합니다. 둘 다 설정하면 2D 히스토그램을 그립니다.
hue : 색상으로 구분할 카테고리 변수의 이름입니다.
bins : 히스토그램의 빈의 수를 지정합니다. 정수, 시퀀스, 문자열 중 하나를 선택할 수 있습니다.
binwidth : 히스토그램의 빈의 폭을 지정합니다.
binrange : 히스토그램의 빈의 범위를 지정합니다.
weights : 각 데이터에 가중치를 부여하려면 해당 가중치의 리스트를 지정합니다.
stat : 히스토그램에서 보여줄 통계량을 지정합니다. count, frequency, density, probability 중 하나를 선택할 수 있습니다.
kde : True로 설정하면, 커널 밀도 추정치(KDE)를 함께 그립니다.
color : 히스토그램의 색상을 지정합니다.

import seaborn as sns
import matplotlib.pyplot as plt

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a histogram for total bill
sns.histplot(data=tips, x="total_bill", kde=True)
plt.show()

5.3.3 rugplot()

rugplot() 함수는 데이터 분포의 각 데이터 포인트를 표시하는 간단한 그래프를 생성합니다. 각 데이터 포인트는 축을 따라 작은 세로선으로 표시되며, 데이터의 분포를 쉽게 확인할 수 있게 돕습니다.

a : 그래프를 그리는 데 사용할 데이터입니다. 일차원 배열이나 리스트를 입력합니다.
height : 세로선의 높이를 지정합니다. 기본값은 0.05입니다.
axis : 데이터를 표시할 축을 지정합니다. 'x' 또는 'y'를 선택할 수 있습니다.
linewidth : 세로선의 너비를 지정합니다.
alpha : 세로선의 투명도를 지정합니다. 0(완전 투명)에서 1(완전 불투명) 사이의 값을 선택합니다.
color : 세로선의 색상을 지정합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a rug plot
sns.rugplot(data=tips, a="total_bill", height=0.5, color="blue")

5.4 Matrix Plots

heatmap(), clustermap() 등의 함수를 통해 행렬 그래프를 그릴 수 있습니다. 이러한 그래프는 행렬 형태의 데이터를 시각화합니다.

5.4.1 heatmap()

heatmap() 함수는 데이터를 색상으로 표현한 행렬을 그리는 데 사용됩니다. 이 함수는 특히 상관계수 행렬과 같은 데이터를 시각화하는 데 유용합니다. heatmap() 함수의 주요 매개변수는 다음과 같습니다.

data : 히트맵을 그리는 데 사용할 데이터셋. pandas DataFrame이나 2차원 배열을 전달합니다.
vmin, vmax : 컬러맵의 최소 및 최대값을 설정합니다.
cmap : 컬러맵을 설정합니다. 기본값은 None으로, 기본 컬러맵을 사용합니다.
center : 컬러맵의 중심을 설정합니다. None으로 설정하면 컬러맵의 중심이 vmin과 vmax의 중간값이 됩니다.
robust : True로 설정하면 컬러맵의 범위를 robust하게 설정하며, 이상치의 영향을 줄입니다.
annot : True로 설정하면 각 셀에 값이 표시됩니다.
fmt : 값 표시 형식을 설정합니다. annot=True일 때만 사용됩니다.
linewidths : 셀 간 경계선의 너비를 설정합니다.
linecolor : 셀 간 경계선의 색상을 설정합니다.
cbar : 컬러바의 표시 여부를 설정합니다.
cbar_kws : 컬러바의 속성을 설정하는 딕셔너리를 전달합니다.
square : True로 설정하면 셀이 정사각형이 되며, 축의 비율이 무시됩니다.

import seaborn as sns

# Load the example flights dataset
flights = sns.load_dataset("flights")

# Pivot the dataframe
flights = flights.pivot("month", "year", "passengers")

# Draw a heatmap
sns.heatmap(data=flights, annot=True, fmt="d", cmap="YlGnBu")

5.4.2 clustermap()

clustermap() 함수는 히트맵에 계층적 클러스터링을 적용하여 그립니다. 이 함수는 특히, 변수 간의 패턴이나 구조를 발견하는 데 유용합니다. clustermap() 함수의 주요 매개변수는 다음과 같습니다.

data : 클러스터맵을 그리는 데 사용할 데이터셋. pandas DataFrame을 전달합니다.
pivot_kws : 데이터를 피벗하는 방법을 지정하는 딕셔너리입니다.
method : 클러스터링 방법을 지정합니다. 기본값은 'single'입니다.
metric : 거리 계산 방법을 지정합니다. 기본값은 'euclidean'입니다.
z_score : 데이터를 표준화하는 방법을 지정합니다.
standard_scale : 데이터를 표준 스케일로 변환하는 방법을 지정합니다.
figsize : 그림의 크기를 지정합니다. (너비, 높이) 형태의 튜플을 전달합니다.
cbar_kws : 컬러바의 속성을 설정하는 딕셔너리를 전달합니다.
row_cluster, col_cluster : 행과 열의 클러스터링을 수행할지 여부를 지정합니다. 기본값은 True입니다.
row_linkage, col_linkage : 행과 열에 대한 클러스터링 방법을 지정합니다.

import seaborn as sns

# Load the example flights dataset
flights = sns.load_dataset("flights")

# Pivot the dataframe
flights = flights.pivot("month", "year", "passengers")

# Draw a clustermap
sns.clustermap(data=flights, cmap="YlGnBu", standard_scale=1)

5.5 Regression Plots

lmplot(), regplot() 등의 함수를 통해 회귀 그래프를 그릴 수 있습니다. 이러한 그래프는 두 변수 사이의 선형 관계를 시각화합니다.

5.5.1 lmplot()

lmplot() 함수는 두 변수 간의 선형 관계를 시각화하는 데 사용되며, 이를 위해 선형 회귀 모델의 결과를 그래프로 나타냅니다. lmplot() 함수의 주요 매개변수는 다음과 같습니다.

x, y : 데이터에서 사용할 변수의 이름입니다.
data : 사용할 데이터 프레임입니다.
hue : 색상을 기준으로 구분할 카테고리 변수의 이름입니다.
col, row : 서브플롯을 생성하여 분리할 카테고리 변수의 이름입니다.
palette : 색상 팔레트를 지정합니다.
markers : 각 데이터 포인트에 대한 마커 모양을 지정합니다.
scatter_kws, line_kws : 각각 산점도와 회귀선에 대한 추가적인 키워드 인자를 전달하는 딕셔너리입니다.
ci : 회귀선 주위에 그릴 신뢰 구간의 크기를 지정합니다. None을 설정하면 신뢰 구간이 그려지지 않습니다.
fit_reg : False를 설정하면 회귀선이 그려지지 않습니다.
logistic, lowess, robust, logx : 회귀선을 적합시키는 방법을 지정합니다. 기본적으로 선형 회귀 모델을 사용합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a lmplot
sns.lmplot(x="total_bill", y="tip", data=tips, hue="time", markers=["o", "v"])

5.5.2 regplot()

regplot() 함수는 두 변수 간의 선형 관계를 시각화하는데 사용됩니다. 이를 위해 선형 회귀 모델의 결과를 그래프로 나타냅니다. regplot() 함수의 주요 매개변수는 다음과 같습니다.

x, y : 데이터에서 사용할 변수의 이름입니다.
data : 사용할 데이터 프레임입니다.
color : 플롯의 색상을 지정합니다.
marker : 각 데이터 포인트에 대한 마커 모양을 지정합니다.
scatter_kws, line_kws : 각각 산점도와 회귀선에 대한 추가적인 키워드 인자를 전달하는 딕셔너리입니다.
ci : 회귀선 주위에 그릴 신뢰 구간의 크기를 지정합니다. None을 설정하면 신뢰 구간이 그려지지 않습니다.
fit_reg : False를 설정하면 회귀선이 그려지지 않습니다.
logistic, lowess, robust, logx : 회귀선을 적합시키는 방법을 지정합니다. 기본적으로 선형 회귀 모델을 사용합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Draw a regplot
sns.regplot(x="total_bill", y="tip", data=tips, color="green", marker="+")

5.6 Multi-plot Grids

pairplot(), FacetGrid() 등의 함수를 통해 복수의 서브 플롯을 한 번에 그릴 수 있습니다.

5.6.1 pairplot()

pairplot() 함수는 데이터 프레임에서 쌍으로 이루어진 관계를 그리는 데 사용됩니다. 즉, 데이터셋의 모든 가능한 쌍 조합에 대한 산점도를 그리고, 주 대각선에는 해당 데이터의 히스토그램 또는 KDE 플롯을 그립니다. pairplot() 함수의 주요 매개변수는 다음과 같습니다.

data : 사용할 데이터 프레임입니다.
hue : 색상을 기준으로 구분할 카테고리 변수의 이름입니다.
palette : 색상 팔레트를 지정합니다.
vars : 사용할 변수의 리스트를 지정합니다. 지정하지 않으면 데이터 프레임의 모든 수치형 변수가 사용됩니다.
kind : 그릴 플롯의 종류를 지정합니다. scatter와 reg 중 선택할 수 있습니다.
diag_kind : 주 대각선에 그릴 플롯의 종류를 지정합니다. hist와 kde 중 선택할 수 있습니다.
markers : 각 그룹에 대한 마커 모양을 지정하는 문자열 리스트입니다.
height : 각 플롯의 크기를 지정합니다.
plot_kws, diag_kws : 각각 산점도와 대각선 플롯에 대한 추가적인 키워드 인자를 전달하는 딕셔너리입니다.

import seaborn as sns

# Load the example iris dataset
iris = sns.load_dataset("iris")

# Draw a pairplot
sns.pairplot(data=iris, hue="species", markers=["o", "s", "D"])

5.6.2 FacetGrid()

FacetGrid()는 여러 서브플롯을 생성하고 각각에 데이터를 시각화할 수 있습니다. 이는 데이터의 여러 측면을 동시에 비교하거나 표현하고자 할 때 유용합니다. FacetGrid() 함수의 주요 매개변수는 다음과 같습니다.

data : 사용할 데이터 프레임입니다.
row, col : 행과 열에 해당하는 변수의 이름입니다. 이 변수들을 기준으로 그리드를 생성합니다.
hue : 색상을 기준으로 구분할 카테고리 변수의 이름입니다.
palette : 색상 팔레트를 지정합니다.
row_order, col_order, hue_order : 각 변수의 레벨을 정렬하는 데 사용할 리스트를 지정합니다.
height, aspect : 각 플롯의 크기와 가로세로 비율을 지정합니다.

아래 코드는 FacetGrid() 함수를 사용하여 플롯을 생성하고, map() 메서드를 사용하여 각 서브플롯에 데이터를 시각화하는 예제입니다. time'에 따라 열을 구분하고, 'smoker'에 따라 색상을 구분하는 그리드를 생성합니다. 각 서브플롯에는 'total_bill'과 'tip' 사이의 산점도가 그려집니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Create a FacetGrid
g = sns.FacetGrid(tips, col="time", hue="smoker")

# Map a scatter plot to each facet
g.map(sns.scatterplot, "total_bill", "tip")

# Add a legend
g.add_legend()

map() 메서드는 먼저 그리드에 설정된 각 조합에 대해 데이터를 선택하고, 해당 데이터와 인수로 제공된 다른 인수와 함께 함수를 호출합니다. FacetGrid.map() 메서드의 주요 매개변수는 다음과 같습니다.

func : 각 서브플롯에 적용할 함수입니다. 대부분의 경우, 이것은 Matplotlib이나 Seaborn에서 제공하는 플로팅 함수일 것입니다.
*args : 함수에 전달할 추가 인수입니다. 여기에는 데이터 프레임의 변수 이름을 전달할 수 있습니다.

5.7 Joint Plots

5.7.1 jointplot()

jointplot() 함수는 두 변수 사이의 이변량(또는 조인트) 관계와 각 변수의 일변량(또는 마진) 분포를 동시에 표시하는 그래프를 생성합니다. 기본적으로 jointplot()는 중앙에 산점도를 표시하고, 상단과 오른쪽 축에는 각 변수의 히스토그램을 표시합니다. jointplot() 함수의 주요 매개변수는 다음과 같습니다.

x, y : 데이터셋에서 비교할 두 개의 변수 이름입니다.
data : 사용할 데이터 프레임입니다.
kind : 그리려는 플롯의 종류를 지정합니다. "scatter" (기본값), "kde", "hist", "hex", "reg", "resid" 등을 선택할 수 있습니다.
color : 모든 요소의 색상을 지정합니다.
height : 그래프의 크기를 지정합니다.
ratio : 중앙 그래프와 마진 그래프의 높이 비율을 지정합니다.
space : 중앙 그래프와 마진 그래프 사이의 공간을 지정합니다.

import seaborn as sns

# Load the example tips dataset
tips = sns.load_dataset("tips")

# Create a joint plot of total bill and tip
sns.jointplot(data=tips, x="total_bill", y="tip", kind="hex", color="g")

[Matplotlib 강좌 – 5] Matplotlib 고급 기법 활용하기: 그래프에 텍스트와 주석 추가, 축 스케일 변경, 그래프 겹치기, 이미지 저장하기

gogo5911 — Tue, 19 Dec 2023 00:06:48 +0900

1. 그래프에 텍스트, 주석 추가하기

Matplotlib는 그래프에 텍스트를 추가하거나 주석을 다는 것을 지원합니다. text 함수를 사용하여 그래프의 특정 위치에 텍스트를 추가할 수 있고, annotate 함수를 사용하여 그래프에 주석을 추가할 수 있습니다. 코드는 그래프에 텍스트와 주석을 추가하는 예제입니다.

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

ax.plot([1, 2, 3, 4], [1, 3, 2, 4])

# 그래프에 텍스트 추가
ax.text(1.5, 2.5, 'Sample Text', style='italic')

# 그래프에 주석 추가
ax.annotate('Max Value', xy=(3, 3), xytext=(4, 4),
            arrowprops=dict(facecolor='black', shrink=0.05))

plt.show()

ax.text() 함수는 특정 위치에 텍스트를 추가하는데 사용됩니다. 이 함수의 주요 매개변수는 다음과 같습니다.

x, y : 텍스트를 삽입할 위치를 나타내는 x와 y의 좌표입니다.
s : 출력할 텍스트입니다.
fontsize : 텍스트의 글꼴 크기를 지정합니다.
color : 텍스트의 색상을 지정합니다.
rotation : 텍스트의 회전 각도를 지정합니다.
horizontalalignment, verticalalignment : 이 매개변수들은 텍스트의 위치를 조정합니다. 'center', 'left', 'right', 'top', 'bottom', 'baseline' 등 다양한 값이 가능합니다.
backgroundcolor : 텍스트의 배경 색상을 지정합니다.
alpha : 텍스트의 투명도를 지정합니다. 0(완전 투명)에서 1(완전 불투명) 사이의 값입니다.

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

ax.text(0.5, 0.5, 'Hello, matplotlib', 
        fontsize=12, 
        color='blue', 
        rotation=45, 
        ha='center', 
        va='center', 
        alpha=0.5)

plt.show()

ax.annotate() 함수는 그래프 상의 특정 점에 주석(annotation)을 추가하는데 사용됩니다. 이 함수의 주요 매개변수는 다음과 같습니다.

text : 주석에 표시할 텍스트입니다.
xy : 주석이 가리키는 점의 위치입니다.
xytext : 주석 텍스트 자체의 위치입니다.
xycoords : xy 매개변수에 대한 좌표계를 지정합니다.
textcoords : xytext 매개변수에 대한 좌표계를 지정합니다.
arrowprops : 화살표의 속성을 지정하는 딕셔너리입니다. arrowstyle, color, linewidth 등 다양한 속성을 설정할 수 있습니다.

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

ax.plot(range(10))

ax.annotate('this point', 
            xy=(5, 5), 
            xytext=(2, 7),
            arrowprops=dict(facecolor='black'))

plt.show()

2. 축의 스케일 변경하기 (로그 스케일 등)

Matplotlib에서는 set_yscale, set_xscale 함수를 사용하여 각 축의 스케일을 변경할 수 있습니다. 로그 스케일로 변경하는 경우에는 'log'를 인자로 전달합니다.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0.1, 15, 400)
y = x**3

fig, ax = plt.subplots()

# x 축을 로그 스케일로 설정, 밑이 2인 로그 스케일로 설정
ax.set_xscale('log', base=2)

# y 축을 로그 스케일로 설정, 밑이 10인 로그 스케일로 설정
# 음수 값은 마스크 처리합니다 ('mask')
ax.set_yscale('log', base=10, nonpositive='mask')

ax.plot(x, y)
plt.show()

set_yscale() 및 set_xscale() 함수는 각각 y축 및 x축의 스케일을 설정하는 데 사용됩니다. 주요 매개변수는 다음과 같습니다.

value : 스케일의 유형을 지정하는 문자열입니다. 가능한 값에는 'linear', 'log', 'symlog', 'logit' 등이 있습니다.
base : 로그 스케일의 경우 로그의 밑을 지정하는 값입니다. 이 매개변수는 로그 스케일을 사용할 때만 사용됩니다.
subsx, subsy : 로그 스케일을 사용할 때 눈금의 위치를 설정하는 데 사용됩니다.
nonposx, nonposy : 음수 또는 0에 대한 처리 방법을 지정하는 문자열입니다. 이 매개변수는 로그나 로짓 스케일을 사용할 때만 사용됩니다.

3. 여러 그래프를 겹쳐 그리기

하나의 'Axes'에 여러 그래프를 그릴 수 있습니다. 이를 통해 여러 데이터를 비교할 수 있습니다. 코드는 두 개의 그래프를 겹쳐서 그리는 예제입니다.

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

x = [1, 2, 3, 4]
y1 = [1, 2, 3, 4]
y2 = [1, 3, 2, 4]

# 두 개의 그래프를 겹쳐서 그리기
ax.plot(x, y1, label='y1')
ax.plot(x, y2, label='y2')

ax.legend()  # 범례 추가

plt.show()

4. 이미지로 저장하기

savefig 함수를 사용하여 그래프를 이미지 파일로 저장할 수 있습니다. 다양한 형식의 이미지 파일을 지원하며, DPI 등의 설정도 가능합니다. 코드는 그래프를 이미지 파일로 저장하는 예제입니다. 이 파일은 실행 코드와 같은 디렉토리에 'test_plot.png'라는 이름으로 저장됩니다.

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4, 5])
plt.savefig("test_plot.png", dpi=300, format='png', transparent=True, bbox_inches='tight', pad_inches=0.1)

Matplotlib의 savefig() 함수는 그림을 이미지 파일로 저장하는데 사용되며, 다양한 매개 변수를 가지고 있습니다. 이 함수의 주요 매개 변수는 다음과 같습니다.

fname : 저장할 파일의 이름이나 경로입니다. 파일 확장자에 따라 이미지 형식이 결정됩니다 (예: .png, .jpg, .svg, .pdf 등).
dpi : 저장될 이미지의 해상도 (dots per inch)를 지정합니다. 기본적으로 figure.dpi를 사용합니다.
quality : (JPEG에만 해당) 출력 품질을 설정합니다. 1(최악)에서 95(기본값, 최고)까지 설정할 수 있습니다. 100은 최고 품질이지만, LZW 압축이 활성화되지 않습니다.
facecolor, edgecolor : 그림의 전경색과 배경색을 설정합니다. 기본적으로 figure.facecolor, figure.edgecolor를 사용합니다.
format : 명시적으로 파일 형식을 지정할 수 있습니다. 대개는 fname의 확장자를 사용하여 자동으로 결정됩니다.
transparent : 배경을 투명하게 할지 결정합니다. 기본값은 False입니다.
bbox_inches : 저장할 이미지의 범위를 설정합니다. 'tight'를 사용하면 출력 영역을 그림에서 사용하는 영역으로 제한하며, 필요한 경우 그림 크기를 줄입니다.
pad_inches : 저장할 이미지의 패딩을 설정합니다. 기본값은 0.1입니다.

[Matplotlib 강좌 – 4] Matplotlib의 Figure와 Subplot 이해하기: 복잡한 그래프 구성하기

gogo5911 — Tue, 19 Dec 2023 00:06:12 +0900

1. Figure 개념 이해하기

Matplotlib에서의Figure는 그래프를 그리기 위한 캔버스 같은 개념입니다. 'Figure'는 하나 이상의 'Axes'(그래프)를 포함할 수 있습니다. 여러 개의 그래프를 동시에 그릴 때, 각각의 그래프는 별도의 Figure에 속하게 됩니다. Figure는 다음과 같이 생성할 수 있습니다.

import matplotlib.pyplot as plt

fig = plt.figure()  # 빈 Figure 생성
plt.show()

plt.figure() 함수는 새로운 그림을 생성하며, 다음과 같은 매개변수가 있습니다.

num : 그림의 고유 번호 또는 이름. 이 매개변수를 사용하면 나중에 그림을 참조할 수 있습니다.
figsize : 그림의 너비와 높이를 지정하는 튜플입니다. 단위는 인치입니다.
dpi : 그림의 해상도를 지정하는 정수값. "dots per inch"의 약자입니다.
facecolor : 그림의 배경색을 지정하는 색상값입니다.
edgecolor : 그림의 테두리 색을 지정하는 색상값입니다.
frameon : 그림의 프레임을 그릴지 여부를 지정하는 불린 값입니다.

아래 코드의 figure()는 고유 이름을 'Sine Wave'로 설정하고, 크기를 10x6 인치로, 해상도를 100 dpi로 설정합니다. 또한, 그림의 배경색을 'lightgray'로, 테두리 색을 'black'으로 설정합니다. 마지막으로, 그림의 프레임을 그리도록 설정합니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

# 그림 생성
plt.figure(num='Sine Wave', figsize=(10, 6), dpi=100, facecolor='lightgray', edgecolor='black', frameon=True)

# 그래프 플롯
plt.plot(x, y, label="sin(x)")

# 레이블 및 타이틀 설정
plt.xlabel('x')
plt.ylabel('y')
plt.title('Sine Wave')
plt.legend()

# 그래프 표시
plt.show()

2. Subplot 사용법

Figure 내에는 하나 이상의 Subplot(서브 플롯)이 포함될 수 있습니다. 서브 플롯은 Figure 내의 개별 그래프를 나타내며, 여러 개의 그래프를 그리드 형태로 배열할 때 유용합니다. plt.subplots() 함수는 그림(Figure)과 서브플롯 객체의 배열(Axes)을 반환합니다. 서브 플롯은 다음과 같이 생성할 수 있습니다.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 400)
y = np.sin(x ** 2)

fig, axs = plt.subplots(2, 2)

axs[0, 0].plot(x, y)
axs[0, 0].set_title('Axis [0, 0]')

axs[0, 1].plot(x, y, 'tab:orange')
axs[0, 1].set_title('Axis [0, 1]')

axs[1, 0].plot(x, -y, 'tab:green')
axs[1, 0].set_title('Axis [1, 0]')

axs[1, 1].plot(x, -y, 'tab:red')
axs[1, 1].set_title('Axis [1, 1]')

for ax in axs.flat:
    ax.set(xlabel='x-label', ylabel='y-label')

# 가장 외부에 위치한 축의 레이블만 표시하게 합니다. 
for ax in axs.flat:
    ax.label_outer()

plt.show()

3. add_subplot() 사용

add_subplot() 메서드는 Matplotlib의 Figure 객체에 subplot(부분 그래프)를 추가하는 데 사용됩니다. 이 메서드는 subplot을 추가하고, 그 위치를 지정하며, 반환된 축 객체(Axes)를 사용해 그래프를 그립니다.

import matplotlib.pyplot as plt

fig = plt.figure()

ax1 = fig.add_subplot(2, 2, 1)  # 첫 번째 subplot 추가
ax2 = fig.add_subplot(2, 2, 2)  # 두 번째 subplot 추가
ax3 = fig.add_subplot(2, 2, 3)  # 세 번째 subplot 추가
ax4 = fig.add_subplot(2, 2, 4)  # 네 번째 subplot 추가

plt.show()

add_subplot() 메서드의 주요 매개변수는 다음과 같습니다.

nrows : 전체 행의 수를 지정합니다.
ncols : 전체 열의 수를 지정합니다.
index : 생성할 subplot의 인덱스를 지정합니다. 이 인덱스는 왼쪽에서 오른쪽, 위에서 아래로 1부터 시작합니다.
projection : 그래프의 유형을 지정합니다. 예를 들어, 'polar'를 지정하면 극 좌표 그래프를 생성합니다.
sharex, sharey : 다른 Axes 객체와 x축 또는 y축을 공유하도록 지정합니다.

import numpy as np
import matplotlib.pyplot as plt

# 데이터 생성
x = np.linspace(0, 2 * np.pi, 400)
y = np.sin(x ** 2)

fig = plt.figure(figsize=(8, 6))

# 첫 번째 subplot 추가 (위치: 왼쪽 상단, 극 좌표)
ax1 = fig.add_subplot(2, 2, 1, projection='polar')
ax1.plot(x, y)
ax1.set_title('First Subplot')

# 두 번째 subplot 추가 (위치: 오른쪽 상단, 직교 좌표)
ax2 = fig.add_subplot(2, 2, 2)
ax2.plot(x, y)
ax2.set_title('Second Subplot')

# 세 번째 subplot 추가 (위치: 왼쪽 하단, 직교 좌표, x축 공유)
ax3 = fig.add_subplot(2, 2, 3, sharex=ax2)
ax3.plot(x, y**2)
ax3.set_title('Third Subplot (Share x-axis with Second Subplot)')

# 네 번째 subplot 추가 (위치: 오른쪽 하단, 직교 좌표, x축 공유)
ax4 = fig.add_subplot(2, 2, 4, sharex=ax2)
ax4.plot(x, y**3)
ax4.set_title('Fourth Subplot (Share x-axis with Second Subplot)')

plt.tight_layout()  # 그래프 간 간격 조절
plt.show()

[Matplotlib 강좌 – 3] Matplotlib 그래프 종류 마스터하기: 라인, 스캐터, 히스토그램, 바, 파이, 박스, 에러바, 컨투어, 3D

gogo5911 — Tue, 19 Dec 2023 00:05:31 +0900

1. 다양한 그래프 유형에 대한 이해

1.1 Line Plot

Line Plot은 데이터 간의 연속성을 표현할 때 사용합니다. 시간에 따른 변화를 표현하거나, 데이터의 추세를 보여주기에 적합합니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Line plot 그리기
plt.plot(x, y)
plt.title('Line Plot - Sin function')
plt.show()

plot 함수는 매우 다양한 매개 변수를 가지고 있습니다. 주요 매개 변수다음과 같습니다.

x, y : 실제로 플롯에 표시되는 데이터입니다. x는 x축 값에 대한 목록이고, y는 y축 값에 대한 목록입니다.
fmt : 이는 색상, 마커 및 선 스타일을 결정하는 옵션입니다. 형식은 '[color][marker][line]'이며, 각 요소는 생략할 수 있습니다.
color : 선의 색상을 결정합니다.
linestyle, ls : 선의 스타일을 결정합니다. 예를 들어, 'dashed', 'dotted', 'solid', 'dashdot' 등이 있습니다.
linewidth, lw : 선의 너비를 설정합니다.
marker : 데이터 포인트에 대한 마커 스타일을 설정합니다. 예를 들어, 'o', '^', '*', 's' 등이 있습니다.
markersize, ms : 마커의 크기를 설정합니다.
markerfacecolor, mfc : 마커의 색상을 설정합니다.
markeredgecolor, mec : 마커 테두리의 색상을 설정합니다.
markeredgewidth, mew : 마커 테두리의 너비를 설정합니다.
label : 플롯에 대한 레이블을 설정하며, 이는 범례에서 사용됩니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 플롯 설정
plt.plot(x, y, 
         color='purple',          # 선의 색상을 보라색으로 설정
         linestyle='dashdot',      # 선의 스타일을 대시-점(dashdot)으로 설정
         linewidth=2,              # 선의 너비를 2로 설정
         marker='o',               # 마커 스타일을 원형('o')으로 설정
         markersize=5,             # 마커의 크기를 5로 설정
         markerfacecolor='yellow', # 마커의 색상을 노란색으로 설정
         markeredgecolor='red',    # 마커 테두리의 색상을 빨간색으로 설정
         markeredgewidth=1.5,      # 마커 테두리의 너비를 1.5로 설정
         label='sin(x)'            # 범례에서 표시될 라벨 설정
)

# 범례 표시
plt.legend()

# 그래프 출력
plt.show()

1.2 Scatter Plot

Scatter Plot은 두 변수 간의 관계를 표현할 때 사용합니다. 각 데이터 포인트는 x, y 좌표를 가지며, 이를 이용해 변수 간의 상관관계를 파악할 수 있습니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.random.rand(100)
y = np.random.rand(100)

# Scatter plot 그리기
plt.scatter(x, y)
plt.title('Scatter Plot')
plt.show()

scatter 함수는 2차원의 점들을 그림으로 표현하는데 사용됩니다. scatter 함수의 주요 매개 변수는 다음과 같습니다.

x, y : 플롯에 표시될 데이터입니다. x와 y는 각각 x축과 y축의 데이터를 나타냅니다.
s : 마커의 크기입니다. 스칼라 또는 스칼라의 배열이 될 수 있습니다. 디폴트는 None이며, 이 경우 마커의 크기는 rcParams에서 설정된 디폴트 크기로 설정됩니다.
c : 마커의 색상입니다. 색상의 이름, RGB 튜플, 또는 해당 점의 값을 나타내는 스칼라 값 또는 스칼라 값의 배열 등 다양한 형태로 설정할 수 있습니다.
marker : 마커의 스타일입니다. 다양한 마커 스타일이 가능합니다.
cmap : colormap입니다. 이는 c 매개변수가 float 형태일 때 사용됩니다.
norm : Normalize 인스턴스입니다. 이는 c 매개변수가 float 형태일 때 사용됩니다.
vmin, vmax : norm이 적용되기 전에 데이터에 적용되는 최소 및 최대 값입니다. c 매개변수가 float 형태일 때 사용됩니다.
alpha : 마커의 투명도입니다. 0(완전 투명)에서 1(완전 불투명) 사이의 값입니다.
linewidths : 마커 테두리의 너비입니다.
edgecolors : 마커 테두리 색입니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.random.rand(50)
y = np.random.rand(50)
colors = np.random.rand(50)
sizes = 1000 * np.random.rand(50)

# scatter 플롯 설정
plt.scatter(x, y, c=colors, s=sizes, alpha=0.3, cmap='viridis', edgecolors='red', linewidths=2)

# 그래프 출력
plt.show()

1.3 Histogram

Histogram은 변수의 분포를 표현할 때 사용합니다. 데이터를 구간별로 나누어 각 구간에 해당하는 데이터의 빈도를 표현합니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
data = np.random.randn(1000)

# Histogram 그리기
plt.hist(data, bins=30)
plt.title('Histogram')
plt.show()

hist 함수는 데이터의 히스토그램을 만드는데 사용됩니다. hist 함수의 주요 매개 변수는 다음과 같습니다.

x : 히스토그램을 만들 데이터입니다.
bins : 히스토그램의 바구니(bin)의 수입니다. 이는 각 데이터가 속하는 구간을 나타냅니다.
range : 바구니에 포함될 수 있는 최소, 최대 값의 튜플입니다. 이 매개 변수가 제공되지 않으면 x의 최소, 최대 값이 사용됩니다.
density : True로 설정하면, 히스토그램의 합계가 1이 되도록 정규화합니다. 이는 확률 밀도 함수를 추정할 때 유용합니다.
weights : 각 x의 가중치입니다. 이는 히스토그램이 빈도수가 아니라 다른 값에 따라 가중치를 적용할 때 유용합니다.
cumulative : True로 설정하면, 각 바구니에 이전 바구니의 합계를 추가하여 누적 히스토그램을 만듭니다.
histtype : 히스토그램의 타입을 결정합니다. 가능한 값은 'bar', 'barstacked', 'step', 'stepfilled'입니다.
align : 바구니와 가로축 간의 정렬 방법을 결정합니다. 'left', 'mid', 'right'가 가능합니다.
orientation : 히스토그램의 방향을 결정합니다. 'horizontal', 'vertical'이 가능합니다.
color : 히스토그램의 색상을 결정합니다.
label : 히스토그램에 대한 레이블을 설정합니다. 이는 범례에서 사용됩니다.

import matplotlib.pyplot as plt
import numpy as np

# 무작위 데이터 생성
data = np.random.randn(1000)

# 히스토그램 그리기
plt.hist(data, bins=30, range=(-3, 3), density=True, alpha=0.7, color='g', edgecolor='black', label='Data')

# 표준 정규 분포 그리기
from scipy.stats import norm
x = np.linspace(-3, 3, 1000)
y = norm.pdf(x, 0, 1)
plt.plot(x, y, 'r--', label='Normal distribution')

plt.legend()
plt.show()

1.4 Bar Plot

Bar Plot은 범주형 데이터의 값을 비교할 때 사용합니다. 각 범주에 해당하는 막대를 그리고, 막대의 높이로 값을 표현합니다.

import matplotlib.pyplot as plt

# 데이터 생성
categories = ['A', 'B', 'C', 'D', 'E']
values = [7, 3, 6, 2, 5]

# Bar plot 그리기
plt.bar(categories, values)
plt.title('Bar Plot')
plt.show()

bar 함수는 막대 그래프를 만드는데 사용되며, 주요 매개변수는 다음과 같습니다.

x : x 축에 위치할 데이터의 일련의 값입니다.
height : 각 막대의 높이를 나타내는 데이터의 일련의 값입니다.
width : (선택) 각 막대의 너비를 설정합니다. 스칼라 값이나 같은 길이의 배열이 될 수 있습니다. 디폴트 값은 0.8입니다.
bottom : (선택) 각 막대의 y 축에서의 위치를 설정합니다. 디폴트 값은 None으로, 막대는 그래프의 기본 위치인 y=0부터 시작됩니다.
align : 막대의 x 좌표를 막대의 가운데로 할 것인지, 막대의 왼쪽 끝으로 할 것인지를 결정합니다. 디폴트 값은 'center'입니다.
color : 막대의 색을 설정합니다.
edgecolor : 막대의 테두리 색을 설정합니다.
linewidth : 막대의 테두리 너비를 설정합니다.
tick_label : 각 막대에 대한 레이블을 설정합니다.
label : 범례에 사용될 레이블을 설정합니다.

import matplotlib.pyplot as plt

labels = ['A', 'B', 'C', 'D', 'E']
values = [3, 7, 2, 5, 8]

plt.bar(labels, values, width=0.4, bottom=2, align='center', color='lightblue', edgecolor='blue', linewidth=1.2, tick_label=labels, label='Category')
plt.legend()

plt.show()

1.5 Pie Chart

Pie Chart는 전체에 대한 각 부분의 비율을 표현할 때 사용합니다.

import matplotlib.pyplot as plt

# 데이터 생성
labels = ['A', 'B', 'C', 'D']
sizes = [15, 30, 45, 10]

# Pie chart 그리기
plt.pie(sizes, labels=labels, autopct='%1.1f%%')
plt.title('Pie Chart')
plt.show()

pie 함수는 원형 차트를 만드는 데 사용되며, 주요 매개변수는 다음과 같습니다.

x : 각 섹션의 크기를 나타내는 배열.
explode : 원형 차트에서 특정 섹션을 '분리'하기 위해 사용하는 배열. 각 섹션의 '분리' 정도를 설정합니다.
labels : 각 섹션의 레이블을 설정하는 리스트.
colors : 각 섹션의 색상을 설정하는 리스트.
autopct : 각 섹션의 퍼센트 값을 자동으로 표시할 방법을 설정합니다. 이는 문자열 형태로 주어지며, 이 문자열 내에는 퍼센트 값을 삽입할 위치를 나타내는 '%1.1f%%' 등의 형식을 사용합니다.
pctdistance : 각 섹션의 중심과 퍼센트 레이블 사이의 거리를 설정합니다. 이 값은 반지름에 대한 상대적인 거리입니다.
shadow : 그림자를 그릴지 여부를 결정하는 불린 값.
labeldistance : 각 섹션의 중심과 레이블 사이의 거리를 설정합니다. 이 값은 반지름에 대한 상대적인 거리입니다.
startangle : 원형 차트가 시작하는 각도를 설정합니다. 이 값은 도(degree) 단위로 설정됩니다.
radius : 원형 차트의 반지름을 설정합니다.
counterclock : 섹션이 시계 반대 방향으로 그려질지, 시계 방향으로 그려질지를 설정합니다.

import matplotlib.pyplot as plt

# Pie chart, where the slices will be ordered and plotted counter-clockwise:
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0)  # only "explode" the 2nd slice (i.e. 'Hogs')

fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels, autopct='%1.1f%%',
        shadow=True, startangle=90)
ax1.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.

plt.show()

1.6 Box Plot

Box Plot은 변수의 분포를 요약하여 표현할 때 사용합니다. 중앙값, 사분위수, 이상치 등을 한눈에 볼 수 있습니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
data = np.random.randn(1000)

# Box plot 그리기
plt.boxplot(data)
plt.title('Box Plot')
plt.show()

boxplot 함수는 박스 플롯을 만드는 데 사용되며, 주요 매개변수는 다음과 같습니다.

x : 플롯에 표시될 데이터입니다. 배열이나 유사한 객체가 될 수 있습니다.
notch : 노치형 박스 플롯을 만들지 여부를 결정하는 불린 값.
sym : 이상치를 어떻게 표시할지를 결정하는 문자열.
vert : 박스 플롯이 수직으로 그려질지, 수평으로 그려질지를 결정하는 불린 값.
whis : whisker(수염)의 범위를 결정하는 값.
positions : 각 박스의 위치를 결정하는 배열.
widths : 각 박스의 너비를 결정하는 스칼라 값이나 배열.
patch_artist : 박스 플롯을 Patch 인스턴스로 그릴지를 결정하는 불린 값.
labels : 각 박스에 대한 레이블을 설정하는 리스트.

import matplotlib.pyplot as plt
import numpy as np

# 랜덤 데이터 생성
np.random.seed(10)
data = [np.random.normal(0, std, 100) for std in range(1, 5)]

fig = plt.figure(figsize =(10, 7))
ax = fig.add_subplot(111)

# Boxplot 생성
bp = ax.boxplot(data, patch_artist = True, notch = True, vert = 0)

# 플롯 제목
plt.title("Customized box plot")

# 플롯 보여주기
plt.show()

1.7 Error Bar

Error Bar는 데이터의 불확실성을 표현할 때 사용합니다. 데이터 포인트 주변에 오차를 나타내는 선을 그립니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 10, 10)
y = x ** 2
errors = np.random.rand(10) * 5

# Error bar 그리기
plt.errorbar(x, y, yerr=errors, fmt='o')
plt.title('Error Bar')
plt.show()

errorbar는 오차 막대가 있는 데이터 플롯을 생성하는 데 사용되며, 주요 매개변수는 다음과 같습니다.

x, y : 플롯에 표시될 데이터의 x와 y 좌표입니다.
yerr, xerr : 수직 및 수평 오차 범위입니다. 스칼라 값, 동일한 길이의 리스트나 배열, 두 개의 동일한 길이의 리스트나 배열(하한 및 상한)이 될 수 있습니다.
fmt : 플롯의 포맷 스타일입니다. 선 종류와 색상을 결정합니다. 예를 들어, 'ro'는 빨간색 원을 의미합니다.
ecolor : 오차 막대의 색상입니다.
elinewidth : 오차 막대의 선 너비입니다.
capsize : 오차 막대의 끝에 있는 "캡"의 크기입니다.
capthick : 오차 막대 캡의 두께입니다.

import numpy as np
import matplotlib.pyplot as plt

# 데이터 생성
x = np.linspace(0, 10, 50)
dy = 0.8
y = np.sin(x) + dy * np.random.randn(50)

# 오차 막대 그래프 생성
plt.errorbar(x, y, yerr=dy, fmt='.k', ecolor='lightgray', elinewidth=3, capsize=0)

plt.show()

1.8 Contour Plot

Contour Plot은 3차원 데이터를 2차원으로 표현할 때 사용합니다. 색상이나 높이선으로 z 값을 표현합니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# Contour plot 그리기
plt.contourf(X, Y, Z, cmap='viridis')
plt.title('Contour Plot')
plt.show()

errorbar는 오차 막대가 있는 데이터 플롯을 생성하는데 사용되며, 주요 매개변수는 다음과 같습니다.

x, y : 플롯에 표시될 데이터의 x와 y 좌표입니다.
yerr, xerr : 수직 및 수평 오차 범위입니다. 스칼라 값, 동일한 길이의 리스트나 배열, 두 개의 동일한 길이의 리스트나 배열(하한 및 상한)이 될 수 있습니다.
fmt : 플롯의 포맷 스타일입니다. 선 종류와 색상을 결정합니다. 예를 들어, 'ro'는 빨간색 원을 의미합니다.
ecolor : 오차 막대의 색상입니다.
elinewidth : 오차 막대의 선 너비입니다.
capsize : 오차 막대의 끝에 있는 "캡"의 크기입니다.
capthick : 오차 막대 캡의 두께입니다.

import numpy as np
import matplotlib.pyplot as plt

# 좌표 생성
x = np.linspace(-3.0, 3.0, 100)
y = np.linspace(-3.0, 3.0, 100)
X, Y = np.meshgrid(x, y)
Z = np.sqrt(X**2 + Y**2)

# 등고선 플롯 생성
plt.contourf(X, Y, Z, levels=20, cmap='RdGy')
plt.title('Contour Plot')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

1.9 3D Plot

3D Plot은 3차원 데이터를 표현할 때 사용합니다. X, Y, Z 값을 가지는 3차원 공간에 데이터를 표현합니다.

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 데이터 생성
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# 3D plot 그리기
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis')
plt.title('3D Plot')
plt.show()

plot_surface 함수는 3차원 플롯에서 서피스 플롯을 만드는 데 사용됩니다. 이 함수는 Axes3D 객체의 메소드로 존재하며, matplotlib의 plot_surface의 주요 매개 변수는 다음과 같습니다.

X, Y, Z : X와 Y는 그리드 좌표를 나타내며, Z는 해당 그리드에서의 높이(또는 값)를 나타냅니다.
rstride, cstride : 이것들은 서피스 플롯에서의 행 및 열 단계 크기를 설정합니다. 큰 값은 그리드를 더 거칠게 만들며, 작은 값은 그리드를 더 세밀하게 만듭니다.
color : 서피스의 색상을 설정합니다.
cmap : colormap을 설정합니다.
facecolors : 각 서피스 패치의 색상을 설정합니다.
norm : Normalize 인스턴스로, 색상 맵의 스케일링을 제어합니다.
vmi, vmax : 색상 맵의 범위를 설정합니다.
shade : bool 값으로, 서피스를 그림자 처리할지를 결정합니다.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# 좌표 생성
x = np.linspace(-6, 6, 100)
y = np.linspace(-6, 6, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# 3D 서피스 플롯 생성
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis', edgecolor='none')
ax.set_title('Surface Plot')
plt.show()

[Matplotlib 강좌 – 2] Matplotlib 기본 사용법: 단순 그래프부터 세부 설정까지

gogo5911 — Tue, 19 Dec 2023 00:04:41 +0900

1. 간단한 그래프 그리기

Matplotlib를 이용하여 간단한 그래프를 그리는 방법을 살펴보겠습니다. 기본적으로 pyplot 서브모듈의 plot 함수를 이용하여 선 그래프를 그릴 수 있습니다. 아래 코드는 0부터 10까지 범위에서 sin 함수를 그리는 예제입니다. 코드를 실행하면 0부터 10까지 범위의 sin 함수 그래프가 생성됩니다.

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

2. 그래프에 타이틀, 라벨, 범례 추가하기

그래프에 title(), xlabel(), ylabel()를 이용해 타이틀, x축 라벨, y축 라벨을 추가할 수 있습니다. 또한, 한 그래프에 여러 선이 있을 경우 각 선이 무엇을 의미하는지 나타내기 위해 legend()를 통해 범례를 추가할 수 있습니다. 아래 코드는 이를 구현한 예제입니다. 코드를 실행하면 sin(x) 그래프와 cos(x) 그래프가 동시에 그려지고, 그래프의 제목, x축 라벨, y축 라벨, 그리고 범례가 표시됩니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 그래프 그리기
plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')

# 타이틀과 라벨 설정
plt.title('Sin and Cos Graphs')
plt.xlabel('X values')
plt.ylabel('Function values')

# 범례 추가
#plt.legend(('sin','cos'))
plt.legend()


plt.show()

3. 색상, 선 스타일, 마커 변경하기

plot 함수는 다양한 스타일 옵션을 제공합니다. 이를 통해 선의 색상, 스타일, 데이터 포인트의 마커 모양 등을 변경할 수 있습니다. 형식은 '[color][marker][line]'이며, 각각의 요소는 생략할 수 있습니다. 아래 코드는 이를 구현한 예제입니다. linestyle의 경우 dashed', 'dotted', 'solid', 'dashdot' 등이 있습니다. marker의 경우 o', '^', '*', 's' 등이 있습니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 10, 40) # 데이터 포인트가 보이도록 데이터 간격을 크게 잡음
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x) * np.cos(x)
y4 = np.cos(x)**2 - np.sin(x)**2
y5 = np.tan(x)

# y1에 대한 plot 설정
plt.plot(x, y1, color='red', linestyle='dashed', marker='o')

# y2에 대한 plot 설정
plt.plot(x, y2, color='blue', linestyle='solid', marker='s')

# y3에 대한 plot 설정
plt.plot(x, y3, color='green', linestyle='dashdot', marker='^')

# y4에 대한 plot 설정
plt.plot(x, y4, color='purple', linestyle='dotted', marker='.')

# y5에 대한 plot 설정
plt.plot(x, y5, color='orange', linestyle='solid', marker='*')

# 범례 추가
plt.legend(['sin(x)', 'cos(x)', 'sin(x)*cos(x)', 'cos^2(x) - sin^2(x)', 'tan(x)'])

# 축 범위 설정 (y5는 tan 함수로 인해 무한대에 가깝게 갈 수 있으므로 y 범위 제한)
plt.ylim([-5,5])

# 그래프 출력
plt.show()

4. 축의 범위 설정하기

xlim과 ylim 함수를 사용하면 그래프의 x축과 y축의 범위를 직접 설정할 수 있습니다. 아래 코드는 이를 구현한 예제입니다. 코드를 실행하면 x축이 0부터 2π까지, y축이 -1.5부터 1.5까지 범위를 가지는 sin 함수 그래프가 생성됩니다.

import matplotlib.pyplot as plt
import numpy as np

# 데이터 생성
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 그래프 그리기
plt.plot(x, y)

# 타이틀과 라벨 설정
plt.title('Sin Graph')
plt.xlabel('X values')
plt.ylabel('Sin values')

# 축 범위 설정
plt.xlim(0, 2 * np.pi)  # x축 범위 설정
plt.ylim(-1.5, 1.5)  # y축 범위 설정

plt.show()

[Matplotlib 강좌 – 1] Matplotlib 시작하기 : 파이썬 데이터 시각화

gogo5911 — Tue, 19 Dec 2023 00:04:00 +0900

1. Matplotlib 소개

Matplotlib은 Python에서 데이터를 시각적으로 표현하기 위한 가장 기본적이고 널리 사용되는 라이브러리입니다. 대표적으로는 선 그래프, 히스토그램, 산점도 등 다양한 형태의 차트와 플롯을 생성할 수 있습니다. Matplotlib은 다음과 같은 특징을 가지고 있습니다.

자세한 부분까지 커스터마이징이 가능합니다.
PNG, PDF, SVG, EPS 등 다양한 형식으로 그래프를 출력할 수 있습니다.
Python과 NumPy만 있으면 어느 플랫폼에서도 동작합니다.
PyQt, wxPython, Tkinter 등의 다양한 GUI 툴킷과 통합이 가능합니다.

2. Matplotlib 설치 방법

Matplotlib는 Python의 pip를 이용하여 설치할 수 있습니다. 아래의 코드를 콘솔 또는 터미널을 통해 실행합니다. 코드를 실행하면 Matplotlib가 설치됩니다.

pip install matplotlib

Python에서 Matplotlib을 사용하기 위해서는 일반적으로 아래와 같이 패키지를 불러옵니다.

import matplotlib.pyplot as plt

3. Matplotlib와 함께 사용하는 다른 라이브러리(Numpy, Pandas 등)

데이터 분석과 시각화를 위해 Matplotlib는 다른 라이브러리들과 잘 호환됩니다. 대표적인 라이브러리들은 Numpy와 Pandas가 있습니다.

아래는 Numpy와 Pandas를 사용하여 데이터를 생성하고, 이를 Matplotlib를 이용해 시각화하는 간단한 예제입니다. 아래 코드를 실행 하면 총 100개의 점을 이은 sin 그래프와 'X Value'와 'Sin of X'라는 두 컬럼을 가진 DataFrame이 출력됩니다.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# Numpy를 사용하여 데이터 생성
x = np.linspace(0, 10, 100)  # 0부터 10까지 동일 간격으로 100개의 숫자 생성
y = np.sin(x)  # x에 대한 sin 값 계산

# Matplotlib를 사용하여 선 그래프 그리기
plt.plot(x, y)
plt.show()  # 그래프 표시

# Pandas DataFrame 생성
df = pd.DataFrame({'X Value': x, 'Sin of X': y})

print(df.head())  # DataFrame의 첫 5개 행 출력

# DataFrame 출력 예시
#   X Value  Sin of X
#0  0.000000  0.000000
#1  0.101010  0.100838
#2  0.202020  0.200648
#3  0.303030  0.298413
#4  0.404040  0.393136

[Pandas 강좌 – 9] Pandas(판다스) 성능 향상을 이용한 대용량 데이터 처리 방법

gogo5911 — Mon, 18 Dec 2023 23:59:43 +0900

1. 데이터 타입 최적화

Pandas에서는 각 데이터 유형에 따라 메모리를 다르게 사용합니다. 따라서 데이터 타입을 최적화하면 메모리 사용량을 줄일 수 있습니다. 예를 들어, 'category' 데이터 타입은 범주형 데이터(즉, 값의 범위가 제한적인 데이터)를 표현할 때 효율적인 메모리 사용이 가능합니다.

범주형 데이터는 특정한 범위 또는 범주 내에서만 값이 변하는 데이터를 의미합니다. 예를 들어, '성별' 열에는 '남성', '여성' 두 가지 값만 있을 수 있으며, '계절' 열에는 '봄', '여름', '가을', '겨울' 네 가지 값만 있을 수 있습니다. 이처럼 고유한 값의 종류가 제한적인 열을 'category' 데이터 타입으로 표현하면 메모리를 효율적으로 사용할 수 있습니다.

import pandas as pd

# 간단한 데이터프레임을 생성합니다.
df = pd.DataFrame({
    'A': ['dog', 'cat', 'dog', 'cat', 'dog', 'cat', 'dog', 'dog'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three']
})

# 'A' 열의 데이터 타입을 'category'로 변경합니다.
df['A'] = df['A'].astype('category')

print(df.dtypes)

이와 같은 방법 외에도 정수 또는 부동소수점 수를 저장하는 열의 경우, 필요한 범위에 맞는 가장 작은 데이터 타입을 선택함으로써 메모리를 절약할 수 있습니다. 예를 들어, -128에서 127 사이의 정수값만을 가진 열의 경우 'int8' 데이터 타입을 사용하면 됩니다. 이는 'int16', 'int32', 'int64'와 같은 더 큰 데이터 타입을 사용하는 것에 비해 메모리 사용량을 줄일 수 있습니다.

import numpy as np

# 'int64' 데이터 타입을 가진 열을 생성합니다.
df = pd.DataFrame(np.random.randint(0, 100, size=(1000, 1)), columns=list('A'))

# 'int8' 데이터 타입으로 변경합니다.
df['A'] = df['A'].astype(np.int8)

print(df.dtypes)

2. 벡터화된 연산 사용

Pandas는 벡터화된 연산을 지원하며 이를 사용하면 계산의 성능을 크게 향상시킬 수 있습니다. 벡터화된 연산이란 배열 또는 시리즈 등의 모든 요소에 대한 연산을 한 번에 처리하는 것을 말합니다. 이는 일반적인 for-loop를 통한 반복 연산에 비해 훨씬 빠르고 효율적입니다. 이는 Pandas가 내부적으로 NumPy를 사용하기 때문입니다. NumPy는 고성능의 다차원 배열 객체와 이를 다루기 위한 도구들을 제공하며, 이를 통해 벡터화된 연산을 수행할 수 있습니다.

# 좋지 않은 예: 반복문을 사용한 연산
for i in range(len(df)):
    df.loc[i, 'age'] = df.loc[i, 'age'] + 1

# 좋은 예: 벡터화된 연산 사용
df['age'] = df['age'] + 1

3. 필요한 데이터만 불러오기

큰 데이터셋을 다룰 때, 모든 데이터를 한 번에 메모리에 로드하는 것은 비효율적이며, 때로는 불가능할 수도 있습니다. 이런 경우에는 필요한 열만 선택하여 불러오는 것이 좋습니다. 이렇게 하면 사용하는 메모리 양을 크게 줄일 수 있습니다. Pandas의 read_csv 함수를 사용할 때 usecols 매개변수를 활용하여 필요한 열만 불러올 수 있습니다. usecols는 불러올 열의 이름이나 인덱스를 리스트로 전달하면 됩니다.

# 'age'와 'fare' 열만 불러오기
cols = ['age', 'fare']
df = pd.read_csv('titanic.csv', usecols=cols)

4. 대용량 데이터 처리를 위한 chunksize 사용

Pandas의 read_csv() 함수에는 chunksize 매개변수가 있어서 이를 활용하면 대용량 데이터를 효율적으로 처리할 수 있습니다. chunksize를 설정하면 read_csv() 함수는 'TextFileReader' 객체를 반환합니다. 이 객체는 이터레이터로 사용할 수 있으며, 각 이터레이션은 데이터프레임의 청크(조각)를 반환합니다. 코드에서는 각 청크를 별도로 처리한 후, 마지막에 pd.concat() 함수를 사용하여 모든 청크를 하나의 데이터프레임으로 결합하고 있습니다. 이 방법을 사용하면 메모리에 한 번에 로드되는 데이터의 양을 제한하면서도 대용량 데이터를 효과적으로 처리할 수 있습니다.

chunksize = 50000  # 한 번에 불러올 행의 수를 설정합니다.

chunks = []  # 각 청크를 저장할 리스트를 생성합니다.

for chunk in pd.read_csv('large_dataset.csv', chunksize=chunksize):
    # 이 곳에서 각 청크를 처리할 수 있습니다. 예를 들어, 각 청크에 대해 데이터 전처리를 수행하거나,
    # 특정 조건을 만족하는 행만 선택할 수 있습니다.
    
    chunks.append(chunk)

# 모든 청크를 하나의 데이터프레임으로 결합합니다.
df = pd.concat(chunks, axis=0)

[Pandas 강좌 – 8] Pandas(판다스)를 활용한 시계열 데이터 처리 (Date TimeIndex, Reasampling)

gogo5911 — Mon, 18 Dec 2023 23:58:48 +0900

1. DateTimeIndex 활용

Pandas의 DateTimeIndex는 날짜와 시간 정보를 기반으로 하는 인덱스입니다. DateTimeIndex를 활용하면, 시간 정보에 따른 데이터 선택, 부분 데이터 집합 추출 등이 용이해집니다. 아래의 예제 코드는 일련의 날짜를 기반으로 DataFrame을 생성하고 이를 활용하는 방법을 보여줍니다. 코드에서 date_range 함수는 주어진 시작 날짜로부터 특정 기간 동안의 날짜를 생성합니다. 이 날짜들은 DataFrame의 인덱스로 사용되며, 이를 통해 각 행이 어떤 날짜에 해당하는 데이터인지를 쉽게 파악할 수 있습니다.

import pandas as pd
import numpy as np

# 날짜 범위 생성
dates = pd.date_range('20230101', periods=6)

# DataFrame 생성
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))

# 출력
print(df)

#                   A         B         C         D
# 2023-01-01  0.930245 -0.047665  0.522884  0.968767
# 2023-01-02  0.563050 -0.435333 -0.714463 -0.003575
# 2023-01-03  0.828224  0.582605  0.231393 -1.368924
# 2023-01-04  0.668463 -0.078117 -0.238567 -0.134624
# 2023-01-05  0.367208  0.428259 -1.607944  0.379299
# 2023-01-06 -1.151233  1.316921 -0.567834  0.715714

date_range() 함수는 다음과 같은 매개변수를 포함합니다.

start : 범위의 시작을 나타내는 문자열 또는 날짜 시간입니다.
end : 범위의 끝을 나타내는 문자열 또는 날짜 시간입니다.
periods : 생성할 기간 수를 나타내는 정수입니다. start와 end가 주어진 경우 이 매개변수는 선택적입니다.
freq : 빈도 문자열 또는 객체입니다 (예: 'D'는 일별, 'M'는 월별, 'Y'는 연간). 기본값은 'D'로 일별 빈도입니다.
tz : 시간대를 나타내는 문자열입니다.
normalize : 시작 및 종료 매개 변수를 자정으로 정규화할지 여부를 결정하는 부울. 기본값은 False입니다.
name : 반환된 DatetimeIndex에 대한 이름입니다.

import pandas as pd

# 2020년 1월 1일부터 10일간의 날짜 생성
print(pd.date_range(start='1/1/2020', periods=10))

# DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',
#                '2020-01-05', '2020-01-06', '2020-01-07', '2020-01-08',
#                '2020-01-09', '2020-01-10'],
#               dtype='datetime64[ns]', freq='D')


# 2020년 1월 1일부터 2020년 2월 1일까지 일별 날짜 생성
print(pd.date_range(start='1/1/2020', end='2/1/2020'))

# DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',
#                '2020-01-05', '2020-01-06', '2020-01-07', '2020-01-08',
#                '2020-01-09', '2020-01-10', '2020-01-11', '2020-01-12',
#                '2020-01-13', '2020-01-14', '2020-01-15', '2020-01-16',
#                '2020-01-17', '2020-01-18', '2020-01-19', '2020-01-20',
#                '2020-01-21', '2020-01-22', '2020-01-23', '2020-01-24',
#                '2020-01-25', '2020-01-26', '2020-01-27', '2020-01-28',
#                '2020-01-29', '2020-01-30', '2020-01-31', '2020-02-01'],
#               dtype='datetime64[ns]', freq='D')


# 2020년 1월 1일부터 10일간의 날짜를 시간별로 생성 (1시간 간격)
print(pd.date_range(start='1/1/2020', periods=10, freq='H'))

# DatetimeIndex(['2020-01-01 00:00:00', '2020-01-01 01:00:00',
#                '2020-01-01 02:00:00', '2020-01-01 03:00:00',
#                '2020-01-01 04:00:00', '2020-01-01 05:00:00',
#                '2020-01-01 06:00:00', '2020-01-01 07:00:00',
#                '2020-01-01 08:00:00', '2020-01-01 09:00:00'],
#               dtype='datetime64[ns]', freq='H')

2. 시계열 데이터 리샘플링

시계열 데이터를 처리하는 데 있어 중요한 요소 중 하나는 데이터의 리샘플링입니다. 리샘플링은 원래의 데이터를 다른 빈도로 변환하는 것을 의미하며, 이는 'downsampling'(고해상도 데이터를 저해상도로 변환)과 'upsampling'(저해상도 데이터를 고해상도로 변환)을 포함합니다. 아래의 예제 코드는 시계열 데이터의 리샘플링을 보여줍니다. 코드에서 resample 함수는 원래의 '시간별' 데이터를 '일별' 데이터로 다시 샘플링하며, 이 과정에서 각 일별 데이터는 해당 일에 해당하는 모든 시간별 데이터의 평균으로 계산됩니다.

import pandas as pd
import numpy as np

# 시간별로 표시된 데이터 생성
rng = pd.date_range('20230101', periods=100, freq='H')
print(rng)


# DatetimeIndex(['2023-01-01 00:00:00', '2023-01-01 01:00:00',
#                '2023-01-01 02:00:00', '2023-01-01 03:00:00',
#                '2023-01-01 04:00:00', '2023-01-01 05:00:00',
#                '2023-01-01 06:00:00', '2023-01-01 07:00:00',
#                '2023-01-01 08:00:00', '2023-01-01 09:00:00',
#                ...
#                '2023-01-04 22:00:00', '2023-01-04 23:00:00',
#                '2023-01-05 00:00:00', '2023-01-05 01:00:00',
#                '2023-01-05 02:00:00', '2023-01-05 03:00:00'],
#               dtype='datetime64[ns]', freq='H')



ts = pd.Series(np.random.randn(len(rng)), index=rng)
print(ts)


# 2023-01-01 00:00:00   -1.413259
# 2023-01-01 01:00:00   -0.052131
# 2023-01-01 02:00:00    1.788970
# 2023-01-01 03:00:00   -1.646791
# 2023-01-01 04:00:00   -0.249388
# ...
# 2023-01-04 23:00:00    0.039376
# 2023-01-05 00:00:00   -1.134042
# 2023-01-05 01:00:00   -0.618590
# 2023-01-05 02:00:00    1.658975
# 2023-01-05 03:00:00   -1.424104
# Freq: H, Length: 100, dtype: float64


# 데이터를 일별로 리샘플링
resampled = ts.resample('D').mean()

# 출력
print(resampled)

# 2023-01-01    0.065184
# 2023-01-02   -0.060284
# 2023-01-03   -0.170753
# 2023-01-04   -0.178925
# 2023-01-05   -0.379440
# Freq: D, dtype: float64

[Pandas 강좌 – 7] Pandas(판다스) 데이터 그룹화하기 (Grouphy 함수 이해와 활용)

gogo5911 — Mon, 18 Dec 2023 23:58:24 +0900

1. Groupby 함수 이해

Pandas의 groupby 함수는 데이터를 원하는 기준에 따라 그룹으로 분류하고, 이렇게 분류된 그룹에 대해 다양한 연산을 수행할 수 있습니다. 이러한 방식은 SQL의 GROUP BY 구문과 유사합니다. 아래 코드에서 groupby 함수는 "Animal" 열을 기준으로 데이터를 그룹화하고, 각 그룹의 내용을 출력합니다.

import pandas as pd

# DataFrame 생성
df = pd.DataFrame({
   'Animal': ['Falcon', 'Falcon', 'Parrot', 'Parrot'],
   'Max Speed': [380., 370., 24., 26.],
   'Weight': [1.5, 1.7, 0.3, 0.2]
})

# 그룹화
grouped = df.groupby("Animal")

# 그룹화 결과 확인
for name, group in grouped:
    print(name)
    print(group)
    print("\n")

# Falcon
#    Animal  Max Speed  Weight
# 0  Falcon      380.0     1.5
# 1  Falcon      370.0     1.7
# 
# 
# Parrot
#    Animal  Max Speed  Weight
# 2  Parrot       24.0     0.3
# 3  Parrot       26.0     0.2

groupby 함수는 여러 매개변수를 가지고 있습니다.

by : 이 매개변수에는 그룹화를 하고자 하는 열 또는 열의 목록을 전달합니다. 특정 열 또는 열의 조합에 따라 그룹화를 수행합니다.
axis : 이 매개변수는 그룹화를 수행하려는 축을 지정합니다. 기본값은 0입니다.
level : 이 매개변수는 멀티 인덱스(MultiIndex)에서 레벨에 따라 그룹화를 수행합니다.
as_index : 이 매개변수는 True일 때 그룹 레이블을 인덱스로 사용합니다. 기본값은 True입니다. False로 설정하면, 그룹화 열이 출력 결과에 열로 유지되며 인덱스로 사용되지 않습니다.
sort : 이 매개변수는 그룹 키에 따라 그룹을 정렬할지 여부를 결정합니다. 기본값은 True입니다. False로 설정하면, 그룹화는 키의 발견 순서대로 수행됩니다.
group_keys : 이 매개변수는 각 그룹의 키를 결과에 추가할지 여부를 결정합니다. 기본값은 True입니다.
squeeze : 이 매개변수는 가능한 경우 반환된 그룹을 Series로 압축할지 여부를 결정합니다. 기본값은 False입니다.
observed : 이 매개변수는 카테고리(Categorical) 형태의 열이 있는 데이터를 그룹화할 때 사용되며, True로 설정하면 관찰된 카테고리만을 그룹화합니다.

2. Groupby를 이용한 연산 (Sum, Mean 등)

그룹화된 데이터에는 다양한 통계 함수를 적용할 수 있습니다. 아래 코드에서는 각각 그룹화된 데이터에 대해 평균(mean), 합계(sum), 최대값(max) 연산을 적용합니다.

# 그룹화된 데이터에 mean 함수 적용
print(grouped.mean())

#         Max Speed  Weight
# Animal
# Falcon      375.0    1.60
# Parrot       25.0    0.25

# 그룹화된 데이터에 sum 함수 적용
print(grouped.sum())

#         Max Speed  Weight
# Animal
# Falcon      750.0     3.2
# Parrot       50.0     0.5

# 그룹화된 데이터에 max 함수 적용
print(grouped.max())


#         Max Speed  Weight
# Animal
# Falcon      380.0     1.7
# Parrot       26.0     0.3

[Pandas 강좌 – 6] Pandas(판다스)를 통한 데이터 병합하기 (Concat, Merge, Join 사용법)

gogo5911 — Mon, 18 Dec 2023 23:55:44 +0900

1. pandas.concat() 함수 사용법

pandas.concat()은 각기 다른 데이터프레임들을 하나로 합치는 함수입니다. 이 때, 기본적으로는 행 방향으로 합치며 (axis=0), 열 방향으로 합치려면 axis=1을 설정해주면 됩니다. 아래 코드에서 pd.concat([df1, df2])을 통해 df1과 df2를 행 방향으로 합칩니다.

import pandas as pd

# 예제 데이터프레임 생성
df1 = pd.DataFrame({
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
}, index=[0, 1, 2, 3])

df2 = pd.DataFrame({
    'A': ['A4', 'A5', 'A6', 'A7'],
    'B': ['B4', 'B5', 'B6', 'B7'],
    'C': ['C4', 'C5', 'C6', 'C7'],
    'D': ['D4', 'D5', 'D6', 'D7']
}, index=[4, 5, 6, 7])

# pandas.concat() 사용
result = pd.concat([df1, df2])
print(result)

pd.concat() 함수의 주요 매개 변수들은 다음과 같습니다.

objs : 이 매개 변수는 합치려는 pandas 데이터프레임들의 리스트를 받습니다.
axis : 이 매개 변수는 연결 방향을 지정합니다. 0은 행 방향(기본값), 1은 열 방향입니다.
join : 이 매개 변수는 'inner'(두 데이터프레임의 공통 열만 보존)와 'outer'(두 데이터프레임의 모든 열을 보존, 기본값) 중 하나를 선택할 수 있게 합니다.
ignore_index : 이 매개 변수가 True로 설정되면, 합친 후의 데이터프레임에서 기존 인덱스는 무시되고 새로운 인덱스가 부여됩니다. 기본값은 False입니다.

import pandas as pd

# 예제 데이터프레임 생성
df1 = pd.DataFrame({
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
}, index=[0, 1, 2, 3])

df2 = pd.DataFrame({
    'A': ['A4', 'A5', 'A6', 'A7'],
    'B': ['B4', 'B5', 'B6', 'B7'],
    'E': ['E4', 'E5', 'E6', 'E7'],
    'F': ['F4', 'F5', 'F6', 'F7']
}, index=[4, 5, 6, 7])

# pandas.concat() 사용 - axis=0, join='outer', ignore_index=False
result = pd.concat([df1, df2])
print(result)

#     A   B    C    D    E    F
# 0  A0  B0   C0   D0  NaN  NaN
# 1  A1  B1   C1   D1  NaN  NaN
# 2  A2  B2   C2   D2  NaN  NaN
# 3  A3  B3   C3   D3  NaN  NaN
# 4  A4  B4  NaN  NaN   E4   F4
# 5  A5  B5  NaN  NaN   E5   F5
# 6  A6  B6  NaN  NaN   E6   F6
# 7  A7  B7  NaN  NaN   E7   F7

# pandas.concat() 사용 - axis=1
result = pd.concat([df1, df2], axis=1)
print(result)


#      A    B    C    D    A    B    E    F
# 0   A0   B0   C0   D0  NaN  NaN  NaN  NaN
# 1   A1   B1   C1   D1  NaN  NaN  NaN  NaN
# 2   A2   B2   C2   D2  NaN  NaN  NaN  NaN
# 3   A3   B3   C3   D3  NaN  NaN  NaN  NaN
# 4  NaN  NaN  NaN  NaN   A4   B4   E4   F4
# 5  NaN  NaN  NaN  NaN   A5   B5   E5   F5
# 6  NaN  NaN  NaN  NaN   A6   B6   E6   F6
# 7  NaN  NaN  NaN  NaN   A7   B7   E7   F7

# pandas.concat() 사용 - join='inner'
result = pd.concat([df1, df2], join='inner')
print(result)


#     A   B
# 0  A0  B0
# 1  A1  B1
# 2  A2  B2
# 3  A3  B3
# 4  A4  B4
# 5  A5  B5
# 6  A6  B6
# 7  A7  B7


# pandas.concat() 사용 - ignore_index=True
result = pd.concat([df1, df2], ignore_index=True)
print(result)


#     A   B    C    D    E    F
# 0  A0  B0   C0   D0  NaN  NaN
# 1  A1  B1   C1   D1  NaN  NaN
# 2  A2  B2   C2   D2  NaN  NaN
# 3  A3  B3   C3   D3  NaN  NaN
# 4  A4  B4  NaN  NaN   E4   F4
# 5  A5  B5  NaN  NaN   E5   F5
# 6  A6  B6  NaN  NaN   E6   F6
# 7  A7  B7  NaN  NaN   E7   F7

2. pandas.merge() 함수 사용법

pandas.merge()는 두 데이터프레임의 공통 열 혹은 인덱스를 기준으로 두 개의 테이블을 합칩니다. 이 때, on 파라미터를 사용해 기준이 되는 열을 지정할 수 있습니다. 아래 코드에서 pd.merge(df1, df2, on='key')를 통해 key 열을 기준으로 df1과 df2를 합칩니다.

# 예제 데이터프레임 생성
df1 = pd.DataFrame({
    'key': ['A', 'B', 'C', 'D'],
    'value': range(4)
})

df2 = pd.DataFrame({
    'key': ['B', 'D', 'D', 'E'],
    'value': range(4, 8)
})

# pandas.merge() 사용
merged = pd.merge(df1, df2, on='key')
print(merged)

pandas.merge() 함수의 주요 매개 변수들은 다음과 같습니다.

left, right : 이 매개 변수들은 병합하려는 두 데이터프레임을 나타냅니다.
on : 이 매개 변수는 병합의 기준이 되는 열의 이름을 나타냅니다.
how : 이 매개 변수는 병합 방식을 나타냅니다. 기본값은 'inner'이며, 'outer', 'left', 'right'를 선택할 수 있습니다.
suffixes : 이 매개 변수는 중복된 열 이름에 대해 접미사를 추가합니다. 기본값은 ('_x', '_y')입니다.

import pandas as pd

# 예제 데이터프레임 생성
df1 = pd.DataFrame({
    'key': ['A', 'B', 'C', 'D'],
    'value': range(4)
})

df2 = pd.DataFrame({
    'key': ['B', 'D', 'D', 'E'],
    'value': range(4, 8)
})

# pandas.merge() 사용
merged = pd.merge(df1, df2, on='key')
print(merged)


#   key  value_x  value_y
# 0   B        1        4
# 1   D        3        5
# 2   D        3        6

# pandas.merge() 사용 - how='outer'
merged = pd.merge(df1, df2, on='key', how='outer')
print(merged)


#   key  value_x  value_y
# 0   A      0.0      NaN
# 1   B      1.0      4.0
# 2   C      2.0      NaN
# 3   D      3.0      5.0
# 4   D      3.0      6.0
# 5   E      NaN      7.0


# pandas.merge() 사용 - how='left'
merged = pd.merge(df1, df2, on='key', how='left')
print(merged)

#   key  value_x  value_y
# 0   A        0      NaN
# 1   B        1      4.0
# 2   C        2      NaN
# 3   D        3      5.0
# 4   D        3      6.0


# pandas.merge() 사용 - suffixes
merged = pd.merge(df1, df2, on='key', suffixes=('_left', '_right'))
print(merged)

#   key  value_left  value_right
# 0   B           1            4
# 1   D           3            5
# 2   D           3            6

3. pandas.DataFrame.join() 함수 사용법

join() 메서드는 두 데이터프레임의 인덱스를 기준으로 합치는 방법입니다. merge()와 달리 기본적으로 인덱스를 사용하며, on 파라미터를 통해 다른 열을 기준으로 합칠 수 있습니다. 아래 코드에서 df1.join(df2)를 통해 df1과 df2의 인덱스를 기준으로 데이터프레임을 합칩니다. join() 메서드 역시 how 파라미터를 통해 join 방식을 선택할 수 있습니다.

# 예제 데이터프레임 생성
df1 = pd.DataFrame({
    'A': ['A0', 'A1', 'A2'],
    'B': ['B0', 'B1', 'B2']
}, index=['K0', 'K1', 'K2'])

df2 = pd.DataFrame({
    'C': ['C0', 'C2', 'C3'],
    'D': ['D0', 'D2', 'D3']
}, index=['K0', 'K2', 'K3'])

# pandas.DataFrame.join() 사용
joined = df1.join(df2)
print(joined)

pandas.DataFrame.join() 함수의 주요 매개 변수들은 다음과 같습니다.

other : 이 매개 변수는 조인하려는 다른 데이터프레임을 나타냅니다.
on : 이 매개 변수는 호출 데이터프레임의 열 또는 인덱스를 기준으로 결합합니다. other의 인덱스와 일치해야 합니다.
how : 이 매개 변수는 조인 방식을 나타냅니다. 기본값은 'left'이며, 'outer', 'inner', 'right'를 선택할 수 있습니다.
lsuffix, rsuffix: 이 매개 변수들은 중복된 열 이름에 대해 접미사를 추가합니다.

import pandas as pd

# 예제 데이터프레임 생성
df1 = pd.DataFrame({
    'A': ['A0', 'A1', 'A2'],
    'B': ['B0', 'B1', 'B2']
}, index=['K0', 'K1', 'K2'])

df2 = pd.DataFrame({
    'C': ['C0', 'C2', 'C3'],
    'D': ['D0', 'D2', 'D3']
}, index=['K0', 'K2', 'K3'])

# DataFrame.join() 사용
joined = df1.join(df2)
print(joined)


#      A   B    C    D
# K0  A0  B0   C0   D0
# K1  A1  B1  NaN  NaN
# K2  A2  B2   C2   D2


# DataFrame.join() 사용 - how='outer'
joined = df1.join(df2, how='outer')
print(joined)

#       A    B    C    D
# K0   A0   B0   C0   D0
# K1   A1   B1  NaN  NaN
# K2   A2   B2   C2   D2
# K3  NaN  NaN   C3   D3


df3 = pd.DataFrame({
    'A': ['A3', 'A4', 'A5'],
    'B': ['B3', 'B4', 'B5']
}, index=['K0', 'K1', 'K2'])

# DataFrame.join() 사용 - lsuffix, rsuffix
joined = df1.join(df3, lsuffix='_df1', rsuffix='_df3')
print(joined)


#    A_df1 B_df1 A_df3 B_df3
# K0    A0    B0    A3    B3
# K1    A1    B1    A4    B4
# K2    A2    B2    A5    B5

[Pandas 강좌 – 5] Pandas(판다스)를 통한 데이터 조작 및 변형(결측치 처리, 데이터 타입 변환 등)

gogo5911 — Mon, 18 Dec 2023 23:54:53 +0900

데이터 분석을 위해 데이터를 조작하고 변형하는 작업은 필수적입니다. Pandas는 이러한 데이터 전처리 작업을 쉽게 할 수 있는 다양한 기능을 제공합니다.

1. 결측치 처리(NaN)

Pandas에서는 isnull이나 notnull 메소드를 사용하여 결측치를 확인할 수 있습니다. 또한 dropna나 fillna 메소드를 사용하여 결측치를 제거하거나 다른 값으로 채울 수 있습니다.

아래 코드에서는 isnull(), dropna(), fillna() 함수를 통해 결측치를 처리합니다. isnull()은 DataFrame내의 결측치를 확인하는데 사용됩니다. 각 값이 결측치인지 아닌지를 나타내는 Boolean값(True 또는 False)를 반환합니다. 여기서 True는 결측치를 의미합니다. dropna()는 결측치를 포함하는 행 또는 열을 제거하는데 사용됩니다. 기본적으로 행을 제거하지만, 매개변수를 조정하여 열을 제거하도록 설정할 수도 있습니다. fillna()는 결측치를 다른 값으로 대체하는데 사용됩니다. 아래 코드에서는 결측치를 0으로 대체합니다.

코드는 A, B, C라는 세 개의 열을 가진 DataFame을 생성합니다. np.nan은 결측치를 의미하므로, A열의 두 번째 값과 B열의 첫 번째 값은 결측치입니다. 먼저 isnull()함수를 사용하여 각 값이 결측치인지 확인합니다. 그리고 dropna()함수를 사용하여 결측치를 포함하는 모든 행을 제거합니다. 이 경우 ,A열의 두 번째 행과 B열의 첫 번째 행에 결측치가 있으므로, 해당 행들이 제거됩니다. 마지막으로 fillna(0) 함수를 사용하여 결측치를 0으로 대체합니다.

import pandas as pd
import numpy as np

# DataFrame 생성
df = pd.DataFrame({
   'A': [1, np.nan, 3],
   'B': [np.nan, 5, 6],
   'C': [7, 8, 9]
})

# 결측치 확인
print(df.isnull())

#       A      B      C
#0  False   True  False
#1   True  False  False
#2  False  False  False

# 결측치 제거
df_dropna = df.dropna()
print(df_dropna)

#     A    B  C
#2  3.0  6.0  9

# 결측치를 0으로 채우기
df_fillna = df.fillna(0)
print(df_fillna)

#     A    B  C
#0  1.0  0.0  7
#1  0.0  5.0  8
#2  3.0  6.0  9

2. 중복된 데이터 처리

Pandas에서는 duplicated(), drop_duplicates()를 사용하여 중복된 데이터를 처리할 수 있습니다. duplicated()는 DataFrame의 각 행이 중복인지 아닌지를 판단합니다. 중복된 행은 True로 표시되고, 중복되지 않은 행은 False로 표시됩니다. drop_duplicates는 DataFrame에서 중복된 행을 제거합니다. 기본적으로 첫 번째 등장하는 행을 유지하고 그 후에 나타나는 중복 행을 제거합니다. 이 함수는 원본 DataFrame을 수정하지 않고 새로운 DataFrame을 반환합니다.

코드는 A, B, C라는 세 개의 열을 가진 DataFrame을 생성합니다. 여기서 두 번째 행과 세 번째 행이 동일하므로 중복된 데이터가 있습니다. duplicated() 함수를 사용하여 각 행이 중복인지 확인합니다. 여기서 두 번째 행과 세 번째 행이 동일하므로 세 번째 행에서 True가 반환됩니다. 마지막으로 drop_duplicates() 함수를 사용하여 중복 행을 제거합니다.

import pandas as pd

# DataFrame 생성
df = pd.DataFrame({
   'A': [1, 2, 2],
   'B': [3, 4, 4],
   'C': [5, 6, 6]
})

# 중복 데이터 확인
print(df.duplicated())

#0    False
#1    False
#2     True

# 중복 데이터 제거
df_dropped = df.drop_duplicates()
print(df_dropped)

#   A  B  C
#0  1  3  5
#1  2  4  6

3. 데이터 타입 변환

Pandas에서는 데이터 타입을 변환하는데 다양한 방법들이 있습니다. 데이터 타입 변환은 분석이나 데이터 처리에 필요한 특정 타입으로 데이터를 변환하는 과정을 의미합니다.

astype()은 Pandas 객체를 지정된 데이터 타입으로 변환합니다. 예를 들어 아래 코드 처럼 DataFrame의 특정 열이 숫자로 되어 있을 때 이를 문자열로 바꾸고 싶을 때 사용할 수 있습니다.

df['column_name'] = df['column_name'].astype(str)

to_datetime()은 문자열을 datetime객체로 변환하는데 사용됩니다. 이 함수는 다양한 날짜/시간 형식의 문자열을 처리할 수 있습니다. 예를 들어 아래 코드처럼 날짜를 나타내는 문자열이 있고 이를 datetime객체로 변환할 때 사용할 수 있습니다.

df['date_column'] = pd.to_datetime(df['date_column'])

to_numeric()는 숫자로 변환할 수 있는 문자열을 숫자로 변환합니다. errors 매개변수를 'coerce'로 설정하면 변환할 수 없는 값은 NaN으로 처리됩니다.

df['numeric_column'] = pd.to_numeric(df['numeric_column'], errors='coerce')

to_timedelta()는 문자열, 숫자, 또는 timedelta 값을 표현하는 다른 시퀀스를 Timedelta 객체로 변환합니다.

df['timedelta_column'] = pd.to_timedelta(df['timedelta_column'])

4. Column 이름 변경

Pandas DataFrame에서 열 이름(또는 컬럼 이름)을 변경하는 방법은 여러 가지가 있습니다. 여기에서는 rename()과 columns 속성 변경, set_axis() 을 통해 Column의 이름을 변경해보겠습니다.

rename()은 원하는 Column의 이름을 쉽게 변경할 수 있는 함수입니다. 아래 코드 처럼 함수 내에서 dictionary형태로 기존 이름을 새 이름으로 매핑합니다. 이 함수는 원본 DataFrame을 직접 변경하지 않고 새로운 DataFrame을 반환합니다.

df = df.rename(columns={'old_name1': 'new_name1', 'old_name2': 'new_name2'})

columns 속성 변경은 DataFrame의 columns 속성을 사용하여 모든 columns 이름을 새로운 값으로 바꿀 수 있습니다. 새로운 columns 이름 리스트의 길이는 반드시 원본 DataFrame의 columns 수와 일치해야합니다.

df.columns = ['new_name1', 'new_name2', 'new_name3']

set_axis()는 rename()과 비슷하게 작동하지만, axis 매개변수를 사용하여 columns 이름뿐만 아니라 index이름도 변경할 수 있습니다. set_axis() 함수도 원본 DataFrame을 직접 변경하지 않고 새로운 DataFrame을 반환합니다. 만약 원본 DataFrame을 변경하고자 하면 inplace=True 옵션을 사용해야합니다.

df.set_axis(['new_name1', 'new_name2', 'new_name3'], axis=1, inplace=True)

5. Column 추가 및 삭제

Pandas에서 column을 추가하거나 삭제하는 방법은 다양합니다. 먼저 Column 추가 및 삭제를 위한 간단한 DataFrame을 만들겠습니다.

import pandas as pd

df = pd.DataFrame({
   'A': [1, 2, 3],
   'B': [4, 5, 6],
   'C': [7, 8, 9]
})

print(df)

#   A  B  C
#0  1  4  7
#1  2  5  8
#2  3  6  9

가장 간단한 방법은 새로운 열을 인덱싱하고 값을 할당하는 것입니다. 이때 value는 여러 가지 형태가 될 수 있습니다. 하나의 값을 할당하면 해당 값이 모든 행에 대해 동일하게 할당되고, 리스트나 배열을 할당하면 각 행에 다른 값이 할당됩니다.

df['D'] = [10, 11, 12]
print(df)

#   A  B  C   D
#0  1  4  7  10
#1  2  5  8  11
#2  3  6  9  12

assign() 함수를 사용하여 새로운 열을 추가할 수 있습니다. 이 함수는 기존 DataFrame을 변경하지 않고 새로운 DataFrame을 반환합니다. 이 함수는 모든 행에 대해 같은 값을 가진 새로운 열을 생성하거나, 각 행에 대해 다른 값을 가진 새로운 열을 생성할 수 있습니다.

df = df.assign(E = [13, 14, 15])
print(df)

#   A  B  C   D   E
#0  1  4  7  10  13
#1  2  5  8  11  14
#2  3  6  9  12  15

insert() 함수를 사용하여 DaraFrame의 특정 위치에 새로운 열을 삽입할 수 있습니다. 이 함수는 원본 DataFrame을 직접 변경합니다. 코드에서 loc는 새로운 열을 삽입할 위치의 인덱스이고, new_column은 새로운 열의 이름이며, value는 새로운 열의 값입니다.

df.insert(2, 'F', [16, 17, 18])
print(df)

#   A  B   F  C   D   E
#0  1  4  16  7  10  13
#1  2  5  17  8  11  14
#2  3  6  18  9  12  15

열을 삭제하는 가장 일반적인 방법은 drop()함수를 사용하는 것입니다. drop()함수는 지정된 열을 제거한 새로운 DataFrame을 반환합니다. 원본 DataFrame을 변경하려면 inplace=True 옵션을 사용하거나 반환 값을 원래의 DataFrame에 다시 할당해야 합니다.

df = df.drop('D', axis=1)
print(df)

#   A  B   F  C   E
#0  1  4  16  7  13
#1  2  5  17  8  14
#2  3  6  18  9  15

또한 del 키워드를 사용하여 열을 삭제할 수도 있습니다. del 키워드는 원본 DataFrame에서 지정된 열을 바로 삭제합니다.

del df['E']
print(df)

#   A  B   F  C
#0  1  4  16  7
#1  2  5  17  8
#2  3  6  18  9

[Pandas 강좌 – 4] Pandas(판다스)를 활용한 데이터 정렬(값과 인덱스를 통한 정렬)

gogo5911 — Mon, 18 Dec 2023 23:54:04 +0900

Pandas의 DataFrame과 Series 객체를 정렬하는 방법에는 주로 두 가지가 있습니다. 값에 따른 정렬방법과 인덱스에 따라 정렬하는 방법입니다. 이들은 각각 sort_values() 메서드와 sort_index() 메서드를 사용하여 수행됩니다. 먼저 DataFrame을 생성하고 이에 대해 설명하도록 하겠습니다.

import pandas as pd

# 예시 DataFrame 생성
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 24, 35, 32],
        'City': ['New York', 'Paris', 'Berlin', 'London']}
df = pd.DataFrame(data)

#출력
#   Name  Age       City
#0  John   28   New York
#1  Anna   24      Paris
#2  Peter  35     Berlin
#3  Linda  32     London

1. 값에 따른 정렬

sort_values() 메서드는 하나 이상의 열의 값을 기준으로 DataFrame을 정렬합니다. sort_values의 구문은 아래와 같고 매개변수는 다음과 같습니다.

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)

by : 정렬의 기준이 될 열의 이름(문자열)이나 열의 리스트.
axis : 0 또는 'index'로 설정하면 인덱스를 기준으로 정렬하며, 1 또는 'columns'로 설정하면 열을 기준으로 정렬합니다.
ascending : 정렬의 방식을 설정합니다. True는 오름차순 정렬, False는 내림차순 정렬을 의미합니다. 여러 열을 기준으로 정렬할 때는 리스트를 사용할 수 있습니다.
inplace : True로 설정하면 원래의 DataFrame을 변경하고, False로 설정하면 새로운 DataFrame을 반환합니다.
kind : 정렬 알고리즘을 선택합니다. 'quicksort', 'mergesort', 'heapsort' 중 하나를 선택할 수 있습니다.
na_position : 'first' 또는 'last'를 선택하여 결측치의 위치를 정할 수 있습니다.
ignore_index : True로 설정하면 정렬 후 인덱스를 재설정합니다.
key : 각 열에 적용하여 정렬을 결정하는 함수를 지정할 수 있습니다.

# Age 열을 기준으로 오름차순 정렬
df.sort_values(by='Age')

# Age 열을 기준으로 내림차순 정렬
df.sort_values(by='Age', ascending=False)

# 두 열을 기준으로 정렬. 먼저 'City'를 오름차순으로, 그 다음 'Age'를 내림차순으로 정렬
df.sort_values(by=['City', 'Age'], ascending=[True, False])

2. 인덱스에 따른 정렬

sort_index 함수는 DataFrame의 인덱스를 기준으로 정렬합니다. sort_index 의 구문은 아래와 같습니다. 매개변수는 sort_values()메서드와 유사하나 추가적으로 level 매개변수가 있습니다. 이 매개변수는 다중 인덱스가 있을 때 정렬하려는 인덱스의 레벨을 지정하는 매개변수입니다.

DataFrame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None)

# 인덱스를 기준으로 오름차순 정렬
df.sort_index()

# 인덱스를 기준으로 내림차순 정렬
df.sort_index(ascending=False)

[Pandas 강좌 – 3] Pandas(판다스) 데이터 조회 및 선택 (loc, iloc)

gogo5911 — Mon, 18 Dec 2023 23:53:21 +0900

Pandas의 DataFrame과 Series는 다양한 조회 및 선택 메소드를 제공합니다. 이 포스트에서는 loc, iloc, 조건을 이용한 선택, 그리고 Column, Row 선택에 대해 자세히 설명하겠습니다.

1. loc, iloc 함수 사용법

판다스(Pandas)의 DataFrame과 Series는 판다스의 주요 객체이며, 여기에는 loc와 iloc이라는 데이터 선택 메소드가 포함되어 있습니다. loc는 레이블 기반의 데이터 선택 메소드입니다. 이는 레이블(열/행 이름)을 통해 값을 선택합니다. iloc는 위치 기반의 데이터 선택 메소드입니다. 이는 위치(정수 인덱스)를 통해 값을 선택합니다.

먼저 loc와 iloc의 사용 방법을 살펴보기 위해 아래 코드를 통해 DataFrame을 만듭니다.

import pandas as pd

# 간단한 데이터 프레임 생성
data = {
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
}

df = pd.DataFrame(data, index=['Row0', 'Row1', 'Row2', 'Row3'])

print(df)

#       A   B   C   D
#Row0  A0  B0  C0  D0
#Row1  A1  B1  C1  D1
#Row2  A2  B2  C2  D2
#Row3  A3  B3  C3  D3

loc를 사용하여 행, 열, 특정 행, 열을 선택하는 방법은 아래 코드와 같습니다. 코드에서 첫 번째는 행을 선택하는 방법이고, 두 번째는 여러 행을 선택하는 방법입니다. 세 번째는 행과 열을 동시에 선택하는 방법이며, 네 번째는 특정 행의 여러 열을 선택하는 방법입니다.

print(df.loc['Row0'])  # Row0 행의 데이터를 선택

#출력
#A    A0
#B    B0
#C    C0
#D    D0

print(df.loc[['Row0', 'Row2']])  # 'Row0'과 'Row2' 행의 데이터를 선택

#출력
#       A   B   C   D
#Row0  A0  B0  C0  D0
#Row2  A2  B2  C2  D2

print(df.loc['Row0', 'A'])  # 'Row0'행의 'A'열 데이터를 선택

#출력
#A0

print(df.loc['Row0', ['A', 'B']])  # 'Row0'행의 'A', 'B'열 데이터를 선택

#출력
#A    A0
#B    B0

iloc를 사용하여 행, 열, 특정 행, 열을 선택하는 방법은 아래 코드와 같습니다. 코드에서 첫 번째는 행을 선택하는 방법이고, 두 번째는 여러 행을 선택하는 방법입니다. 세 번째는 행과 열을 동시에 선택하는 방법이며, 네 번째는 특정 행의 여러 열을 선택하는 방법입니다.

print(df.iloc[0])  # 첫 번째 행의 데이터를 선택

#출력
#A    A0
#B    B0
#C    C0
#D    D0

print(df.iloc[[0, 2]])  # 첫 번째와 세 번째 행의 데이터를 선택

#출력
#       A   B   C   D
#Row0  A0  B0  C0  D0
#Row2  A2  B2  C2  D2

print(df.iloc[0, 0])  # 첫 번째 행의 첫 번째 열 데이터를 선택

#출력
#A0

print(df.iloc[0, [0, 1]])  # 첫 번째 행의 첫 번째, 두 번째 열 데이터를 선택

#출력
#A    A0
#B    B0

2. 조건을 이용한 데이터 선택하기

DataFrame에서 특정 조건을 만족하는 데이터를 선택기 위해 Boolean 인덱싱을 사용할 수 있습니다. 즉, 데이터프레임에 조건을 적용하면 각 요소가 조건을 만족하는지에 대한 True/False 값을 반환합니다. 이를 이용해 True에 해당하는 데이터만을 선택하여 가져올 수 있습니다.

아래 코드는 데이터프레임에서 A열의 값이 A2인 행을 선택하는 코드입니다. 이 코드를 실행하면 A열의 값이 A2인 행만 선택하여 출력됩니다.

selected_rows = df[df['A'] == 'A2']
print(selected_rows)

#       A   B   C   D
#Row2  A2  B2  C2  D2

두 개 이상의 조건을 사용하려면 &(and) 또는 |(or) 연산자를 사용할 수 있습니다. 아래 코드는 A열의 값이 A2이고 B열의 값이 B2인 행을 선택하는 코드입니다.

selected_rows = df[(df['A'] == 'A2') & (df['B'] == 'B2')]
print(selected_rows)

#       A   B   C   D
#Row2  A2  B2  C2  D2

[Pandas 강좌 – 2] Pandas(판다스)로 CSV, Excel, SQL 데이터 불러오고 저장하기

gogo5911 — Mon, 18 Dec 2023 23:52:25 +0900

Pandas에서 CSV, Excel, SQL 사용하기

Pandas는 다양한 데이터 형식을 지원하며, 이를 활용하여 데이터를 불러오거나 저장할 수 있습니다. 이 포스트에서는 CSV, Excel, SQL 데이터베이스에서 데이터를 불러오고 저장하는 방법에 대해 자세히 설명하겠습니다.

1. Pandas에서 CSV 파일 사용하기

CSV(Comma Separated Values) 파일은 간단한 텍스트 기반 형식으로 데이터를 저장하는데 사용됩니다. CSV 파일의 각 행은 데이터 레코드를 나타내며, 각 레코드의 필드는 쉼표로 구분됩니다. CSV 파일은 표 형식의 데이터를 표현하는데 주로 사용됩니다. 아래는 5명의 학생들의 이름, 나이, 성별 데이터를 포함하는 CSV 파일의 간단한 예 입니다.

name,age,gender
John,20,M
Sarah,22,F
Bob,21,M
Alice,19,F
Tom,23,M

Pandas는 read_csv()함수를 통해 CSV 파일을 읽어들일 수 있습니다. read_csv 함수는 지정된 경로의 CSV 파일을 읽어들여 DataFrame으로 변환합니다.

import pandas as pd

# csv 파일을 불러옵니다.
df = pd.read_csv('students.csv')

# 데이터프레임을 출력합니다.
print(df)

#    name  age gender
#0   John   20      M
#1  Sarah   22      F
#2    Bob   21      M
#3  Alice   19      F
#4    Tom   23      M

read_csv() 함수의 주요 매개변수는 아래와 같습니다.

filepath_or_buffer : 파일 경로(문자열) 또는 유사한 객체를 지정합니다.
sep : 필드를 구분하는 데 사용되는 구분자를 지정합니다. 기본값은 ','입니다.
delimiter : sep와 같은 기능을 가진 매개변수입니다.
header : 열 이름으로 사용할 행 번호를 지정합니다. 기본값은 'infer'로, 열 이름이 있는 행을 자동으로 감지합니다.
names : 결과 데이터프레임의 열 이름 목록입니다.
index_col : 인덱스로 사용할 열 번호 또는 이름을 지정합니다.
usecols : 읽을 열의 번호나 이름의 리스트를 지정합니다.
dtype : 각 열의 데이터 타입을 지정합니다.
na_values : 결측치로 간주할 값을 지정합니다.

import pandas as pd

# 특정 열만 읽고, 열의 데이터 타입을 지정합니다.
df = pd.read_csv('students.csv', usecols=['name', 'age'], dtype={'age': 'int64'})

print(df)

#    name  age
#0   John   20
#1  Sarah   22
#2    Bob   21
#3  Alice   19
#4    Tom   23

to_csv()함수는 DataFrame을 CSV파일로 저장하는 데 사용되며, 아래와 같은 주요 매개변수를 가지고 있습니다.

path_or_buf : 파일 경로(문자열) 또는 유사한 객체를 지정합니다.
sep : 필드를 구분하는 데 사용되는 구분자를 지정합니다. 기본값은 ','입니다.
na_rep : 결측치를 나타내는 문자열을 지정합니다. 기본값은 ''입니다.
float_format : 부동 소수점 숫자를 포맷하는 문자열을 지정합니다.
columns : 저장할 열의 순서를 지정하는 리스트를 지정합니다. 기본적으로 모든 열이 저장됩니다.
header : 열 이름을 파일에 포함할지 여부를 지정합니다. 기본값은 True입니다.
index : 행 인덱스를 파일에 포함할지 여부를 지정합니다. 기본값은 True입니다.
index_label : 인덱스 열의 라벨을 지정합니다.
mode : 파일 열기 모드를 지정합니다. 기본값은 'w'입니다.

# 데이터프레임을 CSV 파일로 저장합니다. 인덱스는 저장하지 않습니다.
df.to_csv('students.csv', index=False)

2. Pandas에서 Excel 파일 사용하기

Pandas에서 Excel 파일을 읽고 저장하고 처리하는 것도 CSV 파일을 처리하는 방법과 매우 유사합니다. 다만 Excel파일을 처리할 때는 read_excel()함수와 to_excel()함수를 사용합니다. 아래는 5명의 학생들의 이름, 나이, 성별 데이터를 포함하는 excel 파일의 간단한 예 입니다.

read_excel()함수는 지정된 경로의 Excel 파일을 읽어들여 DataFrame으로 변환합니다.

import pandas as pd

# Excel 파일 불러오기
df = pd.read_excel('filename.xlsx')

# DataFrame을 출력
print(df)

#    name  age gender
#0   John   20      M
#1  Sarah   22      F
#2    Bob   21      M
#3  Alice   19      F
#4    Tom   23      M

아래는 read_excel()함수의 주요 매개변수입니다.

io : 파일 경로(문자열), 파일 객체, URL을 지정합니다.
sheet_name : 읽을 시트 이름이나 번호를 지정합니다. 기본값은 0입니다 (첫 번째 시트). 문자열, 정수, 문자열 리스트, 정수 리스트, None(모든 시트) 등을 지정할 수 있습니다.
header : 열 이름으로 사용할 행 번호를 지정합니다. 기본값은 0입니다 (첫 번째 행).
names : 결과 데이터프레임의 열 이름 목록입니다.
index_col : 인덱스로 사용할 열 번호 또는 이름을 지정합니다.
usecols : 읽을 열의 번호나 이름의 리스트를 지정합니다.
dtype : 각 열의 데이터 타입을 지정합니다.
na_values : 결측치로 간주할 값을 지정합니다.

import pandas as pd

# 특정 열만 읽고, 열의 데이터 타입을 지정합니다.
df = pd.read_excel('students.xlsx', usecols=['name', 'age'], dtype={'age': 'int64'})

print(df)

to_excel()함수는 DataFrame을 Excel파일로 저장하는 데 사용되며, 아래와 같은 주요 매개변수를 가지고 있습니다.

excel_writer : 파일 경로(문자열) 또는 ExcelWriter 객체를 지정합니다.
sheet_name : 시트의 이름을 문자열로 지정합니다. 기본값은 'Sheet1'입니다.
na_rep : 결측치를 나타내는 문자열을 지정합니다. 기본값은 ''입니다.
float_format : 부동 소수점 숫자를 포맷하는 문자열을 지정합니다.
columns : 저장할 열의 순서를 지정하는 리스트를 지정합니다. 기본적으로 모든 열이 저장됩니다.
header : 열 이름을 파일에 포함할지 여부를 지정합니다. 기본값은 True입니다.
index : 행 인덱스를 파일에 포함할지 여부를 지정합니다. 기본값은 True입니다.
index_label : 인덱스 열의 라벨을 지정합니다.
startrow : 데이터프레임을 시작할 최초 행 위치를 지정합니다. 기본값은 0입니다.
startcol : 데이터프레임을 시작할 최초 열 위치를 지정합니다. 기본값은 0입니다.

import pandas as pd

# 샘플 데이터프레임을 생성합니다.
data = {'name': ['John', 'Sarah', 'Bob', 'Alice', 'Tom'],
        'age': [20, 22, 21, 19, 23],
        'gender': ['M', 'F', 'M', 'F', 'M']}
df = pd.DataFrame(data)

# 데이터프레임을 Excel 파일로 저장합니다. 인덱스는 저장하지 않습니다.
df.to_excel('students.xlsx', index=False)

3. Pandas에서 SQL 데이터베이스 사용하기

Pandas는 SQL 쿼리 결과를 DataFrame으로 불러올 수 있습니다. read_sql_query 함수는 SQL 쿼리를 실행하고, 그 결과를 DataFrame으로 변환합니다. 아래 코드에서는 SQLite 데이터베이스와 연결을 생성하고, 해당 데이터베이스에 쿼리를 실행합니다.

import pandas as pd
import sqlite3

# SQLite 데이터베이스에 연결합니다.
conn = sqlite3.connect('students.db')

# SQL 쿼리의 결과를 데이터프레임으로 불러옵니다.
df = pd.read_sql_query("SELECT * FROM students", conn)

# 데이터프레임을 출력합니다.
print(df)

아래는 read_sql_query()함수의 주요 매개변수입니다.

sql : 실행할 SQL 쿼리를 문자열로 지정합니다.
con : 데이터베이스 연결 객체를 지정합니다. SQLAlchemy engine, sqlite3 connection 등을 사용할 수 있습니다.
index_col : 인덱스로 사용할 열의 이름을 지정합니다.
coerce_float : 기본값은 True입니다. 이는 가능한 경우 모든 숫자를 float로 변환합니다.
params : SQL 쿼리에 바인딩할 매개변수 목록 또는 사전을 지정합니다.
parse_dates : 날짜를 파싱할 열의 이름을 지정합니다.
chunksize : 쿼리 결과를 여러 개의 데이터프레임으로 나누어 반환합니다. 각 데이터프레임의 행 수는 chunksize에 의해 결정됩니다.

import pandas as pd
import sqlite3

# SQLite 데이터베이스에 연결합니다.
conn = sqlite3.connect('students.db')

# SQL 쿼리의 결과를 데이터프레임으로 불러옵니다.
# 여기서는 'age' 열이 20 이상인 행만 선택합니다.
df = pd.read_sql_query("SELECT * FROM students WHERE age >= 20", conn)

print(df)

# 데이터베이스 연결을 닫습니다.
conn.close()

to_sql()함수는 DataFrame을 데이터베이스의 테이블로 저장하는 데 사용되며, 아래와 같은 주요 매개변수를 가지고 있습니다.

name : SQL 데이터베이스에서 생성할 테이블의 이름을 지정합니다.
con : 데이터베이스 연결 객체를 지정합니다. SQLAlchemy engine, sqlite3 connection 등을 사용할 수 있습니다.
schema : SQLAlchemy schema를 지정합니다.
if_exists : 테이블이 이미 존재하는 경우의 동작을 지정합니다. 'fail', 'replace', 'append' 중 하나를 선택할 수 있습니다. 기본값은 'fail'입니다.
'fail' : 기본값으로, 테이블이 이미 존재하면 아무 동작도 수행하지 않습니다.
'replace' : 테이블이 이미 존재하면 기존 테이블을 제거하고 새로운 테이블을 생성합니다.
'append' : 테이블이 이미 존재하면 새로운 데이터를 기존 테이블에 추가합니다.
index : 데이터프레임의 인덱스를 테이블에 저장할지 여부를 지정합니다. 기본값은 True입니다.
index_label : 인덱스 열의 라벨을 지정합니다.
chunksize : 한 번에 쓸 행의 수를 지정합니다. 이 매개변수를 사용하면 대용량 데이터를 처리하는 데 유용합니다.
dtype : 열의 SQL 타입을 지정하는 사전을 제공합니다.

import pandas as pd
import sqlite3

# 샘플 데이터프레임을 생성합니다.
data = {'name': ['John', 'Sarah', 'Bob', 'Alice', 'Tom'],
        'age': [20, 22, 21, 19, 23],
        'gender': ['M', 'F', 'M', 'F', 'M']}
df = pd.DataFrame(data)

# SQLite 데이터베이스에 연결합니다.
conn = sqlite3.connect('students.db')

# 데이터프레임을 SQLite 데이터베이스의 테이블로 저장합니다.
# 테이블이 이미 존재하는 경우에는 테이블을 대체합니다.
df.to_sql('students', conn, if_exists='replace', index=False)

# 데이터베이스 연결을 닫습니다.
conn.close()

[Pandas 강좌 - 1] Pandas(판다스)의 기본 이해 그리고 Series와 DataFrame 생성 방법

gogo5911 — Sun, 17 Dec 2023 23:44:55 +0900

1. Pandas 소개

Pandas는 Python에서 사용하는 데이터 분석 라이브러리입니다. 이름은 "PANel DAta"의 약자로 금융 경제학 용어에서 유래되었습니다. Pandas는 데이터 조작 및 분석을 위해 설계되었으며, 빠르고 유연한 데이터 구조를 제공하여 대규모 데이터 세트를 효율적으로 처리할 수 있습니다.

Pandas는 다음과 같은 주요 특징을 가지고 있습니다.

다양한 데이터 타입 처리 : Pandas는 다양한 타입의 데이터를 처리할 수 있습니다. 예를 들어, 정수, 실수, 문자열, Python 객체 등을 처리할 수 있습니다.
누락된 데이터 처리 : Pandas는 누락된 데이터를 쉽게 처리할 수 있습니다. 예를 들어, 누락된 데이터를 특정 값으로 채우거나 누락된 데이터를 포함하는 행이나 열을 삭제할 수 있습니다.
데이터 병합 : Pandas는 여러 데이터프레임을 하나로 병합하거나 조인할 수 있는 기능을 제공합니다.
피벗 테이블 생성 : Pandas는 피벗 테이블을 쉽게 생성할 수 있습니다. 피벗 테이블은 데이터를 요약하고 분석하는데 유용합니다.
시계열 데이터 처리 : Pandas는 시계열 데이터를 다루는 데 매우 유용한 도구들을 제공합니다.

Pandas를 사용하기 위해서는 먼저 pandas 패키지를 설치해야 합니다. pip를 통해 설치하는 경우 아래와 같이 명령을 실행합니다.

pip install pandas

Python에서 Pandas를 사용하기 위해서는 일반적으로 아래와 같이 패키지를 불러옵니다.

import pandas as pd

2. Pandas 데이터 구조

Pandas는 Series, DataFrame, Index라는 세 가지 핵심 데이터 구조를 기반으로 작동합니다.

2.1 Series

Pandas Series는 기본 데이터 구조 중 하나로, 1차원 배열로과 유사하게 동작합니다. 이러한 구조는 일련의 데이터 항목을 저장하고 조작할 수 있는 기능을 제공합니다. Series는 index 을 가질 수 있으며, index를 기반으로 데이터를 액세스할 수 있습니다.

2.1.1 생성

pd.Series 객체는 여러 가지 데이터 유형으로부터 생성될 수 있습니다. 가장 일반적인 방법 중 하나는 리스트 또는 NumPy 배열에서 Series를 만드는 것입니다. 아래 코드는 정수, 실수, NaN(누락된 데이터를 나타냄)을 포함하는 Series를 만듭니다. 또한 딕셔너리를 통해 Series를 만들 수도 있습니다. 이 경우, 딕셔너리의 키가 Series의 index가 됩니다.

import pandas as pd

# 리스트를 사용하여 Series 생성
s1 = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s1)
# 출력:
# 0    1.0
# 1    3.0
# 2    5.0
# 3    NaN
# 4    6.0
# 5    8.0
# dtype: float64

# Dictionary를 사용하여 Series 생성
s2 = pd.Series({'a': 1, 'b': 2, 'c': 3})
print(s2)
# 출력:
# a    1
# b    2
# c    3
# dtype: int64

2.1.2 인덱싱

Series의 요소에는 인덱스를 사용하여 엑세스 할 수 있습니다. 인덱스를 지정하지 않으면 Pandas는 기본적으로 0에서 시작하는 정수 인덱스를 제공합니다. 명시적으로 인덱스를 지정하는 경우에는, 고유한 인덱스 또는 시계열 데이터 등을 사용할 수 있습니다. 예제에서 인덱스 'a', 'b', 'c', 'd', 'e'는 Series의 각 값에 대한 인덱스 역할을 합니다. 이 인덱스를 사용하여 Series의 값을 참조할 수 있습니다.

s = pd.Series([1, 3, 5, np.nan, 6, 8])

print(s[0])  # 출력: 1.0
print(s[3])  # 출력: NaN

s2 = pd.Series({'a': 1, 'b': 3, 'c': 5})

print(s2['a'])  # 출력: 1
print(s2['c'])  # 출력: 5

s3 = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(s)

print(s3['a'])  # 출력: 1
print(s3['d'])  # 출력: 4

2.1.3 메소드

Series에는 데이터 처리 및 변환을 돕는 다양한 메소드가 있습니다. 예를 들어, describe() 메소드는 Series의 기술 통계를 제공하고, hist() 메소드는 Series의 히스토그램을 그릴 수 있습니다. mean(), median(), max(), min()등의 메소드는 Series의 평균, 중앙값, 최대값, 최소값을 계산할 수 있습니다.

hist() 메소드는 그래프를 생성하는 메소드입니다. 아래 코드를 실행하면 다음과 같은 hist()가 생성됩니다. 이 hist()는 모두 유니크하고, 그 간격이 일정하기 때문에 즉, 각 숫자가 한번씩만 나타나고, 각 숫자 사이의 간격이 동일하므로, 히스토그램에서 각 bin(구간)의 높이는 모두 동일하게 나타납니다.

import pandas as pd
import matplotlib.pyplot as plt

s = pd.Series([1, 2, 3, 4, 5])

s.hist()
plt.show()

아래 코드는 describe(), mean(), median(), max(), min() 메소드를 사용한 예시 코드입니다.

import pandas as pd

# Series 생성
s = pd.Series([1, 2, 3, 4, 5])

# 기본 통계 요약 출력
print(s.describe())
# 출력:
# count    5.000000
# mean     3.000000
# std      1.581139
# min      1.000000
# 25%      2.000000
# 50%      3.000000
# 75%      4.000000
# max      5.000000

# 평균 출력
print(s.mean())
# 출력: 3.0

# 중앙값 출력
print(s.median())
# 출력: 3.0

# 최대값 출력
print(s.max())
# 출력: 5

# 최소값 출력
print(s.min())
# 출력: 1

2.1.4 결측치 처리

Pandas에서는 누락된 데이터를 표현하는 데 NaN 값을 사용합니다. Series에서는 .isnull() 또는 .notnull() 메소드를 사용하여 이러한 값들을 감지하고, .dropna() 메소드를 사용하여 이를 제거할 수 있습니다. 또한, .fillna(value) 메소드를 사용하여 NaN 값을 특정 값으로 대체할 수 있습니다.

import pandas as pd
import numpy as np

# NaN 값이 포함된 Series 생성
s = pd.Series([1, 2, np.nan, 4, 5])

# NaN 값이 있는지 확인
print(s.isnull())
# 출력:
# 0    False
# 1    False
# 2     True
# 3    False
# 4    False
# dtype: bool

# NaN 값을 제거
s_no_nan = s.dropna()
print(s_no_nan)
# 출력:
# 0    1.0
# 1    2.0
# 3    4.0
# 4    5.0
# dtype: float64

# NaN 값을 특정 값(예: 0)으로 대체
s_filled = s.fillna(0)
print(s_filled)
# 출력:
# 0    1.0
# 1    2.0
# 2    0.0
# 3    4.0
# 4    5.0
# dtype: float64

2.1.5 벡터화 연산

Series는 벡터화된 연산을 지원합니다. 이는 Series의 각 요소에 함수를 적용하거나, 두 Series 사이의 산술 연산을 수행할 수 있음을 의미합니다. 이러한 연산은 속도와 효율성 측면에서 매우 유용합니다.

s1 = pd.Series([1, 2, 3, 4, 5])
s2 = pd.Series([10, 20, 30, 40, 50])

# 두 시리즈를 더합니다.
s3 = s1 + s2

2.2 DataFrame

Pandas DataFrame은 2차원 테이블로, 서로 다른 타입의 데이터를 보관할 수 있습니다. DataFrame은 각 열마다 다른 타입의 데이터(숫자, 문자열, 불리언 등)를 저장할 수 있으며, 데이터는 열이나 행을 기준으로 선택, 정렬, 조작될 수 있습니다. DataFrame은 스프레드시트, SQL 테이블, 또는 R의 data.frame과 같은 2차원 테이블 형식의 데이터 구조와 유사합니다. DataFrame은 다양한 방법으로 생성할 수 있습니다. 가장 일반적인 방법은 딕셔너리를 사용하는 것입니다.

2.2.1 생성

DataFrame은 다양한 방법으로 생성할 수 있습니다. 가장 간단한 방법 중 하나는 딕셔너리를 사용하는 것입니다. 코드는 각각 'name', 'age', 'city'라는 열 이름과 연관된 데이터를 가진 딕셔너리를 DataFrame으로 변환합니다. 데이터프레임을 생성할 때 index 매개변수를 사용하여 인덱스 값을 지정할 수 있습니다. 이를 통해 인덱스에 특정 값을 할당할 수 있습니다.

import pandas as pd

data = {
    'name': ['John', 'Anna', 'Peter', 'Linda'],
    'age': [28, 24, 35, 32],
    'city': ['New York', 'Paris', 'Berlin', 'London']
}

df = pd.DataFrame(data)
df2 = pd.DataFrame(data, index=['Person 1', 'Person 2', 'Person 3', 'Person 4'])

print(df)
print(df2)

#출력
#    name  age       city
#0   John   28   New York
#1   Anna   24      Paris
#2  Peter   35     Berlin
#3  Linda   32     London

#출력
#          name  age       city
#Person 1  John   28   New York
#Person 2  Anna   24      Paris
#Person 3  Peter  35     Berlin
#Person 4  Linda  32     London

2.2.2 접근하기

DataFrame에는 데이터를 조작하는데 유용한 다양한 메소드가 있습니다. 예를 들어, describe() 메소드는 숫자형 열의 기본적인 통계적 정보를 제공합니다. sort_values() 메소드는 특정 열의 값에 따라 행을 정렬합니다.

import pandas as pd

data = {
    'name': ['John', 'Anna', 'Peter', 'Linda'],
    'age': [28, 24, 35, 32],
    'city': ['New York', 'Paris', 'Berlin', 'London']
}

df = pd.DataFrame(data)
print(df.describe())

df_sorted = df.sort_values('age')
print(df_sorted)

2.2.3 결측치 처리

결측치는 np.nan으로 표시되며, 이를 처리하는 데에는 주로 dropna()와 fillna() 함수를 사용합니다. dropna(): NaN 값이 있는 행 또는 열을 삭제합니다. fillna(): NaN 값을 특정 값으로 채웁니다. 자세한 내용은 강좌-5 에서 다룹니다.

df = pd.DataFrame({
    'A': [1, 2, np.nan],
    'B': [5, np.nan, np.nan],
    'C': [1, 2, 3]
})
print(df.dropna())

print(df.fillna(value='FILL VALUE'))

2.2.4 데이터 필터링

조건에 맞는 데이터를 선택하는 것입니다. 자세한 내용은 강좌-3 에서 다룹니다.

df = pd.DataFrame({
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
    'C': np.random.randn(8),
    'D': np.random.randn(8)
})

# 'A'열이 'foo'인 행만 선택
print(df[df['A'] == 'foo'])

2.2.5 그룹화

groupby() 함수를 사용하면, 하나 이상의 열을 기준으로 데이터를 그룹화하고, 그룹별로 집계 함수를 적용할 수 있습니다. 자세한 내용은 강좌-7 에서 다룹니다.

# 'A'열을 기준으로 그룹화하고, 각 그룹별로 'D'열의 평균을 구함
print(df.groupby('A')['D'].mean())

2.2.6 데이터 합치기

merge(), join(), concat() 등의 함수를 사용해 데이터프레임을 여러 가지 방법으로 합칠 수 있습니다. concat(): 데이터프레임을 이어 붙입니다. merge(): 하나 이상의 키를 기준으로 데이터프레임의 행을 합칩니다. join(): 인덱스를 기준으로 데이터프레임을 합칩니다. 자세한 내용은 강좌-6 에서 다룹니다.

[Numpy 강좌 – 8] 넘파이(NumPy)의 난수 생성과 랜덤 샘플링 이해하기

gogo5911 — Wed, 13 Dec 2023 22:21:17 +0900

1. 난수 생성

난수 생성은 컴퓨터 프로그래밍에서 자주 사용되는 기능 중 하나입니다. 통계적 분석, 머신러닝, 시뮬레이션, 암호화 등 다양한 분야에서 사용됩니다. NumPy는 효과적인 난수 생성을 위한 몇 가지 함수를 제공합니다. 아래 함수들은 모두 랜덤 값을 생성하는 역할을 합니다. 이 값들은 모두 의사 난수(pseudo random number)입니다. 즉, 수학적 알고리즘을 통해 생성된 랜덤한 값입니다.

np.random.rand() : 0과 1 사이에서 균일 분포를 따르는 난수를 생성합니다. 함수에 전달된 인수의 개수에 따라 다차원 배열을 생성하는 데 사용할 수 있습니다. 예를 들어, np.random.rand(5,3)을 호출하면 5x3 크기의 배열이 생성되며, 각 요소는 0과 1 사이의 랜덤한 숫자입니다.
np.random.randn() : 표준 정규 분포(평균이 0이고 표준편차가 1인 분포)를 따르는 난수를 생성합니다.
np.random.randint() : 특정 범위 내에서 랜덤한 정수를 생성합니다. 두 개의 인수를 받으며, 첫 번째 인수는 범위의 시작(포함)이고 두 번째 인수는 범위의 끝(비포함)입니다.
np.random.random() : 0과 1 사이에서 균일 분포를 따르는 난수를 생성합니다. 인수로 튜플을 받아 다차원 배열을 생성할 수 있습니다.

아래 코드는 다양한 난수 생성 함수를 사용하는 방법을 보여줍니다.

import numpy as np

# rand: 0과 1 사이의 균일 분포에서 난수 생성
print("Random number between 0 and 1: ", np.random.rand())

# randn: 표준 정규 분포에서 난수 생성
print("Random number from standard normal distribution: ", np.random.randn())

# randint: 주어진 범위에서 임의의 정수 생성
print("Random integer between 1 and 10: ", np.random.randint(1, 10))

# random: 0과 1 사이의 균일 분포에서 난수 생성 (rand와 비슷하지만 다른 형태의 인자를 받음)
print("Random number between 0 and 1: ", np.random.random())

2. 랜덤샘플링

랜덤 샘플링은 주어진 데이터 집합에서 임의로 선택하는 과정을 말합니다. NumPy에서는 랜덤 샘플링을 위한 몇 가지 함수를 제공하고 있습니다. 아래 함수들은 모두 무작위로 데이터를 선택하거나 순서를 바꾸는 역할을 하며, 이는 데이터를 무작위로 섞거나 특정 개수의 데이터를 랜덤하게 선택하는 등의 작업에서 매우 유용합니다.

np.random.choice() : 주어진 1차원 배열에서 임의의 요소를 선택합니다. 두 번째 인자로 정수를 전달하면 해당 개수만큼의 요소를 랜덤하게 선택합니다.
np.random.shuffle() : 주어진 배열의 순서를 랜덤하게 바꿉니다. 이 함수는 원래 배열 자체를 변경합니다. 원본 배열을 유지하고 싶은 경우에는 np.random.permutation() 함수를 사용합니다.
np.random.permutation() : 주어진 배열의 랜덤한 순열을 반환합니다. 이 함수는 원래 배열에 영향을 주지 않으므로, 원래 배열을 그대로 유지하면서 랜덤하게 순서를 바꿔야 할 때 사용합니다.

아래 코드는랜덤 샘플링 및 배열 재배치 함수를 사용하는 방법을 보여줍니다.

# choice: 주어진 배열에서 임의의 요소 선택
arr = np.array([1, 2, 3, 4, 5])
print("Random choice from array: ", np.random.choice(arr))

# shuffle: 배열을 무작위로 섞음 (원래 배열을 바꿈)
np.random.shuffle(arr)
print("Array after shuffle: ", arr)

# permutation: 배열의 무작위 순열을 반환 (원래 배열을 바꾸지 않음)
print("Random permutation of array: ", np.random.permutation(arr))

[Numpy 강좌 – 7] 넘파이(NumPy)로 데이터를 더 빠르게 처리하는 법: 벡터화 연산과 메모리 접근 패턴 이해하기

gogo5911 — Wed, 13 Dec 2023 22:17:56 +0900

1. 벡터화 연산

벡터화 연산은 데이터 배열에 대해 반복적인 연산을 빠르고 효율적으로 수행할 수 있는 방법을 말합니다. 이는 NumPy의 핵심 기능 중 하나이며, 특히 대용량 데이터 처리에서 훨씬 더 빠른 결과를 제공합니다. 이는 'for'문이나 다른 반복 구조를 사용하지 않고도 배열의 모든 요소에 대해 연산을 수행하므로, 코드가 간결해지고 실행 시간이 단축됩니다.

아래 코드에서 두 개의 NumPy 배열 'a'와 'b'를 생성하였습니다. 그 다음에는 '+' 연산자를 사용하여 'a'와 'b'를 더하는 벡터화 연산을 수행합니다. 이 경우 '+' 연산자는 배열 'a'와 'b'의 모든 요소 간에 요소별로(add element-wise) 작동합니다. 따라서 이렇게 하면 'c'라는 새로운 배열이 생성되며, 이 배열의 각 요소는 'a'와 'b'의 해당 요소의 합입니다. 이에 반해 'for'문을 사용하여 같은 연산을 수행하는 경우, 각 요소를 개별적으로 더해주어야 합니다. 이 방식은 코드가 더 복잡하고 실행 시간이 더 길어집니다. 벡터화 연산을 사용하면 이러한 반복 구조를 사용하지 않고도 동일한 결과를 얻을 수 있습니다.

# 벡터화 연산 예제
a = np.array([1, 2, 3, 4, 5])
b = np.array([6, 7, 8, 9, 10])

# 벡터화 연산
c = a + b
print("c: ", c)

# for loop를 사용한 경우
c_loop = np.zeros(5)
for i in range(5):
    c_loop[i] = a[i] + b[i]
print("c_loop: ", c_loop)

하지만 여기서는 큰 차이를 느끼지 못할 것입니다. 왜냐하면 코드에서 다루는 데이터의 크기가 아직 충분히 크지 않기 때문입니다. 수천, 수만 또는 그 이상의 대규모 데이터셋에서 벡터화 연산의 효율성을 명확하게 확인할 수 있습니다.

2. 메모리 접근 패턴과 캐시 최적화

Numpy는 내부적으로 메모리 접근 패턴을 최적화하여 연산 속도를 향상시킵니다. 이는 큰 데이터를 처리하는 경우, 데이터를 효과적으로 조작하고, 연산의 성능을 향상시키는 데 중요합니다.

NumPy 배열은 메모리에 연속적으로 저장됩니다. 예를 들어, 2차원 배열에서, 각 행은 메모리의 연속적인 위치에 저장되며, 이는 행 기반 접근이 열 기반 접근보다 빠르게 될 수 있도록 합니다. 이것이 바로 "행 우선" (row-major) 저장 방식입니다. 이러한 메모리 배치는 CPU 캐시의 활용을 극대화하는데 도움이 됩니다.행 우선 방식에서, 데이터의 인접한 요소들이 종종 함께 처리되므로 캐시 효율이 높아집니다.

아래 코드는 이러한 원리를 활용하여 2차원 배열에서 행과 열의 합을 계산하는 예제입니다. np.sum(arr, axis=0)은 각 열의 합을 계산하고, np.sum(arr, axis=1)은 각 행의 합을 계산합니다. NumPy의 행 기반 메모리 배치 덕분에, 행의 합을 계산하는 것이 열의 합을 계산하는 것보다 빠릅니다.

import time

# 2차원 배열 생성
arr = np.random.rand(10000, 10000)

# 열의 합을 계산
start = time.time()
column_sum = np.sum(arr, axis=0)
print("Time for column sum: ", time.time() - start)

# 행의 합을 계산
start = time.time()
row_sum = np.sum(arr, axis=1)
print("Time for row sum: ", time.time() - start)

[Numpy 강좌 – 6] 넘파이(Numpy)를 이용한 파일 입출력

gogo5911 — Wed, 13 Dec 2023 22:15:28 +0900

1. 파일 입출력

Numpy는 배열 데이터를 파일에 저장하거나 파일에서 로드하는 데 사용할 수 있는 함수를 제공합니다. Numpy는 데이터 저장을 위한 기본적인 2가지 함수를 제공합니다. 이는 np.save, np.load이며, 이들을 사용하여 Numpy 배열을 저장하고 불러올 수 있습니다. 또한, np.savetxt, np.loadtxt, genfromtxt 의 함수를 사용하여 텍스트 파일을 저장하고 불러올 수도 있습니다. 그러나 CSV 파일을 가져오는 방법의 경우 Pandas 패키지를 사용하는 것이 일반적입니다.

1.1 numpy.save(), numpy.load()

numpy.save()는 Numpy 배열 객체를 .npy 파일로 저장합니다. 파일이 이미 존재하는 경우에는 덮어씁니다.아래 코드에서는 1부터 5까지의 값을 가진 배열을 생성합니다. 그런 다음, np.save를 사용하여 'my_array.npy'라는 이름의 파일로 이 배열을 저장합니다.

import numpy as np

# 배열 생성
arr = np.array([1, 2, 3, 4, 5])

# .npy 파일로 저장
np.save('my_array', arr)

numpy.load()는 .npy 파일을 읽어와 numpy 배열 객체로 반환합니다. 아래 코드에서는 위에서 저장한 'my_array.npy' 파일을 불러와 출력합니다.

# .npy 파일 불러오기
loaded_arr = np.load('my_array.npy')

print(loaded_arr)  # 출력: [1 2 3 4 5]

1.2 numpy.savetxt(), numpy.loadtxt()

numpy.savetxt()는 1차원과 2차원 배열을 텍스트 파일(.txt or .csv)로 저장합니다. 아래 코드는 2차원의 numpy 배열을 생성한 후, np.savetxt를 사용하여 'my_array.txt'라는 이름의 텍스트 파일로 저장합니다.

# 2D 배열 생성
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# .txt 파일로 저장
np.savetxt('my_array.txt', arr_2d)

numpy.loadtxt()는 텍스트 파일(.txt or .csv)을 읽어와 numpy 배열로 반환합니다. 아래 코드는 np.loadtxt 함수를 사용하여 위의 코드에서 저장한 'my_array.txt' 파일을 불러와 numpy 배열로 반환합니다.

# .txt 파일 불러오기
loaded_arr_2d = np.loadtxt('my_array.txt')

print(loaded_arr_2d)  
# 출력: 
# [[1. 2. 3.]
#  [4. 5. 6.]
#  [7. 8. 9.]]

1.3 genfromtext()

Numpy의 genfromtxt 함수는 더 많은 옵션을 제공하며, 누락된 값과 같은 복잡한 상황을 처리할 수 있습니다. 아래 코드에서 np.genfromtxt('my_data.csv', delimiter=',') 부분이 CSV 파일을 불러와 numpy 배열로 변환하는 부분입니다. 여기서 delimiter=','는 각 값이 쉼표로 구분되어 있다는 것을 나타냅니다.

import numpy as np

# 'my_data.csv' 파일 불러오기
data = np.genfromtxt('my_data.csv', delimiter=',')

# data는 이제 다음과 같은 2차원 numpy 배열입니다:
# [[0.1 0.2 0.3 0.4]
#  [1.1 1.2 1.3 1.4]
#  [2.1 2.2 2.3 2.4]
#  [3.1 3.2 3.3 3.4]
#  [4.1 4.2 4.3 4.4]]

numpy.genfromtxt()의 주요 매개변수는 다음과 같습니다.

fname : 파일, 문자열, 생성기(generator) 또는 파일과 유사한 객체의 이름
dtype : 반환할 배열의 데이터 타입. 기본값은 float
comments : 주석으로 간주되는 문자 또는 문자열. 해당 문자 뒤의 모든 문자는 라인의 끝까지 무시됩니다. 기본값은 '#'
delimiter : 필드 구분자 문자열
skip_header : 파일의 시작부터 건너뛸 행 수
skip_footer : 파일의 끝부터 건너뛸 행 수
missing_values : 결측치를 나타내는 문자열의 리스트
filling_values : 결측치를 대체할 값의 리스트
usecols : 읽을 열의 순서

# 이것은 코멘트입니다.
# 이 행은 무시됩니다.
1, 2, 3
4, 5, Six
7, 8, 9

예를 들어, 위와 같이 텍스트 파일('data.txt')이 있다고 가정해보겠습니다. 이 파일에서 데이터를 읽어오는 numpy.genfromtxt() 함수의 사용 예는 아래 코드와 같습니다. 이 코드를 실행하면, 주석이 제거되고, 'Six'라는 문자열이 결측치로 인식되어 -999로 채워진 2차원 배열을 얻게 됩니다.

import numpy as np

# 결측치('Six')를 -999로 채우고, ','를 구분자로 사용하여 파일 읽기
data = np.genfromtxt('data.txt', delimiter=',', comments='#', missing_values='Six', filling_values=-999)

print(data)

#출력
#[[  1.   2.   3.]
# [  4.   5. -999.]
# [  7.   8.   9.]]

결측치 처리, 열 선택, 주석 처리 등의 기능을 제공하기 때문에, numpy.genfromtxt()는 데이터 분석에 자주 사용됩니다. 다만, numpy.genfromtxt()는 파일을 한 번에 한 줄씩 읽으므로 매우 큰 파일을 읽을 때는 numpy.loadtxt()보다 느릴 수 있습니다. 이런 경우에는 Pandas와 같은 라이브러리를 사용하는 것이 더 효과적일 수 있습니다.

[Numpy 강좌 – 5] 넘파이(Numpy) 집계, 정렬 및 분할, 수학 함수를 통한 데이터 처리

gogo5911 — Wed, 13 Dec 2023 22:07:47 +0900

1. Numpy 집계 함수

Numpy는 데이터 분석을 위해 다양한 집계 함수(Aggregate functions)를 제공합니다. 이러한 함수를 사용하면 배열의 요소에 대해 특정 계산을 수행할 수 있습니다. 대표적인 집계 함수들은 다음과 같습니다.

np.sum(): 배열의 모든 요소의 합을 계산합니다.
np.min(), np.max(): 배열의 최소값 또는 최대값을 찾습니다.
np.mean(): 배열의 평균 값을 계산합니다.
np.median(): 배열의 중간값(median)을 찾습니다.
np.std(): 배열의 표준 편차를 계산합니다.
np.var(): 배열의 분산을 계산합니다.

1.1 np.sum()

이 함수는 배열의 모든 요소의 합계를 계산합니다. 데이터의 전체적인 누적치를 알고 싶을 때 유용합니다.

import numpy as np

data = np.array([[1, 2, 3], [4, 5, 6]])

# 모든 요소의 합계를 계산
total = np.sum(data, axis=None)
print("Total sum: ", total)  # 출력: Total sum: 21

# 각 열의 합계를 계산
total_column = np.sum(data, axis=0)
print("Column sum: ", total_column)  # 출력: Column sum: [5 7 9]

# 각 행의 합계를 계산
total_row = np.sum(data, axis=1)
print("Row sum: ", total_row)  # 출력: Row sum: [ 6 15]

1.2 np.min(), np.max()

이 함수는 배열의 최소값(np.min())과 최대값(np.max())을 계산합니다. 데이터의 범위를 알고 싶을 때 유용하게 사용됩니다.

import numpy as np

data = np.array([8, 2, 6, 1, 5])
minimum = np.min(data)
maximum = np.max(data)
print("Min: ", minimum)  # 출력: Min: 1
print("Max: ", maximum)  # 출력: Max: 8

1.3 np.mean()

이 함수는 배열의 평균 값을 계산합니다. 데이터의 중심을 파악하는데 사용됩니다.

import numpy as np

data = np.array([8, 2, 6, 1, 5])
average = np.mean(data)
print("Mean: ", average)  # 출력: Mean: 4.4

1.4 np.median()

이 함수는 배열의 중간값(median)을 계산합니다. 평균과 함께 데이터의 중심을 파악하는데 사용됩니다.

import numpy as np

data = np.array([8, 2, 6, 1, 5])
middle = np.median(data)
print("Median: ", middle)  # 출력: Median: 5.0

1.5 np.std()

이 함수는 배열의 표준 편차를 계산합니다. 데이터가 평균으로부터 얼마나 퍼져 있는지를 나타내는 값입니다.

import numpy as np

data = np.array([1, 2, 3, 4, 5])
std_dev = np.std(data)
print("Standard Deviation: ", std_dev)  # 출력: Standard Deviation: 1.4142135623730951

1.6 np.var()

이 함수는 배열의 분산을 계산합니다. 표준 편차의 제곱이며, 데이터가 평균으로부터 얼마나 퍼져 있는지를 나타내는 또 다른 척도입니다.

import numpy as np

data = np.array([1, 2, 3, 4, 5])
variance = np.var(data)
print("Variance: ", variance)  # 출력: Variance: 2.0

2. Numpy 정렬과 분할 함수

2.1 np.sort()

이 함수는 입력 배열을 오름차순으로 정렬한 새 배열을 반환합니다. 기본적으로 퀵 정렬 알고리즘을 사용하지만, 병합 정렬이나 힙 정렬도 선택할 수 있습니다. 아래 코드에서, np.sort() 함수는 새 배열을 반환합니다. 원본 배열을 직접 정렬하려면 배열의 sort() 메서드를 사용할 수 있습니다.

import numpy as np

data = np.array([5, 1, 6, 2, 3])
sorted_data = np.sort(data)

print("Original: ", data)  # 출력: Original:  [5 1 6 2 3]
print("Sorted: ", sorted_data)  # 출력: Sorted:  [1 2 3 5 6]

2.2 np.partition()

이 함수는 'k-번째' 위치에 있는 요소를 기준으로 작은 요소들을 왼쪽에, 큰 요소들을 오른쪽에 위치시킵니다. 이는 'k-번째' 최소값을 찾는 데 효율적입니다. 아래 코드에서, np.partition() 함수는 3번째 위치에 있는 요소를 기준으로 배열을 분할합니다. 그 결과 배열에서 첫 세 요소는 분할 지점보다 작거나 같고, 나머지 요소는 분할 지점보다 큽니다.

import numpy as np

data = np.array([5, 1, 6, 2, 3])
partitioned_data = np.partition(data, 3)

print("Original: ", data)  # 출력: Original:  [5 1 6 2 3]
print("Partitioned: ", partitioned_data)  # 출력: Partitioned:  [2 1 3 5 6]

2.3 np.array_split()

이 함수는 입력 배열을 주어진 수의 동일한 크기의 하위 배열로 분할합니다. 만약 배열을 동일한 크기로 분할할 수 없다면, 마지막 하위 배열만 더 작을 수 있습니다. 아래 코드에서, `np.array_split()` 함수는 입력 배열을 3개의 하위 배열로 분할합니다.

import numpy as np

data = np.array([1, 2, 3, 4, 5, 6])
split_data = np.array_split(data, 3)

print("Original: ", data)  # 출력: Original:  [1 2 3 4 5 6]
print("Split: ", split_data)  # 출력: Split:  [array([1, 2]), array([3, 4]), array([5,6])]

2.4 np.argsort()

이 함수는 배열을 정렬했을 때의 인덱스를 반환합니다. 즉, 원래 배열에서 정렬된 배열로 요소를 재정렬하려면 어떤 순서로 인덱스를 사용해야 하는지를 알려줍니다. 아래 코드에서, np.argsort() 함수는 정렬된 배열에서 각 요소의 인덱스를 반환합니다. 예를 들어, 원래 배열에서 가장 작은 요소는 1이며, 이는 원래 배열의 인덱스 1에 위치해 있습니다.

import numpy as np

data = np.array([5, 1, 6, 2, 3])
sort_indices = np.argsort(data)

print("Data: ", data)  # 출력: Data: [5 1 6 2 3]
print("Sort Indices: ", sort_indices)  # 출력: Sort Indices: [1 3 4 0 2]

2.5 np.split()

이 함수는 배열을 동일한 크기의 여러 하위 배열로 분할합니다. np.array_split()과는 달리, np.split()은 배열을 동일한 크기의 하위 배열로 정확히 분할할 수 없는 경우 오류를 발생시킵니다. 예제에서, np.split() 함수는 입력 배열을 3개의 하위 배열로 분할합니다.

import numpy as np

data = np.array([1, 2, 3, 4, 5, 6])
split_data = np.split(data, 3)

print("Original: ", data)  # 출력: Original:  [1 2 3 4 5 6]
print("Split: ", split_data)  # 출력: Split:  [array([1, 2]), array([3, 4]), array([5, 6])]

3. Numpy 수학 함수

3.1 np.sin(), np.cos(), np.tan()

이들 함수는 각각 배열의 요소에 대한 사인, 코사인, 탄젠트 값을 계산합니다.

import numpy as np

angles = np.array([0, np.pi / 2, np.pi])
print("sin: ", np.sin(angles))  # 출력: sin:  [0.0000000e+00 1.0000000e+00 1.2246468e-16]
print("cos: ", np.cos(angles))  # 출력: cos:  [ 1.000000e+00  6.123234e-17 -1.000000e+00]
print("tan: ", np.tan(angles))  # 출력: tan:  [ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]

3.2 np.exp()

이 함수는 배열의 각 요소에 대해 자연 상수 e (약 2.71828)의 거듭제곱을 계산합니다.

import numpy as np

values = np.array([1, 2, 3])
print("exp: ", np.exp(values))  # 출력: exp:  [ 2.71828183  7.3890561  20.08553692]

3.3 np.log(), np.log2(), np.log10()

이들 함수는 각각 자연 로그, 로그 밑 2, 로그 밑 10을 계산합니다.

import numpy as np

values = np.array([1, np.e, np.e**2])
print("log: ", np.log(values))  # 출력: log:  [0. 1. 2.]
print("log2: ", np.log2(values))  # 출력: log2:  [0.         1.44269504 2.88539008]
print("log10: ", np.log10(values))  # 출력: log10:  [0.         0.43429448 0.86858896]

3.4 np.sqrt()

이 함수는 배열의 각 요소의 제곱근을 계산합니다.

import numpy as np

values = np.array([1, 4, 9])
print("sqrt: ", np.sqrt(values))  # 출력: sqrt:  [1. 2. 3.]

4. Numpy 유용한 함수

4.1 np.any(), np.all()

np.any() 함수는 배열 내에서 어느 한 요소라도 참(True)이면 True를 반환하고, np.all() 함수는 배열의 모든 요소가 참(True)일 때 True를 반환합니다.

import numpy as np

arr = np.array([True, False, True])

print("Any: ", np.any(arr))  # 출력: Any: True
print("All: ", np.all(arr))  # 출력: All: False

4.2 np.where()

np.where() 함수는 특정 조건을 만족하는 요소의 인덱스를 반환합니다. 아래 코드에서는 배열 arr에서 값이 3보다 큰 요소의 인덱스를 찾습니다. 이 인덱스를 다시 배열 arr에 적용하면 조건을 만족하는 값들을 얻을 수 있습니다.

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
index = np.where(arr > 3)

print("Index: ", index)  # 출력: Index: (array([3, 4]),)
print("Values: ", arr[index])  # 출력: Values: [4 5]

4.3 np.logical_and(), np.logical_or(), np.logical_not()

이들 함수는 요소별 논리 연산을 수행합니다. 각각 논리 'AND', 'OR', 'NOT' 연산에 해당합니다. 코드에서는 각 논리 연산 함수를 사용하여 두 개의 Boolean 배열을 연산합니다.

import numpy as np

arr1 = np.array([True, False, True])
arr2 = np.array([False, False, True])

print("Logical AND: ", np.logical_and(arr1, arr2))  # 출력: Logical AND:  [False False  True]
print("Logical OR: ", np.logical_or(arr1, arr2))  # 출력: Logical OR:  [ True False  True]
print("Logical NOT: ", np.logical_not(arr1))  # 출력: Logical NOT:  [False  True False]

[Numpy 강좌 – 4] 넘파이(Numpy)를 이용한 효율적인 수학 연산 처리(기본 연산, 브로드캐스팅, 행렬 연산)

gogo5911 — Wed, 13 Dec 2023 02:37:12 +0900

1. 기본적인 수학 연산

Numpy는 배열에 대한 기본적인 수학 연산을 지원합니다. 이 연산은 배열의 각 요소에 개별적으로 적용되며, 새 배열을 생성하여 결과를 반환합니다.

1.1 Addition (덧셈)

Numpy 배열에서 덧셈은 '+' 연산자 또는 'np.add() 함수를 사용하여 수행할 수 있습니다. 두 가지 방법 모두 배열 a와 b의 각 요소를 더한 결과인 [5, 7, 9]를 출력합니다.

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Using '+'
print(a + b)

# Using np.add()
print(np.add(a, b))

# 출력: [5 7 9]

1.2 Subtraction (뺄셈)

Numpy에서 뺄셈은 - 연산자 또는 np.subtract() 함수를 사용합니다. 두 가지 방법 모두 배열 a에서 b를 뺀 결과인 [-3, -3, -3]를 출력합니다.

# Using '-'
print(a - b)

# Using np.subtract()
print(np.subtract(a, b))

# 출력: [-3 -3 -3]

1.3 Multiplication (곱셈)

Numpy에서 곱셈은 * 연산자 또는 np.multiply() 함수를 사용하여 수행합니다. 두 가지 방법 모두 곱셈을 수행하면, a와 b 배열의 각 요소를 곱한 결과인 [4, 10, 18]를 출력합니다.

# Using '*'
print("a * b = ", a * b)

# Using np.multiply()
print("a * b = ", np.multiply(a, b))

# 출력: [ 4 10 18]

1.4 Division (나눗셈)

Numpy에서 나눗셈은 / 연산자 또는 np.divide() 함수를 사용하여 수행합니다. 두 가지 방법 모두 나눗셈을 수행하면, a와 b 배열의 각 요소를 나눈 결과인 [0.25, 0.4 , 0.5 ]를 출력합니다.

# Using '/'
print("a / b = ", a / b)

# Using np.divide()
print("a / b = ", np.divide(a, b))

# 출력: [0.25 0.4  0.5 ]

1.5 Modulo Operation (나머지 연산)

Numpy에서 나머지 연산은 % 연산자 또는 np.mod() 함수를 사용하여 수행합니다. 나머지 연산을 수행하면, a와 b 배열의 각 요소를 나눈 나머지인 [1, 2, 3]를 출력합니다.

# Using '%'
print("a % b = ", a % b)

# Using np.mod()
print("a % b = ", np.mod(a, b))

# 출력: [1 2 3]

1.6 Exponentiation (지수)

Numpy의 np.exp() 함수를 사용하여 배열의 각 요소의 지수를 계산할 수 있습니다. 결과는 [2.71828183, 7.3890561 , 20.08553692]를 출력합니다.

print(np.exp(a))  # 출력: [ 2.71828183  7.3890561  20.08553692]

1.7 Square root (제곱근)

np.sqrt() 함수는 배열의 각 요소에 대해 제곱근을 계산합니다. 결과는 [1. , 1.41421356, 1.73205081]를 출력합니다.

print(np.sqrt(a))  # 출력: [1.         1.41421356 1.73205081]

2. Broadcasting (브로드캐스팅)

Numpy의 브로드캐스팅 기능은 서로 다른 크기의 배열에 대해 산술 연산을 수행하는 방법입니다. 이 기능을 통해 배열의 모양을 자동으로 조정하여 요소별 연산을 수행할 수 있습니다. 브로드캐스팅은 코드를 간결하게 만들고 컴퓨터의 처리 속도를 향상시킵니다.

브로드캐스팅 규칙

두 배열의 차원 수가 다른 경우, 더 작은 수의 차원을 가진 배열의 형태(shape) 앞쪽을 1로 채웁니다.
- 예를 들어, 1차원 배열 [1, 2, 3]과 2차원 배열 [[1, 2, 3], [4, 5, 6]]이 있을 때, 1차원 배열이 실제로는 [[1, 2, 3]]처럼 2차원으로 변환된다는 의미입니다. 그래서 두 배열은 [[1, 2, 3], [4, 5, 6]] + [[1, 2, 3]] 형태로 계산되게 됩니다.

두 배열이 어떤 차원에서 크기가 일치하지 않는 경우, 해당 차원의 크기가 1인 배열이 다른 배열의 크기와 일치하도록 변형됩니다.
- 1차원 배열 [1, 2, 3]과 2차원 배열 [[1], [2]]가 있을 때, 1차원 배열이 실제로는 [[1, 2, 3], [1, 2, 3]]처럼 2차원으로 변환되고, 2차원 배열은 [[1, 1, 1], [2, 2, 2]]로 변형됩니다. 그래서 두 배열은 [[1, 1, 1], [2, 2, 2]] + [[1, 2, 3], [1, 2, 3]] 형태로 계산되게 됩니다.

두 배열이 브로드캐스팅으로 일치시킬 수 없는 경우, 즉 위의 규칙을 만족시키지 못하는 경우 에러가 발생합니다.

아래 코드에서 배열 a는 크기가 3이고, b는 스칼라 값입니다. 스칼라 값 b는 브로드캐스팅을 통해 배열 a와 동일한 크기로 확장되고, 각 요소는 원래 스칼라 값 b와 동일합니다. 그런 다음, 요소별 곱셈이 수행됩니다.

import numpy as np

a = np.array([1, 2, 3])
b = 2

print(a * b)  # 출력: [2 4 6]

2.1 행이 많을 때의 브로드캐스팅

아래 코드에서 a는 3x3 크기의 2차원 배열이고, b는 크기가 3인 1차원 배열입니다. 브로드캐스팅 규칙에 따라, b 배열이 a 배열과 같은 크기인 (3, 3)으로 확장되어 각 행이 [1, 2, 3]가 됩니다. 그런 다음, 요소별 덧셈이 수행되어 위의 결과가 출력됩니다.

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  # shape: (3, 3)
b = np.array([1, 2, 3])  # shape: (3,)

result = a + b
print(result)


#출력
#[[ 2  4  6]
# [ 5  7  9]
# [ 8 10 12]]

2.2 열이 많을 때의 브로드캐스팅

아래 코드에서 c는 3x1 크기의 2차원 배열이고, d는 크기가 3인 1차원 배열입니다. 브로드캐스팅 규칙에 따라, d 배열이 c 배열과 같은 크기인 (3, 3)으로 확장되어 각 열이 [1, 2, 3]이 됩니다. 그런 다음, 요소별 덧셈이 수행되어 위의 결과가 출력됩니다.

import numpy as np

c = np.array([[1], [2], [3]])  # shape: (3, 1)
d = np.array([1, 2, 3])  # shape: (3,)

result = c + d
print(result)

#출력
#[[2 3 4]
# [3 4 5]
# [4 5 6]]

3. 행렬 연산

3.1 행렬의 곱셈

Numpy는 요소별 곱셈(element-wise multiplication)과 행렬 곱셈(matrix multiplication)을 모두 지원합니다. * 연산자는 요소별 곱셈을 수행하며, np.dot() 함수나 @ 연산자는 행렬 곱셈을 수행합니다. 행렬 곱셈을 수행하려면 첫 번째 행렬의 열의 수와 두 번째 행렬의 행의 수가 같아야 합니다.

import numpy as np

A = np.array([[1, 2], [3, 4], [5, 6]])
B = np.array([[6, 5], [4, 3], [2, 1]])

print(A * B)  # 요소별 곱셈 
#출력 [[6 10] [12 12] [10 6]]
 
C = np.array([[1, 2], [3, 4]])
D = np.array([[5, 6], [7, 8]])
print(np.dot(C, D))  # 행렬 곱셈 
#출력 [[19 22] [43 50]]

print(C @ D)  # 행렬 곱셈
#출력 [[19 22] [43 50]]

3.2 행렬의 전치

행렬의 전치는 행과 열을 바꾸는 연산입니다. Numpy의 np.transpose() 함수 또는 배열의 T 속성을 사용하여 행렬을 전치할 수 있습니다.

print(np.transpose(A))  #출력 [[1 3 5] [2 4 6]]
print(A.T)  #출력 [[1 3 5] [2 4 6]]

3.3 행렬의 역행렬

Numpy의 np.linalg.inv() 함수를 사용하여 행렬의 역행렬을 계산할 수 있습니다. 이 함수는 주어진 행렬이 역행렬을 가질 수 있는 경우에만 사용해야 합니다. 참고로, 모든 행렬이 역행렬을 가지는 것은 아닙니다. 행렬이 역행렬을 가지려면, 그 행렬은 정방행렬이어야 하며, 그 행렬의 행렬식(determinant)이 0이 아니어야 합니다.

E = np.array([[1, 2], [3, 4]])
print(np.linalg.inv(E))  #출력 [[-2.   1. ] [ 1.5 -0.5]]

3.4 행렬의 행렬식

행렬의 행렬식은 np.linalg.det() 함수를 사용하여 계산할 수 있습니다. 행렬식은 행렬이 역행렬을 가질 수 있는지를 판단하는 데 사용될 수 있습니다.

print(np.linalg.det(E))  # -2.0000000000000004

3.5 행렬의 외적

외적은 벡터 곱셈의 한 형태로, 두 벡터의 외적 결과는 두 벡터가 형성하는 평면에 수직인 벡터입니다. Numpy에서는 np.cross() 함수를 사용하여 외적을 계산할 수 있습니다.

v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
cross_product = np.cross(v1, v2)
print("Cross product: ", cross_product)  # [-3  6 -3]

[Numpy 강좌 – 3] 넘파이(Numpy)를 이용한 배열의 인덱싱(indexing)과 슬라이싱(Slicing) 이해하기

gogo5911 — Wed, 13 Dec 2023 02:28:29 +0900

1. Numpy 인덱싱

Numpy 배열 인덱싱(indexing)은 리스트 인덱싱과 매우 유사하게 작동합니다. 인덱싱(Indexing)은 특정 위치의 데이터에 접근하는 것을 의미합니다. 인덱싱을 이용해 특정 위치에 있는 값을 가져오거나 설정할 수 있습니다.

아래 코드는 numpy 배열에 대한 기본적인 인덱싱 방법을 설명하는 코드입니다. 1에서 5까지의 정수 원소를 포함한 1차원 넘파이 배열 arr을 생성합니다. 그리고 인덱싱을 통해 첫 번째 원소와 마지막 원소에 접근하고, 접근한 원소를 출력합니다. 배열의 인덱스는 0부터 시작하며, -1은 배열의 마지막 원소를 가리킵니다.

배열의 원소에 접근하여 읽는것 뿐만 아니라 원소를 직접 변경할 수도 있습니다. 첫 번째 원소의 값을 10으로 변경합니다. 그리고 변경한 후의 배열을 출력합니다.

import numpy as np

# 인덱싱 기본
arr = np.array([1, 2, 3, 4, 5])
print("Original array: ", arr)
print("First element: ", arr[0])  # 첫 번째 원소
print("Last element: ", arr[-1])  # 마지막 원소

arr[0] = 10  # 첫 번째 원소 값을 변경
print("Array after modification: ", arr)

2. 다차원 배열의 인덱싱

Numpy에서는 다차원 배열을 생성하고 사용할 수 있습니다. 이러한 다차원 배열에서 인덱싱은 각 차원에 대해 독립적으로 작동합니다. 다차원 배열의 경우, 콤마로 구분된 인덱스 튜플을 사용하여 인덱싱합니다. 예를 들어 2차원 배열에서는 두 개의 인덱스가 필요합니다. 첫 번째 인덱스는 행을, 두 번째 인덱스는 열을 가리킵니다.

아래 코드에서 2차원 넘파이 배열 arr를 생성합니다. 이 배열은 3x3 크기로, 3개의 행과 3개의 열로 구성되어 있습니다. 배열의 (1, 1) 위치에 접근하여 원소를 출력합니다. 배열의 인덱스는 0부터 시작하므로 (1, 1)은 실제로 두 번째 행과 두 번째 열에 위치한 원소를 가리킵니다. 배열의 (0, 0) 위치에 있는 원소의 값을 10으로 변경합니다. 이 위치는 첫 번째 행의 첫 번째 열에 해당하는 원소를 가리킵니다.

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original array: \n", arr)
print("Element at position (1,1): ", arr[1, 1])  # (1,1) 위치의 원소

arr[0, 0] = 10  # (0,0) 위치의 원소 값을 변경
print("Array after modification: \n", arr)

3. 불리언 인덱싱 (Boolean indexing)

불리언 인덱싱은 배열의 각 원소에 대한 불리언(True/False)값을 이용해 인덱싱하는 방법입니다. 이 방법은 특정 조건을 만족하는 원소만 선택하고 싶을 때 유용하게 사용할 수 있습니다.

아래 코드는 불리언 인덱싱의 예시 코드입니다. 1차원 넘파이 배열을 생성하고 배열의 원소 중 2보다 큰 원소들만 선택하여 출력 합니다. arr > 2는 배열의 각 원소에 대해 2보다 큰지의 여부를 불리언 값으로 반환합니다. 이 불리언 배열은 원래의 arr 배열에 인덱스로 사용되어, True에 해당하는 위치의 원소들만 선택합니다.

arr = np.array([1, 2, 3, 4, 5])
print("Original array: ", arr)
print("Elements greater than 2: ", arr[arr > 2])  # 2보다 큰 원소들

4. 슬라이싱과 View 개념

슬라이싱은 배열의 일부분을 선택하는 방법을 의미합니다. 넘파이 배열에서 슬라이싱을 수행하면, 그 결과는 원래 배열의 뷰(View)가 됩니다. 뷰는 원래 배열의 데이터를 참조하는 객체를 말하며, 뷰를 수정하면 원래 배열의 데이터도 수정됩니다. 이러한 특징은 메모리를 효율적으로 사용할 수 있게 해주지만, 원본 데이터를 변경하게 될 수 있으므로 주의 해야합니다.

아래 코드는 슬라이싱의 예시 입니다. 1차원 배열을 생성하고, 배열의 인덱스 1에서 인덱스 3까지의 슬라이스를 생성합니다. 슬라이싱에서 콜론( : )기호를 사용하여 시작 인덱스와 종료 인덱스를 지정할 수 있으며, 종료 인덱스는 슬라이스에 포함되지 않습니다. 슬라이스의 첫 번째 원소 값을 10으로 변경합니다. 원소 값을 변경한 후의 슬라이스와 원래 배열을 출력합니다. 원래 배열에서도 첫 번째 인덱스 원소의 값이 변경된 겂을 확인할 수 있습니다. 이는 slice_arr가 arr의 뷰이며, slice_arr를 수정하면 arr도 함께 수정되기 때문입니다.

arr = np.array([1, 2, 3, 4, 5])
print("Original array: ", arr)

slice_arr = arr[1:4]  # 인덱스 1에서 3까지의 슬라이스
print("Slice of the array: ", slice_arr)

slice_arr[0] = 10  # 슬라이스의 첫 번째 원소 값을 변경
print("Slice after modification: ", slice_arr)
print("Original array after modification: ", arr)  # 원래 배열도 변경됨

[Numpy 강좌 - 2] Numpy 배열 속성, 생성과 데이터타입 이해하기

gogo5911 — Mon, 11 Dec 2023 23:07:35 +0900

1. Numpy 배열

Numpy 배열은 값들이 동일한 데이터 타입을 갖는 그리드 형태의 데이터 구조입니다. 여기서 그리드 형태란 Numpy 배열 요소들이 행(row)과 열(column)로 이루어진 구조를 말합니다. 각 값은 양의 정수로 색인(index)화됩니다. 배열의 차원 수는 배열의 rank로 표현되며, 배열의 모양은 각차원에 따라 몇 개의 항목이 있는지를 나타내는 정수의 튜플로 표현됩니다. Numpy 배열은 파이썬의 기본 리스트와는 다른 형태를 가집니다.

Numpy 를 공부하다보면 ndarray라는 단어를 듣게됩니다. ndarray는 "N-dimensional array"의 줄임말로, 임의의 차원으로 구성된 배열을 의미합니다. N차원 배열은 단순한 배열로, 1차원이나 2차원부터 시작하여 임의의 수의 차원으로 구성될 수 있습니다. NumPy의 ndarray 클래스는 행렬과 벡터를 모두 나타내는 데 사용됩니다. 벡터는 단일 차원 배열로, 행 벡터와 열 벡터의 차이는 없습니다. 2차원 이상은 다차원 배열입니다. 3차원 이상의 다차원 배열은 일반적으로 "텐서"라는 용어로도 불리기도 합니다.

1.1 배열의 속성

Numpy 배열은 여러 가지 속성을 가지고 있습니다. 이러한 속성들을 활용하여 배열의 크기, 차원, 데이터 타입 등을 확인할 수 있습니다.

ndarray.ndim : 배열의 차원(축)의 개수를 나타냅니다.
ndarray.shape : 배열의 모양을 나타내는 정수의 튜플입니다. 각 차원에서 배열의 크기를 나타냅니다.
ndarray.size : 배열의 모든 원소의 개수를 나타냅니다.
ndarray.dtype : 배열에 저장된 원소의 타입을 나타내는 객체입니다.
ndarray.itemsize : 배열에 저장된 각 원소의 크기를 바이트 단위로 나타냅니다

아래 코드는 Numpy를 사용하여 특정한 데이터 구조를 생성하고, 그 구조에 대한 속성을 출력하는 코드입니다. my_list는 3차원의 리스트입니다. 이 리스트는 2개의 2차원 리스트로 구성되며, 각 2차원 리스트는 3개의 1차원 리스트로 구성되어 있습니다. 이 리스트를 Numpy의 array 함수를 사용해 Numpy 배열로 변환하고 속성을 출력하면 차원은 3, 모양은 (2, 3, 4), 크기는 24, 데이터 타입은 int 64, 원소 크기는 8의 값을 출력하게 됩니다.

import numpy as np

my_list = [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
           [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]

my_array = np.array(my_list)
print("차원:", my_array.ndim)
print("모양:", my_array.shape)
print("크기:", my_array.size)
print("데이터 타입:", my_array.dtype)
print("각 원소 크기:", my_array.itemsize)


#결과
#차원: 3
#모양: (2, 3, 4)
#크기: 24
#데이터 타입: int64
#각 원소 크기: 8

1.2 Numpy 배열 생성

Numpy 배열을 생성하는 방법에는 여러 가지가 있습니다. 가장 간단한 방법은 numpy.array() 함수를 사용하여 입력 데이터를 ndarray로 변환하는 것입니다. numpy.array는 입력 데이터(리스트, 리스트의 튜플, 다른 배열 등)를 ndarray로 변환합니다.

import numpy as np

my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)

#결과
#array([1, 2, 3, 4, 5])

numpy.arange는 특정 구간 안에서 일정 간격의 값으로 구성된 배열을 생성합니다. start 값에서 시작하여 stop 값까지 step 간격으로 숫자를 생성합니다. 여기서 stop값은 범위에 포함되지 않습니다. 아래 코드에서는 0에서 시작하여 10보다 작은 동안 2씩 증가하는 숫자를 생성합니다.

import numpy as np

my_array = np.arange(0, 10, 2)

#결과
#array([0, 2, 4, 6, 8])

numpy.zeros는 모든 원소가 0인 배열을 생성합니다. 괄호 안의 숫자는 배열의 형태를 나타냅니다. (3, 3)은 이 배열이 3행 3열의 2차원 배열임을 의미합니다. 이 함수는 모델 초기화나 임시 데이터 생성 등에 유용하게 사용됩니다. 이 함수는 데이터 타입을 flot64로 설정하여 실수 0을 배열에 저장합니다. 만약 다른 데이터 타입의 0으로 배열을 채우고 싶다면, dtype 인자를 이용해야 합니다.

import numpy as np

zeros_array = np.zeros((3, 3))

#결과
#array([[0., 0., 0.],
#       [0., 0., 0.],
#       [0., 0., 0.]])

numpy.ones는 모든 원소가 1인 배열을 생성합니다. (2, 4)은 이 배열이 2행 4열의 2차원 배열임을 의미합니다. 이 함수는 가중치를 초기화 할 때, 연산에서 모든 원소가 1인 배열이 필요할 때 주로 사용됩니다. 이 함수는 데이터 타입을 flot64로 설정하여 실수 0을 배열에 저장합니다. 만약 다른 데이터 타입의 0으로 배열을 채우고 싶다면, dtype 인자를 이용해야 합니다.

import numpy as np

ones_array = np.ones((2, 4))

#결과
#array([[1., 1., 1., 1.],
#       [1., 1., 1., 1.]])

numpy.empty는 초기화되지 않은 원소로 구성된 배열을 생성합니다. 이 함수를 이용해서 만들어지는 배열의 초기값은 메모리 상태에 따라 결정되므로 어떤 값이 들어있는지 알 수 없습니다. 그래서 보통 무작위 값이 들어가게 됩니다. 이 함수는 배열을 생성만 하고 초기화를 하지 않으므로 np.zeros, np.ones 보다 빠르게 실행될 수 있습니다.

import numpy as np

empty_array = np.empty((2, 3))

#결과
#array([[6.90738604e-310, 4.67296746e-307, 4.67296746e-307],
#       [1.89146896e-307, 1.37961302e-306, 1.60219306e-306]])

numpy.full는 모든 원소가 지정한 특정 값으로 채워진 배열을 생성합니다. 괄호 안의 첫 번째 인자는 배열의 형태를 나타냅니다. 두 번째 인자는 배열의 모든 요소를 초기화하는 값입니다. 아래 코드의 경우에는 7이므로, 모든 요소가 7로 초기화됩니다.

import numpy as np

full_array = np.full((2, 2), 7)

#array([[7, 7],
#       [7, 7]])

numpy.eye는 주어진 크기의 단위 행렬(Identity matrix)을 생성합니다. 단위 행렬은 대각선 원소들이 모두 1이고, 나머지 원소들이 모두0인 정방 행렬입니다. 이 행렬은 선형대수학에서 중요한 역할을 합니다. 그래서 역행렬을 계산하거나 선형 방정식의 해를 구할 때 사용하기도 합니다.

import numpy as np

eye_array = np.eye(3)

#array([[1., 0., 0.],
#       [0., 1., 0.],
#       [0., 0., 1.]])

1.3 데이터 타입

Numpy 배열은 다양한 종류의 데이터 타입을 지원합니다. 배열 생성 시 데이터 타입을 명시적으로 지정할 수도 있고, Numpy가 자동으로 데이터 타입을 추론할 수도 있습니다. 일반적으로 사용되는 데이터 타입에는 다음과 같은 것들이 있습니다.

int : 정수 타입
float : 부동소수점 타입
bool : 불리언 타입
str : 문자열 타입

아래 예시 코드에서는 dtype=np.float64를 사용하여 배열의 데이터 타입을 부동소수점으로 명시적으로 지정했습니다.

import numpy as np

my_array = np.array([1, 2, 3, 4, 5], dtype=np.float64)

Numpy에서 데이터 타입에 따라 배열의 각 원소의 크기(itemsize)가 다를 수 있습니다. 다음은 몇 가지 일반적인 데이터 타입에 따른 크기 변화의 예시입니다.

np.int8: 1 바이트
np.int16: 2 바이트
np.int32: 4 바이트
np.int64: 8 바이트
np.float16: 2 바이트
np.float32: 4 바이트
np.float64: 8 바이트

아래 예시 코드에서 np.int32 데이터 타입의 배열은 각 원소가 4 바이트 크기이고, np.float64 데이터 타입의 배열은 각 원소가 8 바이트 크기임을 알 수 있습니다. 이와 같이 데이터 타입에 따라 배열의 원소 크기가 달라집니다.

import numpy as np

int_array = np.array([1, 2, 3], dtype=np.int32)
float_array = np.array([1.0, 2.0, 3.0], dtype=np.float64)

print("int_array의 원소 크기:", int_array.itemsize)
print("float_array의 원소 크기:", float_array.itemsize)


#int_array의 원소 크기: 4
#float_array의 원소 크기: 8

Numpy에서 bool과 str 데이터 타입에 대한 크기는 다음과 같습니다. bool 데이터 타입은 True 또는 False 값을 가지는 불리언 타입입니다. 그래서 일반적으로 1 바이트 크기를 차지합니다. str 데이터 타입은 문자열을 표현하는 타입입니다. 문자열은 길이에 따라 크기가 달라집니다. 예를 들어, 10글자짜리 문자열은 10 바이트 크기의 메모리를 차지합니다.

아래 예시 코드에서 np.bool 데이터 타입의 배열은 각 원소가 1 바이트 크기이고, np.str_ 데이터 타입의 배열은 가변적인 길이를 가지므로 -1로 표시됩니다.

import numpy as np

bool_array = np.array([True, False, True], dtype=np.bool)
str_array = np.array(["Hello", "World", "안녕하세요"], dtype=np.str_)

print("bool_array의 원소 크기:", bool_array.itemsize)
print("str_array의 원소 크기:", str_array.itemsize)


#결과
#bool_array의 원소 크기: 1
#str_array의 원소 크기: -1

[Numpy 강좌 - 1] Numpy란?, Numpy의 장점은?

gogo5911 — Mon, 11 Dec 2023 23:00:33 +0900

1. Numpy 란?

Numpy는 "Numerical Python"의 줄임말로, Python에서 과학 계산을 위한 핵심 라이브러리입니다. Numpy는 파이썬의 기본 데이터 구조를 확장하여, 다차원 배열을 효과적으로 처리할 수 있는 기능을 제공합니다.

Numpy의 가장 큰 특징은 다차원 배열 객체인 ndarray를 제공한다는 점입니다. 이 배열은 동일한 유형의 원소들로 구성되며, 파이썬의 리스트에 비해 빠른 연산과 더 적은 메모리를 사용합니다.

1.1 Numpy 장점

1.1.1 효율적인 메모리 사용

Numpy 배열은 동일한 데이터 타입을 가진 원소들로 이루어져 있어, 메모리를 효율적으로 활용합니다. 그 결과, 대용량 데이터를 다룰 때에도 높은 성능을 보장합니다.

1.1.2 빠른 연산 속도

Numpy는 내부적으로 C언어로 구현되어 있어 연산이 매우 빠릅니다. 복잡한 수학적 연산도 빠르게 처리할 수 있습니다.

1.1.3 편리한 수치 연산 기능

Numpy는 수학적 연산을 간편하게 수행할 수 있는 다양한 함수를 제공합니다. 이에는 기본적인 산술 연산부터 복잡한 선형대수 연산까지 포함됩니다.

Numpy는 데이터 분석, 머신러닝, 이미지 처리, 컴퓨터 그래픽스 등 다양한 분야에서 사용됩니다. 특히 파이썬의 대표적인 데이터 분석 라이브러리인 pandas와 시각화 라이브러리인 matplotlib, 그리고 머신러닝 라이브러리인 scikit-learn, TensorFlow, PyTorch 등은 모두 내부적으로 Numpy를 활용합니다. 따라서 Numpy는 파이썬을 활용한 과학 계산과 데이터 분석의 기본적인 라이브러리라고 할 수 있습니다.

2. Numpy 설치

Numpy를 사용하기 위해서는 별도의 설치 과정이 필요합니다. 설치는 매우 간단합니다. 현재 사용하고 있는 IDE(통합 개발 환경)에서 터미널을 열어줍니다. 그리고 터미널에서 pip install numpy을 통해 설치 할 수 있습니다. 만약 아나콘다를 사용하는 경우에는 conda install numpy을 통해 설치할 수 있습니다.

pip install numpy
conda install numpy

설치한 numpy를 사용하기 위해서는 import 해야합니다. 아래와 같이 임포트 하면됩니다. 여기서 as는 코드의 가독성을 높이고, 라이브러리의 이름을 짧게 사용하기 위해 사용됩니다. numpy는 보통 np로 짧게 사용합니다.

import numpy as np

[[Unity 이론] Unity의 UI(UGUI)시스템 성능

gogo5911 — Thu, 19 Oct 2023 13:50:46 +0900

1. UI 역시 메시이다.

- 3D 그래픽에서 신경써야 하는 병목이 모두 똑같이 적용된다. Draw Call, Overdraw 등

드로우 콜(Draw Call) : 그래픽스 API가 GPU에게 화면에 무언가를 그리라고 명령하는 것, 드로우 콜이 많을 수록 CPU와 GPU 간의 통신 부하가 증가하여 게임의 렌더링 성능이 저하될 수 있음, 따라서 게임 개발에서는 도로우 콜의 수를 줄이기 위해 다양한 최적화 기법을 사용

오버드로우(Overdraw) : 화면의 특정 픽셀이 한 프래임 내에서 여러 번 렌더링되는 현상을 말함, 보통 여러 오브젝트가 같은 화면 공간을 공유할 때 발생하며, 특히 뒤에 있는 오브젝트가 앞에 있는 오브젝트에 의해 가려지는 경우에도 뒤에 있는 오브젝트가 렌더링되어 자원을 낭비하게 됨

- Canvas 역시 내부적으로 메시(Mesh) 렌더링 명령으로 생성됨, 즉 최종적으로 메시로 변환되어 GPU에 의해 렌더링됨

- Hierarchy에서 육안으로 분리가 되어 있어도 같은 Canvas안에 있으면 모두 리빌드(Rebuild)가 일어난다. 이는 Canvas가 UI 요소들의 렌더링을 최적화하고 관리하기 위해 디지안된 방식 때문이다.

- Tip : 정적인 객체가 있는 UI와 동적인 객체가 있는 UI와 캔버스를 나눠준다. 캔버스를 많이 나눠도 좋지 않음 , 갱신 비용이냐 혹은 드로우 콜 비용이라서 그때 그때 마다 다르다.

2. NestedCanvas

- NestedCanvas는 UI시스템에서 Canvas내에 다른 Canvas를 중첩하여 사용하는 기법, 이를 사용하여 UI요소의 렌더링과 조직을 더욱 효율적으로 관리할 수 있게 함

- 각 Canvas는 독립적인 렌더링 레이어를 형성하게 됨, 즉, 각 Canvas는 자신만의 렌더링 Mesh를 가지고 있어, 자식 Canvas에서 발생하는 변경 사항이 부모 Canvas나 다른 형제 Canvas에 영향을 미치지 않음, 이는 UI의 일부분만 자주 업데이트되는 경우, 해당 부분만 리빌드되도록 하여 전체적인 성능을 향상시킬 수 있음

- 자식 캔버스는 부모 캔버스의 특정 속성(스케일, 렌더모드 등)을 상속받을지 여부를 선택할 수 있습니다. 이를 통해 Canvas가 필요에 따라 독립적인 행동을 하거나, 부모로 부터 속성을 상속받아 일관된 행동을 할 수 있음

- Canvas 내에서 발생하는 리빌드가 다른 Canvas로 전파되지 않음, 이는 UI 요소 간의 독립성을 보장하며, 특정 부분의 업데이트가 전체 시스템에 불필요한 부하를 주지 않도록 함, 그러나 부모 Canvas의 크기 변경과 같이 전체 구조에 영향을 미치는 경우는 예외일 수 있음

- NestedCanvas 기법은 주로 Screen Space - Overlay 렌더 모드에서 사용됨

사용예시

예를 들어, 배경이 되는 정적인 UI 요소들은 별도의 정적인 Canvas에 배치하고, 사용자와의 상호작용이 잦은 버튼이나 동적인 요소들은 별도의 동적인 UI Canvas에 배치하는 방식입니다. 이렇게 하면 동적인 요소에 변경이 있을 때 정적인 요소가 포함된 Canvas를 리빌드할 필요가 없어, 성능을 최적화할 수 있습니다.

3. Dirty flag

Dirty Flag 시스템의 필요성

유니티에서 UI는 사용자의 입력, 게임 로직의 변경, 애니메이션 등으로 인해 계속해서 갱신될 필요가 있습니다. 이러한 지속적인 갱신은 특히 복잡한 UI 시스템에서 성능 이슈를 야기할 수 있습니다. Dirty Flag 시스템을 사용함으로써, 실제로 변경이 필요한 UI 요소만을 식별하고 업데이트함으로써 처리해야 하는 작업량을 줄일 수 있습니다.

작동 방식

변경 감지: UI 요소의 속성(예: 위치, 크기, 색상 등)에 변경이 발생하면 해당 요소에 Dirty Flag가 설정됩니다. 이는 시스템에게 해당 요소가 업데이트되어야 함을 알립니다.
조건부 업데이트: 렌더링 시스템은 Dirty Flag가 설정된 요소만을 대상으로 업데이트를 수행합니다. 즉, 변경이 없는 요소는 다시 렌더링되지 않아 성능을 절약할 수 있습니다.
계층 구조 영향: 유니티의 UI 요소는 계층 구조로 조직됩니다. 한 요소에 변경이 발생하면, 이는 상위 요소나 하위 요소에도 영향을 미칠 수 있습니다. 예를 들어, 하나의 UI 요소가 더티 상태가 되면, 이는 해당 요소를 포함하는 부모 패널도 더티 상태가 될 수 있습니다. 이러한 방식으로 Dirty Flag는 UI 계층 내에서 전파될 수 있습니다.

Dirty Flag의 장점

성능 최적화: 실제로 변경이 필요한 요소에만 집중함으로써 불필요한 렌더링 작업을 줄일 수 있습니다.
리소스 절약: CPU와 GPU 리소스를 절약할 수 있으며, 특히 모바일 같은 제한된 리소스를 가진 플랫폼에서 중요합니다.
동적 UI 관리 용이: 게임 내에서 동적으로 변경되는 UI 요소들을 효과적으로 관리할 수 있습니다.

4. RectTransform

- Transform이기 때문에 계층 구조가 가능

- RectTransform이 별개가 아니라 Transform이다. ( Transform을 상속받음)

- Transform이 변경될 때 (부모가 바뀔 때 ) - > 부모가 바뀌었어, 부모가 바뀌기전에도 해야하고 부모가 바뀌고 나서도 그리고 자식들도 (할 것이 많음)

- 단순히 활성, 비활성화 하는게 아니라 리페어런팅을 하는 경우도 있는게 이게 매우 싼 행위가 아니다.

5. Rebuild

- 모든 enabled 요소들의 메시를 재생성 (완전 투명 alpha ==0)이라도 생성된다. 그래서 계산을 함

- 캔버스 하나가 드로우 콜이 꼭 1개일 수 없음 각 상황에 따라 달라진다.

- 구조상으로 리페런싱(부모가 바뀔 때) 비싸다.

6. Batch building ( Canvas)

- 캔버스는 갱신이 없으면 계속 그대로 사용됨, 갱신이 있으면 그때 됨

- 갱신을 할 때 배칭 기준을 만들어놔야함 깊이 별로도 체크를 하고 머터리얼 같은걸 사용하는지와 같은 것을 고려하면서 한번에 드로우콜로 만들어 낼 수 있도록 데이터를 만들어낸다 그런 것을 Batch라고 한다. 그리고 멀티 스레드를 사용함

- 만드는 방법이 디바이스에 따라 다름, 휴대용, 게이밍 PC에 따라 다르다. (타겟 PC에서 프로파일링을 해야함)

7. Batching

- 동일한 캔버스

- 동일한 머티리얼 및 스프라이트 에셋

- 동일한 z 깊이의 RectTransform (만약 깊이가 달라지면 배치가 늘어남)

Rendering order : Front to Back vs Back to Front

- 블랜딩이 들어가면 뒤에 있는 애들 부터 그려야함

- UI이도 같이 Z에서 가장 멀리 있는 애를 그려야 하기 때문에 드로우 콜이 나눠져야 해서 배치가 늘어남

- 그래서 시각적으로 같더라도 z값이 나눠져 있으면 드로우 콜이 깨진다.

- 동일한 마스크 적용

- 스프라이트가 별도로 있으면 배칭이 안됨 -> 스프라이트 아틀라스 사용해서 묶자

- 프레임 프로파일링에서 3d 오브젝트는 드로우 콜이 깨진 이유를 알려줌 그런데 UI는 그런게 없음

- 기본 프로파일링에 UI 탭이 있다 거기서 배치가 깨진 이유에 대해서 알려준다.

- Allow Rotation , Tight Packing도 꺼져야 한다. 왜냐 하면 깨지기 때문에 외곽

8. Pixel Perfect

- RectTransform 변경 시

- Pixel Perfect를 체크하면 매우 큰 성능 이슈가 나타남 (느려짐) -> 성능을 많이 먹는 연산이다.

- Pixel Perfect를 꼭 해야 한다면 움직일 때는 Pixel Perfect를 끄는 그러한 개별적인 스크립트를 작성해야함

- NestedCanvas를 만들어서 Pixel Perfect를 상속안되도록 함 (그래서 티가 나거나 그리고 정적인 애들은 Pixel Pefect를 먹이고 동적인 애들은 안먹인다.)

9. Layout Componets (Vertical, Horizontal, Grid, Layout Element...)

- 정적으로 사용하는 애들은 문제가 없으나, 동적인 애들에게 사용하면 갱신 비용이 많이 든다.

- 간단하고 이쁘게 구조화 할 수 있지만 퍼포먼스 이슈가 있음, 그래서 남발하면 안됨

- Dirty flag 시스템에 의존적이다.

- 재구성이 필요 할 때 레이아웃을 활성화 (필요하지 않을 때는 비활성화)

- 재구축되는 하위 엘리먼트 수를 적게 구성

- UI 엘리먼트를 결합 ( ex : 버튼 전경과 배경 합치기) -> 작업이 비효율적일 수 있음. 버튼 전경만 바꾸고 싶은 경우도 있으니...

- 메모리 이슈 발생 가능 (모든 엘리먼트를 다시 갱신해야하기 때문에)

- 레이아웃 관리자 스크립트 제작

- 레이아웃이 업데이트 되는 타이밍 제어

- Object Pool 사용

Cavas Rebuilding - Animator

- idle 애니메이션은 키 프레임을 가져와서 보여주는 것이기 때문에 몇 프레임이 계속 돌기 때문에 갱신이 계속 이러함- UI에서는 최대한 Animator를 사용하지 말자.. 이벤트 성으로 나오는 애들은 닷트윈 같은것을 사용해라(스크립트 계열)

Raycaster

- 필요한 곳에서만 Raycaster 사용하라- 불필요한 곳에서는 비활성화해라- 인터렉션이 필요하다면 Canvas의 Raycaster를 비활성화 하거나 삭제하라 (캔버스에 있으면 하위에 있는 애들은 Raycater를 한다고 취급받는다.)

Full Screen UI- 전체 화면을 덮는 UI 보여줄 시에는 3D 씬 렌더링 불필요 이런 경우 활성화, 비활성화 보다는 카메라를 완전히 돌려버리거, 별도 카메라로 만들거나 하는 형태로 해야한다. 3D 렌더링이 안되도록 - 그리고 UI인 경우 프레임을 많이 먹을 필요가 없기 때문에 타겟 프레임을 30~20으로 나춰준다.

Text -> Icon- Text가 많을 수록 배칭이 깨질 확률이 높음- Text 대신 Icon 사용 권장 -> 다국어 처리에도 효과적

TextMeshPro- 영미권 언어는 큰 문제 없음- 한글은 초성 중성 종성 조합 방식- 꾩 <- 이런 거를 다 지원할 것인가 만약 다 지원하면 큰 Mesh에 그려넣어야하기 때문에 메모리 이슈가 있음- 4096으로 하면 모바일에서 대역폭 이슈가 생김

- Static vs DynamicStatic- 사용될 모든 문자 아틀라스를 미리 생성- 런타임시 원본 폰트가 필요 없음- NPC 대화, UI 관련 등은 Static으로 해도 문제없음Dynamic- 실시간으로 필요한 폰트 아틀라스 갱신- 런타임시 원본 폰트 필요- 사용 문자들의 범위 예측 불가능 시 유용

Multi Atlas Textures- Draw call vs 대역폭(Atlas Resolution)

[Unity] 유니티에서 AI 모델 활용 : Onnx와 Barracuda의 개념 및 설치방법

gogo5911 — Fri, 23 Jun 2023 11:35:55 +0900

1. Onnx란?

ONNX(Open Neural Network Exchange)는 딥러닝 모델을 표현하기 위한 개방형 형식입니다. Microsoft와 Facebook이 주도하여 개발하였고, 이 형식은 여러 딥러닝 프레임워크에서 모델을 공유하기 위한 표준입니다.

ONNX는 여러 프레임워크에서 딥러닝 모델을 생성하고 훈련시킬 수 있도록 하며, 각각의 프레임워크가 제공하는 도구 및 기능을 활용할 수 있습니다. ONNX 형식을 사용하여 모델을 다른 프레임워크로 쉽게 이동할 수 있습니다. 예를 들어, 연구자는 PyTorch에서 모델을 프로토타입하고 개발할 수 있으며, ONNX를 통해 모델을 TensorFlow 또는 Caffe2로 변환하여 서버에서 배포할 수 있습니다.

ONNX는 계산 그래프(computation graph)라는 개념을 사용하여 딥러닝 모델을 표현합니다. 계산 그래프는 노드(node)와 에지(edge)로 구성되며, 각 노드는 연산을, 에지는 노드 간에 전달되는 데이터를 표현합니다. ONNX는 다양한 타입의 노드(예: convolution, pooling, fully connected layer 등)를 지원하여, 매우 복잡한 딥러닝 모델도 표현할 수 있습니다. 따라서 ONNX는 여러 딥러닝 프레임워크 간의 호환성을 제공하여, 개발자가 자신이 선호하는 도구를 사용하여 모델을 개발하고 배포하는 데 도움이 됩니다.

2. Barracuda

Barracuda는 Unity에서 개발한 라이브러리로, Unity 엔진 내에서 신경망을 실행시키는 데 사용됩니다. 이를 통해 개발자들은 Unity 환경에서 직접적으로 머신러닝 모델을 실행시킬 수 있게 되며, 이는 게임이나 다른 Unity 애플리케이션에 AI 기능을 추가하는 데 큰 도움이 됩니다.

Barracuda는 ONNX 포맷의 모델을 지원하며, CPU와 GPU에서 모두 실행될 수 있습니다. 이는 Unity에서 실행되는 모든 플랫폼, 즉 데스크톱, 모바일, 웹 등에서 동작하도록 설계되었습니다.

2.1 Barracuda 유니티 설치

유니티에서 Barracuda 라이브러리를 설치하기 위해서는 다음과 같은 단계를 거쳐야합니다. 첫 번째로 Unity에서 Package Manager를 열어야 합니다. Package Manager는 'Window > Package Manager'에 있습니다.

다음으로 Package Manager에 Barracuda를 찾아 Install해야합니다. 그런데 Barracuda는 일반적인 검색으로 찾을 수 없습니다. 그렇기 때문에 git URL을 통해서 찾아줘야합니다. git URL은 다음과 같이 복사 할 수 있습니다. 먼저 링크를 통해 Barracuda github에 들어갑니다. 그리고 아래 이미지와 같이 Code 버튼을 클릭하고 HTTPS의 주소를 복사해줍니다.

Package Manager의 좌측 상단에 있는 + 버튼을 찾아 눌러줍니다. 그럼 Add package from git URL...이 나옵니다. 이 메뉴를 클릭해줍니다.

그럼 아래와 같이 URL을 입력하는 부분이 나옵니다. 이 부분에 복사해 놓은 링크를 붙여 넣어주시고 Add 버튼을 눌러주면 됩니다.

정상적인 링크를 넣었다면 아래와 같이 패키지를 설치하는 것을 확인할 수 있습니다. 이때 잠시 기다리면 됩니다.

정상적으로 설치가 완료되면 아래 이미지처럼 Barracuda가 설치된 것을 확인할 수 있습니다. (23년 06월 23일 기준으로 가장 최신 버전은 3.0.0 버전입니다.)

[Unity 입문 강좌 - 5] C# 유니티 접근 지정자와 접근자 활용하기 : 데이터 보호 및 캡슐화

gogo5911 — Mon, 19 Jun 2023 20:57:17 +0900

1. 접근 지정자와 접근자의 기본 이해

1.1 접근지정자 or 접근제어자(Access Modifiers)의 개념 설명

유니티에서 사용되는 접근지정자는 클래스 멤버의 접근 수준을 정의하는데 사용됩니다. 각 접근 제한자는 클래스, 변수, 메서드 및 다른 멤버의 가시성과 접근성을 다르게 설정합니다. 여기서 클래스 멤버란 변수, 메서드(함수), 프로퍼티, 이벤트 등을 의미합니다. 다음은 각각의 접근 제한자에 대한 설명입니다.

public : 어떤 클래스에서든 접근할 수 있습니다. public 멤버는 어디서든, 즉 같은 어셈블리(프로젝트) 내부 또는 다른 어셈블리에서도 접근할 수 있습니다.

private : 오직 같은 클래스 내부에서만 접근할 수 있습니다. 다른 클래스에서는 접근할 수 없습니다. private은 해당 클래스의 구현 세부 정보에만 관련되어 있을 때 사용합니다.

internal : 같은 어셈블리(프로젝트) 내의 모든 클래스에서 접근할 수 있지만, 다른 어셈블리의 클래스에서는 접근할 수 없습니다. 프로젝트 내부에서만 사용되어야 하는 멤버에 적합합니다.

protected internal: protected와 internal의 조합으로, 같은 어셈블리 내의 모든 클래스 또는 파생 클래스에서 접근할 수 있습니다. 다시 말해, 어셈블리 내부에서는 internal과 같은 접근 수준을, 어셈블리 외부에서는 protected와 같은 접근 수준을 갖습니다.

private protected: C# 7.2에서 추가된 접근 수준으로, 같은 어셈블리 내의 파생 클래스에서만 접근할 수 있습니다. 다른 어셈블리의 파생 클래스에서는 접근할 수 없습니다. 이는 더 엄격한 protected 접근 수준을 필요로 할 때 유용합니다.

// 어셈블리 내부에서 사용하는 기본 클래스
public class BaseClass
{
   
   // public 멤버: 어디서든 접근 가능
    public int PublicMember = 1;

    // private 멤버: 오직 BaseClass 내부에서만 접근 가능
    private int PrivateMember = 2;

    // internal 멤버: 같은 어셈블리 내에서만 접근 가능
    internal int InternalMember = 3;

    // protected internal 멤버: 같은 어셈블리 내의 모든 클래스 또는 파생 클래스에서 접근 가능
    protected internal int ProtectedInternalMember = 4;

    // private protected 멤버: 같은 어셈블리 내의 파생 클래스에서만 접근 가능
    private protected int PrivateProtectedMember = 5;

}

파생 클래스란? : 객체 지향 프로그래밍에서 상속을 통해 하나의 클래스의 속성과 메서드을 다른 클래스가 받아들이는 메커니즘을 사용하여 정의된 클래스

// 기본 클래스
public class Vehicle {
    public void StartEngine() {
        // 엔진을 시작하는 코드
    }
}

// 파생 클래스
public class Car : Vehicle {
    public void OpenTrunk() {
        // 트렁크를 여는 코드
    }
}

1.2 속성(Property)과 접근자(Accessor)의 개념 설명

속성은 객체가 가지고 있는 데이터를 의미하며, 객체의 상태를 정의합니다. 예를 들어, '차량'이라는 객체가 있다면 '색상', '모델', '제조사' 등이 속성이 될 수 있습니다. 접근자는 이러한 속성에 접근하는 메서드를 의미합니다. get 접근자는 속성 값을 읽어오는 데 사용되며, set 접근자는 속성 값을 설정하는 데 사용됩니다. C#에서는 이를 아래와 같이 표현할 수 있습니다.

private string _color; // 속성

public string Color // 접근자
{
    get { return _color; }
    set { _color = value; }
}

1.3 유니티 내 접근자 사용의 필요성

유니티에서 접근자는 주로 데이터의 캡슐화 및 데이터 보호에 사용됩니다. 예를 들어, 플레이어의 체력을 나타내는 데이터가 있을 때, 이 데이터는 게임 로직 상 직접적으로 변경되어서는 안 되는 값일 수 있습니다. 이럴 때 접근자를 사용하여 이 데이터에 대한 '접근 규칙'을 정의함으로써 데이터를 보호할 수 있습니다. 이런 식으로 더욱 안정적인 코드를 작성할 수 있습니다.

private int _hp; // 플레이어의 체력

public int HP
{
    get { return _hp; }
    set 
    { 
        if(value <= 0) // 체력이 0 이하로 내려가지 않게 한다
        {
            _hp = 0;
        }
        else
        {
            _hp = value; 
        }
    }
}

2. C#의 접근자

C#에서 접근자는 속성에 대한 접근을 제어하는 특별한 메서드로, get과 set 두 가지로 구성됩니다. 이들은 클래스나 구조체 내부의 변수에 간접적으로 접근할 수 있는 방법을 제공합니다.

2.1 get 접근자

get 접근자는 해당 속성의 값을 반환하는 데 사용됩니다. 이는 읽기 전용(read-only) 속성을 생성하는 데도 사용할 수 있습니다. 읽기 전용 속성은 get 접근자만 가지고, set 접근자는 없습니다. 코드에서, _name 필드의 값을 반환하는 Name 속성의 get 접근자를 볼 수 있습니다.

private string _name;

public string Name
{
    get { return _name; } // Name 속성의 값을 반환하는 get 접근자
}

2.2 set 접근자

set 접근자는 속성에 값을 할당하는 데 사용됩니다. 이는 쓰기 전용(write-only) 속성을 생성하는 데도 사용할 수 있습니다. 쓰기 전용 속성은 set 접근자만 가지고, get 접근자는 없습니다. set 접근자 내에서 value라는 키워드를 사용하면, 속성에 할당하려는 값을 참조할 수 있습니다. 코드에서, _name 필드에 값을 할당하는 Name 속성의 set 접근자를 볼 수 있습니다.

private string _name;

public string Name
{
    set { _name = value; } // Name 속성에 값을 할당하는 set 접근자
}

대부분의 경우, 속성은 get 접근자와 set 접근자를 모두 포함하며, 이를 통해 해당 속성의 값을 읽거나 쓸 수 있습니다. 코드에서 Name 속성은 get 접근자와 set 접근자를 모두 가지고 있습니다. 이를 통해 _name 필드의 값을 읽거나 쓸 수 있습니다.

private string _name;

public string Name
{
    get { return _name; }
    set { _name = value; }
}

3. 유니티에서 접근자 사용하기

3.1 접근자를 이용한 데이터 보호

접근자는 클래스의 내부 데이터를 외부로부터 보호하는 데 사용될 수 있습니다. 이를 통해 내부 데이터가 잘못된 방법으로 변경되는 것을 방지할 수 있습니다. 이를 통해 프로그램의 안정성을 높일 수 있습니다.

"외부"라는 용어는 접근 지정자(access modifier)의 Context에서 사용됩니다. 여기서 "외부"는 특정 클래스 또는 객체 외부를 가리킵니다. 예를 들어, 게임에서 플레이어의 체력을 나타내는 필드가 있다고 가정해 보겠습니다. 이 필드는 0 이하의 값이 되면 안 됩니다. 이럴 때 set 접근자를 사용하면 이런 조건을 강제로 적용할 수 있습니다. (아래 코드 참조)

Context는 특정 상황이나 환경을 의미합니다. 접근자와 관련하여 Context는 특정 부분(클래스, 메소드, 변수 등)이 어떤 조건이나 범위 내에서 사용될 수 있는지를 설명하는 배경이나 환경을 가리킵니다. private 접근자가 사용된 멤버는 선언된 클래스 내부에서만 접근할 수 있는 Context에 있습니다. 반면 public 접근 지정자가 사용된 멤버는 어떤 외부 클래스나 객체에서도 접근할 수 있는 더 넓은 Context에 있습니다.

3.2 캡슐화와 접근자

캡슐화는 객체 지향 프로그래밍의 기본 원칙 중 하나로, 데이터와 이를 처리하는 메서드를 하나로 묶는 것을 의미합니다. 이를 통해 클래스의 내부 구현을 숨기고, 사용자에게는 간단한 인터페이스만을 제공합니다.

접근자는 이러한 캡슐화를 지원하는 도구 중 하나입니다. 클래스의 내부 필드에 대한 직접적인 접근을 제한하고, 대신 접근자를 통한 간접적인 접근을 허용함으로써 데이터의 보호를 실현합니다.

코드에서, _health 필드는 private 접근 지정자로 선언되어 클래스 외부에서 직접적으로 접근할 수 없습니다. 대신 Health 속성을 통해 간접적으로 접근할 수 있습니다. 이렇게 접근자를 사용하면, _health 필드에 대한 접근 규칙을 명확하게 정의할 수 있습니다.

private int _health;

public int Health
{
    get { return _health; }
    set
    {
        if (value < 0) // 체력이 0 이하로 내려가지 않도록 하는 조건문
        {
            _health = 0;
        }
        else
        {
            _health = value;
        }
    }
}

4. 유니티 접근자 예시

유니티에서는 여러 내장 객체와 컴포넌트를 제공합니다. 이들에는 다양한 프로퍼티와 접근자가 포함되어 있습니다. 여기서는 transform과 position 등의 주요 접근자를 살펴보겠습니다.

모든 GameObject는 transform 컴포넌트를 가지며, 이를 통해 객체의 위치(position), 회전(rotation) 및 크기(scale)를 가져오거나 설정할 수 있습니다. 이들은 모두 프로퍼티로, get 접근자와 set 접근자를 사용하여 읽고 쓸 수 있습니다.

// 객체의 위치를 가져옴
Vector3 position = gameObject.transform.position;

// 객체의 위치를 설정함
gameObject.transform.position = new Vector3(0, 0, 0);

transform 컴포넌트의 하위 프로퍼티로, 객체의 위치를 나타냅니다. 이 역시 get 접근자와 set 접근자를 사용하여 읽고 쓸 수 있습니다.

// 객체의 위치를 가져옴
Vector3 position = gameObject.transform.position;

// 객체의 위치를 설정함
gameObject.transform.position = new Vector3(10, 0, 5);

[Unity 입문 강좌] Unity(유니티) Editor 인터페이스

gogo5911 — Tue, 13 Jun 2023 11:32:27 +0900

1. Unity Editor Interface

Unity Editor는 유니티 엔진의 주요 개발 환경으로, 게임과 같은 콘텐츠를 만들기 위한 툴입니다. Unity Editor를 사용하여 3D 및 2D 게임 환경을 시각적으로 구성하고, 오브젝트를 배치하고, 스크립트를 적용하고, 게임을 테스트하고, 빌드할 수 있습니다. Unity Editor에는 6개의 주요 창이 있습니다. Scene View, Game View, Hierarchy, Inspector, Project, Console 입니다. 이 창들은 아래 이미지와 같은 기본형태를 가지고 있지만 사용자가 편하게 레이웃을 변경할 수도 있습니다.

1.2 프로젝트(Project) 창

프로젝트 창은 유니티에서 프로젝트에 포함된 모든 에셋을 보여주는 창입니다. 이 창은 개발자가 손쉽게 원하는 에셋을 찾아서 사용할 수 있도록 해줍니다. 그래서 프로젝트창은 에셋 라이브러리라고 생각할 수 있습니다. 여기에서 에셋은 스크립트, 3D 모델, 텍스처, 오디오 파일, 프리팹, 애니메이션 등 프로젝트에 사용되는 모든 파일을 통칭하는 말입니다.

프로젝트창 상단에는 검색창이 있습니다. 이를 통해 특정 에셋을 쉽게 찾을 수 있습니다. 이름뿐만 아니라 에셋의 종류(스크립트, 텍스처 등)로도 검색이 가능합니다. 또한 프로젝트 창에는 뷰 옵션을 가지고 있어 그리드 뷰로 보거나 리스트 뷰로 볼 수 있습니다. 그리드 뷰는 주로 이미지나 모델 등의 에셋을 미리보기 할 때 유용하며, 리스트 뷰는 텍스트 기반의 에셋을 보기 좋습니다.

에셋을 선택하면, 그 에셋의 상세 정보를 볼 수 있습니다. 이 정보는 해당 에셋의 이름, 유형, 크기, 생성 날짜 등을 포함하고 있습니다. 또한 에셋을 더블클릭하면 그 에셋을 편집할 수 있는 적절한 에디터가 열립니다.(예를 들어 스크립트를 더블 클릭하면 코드 에디터가 열립니다.)

에셋을 드래그 앤 드롭으로 원하는 위치로 옮길 수 있습니다. 또한 에셋에 마우스 오른쪽 버튼을 클릭하면 다양한 옵션을 통해 에셋을 조작할 수 있습니다. (예를 들어, 에셋을 복제하거나, 삭제하거나, 이름을 변경하거나, 에셋의 위치를 바꾸거나 등이 있습니다.)

1.2 콘솔(Console)창

콘솔 창은 프로그램 실행 도중 발생하는 오류, 경고, 정보 메시지를 출력하는 창입니다. 여기서 출력되는 메시지는 대부분 스크립트에서 Debug.Log, Debug.LogWaring, Debug.LogError 등의 메서드를 통해 출력되는 메시지입니다. 콘솔 창은 디버깅 및 문제 해결에 있어 필수적인 도구입니다.

로그 메시지는 프로그램 실행 중에 Debug.Log 메서드를 호출하여 출력되는 일반 정보 메시지입니다. 일반적인 용도로는 프로그램의 진행 상황을 확인하거나 변수의 값을 확인하는데 사용됩니다. 경고 메시지는 Debug.LogWarning 메서드를 호출하여 출력되는 경고 메시지입니다. 주로 문제가 될 수 있는 상황을 알리는데 사용됩니다. 오류 메시지는 Debug.LogError 메서드를 호출하여 출력되는 오류 메시지입니다. 프로그램의 실행을 방해하는 심각한 문제가 발생했음을 나타냅니다.

메시지 필터링는 콘솔 창 상단에는 로그, 경고, 오류 메시지를 필터링하는 버튼이 있습니다. 이를 통해 원하는 유형의 메시지만 볼 수 있습니다.

메시지 상세 정보 메시지를 클릭하면 메시지의 전체 내용과 그 메시지가 발생한 스크립트와 줄 번호를 확인할 수 있습니다. 이 정보는 문제의 원인을 찾는 데 매우 유용합니다. 또한 자동 스크롤 콘솔 창은 기본적으로 새로운 메시지가 출력될 때마다 스크롤이 자동으로 아래로 이동합니다. 이는 실시간으로 로그를 확인하려는 경우에 유용하지만, 때때로 방해가 될 수도 있습니다. 이럴 때는 자동 스크롤 옵션을 해제할 수 있습니다.

1.3 계층(Hierarchy)창

Unity의 계층 창(Hierarchy Window)은 현재 씬(Scene)에 있는 모든 게임 오브젝트를 나열하여 보여줍니다. 이는 물리적 구조뿐만 아니라 로직적 계층 관계를 표현하는데도 사용됩니다.

게임 오브젝트 간에는 부모-자식 관계를 형성할 수 있습니다. 이 관계는 계층 창에서 들여쓰기로 표시되며, 부모 게임 오브젝트가 이동하거나 회전하면 자식 게임 오브젝트도 함께 이동하거나 회전합니다.

계층 창을 통해 새로운 게임 오브젝트를 생성하거나 기존 게임 오브젝트를 삭제할 수 있습니다. 새로운 게임 오브젝트는 기본적으로 빈 게임 오브젝트로 생성되지만, Light, Camera, 3D Object 등 특정 유형의 게임 오브젝트를 생성할 수도 있습니다. 계층 창 상단에는 검색 창이 있습니다. 이를 통해 게임 오브젝트의 이름으로 검색할 수 있습니다. 또한 Ctrl(또는 Cmd)키를 누른 상태에서 여러 개의 게임 오브젝트를 선택하면, 그들을 함께 조작할 수 있습니다. 이는 여러 게임 오브젝트를 동시에 이동하거나 삭제하는 데 유용합니다.

1.4 씬(Scene) 뷰

Unity의 씬 뷰(Scene View)는 개발자가 게임의 3D 환경을 직접 시각화하고 조작할 수 있는 창입니다. 씬 뷰는 3D 환경을 표시하거나 2D 환경을 표시하는 데 사용할 수 있습니다. 이는 상단의 툴바에서 간단하게 전환할 수 있습니다. 그리고 씬 뷰에서는 게임 오브젝트를 직접 드래그하거나 회전시키거나 크기를 조절하여 위치와 모양을 조절할 수 있습니다. 이 조작은 상단 툴바의 Move, Rotate, Scale 도구를 통해 수행할 수 있습니다.

씬 뷰에서는 카메라의 위치를 자유롭게 이동하거나 회전시켜 다양한 시점에서 게임 환경을 볼 수 있습니다. 카메라 조작은 마우스와 키보드를 사용하여 수행할 수 있습니다. 그리고 게임 오브젝트를 클릭하면 해당 오브젝트가 선택되고, Inspector 창에서 해당 오브젝트의 상세 정보를 확인할 수 있습니다. 또한, F 키를 누르면 선택한 오브젝트에 초점을 맞출 수 있습니다.

씬 뷰에는 여러가지 역할을 하는 도구가 있습니다. 첫 번째로 Gizmos입니다. Gizmos는 씬 뷰에서 특별한 역할을 하는 오브젝트를 시각적으로 강조하기 위한 도구입니다. 예를 들어, 카메라나 조명 등의 오브젝트는 Gizmos를 통해 쉽게 식별할 수 있습니다.

두 번째로 Skybox와 그리드를 표시하는 기능입니다. 씬 뷰의 배경에는 Skybox가 표시되며, 이는 Scene Settings에서 변경할 수 있습니다. 또한, 그리드를 통해 공간을 더 쉽게 이해할 수 있습니다.

세 번째로 렌더링 설정입니다. 씬 뷰의 상단 오른쪽에서는 씬의 렌더링 설정을 변경할 수 있습니다. 이를 통해 와이어프레임 뷰나 쉐이딩 뷰 등 다양한 방식으로 씬을 볼 수 있습니다.

씬 뷰는 게임이 실행 중일 때도 업데이트되므로, Play 모드에서 게임의 동작을 직접 확인할 수 있습니다. 하지만, Play 모드에서는 게임 오브젝트의 변경 사항이 저장되지 않으므로 주의가 필요합니다.

1.5 게임(Game)뷰

Unity의 게임 뷰(Game View)는 개발자가 게임을 플레이어의 시각으로 볼 수 있는 창입니다. 게임 뷰는 현재 활성화된 카메라를 통해 게임이 어떻게 보일지 미리 보여줍니다. 게임 뷰는 Unity 에디터 내에서 게임을 실행하여 실시간으로 테스트하는 데 사용됩니다. 이를 통해 개발 과정에서 게임의 동작과 인터랙션을 확인하고 조정할 수 있습니다. 게임 뷰의 상단 툴바에서는 게임을 표시하는 화면의 해상도와 비율을 변경할 수 있습니다. 이를 통해 다양한 디바이스와 환경에서 게임이 어떻게 보일지 미리 확인할 수 있습니다.

1.6 인스펙터(Inspector)창

Unity의 인스펙터 창(Inspector Window)은 선택한 오브젝트의 세부 정보와 속성을 보고 수정할 수 있는 창입니다. 씬에서 게임 오브젝트를 클릭하면, 그 오브젝트에 대한 정보가 인스펙터 창에 표시됩니다. 인스펙터 창을 통해 오브젝트의 모든 속성을 확인하고 수정할 수 있습니다. 예를 들어, 게임 오브젝트를 선택하면 그 오브젝트의 위치, 회전, 크기 등의 변형 속성을 확인하고 수정할 수 있습니다. 또한 인스펙터 창에서는 컴포넌트를 추가하거나 삭제하거나 수정할 수 있습니다. 예를 들어, 물리적 동작을 추가하려면 Rigidbody 컴포넌트를 추가하고, 그 컴포넌트의 속성을 인스펙터 창에서 수정하면 됩니다.

게임 오브젝트에 연결된 스크립트의 public 변수를 인스펙터 창에서 확인하고 수정할 수 있습니다. 또한, 스크립트의 이름을 클릭하면 코드 에디터에서 해당 스크립트를 열어 볼 수 있습니다. 그리고 여러 오브젝트를 선택하면 인스펙터 창에서는 그 오브젝트들의 공통 속성만을 표시합니다. 이 상태에서 속성을 변경하면 선택한 모든 오브젝트에 동일한 변경이 적용됩니다. 또한 인스펙터 창의 우측 상단에는 락 버튼이 있습니다. 이 버튼을 클릭하여 인스펙터 창을 락하면, 다른 오브젝트를 선택하더라도 인스펙터 창의 내용이 변경되지 않습니다. 이 기능은 한 오브젝트의 속성을 계속 확인하거나 수정해야 할 때 유용합니다.

2. Unity Editor Tools

2.1 Transform Tools

Transform Tools는 씬 왼쪽에 위치합니다.(버전에 따라 다를 수 있습니다.) 이 도구들은 씬에서 게임 오브젝트를 조작하는 데 사용됩니다.

Hand Tool (손모양 도구): 씬 뷰를 드래그하여 움직일 수 있게 합니다.
Move Tool (이동 도구): 선택한 오브젝트를 이동시킬 수 있게 합니다.
Rotate Tool (회전 도구): 선택한 오브젝트를 회전시킬 수 있게 합니다.
Scale Tool (크기 조정 도구): 선택한 오브젝트의 크기를 조절할 수 있게 합니다.
Rect Tool (사각형 도구): UI 요소나 2D 스프라이트의 크기와 위치를 조절할 수 있게 합니다.

2.2 Play, Pause, Step

Play, Pause, Step는 유니티 에디터의 상단 가운데 부분에 위치합니다. 이 버튼들은 게임의 실행과 테스트를 제어합니다.

Play Button (재생 버튼): 게임을 실행하거나 정지시킵니다.
Pause Button (일시 정지 버튼): 실행 중인 게임을 일시 정지하거나, 일시 정지한 게임을 다시 실행합니다.
Step Button (한 단계 진행 버튼): 게임을 한 프레임씩 진행시킵니다.

[Unity 입문 강좌] 유니티 좌표계 체계의 이해와 활용 방법

gogo5911 — Tue, 6 Jun 2023 20:06:40 +0900

1. 차원에 따른 좌표계

1.1. 1차원 좌표계

1차원 좌표계는 실질적으로 직선 상의 위치를 나타냅니다. 이 좌표계는 단일 축, 종종 x축이라고 부르는 값에 따라 결정됩니다. 가장 단순한 형태의 이 좌표계에서는, 단일 수치(스칼라) 값으로 표현됩니다.

예를 들어, 온도 변화를 측정하는 것은 1차원 좌표계에서 이루어질 수 있습니다. 가령 어떤 곳의 기온이 낮부터 늦은 밤까지 어떻게 변하는지 보려면, 당신은 시간(1차원)에 따른 온도(측정 값)을 추적하면 됩니다.

1차원 좌표계

1.2. 2차원 좌표계

2차원 좌표계는 평면좌표계라고도 하며, 점들은 두 개의 값을 갖습니다. 값은 x와 y로 표현되며, 각각 수평축과 수직축을 나타냅니다.

예를 들어 당신이 지도를 사용하여 특정 도시의 위치를 찾는다고 할 때, 도시의 위치는 지도의 두 축, 즉 경도(x축)과 위도(y축)에 따라 결정됩니다.

2차원 좌표계

1.3. 3차원 좌표계

3차원 좌표계는 공간좌표계라고도 하며, 점들은 세 개의 값을 갖습니다. 이 값들은 x, y, z로 표시되며, 각각을 하나의 축이라고 생각할 수 있습니다. 이 좌표계는 우리가 살고 있는 실제 세상을 가장 잘 나타냅니다.

예를 들어, 당신이 드론을 날리고 있다고 상상해봅시다. 이 드론의 위치는 지상으로 부터의 높이(z축), 그리고 북쪽 및 동쪽으로의 거리(x축과, y축)에 따라 결정 됩니다.

3차원 좌표계

Unity는 3차원 게임 엔진으로, 3차원 좌표계를 사용하여 객체의 위치를 결정합니다. 스크립트에서 이를 사용하는 방법은 다음과 같습니다. 먼저, 객체의 위치를 설정하려면 transform.position을 사용하고 Vector3 객체를 제공해야 합니다. Vector3는 x, y, z의 세가지 값으로 구성됩니다. (transform과 Vecot3와 관련 상세한 내용은 추후 학습합니다. 현재 글에서는 아래와 같은 형식으로 유니티에서 객체의 위치를 설정할 수 있고, 가져올 수 있다. 정도만 알고 넘어가면 됩니다.)

예를 들어, 객체를 (10, 15, 20) 위치로 이동하려면 다음 코드를 사용할 수 있습니다.

transform.position = new Vector3(10, 15, 20);

또한, 객체의 현재 위치를 얻으려면 transform.position을 사용할 수 있습니다. 이렇게 하면 currentPosition은 객체의 현재 위치를 나타내는 Vector3가 됩니다.

Vector3 currentPosition = transform.position;

3차원 공간을 표현하는 데에는 다양한 좌표계들이 사용됩니다. 이 중에서도 흔히 사용되는 좌표계는 왼손 좌표계와 오른손 좌표계입니다. 이는 세 축 X, Y, Z의 방향성을 결정하는 방법을 나타냅니다. 또한 3차원 공간에서의 높이를 표현하는 축이 Y축인지 Z축인지에 따라 Y-Up, Z-up으로 구분됩니다. 각 좌표계는 그래픽스 라이브러리나 게임 엔진에 따라 다르게 사용됩니다. 아래 이미지는 각 엔진에서 사용하는 좌표계입니다. 이제 이러한 좌표계의 특징에 대해 알아보도록 하겠습니다.

출처 : 트위터(@FreyaHolmer)

2. 3차원 공간의 좌표계 종류

좌표계는 대부분의 그래픽스 라이브러리와 게임 엔진에서 기본적으로 내장되어 있습니다. 이 중 일부는 왼손 좌표계를 사용하며, 다른 일부는 오른손 좌표계를 사용합니다. 이 두 좌표계 사이의 주요 차이점은 z축의 방향입니다. 아래 이미지는 왼손 좌표계와 오른손 좌표계의 차이점을 보여주고 있습니다.

출처 : A Guide to Unity's Coordinate System (With Examples) - techarthub

2.1. 왼손 좌표계 (Left-handed coordinate system)

왼손 좌표계에서는 x축, y축, z축이 왼손의 엄지손가락, 검지손가락, 중지손가락과 같은 방향을 가리키도록 구성됩니다. 이 좌표계에서는 x축이 오른쪽, y축이 위쪽, 그리고 z축이 전방(화면 안쪽)으로 설정됩니다.

2.2. 오른손 좌표계 (Right-handed coordinate system)

오른손 좌표계에서는 x축, y축, z축이 오른손의 엄지손가락, 검지손가락, 중지손가락과 같은 방향을 가리키도록 구성됩니다. 이 좌표계에서는 x축이 오른쪽, y축이 위쪽, 그리고 z축이 후방(화면 바깥쪽)으로 설정됩니다.

3. 높이를 표현하는 축에 따른 좌표계

3.1. Y-up

Y-up은 3차원 공간에서 높이를 표현하는 축이 Y축이라는 것을 의미합니다. 이 경우 X축은 좌우 방향, Y축은 상하 방향, 그리고 Z축은 전후 방향으로 설정됩니다. Y-up 좌표계는 Unity, Maya, Blender 등의 게임 엔진과 3D 모델링 소프트웨어에서 주로 사용됩니다.

출처 :Y-Up or Z-Up (reallusion.com)

예시를 들어보면, Unity 게임 엔진에서 만들어진 모델이 있다고 가정합니다. 이 캐릭터를 위로 움직이려면, Y축 값만 변경하면 됩니다. 즉, 현재 위치가 (0, 0, 0)이라면, 캐릭터를 위로 움직이기 위해서는 위치를(0, 5, 0)으로 변경하면 됩니다.

3.2. Z-up

Z-up은 3차원 공간에서 높이를 표현하는 축이 Z축이라는 것을 의미합니다. 이 경우 X축은 좌우 방향, Y축은 전후 방향, 그리고 Z축은 상하 방향으로 설정됩니다. Z-up 좌표계는 3ds Max, Unreal Engine 등의 3D 모델링 소프트웨어와 게임 엔진에서 주로 사용됩니다.

출처 : Y-Up or Z-Up (reallusion.com)

Z-up 예시로, Unreal Engine에서 3D 캐릭터 모델이 있다고 가정하면, 이 캐릭터를 위로 움직이기 위해서는 Z축의 값을 변경해야 합니다. 즉, 현재 위치가 (0,0,0)이라면, 캐릭터를 위로 5 단위 움직이려면 위치를 (0,0,5)로 변경하면 됩니다.

Y-up과 Z-up 간의 변환은 간단한 수학적 연산을 통해 가능합니다. 예를 들어, Y-up 좌표계에서 Z-up 좌표계로 변환하려면 (x, y, z) 좌표를 (x, z, -y)로 변경하면 됩니다. 게임 개발이나 3D 모델링 작업 시 사용하는 소프트웨어에 따라 적절한 축을 사용하고 변환할 필요가 있습니다.

4. 좌표계 변환

4.1. 월드 좌표계

월드(World) 좌표계는 게임이나 3D 모델링에서 전체 공간에서 절대적인 위치를 나타내는 좌표계를 가리킵니다. 월드 좌표계의 원점은 보통 게임 세계의 중앙 또는 특정 지점으로 설정되며, 이 점을 기준으로 모든 위치와 거리가 측정됩니다. 월드 좌표계에서의 위치는 게임 세계의 고정된 기준점에 대한 상대적인 거리와 방향으로 표현됩니다.

예를 들어, 게임 세계에서 캐릭터의 월드 좌표계 위치가 (10, 20, 30)이라면, 이는 월드 좌표계의 원점으로부터 x축 방향으로 10, y축 방향으로 20, z축 방향으로 30의 거리에 위치해 있다는 것을 의미합니다.

4.2. 로컬 좌표계

로컬(Local) 특정 게임 오브젝트에 상대적인 위치를 나타내는 좌표계입니다. 각 게임 오브젝트는 자신만의 로컬 좌표계를 가지며, 이는 오브젝트의 원점, 회전, 크기에 따라 결정됩니다. 로컬 좌표계에서의 위치는 부모 게임 오브젝트(또는 부모가 없는 경우 월드 좌표계)에 대한 상대적인 거리와 방향으로 표현됩니다.

예를 들어, 로컬 좌표계 위치가 (0, 1, 0)이라면, 이는 부모 게임 오브젝트로 부터 x축 방향으로 0, y축 방향으로 1, z축 방향으로 0의 거리에 위치해 있다는 것을 의미합니다.

이미지에는 Cube와 Sphere 두 오브젝트가 표시되어 있습니다. Cube는 부모 오브젝트가 없어 월드 좌표계를 사용합니다. 따라서 Transform의 Position 값이 월드 좌표 (10, 20, 30)에 해당하며, 이는 Cube가 월드 공간에서 해당 좌표에 위치함을 의미합니다.

반면에 Sphere는 Cube를 부모 오브젝트로 가지고 있으며, 이 경우 로컬 좌표계를 이용합니다. Sphere의 Transform Position 값이 (0, 1, 0)으로 표시되는 이유는, 이 값이 부모 오브젝트인 Cube에 대한 상대적인 위치를 나타내기 때문입니다. 즉, 이 설정에 따라 Sphere는 Cube 위에 위치하게 됩니다.

[Unity 입문 강좌] 유니티 생명주기(Lifecycle)과 이벤트 메서드

gogo5911 — Mon, 5 Jun 2023 12:30:57 +0900

1. 유니티 생명 주기란?

컴포넌트들과의 상호작용 그리고 사용자 입력에 대한 반응들을 통해 오브젝트를 제어 할 수 있다고 했습니다. 이러한 상호작용과 반응은 순차적이고 구조화된 방식으로 이루어집니다. 이를 가능하게 하는 것이 바로 유니티의 생명 주기(Life-cycle) 입니다. 이는 객체가 생성되고 활성화되며, 업데이트되고, 종료되는 과정을 의미합니다. 이 생명주기에는 여러 이벤트 메서드가 존재하며, 이를 통해 게임 오브젝트의 동작을 제어할 수 있습니다.

아래 이미지는 유니티의 생명 주기의 흐름도를 보여줍니다. 생명 주기는 주요 이벤트 메서드들로 구성되며, 각 메서드는 필요한 각 단계에서 호출됩니다.

1.1 Awake()

Awake()는 게임 오브젝트가 비활성 상태에서도 호출되며, 씬(Scene)이 로드될 때마다 모든 오브젝트에 대해 한 번만 호출됩니다. 또한, 해당 게임 오브젝트의 모든 스크립트에 있는 Awake() 메서드가 실행되기 전에는 다른 게임 오브젝트나 컴포넌트에 의존하지 않는 초기화 작업을 수행하는 것이 좋습니다.

Awake() 메서드를 사용하여 수행할 수 있는 일은 다음과 같습니다.

게임 오브젝트의 변수 초기화
컴포넌트 가져오기 및 초기화
게임 매니저나 싱글톤과 같은 다른 게임 오브젝트에 대한 참조 설정

Awake()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void Awake() 
{
    // Some initialization code here
}

1.2 OnEnable()

OnEnable() 메서드는 게임 오브젝트가 비활성화되거나 스크립트가 비활성화된 후 다시 활성화될 때마다 호출되기 때문에, 재활성화시 필요한 작업을 수행하는데 적합합니다. 유니티에서 이벤트 등록, 이벤트 리스너 설정, Coroutine 시작 등의 작업에 많이 사용됩니다. (이벤트 등록, 이벤트 리스너, Coroutine은 추후 글에서 설명합니다.)

OnEnable()은 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnEnable() 
{
    // Some enabling code here
}

게임 오브젝트의 활성화 상태는 인스펙터 패널에서 체크 박스를 통해 제어할 수 있으며, 스크립트에서는 gameObject.SetActive(true) 또는 gameObject.SetActive(false)와 같은 메서드를 사용하여 제어할 수 있습니다.

1.3 Start()

Start()는 게임 오브젝트나 컴포넌트를 초기화하는데 사용됩니다. 그러나 Awake()와 달리 Start()는 게임 오브젝트가 활성화되는 동안 한 번만 호출되므로, Awake()에서 초기화된 다른 스크립트나 컴포넌트에 의존하는 초기화 작업을 수행하는 데 사용됩니다.

또한, Start()는 게임 오브젝트가 비활성화된 상태에서는 호출되지 않습니다. 게임 오브젝트가 활성화될 때 Start()가 호출되며, 한번 호출된 이후로는 게임 오브젝트가 다시 활성화되더라도 재호출되지 않습니다.

Start()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있습니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void Start() 
{
    // Some initialization code here
}

1.4 FixedUpdate()

FixedUpdate()는 매 물리 프레임마다 호출되며, 주로 물리적인 연산(예를 들어, 리지드바디(Rigidbody)의 움직임을 다루는 것)에 사용됩니다.

Unity의 물리 시스템은 일정한 시간 간격(물리 타임스텝)에 따라 업데이트되며, FixedUpdate() 함수도 이 물리 타임스텝에 맞춰 호출됩니다. 이는 Update() 메서드와 달리 프레임 레이트에 영향을 받지 않기 때문에, 물리 시뮬레이션과 같이 일정한 업데이트 주기가 필요한 작업에 이상적입니다. 예를 들어, Rigidbody 컴포넌트에 힘을 가하는 것은 보통 FixedUpdate() 메서드 내에서 수행합니다. 왜냐하면 이는 Unity의 물리 엔진이 FixedUpdate() 사이의 간격으로 동작하기 때문입니다.

FixedUpdate()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void FixedUpdate() 
{
    // Some physics related code here
}

1.5 OnTrigger ___()

OnTrigger___ 메서드들은 Collider 컴포넌트가 트리거 모드로 설정되어 있을 때 호출되며, 물리적인 상호작용을 처리하는데 사용됩니다. 이들 메서드는 모두 매개변수로 Collider 혹은 Collider2D 타입의 객체를 받습니다. (매개 변수, Collider는 추후 글에서 설명합니다.)

1.5.1 OnTriggerEnter()

OnTriggerEnter(): 트리거와 다른 Collider가 처음 겹치기 시작할 때 한 번 호출됩니다. 이 메서드는 트리거에 진입하는 객체를 감지하거나 트리거에 진입하는 순간의 특정 동작을 실행하는 데 유용합니다.

OnTriggerEnter()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnTriggerEnter(Collider other) 
{
    // Code to execute when an object enters the trigger
}

1.5.2 OnTriggerStay()

트리거와 다른 Collider가 계속 겹쳐 있을 때 매 프레임마다 호출됩니다. 이 메서드는 트리거 내에 객체가 계속 있을 때 실행해야 하는 동작을 처리하는 데 유용합니다.

OnTriggerStay()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnTriggerStay(Collider other) 
{
    // Code to execute when an object stays in the trigger
}

1.5.3 OnTriggerExit()

트리거와 다른 Collider가 겹치지 않게 될 때 한 번 호출됩니다. 이 메서드는 트리거에서 나가는 객체를 감지하거나 트리거를 떠나는 순간의 특정 동작을 실행하는 데 유용합니다.

OnTriggerExit()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnTriggerExit(Collider other) 
{
    // Code to execute when an object exits the trigger
}

1.6 OnCollision___()

OnCollision___ 메서드들은 물리적 충돌을 처리하는 데 사용되며, Collider 컴포넌트가 트리거 모드로 설정되어 있지 않을 때 호출됩니다. 이들 메서드는 모두 매개변수로 Collision 혹은 Collision2D 타입의 객체를 받습니다. 이 매개변수는 충돌 이벤트에 대한 정보를 제공합니다. (매개 변수, Collision은 추후 글에서 설명합니다.)

1.6.1 OnCollisionEnter()

두 Collider가 처음 충돌할 때 한 번 호출됩니다. 이 메서드는 충돌이 시작될 때 특정 동작을 실행하거나, 충돌하는 객체를 감지하는 데 사용될 수 있습니다.

OnCollisionEnter()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnCollisionEnter(Collision collision) 
{
    // Code to execute when the collision starts
}

1.6.2 OnCollisionStay()

두 Collider가 계속 충돌하고 있을 때 매 프레임마다 호출됩니다. 이 메서드는 두 객체가 계속 충돌하고 있을 때 실행해야 하는 동작을 처리하는 데 사용될 수 있습니다.

OnCollisionStay()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnCollisionStay(Collision collision) 
{
    // Code to execute every frame while the collision continues
}

1.6.3 OnCollisionExit()

두 Collider가 더 이상 충돌하지 않게 될 때 한 번 호출됩니다. 이 메서드는 충돌이 끝나는 순간에 특정 동작을 실행하거나, 충돌이 종료된 것을 감지하는 데 사용될 수 있습니다.

OnCollisionExit()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnCollisionExit(Collision collision) 
{
    // Code to execute when the collision ends
}

1.7 Update()

Update()는 매 프레임마다 호출되며, 주로 게임 로직, 상태의 업데이트, 사용자 입력의 처리 등을 수행하는데 사용됩니다. 게임이 실행되는 동안 매 프레임에서 호출되므로, 이 메서드 내에서 수행되는 작업은 가능한 한 가볍게 유지해야 합니다. 복잡하고 무거운 작업이 Update() 메서드에 포함되면, 프레임 레이트에 부정적인 영향을 미칠 수 있습니다.

또한, Update() 메서드는 프레임 레이트에 따라 호출 간격이 변할 수 있습니다. 따라서, 프레임 레이트에 종속적이지 않은 부드러운 움직임을 구현하려면 Time.deltaTime을 사용하여 시간 간격을 보정해야 합니다.

Update()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있습니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void Update() 
{
    // Code to execute every frame
}

1.8 LateUpdate()

LateUpdate()는 매 프레임마다 호출되지만, 일반적인 Update() 메서드가 모두 호출된 이후에 호출됩니다. 주로 Update() 메서드에서 발생한 변화에 따라 후처리를 하는데 사용됩니다. 예를 들어, 카메라를 플레이어 캐릭터가 이동한 후의 위치에 따라 움직이게 하려면, LateUpdate()에서 카메라의 위치를 조정하면 됩니다. 이렇게 하면 Update() 메서드에서 플레이어 캐릭터가 이동한 후에 카메라가 움직이게 됩니다.

LateUpdate()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void LateUpdate() 
{
    // Some code here to execute after all Update methods
}

1.9 OnDisable()

OnDisable()는 해당 게임 오브젝트나 그에 연결된 스크립트가 비활성화될 때 호출됩니다. 유니티에서 이벤트의 해제, 리스너의 제거, Coroutine의 정지 등의 작업에 주로 사용됩니다. 이 메서드는 게임 오브젝트나 스크립트가 활성화에서 비활성화로 전환될 때마다 호출되기 때문에, 비활성화 시 필요한 정리 작업을 수행하는 데 적합합니다.

OnDisable()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnDisable() 
{
    // Some disabling code here
}

게임 오브젝트의 활성화 상태는 인스펙터 패널에서 체크 박스를 통해 제어할 수 있으며, 스크립트에서는 gameObject.SetActive(true) 또는 gameObject.SetActive(false)와 같은 메서드를 사용하여 제어할 수 있습니다. 이런 방법으로 게임 오브젝트나 스크립트의 활성화 상태를 변경하면, OnEnable() 또는 OnDisable() 메서드가 호출됩니다.

1.10 OnDestroy()

OnDestroy()는 게임 오브젝트나 스크립트가 Destroy() 메서드에 의해 제거되기 직전에 호출됩니다. 주로 필요한 정리 작업을 수행하는 데 사용됩니다. 예를 들어, 이 메서드 내에서 사용한 리소스의 해제, 연결의 해제, 이벤트 핸들러의 제거 등을 수행할 수 있습니다. 또한, 게임 오브젝트가 파괴되는 시점에 특정 행동을 실행하기 위해 이 메서드를 사용할 수도 있습니다.

OnDestroy()는 아래와 같은 형태로 사용하며, 스크립트에 기본적으로 처음에 생성되어 있지 않기 때문에 사용자가 작성해야합니다. 이 메서드는 직접 호출되지 않으며, 자동으로 호출됩니다.

void OnDestroy() 
{
    // Cleanup code here
}

Destroy() 메서드를 사용하여 게임 오브젝트나 컴포넌트를 파괴하는 방법은 다음과 같습니다. 이렇게 Destroy() 메서드를 호출하면, 해당 게임 오브젝트나 컴포넌트가 파괴되기 직전에 OnDestroy() 메서드가 호출됩니다.

// Destroy an object immediately
Destroy(gameObject);

// Destroy an object after a delay
Destroy(gameObject, 5f); // Destroys the object after 5 seconds

1.11 OnApplicationQuit()

OnApplicationQuit()는 유니티 애플리케이션이 종료될 때 호출됩니다. 애플리케이션 종료 전에 실행해야 할 코드를 정의하는 데 사용됩니다. 예를 들어, 게임 진행 상황을 저장하거나, 네트워크 연결을 종료하거나, 사용한 리소스를 정리하는 등의 작업을 수행할 수 있습니다.

OnApplicationQuit() 메서드를 사용하여 게임 오브젝트나 컴포넌트를 파괴하는 방법은 다음과 같습니다. 이렇게 Destroy() 메서드를 호출하면, 해당 게임 오브젝트나 컴포넌트가 파괴되기 직전에 OnDestroy() 메서드가 호출됩니다.

void OnApplicationQuit() 
{
    // Code to execute when the application is about to quit
}

하지만 OnApplicationQuit() 메서드가 호출되는 시점은 유니티 에디터와 실제 빌드된 애플리케이션에서 다르게 작동할 수 있습니다. 특히 모바일 디바이스에서는 홈 버튼을 눌러 애플리케이션을 백그라운드로 보내는 경우 이 메서드가 호출되지 않을 수 있습니다. 이런 상황에서는 OnApplicationPause() 메서드를 함께 사용해야 할 수 있습니다.

COCO data set(Common Objects in Context) 다운로드와 구성요소 및 시각화 코드

gogo5911 — Wed, 31 May 2023 17:47:26 +0900

1. COCO Data Set이란?

COCO Data Set은 "Common Objects in Context"의 약자로 Object detation, Segmentation, image capsion과 같은 컴퓨터 비전 작업을 위해 널리사용되는 대규모 이미지 데이터셋입니다. COCO Data Set은 오픈 라이선스를 가지고 있어 학술 연구와 상업적인 목적을 포함한 다양한 분야에서 활용됩니다. 특히 논문에서 성능 평가 목적으로 많이 사용됩니다. COCO Data Set은 다양한 카테고리에 속하는 약33만 개의 이미지로 구성되어 있으며, 이들 이미지에는 약 80개 이상의 일상적인 객체가 포함되어 있습니다. 각 이미지에는 bbox, segmentation, caption, keypoint 정보가 제공됩니다.

2. 데이터셋 다운로드

COCO Data Set은 코드로 다운로드 받는 방법이 있고 홈페이지에서 다운로드 받는 방식이 있습니다. 필자는 홈페이지에서 다운로드 받았습니다. 링크를 통해 공식 웹 사이트로 이동을 합니다.

공식 웹사이트에서 Dataset 메뉴에 들어가면 데이터셋을 다운로드할 수 있습니다. 필자는 2017년도 Train, Val, Test 이미지 데이터셋과 Train/Val annotations을 다운로드 받았습니다. 학습(training) 데이터셋은 118,000장, 검증(validation) 데이터셋은 5,000장, 테스트(test) 데이터셋은 41,000장의 이미지로 구성되어 있습니다. 합쳐서 용량은 약 26GB입니다. 그렇기 때문에 용량을 충분하게 만들어 놔야하고 시간도 많이 걸립니다.

다운로드된 압축파일을 해제하면 아래와 같이 이미지가 있으며 annotation파일을 압축해제하면 json파일이 있습니다.

3. Annotation 파일

Object detation, Segmentation에 가장 많이 사용되는 Annotation 파일은 다음과 같은 구성을 가지고 있습니다. 큰 단락으로 info, License, images, annotations, categories로 나눠져 있습니다. 단락 중 annotations과 categories는 captions, instances, keypoints 파일에 따라 다르게 구성됩니다.

3.1 info, License

Annotation파일의 가장 첫 번째에는 데이터셋에 관련된 정보들이 있다. 그 다음으로는 이미지에 관련된 License url과 이름이 들어가 있다.

    "info": {
        "description": "COCO 2017 Dataset",
        "url": "http://cocodataset.org",
        "version": "1.0",
        "year": 2017,
        "contributor": "COCO Consortium",
        "date_created": "2017/09/01"
    },
    
    "licenses": [
        {
            "url": "http://creativecommons.org/licenses/by-nc-sa/2.0/",
            "id": 1,
            "name": "Attribution-NonCommercial-ShareAlike License"
        },
        {
            "url": "http://creativecommons.org/licenses/by-nc/2.0/",
            "id": 2,
            "name": "Attribution-NonCommercial License"
        },
        {
            "url": "http://creativecommons.org/licenses/by-nc-nd/2.0/",
            "id": 3,
            "name": "Attribution-NonCommercial-NoDerivs License"
        }
        ...
    ]

3.2 Images

License 다음으로는 이미지 파일에 관련된 내용이 나온다. 이 내용에는 라이센스 번호와 파일이름, 이미지 url, 이미지 크기, captured 날짜, 아이디가 들어가있다.

"images": [
        {
            "license": 4,
            "file_name": "000000397133.jpg",
            "coco_url": "http://images.cocodataset.org/val2017/000000397133.jpg",
            "height": 427,
            "width": 640,
            "date_captured": "2013-11-14 17:02:52",
            "flickr_url": "http://farm7.staticflickr.com/6116/6255196340_da26cf2c9e_z.jpg",
            "id": 397133
        },
        {
            "license": 1,
            "file_name": "000000037777.jpg",
            "coco_url": "http://images.cocodataset.org/val2017/000000037777.jpg",
            "height": 230,
            "width": 352,
            "date_captured": "2013-11-14 20:55:31",
            "flickr_url": "http://farm9.staticflickr.com/8429/7839199426_f6d48aa585_z.jpg",
            "id": 37777
        }
        ...
    ]

3.3.1 Annotations(Caption)

다음으로 annotations 내용이 나온다. annotations은 위에서 말했던것과 같이captions, instances, keypoints에 따라 다르다. 아래 annotations는 caption annotations이다. 이미지 아이디와, caption id그리고 caption 내용이 있다.

 "annotations": [
            {
                "image_id": 179765,
                "id": 38,
                "caption": "A black Honda motorcycle parked in front of a garage."
            },
        }
    ]

3.3.2 Annotations(Instances)

아래 annotations는 instances annotations이다. segmentation정보와 area, iscrowd, image_id, bbox, category_id, id가 있다.

"annotations": [
            {
                "segmentation": [
                    [
                        510.66,
                        423.01,
                        511.72,
                        420.03,
                        510.45,
                        ...
                        506.31,
                        423.32,
                        510.03,
                        423.01,
                        510.45,
                        423.01
                    ]
                ],
                "area": 702.1057499999998,
                "iscrowd": 0,
                "image_id": 289343,
                "bbox": [
                    473.07,
                    395.93,
                    38.65,
                    28.67
                ],
                "category_id": 18,
                "id": 1768
            }
        ]

3.3.3 Annotations(keypoint)

아래 annotations는 keypoint annotations이다. segmentation정보와 area, iscrowd, image_id, bbox, category_id, id가 있다.

 "annotations": [
                {
                    "segmentation": [
                        [
                            125.12,
                            539.69,
                            140.94,
                            522.43,
                            100.67,
                            496.54,
							...
                            145.26,
                            567.01,
                            117.93,
                            551.19,
                            133.75,
                            532.49
                        ]
                    ],
                    "num_keypoints": 10,
                    "area": 47803.27955,
                    "iscrowd": 0,
                    "keypoints": [
                        0,
                        0,
                        0,
                        0,
						...
                        0,
                        0,
                        162,
                        551,
                        2
                    ],
                    "image_id": 425226,
                    "bbox": [
                        73.35,
                        206.02,
                        300.58,
                        372.5
                    ],
                    "category_id": 1,
                    "id": 183126
                }
            ]

3.4.1 Categories(Instances)

다음으로 categories 내용이 나온다. categories 은 위에서 말했던것과 같이 captions, instances, keypoints에 따라 다르다. captions는 Categories가 없다. 아래 annotations는 instances categories이다. 아이디, 카테고리, 이름이 있다.

"categories": [
                {
                    "supercategory": "person",
                    "id": 1,
                    "name": "person"
                },
                {
                    "supercategory": "vehicle",
                    "id": 2,
                    "name": "bicycle"
                },
                {
                    "supercategory": "vehicle",
                    "id": 3,
                    "name": "car"
                }
                ...
            ]

3.4.2 Categories(Keypoint)

아래 categories는 keypoint categories이다. 카테고리, 아이디, 이름, keypoint 이름, Skeleton 정보가 있다.

"categories": [
                {
                    "supercategory": "person",
                    "id": 1,
                    "name": "person",
                    "keypoints": [
                        "nose",
                        "left_eye",
                        "right_eye",
                        "left_ear",
                        "right_ear",
                        "left_shoulder",
                        "right_shoulder",
                        "left_elbow",
                        "right_elbow",
                        "left_wrist",
                        "right_wrist",
                        "left_hip",
                        "right_hip",
                        "left_knee",
                        "right_knee",
                        "left_ankle",
                        "right_ankle"
                    ],
                    "skeleton": [
                        [16, 14],
                        [14, 12],
                        [17, 15],
                        ...
                        [3,5],
                        [4, 6],
                        [5, 7]
                    ]
                }
                ...
            ]

4. COCO data set lode code

아래 코드는 COCO 데이터 셋에서 이미지를 로드하고, 해당 이미지에 대한 Segmentation, bouding box, Class name을 시각화하는 코드입니다.

import cv2
import numpy as np
from pycocotools import mask as maskUtils
from torchvision.datasets import CocoDetection
import random

# 데이터셋 경로 설정
data_dir = 'D:/Coco/val2017'
Caption_file = 'D:/Coco/annotations/captions_val2017.json' #Caption
instances_file = 'D:/Coco/annotations/instances_val2017.json' #Segmentation, category_id, bbox
keypoints_file = 'D:/Coco/annotations/person_keypoints_val2017.json' #Segmentation, keypoints, id, bbox

# 데이터셋 로드
dataset = CocoDetection(root=data_dir, annFile=instances_file)
coco = dataset.coco

# 색상 목록
colors = []
for _ in range(50):
    color = [random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)]
    colors.append(color)

# 이미지와 인스턴스 정보 가져오기
for i in range(len(dataset)):
    image, target = dataset[i]

    # 이미지 시각화
    image = np.array(image)
    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)

    # 인스턴스 정보 가져오기
    for obj in target:
        segmentation = obj["segmentation"]
        bbox = obj["bbox"]
        category_id = obj["category_id"]

        color = colors[category_id % len(colors)]
        color_bgr = color[::-1]  # Convert RGB to BGR

        # 바운딩 박스 시각화
        bbox = [int(coord) for coord in bbox]
        cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[0] + bbox[2], bbox[1] + bbox[3]), color_bgr, 2)

        #segmentation이 유효한지 확인
        if isinstance(segmentation, list):
            h, w = image.shape[:2]

            mask = np.zeros((h, w), dtype=np.uint8)
            for seg in segmentation:
                poly = np.array(seg).reshape((-1, 2)).astype(np.int32)
                cv2.fillPoly(mask, [poly], 255) # color is not specified here

            mask_color = np.stack([mask]*3, axis=-1)
            for i in range(3):
                mask_color[..., i][mask_color[..., i] == 255] = color[i]  # Use RGB color for mask

            alpha = ((mask_color > 0).max(axis=2) * 128).astype(np.uint8)
            rgba_mask = np.concatenate([mask_color, alpha[:, :, np.newaxis]], axis=2)

            image_rgba = cv2.cvtColor(image, cv2.COLOR_BGR2RGBA)
            image_rgba = cv2.addWeighted(image_rgba, 1, rgba_mask, 0.5, 0)

            image = cv2.cvtColor(image_rgba, cv2.COLOR_RGBA2BGR)

        # 클래스 이름 가져오기
        cat_id = coco.getCatIds(catIds=[category_id])
        cat_name = coco.loadCats(cat_id)[0]['name']

        # 클래스 이름 시각화
        cv2.putText(image, cat_name, (bbox[0], bbox[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color_bgr, 2)



    # 이미지 출력
    cv2.imshow('Image', image)
    if cv2.waitKey(0) == ord('q'):
        break

cv2.destroyAllWindows()

Azure Kinect를 이용한 실감형 콘텐츠 개발 외주 후기

gogo5911 — Mon, 29 May 2023 23:13:54 +0900

1. 프로젝트 요청 사항

약 4평 정도의 전시 공간에 사람이 들어오면 사람을 인식하고, 사람의 아바타를 벽면에 프로젝션 하고, 특정한 행위를 하면 이벤트가 발생되는 형태의 시스템

해결 문제 : 사람 인식, 사람의 위치와 벽면에 투영된 아바타와의 위치 매핑, 특정한 행위 추정과 이벤트 발생

2. 사용 하드웨어 및 소프트웨어

유니티, Azure Kinect / 카메라 설치와 프로젝션 설치는 하드웨어 팀 진행함

3. 후기

Azure kinect를 유니티에서 사용할 때 에셋을 구매해서 사용하면 편리하게 기능들을 구현할 수 있음, 에셋은 2개가 있는데 왼쪽에 있는 에셋이 기능이 더 많음, 코드 공부를 해도 왼쪽이 더 공부할게 많음, 처음부터 구현하기보다 그냥 돈 주고 사는 게 편함

Azure Kinect의 경우 지원하는 각도로 설치를 해야 사람을 잘 인식한다. Segmentation과 Pose Estimation을 하는데 학습 데이터가 대부분 지원하는 각도로 학습된 데이터 인 듯하다. 그러나 필자의 카메라 설치는 45도로 설치되어 잘 잡히지 않았다. 특히 발 쪽을 잘 잡지 못했다. 거기에 카메라가 설치된 높이 또한 높았다. 그래서 더 사람을 인식하기 힘들었다. 그래서 Azure kinect에서 지원하는 해상도 중 해상도를 낮게 하지만 인식 범위가 긴 설정을 하여 문제를 조금 해결했다.

키넥트가 사람의 앞을 인식하건 뒤를 인식하건 큰차이가 없다. 앞이 더 인식을 잘하지만 뒤에 있다고 해서 인식을 못하는 건 아니다. 범위가 가장 중요한듯하다. 또한 키넥트의 경우 빛의 반사로 depth를 측정하기 때문에 빛을 잘 흡수하는 재질의 옷을 입은 경우 잘 인식하지 못할 수 있다.

특정한 행위 추정의 경우는 어려운 행동들이 아니기 때문에 각 관절의 각도를 이용해서 추정함. 어려웠으면 딥러닝을 통해 학습하고 추정하려 했으나 다행히 어려운 행동이 아니었음,아바타를 벽면에 프로젝션 맵핑 하는 경우 좌우 맵핑은 쉽게 했으나, 사용자가 앞 뒤로 움직이는 경우 맵핑이 어려웠음, 사람이 뒤로 움직이면 그에 따라 아바타가 작아지고, 벽면에 공중 부양하는 것과 같은 형태로 나타나기에 일정 크기를 유지하며, 바닥면에 붙은 아바타가 생성하도록 하는 부분을 해결하기 위해 키넥트의 하드웨어 각도에따라 유니티 공간의 아바타를 비추는 카메라의 각도를 변경해 줬고, 유니티의 원근 카메라를 원근이 없는 카메라로 변경하여 문제를 해결함

4. 추후 Azure kinect를 사용하는 경우 고려할 점

Azure Kinect를 사용하려는 경우 무조건 공간적 여유를 가지고, 잘 잡히는 위치에 먼저 설치 후 시스템을 그곳에 맞춰서 구현할 것, Azure kinect를 사용하는 것보다 직접 공간에서 찍은 사진으로 딥러닝 네트워크를 학습한 후 onnx 확장자로 뽑은후 유니티에서 사용하는 것이 더 좋을 듯함. 매번 Azure kinect의 딥러닝 네트워크를 보완해서 마이크로소프트 공식문서에 제공해 주나 성능이 그렇게 좋지는 않음

[Unity 입문 강좌] 유니티 게임 엔진의 원리

gogo5911 — Thu, 25 May 2023 13:35:14 +0900

1. Unity 게임 엔진

유니티 게임 엔진은 기본적으로 컴포넌트 기반 객체지향 디자인 원칙을 따르며, 그래픽스 렌더링, 물리 엔진, 사운드 처리 등 다양한 기능을 기본으로 제공합니다. 이러한 기능들은 모두 컴포넌트의 형태로 구성되며, 각각의 게임 오브젝트에 붙여 사용할 수 있습니다. (컴포넌트란 게임 오브젝트의 기능과 속성을 구현하는 기본 단위입니다.) 쉽게 말하면 게임을 조립해서 만드는 컨셉이라고 할 수 있습니다.

아래 그림은 유니티 에디터 모습이며, Cube라는 게임 오브젝트가 Scene에 배치된 모습입니다. 여기서 Cube라는 오브젝트는 Transform, Mesh Renderer, Box Collider 등과 같은 컴포넌트를 가지고 있습니다.

1.1 컴포넌트 방식

컴포넌트 방식은 게임 오브젝트에 컴포넌트를 추가해 기능을 구현하는 방식입니다. 유니티에서 제공하는 게임 오브젝트는 기본적인 컴포넌트들이 부착되어있습니다. 아래 Cube 게임 오브젝트도 여러개의 컴포넌트(Transform, Cube(Mesh Filter), Mesh Renderer ...)가 기본적으로 부착된 것을 확인할 수 있습니다. 사용자가 코드를 작성하여 컴포넌트를 추가할 수도 있습니다. 게임 오브젝트에 어떤 컴포넌트를 추가하느냐에 오브젝트의 기능이 달라집니다.

1.2 컴포넌트 방식의 활용과 장점

컴포넌트 방식은 복잡한 시스템을 구성하는 기본 단위를 작은 조각으로 분리하고 이들을 조합하여 원하는 기능을 얻는 방법입니다. 이를 유니티 게임 엔진에 적용하면, 게임 오브젝트는 여러 컴포넌트들로 이루어져 있고, 각 컴포넌트는 게임 오브젝트가 수행하는 특정 기능을 담당합니다. 또한 이러한 컴포넌트들을 프리팹으로 저장하여 재사용하면, 비슷한 특성을 가진 다양한 캐릭터와 몬스터를 쉽게 구현할 수 있습니다. (프리팹이란 다양한 컴포넌트를 가지고 있는 게임 오브젝트를 재활용하기 쉽게 만든 템플릿이라고 생각하면 됩니다.)

예를 들어 아래 이미지와 같은 '스페이스 쉽'이라는 게임에서 비행기 오브젝트를 만든다고 가정해 보겠습니다. (스페이스 쉽 게임은 비행기를 조종해서 적을 쓰러트리는 게임입니다. ) 비행기가 움직이고, 레이저를 발사하고, 충돌할 때 소멸하는 기능이 필요하다면, 이 각각의 기능을 컴포넌트로 분리할 수 있습니다.

움직임 컴포넌트: 스페이스 쉽의 위치를 제어합니다. 사용자의 입력을 받아 스페이스 쉽이 움직이는 기능을 수행합니다.
레이저 발사 컴포넌트: 사용자가 레이저 발사 버튼을 누르면 이 컴포넌트가 레이저 게임 오브젝트를 생성하고 발사하는 기능을 담당합니다.
충돌 및 소멸 컴포넌트: 스페이스 쉽이 다른 게임 오브젝트와 충돌하면 이 컴포넌트가 스페이스 쉽의 소멸을 처리합니다.

이 처럼 게임 오브젝트는 여러 개의 컴포넌트로 분리되며, 각 컴포넌트는 특정 기능을 수행하고 독립적으로 작동합니다. 이 방식은 코드의 재사용성을 높여줍니다. 또한 각 컴포넌트는 독립적이기 때문에 개발과 디버깅이 용이하며, 게임의 복잡성을 관리하는 데 도움이 됩니다.

만약 새로운 기능이 필요하면 새로운 컴포넌트를 만들어 추가할 수 있습니다. 또한, 기존 컴포넌트를 업데이트하거나 변경하는 것이 쉽습니다. 예를 들어, 스페이스 쉽이 대신 미사일을 발사하도록 변경하려면 '레이저 발사 컴포넌트'를 '미사일 발사 컴포넌트'로 교체하면 됩니다. 이처럼 컴포넌트 방식을 사용하면 기존의 게임 오브젝트 구조를 크게 변경하지 않고도 새로운 기능을 추가하거나 기존 기능을 변경하는 것이 용이합니다.

마지막으로, 컴포넌트 방식은 팀 작업을 용이하게 합니다. 각 팀원은 특정 컴포넌트에 집중하여 작업할 수 있으며, 각자의 컴포넌트를 게임 오브젝트에 추가하거나 수정하면 됩니다. 이는 작업의 분업화를 가능하게 하고, 팀원 간의 협업을 쉽게 만듭니다.

2.1 이벤트 시스템

1.1 컴포넌트 방식에서 컴포넌트를 이용해 게임 오브젝트의 기능을 구현해 게임을 만든다고 했습니다. 그러나 단순히 컴포넌트를 가진 오브젝트들만으로 각 객체간의 상호작용이나 사용자 입력에 반응하는 등의 동적인 부분을 처리하기는 어렵습니다. 이를 위해 유니티의 이벤트 시스템을 사용해야 합니다.

이벤트 시스템은 특정 이벤트를 '구독'하는 컴포넌트가 있고, 이 이벤트가 발생할 때 이에 반응하는 코드를 실행합니다. 이렇게 하면, 여러 컴포넌트 사이에서 정보를 교환하고 작용하는데 유용합니다. 이벤트 시스템은 컴포넌트들 뿐만 아니라 키보드와 마우스 입력, 오브젝트 충돌과 같은 상황에서도 사용됩니다.

예를 들어, 플레이어가 적을 공격했을 때, 이 이벤트를 '적의 체력' 컴포넌트가 구독하고 있을 수 있습니다. 이 이벤트가 발생하면, '적의 체력' 컴포넌트는 이에 반응하여 체력을 감소시키는 코드를 실행합니다. 또 다른 예로는 플레이어가 아이템을 획득했을 때를 들 수 있습니다. 이 이벤트를 '인벤토리' 컴포넌트가 구독하고 있으면, 아이템 획득 이벤트가 발생하면 '인벤토리' 컴포넌트는 이에 반응하여 인벤토리에 아이템을 추가하는 코드를 실행합니다.

3.1 라이프 사이클

2.1 이벤트 시스템에서 컴포넌트들과의 상호작용 그리고 사용자 입력에 대한 반응들을 유니티에서 할 수 있다고 했습니다. 이러한 상호작용과 반응은 순차적이고 구조화된 방식으로 이루어져야 합니다. 게임 개발에서는 각 컴포넌트나 게임 오브젝트가 특정 시점에 어떤 행동을 해야하는지를 제어해야 합니다. 이를 가능하게 하는 것이 바로 유니티의 라이프 사이클입니다. 라이프 사이클은 아래 이미지 처럼 게임 오브젝트의 생성부터 파괴까지 일련의 과정을 통제하는 일련의 메서드로 구성됩니다. 라이프 사이클에 대한 자세한 내용은 다음글에서 설명하도록 하겠습니다.

[Unity] Unity에 Sqlite 연동하기(DB 읽기, DB 쓰기, DB 테이블 만들기)

gogo5911 — Mon, 22 May 2023 21:17:34 +0900

유니티에서 DB를 이용하는 방법은 많습니다. 대표적으로 PlayerPrefs, JsonUtility, SQLite 등 이 있습니다. 그러나 Sqlite는 경량화, 빠른 처리 속도, 안정성 등의 장점으로 많이 사용됩니다. 오늘은 유니티에 Sqlite를 연동하고 사용하는 방법에 대해 알아보도록 하겠습니다.

1. Sqlite 관련 파일 다운로드 및 가져오기

Unity에 Sqlite를 연동하기 위해서는 Sqlite.dll파일을 다운받고 유니티 파일에서 Mono.Data.Sqlite.dll을 가져와야 합니다. 먼저 Sqlite.dll 파일은 링크를 통해서 다운받을 수 있습니다. 링크로 들어가면 SqLite 다운로드 페이지로 들어가집니다. 다운로드 페이지에서 Precompiled Binaries for windows에서 Sqlite-dll-win64-x64-3410200.zip을 다운로드합니다. version은 다운로드하는 시기에 따라 변하기 때문에 이미지와 달라도 걱정할 필요 없습니다.

다운로드를 받고 압축을 풀어주시면 됩니다. 압축을 풀면 sqlite.dll파일과 sqlite3.def 파일을 확인할 수 있습니다. 이 파일은 Mono.Data.Sqlite.dll과 한 번에 유니티 Assets으로 옮길 것이니 일단 압축만 해제해 주시면 됩니다.

다음으로 Mono.Data.Sqlite.dll을 가져와야 합니다. 여러 블로그 혹은 홈페이지에 공유된 dll파일이 있을 수 있으나 Unity 버전이 맞지 않으면 오류가 뜨기 때문에 직접 가져와 주는것이 좋습니다. Mono.Data.Sqlite.dll은 아래와 같은 경로에 있습니다.

C:\Program Files\Unity\Hub\Editor\2021.3.16f1\Editor\Data\MonoBleedingEdge\lib\mono\4.5

경로가 찾기 어렵다면 유니티 Hub에서 설치 메뉴로 들어간 후 설치된 유니티 오른쪽에 톱니바퀴 아이콘을 눌러 탐색기에 표시를 눌러주시면 C:\Program Files\Unity\Hub\Editor\2021.3.16f1\Editor\까지 자동으로 들어가집니다.

여기서 2021.3.16f1은 필자의 유니티 버전입니다. 여러분들의 버전은 다를 수 있기 때문에 사용하는 버전의 폴더에 들어가주시면됩니다. 이제 여기서 Mono.Data.Sqlite.dll을 찾아서 복사를 해줍니다.

이제 관련 파일은 전부 다운로드 받았습니다. 만약 PC 버전에서 sqlite를 사용하실 거라면 현재 파일들만 다운로드하면 됩니다. 그러나 안드로이드에서 sqlite를 사용할 예정이라면 안드로이드 관련 파일도 다운로드 받아야 합니다. 안드로이드 관련 파일은 아래와 같습니다. 안드로이드 관련 파일은 링크에서 다운로드 받았습니다. (필자는 Sqlite 작동을 PC버전에서만 테스트해봤습니다.)

Android.zip

0.56MB

이제 다운로드한 파일을 유니티에 넣어줘야 합니다. 먼저 유니티에 Plugins라는 폴더를 하나 만들어주고 Plugins 안에 sqlite.dll파일, sqlite3.def 파일, Mono.Data.Sqlite.dll을 넣어 줍니다.

안드로이드에서도 사용하실 거라면 Android 폴더를 Plugins 폴더 안에 만들어주시고 그 안에 위에서 다운로드한 libs파일을 Android 폴더에 넣어주시면 됩니다.

2. 데이터베이스(DB) 만들기

데이터베이스 테이블을 만드는 방법은 매우 다양합니다. 그러나 필자는 엑셀을 이용해 테이블을 만들어 사용하는 방법을 이용하겠습니다. 먼저 아래 그림처럼 엑셀을 이용해 필요한 데이터를 만들어 줍니다. 필자는 번호, 이름, 나이, 성별 데이터를 만들었습니다.

데이터를 모두 만들었다면 엑셀을 저장합니다. 이때 '다른 이름으로 저장'을 이용해 파일 형식을 CSV로 만들어줘야 합니다.

CSV 파일은 쉼표로 구분된 값(Comma Separated Values) 파일의 약자입니다. 이 파일 형식은 아래 그림과 같이 일반적으로 텍스트 파일로 작성되며, 각 줄은 쉼표 또는 세미콜론으로 구분된 값들의 집합으로 이루어져 있습니다.

CSV 파일을 만들었다면 이제 CSV파일을 db파일로 만들어야 합니다. db 파일을 만드는 방법은 여러 종류가 있지만 필자는 DB Browser for SQLite를 이용해서 만들도록 하겠습니다. DB Browser for SQLite는 링크를 통해 다운로드할 수 있습니다. 링크에 접속한 후 Download 페이지에 들어가 컴퓨터 환경에 맞게 파일을 다운로드 받아줍니다. 필자는 no installer인 zip파일을 다운로드하였습니다.

DB Browser for SQLite는 SQLite 데이터베이스를 관리하기 위한 오픈소스 도구입니다. 이 도구는 SQLite 데이터베이스를 만들고 수정할 수 있는 그래픽 사용자 인터페이스(GUI)를 제공합니다. 이 도구를 사용하면 SQLite 데이터베이스를 쉽게 관리할 수 있으며, 데이터베이스에 저장된 정보를 쉽게 검색하고 수정할 수 있습니다.

다운로드한 Zip 파일을 압축해제 해줍니다. 그러면 아래 그림과 같이 폴더하나가 생기고 폴더 안에 DB browser for SQLite.exe가 있는 것을 확인할 수 있습니다. 이 실행파일을 실행해 줍니다.

만약 아무 이상이 없다면 아래 그림과 같이 정상적으로 시스템이 실행됩니다. 시스템이 실행되면 왼쪽 상단에 새 데이터베이스 버튼을 클릭합니다.

데이터 베이스를 저장하고 싶은 경로를 선택하고 파일 이름을 설정한 후 저장합니다.

저장을 하면 아래 그림과 같이 테이블 정의 변경 창이 자동으로 뜨게 됩니다. 우리는 엑셀로 만든 데이터를 가지고 와 테이블을 만들 것이기 때문에 닫기 버튼을 눌러줍니다.

그리고 왼쪽 상단 '파일 > 가져오기 > CSV파일에서 테이블 가져오기'를 선택합니다.

파일을 가져오면 아래와 같이 한글 데이터가 깨지는 것을 확인할 수 있습니다. (엑셀을 저장할 때 인코딩이 UTF-8로 저장됐다면 깨지는 현상이 발생하지 않습니다.)

한글 깨짐 현상을 방지하기 위해서는 다음과 같은 절차가 필요합니다. 먼저 저장한 엑셀파일에서 마우스 오른쪽 버튼을 클릭한 후 '연결프로그램 > 메모장'을 선택하여 메모장으로 파일을 열어줍니다.

그리고 메모장에서 ctrl + Shift + S를 눌러 다른 이름으로 저장을 해줍니다. 이때 확장자, 이름을 변경할 필요 없이 ANSI로 인코딩 된 것을 UTF-8로만 변경해 주시면 됩니다.

변경전 인코딩이 ANSI로 설정됨

변경후 인코딩이 UTF-8로 설정됨

UTF-8로 저장을 한 후 DB browser for SQLite에서 csv를 불러오면 정상적으로 한글 폰트가 보이는 것을 확인할 수 있습니다. 불러온 csv를 테이블로 만들기 전에 '첫 행에 필드명 포함', '필드 앞뒤 공백 제거' 부분을 꼭 체크하고 확인을 눌러주세요.

완료가 되면 만든 저장한 엑셀이름으로 테이블이 만들어지는 것을 확인할 수 있습니다. 확인이 끝났다면 ctrl + s를 눌러 저장을 하고DB browser for SQLite를 종료해 줍니다.

DB browser for SQLite와 CSV를 이용해 만든 db파일을 유니티 Assets > StreamingAssets 폴더에 넣어줍니다. StreamingAssets 폴더는 처음에 존재하지 않기 때문에 사용자가 직접 만들어 줘야 합니다.

3. 유니티에서 데이터베이스(DB) 사용하기

유니티에서 스크립트를 하나 만들어줍니다.(스크립트를 생성하는 방법은 따로 설명하지 않겠습니다.) 유니티에서 SQLite를 사용하려면 Mono.Data.Sqlite 네임스페이스를 사용해야 합니다. 그렇기 때문에 스크립트 상단에 using Mono.Data.Sqlite를 추가해 줍니다.

아래는 SQLite 데이터베이스 불러오는 기본 코드입니다. 먼저 StreamingAssets에 저장한 db이름을 dbname에 넣어줍니다. 필자는 testdb로 이름을 정했기 때문에 testdb.db를 넣어줬습니다. 그리고 Application.streamingAssetsPath이용해 데이터베이스 파일의 경로를 만들어 connectionString에 할당해 줍니다. (Application.streamingAssetsPath는 Unity에서 제공하는 Application 클래스의 속성 중 하나로, 스트리밍 에셋 폴더의 경로를 나타냅니다.) 그리고 IDbConnection 인터페이스를 사용해 데이터베이스에 연결합니다.

using UnityEngine;
using System.Data;
using Mono.Data.Sqlite;


public class Test : MonoBehaviour
{

    private void Start()
    {
        string dbname = "/testdb.db";
        string connectionString = "URI=file:" + Application.streamingAssetsPath + dbname;
        IDbConnection dbConnection = new SqliteConnection(connectionString);
        dbConnection.Open();
    }

}

3.1 데이터 베이스 읽기

아래 코드는 데이터베이스 파일에서 데이터를 읽는 예시 코드입니다. 코드에서는 IDbCommand 인터페이스를 사용해 데이터베이스에서 데이터를 쿼리 합니다. 그리고 데이터 리더(IdataReader)를 사용하여 쿼리 결과를 읽습니다. 코드에서는 MyTable이라는 테이블에서 모든 레코드를 가져와 이름(name)과 나이(age)를 출력합니다. (우리가 만든 테이블 이름을 적용해 주면 됩니다.) 데이터 읽기가 끝났다면 데이터베이스 연결을 종료합니다.

dbcommand.CommandText에 어떤 쿼리문을 입력하느냐에 따라 특정 데이터를 불러올 수도 있고, 모든 데이터를 불러올 수도 있습니다. 이 예제는 쿼리문에 관련된 내용을 알려드리는 글이 아니기에 쿼리문에 대한 부분을 생략하겠습니다.

using UnityEngine;
using System.Data;
using Mono.Data.Sqlite;


public class Test : MonoBehaviour
{

    private void Start()
    {
        string dbname = "/tttt.db";
        string connectionString = "URI=file:" + Application.streamingAssetsPath + dbname;
        IDbConnection dbConnection = new SqliteConnection(connectionString);
        dbConnection.Open();

        string tablename = "Test";

        IDbCommand dbCommand = dbConnection.CreateCommand();
        dbCommand.CommandText = "SELECT * FROM " + tablename;
        IDataReader dataReader = dbCommand.ExecuteReader();

        while (dataReader.Read())
        {
            string name = dataReader.GetString(1);
            int age = dataReader.GetInt32(2);
            Debug.Log("Name: " + name + ", Age: " + age);
        }

        dataReader.Close();

    }

}

3.2 데이터 베이스 쓰기

데이터를 추가하기 위해서는 우선 데이터베이스에 연결하고, INSERT 문을 사용하여 새로운 레코드를 추가해야 합니다. 먼저 데이터베이스에 연결합니다. 그리고 INSERT 문을 사용하여 데이터를 추가합니다. 코드에서는 새로운 레코드를 추가하기 위해 INSERT INTO 문을 사용했습니다. 이때, VALUES 절에는 새로 추가할 레코드의 값을 지정합니다. 코드에서는 문자열 타입의 name과 숫자 타입의 age를 추가하고 있습니다.

using UnityEngine;
using System.Data;
using Mono.Data.Sqlite;


public class Test : MonoBehaviour
{

    private void Start()
    {
        string dbname = "/tttt.db";
        string connectionString = "URI=file:" + Application.streamingAssetsPath + dbname;
        IDbConnection dbConnection = new SqliteConnection(connectionString);
        dbConnection.Open();


        int no = 1;
        string name = "아무개";
        int age = 30;
        string sex = "남자";
        string insertQuery = $"INSERT INTO Test (No, 이름, 나이, 성별) VALUES ({no}, '{name}', {age}, '{sex}')";

        IDbCommand dbCommand = dbConnection.CreateCommand();
        dbCommand.CommandText = insertQuery;
        dbCommand.ExecuteNonQuery();
        dbCommand.Dispose();
        dbConnection.Close();

        print("끝");
    }

}

아래 그림은 코드를 통해 설정한 번호, 이름, 나이, 성별을 데이터베이스에 추가한 것을 보여줍니다. 유니티 UI를 응용하면 값을 입력받고 데이터를 데이터베이스에 쓸 수 있게 됩니다.

3.3 새로운 테이블 만들기

아래 코드는 CREATE TABLE 문을 사용하여 새로운 테이블을 만듭니다. 이때, IF NOT EXISTS 절을 사용하면 테이블이 이미 존재하는 경우에도 오류가 발생하지 않습니다. 쿼리문을 이용해 No, Name, Job, Address와 같이 열의 이름과 데이터 타입을 정의합니다. 그리고 PRIMARY KEY와 AUTOINCREMENT 키워드를 No 열에 적용해 줍니다. Ket는 꼭 적용해 줄 필요는 없습니다.

using UnityEngine;
using System.Data;
using Mono.Data.Sqlite;


public class Test : MonoBehaviour
{

    private void Start()
    {
        string dbname = "/tttt.db";
        string connectionString = "URI=file:" + Application.streamingAssetsPath + dbname;
        IDbConnection dbConnection = new SqliteConnection(connectionString);
        dbConnection.Open();


        string createTableQuery = @"CREATE TABLE IF NOT EXISTS NewTable (
                                No INTEGER PRIMARY KEY AUTOINCREMENT,
                                Name TEXT NOT NULL,
                                Job TEXT NOT NULL,
                                Address TEXT NOT NULL)";

        IDbCommand dbCommand = dbConnection.CreateCommand();
        dbCommand.CommandText = createTableQuery;
        dbCommand.ExecuteNonQuery();

        dbConnection.Close();

        print("끝");
    }

}

아래 그림은 코드를 통해 데이터베이스에 추가한 테이블을 보여줍니다. 설정한 것과 같이 No, Name, Job, Address가 열이 있는 것을 확인할 수 있습니다.

[Unity 오류해결] Unity Opencv unsafe code 해결방법

gogo5911 — Tue, 16 May 2023 11:46:45 +0900

Unity에서 Opencv를 사용하는 방법 중 하나는 Unity Asset Store에서 판매하는 OpenCV for Unity, 혹은 OpenCV Plus Unity를 사용하는 것이다. 이때 무료인 OpenCV Plus Unity를 다운받아 사용하는 경우 Unsafe code 오류가 발생한다. 유료 버전인 OpenCV for Unity의 경우는 Unsafe code 오류가 발생하지 않을 뿐아니라 간단하게 Unsafe code를 설정 및 해제 할 수 있다.

다운받은 OpenCV Plus Unity를 Import하면 아래와 같이 unsafe code 오류가 나온다. 이 오류를 해결하는 방법은 매우 간단하다.

Edit -> Project Settings -> Player-> Allow 'unsafe' Code를 체크 해제 해주면된다. 빠르게 찾고 싶다면 Project Settings의 검색창에 unsafe를 검색하면된다.

유니티 목차

gogo5911 — Mon, 17 Apr 2023 16:17:53 +0900

1. 유니티 입문 강좌

넘버	제목[링크]
1	유니티(Unity)란? [링크]
2	유니티(Unity) Window와 Mac에서 설치하기 [링크]
3	유니티(Unity) Editor 인터페이스 [링크]
4	유니티(Unity) 게임 엔진의 원리 [링크]
5	유니티(Unity) 생명주기(Life Cycle)과 이벤트 메서드 [링크]
6	유니티(Unity) 좌표계 체계의 이해와 활용 방법 [링크]
7	C# 유니티(Unity) 스크립트(Script)와 변수 [링크]
8	C# 유니티(Unity) 사칙연산과 복합연산자 [링크]
9	C# 유니티(Unity) 형변환 [링크]
10	C# 유니티(Unity) 접근자 [링크]
11	C# 유니티(Unity) 조건문 [링크]
12	C# 유니티(Unity) 반복문 [링크]
13	C# 유니티(Unity) 배열과 반복문 [링크]
14	C# 유니티(Unity) 함수 [링크]
15	C# 유니티(Unity) 클래스 [링크]
16	C# 유니티(Unity) 델리게이트 [링크]
17	C# 유니티(Unity) 코루틴과 비동기 프로그래밍 [링크]
18	C# 유니티(Unity) 오브젝트와 컴포넌트 이해 [링크]
19	C# 유니티(Unity) 에셋 관리 및 임포트 [링크]
20	C# 유니티(Unity) 스크립트 작성 기본 [링크]
21	C# 유니티(Unity) 플레이어 이동 및 제어 [링크]
22	충돌 처리와 물리 시뮬레이션
23	카메라 제어 및 시야 처리
24	인공지능 및 캐릭터 제어
25	유니티 UI 시스템
26	게임 상태 관리와 씬 전환
27	점수 및 게임 데이터 저장
28	프로파일러를 이용한 성능 분석
29	메모리 관리 및 가비지 컬렉션
30	오브젝트 풀링
31	그래픽 최적화 기법

[Python 내장 함수] open() : 파일을 읽고, 쓰기

gogo5911 — Sun, 16 Apr 2023 00:18:33 +0900

##필요 선행 지식

1. open() 함수란?

파이썬에서 제공하는 기본 내장 함수 중 하나인 open() 함수는 파일을 열고 파일 객체를 반환하는 함수입니다. 이 함수를 사용하면 파일을 읽거나 쓸 수 있습니다. 파일을 사용한 후에는 close() 메서드를 호출하여 파일을 닫아야합니다. with 구문을 이용하면 파일을 자동으로 닫을 수 있어 편리하게 사용할 수 있습니다. 파일을 열 때 인코딩을 지정하지 않으면 기본 인코딩 방식이 사용됩니다.

open() 함수의 구문은 아래와 같습니다.

file: 열고자 하는 파일의 경로와 이름을 나타냅니다.
mode: 파일을 열 때 사용할 모드를 나타냅니다. 기본값은 'r'이며, 파일을 읽기 모드로 엽니다. 다른 모드로는 'w'(쓰기), 'a'(추가), 'b'(바이너리), 't'(텍스트), '+'(읽기와 쓰기 모두 가능) 등이 있습니다. 이러한 모드는 조합하여 사용할 수 있습니다. 예를 들어, 'rb'는 바이너리 읽기 모드, 'w+'는 읽기와 쓰기 모드 등입니다.
buffering: 버퍼링 정책을 설정합니다. 기본값은 -1로 시스템 기본값이 사용됩니다.
encoding: 파일을 읽거나 쓸 때 사용할 인코딩을 설정합니다. 기본값은 None으로 시스템 기본 인코딩을 사용합니다.
errors: 인코딩 및 디코딩 오류 처리 방식을 설정합니다. 기본값은 None입니다.
newline: 개행 문자를 어떻게 처리할지 설정합니다. 기본값은 None입니다.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

2. with 구문을 이용한 파일 입출력

with 구문을 사용한 파일 입출력은 파이썬에서 권장되는 방식입니다. with 구문을 이용하면, 파일 작업이 끝났을 때 자동으로 파일을 닫아줍니다. 이렇게 하면 파일을 명시적으로 닫아주는 close() 메서드를 호출할 필요가 없고, 예외가 발생할 경우에도 파일이 제대로 닫히는 것이 보장됩니다.

아래 코드는 with 구문을 사용하지 않은 경우입니다. 코드에서는 open() 함수를 사용하여 파일을 열고, 작업을 수행한 후 close() 메서드를 호출하여 파일을 닫습니다. 이 경우, 예외가 발생하면 close() 메서드가 호출되지 않을 수 있습니다. 이로 인해 열린 파일이 남아있어 시스템 자원의 낭비가 발생할 수 있습니다.

file = open('example.txt', 'r', encoding='utf-8')
content = file.read()
print(content)
file.close()

아래 코드는 with 구문을 사용한 경우입니다.

with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    print(content)

3. open() 함수의 파일 열기 모드

파일 열기 모드는 open() 함수의 mode 매개변수를 통해 설정할 수 있으며, 이를 통해 파일을 읽고, 쓰고, 추가하는 등 다양한 목적으로 열 수 있습니다. 모드 문자는 조합하여 사용할 수 있습니다. 주요 파일 열기 모드는 다음과 같습니다.

'r' (읽기 모드): 파일을 읽기 위한 모드로, 기본값입니다. 파일을 열 때 해당 파일이 존재하지 않으면 오류가 발생합니다.
'w' (쓰기 모드): 파일을 쓰기 위한 모드입니다. 파일이 이미 존재하면 기존 내용을 삭제하고 새로 쓰기 시작합니다. 파일이 없으면 새 파일을 생성합니다.
'a' (추가 모드): 파일의 끝에 내용을 추가하기 위한 모드입니다. 파일이 없으면 새 파일을 생성합니다.
'x' (배타적 생성 모드): 새 파일을 생성하기 위한 모드입니다. 이미 파일이 존재할 경우 오류가 발생합니다.
'b' (바이너리 모드): 파일을 바이너리 형식으로 엽니다. 텍스트 파일 이외의 파일(이미지, 동영상 등)을 처리할 때 사용됩니다.
't' (텍스트 모드): 파일을 텍스트 형식으로 엽니다. 기본값입니다.
'+' (읽기와 쓰기 모드): 파일을 읽기와 쓰기를 동시에 수행할 수 있는 모드로 설정합니다. 이는 'r', 'w', 'a'와 같은 다른 모드와 함께 사용할 수 있습니다.

아래 코드는 읽기 모드, 쓰기 모드, 추가 모드, 바이너리 읽기 모드를 이용해 파일을 읽는 코드입니다.

# 읽기 모드로 파일 열기
with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()

# 쓰기 모드로 파일 열기
with open('example.txt', 'w', encoding='utf-8') as file:
    file.write('Hello, World!')

# 추가 모드로 파일 열기
with open('example.txt', 'a', encoding='utf-8') as file:
    file.write('Append this text!')

# 바이너리 읽기 모드로 파일 열기
with open('example.jpg', 'rb') as file:
    content = file.read()

4. 연습문제

다음은 파일에서 데이터를 읽어와서 조건에 맞는 부분만 출력해주는 예제입니다. 이 예제에서는 텍스트 파일에서 나이를 기록한 데이터를 읽고, 나이가 30 이상인 사람들의 데이터만 출력하는 작업을 수행합니다.

파일 (ages.txt)

김철수, 25
이영희, 32
박민수, 29
최지영, 38
홍길동, 45

예제에서는 먼저 readlines() 메서드를 사용하여 파일의 내용을 리스트로 읽어옵니다. 그 다음, age_filter 함수를 정의하여 나이가 30 이상인지 확인하는 작업을 수행합니다. 마지막으로, filter() 함수를 사용하여 조건에 맞는 부분만 출력합니다.

# 나이가 30 이상인 사람들의 데이터를 출력하는 함수
def age_filter(line):
    name, age = line.strip().split(', ')
    age = int(age)
    return age >= 30

# 파일에서 데이터를 읽어옵니다.
with open('ages.txt', 'r', encoding='utf-8') as file:
    content = file.readlines()

# 조건에 맞는 부분만 출력합니다.
filtered_content = filter(age_filter, content)
print("나이가 30 이상인 사람들:")
for line in filtered_content:
    print(line.strip())
    
    
#나이가 30 이상인 사람들:
#이영희, 32
#최지영, 38
#홍길동, 45

[Python 모듈] xml : XML 데이터를 처리하기 위한 모듈

gogo5911 — Sat, 15 Apr 2023 16:17:14 +0900

1. xml 모듈이란?

xml 모듈은 파이썬에서 XML 데이터를 처리하기 위한 모듈입니다. XML 데이터를 파싱하고, 생성하고, 수정하는 기능을 제공합니다. xml 모듈의 주요 클래스로는 ElementTree와 Element가 있습니다. ElementTree 클래스는 XML 트리를 생성하고 조작하는 클래스이며, Element 클래스는 XML 요소를 나타내는 클래스입니다.

xml모듈은 별도의 설치 과정이 필요없습니다. 모듈을 사용하려면 아래와 같이 import를 하면 됩니다.

import xml

2. Element

Element 클래스는 XML 요소(Element)를 나타내며, 요소(Element)의 이름과 속성(attribute), 하위 요소(sub-element), 텍스트(text) 등을 포함합니다. Element는 요소(Element)의 생성, 수정, 삭제 등의 작업을 수행할 수 있습니다.

2.1 find

find() 함수는 지정한 태그명과 일치하는 첫 번째 하위 요소(Element)를 찾아 반환합니다. 이 함수는 XML 요소의 구조를 파악하고 필요한 정보를 추출하는 데에 유용합니다.

예를 들어, 다음과 같은 XML 구조를 가진 문자열이 있다고 가정해봅시다.

<book>
  <title>Python Programming</title>
  <author>John Smith</author>
  <publisher>Packt Publishing</publisher>
  <year>2022</year>
</book>

이 코드는 XML 문자열을 파싱하여 ElementTree 객체를 생성하고, 이를 통해 title 요소를 찾아내는 코드입니다. 코드를 실행하면 "Python Programming"이라는 문자열이 출력됩니다. 즉, Element.find() 함수를 사용하여 title 요소를 찾아내고, 해당 요소의 text 속성을 출력하는 것입니다.

import xml.etree.ElementTree as ET

# XML 문자열
xml_str = "<book><title>Python Programming</title><author>John Smith</author><publisher>Packt Publishing</publisher><year>2022</year></book>"

# ElementTree 객체 생성
root = ET.fromstring(xml_str)

# title 요소 찾기
title_elem = root.find("title")
print(title_elem.text)

2.2 findall

findall() 함수는 지정한 태그명과 일치하는 모든 하위 요소(Element)를 찾아 리스트로 반환합니다. 이 함수는 XML 문서에서 특정 요소들을 선택해 추출하는 데에 유용합니다.

예를 들어, 다음과 같은 XML 구조를 가진 문자열이 있다고 가정해봅시다.

<fruits>
  <fruit name="apple" color="red">Sweet and juicy</fruit>
  <fruit name="banana" color="yellow">Rich in potassium</fruit>
  <fruit name="orange" color="orange">High in vitamin C</fruit>
  <fruit name="kiwi" color="brown">Rich in fiber</fruit>
</fruits>

이 코드는 XML 문자열을 파싱하여 ElementTree 객체를 생성하고, 이를 통해 모든 과일(fruit) 요소를 찾아내는 코드입니다. 즉, Element.findall() 함수를 사용하여 모든 과일 요소를 찾아내고, 각 요소의 속성과 텍스트 값을 출력하는 것입니다.

import xml.etree.ElementTree as ET

# XML 문자열
xml_str = "<fruits><fruit name=\"apple\" color=\"red\">Sweet and juicy</fruit><fruit name=\"banana\" color=\"yellow\">Rich in potassium</fruit><fruit name=\"orange\" color=\"orange\">High in vitamin C</fruit><fruit name=\"kiwi\" color=\"brown\">Rich in fiber</fruit></fruits>"

# ElementTree 객체 생성
root = ET.fromstring(xml_str)

# 과일(fruit) 요소 찾기
fruit_elems = root.findall("fruit")

# 모든 과일 요소 출력하기
for fruit_elem in fruit_elems:
    name = fruit_elem.get("name")
    color = fruit_elem.get("color")
    description = fruit_elem.text
    print(name, color, description)
    
    
#apple red Sweet and juicy
#banana yellow Rich in potassium
#orange orange High in vitamin C
#kiwi brown Rich in fiber