자기 소개 및 지원 동기를 말해주세요

" "안녕하세요, '기록으로 성장한는' 개발자, 웹 파트 지원자, 우준영입니다.

저는 군 복무 중 노베이스 상태에서 시작해, 매일 알고리즘 문제를 풀며 백준 실버 1을 달성한 끈기를 가지고 있습니다. 단순히 문제를 푸는 것에 그치지 않고, 해결 과정을 Velog에 체계적으로 기록하며 '모르는 것을 나의 것으로 만드는 학습 매커니즘'을 구축했습니다.

이제는 혼자만의 기록을 넘어, UMC에서 팀원들과 함께 실제 유저가 사용하는 서비스를 만들고 싶습니다. 끝까지 포기없이 10기 활동을 완주하겠습니다. "

핵심은 기록으로 성장하는 개발자 모르는 것을 나의 것으로 만드는 학습 매커니즘을 구축 이제는 혼자만의 기록을 넘어, UMC에서 팀원들과 함께

예상 질문5(2순위)

협업할 때 갈등이 생긴다면 어떻게 해결하실 건가요?

갈등이 생기면 감정보다는 객관적인 데이터에 집중하며, 제 개인의 의견 보다, 우리 팀 서비스의 '완성도' 라는 목표를 항상 최우선으로 두겠습니다. "저는 감정보다는 '데이터'를 믿고, 제 고집보다는 '팀의 목표'를 믿는 개발자가 되겠습니다."

예상 질문 1 (3순위)

React를 선택한 이유는 컴포넌트 기반의 구조적 설계가 주는 효율성 때문입니다. 여기서 컴포넌트 기반의 구조적 설계가 주는 효율성은 무슨 의미인가요 ?

컴포넌트 기반의 구조적 설계는 웹페이지를 하나의 통으로 만드는 것이 아니라, '독립적인 작은 단위(Component)'로 쪼개서 조립하듯 개발하는 방식입니다. 예를 들어 헤더, 버튼, 입력창 등을 각각 하나의 부품으로 만드는 것을 말합니다.

효율적인 면에서는 재사용성과 독립성, 유지보수의 용이성이 있습니다. 한번 잘 만든 컴포넌트를 재활용 한다든가, 각 기능이 컴포넌트 단위로 분리되어 있어, 코드가 섞이지 않고 깔금하며, ui에 수정사항이 생기면 해당 컴포넌트 하나만 수정하면 되는 부분입니다.

예상 질문4

가장 기억에 남는 프로젝트는 무엇인가요?

아직 규모 있는 팀 프로젝트 경험은 없지만, 저는 '백준 실버 1 달성'을 위한 자기주도적 학습 프로젝트가 가장 기억에 남습니다.

단순히 문제를 푸는 것을 넘어, 특정 알고리즘의 원리를 파악하고 이를 Velog에 체계적으로 문서화하는 과정을 하나의 프로젝트라고 생각하고 진행했습니다. 특히 복잡한 골드 수준의 문제를 만났을 때, 문제를 작은 단위로 쪼개고 논리적 오류를 수정해 나가는 과정은 프런트엔드에서 컴포넌트를 설계하고 디버깅하는 과정과 매우 닮아 있다고 느꼈습니다.

이 과정을 통해 '모르는 것을 내 것으로 만드는 메커니즘'을 익혔고, 이제는 이 개인적인 성취를 넘어 UMC에서 팀원들과 함께 실제 유저가 사용하는 서비스를 만드는 진짜 프로젝트에 도전하고 싶습니다."

예상 질문6

Umc는 한학기+방학동안 이루어지며 3학점 짜리 전공 급시간 할애가 필요한 활동이다. 자신의 스케줄에 지장이 갈수 있는데 괜찮을지?

"네, UMC 활동이 전공 수업 이상의 몰입이 필요한 과정이라는 점을 잘 알고 있으며, 이미 충분한 시간과 노력을 쏟을 준비가 되어 있습니다.

저는 어떤 가치 있는 성과를 얻기 위해서는 그에 걸맞은 '절대적인 시간'이 필요하다는 것을 경험으로 배운 사람입니다. 실제로 군 복무 중에도 매일 루틴을 지키며 백준 실버 1을 달성했고, 그 과정을 하나하나 Velog에 기록하며 스스로 학습 메커니즘을 구축해 왔습니다.

UMC는 제가 가장 원했던 React 기반의 실무 협업을 배우는 기회인 만큼, 제 최우선 순위는 UMC가 될 것입니다. 단순히 시간을 때우는 것이 아니라, 팀원들에게 피해가 가지 않도록 책임감 있게 일정을 관리하고, 기술적 난관 앞에서도 끝까지 몰입하여 결과물을 만들어내겠습니다."

예상 질문 7

마지막으로 할말(어필)

"마지막으로 제가 꼭 UMC 10기여야만 하는 이유를 말씀드리고 싶습니다.

많은 개발 동아리가 있지만, 이론에 그치지 않고 '실제 유저가 사용하는 서비스 런칭'이라는 명확한 목표를 향해 6개월간 장기적으로 몰입하는 곳은 UMC가 유일하다고 생각합니다. 저는 그동안 혼자 공부하며 Velog에 기록해온 지식들이 실제 프로젝트에서 어떻게 생명력을 얻는지 너무나 확인하고 싶습니다.

저는 이미 군 복무 중에도 매일 루틴을 지키며 백준 실버 1을 달성할 만큼, 한 번 목표한 것은 끝까지 완수하는 끈기를 증명해 왔습니다. UMC 활동을 제 최우선 순위에 두고, 제가 가진 기록의 습관을 통해 팀의 지식 자산을 체계화하는 데 기여하겠습니다.

단순히 '배우는 학생'이 아니라, 프로젝트의 마지막 순간까지 팀의 결과물을 실체화하는 '가장 든든한 프런트엔드 개발자'가 되겠습니다. 꼭 함께 활동하고 싶습니다. 감사합니다!

예상 질문2

React의 상태 관리와 훅(Hook)의 원리를 누구보다 빠르게 흡수하겠습니다. 라고 하셨는데 설명해주실 수 있으신가요?

"먼저 상태 관리는 컴포넌트 내부의 동적인 데이터를 관리하는 것입니다. 상태가 변하면 React가 UI를 자동으로 다시 그려주기 때문에, 개발자는 데이터의 변화에만 집중할 수 있어 코드의 일관성을 유지하기 좋습니다.

훅(Hook)은 이러한 상태 관리나 생명주기 기능을 함수형 컴포넌트에서 쉽게 사용할 수 있게 해주는 도구입니다. 복잡한 로직을 독립적인 함수로 분리할 수 있어 코드의 가독성을 높이고 로직의 재사용성을 극대화해 줍니다."

예상 질문 8

만일 백앤드, 프론트앤드 중에 하나만 선택한다면? (기출 질문)

"저는 망설임 없이 프런트엔드를 선택하겠습니다. 그 이유는 두 가지입니다.

첫째, 사용자의 피드백을 가장 빠르고 직접적으로 체감할 수 있는 분야이기 때문입니다. 저는 제가 만든 결과물이 유저에게 어떤 가치를 주는지 시각적으로 확인하고, 그 반응을 바탕으로 서비스를 개선해 나가는 과정에서 큰 보람을 느낍니다.

둘째, 복잡한 로직을 직관적인 화면으로 설계하는 '번역가'의 역할이 저의 성향과 잘 맞기 때문입니다. 백엔드에서 처리된 방대한 데이터를 유저가 가장 편하게 사용할 수 있도록 컴포넌트 단위로 구조화하고, 상태 관리와 훅을 이용해 역동적인 화면을 구현하는 과정이 매우 매력적입니다.

물론 백엔드와의 협업을 위해 데이터 구조에 대한 이해도 꾸준히 넓혀가겠지만, 서비스의 첫인상을 결정짓고 유저의 경험을 직접 설계하는 프런트엔드 개발자로서의 전문성을 쌓는 것이 저의 확실한 목표입니다."

어떤 개발자가 되고 싶은지?

가끔 어플리케이션을 사용하다보면 기능이 너무 복잡하거나 헷갈렸던 경험이 있습니다. 이에 저는 사용자가 쉽게 누구나 직관적으로 이해할 수 있도록 편의성을 가장 먼저 생각하는 프론트엔드 개발자가 되고 싶습니다.

궁금한 점?

사실 UMC에 붙고 싶어서 블로그나, 인스타그램, 사이트를 찾아가보면서 많은 정보를 얻었습니다. 해서 궁금한 점은 딱히 없습니다!

만들고 싶은 서비스 (개발 동아리 면접용, 회사라면 패스)

날 뽑아야 하는 이유 (& 지원 동기)

"저를 뽑아야 하는 이유는 '성장의 메커니즘을 스스로 구축한 지원자'이기 때문입니다.

저는 군 복무 중에도 매일 루틴을 지키며 백준 실버 1을 달성했습니다. 단순히 문제를 푸는 것에 그치지 않고, 그 고민의 과정을 Velog에 꼼꼼히 기록하며 모르는 것을 내 것으로 만드는 법을 익혔습니다. React는 이제 시작이지만, 이런 탄탄한 기본기와 끈기를 바탕으로 상태 관리나 훅 같은 핵심 원리를 누구보다 빠르게 흡수할 자신이 있습니다.

또한, 저는 기록을 좋아하는 만큼 팀의 지식 자산을 체계화하는 데 진심입니다. 혼자 공부할 때 느꼈던 협업과 코드 리뷰에 대한 갈증을 UMC에서 해소하고 싶습니다. 제가 가진 꼼꼼한 기록 습관을 팀 프로젝트의 문서화와 컨벤션에 녹여내어, 저 개인의 성장뿐만 아니라 우리 팀 전체의 생산성을 높이는 든든한 프런트엔드 개발자가 되겠습니다. 6개월간의 장기 활동을 최우선 순위로 두고, 서비스 런칭까지 끝까지 책임지고 완수하겠습니다."

목표 (꼭 얻어가고 싶은 것)

"저는 UMC 활동을 통해 단순히 React 기술을 익히는 것을 넘어, '팀 전체의 생산성에 기여하는 협업 메커니즘'을 경험하고 싶습니다.

그동안 혼자 공부하며 백준 실버 1을 달성하고 그 과정을 Velog에 기록해왔지만, 실제 유저가 사용하는 서비스를 만드는 과정에서의 코드 리뷰나 협업 컨벤션에 대한 갈증이 컸습니다.

이번 활동을 통해 제가 가진 꼼꼼한 기록 습관을 팀 프로젝트의 문서화에 녹여내어, 팀원들이 제 코드를 보고 의도를 바로 파악할 수 있는 '읽기 좋은 코드'를 짜는 능력을 얻고 싶습니다. 또한, 기획부터 런칭까지의 전체 사이클을 경험하며, 기술적 난관 앞에서도 끝까지 몰입하여 팀의 결과물을 실체화하는 단단한 프런트엔드 개발자로 성장하는 것이 제 가장 큰 목표입니다."

해당 직무를 선택한 이유

"제가 프론트엔드 중에서도 웹을 선택한 이유는 '가장 낮은 문턱으로 가장 많은 사용자에게 가치를 전달할 수 있는 플랫폼'이기 때문입니다.

앱처럼 설치 과정 없이 주소창에 URL 하나만 입력하면 즉시 서비스에 접속할 수 있다는 압도적인 접근성에 매력을 느꼈습니다. 저는 제가 만든 결과물을 누구나 쉽게 경험하고 피드백을 주는 과정을 즐기는데, 웹은 그런 소통의 속도가 가장 빠른 분야라고 생각합니다.

특히 React를 공부하며 웹이 단순한 문서 페이지를 넘어, 컴포넌트 기반의 구조적 설계를 통해 복잡한 애플리케이션 수준의 퍼포먼스를 낼 수 있다는 점에 확신을 얻었습니다. 제가 백준 실버 1을 달성하며 길러온 논리적 사고력을 바탕으로, 브라우저라는 환경 제약 안에서 최적의 상태 관리와 훅 활용을 통해 유저에게 끊김 없는 웹 경험을 제공하는 개발자가 되고 싶어 지원했습니다."
프런트엔드 개발은 백엔드에서 만든 것을 사용자가 이해하기 쉬운 화면으로 번역하여 전달하는 역할을 한다는 점이 매력적이라 지원하게 되었습니다. UMC에서 팀의 결과물을 실체화하는 든든한 프런트엔드 개발자가 되겠습니다!"

연결리스트는 stack queue list 노드를 사용

비선형 리스트는 tree graph

연결 리스트(단순 연결 리스트, 단순 선형 연결 리스트) LinkedList

data link(주소) [ Node ] Node의 특징 데이터를 가지고 있지 않으면 노드로써의 의미가 없다. link는 주소를 저장하는 변수이고 data에는 정수, 실수, 문자, 문자 배열 등이 들어간다.

하나의 이름에 각기 다른 데이터 타입을 묶어서 사용할 수 있는 변수가 존재 --> 구조체 c에서 자료구조를 구현하는데 사용하는 것이 구조체이다. 노드를 선언하는데 구조체가 필수

preNode CurrentNode nextNode data link data link data link 20 30 Null 현 주소 10 20 30

link에는 다음 값이 있는 주소를 보관한다.

struct listNode{ char data[4]; struct listNode * link; };

연결 할 수 있는 기준 노드를 생성 이 연결 할 수 있는 노드에는 데이터(x) 유일하게 가질 수 있는 것은 주소만이다. 이러한 노드를 자료구조에서 head node 라고 한다.

헤드 노드 정의(기준 노드가 된다) struct headNode{ listNode * headNode; };

연결리스트는 헤드 노드와 노드의 정의로부터 시작

새로운 노드를 추가하는 방법

1. 자기의 앞 노드가 될 이름이 가지고 있는 주소를 받아 온다.
2. 그리고 나서 받은 주소를 통해 연결한다.
3. 자기의 주소를 자신의 뒤 노드에게 전달
4. 자신의 주소를 가지고 있는 뒤 노드와 연결

삽입할 노드를 주닙 새 노드의 데이터 필드에 값을 저장 새 노드의 주소(링크(값을 저장 리스트의 앞 노드에 새 노드이 주소를 전달하여 연결

데이터를 삽입하는 위치에 따라 맨 처음, 중간, 맨 마지막 이렇게 삽입할 수 있다. 자료구조 구현은 1. 각각의 위치에 따라서 함수를 생성하는 방법 2. 하나의 함수로 구현하는 방법이 존재

<InsertLinkedList.h> #pragma once

typedef struct ListNode { char data[4]; struct ListNode* link; } listNode;

typedef struct { listNode* head; } linkedList_h;

linkedList_h* createLinkedList_h(void); void freeLinkedList_h(linkedList_h* L); void printList(linkedList_h* L); void insertFirstNode(linkedList_h* L, char* x); void insertMiddleNode(linkedList_h* L, listNode* pre, char* x); void insertLastNode(linkedList_h* L, char* x);

<InsertLinkedList.c> #define _CRT_SECURE_NO_WARNINGS //경고가 일어나느 부분을 사용자에게 알리지 않고 그냥 실행

#include <string.h> #include <stdlib.h> #include "InsertLinkedList.h"

//메모리 할당 및 해제 함수, 출력 함수, 삽입 함수 구현 linkedList_h* createLinkedList_h(void) { linkedList_h* L; L = (linkedList_h*)malloc(sizeof(linkedList_h)); L->head = NULL; return L; }

//메모리 해제 함수 void freeLinkedList_h(linkedList_h* L) { listNode* p; while (L->head != NULL) { p = L->head; L->head = L->head->link; free(p); p = NULL; } }

//출력 함수 void printList(linkedList_h* L) { listNode* p; printf("L = ("); p = L->head; while (p != NULL) { printf("%s", p->data); p = p->link; if (p != NULL) printf(", "); } printf(") \n"); }

//삽입 함수 void insertFirstNode(linkedList_h* L, char* x) { listNode* newNode; newNode = (listNode*)malloc(sizeof(listNode)); strcpy(newNode->data, x); newNode->link = L->head; L->head = newNode; }

//pre 노드 뒤에 삽입 void insertMiddleNode(linkedList_h* L, listNode* pre, char* x) { listNode* newNode; newNode = (listNode*)malloc(sizeof(listNode)); strcpy(newNode->data, x); if (L->head == NULL) { newNode->link = NULL; L->head = newNode; } else if (pre == NULL) { newNode->link = L->head; L->head = newNode; } else { newNode->link = pre->link; pre->link = newNode; } }

//마지막에 삽입 void insertLastNode(linkedList_h* L, char* x) { listNode* newNode; listNode* temp; newNode = (listNode*)malloc(sizeof(listNode)); strcpy(newNode->data, x); newNode->link = NULL; if (L->head == NULL) { L->head = newNode; return; } temp = L->head; while (temp->link != NULL) temp = temp->link; temp->link = newNode; }

<sampleLink.c> #include <stdio.h> #include "InsertLinkedList.h"

int main(void) { linkedList_h* L; L = createLinkedList_h(); printf("(1) 공백 리스트 생성하기! \n"); printList(L);

printf("\n(2) 리스트에 [수] 노드 삽입하기! \n");
insertFirstNode(L, "수");
printList(L);

printf("\n(3) 리스트 마지막에 [금] 노드 삽입하기! \n");
insertLastNode(L, "금");
printList(L);

printf("\n(4) 리스트 첫 번째에 [월] 노드 삽입하기! \n");
insertFirstNode(L, "월");
printList(L);

printf("\n(5) 리스트 공간을 해제하여 공백 리스트로 만들기! \n");
freeLinkedList_h(L);
printList(L);

return 0;

}

1. 리스트의 분류

자료구조는 크게 선형과 비선형으로 나뉩니다.

선형 리스트 (Linear List)

• Stack
• Queue
• List

연결 리스트 (Linked List)

• Stack, Queue, List 등을 '노드(Node)'를 사용하여 구현
• 단순 연결 리스트, 단순 선형 연결 리스트 등이 있음

비선형 리스트 (Non-Linear List)

• Tree
• Graph

2. 연결 리스트의 구조와 노드(Node)

연결 리스트는 데이터와 주소(Link)를 담은 노드들의 연결로 이루어집니다.

노드(Node)의 특징

• [ data | link ] 구조로 되어 있음
• data: 실제 저장할 값 (정수, 실수, 문자열 등)
• link: 다음 노드의 주소를 저장하는 포인터 변수
• 데이터를 가지고 있지 않으면 노드로서의 의미가 없음

C언어에서의 구현

• 서로 다른 데이터 타입을 묶어야 하므로 구조체(struct) 사용이 필수적입니다.

    struct listNode {
        char data[4];
        struct listNode* link;
    };

헤드 노드(Head Node)

• 리스트의 시작 위치를 알려주는 기준 노드입니다.
• 데이터는 저장하지 않고, 첫 번째 노드의 주소만 보관합니다.

    typedef struct {
        listNode* head;
    } linkedList_h;

3. 새로운 노드 삽입 프로세스

1. 삽입할 노드를 준비하고 데이터 필드에 값을 저장합니다.
2. 이전 노드(pre)가 가리키던 주소를 새 노드의 링크에 저장합니다.
3. 이전 노드의 링크가 새 노드를 가리키도록 업데이트합니다.

4. C언어 구현 코드

(1) 헤더 파일: InsertLinkedList.h

    #pragma once

    typedef struct ListNode {
        char data[4];
        struct ListNode* link;
    } listNode;

    typedef struct {
        listNode* head;
    } linkedList_h;

    linkedList_h* createLinkedList_h(void);
    void freeLinkedList_h(linkedList_h* L);
    void printList(linkedList_h* L);
    void insertFirstNode(linkedList_h* L, char* x);
    void insertMiddleNode(linkedList_h* L, listNode* pre, char* x);
    void insertLastNode(linkedList_h* L, char* x);

(2) 소스 파일: InsertLinkedList.c

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "InsertLinkedList.h"

    // 리스트 생성
    linkedList_h* createLinkedList_h(void) {
        linkedList_h* L;
        L = (linkedList_h*)malloc(sizeof(linkedList_h));
        L->head = NULL;
        return L;
    }

    // 메모리 해제
    void freeLinkedList_h(linkedList_h* L) {
        listNode* p;
        while (L->head != NULL) {
            p = L->head;
            L->head = L->head->link;
            free(p);
            p = NULL;
        }
    }

    // 리스트 출력
    void printList(linkedList_h* L) {
        listNode* p;
        printf("L = (");
        p = L->head;
        while (p != NULL) {
            printf("%s", p->data);
            p = p->link;
            if (p != NULL) printf(", ");
        }
        printf(") \n");
    }

    // 첫 번째 노드로 삽입
    void insertFirstNode(linkedList_h* L, char* x) {
        listNode* newNode;
        newNode = (listNode*)malloc(sizeof(listNode));
        strcpy(newNode->data, x);
        newNode->link = L->head;
        L->head = newNode;
    }

    // 중간 삽입 (pre 노드 뒤)
    void insertMiddleNode(linkedList_h* L, listNode* pre, char* x) {
        listNode* newNode;
        newNode = (listNode*)malloc(sizeof(listNode));
        strcpy(newNode->data, x);
        if (L->head == NULL) {
            newNode->link = NULL;
            L->head = newNode;
        }
        else if (pre == NULL) {
            newNode->link = L->head;
            L->head = newNode;
        }
        else {
            newNode->link = pre->link;
            pre->link = newNode;
        }
    }

    // 마지막 노드로 삽입
    void insertLastNode(linkedList_h* L, char* x) {
        listNode* newNode;
        listNode* temp;
        newNode = (listNode*)malloc(sizeof(listNode));
        strcpy(newNode->data, x);
        newNode->link = NULL;
        if (L->head == NULL) {
            L->head = newNode;
            return;
        }
        temp = L->head;
        while (temp->link != NULL) temp = temp->link;
        temp->link = newNode;
    }

(3) 실행 파일: sampleLink.c

    #include <stdio.h>
    #include "InsertLinkedList.h"

    int main(void) {
        linkedList_h* L;
        L = createLinkedList_h();
        printf("(1) 공백 리스트 생성하기! \n");
        printList(L);

        printf("\n(2) 리스트에 [수] 노드 삽입하기! \n");
        insertFirstNode(L, "수");
        printList(L);

        printf("\n(3) 리스트 마지막에 [금] 노드 삽입하기! \n");
        insertLastNode(L, "금");
        printList(L);

        printf("\n(4) 리스트 첫 번째에 [월] 노드 삽입하기! \n");
        insertFirstNode(L, "월");
        printList(L);

        printf("\n(5) 리스트 공간을 해제하여 공백 리스트로 만들기! \n");
        freeLinkedList_h(L);
        printList(L);

        return 0;
    }

1. Row/Column 추가 및 삭제

컬럼(Column) 추가

• [ ] 사용: df['새컬럼명'] = 데이터 형태로 추가 (가장 우측에 추가)

  df['Age_Double']=df['Age']*2

  PassengerId	Survived	Pclass	Name	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	Embarked	Age_Double
  1	0	3	Braund, Mr. Owen Harris	male	22.0	1	0	A/5 21171	7.2500	NaN	S	44.0
  2	1	1	Cumings, Mrs. John Bradley (Florence Briggs Th...)	female	38.0	1	0	PC 17599	71.2833	C85	C	76.0
  3	1	3	Heikkinen, Miss. Laina	female	26.0	0	0	STON/O2. 3101282	7.9250	NaN	S	52.0
  4	1	1	Futrelle, Mrs. Jacques Heath (Lily May Peel)	female	35.0	1	0	113803	53.1000	C123	S	70.0
  5	0	3	Allen, Mr. William Henry	male	35.0	0	0	373450	8.0500	NaN	S	70.0
  ...	...	...	...	...	...	...	...	...	...	...	...	...
  887	0	2	Montvila, Rev. Juozas	male	27.0	0	0	211536	13.0000	NaN	S	54.0
  888	1	1	Graham, Miss. Margaret Edith	female	19.0	0	0	112053	30.0000	B42	S	38.0
  889	0	3	Johnston, Miss. Catherine Helen "Carrie"	female	NaN	1	2	W./C. 6607	23.4500	NaN	S	NaN
  890	1	1	Behr, Mr. Karl Howell	male	26.0	0	0	111369	30.0000	C148	C	52.0
  891	0	3	Dooley, Mr. Patrick	male	32.0	0	0	370376	7.7500	NaN	Q	64.0

• insert() 사용: df.insert(위치인덱스, '컬럼명', 데이터)를 사용하여 원하는 위치에 삽입

  df.insert(3, 'Fare10', df['Fare'] / 10 )
  

df.head()

| PassengerId | Survived | Pclass |Fare10 | Name | Sex | Age | SibSp | Parch | Ticket | Fare | Cabin | Embarked | Age_Double |
| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
| 1 | 0 | 3 | 0.7250 | Braund, Mr. Owen Harris | male | 22.0 | 1 | 0 | A/5 21171 | 7.2500 | NaN | S | 44.0 |
| 2 | 1 | 1 | 7.1283 | Cumings, Mrs. John Bradley (Florence Briggs Th...) | female | 38.0 | 1 | 0 | PC 17599 | 71.2833 | C85 | C | 76.0 |
| 3 | 1 | 3 | 0.7925 | Heikkinen, Miss. Laina | female | 26.0 | 0 | 0 | STON/O2. 3101282 | 7.9250 | NaN | S | 52.0 |
| 4 | 1 | 1 | 5.3100 | Futrelle, Mrs. Jacques Heath (Lily May Peel) | female | 35.0 | 1 | 0 | 113803 | 53.1000 | C123 | S | 70.0 |
| 5 | 0 | 3 | 0.8050 | Allen, Mr. William Henry | male | 35.0 | 0 | 0 | 373450 | 8.0500 | NaN | S | 70.0 |


### 컬럼(Column) 삭제
* **drop() 함수**: `df.drop('컬럼명', axis=1)` (axis=1은 열 방향)
```python
# DataFrame 은 2차원 데이터,  axis= 값은 0, 1 두가지가 존재 한다
# axis=0 : row level  (default)
# axis=1 : column level

# 열 제거, 원본 변화 없다.
df.drop('Age_Double', axis=1)

• 원본 반영: inplace=True 옵션을 주어야 원본 데이터프레임이 변경됨

행(Row) 추가 및 삭제

• 추가: df.loc['새인덱스'] = 데이터
• 삭제: df.drop(['인덱스명'], axis=0) (axis=0은 행 방향, 기본값)

  df2 = pd.DataFrame([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
  ], columns=['a','b','c','d'], index = ['김길동', '최진수', '허수민'])
  df2

  	a	b	c	d
  김길동	1	2	3	4
  최진수	5	6	7	8
  허수민	9	10	11	12
  ```python
  # 새로운 행(row) 추가
  df2.loc['김갑수'] = pd.Series([100, 200, 300, 400], index=['a', 'b', 'c', 'd'])

df2

| 인덱스 (Index) | a | b | c | d |
| :--- | :--- | :--- | :--- | :--- |
| **김길동** | 1 | 2 | 3 | 4 |
| **최진수** | 5 | 6 | 7 | 8 |
| **허수민** | 9 | 10 | 11 | 12 |
| **김갑수** | 100 | 200 | 300 | 400 |
```python
df2.loc['김철수'] = [101, 202, 303, 404]

# 행 삭제
# drop() 사용,   axis=0 (디폴트)
df2.drop(['최진수', '허수민'])

2. 상관관계 (Correlation)

두 변수 간의 선형적 흐름이 얼마나 비슷한지를 나타내는 척도입니다.

• 범위: -1 ~ +1 사이의 값
  • +1에 가까울수록: 양의 상관관계 (같이 증가)
  • -1에 가까울수록: 음의 상관관계 (한쪽이 증가하면 다른 쪽은 감소)
  • 0에 가까울수록: 상관관계가 거의 없음
  • 절대값이 클수록: 상관관계가 크다.
• 함수: df.corr(numeric_only=True)
• 주의: 상관관계가 높다고 해서 반드시 '인과관계'가 성립하는 것은 아님

상관관계 시각화

plt.matshow(df.corr(numeric_only=True)) plt.colorbar() plt.show()

![](https://velog.velcdn.com/images/snow-jun-0/post/4017b652-af30-41c0-a4c2-33880c4517ca/image.png)

---

## 3. NaN (결측치) 처리

데이터에 값이 없는 상태(Not a Number)를 의미하며, 분석 전 반드시 확인해야 합니다.

* **확인**: `df.isna()` (결측치면 True), `df.info()`
```python
df.info()

# ↓ Age, Cabin, Embarked 는 결측치가 있슴을 알수 있다.
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB



df.isna()

# ↓ 결측치는 True 로 표시된다.

# 특정 컬럼에 대해서 확인
df['Age'].isna()

• 삭제: df.dropna()
  • subset=['컬럼명']: 특정 컬럼에 결측치가 있는 경우만 삭제
  • axis=1: 결측치가 포함된 '열' 자체를 삭제

    df # 891 rows × 12 columns
    

df.dropna() # 183 rows × 12 columns

|  | PassengerId | Survived | Pclass | Name | Sex | Age | ... | Fare | Cabin | Embarked |
| :--- | :---: | :---: | :---: | :--- | :---: | :---: | :--- | :---: | :---: | :---: |
| **1** | 2 | 1 | 1 | Cumings, Mrs. John Bradley... | female | 38.0 | ... | 71.2833 | C85 | C |
| **3** | 4 | 1 | 1 | Futrelle, Mrs. Jacques Heath... | female | 35.0 | ... | 53.1000 | C123 | S |
| **6** | 7 | 0 | 1 | McCarthy, Mr. Timothy J | male | 54.0 | ... | 51.8625 | E46 | S |
| **10** | 11 | 1 | 3 | Sandstrom, Miss. Marguerite Rut | female | 4.0 | ... | 16.7000 | G6 | S |
| **11** | 12 | 1 | 1 | Bonnell, Miss. Elizabeth | female | 58.0 | ... | 26.5500 | C103 | S |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| **889** | 890 | 1 | 1 | Behr, Mr. Karl Howell | male | 26.0 | ... | 30.0000 | C148 | C |    
```python
# ↑ 183개의 row 가 나온다 (891개에서 확 줄었다)
# index 나 PassengerId 를 보면 중간중간에 빠진거 확인


# dropna() 기본적으로 row 기준(axis=0)으로 동작한다
# 각 row 에서, 하나라도 NaN 값이 있으면 해당 row 를 지워버린다


# 행을 삭제하되, 특정 컬럼에 대해서만 dropna 하기

df.dropna(subset=['Age'])  # 714 rows × 12 columns

# ↓Age 컬럼이 NaN 인 경우만 row 가 drop 됨 (axis=0)

↓ Age, Cabin, Embarked 컬럼 삭제!

|  | PassengerId | Survived | Pclass | Name | Sex | SibSp | Parch | Ticket | Fare |
| :--- | :---: | :---: | :---: | :--- | :---: | :---: | :---: | :--- | :---: |
| **0** | 1 | 0 | 3 | Braund, Mr. Owen Harris | male | 1 | 0 | A/5 21171 | 7.2500 |
| **1** | 2 | 1 | 1 | Cumings, Mrs. John Bradley... | female | 1 | 0 | PC 17599 | 71.2833 |
| **2** | 3 | 1 | 3 | Heikkinen, Miss. Laina | female | 0 | 0 | STON/O2. 3101282 | 7.9250 |
| **3** | 4 | 1 | 1 | Futrelle, Mrs. Jacques Heath... | female | 1 | 0 | 113803 | 53.1000 |
| **4** | 5 | 0 | 3 | Allen, Mr. William Henry | male | 0 | 0 | 373450 | 8.0500 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| **886** | 887 | 0 | 2 | Montvila, Rev. Juozas | male | 0 | 0 | 211536 | 13.0000 |
| **887** | 888 | 1 | 1 | Graham, Miss. Margaret Edith | female | 0 | 0 | 112053 | 30.0000 |
| **888** | 889 | 0 | 3 | Johnston, Miss. Catherine Helen... | female | 1 | 2 | W./C. 6607 | 23.4500 |
| **889** | 890 | 1 | 1 | Behr, Mr. Karl Howell | male | 0 | 0 | 111369 | 30.0000 |
| **890** | 891 | 0 | 3 | Dooley, Mr. Patrick | male | 0 | 0 | 370376 | 7.7500|

* **대체**: `df.fillna(값)`
    * 주로 평균값(`mean()`)이나 중앙값으로 채워 데이터의 손실을 방지함
```python
# Age 평균값
df['Age'].mean()   # NaN 은 배제된 연산결과닷! 주의
#29.69911764705882 (인원수 삭제가 일어남-714명)


# 위 mean() 값은 891(전체)명에 대한 평균값이 아니라 714(Nan값 제외) 명에 대한 평균값이다
# df['Age'].sum() / df['Age'].count() 둘이 같음



# NaN 을 평균값으로 대체(원본에 영향 없음)
df['Age'].fillna(df['Age'].mean())

4. 데이터 타입의 이해 (수치형 vs 범주형)

데이터 변환: apply()

특정 함수를 컬럼 전체에 적용하여 데이터를 변환할 때 사용합니다. (예: 나이 숫자를 10대, 20대 등 범주형으로 변환)

# 23 -> 20
# 43 -> 40
def age_categorize(age):
  if np.isnan(age):
    return -1   # Age 값이 없으면 -1 로 처리

  return int(age / 10) * 10


age_categorize(47)  #40  



# 특정 컬럼에 apply(함수) 한다
age_span = df['Age'].apply(age_categorize)
age_span

5. 원-핫 인코딩 (One-hot encoding)

범주형 데이터를 머신러닝 모델이 인식할 수 있도록 숫자(0과 1)로 변환하는 기법입니다.

• 범주의 개수만큼 컬럼을 생성하고, 해당 범주에만 1을 부여합니다.
• 함수: pd.get_dummies(df, columns=['컬럼명'], dtype=int)

  # 범주형 데이터는 연산이 불가하다 (혹은 의미 없다)
  # 그래서 '처리' 가 가능하도록 데이터를 바꿔주어야 할 필요가 있다.  
  

범주형 테이터 컬럼한개를 '범주의 개수' 만큼 늘려서

범주에 해당하는 값에만 '1' 을 주고

나머지에는 '0' 을 주어 처리하는 방법

--> 이를 One-hot encoding 이라 합니다 <-- 결국 '1' 은 한개만 등장한다

가령

Color 란 컬럼에 "Red", "Green", "Blue" 라는 '세가지' 종류의 범주값만 있다면

'세 개'의 '0, 1 로 구성된 값'으로 변환시키는 겁니다 ('1' 은 한개만 등장)

Red -> [1, 0, 0]

Green -> [0, 1, 0]

Blue -> [0, 0, 1]

columns= 파라미터로

one-hot encoding 컬럼으로 만들어질 컬럼들을 지정해줄수 있다.

pd.get_dummies(df, columns=['Pclass', 'Sex', 'Embarked'], dtype=int)

dtype=int 를 주면, 0 과 1 로 인코딩된다.

| Index | PassenId | Survived | Name | Age | SibSp | Parch | Ticket | Fare | Cabin | Age_span | Pclass_1 | Pclass_2 | Pclass_3 | Sex_female | Sex_male | Embarked_C | Embarked_Q | Embarked_S |
| :--- | :---: | :---: | :--- | :---: | :---: | :---: | :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
| **0** | 1 | 0 | Braund, Mr. Owen Harris | 22.0 | 1 | 0 | A/5 21171 | 7.2500 | NaN | 20 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 |
| **1** | 2 | 1 | Cumings, Mrs. John Bradley... | 38.0 | 1 | 0 | PC 17599 | 71.2833 | C85 | 30 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 |
| **2** | 3 | 1 | Heikkinen, Miss. Laina | 26.0 | 0 | 0 | STON/O2. 3101282 | 7.9250 | NaN | 20 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 |
| **3** | 4 | 1 | Futrelle, Mrs. Jacques Heath... | 35.0 | 1 | 0 | 113803 | 53.1000 | C123 | 30 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
| **4** | 5 | 0 | Allen, Mr. William Henry | 35.0 | 0 | 0 | 373450 | 8.0500 | NaN | 30 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| **886** | 887 | 0 | Montvila, Rev. Juozas | 27.0 | 0 | 0 | 211536 | 13.0000 | NaN | 20 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 1 |
| **887** | 888 | 1 | Graham, Miss. Margaret Edith | 19.0 | 0 | 0 | 112053 | 30.0000 | B42 | 10 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
| **888** | 889 | 0 | Johnston, Miss. Catherine Helen... | NaN | 1 | 2 | W./C. 6607 | 23.4500 | NaN | -1 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 |
| **889** | 890 | 1 | Behr, Mr. Karl Howell | 26.0 | 0 | 0 | 111369 | 30.0000 | C148 | 20 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |
| **890** | 891 | 0 | Dooley, Mr. Patrick | 32.0 | 0 | 0 | 370376 | 7.7500 | NaN | 30 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 |

```python
# drop_first=True
pd.get_dummies(df, columns=['Pclass', 'Sex', 'Embarked'], dtype=int, drop_first=True)

#서로 의존적인 컬럼 중 첫 번째 것을 삭제하여 데이터의 중복성을 제거하는 옵션"**입니다.
#Sex_female이 0이면 당연히 Sex_male은 1이 됩니다.
#즉, 한 쪽만 알아도 나머지 값을 100% 알 수 있는 **정보의 중복(다중공선성)**이 발생합니다.

6. 그룹화 (Groupby)

데이터를 특정 조건으로 묶어 통계량을 계산할 때 사용합니다. (분할 Split -> 적용 Apply -> 병합 Combine 과정)

• 생성: grouped = df.groupby('컬럼명')
• 확인: grouped.groups, grouped.size()
• 연산: grouped.mean(), grouped.sum(), grouped.count() 등

사용 예시들 모음

grouped_pclass = df.groupby(by='Pclass')

# groupby 객체의 속성
#   - groups -> dict 형태
#   - key -> 컬럼의 각 값
#   - value -> 인덱스 값들의 list

# Pclass 의 값은 1, 2, 3 세 개 밖에 없었으니 그룹 개수는 3개다
grouped_pclass.groups

# groups 의 key 값은 'Pclass' 의 값들,
#          value 는 index 들의 list
/*
{1: [1, 3, 6, 11, 23, 27, 30, 31, 34, 35, 52, 54, 55, 61, 62, 64, 83, 88, 92, 96, 97, 102, 110, 118, 124, 136, 137, 139, 151, 155, 166, 168, 170, 174, 177, 185, 187, 194, 195, 209, 215, 218, 224, 230, 245, 248, 252, 256, 257, 258, 262, 263, 268, 269, 270, 273, 275, 284, 290, 291, 295, 297, 298, 299, 305, 306, 307, 309, 310, 311, 318, 319, 325, 329, 331, 332, 334, 336, 337, 339, 341, 351, 356, 366, 369, 370, 373, 375, 377, 380, 383, 390, 393, 412, 430, 434, 435, 438, 445, 447, ...], 
2: [9, 15, 17, 20, 21, 33, 41, 43, 53, 56, 58, 66, 70, 72, 78, 84, 98, 99, 117, 120, 122, 123, 133, 134, 135, 144, 145, 148, 149, 150, 161, 178, 181, 183, 190, 191, 193, 199, 211, 213, 217, 219, 221, 226, 228, 232, 234, 236, 237, 238, 239, 242, 247, 249, 259, 265, 272, 277, 288, 292, 303, 308, 312, 314, 316, 317, 322, 323, 327, 340, 342, 343, 344, 345, 346, 357, 361, 385, 387, 389, 397, 398, 399, 405, 407, 413, 416, 417, 418, 426, 427, 432, 437, 439, 440, 443, 446, 450, 458, 463, ...], 
3: [0, 2, 4, 5, 7, 8, 10, 12, 13, 14, 16, 18, 19, 22, 24, 25, 26, 28, 29, 32, 36, 37, 38, 39, 40, 42, 44, 45, 46, 47, 48, 49, 50, 51, 57, 59, 60, 63, 65, 67, 68, 69, 71, 73, 74, 75, 76, 77, 79, 80, 81, 82, 85, 86, 87, 89, 90, 91, 93, 94, 95, 100, 101, 103, 104, 105, 106, 107, 108, 109, 111, 112, 113, 114, 115, 116, 119, 121, 125, 126, 127, 128, 129, 130, 131, 132, 138, 140, 141, 142, 143, 146, 147, 152, 153, 154, 156, 157, 158, 159, ...]}*/



# size()
#   각 group 별로 담겨 있는 데이터 개수 확인

grouped_pclass.size()
# Series   <- df['Pclass'].value_counts() 와 결과 같다

get_group()

그룹별 DataFrame 리턴

# Pclass 가 1 인 그룹의  DataFrame
grouped_pclass.get_group(1)

7. groupby 객체의 기초 연산 메소드

• 그룹 데이터에 적용 가능한 통계 함수(NaN은 제외하여 연산)
• count - 데이터 개수
• sum - 데이터의 합
• mean, std, var - 평균, 표준편차, 분산
• min, max - 최소, 최대값

# groupby() 로 쪼갬 <-- split

# group 별로 count()연산 <-- apply

# DataFrame 으로 합하여 리턴 <-- combine    (원본과는 다른 새로운 DataFrame)

grouped_pclass.count()

# grouped_pclass.mean()  # 에러 .  문자열 타입도 연산하려 해서리..
grouped_pclass.mean(numeric_only=True)  # OK



# groupby 객체에 컬럼 선택 가능!
grouped_pclass[['PassengerId', 'Survived', 'Age']].mean()

# 객식등급별 승객 나이의 평균
grouped_pclass[['Age']].mean()

# 동일 결과
grouped_pclass.mean(numeric_only=True)[['Age']]

복수 columns로 grouping

• groupby에 column 리스트를 전달
• 통계함수를 적용한 결과는 multiindex를 갖는 dataframe

  grouped_multi = df.groupby(['Pclass', 'Sex'])
  
  

grouped_multi.size()

| 객실 등급 (Pclass) | 성별 (Sex) | 승객 수 (명) |
| :--- | :--- | :---: |
| **1등급 (1st Class)** | 여성 (female) | **94** |
| | 남성 (male) | **122** |
| **2등급 (2nd Class)** | 여성 (female) | **76** |
| | 남성 (male) | **108** |
| **3등급 (3rd Class)** | 여성 (female) | **144** |
| | 남성 (male) | **347** |

```python
grouped_multi[['Survived', 'Age']].mean()

index를 이용한 groupby(level)

• index가 있는 경우, groupby 함수에 level 사용 가능

  • level은 index의 depth를 의미하며, 가장 왼쪽부터 0부터 증가

• set_index 함수 column 데이터를 index 레벨로 변경

• reset_index 함수 인덱스 초기화

df.set_index('Pclass')

# level=0 인덱스를 기준으로 쪼갠다.
#  지금은 Embarked 가 index 이기 때문에 'C', 'S', 'Q' 으로 쪼개진다.

df.set_index('Embarked').groupby(level=0).size()

groupby(함수)

• groupby(함수) =>
• 함수의 매개변수는 index 다
• 함수가 리턴하는 값이 grouping 기준이 된다!

  # 나이대별 생존률 구하기
  
  

df.set_index('Age')

![](https://velog.velcdn.com/images/snow-jun-0/post/37e20f10-f7e8-4101-b0ae-622a3db2896f/image.png)

```python
# groupby() 에 전달할 함수

df.set_index('Age').groupby(age_categorize).size() #연령별 분류

df.set_index('Age').groupby(age_categorize)['Survived'].mean() #연령별 생존자 평균 분류

도전 : 이름(Name) 시작 알파벳으로 승객수 집계

# 😎도전) 이름(Name) 시작 알파벳별로 승객수 집계
# groupby(함수) 활용
"""
A    51
B    72
C    69
D    43
...
...
U     1
V    15
W    33
Y     7
Z     3
"""
df['passenger'] = 1

df.groupby(df['Name'].str[0].str.upper())['passenger'].sum()

aggregate(집계) 함수 사용하기

• groupby 결과에 '집계함수'를 적용하여 그룹별 데이터 확인 가능
• 줄임형태: agg()

  # 밑에 2개는 같은 결과
  df.groupby(['Pclass', 'Sex'])['PassengerId'].count()
  df.groupby(['Pclass', 'Sex'])['PassengerId'].aggregate("count")
  

df.groupby(['Pclass', 'Sex'])['PassengerId'].aggregate(np.sum) 오류 가능성 높음

df.groupby(['Pclass', 'Sex'])['PassengerId'].aggregate(["sum", "mean", "max"])

![](https://velog.velcdn.com/images/snow-jun-0/post/6fcf6080-e29c-4abf-9ac4-59d8ff4fad20/image.png)

---
## 도전: 각 객실 등급별 탑승승객인원, 생존자수, 생존률?
```python
df.groupby(['Pclass']).aggregate(승객수=('passenger', 'sum'),생존자=('Survived','sum'),생존률=('Survived','mean'))

8. 정렬 및 구조 변경 (Pivot, Stack)

정렬

• 값 기준: df.sort_values(by=['컬럼1', '컬럼2'], ascending=[True, False])

  # by=  정렬기준
  #  컬럼명이나 컬럼들의 리스트
  df.sort_values(by='Pclass')

  PassengerId	Survived	Pclass	Name	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	Embarked	passenger
  857	1	1	Daly, Mr. Peter Denis	male	51.0	0	0	113055	26.5500	E17	S	1
  858	1	1	Swift, Mrs. Frederick Joel	female	48.0	0	0	17466	25.9292	D17	S	1
  863	0	3	Sage, Miss. Dorothy Edith	female	NaN	8	2	CA. 2343	69.5500	NaN	S	1
  868	0	1	Roebling, Mr. Washington Augustus II	male	31.0	0	0	PC 17590	50.4958	A24	S	1
  525	0	3	O'Driscoll, Miss. Bridget	female	NaN	0	0	14311	7.7500	NaN	Q	1
  ...	...	...	...	...	...	...	...	...	...	...	...	...
  888	1	1	Graham, Miss. Margaret Edith	female	19.0	0	0	112053	30.0000	B42	S	1
  889	0	3	Johnston, Miss. Catherine Helen	female	NaN	1	2	W./C. 6607	23.4500	NaN	S	1
  890	1	1	Behr, Mr. Karl Howell	male	26.0	0	0	111369	30.0000	C148	C	1
  891	0	3	Dooley, Mr. Patrick	male	32.0	0	0	370376	7.7500	NaN	Q	1

#내림차순
df.sort_values(by='Pclass', ascending=False) 

# 우선 Pclass 오름차순, 그리고 Age 오름차순
df.sort_values(by=['Pclass', 'Age'])   

---
* **인덱스 기준**: `df.sort_index()`
```python
# sort_index() index 기준으로 정렬
df.sort_index(ascending=False)

# index 기준으로 내림차순

Pivot / Pivot Table

• pivot: 데이터 재구조화 (중복 데이터가 있으면 에러 발생)
• pivot_table: 중복 데이터가 있을 때 aggfunc를 통해 요약 가능 (기본값은 평균)

Pivot

예시

df = pd.DataFrame({
    '지역': ['서울', '서울', '서울', '경기', '경기', '부산', '서울', '서울', '부산', '경기', '경기', '경기'],
    '요일': ['월요일', '화요일', '수요일', '월요일', '화요일', '월요일', '목요일', '금요일', '화요일', '수요일', '목요일', '금요일'],
    '강수량': [100, 80, 1000, 200, 200, 100, 50, 100, 200, 100, 50, 100],
    '강수확률': [80, 70, 90, 10, 20, 30, 50, 90, 20, 80, 50, 10]
                  })

df

pivot(index=None, columns=None, values=None)

index 로 지정할 컬럼

column 으로 지정할 컬럼

values 나머지 채울 값들.

이제 지역별로(index) 요일별(column) 강수량/강수확률(value)을 보고싶다

df.pivot(index='지역', columns='요일')

![](https://velog.velcdn.com/images/snow-jun-0/post/8bcc317e-7a6e-49c7-bed4-f5307f03a258/image.png)
```python
# ↑ 월~ 금 '요일' 이 두번 들어감.  강수량, 강수확률 <-- 2개의 컬럼이 있기 때문
# 부산 의 경우 금/목/수  데이터가 없다.


# '지역', '요일' 이 같은 데이터가 중복되어 있으면 에러난다.!
df.loc[len(df)] = pd.Series(['경기', '금요일', 111, 11], index=['지역', '요일', '강수량', '강수확률'])
df

df.pivot(index='지역', columns='요일')

#삭제
df.drop(12, inplace=True)
#인덱스 12인 자료 삭제

# 거꾸로 해보자
df.pivot(index='요일', columns='지역')

df.pivot(index='요일', columns='지역', values='강수량')
#df.pivot(index='요일', columns='지역')['강수량'] 와 같다. 

Pivot_table()

• 기능적으로 pivot과 동일

• pivot과의 차이점

  • 중복되는 모호한 값이 있을 경우, aggregation 함수 사용하여 값을 채움

    pd.pivot_table(df, index='지역', columns='요일')  
    

  중복데이터를 만들어 본다. 서울-월요일

  df2 = pd.DataFrame({ '지역': ['서울', '서울', '서울', '경기', '경기', '부산', '서울', '서울', '부산', '경기', '경기', '경기'], '요일': ['월요일', '월요일', '수요일', '월요일', '화요일', '월요일', '목요일', '금요일', '화요일', '수요일', '목요일', '금요일'], '강수량': [100, 80, 1000, 200, 200, 100, 50, 100, 200, 100, 50, 100], '강수확률': [80, 70, 90, 10, 20, 30, 50, 90, 20, 80, 50, 10]

             })

df2 # 서울 - 월요일 <-- 2개 있다.

pivot() 은 중복된 엔트리가 있으면 오류발생

pivot_table() 은 중복된 엔트리는 aggfunc= 를 사용하여 새로운 값 대체

aggfunc='mean' (기본값)

서울, 월요일의 '평균값' 으로 채워진다. (디폴트)

pd.pivot_table(df2, index='지역', columns='요일', aggfunc='mean')

![](https://velog.velcdn.com/images/snow-jun-0/post/add6bf09-6eb4-4548-9d95-dc4db27effd2/image.png)

max로 바꿀 수 있다.

pd.pivot_table(df2, index='지역', columns='요일', aggfunc='max')

---
### Stack & Unstack
* **stack**: 컬럼 레벨 -> 인덱스 레벨 (데이터를 아래로 쌓음)
* **unstack**: 인덱스 레벨 -> 컬럼 레벨 (옆으로 펼침)
  - 둘은 역의 관계에 있음
```python 
new_df = df.set_index(['지역', '요일'])
new_df 

#컬럼 레벨 -> 인덱스 레벨

# unstack() : index(row) -> column

# unstack(level=-1, fill_value=None)
#   level : 인덱스의 레벨
#            new_df 의 경우 지역 의 인덱스 레벨이 0 이다
#                 -1 은 오른쪽 끝 인덱스 '요일' 이 컬럼이다.

# level=-1 (디폴트) 였던 '요일' index 가 '컬럼' 으로 올라간다
new_df.unstack()

# level=0  인텍스가 컬럼으로 올라감
new_df.unstack(0)

# stack() : column -> index(row)
# stack(level=-1, dropna=True)
#         level : 컬럼의 레벨

df2 = new_df.unstack(0)

# level=0 의 컬럼 이 index 로 내려옴
df2.stack(0, future_stack=True)

df2.stack(1)

# 모든 컬럼을 다 내리면? (즉 컬럼이 없어지면) 결과는 -> Series
df2.stack().stack()

# [도전]
# 두 index 위치 (level)  변경하기
new_df.unstack(0).stack()

8. 데이터 병합 (Concat)

여러 데이터프레임을 하나로 합칩니다.

• 행 단위(axis=0): 위아래로 이어 붙임

  # 행 방향으로 병합 (axis=0)
  pd.concat([df1, df2])

• 열 단위(axis=1): 좌우로 옆에 붙임

  # 열 방향 병합 (axis=1)
  pd.concat([df1, df2], axis=1)

• 함수: pd.concat([df1, df2], axis=0)

C++에서 상속 관계를 다룰 때 가장 중요한 생성자/소멸자의 호출 순서와 멤버 변수에 대한 접근 권한, 그리고 객체지향의 꽃인 다형성(Polymorphism)에 대해 예제 코드를 통해 정리합니다.

1. 상속 관계에서의 생성자와 소멸자 호출 순서

상속 관계에서 자식 클래스의 객체가 생성될 때, 부모 클래스의 생성자는 반드시 호출됩니다. 또한, 클래스 내부에 멤버 객체(Composition)가 있다면 해당 객체의 생성자도 순서에 따라 호출됩니다.

예제 코드: 빙수 만들기

    /* - 부모 클래스 생성자 -> 자식 클래스 멤버 객체 생성자 -> 자식 클래스 생성자 순으로 실행
    - 소멸자는 생성자의 역순으로 실행
    */

    #include <iostream>
    using namespace std;

    class Ice {
    public:
        Ice() { cout << "Ice() 생성" << endl; }
        ~Ice() { cout << "~Ice() 소멸" << endl; }
    };

    class Pat {
    public:
        Pat() { cout << "Pat() 생성" << endl; }
        ~Pat() { cout << "~Pat() 소멸" << endl; }
    };

    class Bingsoo {
    public:
        Bingsoo() { cout << "Bingsoo() 부모 생성" << endl; }
        ~Bingsoo() { cout << "~Bingsoo() 부모 소멸" << endl; }
    private:
        Ice ice; // HAS-A 관계(포함관계 != 상속관계)
    };

    class PatBingsoo : public Bingsoo {
    public:
        PatBingsoo() { cout << "PatBingsoo() 자식 생성" << endl; }
        ~PatBingsoo() { cout << "~PatBingsoo() 자식 소멸" << endl; }
    private:
        Pat pat; // HAS-A 관계
    };

    int main() {
        cout << "== 객체 생성 시작 ==" << endl;
        PatBingsoo* p = new PatBingsoo();
        cout << "== 객체 소멸 시작 ==" << endl;
        delete p;
        return 0;
    }


//출력 결과
== 객체 생성 시작 ==
Ice() 생성             // 1. 부모 클래스의 멤버 객체 생성
Bingsoo() 부모 생성     // 2. 부모 클래스 생성자 실행
Pat() 생성             // 3. 자식 클래스의 멤버 객체 생성
PatBingsoo() 자식 생성  // 4. 자식 클래스 생성자 실행
== 객체 소멸 시작 ==
~PatBingsoo() 자식 소멸 // 5. 자식 클래스 소멸자 실행 (생성의 역순 시작)
~Pat() 소멸            // 6. 자식 클래스의 멤버 객체 소멸
~Bingsoo() 부모 소멸    // 7. 부모 클래스 소멸자 실행
~Ice() 소멸            // 8. 부모 클래스의 멤버 객체 소멸

[C++] 생성자 호출 순서

C++에서 상속(IS-A)과 포함(HAS-A) 관계가 섞여 있을 때, 객체가 생성되는 논리적인 단계를 뜯어보겠습니다.

1. 생성의 대원칙: "기초가 있어야 집을 짓는다"

객체가 생성될 때 컴파일러는 내부적으로 다음의 순서를 엄격히 지킵니다.

1. 부모 클래스(Base Class) 영역을 먼저 구성한다.
2. 부모 영역 안에서도 멤버 변수(Has-a)들을 먼저 메모리에 올린다.
3. 그 후 부모의 생성자 몸체({})를 실행한다.
4. 부모가 완성되면 자식 클래스(Derived Class) 영역으로 내려온다.
5. 자식의 멤버 변수(Has-a)들을 메모리에 올린다.
6. 마지막으로 자식의 생성자 몸체({})를 실행한다.

2. 빙수 예제로 보는 상세 프로세스

질문하신 PatBingsoo 객체를 생성할 때의 내부 동작을 단계별로 보겠습니다.

1단계: 부모 클래스(Bingsoo)로 진입

PatBingsoo는 Bingsoo를 상속받았으므로, 자식의 몸체를 실행하기 전에 부모인 Bingsoo를 먼저 만들어야 합니다. 그래서 제어권이 Bingsoo로 넘어갑니다.

2단계: 부모의 내부 재료(Ice) 준비 (★ 여기가 포인트!)

Bingsoo 클래스 안을 보니 Ice ice;라는 멤버 변수가 있습니다.

• 논리: "빙수라는 객체가 온전히 존재하려면, 그 안에 포함된 얼음(Ice)부터 메모리에 존재해야 한다."
• 따라서 Bingsoo의 생성자 {}가 실행되기 직전에, 멤버 변수인 Ice의 생성자가 먼저 호출됩니다.
• 출력: Ice() 생성

3단계: 부모 클래스 생성자 실행

재료(Ice)가 준비되었으니 이제 Bingsoo의 생성자 몸체를 실행합니다.

• 출력: Bingsoo() 부모 생성

4단계: 자식의 내부 재료(Pat) 준비

부모 영역이 완전히 만들어졌으니 다시 자식인 PatBingsoo로 돌아옵니다. 자식 클래스 안을 보니 Pat pat;이라는 멤버가 있네요.

• 논리: "팥빙수가 완성되기 전에 팥(Pat)이 먼저 준비되어야 한다."
• 출력: Pat() 생성

5단계: 자식 클래스 생성자 실행

이제 모든 재료가 준비되었으니 최종적으로 PatBingsoo의 생성자 몸체를 실행합니다.

• 출력: PatBingsoo() 자식 생성

3. 한 줄 요약

"부모의 멤버 -> 부모의 본체 -> 자식의 멤버 -> 자식의 본체"

소멸자는 이 과정을 정확히 거울 보듯 반대(역순)로 진행합니다. 가장 마지막에 완성된 자식의 본체부터 부수기 시작해서, 가장 먼저 만들어졌던 부모의 재료(Ice)를 가장 나중에 치우는 것이죠.

4. 왜 이렇게 설계되었을까?

만약 부모의 본체가 실행되기 전에 부모의 멤버(Ice)가 생성되지 않는다면, 부모 생성자 안에서 ice 변수를 사용하려고 할 때 에러가 날 것입니다. C++은 "사용하기 전에 반드시 완벽하게 준비시킨다"는 철학을 가지고 있기 때문에 이런 순서를 가집니다.

[C++] 객체지향의 핵심: 상속(IS-A)과 포함(HAS-A) 관계 분석

## 1. 포함 관계(Composition)란?
포함 관계는 한 클래스가 다른 클래스의 객체를 자신의 멤버 변수로 가지는 상태를 말합니다. 
상속이 "A는 B이다(IS-A)"라면, 포함은 "A는 B를 가지고 있다(HAS-A)"는 논리입니다.

* 예제에서의 포함 관계:
    - Bingsoo 클래스는 Ice 객체를 멤버로 가짐 (빙수는 얼음을 가짐)
    - PatBingsoo 클래스는 Pat 객체를 멤버로 가짐 (팥빙수는 팥을 가짐)

## 2. 포함 관계의 특징
- 생명 주기 종속: 호스트 객체(Bingsoo)가 생성될 때 부품 객체(Ice)도 함께 생성되고, 호스트가 소멸할 때 부품도 운명을 같이합니다.
- 부품의 우선순위: 객체를 조립할 때 부품이 먼저 준비되어야 본체를 완성할 수 있듯, 생성자 호출 시 멤버 객체의 생성자가 본체 생성자보다 먼저 실행됩니다.

## 3. 전체 코드 및 실행 순서 상세

#include <iostream>
using namespace std;

class Ice {
public:
    Ice() { cout << "Ice() 부품 생성" << endl; }
    ~Ice() { cout << "~Ice() 부품 소멸" << endl; }
};

class Pat {
public:
    Pat() { cout << "Pat() 부품 생성" << endl; }
    ~Pat() { cout << "~Pat() 부품 소멸" << endl; }
};

class Bingsoo {
public:
    Bingsoo() { cout << "Bingsoo() 부모 본체 생성" << endl; }
    ~Bingsoo() { cout << "~Bingsoo() 부모 본체 소멸" << endl; }
private:
    Ice ice; // [포함 관계] 빙수의 부품
};

class PatBingsoo : public Bingsoo {
public:
    PatBingsoo() { cout << "PatBingsoo() 자식 본체 생성" << endl; }
    ~PatBingsoo() { cout << "~PatBingsoo() 자식 본체 소멸" << endl; }
private:
    Pat pat; // [포함 관계] 팥빙수의 부품
};

int main() {
    cout << "== 1. 객체 생성 과정 ==" << endl;
    PatBingsoo* p = new PatBingsoo();

    // 생성 순서 설명:
    // 1단계 [부모 생성 시작]: 부모의 부품(Ice) 생성 -> 부모 본체(Bingsoo) 생성
    // 2단계 [자식 생성 시작]: 자식의 부품(Pat) 생성 -> 자식 본체(PatBingsoo) 생성

    cout << endl << "== 2. 객체 소멸 과정 ==" << endl;
    delete p;

    // 소멸 순서 설명 (생성의 역순):
    // 1단계 [자식 소멸]: 자식 본체 소멸 -> 자식 부품(Pat) 소멸
    // 2단계 [부모 소멸]: 부모 본체 소멸 -> 부모 부품(Ice) 소멸

    return 0;
}

## 4. 요약 및 주의사항
- 포함된 멤버 변수는 '조립품'과 같아서 본체 클래스의 생성자 몸체({ })가 실행되기 전에 이미 메모리에 준비를 마쳐야 합니다.
- 위 예제에서 Ice ice;는 private으로 선언되어 있으므로, PatBingsoo(자식)는 부모의 부품인 ice에 직접 접근할 수 없습니다. 이것이 상속과 포함의 결정적인 차이 중 하나입니다.

2. 멤버 접근 제어와 생성자 초기화 리스트

부모 클래스의 private 멤버는 자식 클래스에서 직접 접근할 수 없습니다. 따라서 자식 클래스의 생성자에서 부모 클래스의 생성자를 명시적으로 호출하여 초기화해야 합니다.

예제 코드: 메시지 시스템

#include <iostream>
#include <string>
using namespace std;

class Image {
public:
    // 형변환 연산자 오버로딩: 객체를 string으로 취급할 때 호출
    operator string() { return "사진 데이터"; }
};

class Message {
public:
    Message(int sendTime, string sendName) 
        : sendTime(sendTime), sendName(sendName) {}

    int getSendTime() const { return sendTime; }
    string getSendName() const { return sendName; }

private:
    int sendTime;   // 자식에서 직접 접근 불가
    string sendName;
};

class TextMessage : public Message {
public:
    TextMessage(int sendTime, string sendName, string text)
        : Message(sendTime, sendName) { // 부모 생성자 호출
        this->text = text;
    }
    string getText() const { return text; }
private:
    string text;
};

class ImageMessage : public Message {
public:
    ImageMessage(int sendTime, string sendName, Image* image)
        : Message(sendTime, sendName) {
        this->image = image;
    }
    Image* getImage() const { return image; }
private:
    Image* image;
};

3. 가상 함수와 다형성 (Dynamic Binding)

부모 타입의 포인터로 자식 객체를 가리킬 때(Upcasting), 가상 함수(virtual)를 사용하면 실행 시점에 실제 객체의 타입에 맞는 함수가 호출됩니다.

예제 코드: 무기 시스템

class Weapon {
public:
    Weapon(int power) : power(power) {
        cout << "Weapon 생성자 호출" << endl;
    }

    // 가상 함수 선언
    virtual void use() {
        cout << "무기를 사용합니다." << endl;
    }

protected:
    // protected: 자식 클래스에게는 접근을 허용
    int power;
};

class Sword : public Weapon {
public:
    Sword(int power) : Weapon(power) {}

    // 부모의 use()를 재정의(Override)
    void use() override {
        cout << "검을 휘둘러 " << power << "의 데미지를 입힙니다!" << endl;
    }
};

int main() {
    // 다형성 활용: 부모 포인터로 자식 객체 관리
    Weapon* myWeapon = new Sword(100);

    // Sword의 use()가 호출됨 (동적 바인딩)
    myWeapon->use(); 

    delete myWeapon;
    return 0;
}

요약

1. 상속 순서: 부모 생성 -> 자식 멤버 객체 생성 -> 자식 생성 순.
2. 접근 제어: private은 자식도 못 건드린다. protected는 자식에겐 오픈된다.
3. 가상 함수: virtual 키워드를 써야 부모 포인터로 자식을 가리켰을 때 자식의 함수가 제대로 호출된다.

1. 표준 입출력 및 문자열 결합

C++에서 cin과 cout을 이용해 문자열을 입력받고 결합하는 기초 예제입니다. string 클래스를 사용하기 위해서는 <string> 헤더를 포함해야 합니다.

이름과 성을 입력받아 결합하는 코드

    #include <iostream>
    #include <string> 
    using namespace std;

    int main() {
        // 변수 선언
        string first;
        string last;
        string space = " ";
        string dot = ".";
        string fullName;

        // 입력
        cout << "이름을 입력 :"; // << endl;을 사용하지 않으면 같은 줄에서 입력
        cin >> last;
        cout << "성을 입력 :";
        cin >> first;

        fullName = first + space + dot + last;

        cout << "전체 이름 : " << fullName << endl;
    }

출력 결과 비교

• endl 미사용 시 (기본) 이름을 입력 : 길동 성을 입력 : 홍

• endl 사용 시 (줄바꿈 발생) 이름을 입력 : 길동 성을 입력 : 홍

2. 상속 (Inheritance)

상속이란 클래스가 다른 클래스에게 자신의 멤버(필드, 메서드)를 "물려주는 것"을 의미합니다.

용어 정리

• 부모 클래스: 슈퍼 클래스(Super), 기본 클래스(Base)
• 자식 클래스: 파생 클래스(Derived), 서브 클래스(Sub)

상속의 특징과 장점

• 상속이 이루어지면 부모의 기능을 포함한 새로운 클래스가 만들어집니다.
• 클래스의 간결성: 공통된 코드를 부모 클래스에 집중시켜 코드 중복을 줄입니다.
• 자식 클래스에는 자신만의 멤버가 존재할 수 있으며, 부모에게 물려받은 멤버도 사용 가능합니다.

접근 제어 지시자와 상속

상속 할 때 부모 클래스이 접근 제어지시자를 protected, private로 선언할 수 있다. (public만 되는게 아님)

• ex) class Derived : protected Base
• ex) class Derived : private Base

주의: 부모 클래스의 private 멤버는 자식 클래스에게 상속은 되지만, 자식 클래스에서 직접 접근할 수는 없습니다.

3. 상속 사용법 및 예제

기본 문법

    class 자식클래스 : 접근제어지시자 부모클래스 {
        // 추가 멤버
    };

상속 관계도

예제: Base와 Derived 클래스

    //부모 클래스
    class Base {
    public:
        void bFunc() {
            cout << "부모 클래스의 메서드" << endl;
        }
        int bNum;
    };

    //자식 클래스
    class Derived : public Base {
    public:
        void dFunc() {
            cout << "자식 클래스의 메서드" << endl;
        }
        int dNum;
    };

    int main() {
        Base b; //객체 생성
        Derived d; //객체 생성

        b.bFunc();
        b.bNum = 1;

        d.bFunc(); // 부모에게 물려받은 메서드 사용
        d.bNum = 2;
        d.dFunc();
        d.dNum = 1;
    }

4. 생성자 호출 순서

상속 관계에서 자식 클래스의 객체가 생성될 때, 반드시 부모 클래스의 생성자가 먼저 호출된 후 자식 클래스의 생성자가 호출됩니다.

    int main() {
        Derived d; // 1. 부모 생성자 호출 -> 2. 자식 생성자 호출
    }

5. 실전 상속 예시 (Animal 클래스)

    #include <iostream>
    using namespace std;

    class Animal {
    public:
        void breathe() {
            cout << "숨을 쉰다." << endl;
        }
        int age;
    };

    class Dog : public Animal {
    public:
        void walk() {
            cout << "걷는다." << endl;
        }
    };

    class Sparrow : public Animal {
    public:
        void fly() {
            cout << "난다." << endl;
        }
    };

    int main() {
        Dog d;
        d.age = 7;
        d.breathe(); // 부모 기능
        d.walk();    // 자식 기능

        Sparrow s;
        s.age = 1;
        s.breathe(); // 부모 기능
        s.fly();     // 자식 기능
    }

6. 업캐스팅 (Upcasting)

자식 클래스의 객체를 부모 클래스의 포인터(또는 참조)로 가리키는 것을 의미합니다.

    int main() {
        Dog d;
        Sparrow s;

        // 업캐스팅: 자식 주소를 부모 포인터에 대입
        Animal* p1 = &d; 
        Animal* p2 = &s;

        p1->breathe(); // 가능
        p2->breathe(); // 가능

        // p1->walk(); // 에러! 부모 포인터로는 자식 전용 멤버가 보이지 않음
    }

업캐스팅을 사용하는 이유 (장점)

• "자식 기능을 못 쓰는데 왜 굳이 부모 포인터로 쓰나요?"라는 의문이 생길 수 있습니다. 가장 큰 이유는 관리의 편의성 때문입니다.

  • 개별 관리의 불편함: 강아지 10마리, 참새 10마리를 관리하려면 Dog* dogList[10], Sparrow* sparrowList[10]처럼 따로따로 리스트를 만들어야 합니다.

  • 통합 관리의 편리함: Animal* zoo[20] 하나만 만들면, 그 안에 강아지든 참새든 사자든 '동물'이라는 이름으로 한꺼번에 담을 수 있습니다.

Tip: 만약 부모 포인터 상태에서도 자식의 특정한 행동(예: 멍멍, 짹짹)을 하고 싶다면, 나중에 배울 '가상 함수(virtual function)'와 '오버라이딩'을 사용하면 됩니다.

오늘 수업에서는 C++에서 상수를 다루는 방법과, 동적 할당을 포함한 클래스에서 반드시 처리해야 할 '깊은 복사'에 대해 학습했습니다. 특히 직접 String 클래스를 설계해보며 메모리 관리의 중요성을 체감할 수 있었습니다.

1. 상수 (const)

변하지 않는 값을 정의할 때 사용하며, 선언과 동시에 초기화해야 합니다.

• const 변수: 값을 변경할 수 없습니다. const int a = 10; (에러: a = 20;)

• 상수형 메서드: void func() const { ... } 형태. 메서드 내부에서 객체의 멤버 변수를 수정하는 것을 금지합니다.

2. String 클래스 만들기 (1차: 동적 할당과 소멸자)

문자열을 저장하기 위해 char* 포인터를 사용하여 힙(Heap) 메모리를 관리하는 클래스를 설계합니다.

[코드 예시]

//String class 생성
class String { // 'String'이라는 이름의 새로운 설계도(클래스)를 만듭니다.
public:
    String() { // [기본 생성자] 아무런 글자 없이 String 객체를 만들 때 실행됩니다.
        strData = NULL; // 가리킬 곳이 없으므로 주소를 NULL(0)로 비워둡니다.
        len = 0; // 길이는 당연히 0입니다.
    }

    String(const char* str) { // [매개변수 생성자] "Hello" 같은 글자를 넣으며 만들 때 실행됩니다. 포인터 형태의 문자열을 받습니다. 
        len = strlen(str); // strlen 함수로 입력받은 글자 수가 몇 개인지 잽니다.
        strData = new char[len + 1]; // 글자 수 + 1(끝을 알리는 '\0' 자리)만큼 힙(Heap) 메모리를 빌려옵니다. 문자열을 저장할 공간을 동적 할당
        strcpy(strData, str); // 빌린 메모리 칸에 입력받은 글자들을 하나씩 복사해 넣습니다. 깊은 복사

    }

    ~String() { // [소멸자] 객체가 수명을 다해 사라질 때 자동으로 호출됩니다.
        if (strData) { // 만약 빌려 쓰고 있는 메모리(strData)가 있다면?
            delete[]strData; new[]로 빌렸던 메모리를 국가(OS)에 반납합니다. (메모리 누수 방지)
        }
    }


    const char* getStrData() const { // 상수형 메서드: 내부 값을 절대 바꾸지 않겠다고 약속하는 조회 함수입니다.
        if (strData) //저장된 데이터가 있다면
            return strData; // 그 주소값을 돌려줍니다.
        return""; // 데이터가 없다면 빈 문자열의 주소를 돌려줍니다.
    }

    int getLen() const { // 상수형 메서드입니다.
        return len; // 저장된 길이 값을 돌려줍니다.
    }
private:
    char* strData; // 실제 문자열이 저장된 메모리 주소를 가리키는 화살표(포인터)입니다.
    int len; // 문자열의 길이를 숫자로 저장하는 칸입니다.

};


int main(void) {
    String str1; // 기본 생성자 호출 -> strData=NULL, len=0인 빈 객체 생성
    String str2("Hello"); // 매개변수 생성자 호출 -> 6칸 빌려서 "Hello\0" 저장

    cout << str1.getLen() << endl; // 0 출력
    cout << str1.getStrData() << endl; // 빈 줄 출력 (또는 아무것도 안 나옴)
    cout << str2.getLen() << endl; // 5 출력
    cout << str2.getStrData() << endl; // Hello 출력

    //런타임 에러 case
    //String str3 = str2; 객체를 복사하면 기본적으로 모든 멤버의 값이 복사된다. (포인터라면 메모리 주소도 같이 복사된다. ==얕은 복사가 이루어진다. ) 


    return 0;
}

const char*str

• const char를 가리키는 포인터 const char* 를 통해서 문자열을 받는다. 읽어오는 것은 가능하지만 새로운 값을 쓰는 것은 할 수 없다. (상수)

• 만약 생성자를 String(char* str)로 만들었다고 가정해 봅시다.

  나의 의도: String str("test");
  

컴파일러의 생각:

1. "test"는 상수형 문자열(const char*)이네? 절대 바뀌면 안 되는 데이터야.

2. 그런데 받는 쪽(char* str)은 const가 없네? 이건 "나중에 이 내용을 바꿀 수도 있다"는 뜻이잖아.

3. "안전하지 않아! 상수를 보관하는데 왜 바꿀 수 있는 통에 담으려고 해? 에러!"

---

## 3. 얕은 복사(Shallow Copy) vs 깊은 복사(Deep Copy)

### 얕은 복사의 문제점
`String str3 = str2;`와 같이 객체를 복사할 때, 별도의 처리가 없으면 포인터 주소값만 그대로 복사됩니다. (얕은 복사가 이루어집니다.)
1. **Double Free Error**: 두 객체가 같은 메모리 주소를 가리키고 있어, 소멸자가 호출될 때 이미 해제된 메모리를 또 해제하려다 에러가 발생합니다.
2. **데이터 공유**: 한쪽에서 값을 바꾸면 의도치 않게 다른 쪽 데이터도 영향을 받습니다.

**예시**
```c
String str3 = str2; //객체를 복사하면 기본적으로 모든 멤버의 값이 복사된다. 
//(포인터라면 메모리 주소도 같이 복사된다. ==얕은 복사가 이루어진다. ) 

str2: len=5, strData=0x1000 (예시 주소)
str3: len=5, strData=0x1000 (똑같은 주소!)


main 함수의 마지막 중괄호 }를 만나는 순간,
Stack에 쌓였던 객체들이 생성된 반대 순서로 사라지기 시작합니다.

1. str3 소멸 시작): 가장 마지막에 들어온 str3의 소멸자가 먼저 호출됩니다.

2. str3가 가진 주소 0x1000을 찾아가서 메모리를 반납(delete[])합니다. (성공)

3. (str2 소멸 시작): 그다음 순서인 str2의 소멸자가 호출됩니다.

4. str2도 자기가 가진 주소 0x1000을 찾아가서 반납하려고 합니다.


문제 발생: 하지만 이미 str3가 반납해버린 땅입니다! 이미 비어있는(혹은 권한이 없는) 메모리를 또 삭제하려 하니 운영체제가 "이건 불법이야!"라며 Double Free Error를 일으킵니다.

그래서 이 문제를 해결하기 위해서는 str2의 객체가 생성될 때 생성자 호출 --> 이 때 호출되는 생성자는 복사 생성자이다.

복사 생성자를 새롭게 선언하지 않으면 얕은 복사가 일어난다. 그러므로 깊은 복사가 이루어 지도록 복사 생성자를 선언해주어야 한다.

깊은 복사 (복사 생성자)

새로운 메모리 공간을 할당받고 내용을 복사하여 독립적인 상태를 유지합니다.

예시

//복사 생성자 선언 
String(const String &rob){
    len = rob.len;
    strData = new char[len + 1];
    strcpy(strData, rob.strData);

}

...

String str3(str2);

위쪽 예시를 포함한 코드

#include <iostream>
#include <cstring> // strlen, strcpy 사용을 위해 필요

using namespace std;

class String {
public:
    // 1. 기본 생성자
    String() {
        strData = NULL;
        len = 0;
    }

    // 2. 매개변수 생성자 (문자열 입력)
    String(const char* str) {
        len = strlen(str);
        strData = new char[len + 1];
        strcpy(strData, str);
    }

    // 3. 복사 생성자 (깊은 복사) - 핵심 수정 부분!
    String(const String &rob) {
        len = rob.len;
        if (rob.strData != NULL) {
            strData = new char[len + 1]; //(깊은 복사)
            strcpy(strData, rob.strData);
        } else {
            strData = NULL;
        }
    }

    // 4. 소멸자
    ~String() {
        if (strData) {
            delete[] strData;
        }
    }

    // 조회용 메서드
    const char* getStrData() const {
        if (strData) return strData;
        return "";
    }

    int getLen() const {
        return len;
    }

private:
    char* strData;
    int len;
};

int main(void) {
    String str1;                // 기본 생성자
    String str2("Hello");       // 매개변수 생성자
    String str3 = str2;         // 복사 생성자 호출 (이제 에러가 나지 않습니다!)

    cout << "str1: " << str1.getStrData() << " (길이: " << str1.getLen() << ")" << endl;
    cout << "str2: " << str2.getStrData() << " (길이: " << str2.getLen() << ")" << endl;
    cout << "str3: " << str3.getStrData() << " (길이: " << str3.getLen() << ")" << endl;

    return 0;
}


//출력 결과 
str1:  (길이: 0)
str2: Hello (길이: 5)
str3: Hello (길이: 5)

4. 복사 대입 연산자 (Copy Assignment Operator)

복사 생성자와는 다른 내용입니다. 이미 생성된 객체에 다른 객체를 대입할 때(str4 = str2;) 호출됩니다.

복사 생성자 : String str3=str2;(태어나면서 바로 복사)

복사 대입 연산자 : str3=str2;(이미 만들어진 str3에 str2를 대입)

• 주의사항: 기존에 가지고 있던 메모리를 먼저 delete 해야 메모리 누수(Memory Leak)가 발생하지 않습니다.

  String 클래스처럼 동적 할당을 쓰는 경우, 단순히 `=` 만 쓰면 다시 얕은 복사 문제가 
  발생. 
  

이미 str3가 빌려놓은 땅에 str2의 주소를 그냥 덮어씌우면 str3가 쓰던 땅은 미아(메모리 누수)

* **자기 대입 방지**: `if (this != &rob)`를 통해 자기 자신을 대입하는 낭비를 막습니다.

**예시**

String& operator=(const String &rob) { if (this != &rob) { // 자기 대입 체크 delete[] strData; // 기존 메모리 해제 (중요!) len = rob.len; strData = new char[len + 1]; strcpy(strData, rob.strData); } return *this; }

...

String str3 = str2;

---

**위의 예시들을 포함한 예시**
```c
#include <iostream>
#include <cstring> // strlen, strcpy 사용을 위해 필요

using namespace std;

class String {
public:
    // 1. 기본 생성자
    String() {
        strData = NULL;
        len = 0;
    }

    // 2. 매개변수 생성자 (문자열 입력)
    String(const char* str) {
        len = strlen(str);
        strData = new char[len + 1];
        strcpy(strData, str);
    }

    // 3. 복사 생성자 (깊은 복사) 
    String(const String &rob) {
        len = rob.len;
        if (rob.strData != NULL) {
            strData = new char[len + 1];
            strcpy(strData, rob.strData);
        } else {
            strData = NULL;
        }
    }

    // 4. 소멸자
    ~String() {
        if (strData) {
            delete[] strData;
        }
    }

    //복사 대입 연산자   -> 메모리 누수 현상 일어남
    String &oper=(const String &rob){
        if (this != &rob){
            len= rob.len;
               delete[]strData;
            strData = new char[len+1];
            strcpy(strData, rob.strData);
        }
        return *this;
    }


    // 조회용 메서드
    const char* getStrData() const {
        if (strData) return strData;
        return "";
    }

    int getLen() const {
        return len;
    }

private:
    char* strData;
    int len;
};

int main(void) {
    String str1;                // 기본 생성자
    String str2("Hello");       // 매개변수 생성자

    String str3 = str2;         // 복사 생성자 호출 (이제 에러가 나지 않습니다!)

    String str4("C++ Pro");
    str4 = str2;

    cout << "str1: " << str1.getStrData() << " (길이: " << str1.getLen() << ")" << endl;
    cout << "str2: " << str2.getStrData() << " (길이: " << str2.getLen() << ")" << endl;
    cout << "str3: " << str3.getStrData() << " (길이: " << str3.getLen() << ")" << endl;
    cout << "str4: " << str4.getStrData() << " (길이: " << str4.getLen() << ")" << endl;
    cout << "str2: " << str2.getStrData() << " (길이: " << str2.getLen() << ")" << endl;

    return 0;
}

//출력 결과

str1:  (길이: 0)
str2: Hello (길이: 5)
str3: Hello (길이: 5)
str4: Hello (길이: 5)
str2: Hello (길이: 5)

    str1: 기본 생성자로 만들어져 내용이 비어 있고 길이는 0입니다.

    str2: "Hello"라는 문자열을 가지고 있으며 길이는 5입니다.

    str3: str2를 복사 생성자로 복사했으므로 똑같이 "Hello"와 5가 출력됩니다.

    str4: 처음에는 "C++ Pro"였지만, str4 = str2;를 거치면서 
    기존 메모리를 delete 하고 str2의 값을 가져왔습니다. 
    그래서 **Hello**와 5가 출력됩니다.

    마지막 str2: str4에 값을 대입해줬다고 해서 원본인 str2가 변하지는 않습니다. 
    그대로 **Hello**와 5가 나옵니다.

객체지향 프로그래밍에서 가장 중요한 것 중 하나는 메모리를 할당하고 관리하는 능력입니다. 특히 객체가 복사될 때 내부 데이터(특히 포인터)가 어떻게 처리되는지 이해하는 것이 핵심입니다.

1. 정적 할당 vs 동적 할당

정적 할당 (Static Allocation)

• 특징: 컴파일 시점에 메모리 크기가 결정됩니다.
• 장점: 사용하기 쉽고 관리(해제)를 신경 쓸 필요가 없습니다.
• 단점: 실행 도중에 메모리 크기를 변경할 수 없어 효율성이 떨어질 수 있습니다.

    // 예시
    int a(5);
    int a = int(5);

동적 할당 (Dynamic Allocation)

• 특징: 프로그램 실행 도중(Runtime)에 필요한 만큼 메모리를 요청합니다.
• 장점: 메모리를 효율적으로 사용할 수 있고, 필요한 시점에 생성/소멸이 가능합니다.
• 단점: delete를 통해 직접 메모리를 해제해주지 않으면 메모리 누수(Memory Leak)가 발생합니다.

    // 예시 (new 연산자 활용)
    int *a = new int(5); 
    delete a;            // 반드시 해제!

new int(5)선언을 하면

1. int를 담는 공간 하나가 동적으로 생성
2. 5라는 값이 들어간다.
3. 접근하기 위해서 새로 만들어진 공간의 주소값을 반환(포인터 변수 선언)

2. 객체의 동적 할당과 소멸 순서

객체를 동적으로 생성하면 new를 하는 순간 생성자가 호출되고, delete를 하는 순간 소멸자가 즉시 호출됩니다. 반면 일반 객체는 함수가 끝날 때 역순으로 소멸합니다.

class Vector {
public:
    Vector() : x(0), y(0) {
        cout << this << " : Vector()" << endl;
    }

    Vector(float x, float y) : x(x), y(y) {
        cout << this << " : Vector(float, float)" << endl;
    }

    // 소멸자
    ~Vector() {
        cout << this << " : ~Vector()" << endl;
    }

    float getX() {return x;}
    float getY() { return y; }

private:
    float x, y;
};


int main(void) {
    cout << "main() 함수 시작" << endl;
    // 정적 할당 객체
    Vector v1;
    Vector v2(3, 4);

    //동적 할당
    Vector* v3 = new Vector();
    Vector* v4 = new Vector(5, 6);

    cout << "(" << v3->getX() << "," << v3->getY() <<")"<< endl;
    cout << "(" << v4->getX() << "," << v4->getY() << ")" << endl;

    delete v3; // v3 즉시 소멸
    delete v4;

    cout << "main() 함수 끝" << endl;

}// 함수 종료 시 v2, v1 소멸


//출력 과정
this는 주소를 출력

main() 함수 시작
0x...10 : Vector()             // v1 생성
0x...20 : Vector(float, float)  // v2 생성

0x...30 : Vector()             // v3 생성 (new)
0x...40 : Vector(float, float)  // v4 생성 (new)

(0,0)                          // v3->getX(), getY()
(5,6)                          // v4->getX(), getY()

0x...30 : ~Vector()            // delete v3 실행 (즉시 소멸)
0x...40 : ~Vector()            // delete v4 실행 (즉시 소멸)

main() 함수 끝

0x...20 : ~Vector()            // v2 소멸 (main이 끝나며 역순 소멸)
0x...10 : ~Vector()            // v1 소멸 (main이 끝나며 역순 소멸)

3. 얕은 복사(Shallow Copy) vs 깊은 복사(Deep Copy)

메모리를 복사할 때, 특히 포인터 변수가 포함된 경우 복사의 방식이 매우 중요합니다.

얕은 복사 (Shallow Copy)

• 정의: 주소값만 복사하는 방식입니다.

• 문제점: 두 포인터가 같은 메모리 공간을 가리키게 되어, 한쪽에서 값을 바꾸면 다른 쪽도 영향을 받습니다. 또한 delete 시 이미 해제된 메모리를 또 해제하려는 에러가 발생할 수 있습니다.

    int *a = new int(3)
  
    //실제 int를 담는 공간과 그 공간에 있는 값이 복사 된 것이 아니라, 주소값만 복사
    int *b = a;
  
  

//결과
a 값 1000(주소)
b 값 1000(주소)

1000의 주소에 있는 값 3

*a=5;

//결과
a 값 1000(주소)
b 값 1000(주소)

1000의 주소에 있는 값 3 -> 5

### 깊은 복사 (Deep Copy)
* **정의**: 실제 데이터가 담긴 새로운 공간을 따로 만들어서 내용물만 복사하는 방식입니다.
* **장점**: 두 객체는 완전히 독립된 메모리를 가집니다.
```c
    int *a = new int(3)
    int *b = new int(*a)


    //결과
    a 값 1000(주소),   1000의 주소값 3
    b 값 2000(주소),   2000의 주소값 3

    *a=5;

    //결과
    a 값 1000(주소),   1000의 주소값 5
    b 값 2000(주소),   2000의 주소값 3

4. 포인터 멤버를 가진 클래스의 복사 예시

클래스 멤버로 포인터가 있을 때, 기본 복사를 수행하면 어떤 일이 벌어지는지 분석해봅시다.

class A{
public:
    A(int x, int y) : x(x), y(y) {    
    int x;
    int *y;
};


int main(void({
    A a(1, new int(2));

    A b = a; 기본 복사 발생 (얕은 복사)

    a.x = 3; // a.x는 일반 변수라 b.x에 영향 없음 (값 복사)
    *a.y = 4; // a.y는 포인터라 주소가 복사됨. b.y도 똑같이 4로 변함 (얕은 복사)

    cout << b.x << endl; // 출력: 1
    cout <<*b.y << endl; // 출력: 4 

    delete a.y; // a.y를 해제하면 b.y는 갈 곳 잃은 포인터(Dangling Pointer)가 됨

}


//출력 결과
1. A a(1, new int(2));
a안에, x, y가 있는데,
x의 값은 1
y의 값은 1000(주소값), *y(1000의 주소에는)의 값은 2

2. A b = a;
b안에, x, y가 있는데,
x의 값은 1
y의 값은 1000(주소값), *y(1000의 주소에는)의 값은 2 (얕은 복사)


3. a.x = 3;
a안에, x, y가 있는데,
x의 값은 1 -> 3
y의 값은 1000(주소값), *y(1000의 주소에는)의 값은 2

b안에, x, y가 있는데,
x의 값은 1 (변화 없음, 값 복사이기 때문에(call by value))
y의 값은 1000(주소값), *y(1000의 주소에는)의 값은 2


4. *a.y = 4;
a안에, x, y가 있는데,
x의 값은 3
y의 값은 1000(주소값), *y(1000의 주소에는)의 값은 2 -> 4

b안에, x, y가 있는데,
x의 값은 1 
y의 값은 1000(주소값), *y(1000의 주소에는)의 값은 2 -> 4 (얕은 복사)

요약:

1. new를 썼다면 반드시 delete를 짝지어주자.
2. 포인터를 멤버로 가진 클래스라면, 주소만 옮기는 얕은 복사가 일어날 수 있음을 항상 경계하자!

1. 생성자와 소멸자 (Constructor & Destructor)

클래스에서 객체가 생성될 때와 사라질 때 자동으로 실행되는 특별한 함수들입니다.

생성자 (Constructor) 재설명

• 정의: 객체가 메모리에 태어나는 순간 자동으로 실행되는 특별한 함수입니다.

• 목적: 아기가 태어나면 이름을 지어주듯, 객체가 태어날 때 변수들에 첫 번째 값(초기값)을 넣어주는 역할을 합니다.

• 특징: 클래스 이름과 똑같이 생겼고, 우리가 직접 부르지 않아도 MyClass m1;이라고 쓰는 순간 컴퓨터가 알아서 실행합니다.

소멸자 (Destructor)

• 특징: 클래스 이름 앞에 ~를 붙입니다.
• 실행 시점: 객체가 사라지는 순간(함수가 종료되거나 프로그램이 끝날 때) 자동으로 호출됩니다.

실행 순서 분석 (지역 객체 vs 전역 객체)

1) 지역 객체의 경우 함수 내부에서 생성된 객체는 해당 함수({ })가 끝나는 순간 소멸합니다.

    class MyClass {
    public:
        MyClass() { cout << "생성자 호출" << endl; } // (3)
        ~MyClass() { cout << "소멸자 호출" << endl; } // (5)
    };

    void testObj() {
        cout << "testObj() 함수 호출 중..." << endl; // (2)
        MyClass obj2; // 생성자 호출
        cout << "testObj() 함수 끝..." << endl; // (4)
    } // obj2 소멸자 자동 호출 시점

    int main() {
        cout << "=== main 시작 ===" << endl; // (1)
        testObj();
        cout << "=== main 종료 ===" << endl; // (6)
    }

2) 전역 객체의 경우 전역 공간에 선언된 객체는 프로그램 시작 시 가장 먼저 생성되고, 프로그램이 완전히 종료될 때 소멸합니다.

    class MyClass {
    public:
        MyClass() {
            cout << "생성자 호출" << endl;  //(1)
        }

        ~MyClass() { 
            cout << "소멸자 호출" << endl;  //(6) 
        }


    };

    MyClass obj; // 0) 전역 객체: main보다 먼저 생성!


    void testObj() {
        cout << "testObj() 함수 호출 중..." << endl; //(3)
        cout << "testObj() 함수 끝..." << endl;     //(4)
    } // obj2 소멸자 자동 호출




    int main(void) {
        cout << "=== main() 함수 시작 ===" << endl;  //(2)

        testObj(); // 객체 생성  -> 생성자는 자 동 호출 (void testObj로)

        cout << "=== main() 함수 종료 ===" << endl; //(5)
    }

2. 'this' 포인터의 비밀

컴퓨터는 내부적으로 멤버 함수를 호출할 때 "어떤 객체가 나를 불렀는지"를 알기 위해 객체의 주소를 몰래 넘겨줍니다.

• 실제 모습: void printData() → void printData(MyClass* this)
• 역할: data라고만 써도 컴퓨터는 this->data로 해석하여 호출한 객체의 데이터를 정확히 찾아갑니다.

int main() {
    MyClass a, b; // 객체 a와 b가 만들어졌어요.
    a.data = 10;
    b.data = 20;

    a.printData(); // (A) 호출
    b.printData(); // (B) 호출
}

- (A) a.printData();를 실행할 때 
컴퓨터는 a의 메모리 주소(예: 0x100)를 파악합니다.
printData 함수를 실행하면서 몰래 this = &a; 라고 주소를 넘겨줍니다.
함수 안에서 cout << data;를 만나는 순간, 컴퓨터는 this가 가리키는 a의 주소로 가서 10을 꺼내옵니다.

- (B) b.printData();를 실행할 때 (이미지의 &b 부분)
이번엔 b의 메모리 주소(예: 0x200)를 파악합니다.
똑같은 printData 함수를 쓰지만, 이번엔 몰래 this = &b; 라고 주소를 바꿔서 넘겨줍니다.
함수 안에서 this는 이제 b를 가리키므로, 20을 꺼내오게 됩니다.

3. 정보 은닉: Getter와 Setter

클래스 내부의 변수(멤버 변수)를 private에 숨겨 안전하게 보호하고, 외부에서는 정해진 함수(public)를 통해서만 접근하게 만드는 방식입니다.

• Getter (열람용): "금고 안의 데이터를 복사해서 보여만 줄게."

• Setter (설정용): "외부에서 가져온 값을 검사한 뒤 안전할 때만 넣어줄게."

    class MyClass {
    private:
        int real; // 외부 접근 불가 (금고)
  
    public:
        int getReal() { return real; } // Getter
        void setReal(int r) { real = r; } // Setter
    };

통합 예제

class MyClass {
    // 1. 외부에서 사용해야 하는 생성자와 함수는 반드시 public에 선언합니다.
public:
    // 기본 생성자
    MyClass() {
        real = 0;
        imag = 0;
    }

    // 매개변수가 있는 생성자
    MyClass(int r, int i) {
        real = r;
        imag = i;
    }

    // Getter / Setter
    int getReal() { return real; }
    void setReal(int r) { real = r; }

    int getImag() { return imag; }
    void setImag(int i) { imag = i; }

    // 2. 실제 데이터(멤버 변수)는 안전하게 private에 보관합니다.
private:
    int real;
    int imag;
};

int main(void) {
    // 객체 생성 방법 3가지
    MyClass m1;                // 기본 생성자 호출 (real=0, imag=0)
    MyClass m2 = MyClass(5, 6); // 명시적 생성
    MyClass m3(7, 8);          // 암시적 생성 (가장 많이 쓰임)

    cout << "m1: " << m1.getReal() << " + " << m1.getImag()  << endl;
    cout << "m2: " << m2.getReal() << " + " << m2.getImag()  << endl;
    cout << "m3: " << m3.getReal() << " + " << m3.getImag()  << endl;

    return 0;
}

4. 생성자 오버로딩 (Overloading)

이름은 같지만 매개변수(재료)의 개수나 타입을 다르게 하여 여러 개의 생성자를 만드는 기술입니다.

class MyClass {
public:
    // 1번 생성자: 매개변수(재료)가 0개
    MyClass() {
        real = 0; imag = 0;
    }

    // 2번 생성자: 매개변수(재료)가 2개 (int, int)
    // 이름은 1번과 똑같지만 매개변수 개수가 틀리죠? -> 오버로딩!
    MyClass(int ral, int img) {
        real = ral; imag = img;
    }
};



MyClass m1; // 이라고 쓰면 컴퓨터가 1번을 호출합니다.

MyClass m2(5, 6); //이라고 쓰면 재료가 2개니까 2번을 호출합니다.

데이터 타입이 틀린 경우 재료의 개수가 같아도 종류(타입)가 다르면 오버로딩이 됩니다.

MyClass(int a) : 정수를 받는 버전

MyClass(double a) : 실수를 받는 버전

• 컴퓨터는 함수를 찾을 때 이름만 보는 게 아니라,

• (이름 + 매개변수 구성)*을 통째로 하나의 세트로 봅니다.

• Student() 와 Student(int score) 는 이름은 같지만, 컴퓨터 입장에서는

• *"재료가 없는 버전"과 **"숫자 재료가 하나 필요한 버전"으로 확실히 구분해서 인식할 수 있습니다.

즉 "오버로딩은 이름은 하나로 통일하되, 재료(매개변수)의 '개수'나 '타입'을 다양하게 준비해서 여러 상황에 대처하는 기술이다!"

• 주의사항: 매개변수가 있는 생성자를 하나라도 직접 만들면, 컴파일러는 디폴트 생성자(매개변수 없는 것)를 자동으로 만들어주지 않습니다. 필요하다면 직접 선언해야 합니다.

class MyClass {
public:
    // 1. 내가 특별한 메뉴(매개변수 생성자)를 하나 만들었습니다.
    MyClass(int a) { 
        cout << "숫자 전달받음!" << endl; 
    }
};

int main() {
    MyClass m1; // 2. 에러 발생! "기본 메뉴(디폴트 생성자)가 없는데요?"
}

• 아무것도 안 했을 때 : (디폴트 생성자 자동 생성): 분식집에 메뉴판이 비어있으면, 주인은 손님이 올 때를 대비해 아주 기본적인 '그냥 김밥' 하나를 미리 준비해 둡니다. 그래서 우리는 아무 말 없이 "김밥 하나요!" 해도 김밥을 먹을 수 있습니다.

• 특별한 메뉴를 만들었을 때 (매개변수 생성자 선언): 우리가 메뉴판에 '참치 김밥(5,000원)'이라는 특별한 메뉴를 딱 적어 넣는 순간! 주인은 "오, 이제 이 집은 고급 참치 김밥 전문점이구나? 이제 그냥 김밥은 안 만들어야지."

• 문제가 생기는 상황: 이때 어떤 손님이 와서 그냥 "김밥 하나요!(MyClass m1;)"라고 하면, 주인님은 "우리 집엔 이제 참치 김밥밖에 없어요! 그냥 김밥은 안 팔아요!"라고 화를 냅니다. 이게 바로 에러가 나는 상황입니다.

5. 생성자 위임 (Constructor Delegation)

비슷한 초기화 코드가 중복되는 것을 방지하기 위해, 하나의 생성자가 다른 생성자를 호출하는 방식입니다.

[생성자 위임 방식 (효율적)] 초기화 리스트(:)를 사용하여 다른 생성자에게 일을 맡깁니다.

#include <iostream>
using namespace std;

class Time {
private:
    int h, m, s;

public:
    // 1. 기본 생성자: 모든 값을 0으로 초기화
    Time() : h(0), m(0), s(0) {
        cout << "기본 생성자 호출" << endl;
    }

    // 2. 생성자 위임: Time()을 먼저 불러서 0으로 세팅한 뒤 s만 변경
    Time(int s) : Time() {
        this->s = s;
        cout << "Time(int s) 호출" << endl;
    }

    // 3. 생성자 위임: Time(s)를 불러서 처리한 뒤 m만 추가로 변경
    Time(int m, int s) : Time(s) {
        this->m = m;
        cout << "Time(int m, int s) 호출" << endl;
    }

    // 4. 모든 값을 직접 받는 생성자
    Time(int h, int m, int s) : Time(m,s){
        this->h = h;
    }


};

[노가다 방식 (비효율적)] 매번 모든 변수를 일일이 대입해줘야 하므로 코드가 길어지고 실수가 생길 수 있습니다.

#include <iostream>
using namespace std;

class Time {
private:
    int h, m, s;

public:
    // 1. 기본 생성자: 모든 값을 0으로 초기화
    Time() : h(0), m(0), s(0) {
        cout << "기본 생성자 호출" << endl;
    }

    // 2. 생성자 위임: Time()을 먼저 불러서 0으로 세팅한 뒤 s만 변경
    Time(int s)  {
        h = 0;
        m = 0;
        this->s = s;
    }

    // 3. 생성자 위임: Time(s)를 불러서 처리한 뒤 m만 추가로 변경
    Time(int m, int s) {
        h=0;
        this->m = m;
        this->s = s;
    }

    // 4. 모든 값을 직접 받는 생성자
    Time(int h, int m, int s) {
        this->h = h;
        this->m = m;
        this->s = s;
    }


};

요약: 외부(main 함수 등)에서 클래스 내부의 private 영역은 직접 건드릴 수 없으므로, 생성자나 Getter/Setter라는 '공식적인 통로'를 이용해 소통해야 합니다.

C++에 처음 입문하며 가장 먼저 마주하게 되는 벽이자 핵심인 클래스(Class)와 객체(Object)에 대해 정리해 보겠습니다.

1. C에서 C++로: 변화의 시작

C언어에 익숙하다면 가장 먼저 달라지는 입출력 방식부터 손에 익혀야 합니다.

• 헤더파일: #include <stdio.h> → #include <iostream>
• 출력: printf("내용"); → cout << "내용" << endl;
• 입력: scanf("%d", &var); → cin >> var;

2. 클래스(Class)와 객체(Instance)

흔히 붕어빵에 비유하면 이해가 빠릅니다.

• 클래스(Class): 붕어빵을 만들기 위한 설계도 혹은 틀. 객체를 만들어 내는 도구입니다.
• 객체(Object/Instance): 틀에 반죽을 부어 만들어진 실제 붕어빵. 설계도를 바탕으로 메모리에 실제로 구현된 결과물입니다.

구조체 vs 클래스

• 구조체: 간단한 데이터의 묶음. 멤버 변수만 선언 가능(함수는 불가능)
• 클래스: 데이터(변수) 보호와 복잡한 기능(함수)을 포함하는 상위 개념.

3. 객체지향의 4대 핵심 원칙

1. 캡슐화 (Encapsulation) 변수(데이터)와 함수(기능)를 하나의 캡슐 안에 넣어 보호합니다. 외부에서 함부로 접근하지 못하게 '자물쇠(접근 제어자)'를 채우는 과정이 포함됩니다.

2. 추상화 (Abstraction) 내부의 복잡한 로직은 숨기고, 사용자에게 꼭 필요한 인터페이스(버튼/함수)만 노출하는 것입니다.

3. 상속 (Inheritance) 이미 만들어진 부모 클래스의 기능을 그대로 물려받아 새로운 자식 클래스를 만드는 것입니다. (예: 붕어빵 틀을 기반으로 '슈크림' 기능만 추가해 슈크림 붕어빵 틀 만들기)

4. 다형성 (Polymorphism) 이름은 같은 함수라도 객체에 따라 다르게 동작하는 성질입니다. (예: '공격' 버튼을 눌렀을 때 전사는 '칼질', 마법사는 '파이어볼')

4. 클래스 구조와 생성자(Constructor)

클래스 이름은 관례적으로 첫 글자를 대문자로 시작합니다 (예: Student).

생성자란?

객체가 생성되는 순간(태어나자마자) 자동으로 호출되는 특수한 함수입니다.

• 클래스 이름과 동일하며, 반환 타입(int, void 등)이 없습니다.

• 멤버 변수를 안전하게 초기화하는 역할을 합니다.

    class Student {
    public: // 밖에서 쓰려면 public이 필요해요!
        string name;
        int score;
  
        // 1. 기본 생성자 (매개변수가 없을 때, 객체를 초기화하는 함수) 
        Student() {
            name = "미등록";
            score = 0;
        }
  
        // 2. 매개변수가 있는 생성자 (원하는 정보를 넣을 때)
        Student(string n) {
            name = n;
            score = 0;
        }
    };
  
    // 사용 예시
    Student std1;           // 기본 생성자 호출
    Student std2("철수");    // 매개변수 생성자 호출

비유를 하면 우리가 게임 캐릭터를 새로 만들 때, 레벨은 1이어야 하고 아이템은 초보자 칼 하나는 들고 있어야 합니다. 캐릭터가 태어나자마자(메모리에 올라오자마자) 이런 기본값들을 세팅해 주는 기능이 바로 생성자입니다.

• 기본 생성자: "도시락 하나 주세요" 하면 미리 정해진 구성(제육볶음, 밥, 김치)으로 딱 나오죠? 이게 기본 생성자입니다.

• 매개변수가 있는 생성자: "제육볶음 말고 불고기 넣은 도시락으로 주세요"라고 주문하는 거예요. 내가 원하는 정보를 넣어서 객체를 만들 수 있습니다.

5. 정보 은닉과 접근 제어 지시자

객체지향의 핵심은 "데이터(변수)는 숨기고(private), 기능(함수)은 연다(public)"는 것입니다.

• private: 클래스 내부에서만 접근 가능 (데이터 보호)
• public: 클래스 외부 어디서든 접근 가능 (인터페이스)

Getter와 Setter

private으로 숨겨진 변수에 안전하게 접근하기 위해 사용하는 함수입니다.

 #include <iostream>
using namespace std; //std를 쓰지 않으면, 출력에 문제 생김

    class Tv {
    private:
        int channel; // 외부에서 직접 수정 불가!

    public:
        // Setter: 값을 검사하며 안전하게 변경
        void setChannel(int ch) {
            if (ch >= 1 && ch <= 999) {
                channel = ch;
            }
        }

        // Getter: 값을 안전하게 읽어옴
        int getChannel() {
            return channel;
        }
    };

6. 전체 코드 예시 (TV 제어)

    #include <iostream>
    using namespace std;

    class Tv {
    // 필드(멤버 변수)를 private으로 설정하여 보호!
    private:
        bool powerOn;
        int channel;
        int volume;

    public:
        // 생성자를 통한 초기화
        Tv() {
            powerOn = false;
            channel = 1;
            volume = 10;
        }

        // 외부에서 사용할 수 있는 public 기능(함수)들
        void on() { powerOn = true; }
        void off() { powerOn = false; }

        // 직접 변수를 건드리지 않고 '함수'를 통해서만 값을 바꿉니다. (Setter)
        void setChannel(int ch) {
            if (ch >= 1 && ch <= 999) channel = ch;
        }

        // 숨겨진 변수 값을 안전하게 읽어옵니다. (Getter)
        int getChannel() { return channel; }

        void setVolume(int vol) {
            if (vol >= 0 && vol <= 100) volume = vol;
        }

        int getVolume() { return volume; }

       };

    int main() {
        Tv myTv; // Tv 클래스의 인스턴스(객체) 생성

        myTv.on(); // 전원 켜기
        myTv.setChannel(5);  // 채널 설정
           myTv.setVolume(25);  // 볼륨 설정

        cout << "현재 채널은 " << myTv.getChannel() << endl;
        cout << "현재 볼륨은 " << myTv.getVolume() << endl;

        return 0;
    }

요약: 클래스는 객체를 만들기 위한 대장(설계도)이며, 캡슐화와 생성자를 통해 데이터를 안전하고 편리하게 관리하는 것이 C++ 프로그래밍의 핵심입니다!

1. DataFrame 개요

Pandas의 DataFrame은 2차원 테이블 형태의 데이터 구조입니다. Excel의 Spreadsheet이나 SQL의 Table과 매우 유사하며, 데이터 분석 및 머신러닝에서 가장 많이 활용됩니다. 2차원이기 때문에 인덱스가 row, column로 구성됩니다. row는 각 개별 데이터를, column은 개별 속성을 의미합니다. ('feature' 라고도 함)

• Series: 1차원 배열 (Column 하나)
• DataFrame: 2차원 배열 (Series의 집합)
• Index: 행(Row)을 식별하는 고유 값
• Column/Feature: 열(속성), 데이터의 특성을 의미

2. 환경 설정 및 데이터 로드

라이브러리 임포트

    import numpy as np
    import pandas as pd
    import os

데이터 불러오기 (Google Colab & CSV)

    from google.colab import drive
    drive.mount('/content/drive')

    base_path = r'/content/drive/MyDrive/dataset'
    filepath = os.path.join(base_path, 'titanic.csv') #여기서는 타이타닉 데이터 사용

    # CSV 파일을 DataFrame 객체로 읽기
    df = pd.read_csv(filepath)

출력 결과

[891 rows x 12 columns]

컬럼 의미

# 컬럼 의미
# survived - Survival (0 = No; 1 = Yes)
# class - Passenger Class (1 = 1st; 2 = 2nd; 3 = 3rd)
# name - Name
# sex - Sex
# age - Age
# sibsp - Number of Siblings/Spouses Aboard
# parch - Number of Parents/Children Aboard
# ticket - Ticket Number
# fare - Passenger Fare
# cabin - Cabin
# embarked - Port of Embarkation (C = Cherbourg; Q = Queenstown; S = Southampton)
# boat - Lifeboat (if survived)
# body - Body number (if did not survive and body was recovered)

3. 데이터 파악 (EDA 기초)

데이터 미리보기

df.head()    # 상위 5개 행 출력 (기본값 5)
df.tail(7)   # 하위 7개 행 출력

데이터 정보 및 통계 확인

    # 1. shape: (행, 열) 크기 확인
    print(df.shape)  #(891,12)

    # 2. info(): 컬럼 타입, 결측치(Non-null) 개수 확인
    df.info()

    #출력 결과 
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 891 entries, 0 to 890
    Data columns (total 12 columns):
     #   Column       Non-Null Count  Dtype  
    ---  ------       --------------  -----  
    0   PassengerId  891 non-null    int64  
    1   Survived     891 non-null    int64  
     2   Pclass       891 non-null    int64  
     3   Name         891 non-null    object 
     4   Sex          891 non-null    object 
    5   Age          714 non-null    float64
     6   SibSp        891 non-null    int64  
    7   Parch        891 non-null    int64  
     8   Ticket       891 non-null    object 
     9   Fare         891 non-null    float64
     10  Cabin        204 non-null    object 
     11  Embarked     889 non-null    object 
    dtypes: float64(2), int64(5), object(5)
    memory usage: 83.7+ KB



    # 3. describe(): 숫자형 데이터의 기술통계량 출력
    # 숫자형 데이터에 대해 기술통계량 정보
    # count, mean, std : 개수, 평균, 표준편차
    # max, min : 최대, 최소
    # 25%, 50%, 75%  : 하위 4분위 하위 2분위...

    df.describe()

4. DataFrame 생성 및 속성

리스트(List)로 생성

    df_list = pd.DataFrame([
        [1, 2, 3],
        [4, 5, 6]
    ], columns=['A', 'B', 'C'], index=['Row1', 'Row2'])

딕셔너리(Dict)로 생성

index= 없어도 생성됨! (기본 0-base index)

    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['Seoul', 'Busan', 'Incheon']
    }
    df_dict = pd.DataFrame(data)

주요 속성들

    df.index    # 인덱스 정보
    df.columns  # 컬럼명 리스트
    df.dtypes   # 컬럼별 데이터 타입 (Series 형태로 반환)
    df.size     # 전체 요소(Element) 개수
    df.ndim     # 차원 (DataFrame은 항상 2)

5. 인덱스 및 컬럼 조작

이름 변경 (Rename)

    # 특정 컬럼명만 변경
    df2 = pd.DataFrame([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
], columns = ['국어', '영어', '수학', '과학']

df2.index = ['고길동', '둘리', '마이콜']

### 인덱스 재설정 (Reset & Set)
- (inplace= 사용하면 원본 변경됨)
```python
    # 1. 기존 인덱스를 컬럼으로 보내고 새로운 숫자 인덱스 부여
    df2.reset_index(inplace=True)

    # 2. 컬럼을 index 로 내리고,  기존의 인덱스를 대체한다.
    df2.set_index('국어')

퀴즈: 인덱스와 컬럼 스와이프

   # 퀴즈: df2 의 index 와 '국어' 컬럼을 바꾸려면?

원본(df2)

df2.reset_index().set_index('국어')

6. 멀티 인덱스 (Multi-level Index)

복잡한 구조의 데이터를 표현할 때 사용합니다.

    pd.DataFrame({('k0', 'k1'): [10]})

    pd.DataFrame({('k0', 'k1'): {('a1', 'a2'): 10, ('b1', 'b2'): 40}})

df4 = pd.DataFrame(
   {
    ('k', 'k1') : [10, 20, 30, 31],
    ('k', 'k2') : [40, 50, 60, 61],
    ('j', 'j1') : [70, 80, 90, 91],
    ('j', 'j2') : [100, 110, 120, 121],
   },
   index = [['서울', '서울', '경기', '경기'], ['평일', '휴일', '평일', '휴일']]
)

데이터프레임 선택 및 필터링

Pandas의 DataFrame에서 특정 컬럼, 로우(행), 그리고 조건에 맞는 데이터를 선택하는 방법들을 정리합니다.

1. 하나의 컬럼 선택

컬럼명을 직접 지정하거나 속성(Attribute) 방식을 사용할 수 있습니다.

• df['Survived']: Series 형태로 반환

• df.Survived: 속성 방식 (컬럼명에 공백이 없을 때 가능)

• df.Age: 나이 컬럼 선택

2. 복수의 컬럼 선택하기

리스트 형태로 컬럼명을 전달하면 DataFrame 형태로 반환됩니다.

• df[['Survived']]: 대괄호를 두 번 쓰면 결과는 DataFrame이다.

• df[['Survived', 'Age', 'Name']]: 여러 컬럼을 한꺼번에 선택 가능하며, 순서 변경이나 중복 선택도 가능하다.

3. Row(행) 선택하기: loc[], iloc[]

DataFrame은 기본적으로 []를 컬럼 선택에 사용하므로, 행 선택을 위해서는 전용 속성이 필요합니다.

예제

3.1 loc (Label-based)

인덱스 자체(이름)를 사용하여 선택합니다.

• df.loc[986]: 해당 인덱스의 데이터를 Series로 반환

• df.loc[[986]]: 해당 인덱스의 데이터를 DataFrame으로 반환

3.2 iloc (Integer-based)

0부터 시작하는 순서(Position)를 기준으로 선택합니다. (0 based index)

• df.iloc[0]: 0번 인덱스가 아니라, '첫 번째' 행을 의미 (Series)

• df.iloc[[0, 100, 200, 2]]: 0, 100, 200, 2번째 행을 DataFrame으로 반환

4. Row와 Column 동시에 선택하기

loc와 iloc에 콤마(,)를 사용하여 행과 열을 동시에 지정할 수 있습니다. 예제

    #loc[row, column] <- loc[axis0, axis1]
    `df.loc[986, 'Survived']`: 특정 인덱스의 특정 컬럼 값 선택

    #출력 결과
    np.int64(0)


    df.iloc[-5, -3] # 뒤에서 5번째 행(986), 뒤에서 3번째 열(Fare) 선택

    #출력 결과
    np.float64(13.0)

예제2

    df.loc[102, 'Name']

    #출력 결과
    Heikkinen, Miss. Laina


    df.iloc[2, 3]

    #출력 결과
    Heikkinen, Miss. Laina  #동일하다!!!


      df.loc[[986, 100, 110, 990], ['Survived', 'Name', 'Sex', 'Age']]
    #출력 결과

참고: 체이닝(Chaining) 방식 df['Name'][102] 또는 df.loc[102]['Name'] 처럼 연속해서 인덱싱하는 것도 가능하지만, 가급적 loc[row, col] 방식을 권장합니다.

5. Boolean Selection으로 Row 선택하기

조건문(Mask)을 이용하여 특정 조건에 맞는 데이터만 추출합니다.

5.1 데이터 탐색 (Value Check)

Pclass는 객실의 등급입니다.

• df.Pclass.unique(): 클래스의 종류 확인 (1, 2, 3)

  # 출력 결과 : array([3, 1, 2])

  
  

• df.Pclass.value_counts(): 클래스별 데이터 개수 확인

  # 출력 결과 : 

  Pclass	Count
  3등급 (3)	491명
  1등급 (1)	216명
  2등급 (2)	184명

5.2 조건 필터링 (Masking)

조건을 변수에 담아 가독성을 높일 수 있습니다.

    # 1등석 승객만 필터링
    pclass_mask = df['Pclass'] == 1
    df[pclass_mask]

    #출력 결과 :

    # 30대 승객 필터링
    age_mask = (df.Age >= 30) & (df.Age < 40)
    df[age_mask]

    #출력 결과 :

    # 다중 조건 (AND 연산자 '&' 사용)
    # 1등석이면서 30대인 승객
    df[pclass_mask & age_mask]

    #출력 결과 :

    # 다중 조건 (AND 연산자 '&' 사용)
    # 1등석이면서 30대인 승객의 클래스와 나이 컬럼만 확인
    df[pclass_mask & age_mask][['Pclass', 'Age']]

    #출력 결과 :

퀴즈

    3등급 객실의 생존자 수는? 


    # 정답 코드
    pclass_mask = df['Pclass'] == 3
    Survived_mask = df['Survived'] == 1

    len(df[pclass_mask & Survived_mask])  #119

Pandas는 행(row)과 열(column) 형태의 '정형 데이터'를 다루는 대표적인 Python 라이브러리입니다. 엑셀 시트나 RDB의 테이블과 유사한 2차원 구조를 다루며, 그 기본이 되는 객체가 바로 Series와 DataFrame입니다.

1. Series란?

• Pandas의 가장 기본적인 객체 중 하나입니다.
• Numpy의 ndarray를 기반으로 하며, 인덱싱 기능이 추가된 1차원 배열입니다.
• index x value의 형태를 가집니다.
• 같은 타입의 데이터를 0개 이상 가질 수 있습니다.

2. Series 생성 및 기초 속성

기본 생성 (0-based Index)

데이터만 전달하면 인덱스는 0부터 자동으로 부여됩니다.

import numpy as np
import pandas as pd  #pandas를 위해 필수 #pandas를 위해 필수

s1 = pd.Series([10, 20, 30])
print(s1)

# 결과: 왼쪽이(0,1,2) index,
# 오른쪽이(10,20,30) value, 
# dtype은 데이터 타입

# 주요 속성 확인
s1.values  # 값 확인 (ndarray)
# array([10, 20, 30])

s1.index   # 인덱스 범위/구성 확인
# RangeIndex(start=0, stop=3, step=1)

s1.dtype   # 데이터 타입 확인
dtype('int64')

명시적 인덱스 설정

인덱스는 숫자일 필요가 없으며 중복도 허용됩니다.

# 숫자 인덱스 지정
pd.Series(data=[1, 2, 3], index=[100, 200, 300])

# 출력결과

# 인덱싱
s5['john'] # np.int64(1)

# 인덱스 중복 허용
s6 = pd.Series([1, 2, 3], ['john', 'john', 'charlie'])

# 중복 indexing 결과 Series!!
s6['john']

3. 딕셔너리(dict)를 이용한 생성

딕셔너리의 Key는 Index가 되고, Value는 데이터 값이 됩니다.

sdata = {'김철수': 35000, '이상현': 67000, '최종수': 12000, '박진관': 4000}
pd.Series(sdata)

4. 인덱싱과 값 변경

s7 = pd.Series(data=np.arange(5), index=np.arange(100, 105), dtype=np.int16)

# 단일 값 접근 (Scalar 반환)
s7[102] #np.int16(2)

# 여러 값 접근 (Series 반환) 1차원 (차원 변화 없슴.)
s7[[102, 104]] 

# 값 변경 및 신규 삽입
s7[104] = 70  # 기존 값 변경
s7

s7[105] = 90  # 기존에 없던 인덱스에 값을 대입 시 새로 생성 (Numpy와 차별점)

5. 주요 함수 및 통계 (NaN 처리)

Pandas의 집계 연산은 NaN(결측치)을 제외하고 계산하는 특징이 있습니다.

• size: 전체 개수 반환
• shape: 튜플 형태로 형태 반환
• unique(): 유일한 값들을 ndarray로 반환
• count(): NaN을 제외한 데이터 개수
• mean(): NaN을 제외한 평균!!
• value_counts(): 각 값들의 빈도수 반환 (NaN 제외)

[예시: Numpy vs Pandas의 NaN 처리]

a1 = np.array([2, 2, 2, 2, np.nan])

print(a1.mean())          # 결과: nan (연산 불가)

print(pd.Series(a1).mean()) # 결과: 2.0 (nan 무시)

6. Series 연산

Series끼리의 연산은 순서가 아닌 같은 인덱스를 기준으로 수행됩니다.

s1 = pd.Series([1, 2, 3, 4], ['a', 'b', 'c', 'd'])

s2 = pd.Series([6, 3, 2, 1], ['d', 'c', 'b', 'a'])

print(s1 + s2) # 'a'는 'a'끼리, 'b'는 'b'끼리 연산
# 인덱스 쌍이 맞지 않으면 결과는 NaN으로 채워집니다.

7. Boolean Selection (필터링)

조건식을 [] 안에 넣어 원하는 데이터만 추출할 수 있습니다.

s = pd.Series(np.arange(10), np.arange(10) + 1)

s > 5 # 조건에 맞으면 True, 틀리면 False

8. 데이터 삭제: drop() 및 inplace

• 대부분의 Pandas 함수는 원본을 건드리지 않고 사본을 반환합니다. drop() 함수는 drop 한결과 를 새로 만들어서 리턴한거고 원본 데이터 s 는 변경하지 않습니다

• numpy , pandas, 그밖의 수많은 데이터 관련 모듈들 에서의 대부분의 객체 함수들은 호출한 원본 객체를 변경하진 않고 원본의 사본을 만든뒤 사본 에 연산수행하여 그 사본 을 리턴하도록 동작합니다 그러나!

• inplace=True 파라미터를 주면 사본 을 만들지 않고 원본을 변화시키도록 동작합니다

s = pd.Series(np.arange(100, 105), ['a', 'b', 'c', 'd', 'e'])

# 삭제된 '사본' 리턴 (원본 유지)
s.drop('a') 



# 원본을 직접 변경하고 싶을 때(중요)
s.drop('b', inplace=True) 

9. Multi-level Index (다중 인덱스)

계층적인 인덱스 구조를 가질 수 있습니다.

s3 = pd.Series([1, 2, 3, 4, 5, 6], ['a', 'a', 'b', 'b', 'c', 'c'])
s3.index  #Index(['a', 'a', 'b', 'b', 'c', 'c'], dtype='object')

# ↑ 단일 level index 다!


# multi-level index 를 가진 Series
s4 = pd.Series(
    np.arange(100, 106),
    index = [
        ['a', 'a', 'b', 'b', 'c', 'c'], # Level 0
        [ 1 ,  2 ,  1,   2 ,  1,   2 ], # Level 1
    ]
)

# 인덱스
s4.index #MultiIndex([('a', 1),
                     #('a', 2),
                     #('b', 1),
                     #('b', 2),
                     #('c', 1),
                     #('c', 2)],
                        #)

#인덱싱 방법
s4['a', 1]     # 튜플 형태 접근  #np.int64(100)

s4.xs('a')     # 특정 레벨 추출 (Cross-section)

s4.xs(('a', 1))  # () 괄호 꼭 필요!   # s4['a', 1] 과 동일

# s4.xs(2)  # 에러, level 0 에서 2 라는 index? 없다!
s4.xs(2, level=1) # 특정 레벨의 값 기준 추출

10. apply()와 rename()

Pandas의 apply()는 데이터 전처리 시 가장 빈번하게 사용하는 함수 중 하나입니다. 각 원소에 복잡한 로직을 적용하거나 문자열을 가공할 때 매우 유용합니다.

Series.apply(func, convert_dtype=True, args=(), **kwargs)

다양한 apply() 활용 사례

단순 연산부터 인자 전달, 문자열 처리까지의 예제입니다.

    import pandas as pd
    import numpy as np

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

    # [사례 1] 람다(lambda)를 이용한 제곱 연산
    result_sq = s.apply(lambda x: x ** 2)

    # [사례 2] 사용자 정의 함수로 문자열 포맷팅
    def custom_func(x):
        return f"Value: {x}"
    result_custom = s.apply(custom_func)

    # [사례 3] args를 통한 추가 인자(factor) 전달
    def multiply(x, factor):
        return x * factor
    result_mult = s.apply(multiply, args=(10,))

    # [사례 4] 문자열 공백 제거 및 소문자 변환
    s2 = pd.Series(["  Apple ", "Banana", " Cherry "])
    result_str = s2.apply(lambda x: x.strip().lower())


   #[사례 1]출력 결과 
    0     1
    1     4
    2     9
    3    16
    4    25
    dtype: int64

    #[사례 2]출력 결과 
    0    Value: 1
    1    Value: 2
    2    Value: 3
    3    Value: 4
    4    Value: 5
    dtype: object

    #[사례 3]출력 결과 
    0    10
    1    20
    2    30
    3    40
    4    50
    dtype: int64

    #[사례 4]출력 결과 
    0     apple
    1    banana
    2    cherry
    dtype: object

📊 주요 실행 결과 (표)

rename()을 이용한 인덱스 변경

Series의 특정 인덱스 이름을 바꾸고 싶을 때는 rename() 메서드를 사용합니다. 딕셔너리 형태({기존: 변경})로 전달하면 원하는 인덱스만 콕 집어 바꿀 수 있습니다.

    # 인덱스 1번을 'haha'로 변경
    s2_renamed = s2.rename(index={1: 'haha'})

    print(s2_renamed)

📊 인덱스 변경 결과 (s2.rename)

💡 핵심 정리

1. apply(args=...): 함수에 고정된 상수값을 전달해야 할 때 args 파이썬 튜플을 사용합니다.
2. Method Chaining: s2.apply(lambda x: x.strip()).apply(lambda x: x.lower()) 처럼 여러 번 이어서 사용할 수도 있습니다.
3. Immutability: rename이나 apply 모두 원본을 바로 바꾸지 않고 새로운 객체를 반환합니다. 원본을 바꾸려면 다시 할당(s2 = s2.rename(...))해야 합니다.

Numpy는 수치적 연산을 위해 최적화된 파이썬 모듈로, 데이터 분석과 머신러닝의 가장 기본이 되는 라이브러리입니다. Pandas, Scikit-learn 등 수많은 라이브러리가 Numpy를 기반으로 구현되어 있습니다.

1. Numpy를 사용하는 이유

1. 성능: 파이썬 리스트보다 훨씬 빠릅니다.
2. 메모리: 적은 메모리를 효율적으로 사용합니다.
3. 기능: 선형대수, 통계 등 풍부한 수치 함수를 제공합니다.
4. 표준: 데이터 과학 생태계의 공용어와 같습니다.

차원

Scalar : 0차원 array (단일값)

Vector : 1차원 array

Matrix : 2차원 array

Tensor : 3차원(이상) array

2. ndarray의 기본 속성

Numpy의 핵심 타입은 ndarray (n-dimensional array)입니다. 모든 원소는 단일 타입으로 정의됩니다. (리스트는 원소타입이 각각 다르다)

    import numpy as np #핵심

    #생성
    arr1 = np.array([1, 2, 3, 4, 5])

    # 주요 속성 확인
    arr1.shape  # (5,) -> 1차원, 크기 5
    arr1.ndim   # 1 (차원 수)    # len(arr1.shape)로 써도 된다. 
    arr1.size   # 5 (전체 원소 개수)
    arr1.dtype  # dtype('int64') (데이터 타입)



    # 2차원 array 생성
    arr2=np.array([[2,3,4],[1,2,4]])

    arr2.shape #(2,3)
    #숫자 2개==2차원, 
    #차원의 크기는 2*3=6, 
    #크기가 3짜리 1차원 배열이 2개가 있다는 뜻


    # 1차원 배열의 원소는 스칼라값 (0차원)
    len(arr1) #5

    # 2차원 배열의 원소는 1차원 배열
    len(arr2)  #2    #1차원 배열의 개수는 2개

데이터 타입 (dtype)

타입이 섞여 있을 경우, 더 큰 범위를 포함하는 타입(예: 정수와 실수가 섞이면 실수형)으로 통일됩니다.

• int: 정수
• float: 실수
• bool: 불리언
• object: 파이썬 객체

자료형의 종료

(자료형 뒤에 붙는 숫자는 몇 비트 크기인지를 의미한다.)

• 부호가 있는 정수 int(8, 16, 32, 64)
• 부호가 없는 정수 uint(8 ,16, 32, 64)
• 실수 float(16, 32, 64, 128)
• 복소수 complex(64, 128, 256)
• 불리언 bool
• 문자열 string_
• 파이썬 오프젝트 object
• 유니코드 unicode_

3. 배열 생성 및 차원 변경

생성 함수

• np.arange(start, stop, step): 범위 내 배열 생성 (range와 사용법 유사)
• np.zeros(shape): 0으로 채워진 배열
• np.ones(shape): 1로 채워진 배열
• np.full(shape, fill_value): 특정 값으로 채우기
• np.eye(N): 주대각선만 1이고 나머지는 0 인 N x N 단위 행렬

np.arange(10)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.arange(1,10,2)
# array([1, 3, 5, 7, 9])

np.arange(10,0)
# array([], dtype=int64) 빈 배열

np.arange(10,0,-1)
# array([10,  9,  8,  7,  6,  5,  4,  3,  2,  1])

np.arange(1,10,dtype=np.int16)
# array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int16)

# N x N 단위 행렬
np.eye(5,dtype=np.int16)
"""array([[1, 0, 0, 0, 0],
            [0, 1, 0, 0, 0],
             [0, 0, 1, 0, 0],
             [0, 0, 0, 1, 0],
             [0, 0, 0, 0, 1]], dtype=int16)"""

shape(차원) 변경하기

차원변환은 데이터분석 과 인공지능에서 매우 빈번하게 발생되는 작업이니만큼 자유자재로 변환할수 있어야 하고, 머리속으로 내가 변환하는 데이터의 구조가 그려지도록 익숙해져야 합니다

EX) 이미지 데이터 벡터화 - 이미지는 기본적으로 2차원 혹은 3차원(RGB)이나 트레이닝을 위해 1차원으로 변경하여 사용됩니다.

ravel(), flatten() 예시

import numpy as np
a = np.array([[1, 2], 
              [3, 4]])

# C-style (Row-major): 가로 방향으로 읽으며 펼침 (기본값)
# 결과: [1, 2, 3, 4]
print(a.ravel(order='C')) 

# F-style (Column-major): 세로 방향으로 읽으며 펼침
# 결과: [1, 3, 2, 4]
print(a.ravel(order='F'))

reshape함수 예시

• 원소의 총 개수(size)가 유지되어야 변환이 가능합니다.
• -1을 사용하면 나머지 차원을 자동으로 계산합니다.

np.arange(12).reshape(2,6) #2차원 배열, 원소 6개씩
#array([[ 0,  1,  2,  3,  4,  5],
           #[ 6,  7,  8,  9, 10, 11]])

x.reshape(2, -1)   # (2, 6) 자동 계산

np.arange(12).reshape(3,2,2) 
# 전체 12개를 먼저 3개의 큰 덩어리로 나누고, 그 각 덩어리를 다시 2행 2열짜리 표로 만든 것 

#array([[[ 0,  1],
     #   [ 2,  3]],

     #  [[ 4,  5],
     #   [ 6,  7]],

     #  [[ 8,  9],
     #   [10, 11]]])

차원 확장 (Expansion)

(1) reshape() 사용

가장 기본적인 방법으로, 전체 요소의 개수만 맞으면 자유롭게 확장 가능합니다.

    import numpy as np
    x3 = np.arange(6)  # (6,)

    # (6,) => (6, 1) 로 차원 확장
    x3 = x3.reshape(6, 1)  #덮어쓰기를 해야지 적용된다!!!!

    # (6, 1) => (6, 1, 1) 로 추가 확장
    x3 = x3.reshape(6, 1, 1)

(2) np.expand_dims() 사용

특정 축(axis)을 지정하여 그 자리에 차원을 '삽입'합니다.

    x5 = np.arange(3)  # (3,)

    # axis=0: 맨 앞에 차원 추가 (3,) -> (1, 3)
    y5 = np.expand_dims(x5, axis=0)

    x6 = np.arange(4).reshape(2, 2)

    # axis=-1: 마지막에 차원 추가 (2, 2) -> (2, 2, 1)
    y7 = np.expand_dims(x6, axis=-1)

    # 여러 축에 동시 추가 가능: (2, 2) -> (1, 2, 2, 1)
    y8 = np.expand_dims(x6, axis=(0, -1))

(3) np.newaxis 활용 (Indexing)

슬라이싱 연산 중에 직관적으로 차원을 늘릴 수 있어 실무에서 매우 선호되는 방식입니다.

    x8 = np.array([2, 0, 1, 8])  # (4,)

    # 1차원 벡터를 행 벡터(Row Vector)로 변환: (4,) -> (1, 4)
    row_vec = x8[np.newaxis, :]

    # 1차원 벡터를 열 벡터(Column Vector)로 변환: (4,) -> (4, 1)
    col_vec = x8[:, np.newaxis]

차원 제거 (Reduction)

(1) np.squeeze()

차원 중 사이즈가 1인 것들을 모두 찾아 제거합니다. 데이터의 본질적인 값은 유지하면서 불필요한 껍데기(차원)를 벗겨냅니다.

    # (2, 1, 3, 1) 구조의 배열 생성
    x4 = np.arange(6).reshape((2, 1, 3, 1))

    # 사이즈가 1인 차원을 모두 제거: (2, 1, 3, 1) -> (2, 3)
    squeezed_x4 = x4.squeeze()

(2) 특정 차원만 제거하기

squeeze()의 axis 파라미터를 사용하면 사이즈가 1인 차원이 여러 개일 때 원하는 것만 골라 제거할 수 있습니다.

    # x4.squeeze(axis=1) -> (2, 3, 1)

4. 축(axis)의 이해

Numpy 연산에서 axis 파라미터는 매우 중요합니다. axis (축) 은 각 '차원' 을 의미합니다. axis= 값을 명시하면 그 함수의 연산 은 해당 axis(축) 에 '따라서' 연산을 수행함

• 1차원 array 라면 각 차원에 대한 axis 값은 0 <- 1개 입니다.
• 2차원 array 라면 각 차원에 대한 axis 값은 0, 1 <- 2개 입니다.
• 3차원 array 라면 각 차원에 대한 axis 값은 0, 1, 2 <- 3개 입니다.

axis=0: 행을 따라 연산 (세로로 더하기) axis=1: 열을 따라 연산 (가로로 더하기)

x1 = np.arange(15)

np.sum(x1) #np.int64(105) np.sum(x1,axis=None) #np.int64(105)

x2 = x1.reshape(3, 5) #array([[ 0, 1, 2, 3, 4],

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14]])

np.sum(x2) # axis=None, 105

np.sum(x2, axis=0) #행끼리 연산 (3,5) => (5,) axis=0인 3을 제거한 것 #array([15, 18, 21, 24, 27]) 행이 사라지고 열의 형태만 남음

np.sum(x2, axis=1) #(3,5) => (3,) 얘는 1인 5를 제거한 것 #array([10, 35, 60]) 열(세로)이 사라지고 행(가로)의 형태만 남음

---







## 5. 인덱싱과 슬라이싱

### 인덱싱(index)
 - 파이썬 리스트와 동일한 개념으로 사용합니다.
 - tuple 를 사용하여 각 차원별 인덱스에 접근 가능합니다. 
 - 인덱싱 할때마다 차원감소됩니다. 


```python
 y = np.arange(10).reshape(2, 5) # 2차원
#array([[0, 1, 2, 3, 4],
        #[5, 6, 7, 8, 9]])

#출력 결과
y[0]
#array([0, 1, 2, 3, 4]) 1차원으로 차원감소

y[0][2]
# np.int64(2) scarler 값으로 차원 감소 

# 콤마(튜플)로 차원별 인덱싱 가능!  numpy 에선 후자의 방법을 추천!(중요)
y[0,2] #위와 결과가 같음. 
# np.int64(2) scarler 값으로 차원 감소 

슬라이싱 (Slicing)

리스트와 달리 다차원에서 콤마(,)를 이용한 동시 슬라이싱이 가능하며, 슬라이싱 결과는 차원을 유지합니다.

y = [[0, 1, 2, 3, 4],
     [5, 6, 7, 8, 9],
     [10, 11, 12, 13, 14]]


# 과연 아래와 같이 slicing 가능한가?
# [[1, 2, 3],
#  [6, 7, 8]]    


y[:2][1:4] #안된다
# ↑ list 는 차원별 slicing 이 불가능하다!    
# 출력 결과 : [[5, 6, 7, 8, 9]]

# ↓ Numpy Array 는 차원별 slicing 가능하다!
x = np.arange(15).reshape(3, 5)
x

#이렇게가 아니라
x[:2][1:4]    #출력 결과 : array([[5, 6, 7, 8, 9]])

#이렇게!
x[:2, 1:4]    #출력 결과 : array([[1, 2, 3],
                                #[6, 7, 8]])


x[2, 1:4]     #출력 결과 : array([11, 12, 13])

배열의 축 바꾸기 (T, transpose, swapaxes)

데이터의 행과 열을 바꾸거나, 고차원 텐서의 차원 순서를 변경하는 방법을 정리합니다.

2차원 배열의 전치 (Transpose)

가장 기본적으로 행과 열을 서로 맞바꾸는 동작입니다.

    import numpy as np
    a = np.arange(15).reshape(3, 5) # (3, 5)

    # 방법 1: np.transpose()
    np.transpose(a) # (5, 3)

    # 방법 2: .T 속성 (가장 많이 사용됨)
    a.T 

    # 방법 3: swapaxes() - 0번 축과 1번 축을 교환
    np.swapaxes(a, 0, 1)

2. 고차원 배열에서의 축 변경

3차원 이상의 배열에서는 단순히 뒤집는 것보다 특정 축의 순서를 지정하는 것이 중요합니다.

(1) np.transpose(array, axes)

축의 순서를 리스트나 튜플로 지정합니다. 지정하지 않으면 역순으로 바뀝니다.

    # (2, 3, 5) -> 축 번호는 (0, 1, 2)
    b = np.random.randn(2, 3, 5)

    # 0번과 1번의 위치를 바꾸고 싶을 때
    b_trans = b.transpose(1, 0, 2) # 결과 shape: (3, 2, 5)

### (2) np.swapaxes(array, axis1, axis2)
전체 순서를 고민할 필요 없이, **바꾸고 싶은 두 개의 축**만 딱 집어서 교환합니다.

    # 0번 축과 2번 축을 교환
    b_swapped = np.swapaxes(b, 0, 2) # 결과 shape: (5, 3, 2)

요약

• .T: 2차원 행렬 뒤집기용 (간편함)
• transpose(): 전체 축 순서를 재설정할 때 (강력함)
• swapaxes(): 두 축의 위치만 가볍게 바꿀 때 (명확함)

6. Array 연산의 기초: List와의 차이 및 브로드캐스팅

파이썬 기본 리스트(List)와 넘파이 배열(Array)의 연산 방식 차이를 이해하고, 넘파이만의 강력한 기능인 브로드캐스팅을 정리합니다.

파이썬 리스트(List)의 연산

리스트에서의 연산은 산술 계산이 아니라 '데이터의 변형(반복, 연결)'을 의미합니다.

    a = [10, 20, 30, 40]
    b = 2
    c = [100, 200, 300, 400]

    # 리스트 * 숫자 : 리스트 내용 반복
    print(a * 2)  # [10, 20, 30, 40, 10, 20, 30, 40]

    # 리스트 + 숫자 : TypeError 발생
    # a + b

    # 리스트 + 리스트 : 두 리스트를 하나로 연결
    print(a + c)  # [10, 20, 30, 40, 100, 200, 300, 400]

넘파이 배열(Array)의 연산

배열의 연산은 기본적으로 원소끼리(Element-wise) 수행됩니다. 수학적 행렬/벡터 연산과 동일하게 동작합니다.

    import numpy as np
    x = np.array([1, 2, 3])
    y = np.array([10, 20, 30])

    # 원소별 더하기/빼기
    print(x + y)  # [11, 22, 33]
    print(x - y)  # [-9, -18, -27]

브로드캐스팅 (Broadcasting)

• (기본적으로는) Shape이 같은 두 ndarray에 대한 연산은 각 원소별로 진행합니다.

• 다른 Shape을 갖는 array 간 연산 의 경우 브로드 캐스팅(Shape을 맞춤) 후 진행합니다.

  (1) Array와 스칼라(Scalar) 연산

  배열의 모든 원소에 동일한 값을 한 번에 적용합니다.

  # 모든 원소에 10을 더함
  print(x + 10)  # [11, 12, 13]

  (2) 단일 값을 가진 객체와의 연산

  대괄호([])의 개수에 따라 연산 후 결과물의 차원(Shape)이 결정됩니다.

  # x + [10] : 1차원 벡터 간의 연산으로 간주
  # [1, 2, 3] + [10, 10, 10]
  print(x + [10])  # [11, 12, 13] (1차원)
  
  # x + [[10]] : 2차원 행렬과의 연산으로 간주 (브로드캐스팅)
  # x는 (3,)에서 (1, 3)으로 확장되고, [[10]]은 (1, 3)으로 확장됨
  # 결과는 [[11, 12, 13]] (2차원)
  print(x + [[10]]) 
  
  a = np.arange(12).reshape(4, 3)
  b = np.arange(100, 103) # (3,)
  a + b # b가 모든 행에 더해짐
  
   #출력 결과
   array([[100, 102, 104],
           [103, 105, 107],
           [106, 108, 110],
        [109, 111, 113]])  
  
  

---

## 요약 및 결론

* **List**: `+`는 연결, `*`는 반복을 의미하며 숫자와의 직접 더하기는 불가능합니다.
* **Array**: 모든 산술 연산이 **원소 단위**로 이루어집니다.
* **Broadcasting**: `[[10]]`처럼 고차원 단일 값과 연산하면, 결과 배열도 해당 **고차원 형태**를 따라갑니다.





---

## 7. 불리언 인덱싱 (Boolean Indexing) ★중요
조건에 맞는 데이터만 추출하는 강력한 기능입니다.
array 인덱싱 시, bool 리스트(aka. mask)를 전달하여 True인 경우만 필터링 합니다. 
for 사용하지 않고도 array 에서 '조건'에 맞는 데이터만 추출 하는 기능
```python
    # 브로드캐스팅을 활용하여 array로 부터 bool list 얻기
    #  - 예) 짝수인 경우만 찾아보기

    np.random.seed(41)
    x = np.random.randint(1, 100, size=10)

    even_mask = x % 2 ==0
    # 위와 같이 bool 값으로 이루어진 array 를 Mask 라고도 한다

    print(even_mask) # True, False들로 구성. 
    # x[[True,True,True,True,False,False,False,False,False,True]]

    x[even_mask]  #True 값들만 출력


    x = np.random.randint(1, 100, 10)
    # 30보다 큰 짝수만 추출
    mask = (x > 30) & (x % 2 == 0) #이때 and는 사용(x), &만 사용 가능
    x[mask]

8. 실습 예제: 서울시 5월 기온 분석

temp = np.array([23.9, 24.4, 24.1, 25.4, 27.6, 29.7, 26.7, 25.1, 25.0, 22.7, 21.9, 23.6, 24.9, 25.9, 23.8, 24.7, 25.6, 26.9, 28.6, 28.0, 25.1, 26.7, 28.1, 26.5, 26.3, 25.9, 28.4, 26.1, 27.5, 28.1, 25.8])

# Q1. 평균기온이 25도를 넘는 날의 수는?
over_25 = temp[temp > 25]
print(len(over_25))

# Q2. 평균기온이 25도를 넘는 날의 평균기온은?
print(f"{over_25.mean():.1f}도")

9. np.random 서브 모듈

• rand: 0부터 1사이의 균일 분포 [0, 1) uniform distribution
• randn: 가우시안 표준 정규 분포 (평균0, 표준편차1 인 종모양 분포) normal distribution
• randint: 균일 분포의 정수 난수
• seed: 램덤 시드값. 고정 난수값 생성

np.random.rand(10) #0부터 1까지 랜덤 숫자 생성


np.random.rand(2,3) #값 3개 가진 이중 배열

np.random.randn(5) #정규분포를 가진 5개 랜덤 숫자 생성


np.random.randint(5) # 0 ~ 4 사이의 정수 난수 [0, 5) 1개 생성

np.random.randint(1,10) #[1,10) # 1 ~ 9 사이의 정수 난수 1개 생성

np.random.randint(1,100,(3,5,2)) #3중 배열로 2중 배열 3개, 각 2중 배열에 1차원 배열 5개씩 생성

# seed() : 난수를 예측가능하도록 만든다.  실행할때마다 동일한 난수가 발생되도록 함.
np.random.seed(0) #이걸 사용하는 다른 컴퓨터도 동일한 결과를 내놓게 함.
np.random.rand(4)


#  비결정적 연산 (Non-Deterministic Operations)
#    같은 코드, 같은 입력을 줬는데도 결과가 매번 조금씩 달라지는 연산

#  결정적 연산 (Deterministic Operations)
#    같은 코드, 같은 입력, 같은 시드를 주면 결과가 동일한 연산

10. 통계 함수와 NaN(Not a Number)

배열에서 최댓값과 그 위치를 찾는 방법, 그리고 데이터 분석의 필수 관문인 결측치(NaN)의 특징을 정리합니다.

최댓값 찾기: max()와 argmax()

넘파이에서는 단순히 최댓값을 찾는 것뿐만 아니라, 그 값이 어디에 위치해 있는지도 쉽게 알 수 있습니다.

(1) 전체 대상 연산

별도의 축 지정이 없으면 배열을 1차원으로 펼쳤을 때를 기준으로 계산합니다.

    import numpy as np
    y = np.array([[0, 1, 2, 3, 4],
                  [5, 6, 7, 8, 9],
                  [10, 11, 12, 13, 14]])

    # 전체 최댓값
    np.max(y) # 14

    # 전체 최댓값의 인덱스 (펼쳤을 때의 번호)
    np.argmax(y) # 14

(2) 축(axis)별 연산

특정 방향(행 또는 열)을 기준으로 최댓값을 찾습니다.

    # axis=0 (열 방향): 위에서 아래로 훑으며 최댓값 찾기
    # 결과 모양: (3, 5) -> (5,)
    np.max(y, axis=0) # [10, 11, 12, 13, 14]

    # 열 방향 최댓값의 인덱스
    np.argmax(y, axis=0) # [2, 2, 2, 2, 2] (모두 마지막 행에 있음)

결측치 처리: NaN (Not a Number)

NaN은 정의되지 않거나 표현할 수 없는 수치 결과를 의미하며, 실무 데이터(누락값, DBMS의 null 등)에서 매우 자주 마주하게 됩니다.

(1) NaN의 특징

NaN은 수치형 데이터 타입(float)이지만, 어떤 연산을 해도 결과는 NaN이 된다는 치명적인 특징이 있습니다.

    np.nan  # nan

    # NaN과의 연산 결과는 무조건 NaN
    print(np.nan + 10) # nan

    arr = np.array([10, 20, np.nan])
    print(np.sum(arr)) # nan (하나만 섞여 있어도 결과가 파괴됨)

(2) NaN 판별하기: isnan()

NaN은 일반적인 비교 연산자(==)로 확인할 수 없으므로, 반드시 전용 함수를 사용해야 합니다.

    # 100은 숫자인가? (False)
    np.isnan(100) # False

    # np.nan은 NaN인가? (True)
    np.isnan(np.nan) # True

    # math 라이브러리에서도 동일하게 제공
    import math
    math.isnan(np.nan) # True

요약 및 주의사항

• 데이터 분석의 필수: 원본 데이터에 NaN이 포함되어 있다면 통계값(평균, 합계 등)이 왜곡될 수 있으므로, 연산 전에 반드시 제거하거나 다른 값(0이나 평균값 등)으로 치환해야 합니다.
• 차원 축소: max(axis=0)을 하면 해당 축이 사라지며 차원이 축소됩니다. (3x5 배열이 5개짜리 1차원 배열로 변함)

팁: NaN을 무시하고 계산하고 싶다면?

넘파이에는 NaN을 제외하고 계산해주는 nan-safe 함수들이 별도로 존재합니다.

• np.nansum(arr): NaN을 0으로 간주하고 합계 계산
• np.nanmax(arr): NaN을 제외한 최댓값 계산

변수명, 함수명, 클래스명 등 이름(name)이 사용될 수 있는 영역을 Scope라고 합니다. 즉, 변수가 살아있는 범위와 이를 어디에서 사용할 수 있는지에 대한 규칙입니다.

1. Global Variable & Global Scope (전역 변수)

함수 바깥에서 선언한 변수로, 스크립트 전체에서 접근할 수 있습니다.

    x = 10  # 전역 변수

    def foo():
        print(x)  # 함수 안에서도 전역변수 '읽기' 동작 가능

    foo()
    print(x)

2. Local Variable & Local Scope (지역 변수)

함수 안에서 선언된 변수는 해당 함수 내부에서만 접근 가능하며, 함수 종료(리턴)와 함께 소멸합니다.

    def foo():
        y = 10  # y는 foo의 지역변수
        print(y)

    foo()
    # print(y)  # 에러 발생: 함수 밖에서는 지역 변수에 접근 불가

3. 함수 안에서 전역 변수 수정하기 (쓰기 동작)

함수 내에서 전역 변수와 동일한 이름에 값을 대입하면, 파이썬은 이를 새로운 지역 변수로 간주합니다.

    z = 10

    def foo():
        z = 20  # z는 foo의 지역변수로 새로 생성됨 (쓰기 동작)
        print(z) # 지역변수 z(20) 출력

    foo()    # 20
    print(z) # 10 (전역 변수는 변하지 않음)

※ 주의: UnboundLocalError

함수 내에서 변수에 값을 대입하는 코드가 있으면 파이썬은 그 변수를 지역 변수로 인지합니다. 대입 전에 사용하려고 하면 에러가 발생합니다.

    a = 1
    def foo():
        # a = a + 1  # 에러 발생: a를 지역 변수로 인식했지만 값이 할당되기 전임
        print('foo] a=', a)

4. 전역 변수 값을 변경하는 방법

방법 1: return 값 활용 (추천)

가장 깔끔하고 구조적인 방법입니다.

    a = 1  # 전역변수

    def foo(a):  # 매개변수 a (지역변수)
        a = a + 1
        return a

    a = foo(a)  # 리턴값으로 전역변수 a를 갱신
    print('전역 a=', a)

방법 2: global 키워드 사용 (비추천)

코드의 의존성을 높여 유지보수를 어렵게 만들 수 있습니다.

    a = 1

    def foo():
        global a  # 이 함수 안에서 사용하는 a는 전역변수임을 선언
        a = a + 1
        print('foo] a=', a)

    foo()
    print('전역 a=', a)

5. 네임스페이스 (Namespace)와 LEGB 규칙

네임스페이스는 '이름'들이 담겨있는 공간입니다. locals()를 통해 확인할 수 있습니다.

LEGB 규칙 (이름 검색 순서)

이름을 찾을 때 L → E → G → B 순서로 탐색합니다.

1. L (Local): 함수 내부
2. E (Enclosing): 중첩 함수에서 바깥 함수 범위
3. G (Global): 전역 변수 범위
4. B (Built-in): 파이썬 내장 함수/변수 (print, len 등)

    k = 100 //Global
    def aaa():
        k = 200  # Enclosing scope가 됨
        print(k)  # Local

        def bbb():
            # k를 찾을 때: L(없음) -> E(여기 있네!)
            print(k)

        bbb()

    aaa()

 #출력 결과
 200
 200

6. Python Scope의 특징: Block Scope의 부재

Python은 if, for, while, try, with 블록에서 새로운 Scope를 생성하지 않습니다.

Java나 C, JavaScript(let, const)와는 대조적인 특징입니다. 블록 안에서 선언한 변수도 블록 밖(동일 함수 내 또는 전역)에서 사용 가능합니다.

    # for문 예시
    for i in range(3):
        xx = i * 10  # xx는 전역 scope에 생성됨

    print(xx)  # for 바깥에서도 사용 가능 (20 출력)

    # if문 예시
    if True:
        yy = 100
    print(yy)  # 사용 가능

Scope 생성 기준 정리

• 새로운 Scope 생성: def(함수), lambda, class
• 기존 Scope 유지: if, for, while, try-except, with

7. nonlocal 키워드

중첩 함수에서 바깥 함수의 변수를 수정하고 싶을 때 사용합니다.

    k = 100
    def aaa():
        k = 200
        print("aaa 내부 k:", k)

        def bbb():
            nonlocal k  # bbb의 지역변수가 아니라 aaa의 k를 사용하겠다고 선언
            k = k + 1
            print("bbb 내부 k:", k)

        bbb()
        print("bbb 호출 후 aaa의 k:", k)

    aaa()
    print("전역 k:", k)

파이썬의 asyncio 모듈을 사용하여 동기(Synchronous)와 비동기(Asynchronous) 방식의 차이점을 알아보고 실무적인 사용법을 정리합니다.

1. 동기(Synchronous) vs 비동기(Asynchronous)

🌐 동기 프로그래밍 (Synchronous)

• 개념: 작업을 순차적으로 처리합니다. 앞선 작업이 완료되어야 다음으로 넘어갑니다.
• 장점: 설계가 간단하고 디버깅이 쉽습니다.
• 단점: I/O 작업(네트워크, 파일 읽기 등)처럼 시간이 걸리는 작업 시 전체 프로세스가 멈춥니다(Blocking).

⚡ 비동기 프로그래밍 (Asynchronous)

• 개념: 작업을 시작한 뒤 완료를 기다리지 않고 다음 작업을 수행합니다. 결과는 나중에 통지받습니다.
• 장점: 자원을 효율적으로 사용하며, 여러 작업을 동시에 처리할 때 성능이 극대화됩니다.
• 단점: 코드 흐름이 복잡해질 수 있으며 디버깅이 상대적으로 까다롭습니다.

2. 파이썬의 비동기 문법 (async / await)

파이썬 3.5부터 async와 await 키워드가 공식 도입되어 비동기 프로그래밍을 지원합니다.

코루틴(Coroutine) 정의 및 호출

    import asyncio
    import time

    # async def로 선언하면 코루틴 객체를 리턴하는 함수가 됩니다.
    async def hello():
        print('hello python!')

    # 일반적인 호출 방식으로는 실행되지 않습니다.
    # await hello() 또는 asyncio.run(hello())를 사용해야 합니다.

3. 동기 방식 예제 (time.sleep)

동기 방식에서는 모든 작업 시간이 합산되어 나타납니다.

    def sync_work(icon, seconds=0):
        print(f'{icon} {seconds}초 작업 시작')
        start = time.time()
        time.sleep(seconds)  # 작업이 끝날 때까지 여기서 멈춤
        end = time.time()
        print(f"{icon} 작업종료: {end-start:.3f}초 소요")

    def sync_all():
        sync_work('🍆', 3)
        sync_work('🍊', 1)
        sync_work('🥦', 2)

    start = time.time()
    sync_all()
    end = time.time()
    print(f'>>> 총 경과시간: {end - start:.3f}초')
    # 결과: 약 6초 (3+1+2)

4. 비동기 방식 예제 (asyncio.sleep)

비동기 방식에서는 대기 시간 동안 다른 작업을 수행하므로, 가장 오래 걸리는 작업 시간을 기준으로 전체 작업이 완료됩니다.

    async def async_work(icon, seconds=0):
        print(f'{icon} {seconds}초 작업 시작')
        start = time.time()
        await asyncio.sleep(seconds)  # 대기하는 동안 제어권을 넘김
        end = time.time()
        print(f'{icon} 작업종료: {end - start:.3f}초 소요')
        return f'{icon}-{seconds}작업'

    async def async_all():
        # Task를 생성하여 비동기 실행을 예약합니다.
        task1 = asyncio.create_task(async_work('🍆', 3))
        task2 = asyncio.create_task(async_work('🍊', 1))
        task3 = asyncio.create_task(async_work('🥦', 2))

        # gather를 통해 여러 비동기 작업을 동시에 기다리고 결과값을 모읍니다.
        result = await asyncio.gather(task1, task2, task3)
        return result

    start = time.time()
    # 주피터/코랩 환경이 아닐 경우 asyncio.run(async_all()) 사용
    result = await async_all() 
    end = time.time()
    print(f'>>> 총 경과시간: {end - start:.3f}초')
    print(f'결과 리스트: {result}')
    # 결과: 약 3초 (가장 긴 작업인 3초에 수렴)

요약

• 동기: 순차적 실행 (3+1+2 = 6초)
• 비동기: 병렬적 대기 (max(3, 1, 2) = 3초)
• 핵심: I/O Bound 작업이 많은 현대 애플리케이션에서 asyncio는 성능 향상의 필수 요소입니다.

1. API Key 보안 및 환경변수 설정

API Key와 같은 민감한 정보는 소스 코드에 직접 노출하지 않고 환경변수로 관리하는 것이 보안상 필수입니다.

환경변수 로드 및 확인

    import os
    os.environ['LANGUAGE']
    os.environ['GEMINI_API_KEY'] #여기에 제미나이 키 입력

    # 별도의 환경변수 파일을 만들고
    # 실행시 환경변수 로딩을 하고 사용하기

    # .env 파일 작성


    from dotenv import load_dotenv
    load_dotenv()  # 환경변수 파일(기본 '.env')을 읽어들여 환경변수 등록.
               # 성공하면 True 리턴

     api_key = os.environ['GEMINI_API_KEY']  #여기에 제미나이 키 입력         

2. Gemini API 기본 호출

라이브러리 설치: pip install google-genai

기본 텍스트 생성

    from google import genai

    client = genai.Client()

    # 모델 호출
    response = client.models.generate_content(
        model="gemini-3-flash-preview",
        contents="Google Gemini에 대해 설명해줘",
    )
    print(response.text) # 설명이 다 나옵니다.  

3. 주요 기능 활용하기

스트리밍 (Streaming)

답변이 생성되는 대로 즉시 출력하여 사용자 경험을 개선합니다.

from google import genai

client = genai.Client()

# 모델 호출
response = client.models.generate_content_stream(  # generate_content_stream 는 iterable 리턴
    model="gemini-3-flash-preview",
    contents="Google Gemini 에 대해 설명해줘",
)

for chunk in response:
  print(chunk.text, end="")

시스템 인스트럭션 (System Instruction)

모델의 페르소나나 답변 스타일을 고정할 수 있습니다.

from google import genai
from google.genai import types

client = genai.Client()

# 모델 호출
response = client.models.generate_content(
    model="gemini-3-flash-preview",

    config= types.GenerateContentConfig(
        system_instruction="너는 고양이다.  너의 이름은 '냐코' 다"
    ),

    contents="안녕?",
)

print(response.text) #고양이처럼 말해줍니다. 

온도 조절 (Temperature)

0.0에 가까울수록 결정론적(일관적)이고, 1.0에 가까울수록 창의적인 답변을 생성합니다. config = types.GenerateContentConfig(temperature=0.1) # ... 호출 시 config 적용

from google import genai
from google.genai import types

client = genai.Client()

# 모델 호출
response = client.models.generate_content(
    model="gemini-3-flash-preview",

    config= types.GenerateContentConfig(
        temperature=0.1
    ),

    contents="AI 가 어떻게 동작하는지 알려줘",
)

print(response.text)

4. 멀티모달 (Multi-modal) 추론

텍스트뿐만 아니라 이미지를 함께 입력으로 전달하여 분석할 수 있습니다.

이미지 분석 예시

    import requests
    from PIL import Image
    from io import BytesIO
    from google import genai

    # 이미지 로드
    url = "https://cdn.britannica.com/18/129118-050-BF48319E/organ.jpg"
    img_data = requests.get(url).content
    image = Image.open(BytesIO(img_data))

    # 이미지와 텍스트를 함께 전달
    client = genai.Client()
    response = client.models.generate_content(
        model="gemini-3-flash-preview",
        contents=[image, "이 악기에 대해 설명해 줘"],
    )
    print(response.text)

5. Gemini 모델 사이즈 요약

• Ultra: 복잡한 추론 및 코딩 작업용 최상위 모델
• Pro: 성능과 속도의 균형이 잡힌 범용 모델
• Flash: 실시간 응답이 필요한 고효율 경량 모델
• Nano: 모바일 기기 내부에서 작동하는 온디바이스 모델

1. 예외 처리란?

프로그램 실행 중 발생하는 오류(Error)를 if 조건문으로 일일이 막으려 하면 코드가 매우 난잡해집니다. 파이썬에서는 '코드 수행 블록'과 '예외 처리 블록'을 분리하여 유지보수를 쉽게 할 수 있도록 try ~ except 구문을 제공합니다.

2. 기본 구문 (try ~ except)

try 블록 수행 중 오류가 발생하면 즉시 except 블록으로 넘어갑니다. 오류가 없으면 except 블록은 무시됩니다.

    num = 0

    try:
        print('1-1 try 시작')
        result = 10 / num  # ZeroDivisionError 발생 -> except로 점프
        print('1-2 try 종료')
    except:
        print('2. 오류 발생')

    print('4. 프로그램 종료')

3. 예외의 세분화 및 정보 확인

A. 특정 오류만 처리하기

발생할 것으로 예상되는 오류명을 명시하여 각각 다르게 처리할 수 있습니다.

    try:
        # result = 10 / 0      # ZeroDivisionError
        result = 10 / "0"      # TypeError
    except ZeroDivisionError:
        print('2-1. 0으로 나눌 수 없습니다.')
    except TypeError:
        print('2-2. 타입이 맞지 않습니다.')

B. 예외 메시지 변수 사용 (as e)

오류의 상세 내용(에러 메시지 등)을 확인하고 싶을 때 as 키워드를 사용합니다.

    try:
        result = 10 / "0"
    except TypeError as e:
        print('오류 발생:', e)
        print('추가 정보(args):', e.args)

4. 반드시 실행되어야 하는 코드 (finally)

오류 발생 여부와 관계없이, 파일을 닫거나 리소스를 해제하는 등 무조건 실행되어야 하는 코드는 finally에 작성합니다.

    try:
        f = open('foo.txt', 'w', encoding='utf-8')
        a = 10 + bb  # 정의되지 않은 변수 bb로 인해 NameError 발생
    except Exception as e:
        print('오류:', e)
    finally:
        print('파일을 안전하게 닫습니다.')
        f.close()

5. 다중 예외 처리 (Tuple 사용)

여러 개의 오류를 하나의 except 블록에서 동시에 처리할 수 있습니다.

    try:
        a = ['alpha', 'beta']
        print(a[2])  # IndexError 발생 가능
        b = 4 / 0    # ZeroDivisionError 발생 가능
    except (IndexError, ZeroDivisionError) as e:
        print(f"에러 발생: {e.args}, 클래스명: {e.__class__.__name__}")

6. 예외 강제 발생 (raise)

개발자가 의도적으로 오류를 일으킬 때 raise를 사용합니다. 주로 부모 클래스를 상속받는 자식 클래스가 특정 메서드를 반드시 구현(오버라이딩)하도록 강제할 때 유용합니다.

    class Bird:
        def fly(self):
            # 자식 클래스에서 이 메서드를 재정의하지 않으면 에러 발생
            raise NotImplementedError

    class Eagle(Bird):
        # fly()를 오버라이딩 하지 않고 호출하면 에러 발생
        def fly(self):
            print("독수리는 빠르게 납니다.")

    # 정상 작동
    eagle = Eagle()
    eagle.fly()

요약:

1. try: 실제 코드를 수행하는 곳
2. except: 발생한 에러를 잡아서 처리하는 곳
3. finally: 에러 유무와 상관없이 마무리 작업을 하는 곳
4. raise: 일부러 에러를 던지는 곳

1. 모듈 (Module) 이란?

• 정의: 함수, 변수, 클래스를 모아놓은 파이썬 파일(*.py)입니다.
• 장점:
  • 한 번 만들어 놓으면 다른 프로그램에서 언제든 import하여 재사용 가능합니다.
  • 다른 사람이 만든 유용한 프로그램을 내 코드에 쉽게 가져다 쓸 수 있습니다.

2. 모듈 만들기 및 불러오기 (import)

A. 모듈 파일 생성 (예: mod0.py)

현재 작업 폴더에 다음과 같은 내용으로 mod0.py를 저장합니다.

    my_name = "hong"

    def my_func(*argc):
        print(argc)

    class My_class:
        def __init__(self):
            print('My_class() 생성')

B. 모듈 사용하기

import 모듈이름 형식으로 불러와서 사용합니다. 이때 모듈 안에 정의된 요소들은 모듈명.이름 형태로 접근합니다.

    import mod0

    # 모듈의 변수 사용
    print(mod0.my_name)

    # 모듈의 함수 호출
    mod0.my_func(10, 20, 30)

    # 모듈의 클래스 인스턴스 생성
    mod0.My_class()

3. 패키지 (Package) 와 모듈 경로

• 패키지: 여러 모듈을 디렉토리 구조로 묶어 관리하는 것 (일종의 모듈 주머니).
• 경로 접근: 점(.)을 사용하여 하위 디렉토리로 들어갑니다.

예시: 하위 폴더의 모듈 가져오기

만약 ./Mymodules/mod1.py 경로에 파일이 있다면:

    import Mymodules.mod1  # Mymodules는 패키지, mod1은 모듈

    # 사용 시 경로를 다 적어야 해서 이름이 길어짐
    Mymodules.mod1.add_num(10, 20)

4. 효율적인 import 기법 (as, from)

A. 별칭 사용하기 (as)

모듈 명칭이 너무 길거나 복잡할 때 별명을 붙여 사용합니다.

    import Mymodules.mod1 as my
    my.add_num(20, 30)

B. 특정 요소만 직접 가져오기 (from ... import)

모듈명을 생략하고 함수나 변수 이름만 바로 쓰고 싶을 때 사용합니다.

    from Mymodules.mod1 import add_num
    add_num(10, 15)  # 모듈명 없이 사용 가능

    # 여러 개를 동시에 가져올 수도 있음
    from mod0 import my_name, my_func
    print(my_name)
    my_func(1, 2, 3)

5. 파이썬 생태계의 관례적인 별칭 (Alias)

데이터 분석이나 인공지능 분야에서 관례적으로 사용하는 줄임말들입니다.

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import tensorflow as tf
    from tensorflow import keras
    from sklearn.model_selection import train_test_split, cross_validate

Tip: 모듈을 찾지 못할 경우(ModuleNotFoundError), 해당 파일이 현재 실행 중인 스크립트와 같은 경로에 있는지 혹은 파이썬 경로(sys.path)에 등록되어 있는지 확인해야 합니다.

1. JSON (JavaScript Object Notation) 이란?

• 정의: 데이터 교환 용도의 JavaScript 객체 구문입니다.
• 특징: 오늘날 웹, 앱 등 애플리케이션 개발에서 데이터 교환에 사용되는 가장 중요한 텍스트 포맷입니다.

2. 데이터 타입 비교 (Python vs JS)

파이썬과 자바스크립트의 데이터 구문은 모양은 거의 동일하나, 명칭과 세부 규칙이 조금 다릅니다.

3. JSON 구문의 핵심 규칙

1. 반드시 쌍따옴표(") 사용: name(key)과 문자열 데이터는 반드시 쌍따옴표로 감싸야 합니다.
   • 예: {"name": "John"} (O) / {'name': 'John'} (X)
2. Trailing Comma 불가: 배열이나 객체의 마지막 원소 뒤에 콤마(,)를 허용하지 않습니다.
3. 담을 수 있는 것: str, int, float, list, tuple, dict, None
4. 담을 수 없는 것: set, function, datetime (별도의 직렬화 과정 필요)

4. Python json 모듈 사용법

파이썬에서는 import json을 통해 기본적으로 JSON 기능을 제공합니다.

A. json.dumps() : Python 데이터 → JSON 문자열 (직렬화)

    import json

    # 문자열 변환
    print(json.dumps('hello')) 
    # 결과: "hello"

    # 딕셔너리 변환
    print(json.dumps({'name': 'John'})) 
    # 결과: {"name": "John"}

    # 리스트 변환
    print(json.dumps([10, 20, 30])) 
    # 결과: [10, 20, 30]

    # 논리값 및 None 변환
    print(json.dumps([True, False, None])) 
    # 결과: [true, false, null]

### B. json.loads() : JSON 문자열 → Python 데이터 (역직렬화)

    import json

    # JSON 문자열 준비
    json_texts = [
        "[4, 5, 6]",
        '{"name":"hong", "age":13}'
    ]

    for text in json_texts:
        obj = json.loads(text)
        print(obj, type(obj))

    # 주의사항: 
    # '{'name':'hong'}' -> key에 홀따옴표 사용 시 에러 발생
    # '[4, 5, 6,]' -> 마지막 콤마 포함 시 에러 발생

### C. 파일 입출력 (json.load / json.dump)

    # 1. 파일 생성 및 쓰기 (준비 과정)
    with open('data.json', 'w', encoding='utf-8') as f:
        f.write('''
        {
          "name": "홍길동",
          "birth": "0525",
          "age": 30
        }
        ''')

    # 2. json.load(file) : JSON 파일 -> 파이썬 데이터
    with open('data.json', 'r', encoding='utf-8') as f:
        obj = json.load(f)
        print(obj)
        print(f"타입: {type(obj)}")

1. 클래스 정의와 인스턴스 생성

클래스는 새로운 타입을 정의하는 '붕어빵 틀'과 같습니다. 이 틀을 통해 만들어진 실체를 '객체' 또는 '인스턴스'라고 부릅니다.

클래스 정의 및 객체 생성

class Cookie:
        pass

    # 인스턴스 생성
    a = Cookie()
    print(type(a))  # <class '__main__.Cookie'>

2. 객체의 속성과 동작

• 속성(Attribute): 객체가 가지는 변수 (가로, 세로, 이름 등)
• 동작(Method): 객체가 수행하는 함수 (넓이 구하기, 걷기 등)

객체변수(instance variable)

객체변수앞에서 말한 속성값과 같은 뜻입니다. 속성값이라고 불리고, 멤버 변수 혹은 필드라고 불립닏다.

생성자 (Constructor): __init__

객체가 생성될 때 자동으로 호출되며, 주로 속성을 초기화하는 역할을 합니다.

self의 이해

메소드의 첫 번째 매개변수는 항상 self여야 합니다. 이는 호출된 '객체 자신'을 가리킵니다.

    class Rectangle: #클래스 정의
        def __init__(self, width=1, height=1): #객체가 생성되면 자동 호출
            print(f"Rectangle({width}, {height}) 생성")
            self.width = width #객체 변수 생성
            self.height = height #객체 변수 생성

        #메소드(함수) 정의 
        def get_area(self):
            return self.width * self.height 

        def set_size(self, w, h):
            self.width = w
            self.height = h

    #인스턴스 생성 및 자동 호출
    r1 = Rectangle(30, 20)

    #매개변수 없이 호출(기본값)
    r2 = Rectangle()


    #메소드 호출 및 결과 출력
    print(r1.get_area())  # 600
    print(r2.get_area())  # 1

    #생성 후 객체 값 수정
    r2.set_size(10, 50)

    #수정 결과 출력
    print(r2.get_area())  # 500

3. 클래스 변수 vs 인스턴스 변수

• 인스턴스 변수: self.변수명. 각 객체마다 독립적인 값을 가집니다.

• 클래스 변수: 클래스 내부에서 선언. 모든 객체가 공유하며 클래스명.변수명으로 접근합니다.

    class Account:
        num_accounts = 0  # 클래스 변수 (전체 계좌 수)
  
        def __init__(self, name):
            self.name = name  # 인스턴스 변수
            Account.num_accounts += 1
  
  

a1 = Account("철수") 
# 1. '철수'라는 이름표를 가진 객체 생성
# 2. 공용 게시판(Account.num_accounts)의 숫자가 0에서 1이 됨

a2 = Account("영희")
# 1. '영희'라는 이름표를 가진 객체 생성
# 2. 공용 게시판(Account.num_accounts)의 숫자가 1에서 2가 됨

| 구분 | 인스턴스 변수 (self.name) | 클래스 변수 (Account.num_accounts) |
| :--- | :--- | :--- |
| **소유주** | 개별 객체 (인스턴스) | 클래스 전체 (모든 객체 공용) |
| **생성 시점** | 객체가 생성될 때마다 매번 | 클래스가 정의될 때 딱 한 번 |
| **접근 방법** | 객체명.변수명 | 클래스명.변수명 (권장) |
| **용도** | 객체의 고유한 특징 (이름, 잔액 등) | 모든 객체가 공유하는 정보 (전체 개수, 고정 이율 등) |


---

### 예제
```python
# '매 직원(PartTimer)'에 공통적으로 적용되는 자료
# - 시급
# - 전체 직원수

# 각 직원별 객체 생성시 직원별로 '별칭'과 '근무지' '급여총액' 초기화 (속성)
#   '근무지' 생략시 '113동' 으로 지정
#   직원별로 '급여총액'  0으로 초기화

# 직원의 급여 계산하기(동작)
#    '몇시간 근무',  '+상여금'  에 따른 직원급여 계산
#   '상여금' 은 지정안하면 0 으로 처리


# 예]
# park = PartTimer('라이언')   // park 은 ‘라이언’ 이라는 닉네임의 직원으로 등록

# park 이 4시간 일한 급여 총액은?  → 34400
# park 이 2시간 일한 급여 총액은? → 17200
# park 이 2시간 일한 급여 + 상여급 2000 총액은? → 19200


class PartTimer:
  # 클래스변수
  hour_rate = 10320 # 시급
  total_part_timers = 0 # 전체 직원수

  # 생성자 (nickname, workplace)
  #   인스턴스 변수들 선언 (nickname, workplace, total_wage)
  def __init__(self, nickname, workplace = "113동"):
    PartTimer.total_part_timers += 1
    self.nickname = nickname
    self.workplace = workplace
    self.total_wage = 0

  # 급여계산
  def calculate_wage(self, hours, bonus=0):
    self.total_wage = PartTimer.hour_rate * hours + bonus
    return self.total_wage

#실행하기
park = PartTimer('라이언')
lee = PartTimer('네오', '127-1동')


park.total_wage  # 급여총액 0
lee.total_wage # 0


park.calculate_wage(4) # 시급 x 4

lee.calculate_wage(3, 15000) # 시급 x 3 + 보너스 15000


PartTimer.total_part_timers # 2 명

4. 상속 (Inheritance)

• 기존 클래스(부모)의 기능을 그대로 물려받아 새로운 클래스(자식)를 만드는 것입니다. 코드 재사용성이 높아집니다.

• 기존의 만들어진 클래스를 상속받아 새로운 클래스 정의 가능합니다.

• 상속받아 만들어진 클래스는 기존의 클래스의 메소드, 객체변수 를 그대로 가지고 있다.

• 상속받은뒤, 새로운 객체변수, 메소드 추가 할수 있다.

• 상속받은뒤, 상속받은 메소드 재정의 가능 (오버라이딩)

기존의 클래스 상속하여 새로운 클래스 정의하는 구문

class 새클래스명(기존의 클래스명)
class 새클래스명(기존클래스1, 기존클래스2, ...)  <-- 다중상속 허용

• 기존의 클래스를 '부모클래스(parent class)' 라고 하고
  (혹은 super class, base class ...)

• 상속받은 클래스를 '자식클래스(child class) 라고 한다 (혹은 sub class, derived class ...)

상속과 오버라이딩(Overriding)

부모의 메소드를 자식 클래스에서 목적에 맞게 다시 정의하는 것을 말합니다.

    class BasicTV:
        def __init__(self):
            self.power = False
            self.channel = 0

        def display_info(self):
            print(f"전원: {self.power}, 채널: {self.channel}")

    class SmartTV(BasicTV): #자식
        def __init__(self):
            super().__init__()  # 1. 부모의 생성자를 호출하여 power, channel 초기화
            self.ip = "192.168.0.1" # 2. SmartTV만의 고유 속성 추가


        def display_info(self):  # 메소드 오버라이딩(재정의)
            super().display_info() # 4. 부모의 출력 기능을 먼저 실행 (부모 클래스로 이동)
            print(f"IP: {self.ip}") # 5. 추가된 IP 정보 출력

5. 클래스 설계 원칙 (IS-A vs HAS-A)

• IS-A (상속): "~은 ~이다" 성립 시 (예: 자동차는 탈것이다 -> Car IS-A Vehicle)
• HAS-A (포함): "~은 ~을 가지고 있다" 성립 시 (예: 자동차는 타이어를 가진다 -> 속성으로 정의)

예제

# 2차원 원 Circle
#  └─ 3차원 구 (球,Sphere)

#  1. '원' 객체 정의
#  클래스 이름 : Circle
#  생성자 : '반지름(radius)'를 받아서 초기화
#  get_area() : 면적을 계산하여 리턴하는 메소드
#  get_perimeter() : 둘레을 계산하여 리턴하는 메소드

# 2. '구' 객체 정의 <-- Circle 상속받아 정의
#  클래스 이름 : Cube
#  get_area() : 정육면체의 총 면적.   4/3 x pi x r³
#  get_volume() : 정육면체의 부피 계산.  4 x pi x r²



import math

# 2차원 Circle 정의
class Circle:
  def __init__(self, radius = 0):
    self.radius = radius

  def get_area(self):
    return math.pi * self.radius ** 2

  def get_perimeter(self):
    return 2 * math.pi * self.radius


#실행해보기
c1 = Circle(10)

print(c1.get_area())
print(c1.get_perimeter())



# Circle 을 상속받아 구(Sphere) 객체 생성
class Sphere(Circle):
  def get_volume(self):  # 자식 클래스에서 추가되는 메소드
    return (4 / 3) * math.pi * self.radius ** 3

  def get_area(self):  # 자식클래스에서 부모클래스의 메소드를 재정의 '오버라이딩'
    return 4 * math.pi * self.radius ** 2

#실행해보기
s1 = Sphere(10)

print(s1.get_area())
print(s1.get_perimeter())
print(s1.get_volume())

상속에서의 생성자 호출과 super() 완벽 가이드

상속 관계에서 자식 클래스가 생성자를 정의할 때, 부모의 생성자를 어떻게 처리해야 하는지 단계별로 알아봅니다.

1. 생성자 상속의 기본 원리

자식 클래스에 __init__이 없으면 파이썬은 자동으로 부모의 __init__을 찾아 실행합니다. 하지만 자식에게 __init__을 만드는 순간, 부모의 것은 덮어씌워져(Overriding) 호출되지 않습니다. 따라서 명시적 호출이 필요합니다.

2. 코드 분석 및 완성

① 부모 생성자 명시적 호출

자식 생성자에서 super().__init__()을 호출하여 부모가 가진 speed 속성을 안전하게 물려받습니다.

    class Vehicle:
        def __init__(self, speed=0):
            print(f'Vehicle 생성 speed={speed}')
            self.speed = speed

    class Car(Vehicle):
        def __init__(self, speed=0, oil=0):
            # 부모에게 필요한 speed 값을 전달하며 생성자 호출
            super().__init__(speed) 
            print(f'Car 생성 oil={oil}')
            self.oil = oil

② 3단계 상속 구조 완성 (HybridCar)

Vehicle → Car → HybridCar로 이어지는 상속 체인을 완성해 봅니다.

    class HybridCar(Car):
        def __init__(self, speed=0, oil=0, battery=0):
            # 바로 위 부모인 Car의 생성자를 호출
            # Car는 다시 Vehicle의 생성자를 호출하게 됩니다 (상속 체인)
            super().__init__(speed, oil)
            print(f'HybridCar 생성 battery={battery}')
            self.battery = battery

3. 핵심 포인트 정리

4. 실행 결과 (HybridCar 생성 시)

    h = HybridCar(100, 50, 80)

    # 출력 순서:
    # Vehicle 생성 speed=100 (최상위 부모부터)
    # Car 생성 oil=50
    # HybridCar 생성 battery=80 (마지막에 자기 자신)

💡 주의사항 super().__init__()을 호출하지 않으면, 자식 객체는 부모가 정의한 self.speed 같은 변수를 가지지 못하게 됩니다. 나중에 h.speed를 조회할 때 AttributeError가 발생할 수 있으니 꼭 써주는 것이 원칙입니다!

예시

자식이 생성자를 만들지 않은 경우
class Vehicle:
    def __init__(self, speed):
        print("Vehicle 생성자 실행!")
        self.speed = speed

class Car(Vehicle):
    pass  # 생성자를 만들지 않음

# Car에는 생성자가 없지만, 부모의 것을 빌려와서 사용함
c1 = Car(100) 
print(c1.speed) # 결과: 100



자식이 생성자를 만든 경우(오버라이딩)
class Vehicle:
    def __init__(self, speed):
        self.speed = speed  # 부모의 소중한 변수 설정

class Car(Vehicle):
    def __init__(self, oil):
        self.oil = oil  # 자식인 나는 내 변수(oil)만 챙김

c1 = Car(50)
print(c1.oil)   # 출력: 50 (잘 됨)
print(c1.speed) # 에러 발생! (AttributeError: 'Car' object has no attribute 'speed')

6. 매직 메소드 (Magic Method)

__로 시작하고 끝나는 특별한 메소드들로, 파이썬 내장 연산자들의 동작을 클래스에 정의할 수 있게 합니다.

repr vs str

• __repr__: 객체 자체의 표현값 (개발/디버깅용)

• __str__: 사용자가 보기 편한 문자열 (출력용)

    class Number:
        def __init__(self, number):
            self.number = number
  
        def __add__(self, other):
            return Number(self.number + other.number)
  
        def __repr__(self):
            return str(self.number)
  
    n1, n2 = Number(10), Number(20)
    print(n1 + n2)  # 30 (__add__에 의해 객체 연산 가능)