인뽕 님의 개발일지

0722 MVP, 스레드

인뽕 — Wed, 22 Jul 2026 20:56:42 +0900

#Gemini 활용 꿀팁

'''
코드 붙여넣고,
"이 코드 내부 실행 순서를 시뮬레이터로 만들어줘. 단, html로"
설정은 Canvas로
'''

MVP

#MVP 패턴 적용

'''
MVP는 Model-View-Presenter의 약자로, GUI 프로그램의 코드를 역할에 따라 세 부분으로 
나누는 아키텍처입니다.
핵심 목적은 데이터, 화면, 로직을 분리하여 규모가 커져도 코드를 관리할 수 있게 만드는 것입니다.

MVP의 세가지 역할

구성 요소                       역할                      tkinter에서
Model                  데이터와 비즈니스 로직             순수 파이썬 클래스 (tkinter 모름)
View    `              화면 표시와 사용자 입력 받기        위젯 배치, 이벤트 전달
Presenter              Model과 View를 연결하는 중재자     입력 처리 후 Model 갱신, View 업데이트

핵심 규칙과 데이터 흐름

핵심 규칙은 "View와 Model은 서로 직접 대화하지 않는다" 입니다.
모든 흐름은 Presenter를 거칩니다.

[사용자] → View → Presenter → Model
              ↓
[사용자] ← View ← Presenter

View는 스스로 판단하지 않고 사용자 동작을 Presenter에게 "전달"만 합니다.
Model은 tkinter를 전혀 모르는 순수한 파이썬일 뿐입니다.
Presenter는 Model과 View를 둘 다 알고 있으며, 흐름을 조율합니다.

MVP 적용 시 장점

화면(View) 없이도 데이터(Model)와 로직(Presenter)을 독립적으로 단위 테스트할 수 있습니다.
화면을 변경해도 로직은 그대로, 로직을 수정해도 화면은 그대로 둘 수 있어 유지보수가 편리합
니다.
디자이너는 화면에, 개발자는 로직에 집중할 수 있어 명확한 업무 분장과 협업이 가능합니다.
프로그램 기능이 늘어나도 역할별로 코드가 체계적으로 정리되어 확장성이 뛰어납니다.


'''

# MVP 패턴으로 앱 만들기

# Model

#Model은 import tkinter 가 없는 순수한 파이썬일 뿐입니다.
class DistanceModel:
    KM_PER_MILE = 1.609344

    def km_to_miles(self, km):
        return km / self.KM_PER_MILE
    def miles_to_km(self, miles):
        return miles * self.KM_PER_MILE

#View

# 위젯을 만들고, 사용자 동작을 Presenter에게 "전달"만 합니다. 스스로 판단 X

import tkinter as tk

class DistanceView(tk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.pack(padx=15, pady=15)

        self.entry = tk.Entry(self, width=15)
        self.entry.grid(row=0, column=0, columnspan=2, pady=5)

        self.km_btn = tk.Button(self, text="km → 마일")
        self.km_btn.grid(row=1, column=0, padx=2)

        self.mile_btn = tk.Button(self, text="마일 → km")
        self.mile_btn.grid(row=1, column=1, padx=2)

        self.result = tk.Label(self, text="값을 입력하세요", width=25)
        self.result.grid(row=2, column=0, columnspan=2, pady=10)

    def get_input(self):
        return self.entry.get()

    def show_result(self, text):
        self.result.config(text=text)

#Presenter

#Presenter는 Model과 View를 둘 다 알고 있으며, 흐름을 조율합니다.

class DistancePresenter:
    def __init__(self, model, view):
        self.model = model
        self.view = view
        self.view.km_btn.config(command=self.on_km_to_miles)
        self.view.mile_btn.config(command=self.on_miles_to_km)
    def _read_value(self):
        """입력값을 숫자로 변환. 실패하면 None과 함께 안내."""
        try:
            return float(self.view.get_input())
        except ValueError:
            self.view.show_result("숫자를 입력하세요")
            return None
    def on_km_to_miles(self):
        value = self._read_value()
        if value is not None:
            miles = self.model.km_to_miles(value)
            self.view.show_result(f"{value} km = {miles:.2f} 마일")
    def on_miles_to_km(self):
        value = self._read_value()
        if value is not None:
            km = self.model.miles_to_km(value)
            self.view.show_result(f"{value} 마일 = {km:.2f} km")

#조립과 실행

if __name__ == "__main__":
    root = tk.Tk()
    presenter = DistancePresenter(DistanceModel(), DistanceView(root))
    root.mainloop()

km-마일 변환 프로그램이다.

실행 결과

스레드

'''
스레드란

프로그램을 실행하면 프로세스가 생기고, 그 안에서 실제로 코드를 실행하는 흐름이 스레드
(Thread) 입니다.
기본적으로 스레드는 하나(메인 스레드)지만, 필요하면 여러 개를 만들어 일을 나눌 수 있습니다.

스레드는 왜 필요한가?

스레드가 하나면 모든 일을 순서대로 처리합니다. 그래서 오래 걸리는 작업(읽기, 네트워크 등)을
 만나면 끝날 때까지 다른 일이 멈춥니다.
time.sleep , 파일
GUI에서 이 문제가 바로 '응답 없음' 입니다. 메인 스레드가 대기 작업에 묶이면 창 이동·버튼 클
릭에 반응하지 못합니다.
그래서 해결책은 역할을 나누는 것입니다.
메인 스레드 : 화면을 그리고 사용자 입력에 반응하는 일에 집중합니다.
작업 스레드 : 오래 걸리는 작업을 따로 맡아 처리합니다.
이렇게 하면 작업이 도는 동안에도 화면이 멈추지 않아 '응답 없음'을 피할 수 있습니다.

파이썬에서 스레드 구성 방법

파이썬은 표준 라이브러리인 
threading 모듈로 스레드를 다룹니다. 스레드를 만드는 방식은 크게 두 가지입니다.

함수를 넘기는 방식

가장 간단한 방법은 Thread 객체를 만들면서 실행할 함수를 target 으로 지정하는 것입니다.
'''

# 스레드 예제

import threading
import time

def work():
    for i in range(5):
        print(f"작업 중 {i}")
        time.sleep(1)

t = threading.Thread(target=work)
t.start()

1초동안 대기하고 print하는 스레드를 만든 코드이다.

출력 결과

'''
Thread를 상속하는 방식

좀 더 구조적인 방법은 threading.Thread 를 상속한 클래스를 만들고 run 메서드를 재정의하 
는 것입니다. 
스레드가 다룰 데이터나 상태가 많아 객체지향적으로 설계할 때 적합합니다.
'''

#스레드 상속 예제

import threading
import time

class Worker(threading.Thread):
    def __init__(self, name):
        super().__init__()
        self.worker_name = name
    def run(self):
        for i in range(5):
            time.sleep(1)
            print(f"{self.worker_name}: {i}")

w = Worker("작업자1")
w.start()

threading.Thread를 상속받고, run함수를 오버라이딩한 모습이다.

Thread의 run함수

출력 결과

'''
이제 같은 카운트다운 프로그램을 두 가지 방식으로 만들어, 화면이 멈추는 경우와 멈추지 않는
경우를 직접 비교해 보겠습니다.
두 코드는 10부터 0까지 1초 간격으로 숫자를 줄여 표시하고, 마지막에 "끝!"을 보여준다는 점에
서 동일합니다.
차이는 그 작업을 누가 처리하느냐에 있습니다.
'''

#메인 스레드에서 처리

import tkinter as tk
import time
class CountdownApp:
    def __init__(self, root):
        self.root = root
        self.label = tk.Label(root, text="10", font=("Arial", 60))
        self.label.pack(expand=True)
        tk.Button(root, text="시작", command=self.start).pack(pady=10)

    def start(self):
        for i in range(10, -1, -1):
            self.label.config(text=str(i))
            self.root.update_idletasks()
            time.sleep(1)
        self.label.config(text="끝!")

if __name__ == "__main__":
    root = tk.Tk()
    CountdownApp(root)
    root.mainloop()

time.sleep(1) 이 메인 스레드를 붙잡아 두어 화면 갱신이나 다른 입력을 막는다.
카운트다운 중 창을 움직이면 반응하지 않는다.
오래 걸리는 작업을 메인 스레드에서 처리하면 결국 '응답 없음' 상태가 됨을 보여준다.

메인스레드가 작업을 하면서 응답없음이 뜸

#작업 스레드로 분리

import tkinter as tk
import threading
import time

class CountdownApp:
    def __init__(self, root):
        self.root = root
        self.label = tk.Label(root, text="10", font=("Arial", 60))
        self.label.pack(expand=True)
        tk.Button(root, text="시작", command=self.start).pack(pady=10)
    def start(self):
        threading.Thread(target=self.count, daemon=True).start()# 작업스레드에 짬떄리기
    def count(self):
        for i in range(10, -1, -1):
            self.label.config(text=str(i))
            time.sleep(1)
        self.label.config(text="끝!")
if __name__ == "__main__":
    root = tk.Tk()
    CountdownApp(root)
    root.mainloop()

시작 버튼을 누르면 카운트다운 작업(count)을 새로운 작업 스레드에 온전히 맡깁니다.
무거운 대기 시간이 작업 스레드에서 흐르므로 메인 스레드는 자유로운 상태가 됩니다.
메인 스레드가 멈추지 않아 카운트다운 중에도 창 이동, 버튼 클릭 등에 정상적으로 반응합니다.

#after()로 안전하게 화면 갱신하기

'''
위젯은 메인 스레드에서만 다루어야 함
앞서 작업 스레드로 분리한 코드는 화면이 멈추지 않아 잘 동작하는 것처럼 보입니다.
작업 스레드에서 self.label.config(...) 처럼 위젯을 직접 건드리면, 
당장은 문제가 없어 보여도 상황에 따라 화면이 깨지거나 예기치 않게 프로그램이 멈출 수 있습니다.

그래서 필요한 것이 after()

after(밀리초, 함수)는 "지정한 시간이 흐른 뒤 이 함수를 메인 스레드에서 실행하라"고 예약하는
메서드입니다.
즉 위젯을 바꾸는 일은 메인 스레드에 맡기고, 작업 스레드는 "언제 무엇을 할지"만 예약하는 방
식으로 역할을 다시 나눌 수 있습니다.

after()만으로 카운트다운 구현하기

사실 카운트다운처럼 "1초마다 한 번씩"인 단순한 반복은 스레드 없이 
after() 만으로도 깔끔하게 만들 수 있습니다.
time.sleep 으로 흐름을 멈추는 대신, 다음 숫자를 1초 뒤에 실행하도록 예약하고 함수를 
빠져나오는 것이 핵심입니다.
'''

#after 예제

import tkinter as tk

class CountdownApp:
    def __init__(self, root):
        self.root = root
        self.label = tk.Label(root, text="10", font=("Arial", 60))
        self.label.pack(expand=True)
        tk.Button(root, text="시작", command=self.start).pack(pady=10)
    def start(self):
        self.count(10)
    def count(self, i):
        if i < 0:
            self.label.config(text="끝!")
            return

        self.label.config(text=str(i))
        self.root.after(1000, self.count, i - 1)

if __name__ == "__main__":
    root = tk.Tk()
    CountdownApp(root)
    root.mainloop()

# 큐 통신

'''
tkinter 위젯은 메인 스레드에서만 안전하게 조작할 수 있으므로, 
백그라운드 스레드가 위젯을 직접 바꾸면 간헐적으로 충돌합니다.
그래서 큐(queue)를 사이에 둡니다. 백그라운드 스레드는 결과를 큐에 넣기만 하고, 
메인 스레드는 큐에서 결과를 꺼내 화면을 바꿉니다. 역할이 나뉘므로 위젯은 언제나
메인 스레드에서만 조작됩니다

큐(Queue)란

큐는 먼저 넣은 것이 먼저 나오는(FIFO, First In First Out) 자료구조입니다.
넣기(put) →  [ 1 ][ 2 ][ 3 ]  → 꺼내기(get)
        뒤            앞
        
리스트로도 비슷하게 흉내 낼 수 있지만, 파이썬의 queue.Queue에는 두 가지 중요한 장점이 있
습니다.

-스레드 안전(thread-safe): 여러 스레드가 동시에 넣고 꺼내도 데이터가 깨지지 않도록 내부
적으로 잠금(lock)을 처리해 줍니다. 그래서 스레드 사이의 데이터 전달 통로로 안성맞춤입니
다.
-대기 기능: 큐가 비어 있을 때 값이 들어올 때까지 기다리게 하거나, 기다리지 않고 즉시 넘어
가게 하는 등 상황에 맞게 선택할 수 있습니다.

기본 사용법

큐 만들기

import queue
q = queue.Queue()          
# 크기 제한 없는 큐
q = queue.Queue(maxsize=5) # 최대 5개까지만 담는 큐

값 꺼내기 ( get , get_nowait )

n = q.get() 
n = q.get_nowait()

get() 은 값이 올 때까지 멈춰 서서 기다립니다. GUI 메인 스레드에서 이걸 쓰면 화면이
얼어붙으므로 주의해야 합니다.
get_nowait() 는 기다리지 않으므로 GUI에 적합합니다. 대신 큐가 비어 있으면 예외가
나므로 try/except로 감싸 처리합니다.

상태 확인
q.empty()  # 비어 있으면 True                
q.qsize()  # 대략적인 크기 (참고용)                
'''

#스레드와 큐 활용하기
#'스레드 → 큐 → 화면' 예제코드
#백그라운드에서 1초마다 숫자를 세어 큐에 넣고, 메인 스레드가 이를 꺼내 라벨에 표시합니다.

import tkinter as tk
import threading
import queue
import time

root = tk.Tk()
label = tk.Label(root, text="대기 중", font=("", 20))
label.pack(padx=40, pady=40)

q = queue.Queue()

def work():
    for i in range(1, 10):
        time.sleep(1)
        q.put(i)
def poll():
    try:
        while True:
            n = q.get_nowait()
            label.config(text=f"{n} 초")
    except queue.Empty:
        pass
    root.after(100, poll)

threading.Thread(target=work, daemon=True).start() #daemon은 윈도우가 꺼지면, 이 스레드도 멈춰라
root.after(100, poll)
root.mainloop()

'''
카운트 다운 코드 큐 기능 추가

앞서 스레드 강좌를 위한 카운트다운 예제 코드는 백그라운드 스레드에서 GUI를 조작하는 문제
점이 있었습니다.
이를 큐 기능을 추가해 안전한 코드로 아래와 같이 개선했습니다.
'''

#큐 기능이 추가된 코드

import tkinter as tk
import threading
import queue
import time
class CountdownApp:
    def __init__(self, root):
        self.root = root
        self.running=False # 카운트다운 중
        self.queue = queue.Queue()
        self.label = tk.Label(root, text="10", font=("Arial", 60))
        self.label.pack(expand=True)
        tk.Button(root, text="시작", command=self.start).pack(pady=10)
        self.poll()
    def start(self):
        if self.running:# 카운트다운 중일땐 스레드를 더이상 만들지 않음
            return
        self.running=True
        threading.Thread(target=self.count, daemon=True).start()

    def count(self):
        for i in range(10, -1, -1):
            self.queue.put(str(i))
            time.sleep(1)
        self.queue.put("끝!")
    def poll(self):
        try:
            while True:
                self.label.config(text=self.queue.get_nowait())
        except queue.Empty:
            pass
        self.root.after(100, self.poll)
if __name__ == "__main__":
    root = tk.Tk()
    CountdownApp(root)
    root.mainloop()

카운트다운 모델을 직접 MVP로 구현해보았다.

import tkinter as tk
import threading
import queue
import time
class CountdownModel:
    def __init__(self):
        self.queue = queue.Queue()
    def start(self):
        threading.Thread(target=self.count, daemon=True).start()

    def count(self):
        for i in range(10, -1, -1):
            self.queue.put(str(i))
            time.sleep(1)
        self.queue.put("끝!")

class CountdownView(tk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.label = tk.Label(root, text="10", font=("Arial", 60))
        self.label.pack(expand=True)
        self.btn=tk.Button(root, text="시작")
        self.btn.pack(pady=10)

    def schedule(self, delay, callback):
        self.after(delay, callback)

class CountdownPresenter:
    def __init__(self,model,view):
        self.model = model
        self.view = view
        self.view.btn.config(command=self.start)
    def start(self):
        threading.Thread(target=self.model.count, daemon=True).start()
        self.poll()
    def poll(self):
        try:
            while True:
                self.view.label.config(text=self.model.queue.get_nowait())
        except queue.Empty:
            pass
        self.view.schedule(100,self.poll)
if __name__ == "__main__":
    root = tk.Tk()
    CountdownPresenter(CountdownModel(),CountdownView(root))
    root.mainloop()

원본(MVP없이 구현된 코드) 코드를 보았을때, poll 함수에서 root를 사용한다.

def poll(self):
    try:
        while True:
            self.label.config(text=self.queue.get_nowait())
    except queue.Empty:
        pass
    self.root.after(100, self.poll)

-CountdownApp 클래스의 poll 함수

그래서 poll함수를 CountdownPresenter클래스에 넣을지, CountdownView 클래스에 넣을지 고민을 했는데,

GPT한테 물어본 결과

Presenter에 root(Tk 객체)를 넘기는 것보다, View가 after()를 관리하도록 두는 쪽이 더 MVP스럽습니다.
다만 poll() 자체는 View보다 Presenter에 두는 게 더 자연스럽습니다.

라고 했다. 그래서 view쪽에 schedule이라는 함수를 만들고, (after 실행) 해당 코드를 Presenter클래스의

poll함수에서 호출하는 쪽으로 결정하게 되었다.

JSON 파일 이해하기

'''
JSON이란 무엇인가?

JSON(JavaScript Object Notation)은 데이터를 텍스트로 표현하는 형식입니다.
읽기 쉽고 구조도 단순해서, 프로그램끼리 데이터를 주고받거나 파일에 데이터를 저장할 때 널리 쓰입니다.

JSON의 생김새

연락처 하나를 JSON으로 표현하면 아래와 같습니다.

{
"name": "홍길동",
"company": "한빛상사",
"phone": "010-1234-5678"
}

중괄호 { }로 묶인 이 덩어리를 객체라고 부릅니다. 안에는 "이름": 값 형태의 쌍이 들어 있습니다.
왼쪽의 "name" 은 항목의 이름(키), 오른쪽은 그 값입니다. 키는 반드시 큰따옴표로 감싸고, 쌍과
쌍 사이는 쉼표로 구분합니다.
연락처는 여러 개가 필요하므로, 객체들을 대괄호 [ ] 로 묶어 배열(목록)로 만듭니다.

파이썬에서 JSON 파일 읽고 쓰기

파이썬에는 JSON을 다루는 json 모듈이 기본으로 들어 있어 따로 설치할 필요가 없습니다. 
핵심 함수는 두 개입니다.

json.load(f) 는 파일에서 JSON을 읽어 파이썬 자료형으로 바꿉니다. 파일 속 배열은 리스트
로, 객체는 딕셔너리로 변환되어 돌아옵니다.

json.dump(데이터, f) 는 반대로 파이썬 자료형을 JSON 텍스트로 바꿔 파일에 씁니다.
'''

#JSON 저장/불러오기 코드

#앱에서 사용할 저장/불러오기 코드를 보면 이 두 함수가 어떻게 쓰이는지 알 수 있습니다.

import os, json

FILE = "contacts.json"

def load():
    if os.path.exists(FILE):
        with open(FILE, encoding="utf-8") as f:
            return json.load(f)
    return []
    
def save():
    with open(FILE, "w", encoding="utf-8") as f:
        json.dump(contacts, f, ensure_ascii=False, indent=2)
        
contacts = load()
save()
'''
알아두기

with open(...) 구문과 인코딩 지정

with open(...) 구문을 쓰면 작업이 끝났을 때 파일이 자동으로 닫혀 안전합니다.
encoding="utf-8" 은 한글이 깨지지 않도록 문자 인코딩을 지정하는 부분입니다.
'''

실행시 디렉토리에 contacts.json이 생성됨

#입력폼 생성하고 연락처 추가하기
#목표
#contacts.json 파일에 '이름','회사','연락처'를 추가할 수 있는 최소한의 GUI 폼을 작성합니다.
#연락처 v0.1

import tkinter as tk
import os, json

FILE = "contacts.json"

def load():
    if os.path.exists(FILE):
        with open(FILE, encoding="utf-8") as f:
            return json.load(f)
    return []

def save():
    with open(FILE, "w", encoding="utf-8") as f:
        json.dump(contacts, f, ensure_ascii=False, indent=2)

def add():
    contacts.append({
        "name": e_name.get(),
        "company": e_company.get(),
        "phone": e_phone.get(),
    })
    save()

contacts = load()

root = tk.Tk()
root.title("연락처 v0.1")

e_name = tk.Entry(root)
tk.Label(root, text="이름").grid(row=0, column=0)
tk.Label(root, text="회사").grid(row=0, column=1)
tk.Label(root, text="전화").grid(row=0, column=2)
e_company = tk.Entry(root)
e_phone = tk.Entry(root)
e_name.grid(row=1, column=0)
e_company.grid(row=1, column=1)
e_phone.grid(row=1, column=2)
tk.Button(root, text="추가", command=add).grid(row=3, column=1)

root.mainloop()

실행결과

저장된 json파일

#Treeview 위젯으로 연락처 보기

#목표
#ttk.Treeview 위젯으로 'contacts.json' 파일 내 연락처 정보를 엑셀 시트처럼 출력합니다.
#연락처 삭제 기능을 추가합니다.
#연락처 v0.2

import tkinter as tk
from tkinter import ttk, messagebox
import os, json

FILE = "contacts.json"

def load():
    if os.path.exists(FILE):
        with open(FILE, encoding="utf-8") as f:
            return json.load(f)
    return []

def save():
    with open(FILE, "w", encoding="utf-8") as f:
        json.dump(contacts, f, ensure_ascii=False, indent=2)

def refresh():
    tree.delete(*tree.get_children())
    for c in contacts:
        tree.insert("", "end", values=(c["name"], c["company"], c["phone"]))

def add():
    name, company, phone = e_name.get(), e_company.get(), e_phone.get()
    if not name:
        messagebox.showwarning("확인", "이름을 입력하세요.")
        return
    contacts.append({"name": name, "company": company, "phone": phone})
    save()
    refresh()
    for e in (e_name, e_company, e_phone):
        e.delete(0, "end")

def delete():
    sel = tree.selection()
    if not sel:
        return
    idx = tree.index(sel[0])
    contacts.pop(idx)
    save()
    refresh()

contacts = load()

root = tk.Tk()
root.title("연락처 v0.2")

input_frame = tk.LabelFrame(root, text="입력", padx=10, pady=10)
input_frame.pack(padx=10, pady=10, fill="x")

tk.Label(input_frame, text="이름").grid(row=0, column=0)
tk.Label(input_frame, text="회사").grid(row=0, column=1)
tk.Label(input_frame, text="전화").grid(row=0, column=2)

e_name = tk.Entry(input_frame)
e_company = tk.Entry(input_frame)
e_phone = tk.Entry(input_frame)
e_name.grid(row=1, column=0, padx=2)
e_company.grid(row=1, column=1, padx=2)
e_phone.grid(row=1, column=2, padx=2)

tk.Button(input_frame, text="추가", command=add).grid(row=1, column=3, padx=5)
tk.Button(input_frame, text="삭제", command=delete).grid(row=1, column=4)

list_frame = tk.LabelFrame(root, text="목록", padx=10, pady=10)
list_frame.pack(padx=10, pady=(0, 10), fill="both")

tree = ttk.Treeview(list_frame, columns=("name", "company", "phone"), show="headings", height=8)
tree.heading("name", text="이름")
tree.heading("company", text="회사")
tree.heading("phone", text="전화")
tree.pack()

refresh()
root.mainloop()

실행결과

#연락처 v0.3

위 코드를 MVP형식으로 재구성.

#model

'''
모델

설명

데이터를 담당하는 모델부터 만듭니다.
절차적 코드에서 흩어져 있던 load, save, 그리고 연락처 리스트를 다루던 부분이 하나의 클래스
로 모입니다.
모델은 데이터만 다루고 화면이나 입력은 전혀 알지 못한다는 점이 핵심입니다
'''
import os, json
class ContactModel:
    def __init__(self, file_path="contacts.json"):
        self.file_path = file_path
        self.contacts = self._load()
    def _load(self):
        if os.path.exists(self.file_path):
            with open(self.file_path, encoding="utf-8") as f:
                return json.load(f)
        return []
    def _save(self):
        with open(self.file_path, "w", encoding="utf-8") as f:
            json.dump(self.contacts, f, ensure_ascii=False, indent=2)

    def get_all(self):
        return self.contacts

    def add(self, name, company, phone):
        self.contacts.append({"name": name, "company": company, "phone": phone})
        self._save()
    def delete(self, idx):
        self.contacts.pop(idx)
        self._save()

'''
이름 앞에 밑줄이 붙은 _load 와 get_all 는 클래스 내부에서만 쓰는 메서드라는 신호입니다.
바깥에서는 , add ,_save, delete 처럼 밑줄 없는 메서드만 호출하고, 파일을 실제로 읽고
쓰는 세부 동작은 클래스 안에 감춰 둔 것입니다.
add 나 delete 가 끝날 때마다 스스로 _save 를 호출하므로,호출하는 쪽은 저장을 신경 쓸
필요가 없습니다
'''

#view

'''
뷰
설명

화면을 담당하는 뷰입니다. 입력창·버튼·목록을 그리고 입력값을 넘겨주거나 목록을 다시 그립니다.
저장이나 검증은 하지 않고, 버튼을 눌렀을 때의 처리는 프리젠터에게 맡깁니다
'''

import tkinter as tk
from tkinter import ttk, messagebox

class ContactView:
    def __init__(self, root):
        self.root = root
        self.presenter = None
        self._setup_ui()

    def set_presenter(self, presenter):
        self.presenter = presenter

    def _setup_ui(self):
        input_frame = tk.LabelFrame(self.root, text="입력", padx=10, pady=10)
        input_frame.pack(padx=10, pady=10, fill="x")

        tk.Label(input_frame, text="이름").grid(row=0, column=0)
        tk.Label(input_frame, text="회사").grid(row=0, column=1)
        tk.Label(input_frame, text="전화").grid(row=0, column=2)

        self.e_name = tk.Entry(input_frame)
        self.e_company = tk.Entry(input_frame)
        self.e_phone = tk.Entry(input_frame)

        self.e_name.grid(row=1, column=0, padx=2)
        self.e_company.grid(row=1, column=1, padx=2)
        self.e_phone.grid(row=1, column=2, padx=2)

        tk.Button(input_frame, text="추가",
                  command=lambda: self.presenter.add()).grid(row=1, column=3, padx=5)
        tk.Button(input_frame, text="삭제",
                  command=lambda: self.presenter.delete()).grid(row=1, column=4)
        list_frame = tk.LabelFrame(self.root, text="목록", padx=10, pady=10)
        list_frame.pack(padx=10, pady=(0, 10), fill="both", expand=True)

        self.tree = ttk.Treeview(list_frame, columns=("name", "company", "phone"),
                                 show="headings", height=8)
        self.tree.heading("name", text="이름")
        self.tree.heading("company", text="회사")
        self.tree.heading("phone", text="전화")
        self.tree.pack(fill="both", expand=True)

    def get_inputs(self):
        return self.e_name.get(), self.e_company.get(), self.e_phone.get()

    def clear_inputs(self):
        for e in (self.e_name, self.e_company, self.e_phone):
            e.delete(0, "end")

    def get_selected_index(self):
        sel = self.tree.selection()
        if not sel:
            return None
        return self.tree.index(sel[0])

    def render(self, contacts):
        self.tree.delete(*self.tree.get_children())

        for c in contacts:
            self.tree.insert("", "end", values=(c["name"], c["company"], c["phone"]))

    def show_warning(self, title, message):
        messagebox.showwarning(title, message)

'''
버튼의 command 가 lambda: self.presenter.add() 로 되어 있는 데 주목합니다.
이전에는 버튼이 직접 add 함수를 불렀지만, 이제는 프리젠터에게 "추가해 달라"고 요청만 합
니다.get_inputs , clear_inputs , render 처럼 뷰가 제공하는 메서드들은 모두 화면을 읽거나 다
시 그리는 창구 역할을 하며, 프리젠터는 이 창구를 통해서만 화면과 소통합니다.
view.py 코드 하단에 아래 코드를 추가하면 UI만 확인할 수 있습니다.

if __name__ == "__main__":
    root = tk.Tk()
    view = ContactView(root)
    root.mainloop()
'''

#presenter

'''
프리젠터

설명

서로 모르는 모델과 뷰 사이를 오가며 흐름을 조율하는 것이 프리젠터입니다
절차적 코드에서 add , delete , refresh 함수가 하던 "판단과 조율"의 로직이 이곳으로 모입
니다
'''

class ContactPresenter:
    def __init__(self, view, model):
        self.view = view
        self.model = model
        self.view.set_presenter(self)
        self.refresh()
    def refresh(self):
        self.view.render(self.model.get_all())
    def add(self):
        name, company, phone = self.view.get_inputs()
        if not name:
            self.view.show_warning("확인", "이름을 입력하세요.")
            return
        self.model.add(name, company, phone)
        self.refresh()
        self.view.clear_inputs()
    def delete(self):
        idx = self.view.get_selected_index()
        if idx is None:
            return
        self.model.delete(idx)
        self.refresh()

'''
add의 흐름을 따라가 보면 세 부분이 어떻게 협력하는지 잘 드러납니다.
프리젠터는 먼저 뷰에서 입력값을 받아 오고(get_inputs ), 이름이 비었는지 검증한 뒤, 문제가
없으면 모델에 저장을 지시하고(model.add ), 마지막으로 화면을 다시 그리고 입력창을 비웁니
다.
이름 검증 같은 "규칙"은 뷰도 모델도 아닌 프리젠터가 쥐고 있습니다.
생성자에서 set_presenter 로 자신을 뷰에 등록하고 곧바로 
refresh 를 호출해, 앱이 켜지자
마자 저장돼 있던 연락처가 화면에 나타나게 합니다.

mvp는 이해만 하고 넘어가면 안됨.
스스로 설계할 줄 알아야한다.
'''

#main

#세 파일을 모두 만들었으니, 이제 이들을 실제로 조립해 실행하는 진입점만 남았습니다.
import tkinter as tk

from model import ContactModel
from view import ContactView
from presenter import ContactPresenter

def main():
    root = tk.Tk()
    root.title("연락처 v0.3")

    view = ContactView(root)
    model = ContactModel()
    ContactPresenter(view, model)

    root.mainloop()

if __name__ == "__main__":
    main()

'''
main 함수가 하는 일은 세 조각을 만들어 연결하는 것뿐입니다.
뷰와 모델을 각각 생성한 뒤, 이 둘을 프리젠터에 넘겨 주면 나머지 연결은 프리젠터가 알아서 처
리합니다.
조립 과정이 단순하다는 것 자체가 MVP 패턴이 역할을 잘 나눠 놓았다는 증거입니다.
'''

네트워크

'''
HTTP(HyperText Transfer Protocol)/ HTTPS(HyperText Transfer Protocol Secret)
인터넷에서 우리가 매일 보는 웹 페이지(HTML),이미지, 텍스트 등의 데이터를 주고받기 위해
사용하는 가장 대표적인 웹 통신 규약

ICMP(Internet Control Message Protocol): ping test
데이터를 주고받기 위한 목적보다는, 네트워크의 상태를 진단하고
통신 오류를 알려주기 위해 만들어진 프로토콜

TCP(Transmission Control Protocol)
인터넷상에서 데이터를 빠짐없이, 순서대로, 정확하게 주고 받기 위해
상호 간에 신뢰할 수 있는 연결을 맺는 프로토콜

UDP(User Datagram Protocol)
인터넷에서 데이터를 주고 받을 때 정확성이나 순서 보다는 '속도'를 최우선으로
하는 통신 규약

FTP()
파일을 주고받는 프로토콜

==============================================
모듈
socket : 네트워크의 가장 낮은 수준에서 TCP 연결을 직접 맺어 포트 상태를 확인할 때 사용
subprocess : 파이썬 코드 안에서 운영체제의 셸(CMD, 터미널) 명령어를 실행하고 결과를 받아온다.
urllib.request :  HTTP/HTTPS/ 웹 페이지를 요청하고 서버의 응답(상태 코드 등)을 파싱할 때 사용
==============================================
cheker.py(위의 각 네트워크 점검에 필요한 함수들을 보유하고 있는 기본 클래스)
Checker 클래스 : run()를 정의만..

HttpChecker 클래스 : 웹 사이트 점검
    서버에서 반환한 reaponse코드가 200인지 확인 200이면 True
    urllib.request.urlopen()를 이용하여 설정된 URL로 접속을 시도.
    
IcmpChecker 클래스 : ping 점검
 returncode가 0인지를 확인
 platform.system()를 이용하여 Window, Mac, Linux인지를 판별 ping을 1회 보내고 경과를 확인
 subprocess.run()를 이용하여 파이썬 내부 터미널 명령어를 직접 실행. 그 결과를 캡처.
 내부 터미널 명령어가 오류없이 정상적으로 종료(returncode==0)이면 True
 
TcpChecker 클래스 : port 개방 점검
 지정한 port가 열려 있으면 True
 socket.create_connection()를 이용하여 IP의 해당 port로 직접 TCP연결을 시도
'''

# -*- coding: utf-8 -*-
"""
교재 예제 파일: 네트워크 점검 스레드 적용
"""

import tkinter as tk
from tkinter import ttk, messagebox
import threading
import queue
from checker import HttpChecker, IcmpChecker, TcpChecker

TYPES = {"HTTP/HTTPS": HttpChecker, "ICMP": IcmpChecker, "TCP": TcpChecker}


class App:
    def __init__(self, root):
        self.root = root
        root.geometry("700x450")

        self.checkers = {}
        self.result_queue = queue.Queue()

        top = ttk.Frame(root, padding=10)
        top.pack(fill="x")
        self.type_cb = ttk.Combobox(top, values=list(TYPES), state="readonly", width=12)
        self.type_cb.current(0)
        self.type_cb.pack(side="left")
        self.target_entry = ttk.Entry(top, width=30)
        self.target_entry.pack(side="left", padx=5)
        ttk.Label(top, text="포트:").pack(side="left")
        self.port_entry = ttk.Entry(top, width=8)
        self.port_entry.pack(side="left", padx=(2, 5))
        ttk.Button(top, text="추가", command=self.add).pack(side="left")

        cols = ("type", "target", "result", "detail")
        self.tree = ttk.Treeview(root, columns=cols, show="headings")
        for c, t in zip(cols, ("유형", "대상", "결과", "상세")):
            self.tree.heading(c, text=t)
        self.tree.tag_configure("ok", foreground="green")
        self.tree.tag_configure("fail", foreground="red")
        self.tree.pack(fill="both", expand=True, padx=10)

        bottom = ttk.Frame(root, padding=10)
        bottom.pack(fill="x")
        self.check_btn = ttk.Button(bottom, text="전체 점검", command=self.check_all)
        self.check_btn.pack(side="left")
        ttk.Button(bottom, text="전체 삭제", command=self.clear).pack(side="left", padx=5)

        self.root.after(100, self.process_queue)

    def add(self):
        ctype = self.type_cb.get()
        cls = TYPES[ctype]
        target = self.target_entry.get().strip()
        port = self.port_entry.get().strip()
        if not target:
            messagebox.showwarning("입력 오류", "대상을 입력하세요.")
            return

        if cls is TcpChecker:
            if not port.isdigit():
                messagebox.showwarning("입력 오류", "TCP는 숫자 포트가 필요합니다.")
                return
            checker = cls(target, port)
            shown = f"{target}:{port}"
        else:
            checker = cls(target)
            shown = target

        iid = self.tree.insert("", tk.END, values=(ctype, shown, "-", ""))
        self.checkers[iid] = checker
        self.target_entry.delete(0, tk.END)

    def check_all(self):
        if not self.checkers:
            return

        self.check_btn.config(state="disabled")
        for iid in self.checkers:
            self.tree.set(iid, "result", "점검 중…")
            self.tree.set(iid, "detail", "")
            self.tree.item(iid, tags=())

        targets = list(self.checkers.items())
        thread = threading.Thread(target=self.run_checks, args=(targets,), daemon=True)
        thread.start()

    def run_checks(self, targets):
        for iid, checker in targets:
            try:
                ok, detail = checker.run()
                self.result_queue.put((iid, "정상" if ok else "실패", detail,
                                       "ok" if ok else "fail"))
            except Exception as e:
                self.result_queue.put((iid, "오류", str(e), "fail"))
        self.result_queue.put(("__done__", None, None, None))

    def process_queue(self):
        try:
            while True:
                iid, result, detail, tag = self.result_queue.get_nowait()
                if iid == "__done__":
                    self.check_btn.config(state="normal")
                    continue

                if self.tree.exists(iid):
                    self.tree.set(iid, "result", result)
                    self.tree.set(iid, "detail", detail)
                    self.tree.item(iid, tags=(tag,))
        except queue.Empty:
            pass
        finally:
            self.root.after(100, self.process_queue)

    def clear(self):
        for iid in self.tree.get_children():
            self.tree.delete(iid)
        self.checkers.clear()


if __name__ == "__main__":
    root = tk.Tk()
    App(root)
    root.mainloop()

# ==================================================
# 참고 예제 코드 (Reference Code)
# ==================================================

# [코드 조각]
# self.result_queue = queue.Queue()

# [코드 조각]
# self.root.after(100, self.process_queue)

# [코드 조각]
# def check_all(self):
#     if not self.checkers:
#         return
# 
#     self.check_btn.config(state="disabled")
#     for iid in self.checkers:
#         self.tree.set(iid, "result", "점검 중…")
#         self.tree.set(iid, "detail", "")
#         self.tree.item(iid, tags=())
# 
#     targets = list(self.checkers.items())
#     thread = threading.Thread(target=self.run_checks, args=(targets,), daemon=True)
#     thread.start()

# [코드 조각]
# def run_checks(self, targets):
#     for iid, checker in targets:
#         try:
#             ok, detail = checker.run()
#             self.result_queue.put((iid, "정상" if ok else "실패", detail,
#                                    "ok" if ok else "fail"))
#         except Exception as e:
#             self.result_queue.put((iid, "오류", str(e), "fail"))
#     self.result_queue.put(("__done__", None, None, None))

# [코드 조각]
# def process_queue(self):
#     try:
#         while True:
#             iid, result, detail, tag = self.result_queue.get_nowait()
#             if iid == "__done__":
#                 self.check_btn.config(state="normal")
#                 continue
#             if self.tree.exists(iid):
#                 self.tree.set(iid, "result", result)
#                 self.tree.set(iid, "detail", detail)
#                 self.tree.item(iid, tags=(tag,))
#     except queue.Empty:
#         pass
#     finally:
#         self.root.after(100, self.process_queue)

자세한 설명은 pdf 04에..

0721 아키텍처/데이터파이프라인 +GUI

인뽕 — Tue, 21 Jul 2026 17:12:55 +0900

아키텍처 (Architecture)

IT 분야에서 아키텍처(Architecture)란
소프트웨어나 시스템을 구성하는 핵심 요소들과
그 요소들이 상호작용하는 방식
그리고 전체 시스템을 설계하고 발전시키는 기반 규칙을 의미

쉽게 말해 건물을 지을 때 뼈대와 배관, 전기 회선의 위치를 잡는 '건축 설계도'와 같다.
인테리어(UI/UX)를 꾸미기 전에 건물이 무너지지 않고 효율적으로 기능하도록 튼튼한 구조를 잡는 작업

아키텍처의 핵심 구성 요소

아키텍처는 보통 다음 세 가지를 정의.

컴포넌트(Components):
시스템을 이루는 조각들입니다.
프론트엔드(화면), 백엔드 서버, 데이터베이스, 외부 API 등이 여기에 해당합니다.

관계와 상호작용(Interactions):
컴포넌트들이 어떻게 데이터를 주고받는지 정의.(우리는 데이터 파이프라인)
(예: "사용자가 로그인하면, 서버는 데이터베이스에서 정보를 확인하고 화면에 결과를 반환한다.")

제약 조건과 규칙(Rules & Constraints):
보안 기준, 데이터 저장 방식, 트래픽이 몰렸을 때 서버를 늘리는 방식 등
시스템이 지켜야 할 원칙.

주요 아키텍처의 종류

관점에 따라 여러 가지로 나뉘지만, 대표적으로 두 가지.

시스템 아키텍처 (인프라 관점):
하드웨어, 네트워크, 클라우드 서버, 데이터베이스 등
물리적/가상적 자원들이 어떻게 배치되고 연결되는지?.

소프트웨어 아키텍처 (코드 관점):
개발자들이 작성하는 애플리케이션 코드를
어떤 패턴(예: MVC 패턴)과 구조로 분리하여 짤 것인지?.

가장 대표적인 아키텍처 패턴 비교

모놀리식(Monolithic)은 모든 시설이 한 층에 모여 있는 대형 마트이고,
마이크로서비스(MSA)는 개별 매장들이 골목에 모여 상권을 이룬 전통 시장!

1. 모놀리식(Monolithic) 아키텍처

소프트웨어의 모든 기능(사용자 관리, 결제, 게시판 등)과
데이터베이스 접근 로직이 단일 코드베이스로 작성되고,
하나의 통짜 애플리케이션으로 배포되는 전통적인 구조.

장점:
초기 개발 속도가 매우 빠르다.
코드가 한곳에 있어 디버깅이나 흐름을 파악하기 쉽다.
하나의 결과물로 빌드되므로 테스트와 배포 과정이 단순.

단점:
서비스가 커질수록 코드가 방대해져
작은 수정 하나를 위해 전체 시스템을 다시 빌드하고 배포해야 한다.
특정 기능(예:결제)에 트래픽이 몰려도 전체 서버의 사양을 높여야 하므로 비효율적.
한 부분의 치명적인 버그가 전체 시스템을 멈추게 할 수 있다.

2. 마이크로서비스 아키텍처 (MSA)

애플리케이션을 핵심 비즈니스 기능(예: 회원 서비스, 주문 서비스, 결제 서비스) 단위로 잘게 쪼개고,
각각 독립적으로 작동하는 서비스들의 조합으로 구축하는 방식.
서비스들은 주로 API(네트워크)를 통해 서로 통신.

장점:
부분적인 수정과 독립 배포가 가능.
다른 서비스에 영향을 주지 않고 하루에도 수십 번씩 업데이트할 수 있다.
트래픽이 몰리는 특정 서비스(예: 이벤트 기간의 '주문' 서비스)만
서버를 늘려 유연하게 대처할 수 있다.
하나의 서비스가 다운되어도 전체 시스템은 계속 작동(장애 격리).

단점:
네트워크 통신이 필수적이므로
전체적인 구조와 트랜잭션 관리가 매우 복잡해진다.
여러 서비스에 걸쳐 있는 오류를 추적(디버깅)하고 통합 테스트를 하기가 어렵다.
초기 아키텍처 설계와 인프라 구축 비용이 높다.

=========================================================

데이터 파이프라인(Data Pipeline)

데이터 파이프라인은
다양한 소스(출처)에서 발생한 원시 데이터(Raw Data)를 수집하여,
분석이나 활용이 가능한 형태로 가공한 뒤,
목적지(데이터 웨어하우스, 데이터 레이크 등)로 안전하게 이동시키는
'자동화된 데이터 흐름 체계'를 말한다.

데이터 웨어하우스 (Data Warehouse) :
개념: 분석을 위해 사전에 정의된 규칙(스키마)에 맞게 잘 정제되고 구조화된 데이터만 모아두는 중앙 저장소.
데이터 형태: 엑셀이나 관계형 데이터베이스(RDB)처럼 행(Row)과 열(Column)이 명확한 구조화된 데이터(Structured Data)만 저장

데이터 레이크 (Data Lake)
비유: 비, 강물, 지하수 등 다양한 형태의 물이 자연 그대로 흘러들어와 고이는 '거대한 자연 호수'
개념: 데이터의 용도나 형태를 미리 정하지 않고, 생성된 원시 데이터(Raw Data)를 가공하지 않은 상태 그대로 무한정 쏟아붓는 방대한 저장소

데이터 레이크하우스:
데이터 레이크의 유연하고 저렴한 스토리지 위에,
데이터 웨어하우스의 강력한 데이터 관리와 빠른 검색 성능(SQL 엔진)을 얹은 통합 플랫폼

쉽게 비유하자면 '정수장의 상수도 시스템'과 같다.
강물이나 호수(다양한 데이터 소스)에서 물을 끌어와,
파이프를 통해 정수장으로 보내 불순물을 걸러내고(데이터 가공 및 정제),
최종적으로 각 가정의 수도꼭지(데이터 분석가, AI 모델 등 목적지)로 깨끗한 물을 배달하는전체 인프라가 바로 데이터 파이프라인.

핵심 구성 요소 (ETL 과정)

데이터 파이프라인은 일반적으로 ETL이라는 세 가지 주요 단계를 거쳐 구축.

(최근에는 클라우드의 발달로 순서가 바뀐 ELT 방식도 많이 쓰입니다.)

추출 (Extract):

웹사이트 접속 로그, 결제 시스템의 트랜잭션, 소셜 미디어 API, 스마트폰 앱 등

여러 곳에 흩어져 있는 원시 데이터를 수집하여 가져오는 단계.

변환 (Transform):

가져온 듬성듬성한 데이터를 분석하기 좋게 쓸모 있게 만드는 과정.

중복이나 오류 데이터를 제거하고(정제), 날짜 형식을 통일하며,

민감한 개인정보를 마스킹(암호화)하는 등의 작업이 이루어진다.

적재 (Load):

잘 가공된 데이터를 데이터 웨어하우스(Data Warehouse)나 클라우드 저장소 등 최종 목적지에 저장하여,

분석가나 마케터가 언제든 꺼내 쓸 수 있게 만든다.

데이터 파이프라인이 왜 중요한가요?

수작업 및 오류 감소:

과거에는 개발자나 데이터 담당자가 직접 엑셀이나 쿼리로 데이터를 모으고 가공했다면,

파이프라인은 이를 24시간 자동으로 처리하여 업무 효율을 높이고 휴먼 에러를 방지.

신속한 의사결정 (Real-time):

데이터가 실시간 또는 정해진 주기마다 빠르게 업데이트되므로,

기업은 최신 데이터를 바탕으로 즉각적인 비즈니스 결정을 내릴 수 있다.

AI와 빅데이터의 핵심 기반:

인공지능 모델을 학습시키거나 비즈니스 대시보드를 만들 때

가장 중요한 것은 '깨끗하고 믿을 수 있는 데이터'.

튼튼하고 안정적인 파이프라인 없이는 AI 도입이나 데이터 기반 의사결정이 불가능!!!.

GUI-tkinter 심화

앞 장에서 tkinter의 기본 위젯과 이벤트 처리 흐름을 익혔다면, 이번 장에서는 GUI 프로그램을 더 체 계적으로 구성하는 방법을 살펴봅니다. 간단한 프로그램은 함수 중심의 절차적 코드만으로도 충분히 만들 수 있습니다. 하지만 버튼 하나, 입력창 하나가 늘어날 때마다 전역 변수가 많아지고, 위젯과 함수가 서로 얽히면서 코드를 읽고 고치 기가 점점 어려워집니다. 기능이 많아질수록 "동작하는 코드"를 넘어 "정리된 코드"를 고민해야 하는 이유입니다. 먼저 절차적 코드가 어디에서 한계를 드러내는지 확인하 고, 이를 객체 지향 프로그래밍(OOP)으로 다시 구성하면 어떤 점이 나아지는지 비교해 봅니다. 이어서 Model(데이터와 비즈니스 로직), View(화면표시와 사용자 입력받기), Presenter (Model과 View를 연결하는 중재자) 로 프로그램의 코드를 역할에 따라 나누는 아키텍처를 가볍게 맛봅니다.

데이터 상태와 바인딩

GUI 프로그램을 작성하다 보면 한 번쯤 다음과 같은 고민을 하게 됩니다. "입력창에 적힌 값을 어떻게 가져오지?" "버튼을 누르면 화면의 글자를 어떻게 바꾸지?" 단순한 구조에서는 위젯을 직접 제어하여 대응할 수 있지만, UI가 복잡해질수록 데이터의 흐름과 상 태 변화를 수동으로 추적하는 것은 유지보수를 크게 저하시킵니다. 이 장에서는 이러한 복잡성을 해소할 핵심 개념으로 Tkinter 변수 클래스와 데이터 바인딩(Data Binding)을 다룹니다. 이를 적용하면 위젯을 직접 조작하는 방식이 아니라 데이터의 상태 변화만으 로 화면이 자동 동기화되는 효율적인 프로그램을 작성할 수 있습니다.

상태(State)란?

상태란 한마디로 '프로그램이 지금 이 순간 기억하고 있는 데이터' 를 말합니다. 거창해 보이지만, 우리가 화면에서 보는 거의 모든 것이 상태입니다. 체크박스에 체크가 되어 있는가, 아닌가 사용자가 입력창에 어떤 글자를 적었는가 지금 화면에 보이는 숫자가 몇인가 이런 것들이 모두 프로그램의 '상태'입니다. 프로그램을 만든다는 것은 결국 이 상태를 잘 보관하 고, 잘 바꾸고, 화면에 잘 보여 주는 일 이라고 할 수 있습니다.

데이터 바인딩이란?

문제는, 우리가 평소에 쓰던 일반 변수로는 상태를 화면과 연결하기가 번거롭다는 점입니다.

my_name = "홍길동" # 일반 변수

이렇게 만든 변수는 값이 바뀌어도 화면에 그 사실을 스스로 알려 주지 않습니다. 화면을 새 값으 로 바꾸고 싶다면, 우리가 코드로 매번 직접 라벨이나 텍스트를 갱신해 주어야 합니다. 비유하자면, 일반 변수는 "내 값이 바뀌었어!"라고 아무에게도 말하지 않는

조용한 변수 입니다. 데이터 바인딩은 이 불편함을 없애 줍니다. 데이터 바인딩이란 '데이터(변수)'와 '화면(위젯)'을 하 나로 묶어(Bind) 버리는 것 입니다. 한 번 묶어 두면 다음이 자동으로 일어납니다. 변수의 값을 바꾸면 → 화면이 알아서 바뀐다 화면에서 사용자가 값을 바꾸면 → 변수 안의 데이터도 알아서 바뀐다 즉, 우리는 화면이 아니라 변수 하나만 신경 쓰면 됩니다. 나머지는 tkinter가 대신 처리해 줍니다.

상태와 데이터 바인딩

tkinter 변수 클래스

데이터 바인딩을 하려면, 파이썬의 일반 변수 대신 tkinter 전용 변수 클래스를 써야 합니다. 이 변수들은 값이 바뀔 때마다 화면에 "값이 바뀌었어!"라고 신호를 보내 주는 특별한 변수입니다.

.set(), .get() 사용으로 값을 다룸

#라벨과 변수 묶기

# 기존의 변수 사용

import tkinter as tk

root = tk.Tk()
message = tk.StringVar()
message.set("초기값")


label = tk.Label(root, text=message.get())
label.pack(padx=20, pady=20)

def change_text():
    message.set("버튼을 눌러서 바뀐 값!")  # 이 한 줄만으로 label이 자동 갱신됨

btn = tk.Button(root, text="값 변경", command=change_text)
btn.pack()

root.mainloop()

결과

값 변경 버튼을 눌러도, 라벨의 text=message.get()(일반변수)를 사용했기 때문에 처음에 저장한 "초기값"이라는 문자열이 변하지 않는다.

# textvariable 방식 (자동 갱신됨)

import tkinter as tk

root = tk.Tk()
message = tk.StringVar()
message.set("초기값")

# textvariable 방식 (자동 갱신됨)
label = tk.Label(root, textvariable=message)
label.pack(padx=20, pady=20)

def change_text():
    message.set("버튼을 눌러서 바뀐 값!")  # 이 한 줄만으로 label이 자동 갱신됨

btn = tk.Button(root, text="값 변경", command=change_text)
btn.pack()

root.mainloop()

결과

textvariable=message 인자를 사용했기 때문에, 값 변경을 누르고 message.set한 문자열이 실시간으로 출력된다.

#라디오 버튼
#여러 선택지 중 하나만 고르는 라디오버튼은 IntVar 로 관리합니다.
#각 라디오버튼에 value 값을 정해 주고, 같은 변수에 묶어 두면 어떤 것을 골랐는지
# 변수 하나로알 수 있습니다.
# 라디오 버튼 선택에 따른 라벨 실시간 출력

import tkinter as tk
def show_result():
    label.config(text="난이도 : " + level_var.get())

root = tk.Tk()
level_var = tk.StringVar(value="쉬움")
for level in ["쉬움", "보통", "어려움"]:
    tk.Radiobutton(root, text=level, variable=level_var, value=level,
                   command=show_result).pack(anchor="w")
label = tk.Label(root, text="")
label.pack(pady=10)

root.mainloop()

결과

text는 라디오 버튼 옆에 표시 될 글자.

variable은 k.StringVar(value="쉬움") 객체.

value는 해당 라디오 버튼이 선택되었을 때 level_var에 실제로 저장될 값.

command는 사용자가 라디오버튼 중 하나를 클릭할 때마다 실행될 함수를 지정.

anchor은 라디오버튼을 정렬할 방향.(서쪽)

#"OOP 기반 GUI 구조 설계" 의 중요성을 이해하기 위한 단계별
# To-do list 프로그램 만들기

import tkinter as tk
root = tk.Tk()
root.geometry("300x250")
listbox = tk.Listbox(root)
listbox.pack(fill="both", expand=True, padx=10, pady=(0, 7))
entry = tk.Entry(root)
entry.pack(fill="x", padx=10, pady=10)
def add_item():
    text = entry.get().strip()
    if text:
        listbox.insert(tk.END, text)
        entry.delete(0, tk.END) #ux를 위해 엔트리를 비워준다
button = tk.Button(root, text="추가", command=add_item)
button.pack(pady=(0, 10))

root.mainloop()

결과

# 삭제 기능 추가

import tkinter as tk
root = tk.Tk()
root.geometry("300x400")
listbox = tk.Listbox(root)
listbox.pack(fill="both", expand=True, padx=10, pady=(0, 7))

entry = tk.Entry(root)
entry.pack(fill="x", padx=10, pady=10)
def add_item():
    text = entry.get().strip()
    if text:
        listbox.insert(tk.END, text)
        entry.delete(0, tk.END)
def delete_item():
    selected_indices = listbox.curselection()
    if selected_indices:
        listbox.delete(selected_indices[0])

add_button = tk.Button(root, text="추가", command=add_item)
add_button.pack(pady=(0, 5))

delete_button = tk.Button(root, text="삭제", command=delete_item)
delete_button.pack(pady=(0, 10))

root.mainloop()

결과

리스트박스의 항목을 선택하고 삭제 버튼을 누르면 삭제 되는 기능 추가.

# 완료 처리 추가

import tkinter as tk

root = tk.Tk()
root.geometry("300x400")

total_count = 0
done_count = 0

listbox = tk.Listbox(root)
listbox.pack(fill="both", expand=True, padx=10, pady=(0, 7))

entry = tk.Entry(root)
entry.pack(fill="x", padx=10, pady=10)

status_label = tk.Label(root, text="전체 0개 / 완료 0개")
status_label.pack()

def update_status():
    global total_count, done_count
    status_label.config(text=f"전체 {total_count}개 / 완료 {done_count}개")

def add_item():
    global total_count
    text = entry.get().strip()
    if text:
        listbox.insert(tk.END, text)
        entry.delete(0, tk.END)
        total_count += 1
        update_status()

def delete_item():
    global total_count
    selected = listbox.curselection()
    if selected:
        listbox.delete(selected[0])
        total_count -= 1
        update_status()

def mark_done():
    global done_count
    selected = listbox.curselection()
        if selected:
            text = listbox.get(selected[0])
            listbox.delete(selected[0])
            listbox.insert(selected[0], "[완료] " + text)
            done_count += 1
            update_status()
def clear_all():
    global total_count, done_count
    listbox.delete(0, tk.END)
    total_count = 0
    done_count = 0
    update_status()

add_button = tk.Button(root, text="추가", command=add_item)
add_button.pack()

done_button = tk.Button(root, text="완료 처리", command=mark_done)
done_button.pack()

delete_button = tk.Button(root, text="삭제", command=delete_item)
delete_button.pack()

clear_button = tk.Button(root, text="전체 비우기", command=clear_all)
clear_button.pack()

root.mainloop()

결과

완료한 일정을 표시하는 기능과 전체 삭제 기능 추가.

아따 길다 길어

'''
절차적 코드의 4가지 한계

#global 키워드의 남발

상태 변수 total_count, done_count가 전역이라, 이 값을 바꾸는 모든 함수가 야 합니다.
위 코드에 global 선언을 해 global 이 다섯 번이나 등장하고, 함수가 늘수록 계속 따라붙습니다.
global 이 많아질수록 어떤 함수가 어떤 상태를 건드리는지 파악하기 어렵습니다.
def mark_done():
    # global done_count  ← 이 줄을 빠뜨리면?
    done_count += 1      # 에러는 없지만, 카운터가 증가하지 않습니다.
global 을 깜빡하면 파이썬은 조용히 새 지역 변수를 만들어, 값이 반영되지 않는 버그가 생깁니다.
에러 메시지 없이 동작만 이상해지므로 찾기가 까다롭습니다.
위젯과 변수가 같은 공간에 노출entry , listbox , status_label, 버튼 다섯 개까지
모든 위젯이 전역 공간에 놓여 있습니다.함수도 상태 변수도 같은 공간이라, 프로그램이 커지면 
수십 개의 이름으로 가득 찹니다.이름이 많아지면 충돌 위험도 커집니다. 
무심코 entry 를 다시 쓰면 기존 것이 덮어써져 기능이 망가집니다.
어떤 위젯이 어느 기능에 속하는지 코드 구조만으로는 알 수 없습니다.

#같은 화면을 여러 개 만들 수 없음

가장 본질적인 한계입니다. 위 코드는 "할 일 목록 하나"에 완전히 묶여 있습니다.
한 창에 개인용·업무용 목록을 나란히 두고 싶어도 방법이 없습니다. listbox, total_count,
add_item이 하나씩만 존재하기 때문입니다.

두 번째 목록을 만들려면 listbox2, total_count2처럼 전부 복사해 이름만 바꿔야 하고, 세 개면 또
한 번을 복사합니다.
반면 CounterFrame 같은 클래스는 CounterFrame(root)를 두 번 호출하면 독립된 인스턴스가 
둘 생기고, 각자의 상태와 위젯을 가져 서로 간섭하지 않습니다.

#상태와 동작의 분리

total_count 데이터와 이를 바꾸는 add_item, delete_item, clear_all은 논리적으로 한 덩어리입니다.
하지만 절차적 코드에서는 변수는 위, 함수는 가운데, 위젯은 아래로 흩어져 있습니다.
관련 코드가 떨어져 있으면 기능 하나를 고칠 때 곳곳을 오가야 합니다.
"할 일 목록 로직"만 떼어 재사용하려 해도 경계가 분명하지 않아 추출이 어렵습니다.

정리하며
한계                         핵심 증상
global 남발                   상태 변경 함수마다 선언이 붙고, 빠뜨리면 조용한 버그
이름 공간 오염                  모든 이름이 한 공간에 뒤섞여 충돌 위험  
복제 불가                      같은 화면을 여러 개 만들 수 없음
상태·동작 분리                  관련 코드가 흩어져 수정·재사용이 어려움 

'''

#OOP 기반 GUI 구조 설계

'''
클래스 도입에 따른 구조적 장점

위젯이 self.label 처럼 객체의 속성이 되어, 어느 메서드에서든 바로 접근할 수 있습니다.
관련 동작이 메서드로 모여, 코드가 기능 단위로 정리됩니다.
화면을 통째로 재사용하거나, 일부만 떼어 테스트하기 쉬워집니다

self란?
클래스 안에서 "자기 자신"을 가리키는 이름입니다. 
self.label 은 "이 객체가 가진
label "이라는 뜻으로, 객체 안 어디서든 같은 위젯을 가리킵니다.
'''

# Tk 직접 상속

import tkinter as tk
class Application(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry("300x80")
        self.label = tk.Label(self, text="안녕하세요")
        self.label.pack(pady=5)
        tk.Button(self, text="클릭", command=self.on_click).pack()
    def on_click(self):
        self.label.config(text="버튼을 눌렀습니다")

if __name__ == "__main__":
    Application().mainloop()

위젯을 self.label 처럼 속성으로 두었기 때문에,on_click 안에서 바로 접근할 수 있 습니다.
위젯을 일일이 전역 변수로 두거나 인자로 주고받을 필요가 없습니다.

#Frame 상속
#재사용 가능한 부품으로 캡슐화 실무에서는 Tk를 직접 상속하기보다 Frame 을 상속하는 방식을 더 권장합니다.
#Frame 은 여러 위젯을 담는 컨테이너이므로, 이를 상속한 클래스는 그 자체로 하나의 "부품(컴
#포넌트)"이 됩니다. 여러 개를 조합하거나 다른 창에 끼워 넣기 쉽습니다.

import tkinter as tk

class CounterFrame(tk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.count = 0
        self.display = tk.Label(self, text="0", font=("맑은 고딕", 24))
        self.display.pack(pady=10)
        tk.Button(self, text="+1", command=self.increase).pack()

    def increase(self):
        self.count += 1
        self.display.config(text=str(self.count))

if __name__ == "__main__":
    root = tk.Tk()
    CounterFrame(root).pack(padx=20, pady=20)
    root.mainloop()

결과

tk.Tk()를 우선 실행하여 root를 만들고, 위젯들을 프레임 단위로 관리한다.

#두번째 예제

import tkinter as tk
class NameInput(tk.Frame):
    def __init__(self, master, on_submit):
        super().__init__(master)
        self.on_submit = on_submit
        self.entry = tk.Entry(self)
        self.entry.pack(side="left")
        tk.Button(self, text="인사하기", command=self.submit).pack(side="left")

    def submit(self):
        self.on_submit(self.entry.get())
class Greeting(tk.Frame):
    def __init__(self, master):
        super().__init__(master)
        self.label = tk.Label(self, text="", font=("맑은 고딕", 14))
        self.label.pack()
    def show(self, name):
        self.label.config(text=f"안녕하세요, {name}님!")
class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry("300x120")
        self.greeting = Greeting(self)
        self.name_input = NameInput(self, on_submit=self.greeting.show)
        self.name_input.pack(pady=10)
        self.greeting.pack(pady=10)
if __name__ == "__main__":
    App().mainloop()

결과

#세번째 예제

#다중 페이지 전환
#페이지를 겹쳐 두고 바꿔 올리기
#로그인 화면에서 메인 화면으로 넘어가듯 여러 페이지를 전환해야 할 때, 각 페이지를 Frame 으로
#만들어 같은 위치에 겹쳐 둔 뒤 보여 줄 페이지만 맨 위로 끌어올리는 패턴을 자주 씁니다.

import tkinter as tk
class PageOne(tk.Frame):
    def __init__(self, master, controller):
        super().__init__(master)
        tk.Label(self, text="첫 번째 페이지", font=("맑은 고딕", 16)).pack(pady=20)
        tk.Button(self, text="다음으로",
                  command=lambda: controller.show_page("PageTwo")).pack()
class PageTwo(tk.Frame):
    def __init__(self, master, controller):
        super().__init__(master)
        tk.Label(self, text="두 번째 페이지", font=("맑은 고딕", 16)).pack(pady=20)
        tk.Button(self, text="이전으로",
                  command=lambda: controller.show_page("PageOne")).pack()
class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry("300x200")
        self.pages = {}
        for PageClass in (PageOne, PageTwo):
            page = PageClass(self, self)
            self.pages[PageClass.__name__] = page
            page.grid(row=0, column=0, sticky="nsew")
        self.show_page("PageOne")
    def show_page(self, name):
        self.pages[name].tkraise()
if __name__ == "__main__":
    App().mainloop()

실행시

다음으로 버튼 누를 시

처음에는 App 클래스 부분이 이해가 잘 안됐다.

생성자에서, 부모(tk.Tk)의 생성자를 호출하고, pages라는 페이지들의 객체를 요소로 갖는 딕셔너리를 정의한다.

PageOne, PageTwo 클래스를 묶은 튜플을 순회하여 각 클래스의 생성자를 호출한다.

생성된 page를 pages의 요소로 넣는다. key는 클래스 이름(PageOne, PageTwo), value는 해당 페이지.

0720

인뽕 — Mon, 20 Jul 2026 21:34:36 +0900

GUI

파이썬 GUI가 필요한 이유

피지컬 AI(Physical AI)와 tkinter는 한마디로 인공지능이 탑재된 물리적 기기(로봇, 센서 등)를 조종하고 모니터링 하는 데스크톱 리모컨을 만드는 과정.

1. 두 기술의 역할 분담

이 둘을 결합할 때 각각은 명확한 역할을 수행합니다.

피지컬 AI (두뇌 + 감각/근육):
카메라, 마이크, 온습도 센서 등을 통해 현실 세계의 데이터를 수집.
이를 AI 모델(머신러닝 등)로 분석한 뒤
물리적인 행동(로봇 팔 이동, 모터 작동 등)을 수행하거나 데이터를 반환.

tkinter (사용자 소통 창구):
사람이 피지컬 AI의 상태를 눈으로 확인하고,
명령을 내릴 수 있도록
버튼, 그래프, 텍스트 입력창 등 GUI(그래픽 사용자 인터페이스)를 그려준다.

2. 대표적인 활용 사례

tkinter는 파이썬에 기본 내장되어 있어 별도 설치가 필요 없고 매우 가볍기 때문에,
피지컬 AI 연구나 하드웨어 제어 프로토타입을 만들 때 널리 쓰인다.

로봇 제어 패널 (HMI):
로봇의 현재 위치, 센서 값, 배터리 상태를 tkinter 창에 띄우고,
창에 있는 방향키 버튼을 눌러 로봇을 원격 조종한다.

엣지 디바이스(초소형 기기)의 터치스크린:
라즈베리파이(Raspberry Pi) 같은 소형 컴퓨터에 센서와 AI 모델을 올린 뒤,
작은 LCD 디스플레이에 tkinter로 만든 UI를 전체 화면으로 띄워
스마트 기기(음성 인식기, 스마트 도어록 등)처럼 작동하게 만든다.

실시간 AI 모니터링:
웹캠이 인식한 사람의 행동(비전 AI)이나
마이크로 들어온 음성 데이터 분석 결과를
tkinter 창에 텍스트나 그래프로 실시간 업데이트하여 보여준다.

3. 한계와 대안

피지컬 AI 시스템에 tkinter를 사용할 때 반드시 고려해야 할 가장 큰 한계는
'데스크톱 로컬 환경'에 묶인다는 점

- 출처 : https://cafe.naver.com/f-e/cafes/15757610/articles/15333?menuid=328&referrerAllArticles=false

tkinter

tkinter는 파이썬에서 GUI 프로그램을 만들 때 사용하는 표준 모듈이다.

GUI 창, 버튼, 라벨, 입력창 같은 요소들이 모두 이 모듈 안에 포함

#창 띄우기

import tkinter as tk

#tk,Tk() 는 GUI 프로그램의 기본 창
# 보통 루트 창(root Window)
root=tk.Tk()
root.title("tkinter로 파이썬 GUI 배우기")
root.geometry("200x500+100+300")# +연산자를 사용해서 창 시작 위치도 설정 가능"가로x세로+x좌표+y좌표"
root.configure(bg="white") # 창의 배경색 설정 bg는 백그라운드
#root.resizable(False, False)# 가로/세로 창 크기 변경 막아놓는 함수
#창 크기 변경 자체는 허용하되, 너무 작아지거나 너무 커지는 것을 막고 싶을 수 있습니다. 최소 창 크기와 최대 창 크기 지정 가능
#root.minsize(300, 200)
#root.maxsize(800, 600)

기본 윈도우를 띄우는 코드이다.

#라벨 (어디에, 어떤 글자를 표시하겠다)

label =tk.Label(root, text='라벨입니다.') #첫 인자로 root를 넣어 어떤 윈도우에 포함되는지 명시
label.pack()# root와 label을 패킹

label = tk.Label(
root,
text="Python GUI",
font=("맑은 고딕", 16),
fg="white",         #폰트 색
bg="navy"           #배경 색
)
label.pack(padx=40,pady=10)

라벨 함수의 여러 인자들.

#버튼

def hello():
    label.config(text="clicked button",fg="red")

button = tk.Button(root, text="click!", command=hello)
button.pack()

text 옵션은 버튼에 표시할 글자입니다.
command 옵션은 버튼을 클릭했을 때 실행할 함수를 지정합니다.
config() 는 이미 만들어진 위젯의 옵션을 변경할 때 사용합니다.
여기서는 라벨의
text 옵션을 새 문자열로 바꾸었습니다
코드                              의미
command=hello       버튼을 클릭했을 때 hello 함수 실행
command=hello()     프로그램 시작 시 hello()를 바로 실행

#mainloop()

root.mainloop()
print("파이썬 핵심 요약 학습에 오신 것을 환영합니다!")

'''
mainloop()의 역할
# 콘솔 프로그램은 보통 위에서 아래로 실행된 뒤 종료.
하지만 GUI 프로그램은 조금 다르게 동작
# GUI 프로그램은 사용자가 어떤 행동을 할 떄까지 계속 기다린다.
#이러한 사용자의 동작을 이벤트라고 한다.
예) 창 닫기/ 버튼 클릭 / 키보드 입력/ 마우스 이동/ 창 크기 변경

tkinter 프로그램 세 단계
1. tkinter 모듈 가져오기
2. 기본 창 생성하기
3. mainloop()로 창 유지하기
-------------------------------------
'''

tkinter 프로그램 workflow

창 생성
⬇️
위젯 배치
⬇️
mainloop() 실행
⬇️
사용자 이벤트 대기
⬇️
이벤트 발생 시 처리
⬇️
창을 닫을 때까지 반복

#버튼 옵션과 상태적용 예제

import tkinter as tk
root = tk.Tk()
btn1 = tk.Button(root, text="두꺼운 테두리", bd=5, relief="raised", width=15)
# relief는 입체감이라는 뜻
# flat:평평함,sunken:화면 안으로 음푹 들어간 모양, groove: 테두리 선만 안으로 파인 모양, ridge: 테두리 선만 밖으로 튀어나온 모양,
# solid: 단순한 검은색 단선 테두리 사용 가능
btn1.pack(pady=5)
btn2 = tk.Button(root, text="커서 변경 (손가락)", cursor="hand2", bg="lightyellow")
#cursor에 쓸 수 있는 다른 유용한 옵션들
#"arrow" 기본 화살표 모양, "cross":십자선 모양(도면이나 그래프에서 위치를 지정할 때 유용
#"watch" : 시계 또는 모래시계 모양(로딩중이거나 작업중임을 나타낼 때 사용) "xterm": 텍스트 입력 칸에서 흔히 보이는 'I'모양의 텍스트 커서
btn2.pack(pady=5)
btn3 = tk.Button(root, text="클릭 불가", state="disabled")
btn3.pack(pady=5)
root.mainloop()

결과

#엔트리

'''
주요 옵션
옵션                      허용값                               설명

width   0 이상의 정수 (입력 문자 개수 기준)                  너비를 입력 문자 개수 기준으로 설정
font    ("맑은 고딕", 12) 형식의 튜플 또는 문자열             입력 글자의 글꼴, 크기, 스타일을 설정
fg      색상 이름( "black" ) 또는 16진수( "#000000" )       입력 글자의 색상을 설정
bg      색상 이름( "white" ) 또는 16진수( "#ffffff" )       입력 상자의 배경색을 설정
show    단일 문자 ( "*" 등)                                입력한 문자를 다른 문자로 표시(주로 비밀번호 입력창)
state   "normal" , "disabled" , "readonly"중 하나         입력 가능 상태를 설정
'''
# 비밀번호 입력 엔트리 만들기 예제
import tkinter as tk
root = tk.Tk()
password_entry = tk.Entry(root, show="*", width=30)
password_entry.pack(pady=20)
root.mainloop()

결과

# 텍스트 사용하기 예제

import tkinter as tk
root = tk.Tk()
text = tk.Text(root)
text.pack(pady=10)
root.mainloop()

결과

메모장 만들기가 이렇게 쉽다니... 윈플 실습 6-1은 지옥이었는데,,,

'''
메서드                         설명                          사용 예
get()               특정 범위의 텍스트 가져오기             text.get("1.0", tk.END)
delete()            특정 범위의 텍스트 지우기               text.delete("1.0", tk.END)
insert()            특정 위치에 텍스트 넣기                 text.insert("1.0", "안녕")


옵션                          허용값                                  설명
width                0 이상의 정수 (글자 수 기준)                     위젯의 너비를 '글자 수' 기준으로 설정
height               0 이상의 정수 (글자 수 기준)                     위젯의 높이를 '줄 수' 기준으로 설정
font                 ("Arial", 12) 형식의 튜플 또는 문자열            입력 글자의 글꼴, 크기 설정
bg                  색상 이름("white") 또는 16진수("#ffffff" )         배경색을 설정
fg                  색상 이름("white") 또는 16진수("#ffffff" )          글자색을 설정
wrap                "word" , "char" , "none" 중 하나                   텍스트가 위젯 너비를 넘어갈 때 줄바꿈 방식 설정

'''

#checkButton 예제

import tkinter as tk
def show_result():
    if agree_var.get():
        label.config(text="동의했습니다.")

root = tk.Tk()
agree_var = tk.BooleanVar()
check = tk.Checkbutton(root, text="동의합니다", variable=agree_var, command=show_result)
check.pack(padx=20, pady=20)
label = tk.Label(root, text="")
label.pack(pady=10)

root.mainloop()

결과

'''
주요 메서드
메서드                     설명
select()                체크 상태로 변경
deselect()              체크 해제 상태로 변경
toggle()                현재 상태를 반대로 변경
invoke()                사용자가 클릭한 것처럼 동작 실행

옵션                      허용 값                            설명                  
text                    임의의 문자열                     체크 버튼 옆에 표시할 문자열 설정
variable                Tkinter 변수 객체                체크 상태를 저장할 변수 설정  
onvalue                 정수 1 , 문자열 "yes" 등          체크되었을 때 변수에 저장할 값 설정
offvalue                정수 0 , 문자열 "no" 등           체크 해제되었을 때 변수에 저장할 값 설정
command                 함수 객체                        체크 상태가 바뀔 때 실행할 함수 설정
state                   "normal" , "disabled" 중 하나    위젯의 상태 설정

'''

#radiobutton 사용 예제

import tkinter as tk
root = tk.Tk()
food = tk.IntVar(value=1)
tk.Radiobutton(root, text="육고기", variable=food, value=1).pack()
tk.Radiobutton(root, text="해산물", variable=food, value=2).pack()
root.mainloop()

라디오버튼은 하나만 선택할 수 있는 체크박스이다.

결과

'''
주요 메서드
메서드                     설명
select()            라디오 버튼을 선택
deselect()          라디오 버튼의 선택 해제
invoke()            사용자가 클릭한 것처럼 동작 실행
주요 옵션
옵션                                  허용 값                                설명
text                                임의의 문자열                         라디오 버튼 옆에 표시할 문자열 설정
variable                            Tkinter 변수 객체                    선택값을 저장할 변수 설정
value                               변수 타입에 맞는 값                    라디오 버튼을 선택했을 때 변수에 저장할 값 설정
command                             함수 객체                            라디오 버튼을 선택했을 때 실행할 함수 설정
state                               "normal" , "disabled" 중 하나        위젯의 상태 설정

알아두기
Radiobutton은 같은 변수를 공유해야 합니다
여러 개의 Radiobutton이 하나의 그룹으로 동작하려면 모두 같은 variable을 사용해야 합니다.
'''

#리스트박스 예제

import tkinter as tk
def show_selected(event):
    label.config(text="선택한 항목: " + listbox.get(listbox.curselection()))
root = tk.Tk()
listbox = tk.Listbox(root, height=5)
listbox.pack(padx=10, pady=10)

for item in ["Python", "Java", "JavaScript", "C", "C++"]:
    listbox.insert(tk.END, item)
listbox.bind("<<ListboxSelect>>", show_selected)# 해당 항목에서 이벤트가 발생하면 특정 함수를 호출한다.
label = tk.Label(root, text="")
label.pack(pady=10)
root.mainloop()

결과

'''
메서드                     설명                                사용 예
insert()            항목 추가                        listbox.insert(tk.END, "Python")
delete()            항목 삭제                        listbox.delete(0)
get()               항목 가져오기                     listbox.get(0)
curselection()      선택된 항목의 인덱스 가져오기        listbox.curselection()
size()              전체 항목 개수 가져오기             listbox.size()
selection_set()     특정 항목 선택                    listbox.selection_set(0)
selection_clear()   선택 해제                       listbox.selection_clear(0, tk.END)

주요옵션
옵션                              허용 값                                        설명
width                0 이상의 정수 (글자 수 기준)                             위젯의 너비를 글자 수 기준으로 설정
height               0 이상의 정수 (줄 수 기준)                              표시할 항목의 줄 수 설정
selectmode          "browse" , "single" , "multiple" ,"extended" 중 하나   항목 선택 방식을 설정
font                ("Arial", 12) 형식의 튜플 또는 문자열                     목록 글자의 글꼴과 크기 설정
fg                  색상 이름( "black" ) 또는 16진수( "#000000" )            글자색 설정
bg                  색상 이름( "white" ) 또는 16진수( "#ffffff" )            배경색 설정

Listbox의 인덱스

Listbox의 항목 위치는 0부터 시작합니다. 첫 번째 항목은 0, 두 번째 항목은 1, 세 번째 항목은 2
입니다.
listbox.get(0)
위 코드는 Listbox의 첫 번째 항목을 가져옵니다.
'''

#스핀 박스 예제

import tkinter as tk
def show_value():
    label.config(text="선택한 수량: " + spinbox.get())
root = tk.Tk()
root.title("Spinbox 예제")
spinbox = tk.Spinbox(root, from_=1, to=10, width=10)
spinbox.pack(padx=10, pady=10)
button = tk.Button(root, text="확인", command=show_value)
button.pack(pady=5)
label = tk.Label(root, text="")
label.pack(pady=10)
root.mainloop()

스핀박스는 수량을 조절할 수 있는 박스이다.

결과

#문자열을 사용한 스핀박스

import tkinter as tk
def show_month():
    label.config(text="선택한 달: " + spinbox.get())
root = tk.Tk()
root.title("문자열 Spinbox")
#1월 부터 12월까지 선택할 수 있는 스핀박스
spinbox = tk.Spinbox(root, values=("1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월"), width=10)
spinbox.pack(padx=10, pady=10)

#선택된 값을 확인하는 버튼
button = tk.Button(root, text="확인", command=show_month)
button.pack(pady=5)

label = tk.Label(root, text="")
label.pack(pady=10)
root.mainloop()

결과

'''
주요 메서드
메서드                     설명
get()               현재 값 가져오기
delete()            입력된 값 삭제
insert()            값 삽입

주요 옵션

옵션                              허용 값                                        설명
from_                       실수 또는 정수                                   시작값 설정
to                          실수 또는 정수                                   끝값 설정
increment                   0보다 큰 실수 또는 정수                           값이 증가하거나 감소하는 단위 설정
values                      문자열 튜플 또는 리스트                           선택할 문자열 목록 설정
width                       0 이상의 정수 (글자 수 기준)                      위젯의 너비 설정
command                     함수 객체                                       위아래 버튼을 눌러 값이 바뀔 때 실행할 함수 설정
state                       "normal" , "readonly" , "disabled"중 하나       입력 가능 상태 설정
�
�
 알아두기
Spinbox는 사용자가 값을 직접 입력할 수 있다는 점에서 Entry와 비슷합니다. 하지만
Spinbox는 정해진 범위나 목록 안에서 값을 선택하도록 만들 수 있다는 차이가 있습니다.
예를 들어 단순히 이름을 입력받을 때는 Entry가 적합하고, 수량이나 월처럼 제한된 값을 선
택할 때는 Spinbox가 적합합니다.

'''

# 스케일 사용 예제

import tkinter as tk
def show_value():
    label.config(text="선택한 볼륨: " + str(scale.get()))
root = tk.Tk()
scale = tk.Scale(root, from_=0, to=100, orient="horizontal")
scale.pack(padx=10, pady=10)
button = tk.Button(root, text="확인", command=show_value)
button.pack(pady=5)
label = tk.Label(root, text="")
label.pack(pady=10)
root.mainloop()

볼륨을 조절하는 스케일.

결과

# 밝기 세로 조절 예제

import tkinter as tk
def show_value():
    label.config(text=f"선택한 밝기: {scale.get()}")
root = tk.Tk()
scale = tk.Scale(root, from_=0, to=100, orient="vertical")
scale.pack(pady=10)
tk.Button(root, text="확인", command=show_value).pack()
label = tk.Label(root)
label.pack(pady=10)
root.mainloop()

결과

'''
주요 메서드                                              
메서드                                                  설명
get()                                            현재 Scale 값 가져오기
set()                                            Scale 값을 지정한 값으로 변경하기

주요 옵션

옵션                                      허용 값                                설명
from_                               실수 또는 정수                            시작값 설정
to                                  실수 또는 정수                            끝값 설정
orient                              "horizontal" , "vertical" 중 하나        Scale 방향 설정
length                              0 이상의 정수 (픽셀 단위)                  Scale의 길이 설정
resolution                          0보다 큰 실수 또는 정수                    값이 움직이는 간격 설정
tickinterval                        0 이상의 실수 또는 정수                    눈금 표시 간격 설정
label                               임의의 문자열                             Scale위젯에 표시할 제목 설정
command                             함수 객체                               값이 바뀔 때 실행할 함수 설정
state                               "normal" , "disabled" 중 하나          사용 가능 상태 설정

 알아두기
위젯마다 값을 가져오는 방식이 다릅니다
Checkbutton과 Radiobutton은 직접 위젯에서 값을 가져오기보다 연결된 변수에서 값을 가
져오는 방식이 일반적입니다.
반면 Listbox , Scale , Spinbox는 위젯의 get() 메서드를 사용하여 값을 가져올 수 있습
니다.
단, Listbox는 먼저 curselection()으로 선택된 항목의 위치를 확인한 뒤, 그 위치를 이용해
값을 가져와야 합니다.
'''

'''
관리자                         배치 방식                       어울리는 상황
pack()              한 방향으로 차곡차곡 쌓음                  단순한 세로/가로 나열
grid()              행·열 표 형태로 배치                        입력 폼, 설정 화면
place()             좌표로 직접 고정                           정밀한 고정 배치(특수한 경우)
'''

#pack() 레이아웃 예제

import tkinter as tk
root = tk.Tk()
root.geometry("200x150")
tk.Label(root, text="첫 번째 라벨 위젯", bg="red").pack()
tk.Label(root, text="두 번째 라벨 위젯", bg="green").pack()
tk.Label(root, text="세 번째 라벨 위젯", bg="yellow").pack()
root.mainloop()

결과

'''
주요 옵션
옵션                                  허용 값                                설명
side                    "top" , "bottom" , "left" , "right"             위젯을 붙일 방향
fill                    "x" , "y" , "both" , "none"                     남는 공간을 채우는 방향
expand                  True , False                                    남는 공간 차지 여부
anchor                  "n" , "s" , "e" , "w" , "ne" , "center" 등      할당된 공간 안에서의 정렬
padx / pady             정수 또는 (좌, 우) / (상, 하) 튜플                  위젯 바깥 여백
ipadx / ipady           정수                                             위젯 안쪽 여백

side가 "공간을 어디서 떼어올지"를 정한다면, anchor는 "그 공간 안에서 어느 쪽으로 정
렬할지"를 정합니다
'''

#side 예제

import tkinter as tk
root = tk.Tk()
root.geometry("400x300")
tk.Button(root, text="LEFT").pack(side="left")
tk.Button(root, text="RIGHT").pack(side="right")
root.mainloop()

결과

#fill과 expand 예제

import tkinter as tk
root = tk.Tk()
root.geometry("250x120")
tk.Button(root, text="가로만 채우기").pack(fill="x")
tk.Button(root, text="전체 확장").pack(expand=True, fill="both")
root.mainloop()
'''
위젯 숨기기
btn.pack_forget()
btn.pack()
'''

결과

#grid() 레이아웃

import tkinter as tk
root = tk.Tk()
root.geometry("180x50")
tk.Label(root, text="이름").grid(row=0, column=0)
tk.Entry(root).grid(row=0, column=1)
tk.Label(root, text="나이").grid(row=1, column=0)
tk.Entry(root).grid(row=1, column=1)
root.mainloop()

결과

'''
주요 옵션
옵션                      허용값                                         설명
row                     0 이상의 정수                                    위젯이 놓일 행 번호(0부터)
column                  0 이상의 정수                                    위젯이 놓일 열 번호(0부터)
columnspan              1 이상의 정수                                    위젯이 가로로 여러 칸 차지
rowspan                 1 이상의 정수                                    위젯이 세로로 여러 칸 차지
sticky                  "n" , "s" , "e" , "w" 및 조합("nsew" 등)        셀 안에서 위젯을 붙일 방향

'''

#span과 sticky 예제

import tkinter as tk
root = tk.Tk()
root.grid_columnconfigure(1, weight=1) #1번 열만 늘어남
opt = {"padx": 5, "pady": 5}
tk.Label(root, text="이메일 주소", bg="lightblue").grid(row=1, column=0, sticky="w", **opt)
tk.Entry(root, bg="lightyellow").grid(row=1, column=1, sticky="we", **opt)
tk.Button(root, text="로그인", bg="lightgreen").grid(row=2, columnspan=2, sticky="we", **opt)
root.mainloop()

결과

#선생님이 주신 예제

import tkinter as tk

root = tk.Tk()
root.geometry("250x150")

# 첫 번째 줄: 아주 긴 텍스트를 넣어 0번 열(Column)의 너비를 넓힘
lbl_long=tk.Label(root,text="이 라벨 때문에 격자의 너비가 넓어집니다.",bg="lightgray")
lbl_long.grid(row=0, column=0,pady=5)

# 두 번째 줄: 서쪽(왼쪽)에 달라붙는 버튼
btn_west = tk.Button(root,text="서쪽(w)에 붙음")
btn_west.grid(row=1, column=0, sticky="w", pady=5)

# 세 번째 줄: 동쪽(오른쪽)에 달라붙는 버튼
btn_east = tk.Button(root,text="동쪽에 붙음")
btn_east.grid(row=2, column=0, sticky="e", pady=5)

# 네 번째 줄: 가로로 꽉 채우는 버튼
btn_fill = tk.Button(root,text="가로로 꽉 채움(ew)")
btn_fill.grid(row=3, column=0, sticky="ew", pady=5)

root.mainloop()

결과

#행 열 늘리기

import tkinter as tk

root = tk.Tk()
root.title("반응형 창 만들기")
root.geometry("300x200")

#0번째 행과 0번째 열이 창 크기 변화에 반응하여 늘어나도록 가중치(weight) 부여
root.grid_rowconfigure(0, weight=1)
root.grid_columnconfigure(0, weight=1)

#텍스트 창 생성
text_widget = tk.Text(root,bg="lightyellow")

#넓어지는 격자(0행 0열) 안에서 동서남북(nsew)으로 꽉 채우도록 (sticky) 배치
text_widget.grid(row=0, column=0,sticky="nsew",padx=10,pady=10)

#하단 닫기 버튼(1번째 행에 배치. weight를 주지 않았으므로 크기 고정됨)
btn_close = tk.Button(root,text="닫기", command=root.quit)
btn_close.grid(row=1, column=0, pady=(0,10))

root.mainloop()

창의 크기를 바꿈에 따라 문자열의 줄바꿈도 바뀜

'''
메서드
grid_forget()
grid_remove()
위젯을 떼어내고 위치 정보도 잊음
설명
위젯을 떼어내되 위치 정보를 기억(다시 
grid() 호출 시 원래 자리로)
'''
#예제
import tkinter as tk
def toggle_widget():
    #winfo_ismapped()로 현재 화면에 보이는지 확인
    if text_box.winfo_ismapped():
        #숨길 때는 grid_remove() 사용 (위치 기억)
        text_box.grid_remove()
        btn_toggle.config(text="텍스트 창 보이기")
    else:
        #다시 나타낼 때는 아무 옵션 없이 grid()만 호출해도 원래 자리(row=1,column=0)로 돌아옴!
        text_box.grid()
        btn_toggle.config(text="텍스트 창 숨기기")

root =tk.Tk()
root.geometry("250x150")

btn_toggle = tk.Button(root,text= "텍스트 창 숨기기",command=toggle_widget)
btn_toggle.grid(row=0, column=0, pady=10, padx=10)


text_box=tk.Text(root,height=3,width=20,bg="lightyellow")
text_box.insert("1.0", "잠시 숨겨질 수 있는 \n수필 텍스트 입니다.")
#최초 배치 시 위치와 여백 설정 (이 설정을 grid_remove가 기억함)
text_box.grid(row=1, column=0, padx=20)

root.mainloop()

숨길수 있는 텍스트박스

#place() 레이아웃
#place() 는 위젯의 위치를 좌표로 직접 지정합니다.
#직관적이지만 창 크기 변화에 약하므로, 꼭 필요한 고정 배치에만 제한적으로 사용합니다.
#예제

import tkinter as tk
root = tk.Tk()
root.geometry("300x150")
tk.Label(root, text="절대 위치 (50, 30)", bg="lightblue").place(x=50, y=30) # 절대 좌표 배
tk.Label(root, text="상대 좌표 배치 (정중앙)", bg="lightgreen").place(
relx=0.5, rely=0.5, anchor="center") # 상대 좌표 배치 (relx, rely는 0.0 ~ 1.0 비율)

tk.Label(root, text="상대 크기 지정 (너비 80%)", bg="lightyellow").place(
relx=0.1, rely=0.8, relwidth=0.8
) # 상대 크기 지정 (relwidth, relheight)
root.mainloop()

창을 늘림에따라 위치가 바뀌는 상대좌표배치와, 바뀌지 않는 절대 위치

'''
주요 옵션
옵션                          허용 값                                설명
x , y                       정수(픽셀)                             절대 좌표(왼쪽 위 모서리 기준)
relx , rely                 0.0~1.0 실수                          부모 크기 대비 비율
anchor                      "n", "s", "e", "w", "ne", "center"등  기준점 위치
'''

#pack() 과 grid()

'''
레이아웃 관리자 혼용 규칙
같은 부모 위젯 안에서 
pack() 과 grid() 를 섞어 쓰면 안 됩니다.
두 관리자가 요구하는 창 크기가 충돌하면서 tkinter가 크기를 계속 재계산해, 창이 떨리거나 응답하지 않는 상태가 됩니다.
이때 명확한 예외(TclError )가 발생하지 않는 경우가 많아 원인을 찾기 어렵습니다.
'''

#Frame으로 계층 분리
#Frame 으로 구역을 나누면 됩니다.
#핵심은 "같은 부모 안에서만 한 가지 관리자를 쓴다" 는 것입니다. 부모가 다르면(창 vs. 프레임)
#서로 다른 관리자를 써도 괜찮습니다

#예제
import tkinter as tk
root = tk.Tk()
root.geometry("360x150")
root.configure(bg="#797777")
# 위쪽 프레임: 입력 폼 (내부는 grid)
top = tk.Frame(root, bg="#d7ecff", padx=5, pady=5)
top.pack(side="top", fill="x", padx=5, pady=5)
tk.Label(top, text="이메일 주소", bg="#d7ecff").grid(row=0, column=0, sticky="w", padx=10)
tk.Entry(top, bg="white").grid(row=0, column=1, sticky="we")
top.grid_columnconfigure(1, weight=1)  # 입력칸이 가로로 늘어나도록
# 아래쪽 프레임: 버튼 (내부는 pack)
bottom = tk.Frame(root, bg="#ffe0e0", padx=5, pady=5)
bottom.pack(side="bottom", fill="x", padx=5, pady=5)
tk.Button(bottom, text="확인", bg="#7bc96f", fg="white", width=8).pack(side="left")
tk.Button(bottom, text="취소", bg="#e87a7a", fg="white", width=8).pack(side="right")
root.mainloop()

결과

#이벤트 기반 프로그래밍 예제 한글은 2바이트 이므로 조금씩 늦음

import tkinter as tk
def on_key(event):
    result_label.config(text=f"입력된 키 : {event.char}")
root = tk.Tk()
entry = tk.Entry(root, width=30)
entry.pack(padx=20, pady=10)
result_label = tk.Label(root, text="입력된 키 : ", bg="lightyellow")
result_label.pack(padx=20, pady=10)
entry.bind("<Key>", on_key)
root.mainloop()

한글 '똥'은 2바이트라 실시간으로 반영되지 않는 모습

'''
분류                                       시퀀스                                     설명
마우스                                 <Button-1>                                      좌클릭
마우스                                 <Button-2>                                      휠 클릭
마우스                                 <Button-3>                                      우클릭
마우스                                 <ButtonRelease-1>                               버튼 뗌
마우스                                 <B1-Motion>                                     좌클릭 드래그
마우스                                 <Double-Button-1>                               더블클릭
마우스                                 <Enter> / <Leave>                               위젯 영역 진입 / 이탈
키보드                                 <KeyPress>                                      모든 키
키보드                                 <KeyPress-Return>                               엔터
키보드                                 <Key-Escape>                                    ESC
키보드                                 <Control-c>                                     Ctrl+C 조합
키보드                                 <a>                                             일반 문자키 (간단 표기)
윈도/포커스                              <Configure>                                    크기·위치 변경
윈도/포커스                              <FocusIn> / <FocusOut>                         포커스 획득 / 상실
윈도/포커스                              <Destroy>                                      위젯 소멸

'''

'''
메뉴
Menu는 프로그램 창 상단에 보이는 메뉴바입니다. 메모장에서 보이는 파일 / 편집 / 보기 같은
것들이 바로 Menu입니다.
큰 메뉴바 안에 작은 메뉴(파일, 편집 등)를 넣고, 그 안에 실제 항목(열기, 저장 등)을 넣는 계층
구조를 갖습니다.

메뉴 만드는 순서

메뉴바 역할을 할 Menu바를 생성합니다.
그 안에 넣을 하위 메뉴(Menu)를 생성합니다.
하위 메뉴는 add_command 등으로 항목을 채웁니다.
add_cascade로 하위 메뉴를 메뉴바에 연결합니다.
root.config(menu=...)로 메뉴바를 창에 부착합니다.
'''

#메뉴 사용 예제

import tkinter as tk
root = tk.Tk()
root.geometry("400x120")

menubar = tk.Menu(root)# 1) 메뉴바 생성

file_menu = tk.Menu(menubar, tearoff=0)# 2) 하위 메뉴 생성
file_menu.add_command(label="열기", command=lambda: print("열기 클릭")) # 3) 항목 채우기
file_menu.add_separator()
file_menu.add_command(label="종료", command=root.destroy)


menubar.add_cascade(label="파일", menu=file_menu)# 4) 메뉴바에 연결
root.config(menu=menubar)               # 5) 창에 부착
root.mainloop()

결과

'''
주요 메서드
메서드                                             설명
add_command(label, command)                        클릭하면 동작하는 일반 항목 추가
add_cascade(label, menu)                           하위 메뉴를 펼치는 항목 추가 (메뉴바에 메뉴 연결) 
add_separator()                                    항목 사이에 구분선 추가
add_checkbutton(label, variable)                   켜고 끌 수 있는 체크 항목 추가
add_radiobutton(label, variable, value)            여러 개 중 하나만 선택하는 항목 추가        
tk_popup(x, y)                                     지정한 화면 좌표에 메뉴를 팝업으로 표시
delete(index)                                      항목 삭제

주요 옵션                     
옵션                                허용 값                        설명
tearoff                 0 , 1 (또는 False /True )
label                   문자열
command                 함수(콜러블)                             항목 클릭 시 실행할 함수
accelerator             문자열(예:"Ctrl+S" )                     단축키 안내 문자열
state                   tk.NORMAL , tk.DISABLED ,tk.ACTIVE      항목 상태
underline               0 이상의 정수(글자 인덱스)                 항목 이름 중 한 글자에 밑줄을 그어 키보드 접근 문자로 지정
'''

import tkinter as tk
root = tk.Tk()
root.geometry("300x120")
menu = tk.Menu(root, tearoff=0)
menu.add_command(label="복사", command=lambda: print("복사"))
menu.add_command(label="붙여넣기", command=lambda: print("붙여넣기"))
label = tk.Label(root, text="이 글자 위에서 오른쪽 클릭", bg="lightyellow")
label.pack(pady=30)
label.bind("<Button-3>", lambda e: menu.tk_popup(e.x_root, e.y_root))
root.mainloop()

결과

'''
�
알아두기
팝업 좌표는 왜 x_root 일까?
tk_popup() 은 화면 전체를 기준으로 한 절대 좌표를 받습니다. 그래서 위젯 기준인 
e.y 가 아니라 e.x_root , e.y_root 를 넘겨야 클릭한 자리에 정확히 메뉴가 뜹니다.
'''

#대화상자

'''
Dialogs는 사용자와 잠깐 대화하기 위해 뜨는 팝업창입니다.
tkinter는 자주 쓰는 대화상자를 미리 만들어 제공하므로, 창을 직접 디자인하지 않고 함수 한 줄
로 호출할 수 있습니다.
대화상자는 크게 두 종류로 나뉩니다.

표준 대화상자

tkinter가 제공하는 
messagebox , filedialog , simpledialog 가 있습니다.
사용자 정의 대화상자
Toplevel 로 대화상자로 입력 필드가 여러 개거나 디자인을 짜야 할 때 직접 만드는 창입니다.

표준 대화상자

세 가지 주요 모듈
표준 대화상자는 용도에 따라 세 모듈로 나뉩니다.
모듈                               용도                            주요 메서드
messagebox                      알림, 경고, 예/아니오 질문        showinfo , askyesno            
filedialog                      파일/폴더 열기·저장 창           askopenfilename , asksaveasfilename           
simpledialog                    짧은 텍스트·숫자 입력받기          askstring , askinteger          

세 모듈 모두 tkinter 안에 있지만, 자동으로 따라오지 않으므로 별도로 import 해야 합니다.

from tkinter import messagebox, filedialog, simpledialog

대화상자는 "값을 반환한다"

표준 대화상자의 중요한 특징은 사용자의 선택·입력 결과를 반환값으로 돌려준다는 점입니다.
따라서 보통 결과 = 대화상자함수(...) 형태로 받아서 사용합니다.
모듈                              반환값                             취소했을 때
messagebox                      True / False                        보통 False
filedialog                      파일 경로 문자열                       빈 문자열 ""
simpledialog                    입력한 텍스트/숫자                      None

사용자가 취소하면 정상적인 값 대신 None이나 빈 문자열이 돌아옵니다. 반환값을 그대로 쓰기
전에 반드시 확인하는 습관이 필요합니다.
'''

#messagebox

#가장 자주 쓰는 모듈로 정보를 보여주거나 예/아니오를 묻습니다.

import tkinter as tk
from tkinter import messagebox
root = tk.Tk()
def exit_app():
    if messagebox.askyesno("확인", "정말 종료할까요?"):
        root.destroy()
tk.Button(root, text="종료", command=exit_app).pack(padx=180, pady=48)
root.mainloop()

결과

종료를 누르면.

'''
messagebox 주요 메서드
메서드                                         설명
showinfo                                      정보 알림 표시 (확인 버튼)   
showwarning                                  경고 알림 표시 (확인 버튼)
showerror                                    오류 알림 표시 (확인 버튼)
askquestion                                  예/아니오 질문, "yes" /"no" 문자열 반환       
askyesno                                     예/아니오 질문, True /False 반환
askokcancel                                  확인/취소 질문, True /False 반환
askretrycancel                               재시도/취소 질문, True /False 반환
askyesnocancel                               예/아니오/취소 질문, True /False /None 반환

'''

#filedialog

#파일이나 폴더의 경로를 사용자에게 받아옵니다.

from tkinter import filedialog
path = filedialog.askopenfilename(
title="파일 선택",
filetypes=[("텍스트 파일", "*.txt"), ("모든 파일", "*.*")]
)
if path:
    print("선택한 파일:", path)

실행결과. 파일탐색기를 연다.

'''

filedialog 주요 메서드

메서드                                                 설명
askopenfilename                                     파일 하나 열기. 선택한 경로 문자열 반환 (취소 시 "" )
askopenfilenames                                    여러 파일 열기. 경로 튜플 반환 (취소 시 빈 튜플)
asksaveasfilename                                   저장할 경로 받기. 경로 문자열 반환 (취소 시 "" )                                   
askdirectory                                        폴더 선택. 폴더 경로 문자열 반환 (취소 시 "" )
askopenfile                                         파일을 열어 읽기용 파일 객체 반환 (취소 시 None )
asksaveasfile                                       파일을 열어 쓰기용 파일 객체 반환 (취소 시 None )

filedialog 주요 옵션

옵션                            허용                                       값설명
title                         문자열                                     대화상자 제목
initialdir                    폴더 경로 문자열                             처음 열릴 폴더 경로                   
filetypes                     (설명, 패턴) 튜플의 리스트 (예 : "*.txt"))]    표시할 파일 종류 제한    
defaultextension              확장자 문자열 (예: ".txt" )                  저장 시 자동으로 붙는 기본확장자
initialfile                   파일명 문자열                               저장 대화상자에 미리 채워질 파일명
'''

#simpledialog
#짧은 텍스트나 숫자를 입력받을 때 사용합니다.

from tkinter import simpledialog
name = simpledialog.askstring("입력", "이름을 입력하세요.")
age = simpledialog.askinteger("입력", "나이를 입력하세요.", minvalue=0, maxvalue=120)
if name:
    print(f"{name}님, {age}세")

결과

'''
simpledialog 주요 메서드

메서드               설명
askstring         문자열 입력받기. 입력한 문자열 반환 (취소 시 None )
askinteger        정수 입력받기. minvalue , minvalue , maxvalue 로 범위 제한 가능 (취소 시 None )
askfloat          실수 입력받기. maxvalue 로 범위 제한 가능 (취소 시 None )

'''

#사용자 정의 대화상자

'''
messagebox 나 filedialog 는 정해진 모양만 제공합니다.
입력 필드가 여러 개 필요하거나 디자인을 직접 짜고 싶다면 새 창을 직접 만들어야 하며, 이때
사용하는 것이 Toplevel 위젯입니다.

Toplevel이란?

Tk() 가 프로그램의 메인 창이라면, 메인 창처럼 Toplevel() 은 그 위에 추가로 띄우는 새 창입니다.
Label , Entry , Button 등 모든 위젯을 넣을 수 있습니다.
메인 창에 종속된 자식 창이므로, 메인 창을 닫으면 함께 닫힙니다.
비 모달 방식 대화상자
메인 창과 동시에 떠 있으며 둘 다 자유롭게 조작할 수 있는 방식을 비 모달(modeless) 이라고 합
니다.
'''

import tkinter as tk
root = tk.Tk()
root.title("메인 창")
root.geometry("300x200")
def open_window():
    win = tk.Toplevel(root) # 새 창 생성
    win.title("새 창")
    tk.Label(win, text="이건 새 창입니다!").pack(pady=20)
    tk.Button(win, text="닫기", command=win.destroy).pack()
tk.Button(root, text="새 창 열기", command=open_window).pack(pady=50)
root.mainloop()

#모달(Modal) 대화상자

'''
사용자가 입력을 끝낼 때까지 메인 창을 막아두는 방식을 모달(Modal) 창이라 합니다.
설정 변경이나 필수 입력처럼 반드시 응답을 받아야 할 때 사용합니다.
모달은 다음 세 가지 설정으로 만듭니다.

메서드                                     설명
transient(root)                         메인 창에 종속시킴 (항상 위에 표시)
grab_set()                              모든 입력을 이 창에만 집중
wait_window(dialog)                     이 창이 닫힐 때까지 코드 실행을 멈추고 대기
'''

'''
사용자가 입력을 끝낼 때까지 메인 창을 막아두는 방식을 모달(Modal) 창이라 합니다.
설정 변경이나 필수 입력처럼 반드시 응답을 받아야 할 때 사용합니다.
모달은 다음 세 가지 설정으로 만듭니다.

메서드                                     설명
transient(root)                         메인 창에 종속시킴 (항상 위에 표시)
grab_set()                              모든 입력을 이 창에만 집중
wait_window(dialog)                     이 창이 닫힐 때까지 코드 실행을 멈추고 대기
'''

이름 입력을 완료할때까지 메인 창은 꺼지지 않는다.

#캔버스

'''
도형 그리기 (Shapes)

선, 사각형, 원 그리기

Canvas는 다양한 도형을 그리는 create_ 로 시작하는 메서드를 제공합니다.
각 도형은 고유한 ID(정수)를 반환하며, 이를 통해 나중에 도형을 수정할 수 있습니다.
원(Oval)은 해당 원을 둘러싸는 가상의 직사각형(Bounding Box)의 좌측 상단 좌표와 우측 하단
좌표를 입력하여 그립니다.
'''

#선, 사각형, 점선 원 그리기
#캔버스에 직선과 사각형, 점선 테두리의 타원을 각각 색을 달리하여 출력합니다.

import tkinter as tk
root = tk.Tk()
canvas = tk.Canvas(root, width=400, height=250, bg="#F8F3C0", highlightthickness=0)
canvas.pack()
canvas.create_line(50, 50, 350, 50, fill="#6194FA", width=7)
canvas.create_rectangle(50, 90, 150, 190, fill="#F58C9F", width=1)
canvas.create_oval(200, 90, 300, 190, fill="#88EBD4", width=1, dash=(5, 2))
root.mainloop()

결과

'''
주요 메서드
메서드                                                 설명
create_line(x1, y1, x2, y2, ...)                    직선 그리기
create_rectangle(x1, y1, x2, y2, ...)               직사각형 그리기
create_oval(x1, y1, x2, y2, ...)                    타원이나 원 그리기
create_polygon(x1, y1, x2, y2, x3, y3, ...)         3개 이상의 점을 연결한 다각형 그리기

주요 옵션
옵션                              허용                              값설명
fill            색상 이름( "red" ) 또는 16진수 값( "#ff0000" )       도형 내부를 채울 색상
outline         색상 이름( "black" ) 또는 16진수 값( "#000000" )     도형의 테두리 색상
width           정수 또는 실수 (픽셀 단위, 예: 2 , 1.5 )              선이나 테두리의 두께
dash            정수 튜플(예: (5, 3) ) 또는 문자열(예:"." , "-" )     점선 스타일 지정 (예 : (5, 3)은 5픽셀 긋고3픽셀 띄움)
'''

#캔버스에 그리기 예제

import tkinter as tk

old_x,old_y =None,None

def start_draw(event):
    global old_x,old_y
    old_x,old_y = event.x, event.y
def draw_line(event):
    global old_x,old_y
    if old_x and old_y:
        canvas.create_line(old_x, old_y, event.x, event.y, width=2,fill="black")
        old_x,old_y = event.x, event.y
root = tk.Tk()

canvas=tk.Canvas(root,width=400,height=300,bg="white",cursor="crosshair")
canvas.pack()

canvas.bind("<Button-1>", start_draw)
canvas.bind("<B1-Motion>", draw_line)

root.mainloop()

결과

'''
텍스트 및 이미지 삽입

캔버스에 텍스트와 사진 출력하기

Canvas 상의 특정 좌표를 지정하여 문자열을 렌더링할 수 있습니다.
PhotoImage 객체를 활용하여 이미지를 삽입할 수 있습니다.
이미지는 가비지 컬렉터(Garbage Collector)에 의해 삭제되지 않도록 전역 변수로 관리하거나 객
체에 참조를 남겨야 합니다.

문구와 이미지 출력하기

캔버스 중앙에 텍스트를 표시하고, 이미지 파일이 있으면 출력하며 없으면 안내 문구로 대체합니다.
코드가 저장된 동일한 경로에 200x200 크기의 'image.png' 파일을 위치해 둡니다.
'''

import tkinter as tk
root = tk.Tk()
canvas = tk.Canvas(root, width=400, height=300, bg="white")
canvas.pack()
canvas.create_text(200, 50, text="Canvas 입니다.", font=("Arial", 15, "bold"), fill="purple")
try:
    img = tk.PhotoImage(file="image.png")
    canvas.image = img
    canvas.create_image(200, 180, image=img, anchor="center")
except tk.TclError:
    canvas.create_text(200, 180, text="(이미지가 없습니다.)")
root.mainloop()

고양이그림으로 저장햇는데 잘렸네..

'''
객체 제어 및 애니메이션

도형 이동 및 속성 변경하기

Canvas에 그려진 모든 항목은 고유 식별자(ID) 또는 사용자가 지정한 문자열 태그(Tag)로 제어할
수 있습니다.
move() 메서드와 after() 메서드를 결합하면 간단한 애니메이션 효과를 구현할 수 있습니다.
'''

#버튼 클릭으로 원을 오른쪽으로 이동시키기
#버튼을 누르면 파란 원이 50ms 간격으로 오른쪽으로 움직이다가 화면 끝에 닿으면 멈춥니다.

import tkinter as tk
def move_circle():
    canvas.move("my_circle", 5, 0)
    coords = canvas.coords("my_circle")
    if coords[2] < 400:
        root.after(50, move_circle)
root = tk.Tk()
canvas = tk.Canvas(root, width=400, height=200, bg="white")
canvas.pack()

canvas.create_oval(10, 80, 50, 120, fill="blue", tags="my_circle")

btn = tk.Button(root, text="이동 시작", command=move_circle)
btn.pack(pady=10)

root.mainloop()

이동 시작을 누르면 캔버스 끝까지 이동함.

'''
주요 메서드
메서드                                             설명
move(id_or_tag, dx, dy)                         객체를 현재 위치에서 dx, dy만큼 이동
coords(id_or_tag, [x1,y1...])                   객체의 현재 좌표를 반환하거나 새로운 좌표로 재설정
itemconfig(id_or_tag,options)                   생성된 객체의 옵션(색상, 두께 등)을 동적으로 변경
delete(id_or_tag)                               객체를 캔버스에서 삭제합. 모두 지우려면 canvas.delete("all") 을 사용

주요 옵션
옵션                      허용 값                                    설명
tags        문자열 또는 문자열 튜플(예 : ("tag1", "tag2"))             도형에 하나 이상의 태그를 부여하여, 동일 태그가 지정된 여러 도형을 그룹으로 묶어 한 번에 조작(이동, 색상 변경, 삭제 등)할 수 있게 함
'''

#ttk 위젯과 스타일링

'''
ttk 소개와 기본 개념
tkinter 위젯과 ttk 위젯의 차이
외관이 OS 테마(Windows, macOS, Linux)에 자연스럽게 어울립니다.
색상·폰트 등을 위젯 옵션이 아닌 Style 객체로 관리합니다. 그래서 bg=, fg= 같은 옵션이 ttk 위젯
에는 없거나 무시되는 경우가 많습니다.
ttk는 Tk 8.5부터 도입되었습니다. Tk 버전은 다음과 같이 확인할 수 있습니다.
import tkinter
print("Tk Version:", tkinter.TkVersion)
print("Tcl Version:", tkinter.TclVersion)
'''

#ttk 기본 예제(Label, Entry, Button)

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
label = ttk.Label(root, text="이름 : ")
label.grid(row=0, column=0, padx=5, pady=5)
entry = ttk.Entry(root)
entry.grid(row=0, column=1, padx=5, pady=5)
button = ttk.Button(root, text="확인", command=lambda: print(entry.get()))
button.grid(row=1, column=0, columnspan=2, pady=5)
root.mainloop()

결과

'''
스타일링과 테마

Style을 이용한 외관 제어

ttk의 핵심은 ttk.Style 객체입니다.위젯 클래스마다 스타일 이름(예 :TLabel )이 정해져 있으며, 
이를 통해 외관을 일괄 변경할 수 있습니다.
일반 tkinter 위젯은 위젯마다 font , bg 등의 옵션을 직접 지정하지만, ttk는 스타일을 한 번 
정의해두면 같은 스타일을 쓰는 모든 위젯에 일괄 적용됩니다.
'''

import tkinter as tk
from tkinter import ttk

root = tk.Tk()

style = ttk.Style()#스타일을 제어하는 객체를 생성
style.configure("TButton", font=("맑은 고딕", 11), padding=6)#기본 버튼 스타일인 TButton 을 수정
style.configure("Accent.TButton", foreground="lightgreen", background="green")#Accent.TButton이라는 사용자 정의 스타일 생성

btn1 = ttk.Button(root, text="기본 버튼")#기본 스타일 적용
btn1.pack(padx=50, pady=5)

btn2 = ttk.Button(root, text="강조 버튼", style="Accent.TButton")#사용자 정의 스타일을 적용
btn2.pack(padx=50, pady=5)

root.mainloop()

ttk를 사용하면 이렇게 이쁜 버튼을 만들 수 있다.

#테마 선택
#ttk는 테마를 제공하며 다음 코드로 사용 가능한 테마와 현재 사용중인 테마를 확인할 수 있습니다.

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
style = ttk.Style()
print(style.theme_names())
print(style.theme_use())
root.mainloop()

결과:현재 테마의 모습

#테마를 변경하는 코드

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
style = ttk.Style()
frm = ttk.Frame(root, padding=20)
frm.pack()
cur = tk.StringVar(value=style.theme_use()) #콤보박스에 연결할 문자열 변수 정의
cb = ttk.Combobox(frm, values=style.theme_names(), textvariable=cur, state="readonly")#선택 가능한 테마 목록을 콤보박스로
cb.pack(pady=5)
cb.bind("<<ComboboxSelected>>", lambda e: style.theme_use(cur.get()))#항목 선택 시 이벤트에 함수를 연결
ttk.Button(frm, text="버튼").pack(pady=5)
ttk.Checkbutton(frm, text="체크박스").pack(pady=5)
ttk.Progressbar(frm, value=60).pack(pady=5)
root.mainloop()

테마형식을 선택할 수 있다.

classic테마의 버튼, 체크박스, 프로그레스 바

#상태(state)와 동적 스타일
#ttk 위젯은 active , pressed , disabled , focus 등의 상태를 가지며, style.map() 으로 상태별 외관을 지정할 수 있습니다.

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
style = ttk.Style()
style.theme_use("clam")
style.map("TButton",
background=[("active", "lightblue"),
("pressed", "blue"),
("disabled", "lightyellow")],
foreground=[("disabled", "gray")])
ttk.Button(root, text="마우스를 올려보세요").pack(padx=20, pady=10)
root.mainloop()

결과

#콤보박스

'''
사용자가 드롭다운 목록에서 항목을 고르거나, 직접 값을 입력할 수 있습니다.
항목이 선택되면 <<ComboboxSelected>> 가상 이벤트가 발생합니다.

콤보박스 사용하기

리스트로 넘겨받은 도시 이름을 콤보박스에서 사용해 선택된 값을 출력합니다.
'''

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
combo = ttk.Combobox(root, values=["서울", "부산", "대구"])
combo.set("서울")
combo.bind("<<ComboboxSelected>>", lambda e: print(combo.get()))
combo.pack(padx=20, pady=20)
root.mainloop()

결과

'''
주요 메서드
메서드                                             설명
get()                                           현재 입력되거나 선택된 값을 반환
set(value)                                      콤보박스의 값을 지정한 값으로 설정
current(index)                              인자가 없으면 선택된 항목의 인덱스를 반환하고, 인덱스를 주면 해당 항목을 선택
insert(index,value)                         입력 영역의 지정 위치에 문자열을 삽입
delete(first, last)                         입력 영역에서 지정 범위의 문자를 삭제
configure(options)                          위젯의 옵션을 동적으로 변경 (config 도 동일)
bind(event, func)                           특정 이벤트에 콜백 함수를 연결

주요 옵션
옵션                                       허용                                     값설명
values                        리스트 또는 튜플 (예: ['A', 'B','C'] )                드롭다운 목록에 표시할 항목
state                           normal , readonly , disabled                     입력 상태를 지정
textvariable                StringVar 등의 변수 객체                              값과 연동할 StringVar 등의 변수를 지정
width                       정수 (문자 단위)                                      위젯의 너비(문자 단위)를 지정
height                      정수 (항목 수)                                       드롭다운 목록에 한 번에 표시할 항목 수를지정
justify                  left , center , right                                  입력 텍스트의 정렬 방식을 지정
font                    폰트 지정 (예: ('맑은 고딕', 12) )                         표시 글꼴을 지정
postcommand             함수 또는 콜백 객체                                         드롭다운 목록이 열리기 직전에 호출할 함수를 지정

'''

'''
프로그레스바
작업의 진행 상황을 막대 형태로 시각화하는 위젯입니다.
진행률을 알 수 있을 때는 determinate 모드로 값을 채우고, 알 수 없을 때는 indeterminate
모드로 막대를 움직여 작업 중임을 표시합니다.
파일 다운로드, 설치, 데이터 처리 등 시간이 걸리는 작업의 상태를 사용자에게 알려줄 때 주로
사용합니다.
프로그레스바 사용하기
버튼을 클릭하면 Progressbar가 10%씩 증가합니다.
'''

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
pb = ttk.Progressbar(root, length=200, mode="determinate", maximum=100)
pb.pack(padx=20, pady=20)
pb["value"] = 0
def step():
    pb["value"] = (pb["value"] + 10) % 110

ttk.Button(root, text="+10", command=step).pack(pady=5)
root.mainloop()

+10 버튼으로 프로그레스 바 조절 가능

'''
주요 메서드
메서드                                         설명
start(interval=50)                      indeterminate 모드에서 애니메이션을 시작.interval 은 갱신 간격(ms) 
stop()                                  애니메이션 중지
step(amount=1.0)                        현재 값을 amount 만큼 증가 maximum 을 넘으면 0으로 순환
주요 옵션

옵션                                  허용 값                                    설명 
mode                            determinate , indeterminate                 값 기반 또는 애니메이션 모드를 지정
maximum                         실수 (기본값 100 )                           진행률의 최대값
value                           실수 (0 ~ maximum)                          현재 진행 값. determinate 모드에서 사용
variable                        IntVar 또는 DoubleVar 변수 객체               진행 값을 담을 변수를 연결 
length                          정수 (픽셀)                                  진행바의 길이
orient                          horizontal , vertical                       방향을 지정함

'''

'''
노트북 (탭)

여러 페이지를 탭으로 묶어, 클릭으로 전환할 수 있게 해주는 위젯입니다.
각 탭에는 보통 Frame을 연결하고, 그 안에 원하는 위젯을 배치합니다.
노트북 으로 탭 기능 사용하기
두 개의 프레임을 '메인 탭', '설정 탭'으로 구성합니다.
'''

결과. 메인,설정탭이 있다.

'''
주요 메서드
메서드                                                     설명
add(child, [options])                           새 탭을 추가. text로 탭 이름을 지정
insert(index, child, [options])                 지정한 위치( index )에 탭을 삽입
forget(tab_id)                                  해당 탭을 제거
select(tab_id)                                  지정한 탭을 선택(전환). 인자가 없으면 현재 선택된 탭을 반환
index(tab_id)                                   탭의 인덱스를 반환. "end"를 넘기면 탭 개수를 반환
tab(tab_id, **options)                          특정 탭의 옵션을 조회하거나 변경
주요 옵션
옵션                              허용                            값설명
text                            문자열                         탭에 표시할 이름 ( add / insert에서 사용)
state                    normal , disabled , hidden             탭 상태를 지정
image                    PhotoImage 등 이미지 객체                탭에 표시할 이미지
compound                 left , right , top , bottom ,center    텍스트와 이미지를 함께 배치할 때 위치를 지정
padding                  정수 또는 (좌, 상, 우, 하) 형식            탭 내부 여백
sticky                   n , s , e , w의 조합                   연결된 자식 위젯이 탭 영역에서 정렬·확장되는방식을 지정

'''

#트리뷰

'''
데이터를 행과 열로 표시하는 위젯으로, 표와 트리를 표현할 수 있습니다.
각 행은 항목(item)이며, 부모-자식 관계로 펼치고 접을 수 있는 트리 구조를 만들 수 있습니다.
'''

#트리뷰 사용하기

import tkinter as tk
from tkinter import ttk
root = tk.Tk()
tree = ttk.Treeview(root, columns=("item", "spec", "price"), show="headings")
tree.heading("item", text="제품")
tree.heading("spec", text="스펙")
tree.heading("price", text="가격")
data = [("가방", "16인치", 123), ("청소기", "700W", 250), ("운동화", "275mm", 54)]
for item, spec, price in data:
    tree.insert("", "end", values=(item, spec, price))

tree.pack(padx=5, pady=5, expand=True, fill="both")
root.mainloop()

결과

'''
메서드                                             설명
insert(parent, index,**options)             항목을 추가. parent 가 "" 이면 최상위 항목. 추가된 항목 ID를 반환
delete(*items)                              지정한 항목을 삭제
heading(column, **options)                  열 머리글의 텍스트나 정렬 명령 등을 설정
column(column, **options)                   열의 너비, 정렬 방식 등을 설정
item(item, **options)                       특정 항목의 값이나 옵션을 조회·변경
selection()                                 현재 선택된 항목들의 ID를 반환
set(item, column, value)                    특정 항목의 셀 값을 조회하거나 변경
get_children(item="")                       해당 항목의 자식 항목 ID 목록을 반환

주요 옵션
옵션                                   허용 값                               설명
columns                             식별자 목록                          표시할 열들의 식별자 목록
show                                tree , headings , 또는 둘 다를조합     표시 영역을 지정
selectmode                          browse ,extended (기본), none         선택 방식(단일/다중/비활성)          
height                              정수                                  한 번에 보이는 행의 개수
text                                문자열                                 항목의 트리 열에 표시할 텍스트 (사용)                               
values                              값 목록                            항목의 각 열에 들어갈 값들 (insert 에서 사용)                              
anchor                              center ,w , e등                      열 내 텍스트 정렬 위치 (column 에서 사용)                    
'''

0714 ML/DL(2)

인뽕 — Tue, 14 Jul 2026 23:13:09 +0900

머신러닝과 딥러닝에서의 선형대수학

ML과 DL에서 선형대수학은 데이터를 표현하고 계산하는 언어이다.
복잡하고 방대한 데이터를 컴퓨터가 이해하고 아주 빠르게 처리할 수 있도록 만들어주는 가장 핵심적인 수학적 기반.

1. ML/DL에서 선형대수가 필수적인 이유
데이터의 구조화: 현실의 데이터(이미지, 텍스트, 음성 등)를 컴퓨터가 다룰 수 있는 숫자들의 배열(벡터, 행렬, 텐서)로 변환해 준다.

계산의 효율성: 수만 개의 수식을 하나하나 계산하는 대신, 행렬 연산을 통해 한 번에 병렬로 처리 할 수 있다. GPU가 딥러닝에 강력한 이유도 바로 이 행렬 연산에 최적화 되어 있기 때문.

2. ML/DL에 적용되는 핵심 선형대수 개념

1) 벡터(Vector)와 행렬(Matrix), 텐서(Tensor) 데이터를 담는 그릇의 차원을 의미

벡터(1차원):

하나의 데이터 포인트.
(예: 집의 평수, 방 개수, 가격을 담은 1차원 배열)
행렬(2차원):

여러 개의 데이터 포인트(행)와 각 데이터의 특징(열)을 담은 형태의 데이터 세트.
텐서(3차원 이상):

컬러 이미지(가로, 세로, RGB 채널)나 비디오 데이터 등을 표현할 때 사용.
딥러닝 프레임워크인 'TensorFlow(텐서플로우)'의 이름도 여기서 유래.

2) 행렬 곱 (Matrix Multiplication) : 딥러닝의 인공신경망(Neural Network) 연산의 90% 이상은 행렬 곱셈.

3) 노름 (Norm)

벡터의 크기나 길이를 측정하는 방법.
ML/DL에서는 모델이 학습데이터에만 너무 과도하게 맞춰지는 '과적합(Overfitting)을 방지하는 규제로 주로 쓰인다.

4) 고윳값과 고유벡터
행렬을 곱해도 방향이 변하지 않고 크기만 변하는 벡터를 고유벡터, 그때 변화하는 크기를 고윳값이라고 한다.

차원 축소(PCA): 데이터의 특성이 너무 많을 때, 정보 손실을 최소화 하면서 차원을 줄이는 주성분(PCA) 알고리즘의 핵심 원리.
데이터의 분산이 가장 큰 방향(가장 중요한 특징)을 찾는데 사용.
선형대수의 기초적인 수학적 계산 원리(행렬의 곱셈 방법 등)
선형대수의 가장 기본이 되면서도 머신러닝/딥러닝 연산의 뼈대를 이루는 벡터의 내적과 행렬의 곱셈, 그리고 몇 가지 필수 연산 규칙

# 벡터의 내적
# 함수를 만들어 벡터의 내적 구하기

def dot(v,w):
    return sum(v_i*w_i for v_i, w_i in zip(v,w))

A=[4,3]
B=[6,0]

dot(A,B)

직접 내적 함수를 만드는 방식. v,w의 요소끼리 곱한 값들을 모두 더해 반환한다. (출력결과 : 24)

# 넘파이로 벡터의 내적 구하기

a=np.array([1,2,3,4,5])
b=np.array([2,4,6,8,10])
print(a*b)
print(sum(a*b))
print(np.sum(a*b))

넘파이를 딸깍하면 요소의 개수만 맞춰주면 a*b만으로도 각 요소의 곱 array를 만들 수 있다.

sum함수만 취해주면내적 완성!

#넘파이 브로드캐스팅으로 벡터의 내적 구하기

np_Hong1 = np.array([80,90,10,9])
np_Jung1 = np.array([70,80,9,8])
v=np_Hong1+np_Jung1
w=[0.5,0.5,0.5,0.5]
[i*j for i,j in zip(v,w)]

비교를 위해 위 코드는 넘파이 어레이로 구한 홍원과 정원의평균이다.

#넘파이 브로드캐스팅 실습
######벡터와 스칼라는 관례적으로 1-벡터를 사용하여 스칼라를 벡터로 변환하는 연산을 허용하는데, 이를 브로드캐스팅이라고 부른다!!

avg=[75.0,85.0,9.5,8.5]
avg1=np.array(avg)
W1=np.array([0.4,0.4,1,1])
print(avg1*W1)
#내적
Final=avg1*W1
print(Final.sum())

위 코드가 바로 브로드캐스팅을 이용한 내적이다.

가중치 array W1과, 정원이와 홍원이의 평균점수 array avg1을 요소끼리 곱한 Final arry의 합계를 구하면 내적을 구할 수 있다.

출력 결과: 82.0

#벡터의 길이
#넘파이 함수로 벡터의 길이 구하기

a1 = np.array([1,2])
np.linalg.norm(a1) # 넘파이의 벡터의 길이를 구하는 함수

2차원 평면에서 벡터 (1,2)의 길이는 루트(1^2+2^2) 인데, 넘파이의 linalg.norm 함수를 사용하면 벡터의 길이를 그냥 딸~깍 해서 구할 수 있다.

출력 결과: np.float64(2.23606797749979)

위 코드를 넘파이 없이 파이썬 함수만으로 구현하면 다음과 같다.

def dot(v,w):
    return sum(v_i*w_i for v_i, w_i in zip(v,w))

def sum_of_squares(v):
    return dot(v,v)
v=[1,2]

import math # 수학의 함수들을 사용할떄
def magnitude(v):
    return math.sqrt(sum_of_squares(v))
v=[1,2]
mag=magnitude(v)
print(mag)

어우~복잡해. 넘파이를 쓰도록 하자.

출력 결과: 2.23606797749979

#벡터 간의 거리(유클리드 거리) 구하기
#유클리드 거리는 두 벡터가 가리키는 점 사이의 거리.
#유클리드 거리는 벡터의 놈의 정의와 차의 정의를 사용하여 구함
#math 라이브러리의 sqrt함수를 사용하여 계산 할 수도 있음

def vector_subtract(v,w):
    return [v_i-w_i for v_i, w_i in zip(v,w)]
def squared_distance(v,w):
    return sum_of_squares(vector_subtract(v,w))

v=[1,2]
w=[3,4]
sd=squared_distance(v,w)

def distance(v,w):
    return math.sqrt(squared_distance(v,w))

def distance1(v,w):
    return magnitude(vector_subtract(v,w))
v=[1,2]
w=[3,4]

print(distance(v,w))
print(distance1(v,w))

유클리드 거리라 함은 공간에서의 두 벡터의 시작점을 원점으로 통일 시키고 벡터 끝이 가리키는점 사이의 거리라고 볼 수 있다.

위 코드의 distance함수는 넘파이 없이 파이썬만으로 유클리드 거리를 구한 것이다.

vector_subtract 함수는 리스트의 각 요소의 차를 저장한 리스트를 반환, squared_distance함수는 v,w의 요소의 차를 제곱한 값을 담은 리스트를 반환한다.distance 함수는 math라이브러리의 sqrt(제곱근 함수)와 squared_distance함수를 사용하여 유클리드 거리를구하는 함수이다.

distance1함수는 magnitude함수와 vector_subtract함수를 사용해서 유클리드 거리를 구한다.

출력 결과:

2.8284271247461903
2.8284271247461903

# 벡터를 이용한 평균 제곱 오차와 평균 제곱근 오차

### 평균 제곱 오차
#예측값이 실제값에 얼마나 근접한지 나타냄
y=[1,1,0,1,0,1,0,0]#실제값
t=[0,0,1,0,0,1,0,0]#예측값
import numpy as np

def mean_squared_error(y,t):
    return 0.5*np.sum((y-t)**2)

print(mean_squared_error(np.array(y),np.array(t)))

출력 결과: 2.0

평균인데 왜 0.5를 곱할까? (y-t)**2의 어레이의 크기는 8인데?? 라는 궁금증에 대한 클로드의 답변:

이건 사실 딥러닝(신경망) 학습에서 자주 쓰이는 손실 함수(loss function) 공식이에요. 유명한 딥러닝 교재(사이토 고키의 "밑바닥부터 시작하는 딥러닝" 등)에서 이 형태를 "평균제곱오차"라는 이름으로 소개하는 경우가 있는데, 엄밀히 통계학적 정의의 "평균"과는 다른 형태예요.

#평균 제곱근 오차

c=np.array([1,2,3,4,5])
d=np.array([2,4,6,8,10])
print((sum((c-d)**2)/len(c))**(1/2))

여기는 또 어레이 크기로 나누네..

행렬

import numpy as np
A=[[1,2,3],
   [4,5,6]]
B= [[1,2],
    [3,4],
    [5,6]]
A1=np.array(A)
A1.shape
np.shape(A)

A와 B는 각각 2행3열, 3행 2열의 리스트. A1은A를 행렬로 만든것.

출력 결과:

A1.shape
>>(2, 3)
np.shape(A)
>>(2, 3)

#행렬의 덧셈, 뺄셈, 곱셈

x=np.array([10,11,12,13,14])
y=np.array([0,1,2,3,4])
x+y
x-y
#행렬의 곱셈
x= np.array([[1],[2],[3]])
y= np.array([[4],[5],[6]])
x*y

합의 경우 그냥 리스트는 문자열끼리 이어주는데 행렬은 요소끼리의 연산.

#전치 행렬과 브로드캐스팅

x.shape, y.shape # (3, 1), (3,1)
x.T
x.T.shape
x.T*y

x,y는 3행 1열 인데, x에 전치를 함으로써 x는 1행 3열, y는 3행 1열.

둘을 곱해주면 형태가 안맞기 때문에 브로드캐스팅이 일어난다.

1 2 3

과

4 4 4

5 5 5

6 6 6

의 벡터곱을 한다는 의미.

결과

array([[ 4,  8, 12],
       [ 5, 10, 15],
       [ 6, 12, 18]])

#행렬곱

x=np.array([[1,2,3]])
y=np.array([[4,5,6]])
print(x.T@y)
print(x@y.T)

행렬곱을 하려면 @연산기호를 사용해야 한다.

각 어레이에 전치를 해서 행렬곱을 해주면 결과는 3x3, 1x1이 나오게 된다.

결과

[[ 4 5 6]
[ 8 10 12]
[12 15 18]]
[[32]]

손실함수와 활성화함수

'''
손실 함수 (Loss Function)
MSE : 모델읠 출력층에서 선형회귀, 주택 가격 등 수치 예측
MAE : 모델의 출력층에서 이상치가 많은 환경에서의 수치 예측
BCE : 분류류기의 최종 출력층, 주요모델은 불량 탐지, GAN의 판별자
CCE : 다중 분류기의 최종출력층, 이미지분류, 텍스트 카테고리 분류

회귀 : MSE
이진 : BCE
다중 : CCE

활성화 함수(Activation Function)
이전 층으로 부터 전달받은
Sigmoid : 이진분류 모델의 최종 출력층
Tanh : RNN의 은닉층에서
ReLU : 대부분의 은닉층에서
Softmax : 다중 분류의 최종 출력층에서
은닉층 : ReLU
출력층 : Softmax,Sigmoid
'''

# 손실 함수의 예
import tensorflow as tf

# 1. MSE (Mean Squared Error) 실례 - 수치 예측

mse_loss_fn = tf.keras.losses.MeanSquaredError()
# 예: 모델의 집값 예측이 10.0, 실제 정답(집값)이 12.0인 경우
predictions = tf.constant([[10.0]]) # 예측값
targets = tf.constant([[12.0]])     # 정답
# TensorFlow에서는 관례상 (정답, 예측값) 순서로 입력합니다.
loss_mse = mse_loss_fn(targets, predictions)
print(f"MSE Loss: {loss_mse.numpy()}") # 결과: 4.0 ((12-10)^2)

# 2. BCE (Binary Cross Entropy) 실례 - 이진 분류 (합격/불합격)

bce_loss_fn = tf.keras.losses.BinaryCrossentropy() #- 위치: 다중
#분류기의 최종
#출력층 - 주요 모델: 이미지
#분류, 텍스트
#카테고리 분류
# 예: 모델이 '합격(1)'일 확률을 0.8로 예측했고, 실제 정답도 '합격(1.0)'인 경우
pred_probs = tf.constant([[0.8]])
target_binary = tf.constant([[1.0]])
loss_bce = bce_loss_fn(target_binary, pred_probs)
print(f"BCE Loss: {loss_bce.numpy()}") # 예측이 맞았으므로 매우 낮은 손실값 출력

# 3. CCE (Categorical Cross Entropy) 실례 - 다중 분류 (개/고양이/새)

cce_loss_fn = tf.keras.losses.CategoricalCrossentropy()
# 정답이 원-핫 인코딩 되어있다고 가정 (고양이: [0, 1, 0])
target_class = tf.constant([[0.0, 1.0, 0.0]])
# 모델이 예측한 각 클래스별 속할 확률 (합이 1.0)
pred_probs_multi = tf.constant([[0.1, 0.8, 0.1]])
loss_cce = cce_loss_fn(target_class, pred_probs_multi)
print(f"CCE Loss: {loss_cce.numpy()}")

아마 우리 프로젝트에선 이걸 사용하지 않을까...

#활성함수의 예
import tensorflow as tf
# 임의의 1차원 데이터 생성
input_data = tf.constant([-2.0, 0.0, 2.0])

# 1. Sigmoid 실례

out_sigmoid = tf.keras.activations.sigmoid(input_data)
print(f"Sigmoid Out: {out_sigmoid.numpy()}")
# 결과: 음수는 0에 가깝게, 양수는 1에 가깝게 변환됨 (0과 1 사이)

좀 더 자세히 말하면 Sigmoid(x)는 1/e^x+1이다. 자연상수 e의 지수함수를 사용함.

x가 무한히 커지면 Sigmoid(x)는 0에 수렴,

x가 무한히 작아지면 Sigmoid(x)는 1에 수렴.

# 2. ReLU 실례

out_relu = tf.keras.activations.relu(input_data)
print(f"ReLU Out: {out_relu.numpy()}")
# 결과: [0.0, 0.0, 2.0] -> 0 미만의 값은 모두 0으로 깎아버림

# 3. Leaky ReLU 실례 (tf.nn 모듈 사용)

out_leaky = tf.nn.leaky_relu(input_data, alpha=0.1) # 음수일 때 곱할 작은 기울기(alpha) 설정
print(f"Leaky ReLU Out: {out_leaky.numpy()}")
# 결과: [-0.2, 0.0, 2.0] -> 음수값이 완전히 0이 되지 않고 약간의 값을 유지 (Dying ReLU 방지)

# 4. Softmax 실례

# 텐서플로우의 Softmax는 다차원 텐서를 기대하므로 2차원 형태로 만들어 계산
input_data_2d = tf.constant([[-2.0, 0.0, 2.0]])
out_softmax = tf.keras.activations.softmax(input_data_2d)
print(f"Softmax Out: {out_softmax.numpy()}")
# 결과: 가장 큰 값인 2.0이 가장 높은 확률을 가지며, 값들의 합이 무조건 1.0이 됨
print(f"Softmax Sum: {tf.reduce_sum(out_softmax).numpy()}") # 합: 1.0

보통 Softmax와 sigmoid가 가장 많이 쓰인다고 함ㅇㅇ

순전파와 역전파

#지방과 소금 성분에 따른 치즈 선호도
# 독립변수 : Fat, Salt
# 종속변수 : Acceptance (like, dislike)
# 3개 계층으로 이루어지며 왼쪽부터 입력층, 은닉층, 출력층 구조이다.

#시그모이드 함수 시각화

import numpy as np
import matplotlib.pylab as plt
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
X=np.arange(-5.0, 5.0, 0.1)
Y=sigmoid(X)
plt.plot(X, Y)
plt.ylim(-0.1, 1.1)
plt.show()

맷플롯립을 사용해서 시그모이드 함수를 시각화하는 코드이다.

시그모이드 함수

시그모이드 함수는 '기울기 소실'이라는 한계점이 있기 때문에 이진분류의 출력층에만 제한적으로 주로 쓰인다.

시그모이드 함수의 그래프를 보면, 양 끝 곡선이 거의 평평한데, 이때 기울기는 거의 0에 가깝다.

경사하강법에 따르면, 모델 학습은 기울기를 따라 가중치를 조금씩 업데이트 하는것인데, 기울기가 0에 가깝기 때문에 가중치가 거의 업데이트 되지 않아서, 학습이 멈춘것 처럼 느려진다.

이런한계 때문에, 오늘날신경망의 은닉층에서는 시그모이드 대신 ReLU같은 함수를 훨씬 많이 쓴다.

# 2*3*1 구조의 간단한 순전파 신경망 구현

input=[0.2, 0.9] # 입력층의 2개의 값
weight1=[[0.05, 0.01], [-0.01, 0.03], [0.02, -0.01]] # 입력층에서 은닉층으로 가는 가중치
bias1=[-0.3, 0.2, 0.05] # 은닉층으로 가는 바이어스
weight2=[0.01,0.05,0.015] # 은닉층에서 출력층으로 가는 가중치
bias2=[-0.015] # 출력층으로 가는 바이어스

우선 입력층의 2개의 값(지방과 소금의 양)과, 입력층에서 은닉층으로 가는 가중치 weight1, 은닉층으로 가는 바이어스 bias1, 은닉층에서 출력층으로 가는 가중치 weight2, 출력층으로 가는 바이어스 bias2를 정의한다.

입력값을 제외한 가중치와 편향은 임의로 정해진다.

# 입력층의 첫 번째 노드에서 은닉층의 첫 번째 노드로 신호 전달

def dot(v, w):
    return sum(i * j for i, j in zip(v, w))
dot(input,weight1[0])+bias1[0]  #0.2*0.05 +0.9*0.01 + (-0.3) # =-0.28099999999999997

input 벡터 (0.2,0.9) 와 weight1[0] 벡터 (0.05,0.01)을 내적하고 bias1[0]을 더해서 A3을 구한다.

위와 같은 방식으로, A3,A4,A5를 구한다.

# 입력층에서 은닉층 노드로 보내는 신호값

A3=dot(input,weight1[0])+bias1[0]
A4=dot(input,weight1[1])+bias1[1]
A5=dot(input,weight1[2])+bias1[2]
A3, A4, A5 #(-0.28099999999999997, 0.225, 0.045)

ㅇㅇ

#시그모이드 함수를 이용해 A3, A4, A5 노드에서 출력하는 값

import numpy as np
def sigmoid(x):
    return 1 / (1 + np.exp(-x)) # np.exp(x)는 자연상수 e의 x 승 값을 리턴함

outputA3=sigmoid(A3)
outputA4=sigmoid(A4)
outputA5=sigmoid(A5)
outputA3, outputA4, outputA5 #(0.4302086298074603, 0.5560138905446199, 0.5112481019468548)

#은닉층에서 출력층으로 신호 전달

Y1=[outputA3, outputA4, outputA5]
A6=dot(Y1, weight2)+bias2
outputA6=sigmoid(A6)
outputA6 #array([0.50619256])

ㅇㅇ

여기까지 2*3*1 구조의 간단한 순전파 신경망을 구현해보았다.

이제 넘파이를 이용해서 계산해보자.

# 넘파이를 활용한 순전파 신경망 계산

'''
지금까지의 계산을 넘파이를 이용하면 매우 편리하게 진행할 수 있다. 입력층에서 은닉층으로 전달되는 값 
A1을 구하고 시그모이드 함수를 이용하여 출력층으로 전달하기 위한 값 Y1을 구한다.
'''
# 입력층에서 첫 번째 은닉층으로 신호 전달 방법
import numpy as np
input=np.array([0.2, 0.9]) # 1*2 행렬
weight1=np.array([[0.05,0.01], [-0.01,0.03], [0.02,-0.01]]) # 3*2 행렬
bias1=np.array([-0.3,0.2,0.05])
A1=np.dot(input, weight1.T) + bias1 # weight1.T는 weight의 전치 행렬
print(A1)
Y1=sigmoid(A1)
Y1 #array([0.43020863, 0.55601389, 0.5112481])

'''
다음은 은닉층의 값 Y1에 가중치와 바이어스 값을 적용해 출력층으로 전달하는 과정이다. 이 값은 A2에 
저장하고 시그모이드 함수를 이용해 출력층에서 최종 산출하는 값을 Y2에 저장한다.
'''
weight2=np.array([0.01, 0.05, 0.015])
bias2=np.array([-0.015])
A2=np.dot(Y1, weight2.T)+bias2
Y2=sigmoid(A2)
Y2 #array([0.50619256])

'''
보통 마지막 출력층에서는 시그모이드 함수 대신 항등 함수를 사용하지만 이 책에서는 편의상 최종 출력
값으로 시그모이드 함수를 사용한 값을 이용하기로 한다. 항등 함수를 사용할 때 출력층의 값은 다음과 같
다. 
'''

넘파이를 사용하면 행렬곱 연산이 용이해서 훨씬 쉽게 구현 할 수 있다.

#항등함수를 이용해서 출력층 구하기

def identity_function(x):
    return x
Y=identity_function(A2) # 혹은 Y=A2
Y #array([0.0247715])

#순전파 신경망을 함수로 정의 한다면?

def init_network():
  network={}
  network['W1']=np.array([[0.05,0.01], [-0.01,0.03], [0.02,-0.01]])
  network['b1']=np.array([-0.3,0.2,0.05])
  network['W2']=np.array([0.01, 0.05, 0.015])
  network['b2']=np.array([-0.015])
         return network
def forward(network, x):
  W1, W2=network['W1'], network['W2']
  b1, b2=network['b1'], network['b2']
  a1=np.dot(x, W1.T) + b1
  y1=sigmoid(a1)
  a2=np.dot(y1, W2.T) + b2
  y2=sigmoid(a2) # 시그모이드 함수 사용
  # z2=identity_function(a2) # 항등 함수 사용
        return y2

network=init_network()
input=np.array([0.2, 0.9])
Y=forward(network, input)
Y #array([0.50619256])

0713 ML/DL

인뽕 — Mon, 13 Jul 2026 22:53:33 +0900

ML/DL: 머신러닝과 딥러닝은 컴퓨터가 데이터를 통해 스스로 규칙을 학습하게 만드는 기술이다.

AI (인공지능)

└─ ML (머신러닝)

└─ DL (딥러닝)

머신러닝/딥러닝 결과가 컴퓨터마다 다른 이유는 알고리즘 본연의 무작위성, 하드웨어 연산 방식의 차이, 소프트웨어 및 라이브러리 버전 차이 등이 있다. 딥러닝에서 하드웨어 차이로 인해 발생하는 1% 미만의 성능 차이는 통제할 수 없는 자연스러운 현상으로 받아들이고, 오차에 집착하기 보다는 전반적인 모델의 성능을 향상시키는데 집중하는 것이 필요하다.

ML이 할 수 있는 것 (잘하는 것)

정형 데이터 분석 및 예측: 엑셀이나 데이터베이스에 깔끔하게 정리된 숫자, 텍스트 데이터를 분석

분류 및 군집화: 스팸 메일을 걸러내거나, 고객을 구매 성향에 따라 몇 가지 그룹으로 나누는 작업

명확한 추천 시스템: 사용자의 과거 클릭 이력, 조회수, 평점 등을 바탕으로 좋아할 만한 콘텐츠

해석 가능성: AI가 왜 이런 결과를 도출했는지 사람이 역으로 추적하고 이해

ML이 할 수 없는 것 (한계점)

비정형 데이터의 독립적 이해: 이미지, 음성, 영상, 긴 줄글 형태의 텍스트 자체를 그냥 던져주면 스스로 이해하지 못한다.

고차원적인 창작: 새로운 글을 지어내거나, 완전히 새로운 이미지를 그려내는 등의 복잡한 생성 작업은 하지 못한다.

딥러닝(Deep Learning, DL): 머신러닝의 한 분야.
인간의 뇌 신경망을 모방한 인공신경망을 층층이 깊게 쌓아(Deep), 기계가 스스로 데이터의 특징을 찾아내도록 하는 방식

DL이 할 수 있는 것 (잘하는 것)

비정형 데이터 처리의 최강자: 사진 속 객체 인식, 음성 인식(STT), 음성 합성(TTS), 자연어 이해 등 복잡하고 규칙이 없는 데이터를 처리하는 데 압도적인 성능

고도의 생성형 AI: 챗GPT처럼 자연스러운 문장을 이어나가거나, 글의 문맥을 파악해 요약하고, 텍스트를 기반으로 새로운 이미지를 만들어내는 등 창작의 영역에 가까운 결과

스스로 특징 추출: 사람이 특징을 지정해주지 않아도, 방대한 데이터를 보면서 스스로 "아 고양이는 귀가 뾰족하고 수염이 있구나"라는 패턴

DL이 할 수 없는 것 (한계점)

적은 데이터로 학습하기 : 데이터가 적으면 아예 제대로 된 학습 결과를 내지 못한다.

과정 설명하기: "왜 이런 결과가 나왔어?"라고 물었을 때 그 이유를 설명하지 못한다.

상식적 추론 : 문맥상 그럴듯한(확률이 높은) 단어를 나열 할 뿐, 인간이 가진 기본적인 '상식'이나 세계관을 이해 하고 논리적으로 사유하는게 아니다.

딥러닝 이론을 프로그래밍 코드로 작성하는 것을 돕는 라이브러리는 텐서플로, 파이토치, 카페, 테아노 등이 있다. 그 중 우리가 사용할것은 바로 텐서플로 이다.

'''
Tensor Flow

Layer [Input]
Layer [Dense]
위와 같은 레이어가 쌓여있는 구조.

독립  종속
-----------
온도  판매량
.       .
.       .
.       .
.       .
----------
인풋을 넣었을떄 덴스가 정답과 오차가 있을텐데, 이를 조정하는게 loss 함수
mse(평균제곱오차)를 사용해서 오차를 조절(가중치 조절)

이미지분석 : 보통 2가지가 있음
1. 객체탐지 (ex-Yolo 모델)
2. 세그먼트 탐지

손실함수와 활성함수를 어떨때 뭘 쓰는지를 잘 판단해야함!!
'''

지도학습

# 1 과거의 데이터를 준비한다. (기온과 레모네이드 판매량, 원인 : 독립변수, 결과: 종속변수)
# 2 모델의 구조를 만든다. (온도를 알려주면 판매량을 예측해주는 기계)
# 3 데이터로 모델을 학습(fit)한다.
# 4 모델을 이용한다.

위 방법에 따라 레모네이드 판매를 예측하는 모델을 만들어보자.

레모네이드 판매 예측 실습

온도(레모네이드 온도 아님)에 따른 레모네이드의 판매량을 예측하는 실습을 해보았다.

온도는 기온임

#라이브러리 사용
import pandas as pd
import tensorflow as tf

#================================
# [1] 레모네이드 판매 예측 모델
#================================
#1. 과거의 데이터를 준비합니다.
path = 'https://raw.githubusercontent.com/blackdew/tensorflow1/master/csv/lemonade.csv'
lemonade = pd.read_csv(path)

#독립변수(온도0와 종속변수(판매량) 분리
independent = lemonade[['온도']]
dependent = lemonade[['판매량']]

path는 기온과 판매량 데이터임. 읽어와서 독립변수와 종속변수를 분리한다.

독립변수: 원인

종속변수: 결과

#2. 모델의 구조
X = tf.keras.layers.Input(shape=[1]) # Input(): 데이터가 들어오는 '입구'
Y = tf.keras.layers.Dense(1)(X)     # Dense(): 출구 레이어 (1) : 나가는 데이터가 1개
model = tf.keras.models.Model(X, Y) #: X,Y 레이어로 하나의 모델을 생성
model.compile(loss='mse')   # 만들어진 모델은 반드시 컴파일 해야 한다.

데이터가 들어오는 입구인 Input 레이어와 나가는 출구인 Dense 레이어를 설정한다.매개변수는 데이터의 개수.

loss = 'mse' 모델에 대한 손실함수는 mse(평균 제곱 오차)를 사용
즉, 학습과정에서 틀린 정도(오차)를 계산할 때 Mean Squared Error 방식을 사용하겠다!
오차 정수가 0에 가까울 수록 알고리즘이 가중치 W를 미세하게 자동 조정한다!

"1개의 입력을 받아서 (Input(shape=[1])),
수학 연산을 거쳐 1개의 정답을 내보내는 (Dense(1)) 기계를 조립하고(Model),
오차를 줄여나갈 학습 전략을 세운다(compile)."

# 3. 데이터로 모델을 학습
print("\n모델 학습을 시작합니다...")
model.fit(independent, dependent, epochs=10)

fit -> 모델을 학습시키는 함수 epochs는 학습 횟수.

# 3. 데이터로 모델을 학습
print("\n모델 학습을 시작합니다...")
model.fit(independent, dependent, epochs=10)

#4 모델을 이용
print("\n---기존 데이터(independent) 예측 결과---")
print(model.predict(independent))

print("\n--- 내일 온도가 15도일 때의 판매량 예측 결과 ---")
predic_data = pd.DataFrame({'온도': [15]})

머신러닝 알고리즘

지도학습 영역에는 회귀문제와 분류 문제가 있다.

회귀 : 숫자로 된 결과를 예측 ( ex:레모네이드 판매량 예측)

분류 : 범주(category) 형태의 결과를 예측 (ex: 스팸메일 분류)

분류와 회귀 문제를 풀기 위해서 다양한 머신러닝 알고리즘이 쓰입니다.

1. 결정 트리(decision tree)

2. 랜덤 포레스트(random forest)

3. k-최근접 이웃(KKN: k-nearest neighbors)

4. 서포트 벡터 머신(SVM: support vector machine)

5. 인공 신경망(artificial neural networks)

#공통 데이터 준비
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier

#붓꽃 데이터 불러오기

X,y=load_iris(return_X_y=True)# 일반적으로 원인은 대문자 x, 결과는 소문자 y
'''
붓꽃 데이터 구조
문제지 (X: 4가지 특징)
꽃받침 길이 (Sepal Length), 꽃받침 너비(Sepal Width), 꽃잎 길이(Petal Length), 꽃잎 너비 (Petal Width)
정답지 (y: 3가지 품종)
세토사 (Setosa):0, 버시칼라(Versicolor):1, 버지니카(Virginica):2

'''
#데이터를 학습용(80%) 과 테스트용 (20%)으로 무작위 분할 # 꽃받침의 넓이, 줄기의 길이로 어떤 품종인지 알려줌
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

#
import time
# 모델의 학습 진행율을 보기 위한 라이브러리
from tqdm import tqdm
###1 결정 트리(Decision Tree)
from sklearn.tree import DecisionTreeClassifier

#결정 트리 모델 생성 및 학습
dt_model = DecisionTreeClassifier(random_state=42)
print("모델 학습을 시작합니다...")
# 기존의 range(100) 대신 tqdm(range(100))을 사용.
#desc 옵션을 주면 진행률 바 앞에 원하는 문구를  띄울 수 있다.
for epoch in tqdm(range(100), desc="[Epoch 학습 중]"):
    #이 부분에 실제 모델 학습 코드(fit 등)가 들어간다.
    dt_model.fit(X_train, y_train)
    #진행률 확인을 위해 가상으로 0.05초씩 쉬어간다.
    time.sleep(0.05)
print("학습이 완료되었습니다!")
# 테스트 데이터로 예측 및 정확도 확인
dt_pred = dt_model.predict(X_test)
print(f"결정 트리 정확도 : {accuracy_score(y_test, dt_pred):.2f}")
### 2 랜덤 포레스트
from sklearn.ensemble import RandomForestClassifier

# 랜덤 포레스트 모델 생성 ( 나무를 100개 만들도록 설정) 및 학습
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)#n_estimators: 의사 결정 트리를 몇개 만들건지
dt_model = DecisionTreeClassifier(random_state=42)
print("모델 학습을 시작합니다...")
for epoch in tqdm(range(100),desc="[Epoch 학습 중"):
    rf_model.fit(X_train, y_train)
    time.sleep(0.05)
print("모델 학습이 종료되었습니다...")
#예측 및 정확도 확인
rf_pred = rf_model.predict(X_test)
print(f"랜덤 포레스트 정확도 : {accuracy_score(y_test, rf_pred):.2f}")

### 3. k-최근접 이웃( KNN: k-nearest neighbors)
from sklearn.neighbors import KNeighborsClassifier

# KNN 모델 생성 ( 가장 가까운 이웃 3개를 참고하도록 설정) 및 학습
knn_model = KNeighborsClassifier(n_neighbors=3)
print("모델 학습을 시작합니다...")
for epoch in tqdm(range(100),desc="[Epoch 학습 중"):
    knn_model.fit(X_train, y_train)
    time.sleep(0.05)
print("모델 학습이 종료되었습니다...")
# 예측 및 정확도 확인
knn_pred = knn_model.predict(X_test)
print(f"KNN 정확도: {accuracy_score(y_test,knn_pred):.2f}")

###4. 서포트 벡터 머신(SVM: support vector machine)
from sklearn.svm import SVC

#SVM 모델 생성 (분류 기준을 직선으로 설정) 및 학습
svm_model = SVC(kernel='linear',random_state=42)
print("모델 학습을 시작합니다.")
for epoch in tqdm(range(100),desc="[Epoch 학습 중]"):
    svm_model.fit(X_train, y_train)
    time.sleep(0.05)
print("모델 학습이 종료되었습니다....")

# 예측 및 정확도 확인
svm_pred = svm_model.predict(X_test)
print(f"SVM 정확도: {accuracy_score(y_test,svm_pred):.2f}")

###5. 인공 신경망 (Artificial Neural Networks)
from sklearn.neural_network import MLPClassifier

#인공 신경망 모델 생성 (최대 1000번 반복 학습하도록 설정) 및 학습
ann_model= MLPClassifier(max_iter=1000,random_state=42)
print("모델 학습을 시작합니다...")
for epoch in tqdm(range(100),desc="[Epoch 학습 중]"):
    ann_model.fit(X_train, y_train)
    time.sleep(0.05)
print("모델 학습이 종료되었습니다....")
#예측 및 정확도 확인
ann_pred = ann_model.predict(X_test)
print(f"인공 신경망 정확도: {accuracy_score(y_test,ann_pred):.2f}")

사이킷런(Scikit-learn)

파이썬 환경에서 머신러닝을 구현할 때 사용하는 가장 표준적이고 강력한 라이브러리.

복잡한 수학 공식이나 알고리즘을 처음부터 짤 필요 없이, 결정 트리나 인공신경망 같은 다양한 모델들을 아주 짧은 코드로 불러와

사용할 수 있게 해주는 '머신러닝 종합 공구 상자'

머신러닝 워크플로우(Workflow of Machine Learning)

중앙의 트리 구조 (결정 트리 형태)를 중심으로, 머신러닝 프로젝트가진행되는 전체적인작업 흐름을 8단계로 나타낸 도해.

시계방향으로 진행되는 각 단계의 한국어 의미는 다음과 같다.

머신러닝 워크 플로우

1. 전략 정의(De;fine Strategy)

어떤 문제를해결할 것인지, 머신러닝을 통해 달성하고자 하는 목표와 계획을 세우는 단계

2. 데이터 수집(Data Collection)

문제 해결에 필요한 다양한 데이터를 수집하고 모으는 단계

3. 데이터 전처리(Data Preprocessing)

문제 해결에 필요한 다양한 데이터를 수집하고 모으는 단계

4. 데이터 모델링(Data Modeling)

전처리된 데이터를 바탕으로, 문제 해결에 가장 적합한 머신러닝 알고리즘(모델)을 선택하고 설계하는 단계

5. 학습 및 평가(Training and Evalution)

선택한 모델에 데이터를 넣어 학습시키고, 그 모델이 얼마나 정확하게 작동하는지 시험해 보는(평가하는) 단계

6. 최적화(Optimization)

평가 결과를 바탕으로 모델의 성능을 최대한으로 끌어올리기 위해 미세하게 조정하고 개선하는 과정

7. 배포(Deplayment)

완성된 모델을 실제 서비스나 시스템에 적용하여 사용자들이 쓸 수 있게 만드는단계

8. 성능 모니터링(Performancd Monitoring)

배포된 모델이실제 환경에서도 에상대로 잘 작동하는지 지속적으로 관찰하고, 데이터 변화에 따른 성능 저하가없는지

확인하는 단계입니다. 이 결과에 따라 다시 전략을 수정하거나 데이터를 수집하는 등 순환하게 됩니다.

보스턴 집값 예측 실습

# 보스턴 집값 예측
import requests
# 라이브러리 사용
import tensorflow as tf
import pandas as pd
import certifi
from io import StringIO

#1. 과거의 데이터를 준비합니다.
path = 'https://raw.githubusercontent.com/blackdew/tensorflow1/master/csv/boston.csv'
response = requests.get(path, verify=certifi.where())
boston = pd.read_csv(StringIO(response.text))
print(boston.columns)
boston.head()

라이브러리 import와 데이터 준비.

다음은 boston.csv의 칼럼과 데이터의 일부이다.

#독립변수, 종속변수 분리
independent= boston[['crim','zn','indus','chas','nox','rm','age','dis','rad','tax','ptratio','b','lstat']]
dependent = boston[['medv']]

boston에서 독립변수와 종속변수로 분리한다. 13개의 조건에 따른 집값 예측이므로

independent는 나머지 13개의 조건, dependent는 집값이다. 각각 506행 13열, 506행 1열이다.

#2. 모델의 구조
X=tf.keras.layers.Input(shape=[13]) # 독립변수(칼럼)
Y=tf.keras.layers.Dense(1)(X) # 종속변수
model = tf.keras.models.Model(X,Y)
model.compile(loss='mse')

독립변수와 종속변수로 Input 레이어와 Dense 레이어를 설정한다. 로스함수로 mse를 선택하고 컴파일 한다.

keras는 tensorflow 안에 있는 딥러닝 모델을 쉽고 직관적으로 만들 수 있게 해주는 파이썬 라이브러리임.

#3. 데이터로 모델을 학습
model.fit(independent,dependent,epochs=1000)

데이터들을 이용해서 모델을 1000번 학습시킨다.

#4. 모델을 이용

print(model.predict(independent[5:10]))
print(dependent[5:10])
print(model.get_weights())

출력 결과:

[[26.129301]
[20.883503]
[17.717175]
[ 9.075988]
[17.332752]]

   medv
5  28.7
6  22.9
7  27.1
8  16.5
9  18.9

[array([[-0.08689677],
       [ 0.07696634],
       [-0.06071758],
       [ 3.3436177 ],
       [ 1.6904595 ],
       [ 3.9580069 ],
       [ 0.01542883],
       [-0.9243423 ],
       [ 0.14606974],
       [-0.00957732],
       [ 0.04639207],
       [ 0.01565579],
       [-0.58180475]], dtype=float32), array([2.4192894], dtype=float32)]

'''
# 원핫인코딩
=> 범주형 데이터(Categorical Data)를 수치 데이터로 변환하는 가장 기본적인 방법
과일 종류인 [사과, 바나나, 포도]를 원-핫 인코딩으로 변환
범주 사과 바나나 포도
사과 1   0     0
바나나0  1     0
포도 0   0     1
붓꽃 데이터
===========================================
선형 회귀(Linear Regression): 연속적인 실수
로지스틱 회귀(Logistic Regression): 0 과 1 사이의 확률 / 분류 (Classification)

무엇을 예측하는가(결과값의 형태):

집값 예측, 주식 가격 예측, 기온 예측 <= 선형 회귀
스팸 메일 분류, 질병 양성/음성 판정, 합격/불합격 예측 <=로지스틱 회귀
======================================
선형 회귀(Linear Regression): 데이터의 경향성을 가장 잘 설명하는 하나의 '직선'을 찾는 모델
                            독립 변수(x)와 종속 변수(y) 사이의 선형 관계를 모델링
                y = wx + b
특징 : 예측값이 음의 무한대에서 양의 무한대까지
예시 : "평수가 30평이고 역세권인 아파트의 가격은 얼마일까?"를 예측 할 때 사용
결과값 : '5억원','7억 5천만 원'과 같이 연속된 수치
======================================
로지스틱 회귀(Logistic Regression) : 분류(Classification)문제에 주로 사용
선형회귀의 결과값을 0과 1 사이로 압축하여, 특정 사건이 발생할 '확률'로 변환
특징: 결과값이 항상 0과 1 사이의 확률
보통 기준값(예: 0.5)을 정해두고,
예측된 확률이 이보다 크면 클래스 1 (예: 스팸 맞음) 작으면 클래스 0 (예:스팸 아님)으로 분류
예시: "이 메일이 스팸 메일일 확률은 얼마일까?"를 예측할 때 사용
결과값이 '0.9'라면 90% 확률로 스팸 메일이라고 판단하여 스팸함으로 분류
======================================
다중 회귀 : 2개 이상의 독립변수를 종합하여 예측하는 모델.

y = w1x1 + w2x2 + w3x3 + wnxn + b(bias:편향)

단순 회귀: 2차원에서 하나의 직선 형태
다중 회귀: 3차원 공간에서 데이터를 잘 설명하는 하나의 평면
=====================================

'''

아이리스 품종 분류

#아이리스 품종 분류
#라이브러리 사용
import tensorflow as tf
import pandas as pd
import requests
import certifi
from io import StringIO
from boston import independent

#1. 과거의 데이터를 준비
path ='https://raw.githubusercontent.com/blackdew/tensorflow1/master/csv/iris.csv'
response = requests.get(path, verify=certifi.where())
iris = pd.read_csv(StringIO(response.text))
iris.head()

#원핫인코딩
encoding=pd.get_dummies(iris)
encoding.head()
#-----------------------------------------
#칼럼이름 출력
print(encoding.columns)
#-----------------------------------------
#독립 변수(입력 데이터)와 종속 변수(정답 데이터)분리
#꽃잎길이,꽃잎폭,꽃받침길이,꽃받침폭,품종
independent=encoding[['꽃잎길이','꽃잎폭','꽃받침길이','꽃받침폭']]
dependent=encoding[['품종_setosa','품종_versicolor','품종_virginica']]
#-----------------------------------------
#2. 모델의 구조
X=tf.keras.layers.Input(shape=[4])
Y=tf.keras.layers.Dense(3,activation="softmax")(X)
model = tf.keras.models.Model(X,Y)
model.compile(loss='categorical_crossentropy',metrics=['accuracy'])
#-----------------------------------------
#3. 데이터로 모델을 학습
model.fit(independent,dependent,epochs=100)
#-----------------------------------------
#4. 모델을 이용
print(model.predict(independent[:5]))
'''

'''
print(dependent[:5])
print(model.predict(independent[-5:]))
print(dependent[-5:])
#-----------------------------------------
print(model.get_weights())

최소자승법

마치 여러 개의 별들이 흩어져 있을 때, 그 별들의 대략적인 흐름을 가장 잘 보여주는 하나의 선을 긋는 것과 같다.

이 점들의 흐름을 가장 잘 나타내는 하나의 직선을 그리는것.

우리가 어떤 직선을 그렸을 때, 실제 점들은그 직선 위에 딱 놓이지 않고 약간씩 떨어져 있다.

이 떨어진 거리가 바로 오차.

최소자승법은 이 모든 점들의 오차를 제곱해서 더한 값을 가장 작게 만드는 직선을 찾는 방법.

흩어진 데이터들을 가장 잘 설명하는 대표적인 선을 찾아주는 아주 유용한 방법이다. 이 선을 이용하면 앞으로의 경향을 예측하거나 데이터들 사이의 관계를파악하는 데 도움을 받을 수 있다.

회귀 계수

우리가 어떤 원인(독립변수)이 결과(종속변수)에 얼마나 영향을 미치는지 알려주는 숫자.

ex) 공부시간과 시험점수의 관계

회귀 계수가 5라면? 공부 시간을 1시간 늘릴때마다 시험점수가 평균적으로 5점씩 올라간다는 의미.

회귀 계수가 0에 가깝다면 원인이 결과에 거의 영향을 미치지 않는다는 의미이다.

SSE(오차 제곱 합)

최소자승법으로 찾은 "가장 잘 맞는 선"이 실제 데이터들을 얼마나 잘 설명하는지를 알려주는 숫자. 마치 우리가 그린 선들이 실제 점들과 얼마나 떨어져 있는지, 그 떨어진 정도를 종합적으로 보여주는 지표.

Sum of Squares(제곱 합)

이 오차들을 그냥 더하면 양수 오차와 음수 오차가 서로 상쇄될 수 있다. 그래서 각 오차를 제곱해준다.

제곱하면 모든 오차가 양수가 되고, 큰 오차는 더 크게 벌주는 효과도 있다. 그리고 이 제곱된 모든 오차들을 다 더한 값이 바로 제곱 합이다.

제곱 합이 작다 -> 실제 데이터들과 우리가 그린 선이 별로 떨어져 있지 않다는 뜻.

제곱 합이 크다 -> 실제 데이터들과 우리가 그린 선이 많이 떨어져 있다는 뜻.

최소자승법은 이 SSE 값을 가장 작게 만드는 선을 찾는 방법이다.

SST = 분산 * N

경사하강법

현재 위치에서 가장 가파르게 내려가는 방향을 찾아서 조금씩 이동. 이 "가장 가파르게 내려가는 방향"이 바로 경사를 의미. 그리고 이 방향으로 하강하는 방법을 쓰는것.

현재 상태에서 결과가 가장 좋아지는 방향(가장 가파르게 내려가는 방향)을 찾는다. 그 방향으로 아주 조금씩 움직인다.

0710 Numpy

인뽕 — Fri, 10 Jul 2026 09:48:07 +0900

#Numpy

- 넘파이는 파이썬에서 수치를 계산하는 라이브러리이다. 머신러닝과 데이터 과학 분야에서 넘파이는 필수이다.

머신러닝의 모든 데이터는 결국 숫자로 이루어진 행렬로 표현되며, 넘파이는 이 대규모 행렬 연산을 압도적인 속도로 처리해 주는 핵심 라이브러리이다.

# 머신러닝 코드를 작성하거나 논문을 구현할 때 가장 자주 쓰이는 핵심 기능

1. 다차원 배열 생성

'''
머신러닝에서 데이터셋은 대개 2차원(행과 열) 또는 3차원(이미지: 가로, 세로, 채널) 배열.

np.array(): 리스트를 NumPy 배열로 변환

np.zeros(), np.ones(): 0 또는 1로 채워진 가중치(Weights) 초기화 시 사용

np.arange(): 일정 간격의 수열 생성 (인덱싱이나 루프 제어 시 유용)
'''
###-----------------------------------------------------------------
import numpy as np

# 2차원 데이터셋 예시 (샘플 2개, 특성 3개)
X = np.array([[1.0, 2.0, 3.0], 
              [4.0, 5.0, 6.0]])

2. 차원과 모양 변경 (Reshaping)

'''

머신러닝 모델에 데이터를 입력할 때
가장 에러가 많이 나는 부분이 바로 데이터의 '모양(Shape)'이 맞지 않을 때.

X.shape: 배열의 구조(차원) 확인 
(예: (100, 32, 32) -> 100장의 32x32 이미지)

X.reshape(): 데이터의 개수는 유지하되 차원을 변경 
(예: 2D 이미지를 1D로 평탄화)

Tip: -1을 넣으면 남은 차원으로부터 크기를 자동으로 계산. 
X.reshape(-1, 1)은 머신러닝 레이블 벡터를 만들 때
'''
#----------------------------------------------
# 2x3 배열을 6x1 배열로 변환
X_reshaped = X.reshape(-1, 1)

-1의 의미 : "이 자리의 크기는 너가 알아서 계산해"

2x3 배열이므로 reshape(-1,1)을 하면 열 크기를 1로 고정해서 자동으로 6행 1열이 된다.

3. 브로드캐스팅 (Broadcasting)

'''

머신러닝에서 모든 데이터 샘플에 동일한 연산
(예: 평균 빼기, 스케일링)을 적용할 때 루프를 돌릴 필요가 없다. 
NumPy는 서로 모양이 다른 배열 간의 연산을 자동으로 확장해서 처리!
'''
#----------------------------------------------
# 모든 데이터에 일괄적으로 편향(Bias) 더하기
biases = np.array([0.5, 1.0, 1.5])
result = X + biases  # 각 행에 biases가 알아서 더해짐

#행이 맞지않아도 자동으로 더해짐

biases를 X의 행에 각각 더해준다.

4. 벡터 및 행렬 연산 (Linear Algebra)

'''

딥러닝의 핵심은 행렬 곱(Dot Product). 
신경망(CNN)의 순전파(Forward) 연산은 대부분 행렬 곱으로 이루어진다.
순전파는 정방향으로 가는거 ->
역전파는 역방향으로 가는거 <-
np.dot(A, B) 또는 A @ B: 행렬 곱셈 (내적)

A.T: 전치 행렬 (Transposed Matrix, 행과 열을 바꿈)
'''
#----------------------------------------------
W = np.array([[0.1, 0.2], 
              [0.3, 0.4], 
              [0.5, 0.6]]) # 가중치 행렬 (3x2)

# 행렬 곱 연산 (2x3) @ (3x2) = (2x2)
output = X @ W

반가운 행렬이 나왔다. 수학 조교할떄가 생각나는군!

5. 집계 함수와 축(Axis) 개념

'''

손실 함수(Loss Function)를 계산하거나 
데이터의 특성별 평균을 구할 때 사용. 
axis 개념을 정확히 이해하는 것이 중요!!!!!

axis=0: 열(Column) 기준 연산 
(행을 따라 내려가며 연산 -> 각 특성별 평균)

axis=1: 행(Row) 기준 연산 
(열을 가로지르며 연산 -> 각 샘플별 합계)
'''
#----------------------------------------------
# 각 특성(열)별 평균 계산 -> 머신러닝 정규화(Normalization)의 기초
mean = np.mean(X, axis=0)

6. 조건문과 인덱싱 (Filtering)

'''

데이터셋에서 특정 조건(예: 이상치 제거, 특정 클래스 추출)을 만족하는 
데이터만 뽑아낼 때 사용.

불리언 인덱싱(Boolean Indexing): 조건식의 결과가 True인 요소만 추출

np.where(조건, 참일 때 값, 거짓일 때 값): 조건에 따른 데이터 수정 또는 인덱스 찾기
'''
#----------------------------------------------

# 3보다 큰 데이터만 추출
filtered_X = X[X > 3]

# 3보다 큰 값은 1로, 나머지는 0으로 변환 (이진 분류 레이블링 등에 유용)
binary_labels = np.where(X > 3, 1, 0)

where은 삼항연산자랑 똑같음

#행렬

# 1. 전치 행렬 (Transpose, .T)
"""

"가로줄과 세로줄을 통째로 맞바꾸기"

머신러닝에서는 데이터의 형태(shape)를 맞추기 위해 행렬을 휙 돌려야 할 때가 정말 많다. 
가로(행)를 세로(열)로, 세로(열)를 가로(행)로 뒤집는 것을 전치

결과: 원래 [1, 2, 3]이었던 가로줄이 세로줄 [1, 2, 3]으로 변경
"""
#----------------------------------------------

import numpy as np

# 2행 3열짜리 행렬 생성
A = np.array([[1, 2, 3],
              [4, 5, 6]])

# .T를 붙여서 뒤집기
A_transposed = A.T

print("원본 A (2x3):\n", A)
print("전치 후 A.T (3x2):\n", A_transposed)





#----------------------------------------------
# 2. 행렬 곱 (Dot Product, @)
"""

"앞 행렬의 가로줄과 뒤 행렬의 세로줄을 교차하며 곱하고 더하기"

인공지능 신경망이 '예측'을 할 때 입력 데이터와 가중치(Weight)를 곱하는 핵심 연산. 
일반 곱셈(*)처럼 원소끼리 그냥 곱하는 게 아니라, 가로와 세로를 교차하며 곱해 합산.

규칙: 앞 행렬의 가로 길이와 뒤 행렬의 세로 길이가 반드시 같아야 연산이 가능!! 
((2x3) @ (3x2) = (2x2))

계산 원리: 결과 창의 첫 번째 칸은 (1*1) + (2*3) + (3*5) = 22
"""
#----------------------------------------------

# 2행 3열 행렬 (예: 데이터 2개)
X = np.array([[1, 2, 3],
              [4, 5, 6]])

# 3행 2열 행렬 (예: 가중치)
W = np.array([[1, 2],
              [3, 4],
              [5, 6]])

# 행렬 곱 실행
result = X @ W

print("행렬 곱 결과 (2x2):\n", result)

#머신러닝 데이터 처리

#----------------------------------------------------------------
# 요약하자면,
# 머신러닝 데이터 처리는
# ".T로 돌리고,
# @로 곱하고,
# 브로드캐스팅으로 알아서 맞춰 더한 뒤,
# axis로 원하는 방향의 평균을 내는 과정"의 반복
#----------------------------------------------------------------

#----------------------------------------------
# 이미지 분석할때

'''
1. 컴퓨터에게 이미지는 그냥 '숫자 행렬'이다
   우리 눈에는 예쁜 사진으로 보이지만, 
   컴퓨터는 이미지를 거대한 숫자 바둑판(행렬)으로 인식.
   가로 세로 픽셀마다 밝기나 색상(0~255)이 숫자로 채워져 있다.
   예를 들어, 가로 28픽셀, 세로 28픽셀짜리 작은 손글씨 이미지는 
   컴퓨터에게 28 X 28 크기의 행렬일 뿐이다.
   
2. 이미지 분석의 핵심: 특징 추출 (합성곱, Convolution)
   이미지를 분석하려면 사물의 '테두리(선)', '색상의 변화', '특정 모양' 같은 특징을 찾아내야 한다. 
   이때 인공지능은 필터(Filter 또는 Kernel)라고 불리는 
   작은 돋보기 행렬을 사용하는데, 
   여기서 바로 행렬곱이 쓰인다.
   도장 찍기: 이미지 행렬 위에 작은 필터 행렬(예:3X3)을 포갠다.
   행렬곱 연산: 포개어진 부분의 이미지 숫자들과 필터의 숫자들을 순서대로 곱하고 모두 더한다.
   (우리가 방금 배운 그 행렬곱 방식입니다!)
   특징 맵 생성: 이 돋보기를 옆으로, 아래로 한 칸씩 이동하며 이미지 전체에 도장을 찍으면, 
   특정 특징(예: 세로선)만 뚜렷하게 강조된 새로운 행렬이 만들어진다.
   
     딥러닝에서 이미지 분석에 최고로 꼽히는 
   **CNN(합성곱 신경망)**의 '합성곱'이 바로 이 필터를 이용한 행렬곱 연산을 의미.  
   
3. 최종 판단: 분류 (Fully Connected Layer)
필터를 통해 이미지에서 
"고양이 귀 모양", "고양이 수염 모양" 같은 특징들을 다 뽑아내고 나면, 
인공지능은 마지막으로 "그래서 이 사진이 고양이일 확률이 몇 %인가?"를 계산해야 한다.

이때도 마찬가지로 
추출된 특징 데이터 행렬과 
인공지능이 학습한 가중치(Weight) 행렬을 
최종적으로 거대하게 행렬곱(@) 하여 
"고양이: 98%, 강아지: 2%" 같은 결론을 도출한다.
'''
#----------------------------------------------

#----------------------------------------------------------------
# 요약하자면,
# 컴퓨터가 이미지를 분석하는 과정은
# "이미지 행렬에
# 필터 행렬을 계속 곱해서(@)
# 중요한 특징을 짜낸 후,
# 마지막 행렬곱을 통해
# 정답을 맞추는 과정"이라고 볼 수 있다.   
#----------------------------------------------------------------

0709 파이썬 기초 문법 복습

인뽕 — Thu, 9 Jul 2026 16:36:45 +0900

자료구조

# List

다중값을 저장, 순서가 있고 index가 자동으로 부여 (index는 0~1씩 증가) C++의 vector와 유사하다.

형식 : 리스트명 = [], 리스트명 = ['데이터','데이터','데이터']

인덱스

왼쪽->오른쪽 : 0,1,2,3,4,
오른쪽-> 왼쪽 :-4, -3, -2,-1

#-------------------------------------------------------
## 데이터 추가 : append()/ insert()/ extend()
menu = ["페르소나"]
menu.append("릴레이") # ['페르소나', '릴레이']
menu.insert(1, "마중물") #  ['페르소나', '마중물', '릴레이']
menu.extend(["수필", "시각"]) # ['페르소나', '마중물', '릴레이', '수필', '시각']

append는 C++의 vector.push_back()과 비슷함.

insert를 통해 삽입하고 싶은 위치에 삽입 가능.

extend 함수로 한번에 여러 데이터 삽입 가능.

items = ["A", "B", "C", "B"]
items.remove("B") # ['A', 'C', 'B'] : 맨 처음 만나는 데이터만 삭제
last = items.pop() # items :  ['A', 'C'] / last : 'B'
items.clear()

remove는 전달한 값과 같은 값을 갖는 요소를 삭제 함. 근데 맨 처음 만나는 데이터만 삭제.

pop()은 맨 뒤 요소 삭제. 마치 C++ queue.pop()

clear은 리스트의 데이터만 삭제. 메모리는 남아있음

## 데이터 위치(index) 및 동일 데이터 갯수 : index(x) / count(x) / len(리스트명)

# index(x): 리스트에서 값 x가 있는 첫 번째 위치(인덱스)를 반환. 없으면 오류 발생!!!!
# count(x): 리스트에 값 x가 몇 개 들어있는지 개수
tech = ["Python", "Java", "Python", "C"]
print(tech.index("Python")) # 맨 처음 만나는 데이터의 index만 반환
print(tech.count("Python")) # 2 출력

len은 C++의 v.size()랑 비슷함

## 정렬 및 뒤집기 : sort() / reverse()
# sort(): 리스트의 요소를 오름차순으로 정렬 / 주의 원본 데이터의 순서가 바뀐다.
# reverse(): 정렬과 상관없이 현재 리스트의 순서를 그대로 거꾸로 뒤집는다.
numbers = [3, 1, 4, 5, 2]
numbers.sort()    # 오름차순 정렬 -> [1, 2, 3, 4, 5]
numbers.sort(reverse=True)    # 내림차순 정렬 ->  [5, 4, 3, 2, 1]
numbers.reverse() # 뒤집기 -> [5, 4, 3, 2, 1]

# 복사 : copy() / 리스트를 똑같이 복사하여 새로운 리스트를 생성
# => 원본 리스트를 보존하고 똑같은 복사본으로 작업하고 싶을 때 사용
original = [1, 2, 3]
clone = original.copy() # [1, 2, 3]

clone=original이라고만 하면 깊은 복사가 이루어져서 위험함. 복제본을 만드려면 반드시 copy()함수를 사용할것.

#Dictionary

"키(key) - 값(value)" 쌍으로 데이터를 저장하는 자료구조. C++의 map과 비슷함. 근데 value 값에 모든 타입이

올 수 있다.

#생성

# 데이터가 존재하는 딕셔너리 생성
platform_info = {
    "name": "당목담글",
    "slogan": "사람과 마음을 연결하는 세상에서 가장 따뜻한 이어읽기 플랫폼",
    "components": ["페르소나", "마중물", "릴레이"]
}

# 빈 딕셔너리 생성
empty_dict = {}
empty_dict2 = dict()

#get()

# get()을 사요하는 경우
print(platform_info.get("launch_year")) # None  인덱스로 접근하면 오류발생
print(platform_info.get("launch_year", 2026)) # 2026

get()을 사용하면 없는 키 값을 읽을 때 오류가 나지 않는다.

# 전용 내장 함수

'''
keys(): 딕셔너리의 모든 Key만 모아서
values(): 딕셔너리의 모든 Value만 모아서
items(): 딕셔너리의 (Key, Value) 쌍을 튜플로 묶어서
=> 주로 반복문에서 사용
'''

#데이터 삭제

# pop(key): 특정 Key에 해당하는 쌍을 꺼내면서(반환) 삭제
# del 딕셔너리[key]: 특정 Key의 쌍을 바로 삭제
# clear(): 딕셔너리의 모든 데이터
sample = {"A": 1, "B": 2}
val = sample.pop("A") # {'B': 2} / val => 1
del sample["B"] # {}

sample = {"A": 1, "B": 2, "c": 2}
sample.clear() #  {} => 딕셔너리는 그대로.. 내부 데이터(key:value)들만 삭제.

#많이 쓰이는 사례

### 딕셔너리 활용법
# setdefault()와 collections.defaultdict(초기값 자동 설정)
'''
딕셔너리를 사용할 때 가장 자주 하는 작업 중 하나
"존재하지 않는 키면 값을 0(또는 빈 리스트)으로 만들고, 
이미 존재하는 키면 값을 업데이트하기"
'''
## setdefault(key, default) 활용 : 단어 빈도수(Count) 계산
words = ["릴레이", "마중물", "릴레이", "페르소나", "마중물", "릴레이"]
counter = {}

for word in words:
    # 키가 없으면 0을 먼저 넣고, 있으면 원래 값에 +1
    counter[word] = counter.setdefault(word, 0) + 1
#  {'릴레이': 3, '마중물': 2, '페르소나': 1}

## defaultdict 활용

# collections 모듈의 defaultdict를 사용하면 
# 아예 딕셔너리 생성 단계부터 "기본 데이터 타입"을 지정할 수 있다!!
# 존재하지 않는 키를 조회하면 자동으로 빈 리스트([])를 기본값으로 생성
from collections import deque, Counter, defaultdict
user_history = defaultdict(list) # defaultdict(list, {})

user_history["김철수"].append("수필 텍스트 읽기")
user_history["이영희"].append("목소리 기부 참여")
user_history["김철수"].append("이어읽기 플랫폼 접속")
'''
 defaultdict(list, {'김철수': ['수필 텍스트 읽기', 
                               '이어읽기 플랫폼 접속'], 
                    '이영희': ['목소리 기부 참여']})

# 딕셔너리 컴프리헨션 (Dictionary Comprehension) : 내포리스트 형태

# 1. 구성 요소 리스트를 기반으로 {요소명: 글자수} 딕셔너리 생성
components = ["페르소나", "마중물", "릴레이"]

component_lengths = {comp: len(comp) for comp in components}
print(component_lengths)
#=>  {'페르소나': 4, '마중물': 3, '릴레이': 3}

# 조건문(if)과 함께 사용하기 (글자 수가 3개인 것만 골라내기)
filtered_dict = {k: v for k, v in component_lengths.items() if v == 3}
#=> {'마중물': 3, '릴레이': 3}

# collections.Counter : 데이터의 개수를 세어서 딕셔너리 형태로 변환해 주는 파이썬 내장 라이브러리

# 주로 알고리즘 테스트나 데이터 분석에서 많이 사용
from collections import Counter


votes = ["페르소나", "릴레이", "페르소나", "마중물", "페르소나", "릴레이"]
voted_counter = Counter(votes)
# => Counter({'페르소나': 3, '릴레이': 2, '마중물': 1})

# 가장 많이 등장한 상위 N개 뽑기
print(voted_counter.most_common(1)) # [('페르소나', 3)]

## 딕셔너리 병합 및 수정 : update()

# 두 개의 딕셔너리를 하나로 합치거나, 여러 값을 한 번에 수정할 때 update() 메서드를 사용
# 겹치는 키가 있다면 새로 들어온 값으로
platform_base = {"name": "당목담글", "type": "플랫폼"}
platform_detail = {"type": "이어읽기 플랫폼", "launch_year": 2026}

platform_base.update(platform_detail)
# =>  {'name': '당목담글', 'type': '이어읽기 플랫폼', 'launch_year': 2026}
# => platform_base에 platform_detail을 덮어쓰기

#Tuple

형식 : TUPLE명 = (데이터, 데이터... )
특징 : 리스트 처럼 순서는 있지만 데이터에 재한 수정이 불가!!!
따라서 LIST보다 처리 속도가 빠르다!!

platform_core = ("페르소나", "마중물", "릴레이")

numbers = 1, 2, 3 # 도 가능
# =>  (1, 2, 3)

#주의사항 :  데이터가 1개만 존재하는 겨우 마지막에 반드시,를 붙여야 한다.
single_element = (5,)
not_a_tuple = (5) # 는 튜플이 아닌 그냥 정수로..
# => 5


sample = (10, 20, 30)
print(sample[0])

sample[0] = 99 # TypeError : 'tuple' object does not support item assignment
del sample[0] # TypeError : 'tuple' object does not support item assignment

## 튜플의 활용법

# 1. 다중 변수 할당
service, phrase = ("당목담글", "사람과 마음을 연결하는 세상에서 가장 따뜻한 이어읽기 플랫폼")
# service : "당목담글"
# phrase : "사람과 마음을 연결하는 세상에서 가장 따뜻한 이어읽기 플랫폼"

# 2. 변수의 값 교환
a = 10
b = 20

a, b =b, a
# a : 20
# b : 10

# 3. 함수 내에서 다중 값 반환
def get_platform_info():
    name = "당목담글"
    year = 2026
    return name, year #dtype : tuple

result = get_platform_info() # ('당목담글', 2026)

# 튜플은 프로그램이 실행되는 동안 절대 변하면 안된느 값을 다룰때 많이 사용
# 예 : 1년의 12달, 위도와 경도, 플랫폼 고정 메뉴 이름,주민등록번호 등...

#Set

파이썬의 셋(Set, 집합)은 수학의 집합 개념을 코드로 구현한 자료구조
중복을 허용하지 않는다: 아무리 똑같은 값을 여러 번 넣어도 set 안에는 딱 하나
순서가 없다 (Unordered): 데이터가 들어간 순서를 기억하지 않기 때문에,

리스트처럼 인덱싱(set[0])으로 특정 값을 꺼낼 수 없다!!!

#생성

components = {"페르소나", "마중물", "릴레이", "페르소나"}

# **** 주의: 빈 set을 만들 때는 {}가 아닌 set()을 사용!!!
# 이유 : 빈 딕셔너리가 만들어지기 때문!!!
empty_set = set()

## 데이터 추가/삭제

'''
add(x): 요소 1개 추가
update([x, y]): 여러 요소 한 번에 추가 / 이 때 리스트, 튜플로 전달됨!
remove(x): 특정 요소 삭제 / 주의 : 삭제할 값이 없을 경우, 오류 발생!!
discard(x): 특정 요소 삭제 /  삭제할 값이 없어도 오류 발생 하지 않음(오류 무시!)
'''
tech = {"Python", "Java"}

tech.add("C++") #  {'C++', 'Java', 'Python'}
tech.update(["Go", "Kotlin"]) # {'C++', 'Go', 'Java', 'Kotlin', 'Python'}
tech.remove("Java") #  {'C++', 'Go', 'Kotlin', 'Python'}

# Set만의 특별한 함수들

## 수학적 집합 연산 : 교집합/ 차집합/ 합집합
set_A = {1, 2, 3, 4}
set_B = {3, 4, 5, 6}

# 교집합(iNTERSECTION)
print(set_A & set_B) # {3, 4}
print(set_A.intersection(set_B))  # {3, 4}

# 합집합 (union) : 만약 중복데이터가 있을 경우 하나만...
print(set_A | set_B) # {1, 2, 3, 4, 5, 6}
print(set_A.union(set_B)) # {1, 2, 3, 4, 5, 6}

#차집합(Diffence) : 아애의 경우, A에는 있지만 B에는 없는 경우
print(set_A - set_B) # {1, 2}
print(set_A.difference(set_B))  # {1, 2}

## **** 실무/알고리즘에서 Set을 사용하는 경우***

# 1. 리스트에서 중복 데이터 단 한 줄로 제거
duplicated_list = ["릴레이", "마중물", "릴레이", "페르소나", "마중물"]
unique_list = list(set(duplicated_list)) # ['릴레이', '페르소나', '마중물']

# 2. 특정 데이터가 존재하는지 확인 (in 연산자)
blacklist = {"user123", "bad_bot", "spammer"}
if "bad_bot" in blacklist:
    print("접근을 차단합니다.") # 접근을 차단합니다.
    
# *** Set은 딕셔너리와 같은 원리(해시 테이블)로 동작하기 때문에 
#     데이터가 1,000만 개가 있어도 단 한 번에 값을 찾아낸다!!!

#해시 테이블

'''
해시 테이블(Hash Table)에 대하여 
"어떤 데이터(Key)를 주더라도 단 한 번에 그 위치를 찾아내는 마법의 저장소"

원리
해시 함수(Hash Function)라는 특별한 수학적 함수를 거쳐 데이터의 방 번호(인덱스)를 결정
1. Key입력 : 검색하거나 저장하고 싶은 데이터("bad_bot")
2. 해시함수 통과 : 해시 함수가 글자를 숫자로 이루어진 고유한 고윳값(해시 코드)으로 변환
3. 인덱스 변환 : 이 숫자를 배열의 크기로 나눈 나머지 등을 이용해 실제 저장될 방 번호(인덱스)를 구한다
4. 값 저장/조회 : 그 방 번호(버킷)에 데이터(Value)를 바로 저장, 추출
의 단계를 거친다.
'''
#실제 생활과 비교 설명
'''
책이 1,000만권이 있는 도서관에서 책을 찾을 경우,
리스트 처럼 1번 부터 찾기는 힘들다
하지만, 책 이름을 컴퓨터에서 검색하여 "3층 c열에 있다"라고 결과를 확인한 후, 
찾으면 바로 찾을 수 있다.
컴퓨터에서 검색 : 해시 함수
이와 같은 과정이 해시 테이블

# 해시 테이블의 장점 : 빠르다!
# 해시 테이블의 단점 : 미리 공간을 만들어놓아야 하기 때문에 메모리를 많이 차지 한다!

'''

# 출력 : print()

# 입력 : input()

name = '파이쏭'
print(name)
print(f'변수를 이용할 경우 %s' % name)
# %s : 문자열, %d: 숫자
#  정수의 경우 : int()로, 소숫점일 경우 float()로 변환
# 기본값 (각각의 값을 출력할 때 공백으로 구분)
print("apple", "banana", "cherry")
# => 출력:apple banana cherry

# 구분 기호를 이용할 경우 : sep="구분자"
print("apple", "banana", "cherry", sep=" / ")
# => 출력: apple / banana / cherry

# 하나의 print()에서 줄바꿈 대신 공백을 붙여서 한 줄로 출력
print("Hello", end=" ")
print("World")
# => 출력: Hello World
# 자주 사용되는 출력 특수 문자(이스케이프 문자)
\n: 줄바꿈
\t: 탭(Tab)만큼 띄우기
\\: 역슬래시(\) 문자 자체를 출력

# 형식을 지정하여 출력할 경우 : f-string 활용

f-string : 파이썬에서 문자열 안에 변수 값을 바로 넣을 수 있게 해주는 문법. "formatted string" 코드의 가독성 때문에 추가된 기능

service_name = "당목담글"
slogan = "사람과 마음을 연결하는 세상에서 가장 따뜻한 이어읽기 플랫폼"

print(f"[{service_name}]은 {slogan}입니다.")

age = 20

# 1. 옛날 방식 (문자열 더하기) - 숫자는 str()로 형변환을 해야 해서 번거로움
print("내 나이는 " + str(age) + "살입니다.")

# 2. .format() 방식 - 문자열과 변수의 위치가 떨어져 있어 한눈에 보기 힘듦
print("내 나이는 {}살입니다.".format(age))

# 3. f-string 방식 - 직관적이고 직관적이며 간결함!
print(f"내 나이는 {age}살입니다.")

a = 10
b = 20
print(f"{a} + {b}의 결과는 {a + b}입니다.")
# => 10+20의 결과는 30입니다.

name = "python"
print(f"대문자로 변환: {name.upper()}")
# => 출력: 대문자로 변환: PYTHON

## 소수점 자리수 지정
pi = 3.1415926535
print(f"원주율: {pi:.2f}")
# => 소소정 두자리까지만 출력
#실제 데이터는 그대로 있고, 출력할 때만 두자리까지 출력
# 금융권등에서 통장에 출력하는 경우 많이 사용
# 통신사의 요금 청구서 출력시에도 사용됨

## 천 단위 콤마(,) 넣기
money = 5000000
print(f"잔액: {money:,}원")
# => 출력: 잔액: 5,000,000원

## 디버깅용 출력 (=) (파이썬 3.8 이상)
# 변수에 무슨 값이 들어있는지 빠르게 확인(디버깅)하고 싶을 때,
# 괄호 안에 변수명과 함께 =를 붙이면 '변수명=값' 형태로 알아서 출력
user_count = 125
print(f"{user_count=}")
# => 출력: user_count=125
## 정렬과 공백 채우기 (Alignment)
# 텍스트를 좌측, 우측, 또는 가운데로 정렬하고 
# 남는 공간을 특정 문자로 채울수 있다
'''
:<[길이]: 좌측 정렬
:>[길이]: 우측 정렬
:^[길이]: 가운데 정렬
'''
text = "당목담글"
# 10칸의 공간을 만들고 정렬
print(f"|{text:<10}|") # 좌측 정렬 -> |당목담글      |
print(f"|{text:>10}|") # 우측 정렬 -> |      당목담글|
print(f"|{text:^10}|") # 가운데 정렬 -> |   당목담글   |

## 빈 곳을 원하는 문자로 채우기
# 방향 표시(<, >, ^) 앞에 원하는 문자를 넣으면, 
# 공백 대신 그 문자로 빈 곳을 채운다
# 예: 가운데 정렬하고 남는 공간을 하이픈(-)으로 채우기
print(f"{text:-^20}")
# => 출력: --------당목담글--------

## 날짜 및 시간(datetime) 포맷팅
# datetime 모듈을 사용할 때, 번거롭게 .strftime() 메서드를 쓰지 않고 
# f-string 안에서 곧바로 원하는 날짜/시간 형식으로 출력할 수 있다
# 연-월-일 시:분:초 형식으로 출력
from datetime import datetime
now = datetime.now() # now() 현재 시스템의 시간 추출 함수
print(f"현재 시간: {now:%Y-%m-%d %H:%M:%S}")
# => 출력: 현재 시간: 2026-07-09 09:41:01

## 중괄호 {} 문자 자체를 출력
# 중괄호를 두 번 연속({{, }}) 쓰면 출력 가능
group = "릴레이"
print(f"플랫폼 구성 요소: {{{group}}}")
# => 플랫폼 구성 요소: {릴레이}

##  따옴표가 겹치는 상황 해결
# => f-string 내부에서 딕셔너리(Dictionary)의 키를 조회할 때 자주 발생
# => f-string 바깥쪽 따옴표와 안쪽 따옴표를 
#     서로 다른 종류(쌍따옴표/홑따옴표)로 사용
user = {"name": "김철수", "role": "페르소나"}
print(f"사용자 역할: {user['role']}") # 사용자 역할: 페르소나

# 에러 예
print(f"사용자 역할: {user["role"]}") # SyntextError 발생

## 진수(Binary, Hex) 변환 및 0 채우기
# => 숫자를 2진수, 8진수, 16진수로 바꾸거나, 
#    지정한 길이만큼 앞자리를 0으로 채워야 할 때
number = 42
print(f"2진수: {number:b}") # 2진수: 101010
print(f"16진수: {number:x}") # 16진수: 2a

# 빈 자리는 0으로 채우기
page = 7
print(f"페이지 번호: {page:03d}") # 페이지 번호: 007

0708 데이터 분석 및 시각화

인뽕 — Thu, 9 Jul 2026 00:31:36 +0900

데이터를 다루기 위해서는 데이터를 가공하고 분석만 하는데 그쳐선 안된다.

데이터를 한 눈에 볼 수 있게시각화하는 과정이 반드시 필요하다. 가공되지 않은 데이터의 이상치를 찾아내거나, 결측치, 이상치, 데이터 왜곡 및 타입 오류를 해결하여 의미있는 데이터로 만들고 의미있는 인사이트를 도출해낼 때 데이터의 시각화를 하게 된다.

대한민국의 '삶의 만족도', '건강', '경제', '관계및사회참여', '교육', '안전', '환경', '여가' (이하 데이터묶음) ()를 활용해서 지역별 데이터의 평균을 분석하고 시각화 해보자.

# 데이터 로드

import pandas as pd

happy_life = pd.read_excel('./data/대한민국행복지도_삶의만족도.xlsx')
happy_life.head();
happy_health =pd.read_excel('./data/대한민국행복지도_건강.xlsx')
happy_health.head()
happy_econo = pd.read_excel('./data/대한민국행복지도_경제.xlsx')
happy_econo.head()
happy_relation =pd.read_excel('./data/대한민국행복지도_관계및사회참여.xlsx')
happy_relation.head()
happy_edu = pd.read_excel('./data/대한민국행복지도_교육.xlsx')
happy_edu.head()
happy_safe = pd.read_excel('./data/대한민국행복지도_안전.xlsx')
happy_safe.head()
happy_leisure = pd.read_excel('./data/대한민국행복지도_여가.xlsx')
happy_leisure.head()
happy_environ = pd.read_excel('./data/대한민국행복지도_환경.xlsx')
happy_environ.head()

엑셀에 저장된 각 데이터묶음 들을 pandas의 read_excel 함수로 읽어온다.

#데이터 병합

city = list(happy_life['시도'].unique())# 중복제거

happy_merge = pd.DataFrame({'시도' : city})
#삶의 만족도
life = happy_life['삶의 만족도'].groupby(by=happy_health['시도']).mean()
happy_merge = pd.merge(happy_merge,life,on='시도')
#건강
health = happy_health['평균'].groupby(by=happy_health['시도']).mean()
happy_merge = pd.merge(happy_merge,health.rename('건강'),on='시도')
#경제
econo = happy_econo['평균'].groupby(by=happy_econo['시도']).mean()
happy_merge = pd.merge(happy_merge,econo.rename('경제'),on='시도')
#관계및사회참여
relation = happy_relation['평균'].groupby(by=happy_relation['시도']).mean()
happy_merge = pd.merge(happy_merge,relation.rename('관계및사회참여'),on='시도')
#교육
edu = happy_edu['평균'].groupby(by=happy_edu['시도']).mean()
happy_merge = pd.merge(happy_merge,edu.rename('교육'),on='시도')
#안전
safe = happy_safe['평균'].groupby(by=happy_safe['시도']).mean()
happy_merge = pd.merge(happy_merge,safe.rename('안전'),on='시도')
#환경
environ = happy_environ['평균'].groupby(by=happy_environ['시도']).mean()
happy_merge = pd.merge(happy_merge,environ.rename('환경'),on='시도')
#여가
leisure = happy_leisure['평균'].groupby(by=happy_leisure['시도']).mean()
happy_merge = pd.merge(happy_merge,leisure.rename('여가'),on='시도')

각 데이터묶음 의 '시도' 데이터들을 unique() 함수를 통해 중복이 없는 시도집합을 city 리스트에 저장한다.

중복이 없는시도 데이터들을값으로 갖고 '시도'라는 칼럼을 갖는 happy_merge를 정의한다.

각 데이터묶음 의 '시도' 데이터들로 그룹화 하여 데이터의 평균을 값으로 갖는 시리즈들을 만들고,

어제 공부했던 pandas의 merge 함수를 이용해 각 데이터프레임의 '시도' 데이터로 happy_merge와 병합한다.

이때, 각 데이터묶음 은 같은 종류의 시도를 갖기 때문에 새로운 결측치가 생기지 않는다.

#데이터 분석

happy_merge.info()
happy_merge.describe()

우선 info(), describe()를 통해 결측치를 알아보고 평균을 알아본다.

결측치는 없군.

칼럼별 개수, 평균, 표준편차, 최저값,최고값 등

happy_merge.mean(axis=1,numeric_only=True)# 행의 평균
happy_merge.mean(axis=0,numeric_only=True)# 열의 평균

각 행과 열의 평균을 알아본다. axis =1 : 행 axis = 0 : 열

시도문자열(서울특별시,경기도 등)이 인덱스가 아니고 값이기 때문에, 숫자의 평균을 내는데 문자열 데이터가 섞여들어가는 꼴이기 때문에 mean함수를 사용할때 numeric_only=True를 해줘야 한다.

happy_merge.set_index(['시도']).mean(axis=1)

('시도' 데이터를 값 -> 인덱스로 바꾼 데이터프레임).mean이기때문에 여기선 numeric_only=True이 필요 없다.

happy_merge.corr(numeric_only=True) # 각 변수(컬럼)들 간의 상관 관계

corr은 각 칼럼들의 상관관계를 나타내는 함수이다.

출력 결과

#데이터 시각화

드디어 데이터를 시각화할때가 왔다.

데이터 시각화를 위해서는 matplotlib와 seaborn 라이브러리가 필요하다.

import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import seaborn as sns

#OS에 따른 폰트 설정방법
path = 'c:/Windows/Fonts/malgun.ttf'
import platform
from matplotlib import font_manager, rc
if platform.system()=='Darwin':
    rc('font',family='AppleGothic')
elif platform.system() =='Windows':
    font_name=font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
else:
    print('Unknown system... sorry~~~')

우선 플랫폼에 따른 폰트를 설정한다.

plt.figure(figsize=(15,6))

플롯의 크기 를 설정한다. 가로 15, 세로 6

item = list(happy_merge.columns[1:9])
for a in item:
    chartdata = happy_merge[a]
    plt.plot(chartdata, marker='o', label=a)

칼럼의 0열은 '시도' 이므로 1열~8열까지 저장하는 리스트 item을 만들고,

item의 값을 인덱스로하는 happy_merge의 행을 chartdata에 저장하고, plt.plot 함수로 가로축에 지역 라벨을 붙이고 o 모양의 점을 찍고 선을 이어 그래프를 만든다.

플롯 그리기

여기까지만 하면 뭔가 심심하다. 그래프의 제목과, 가로축 세로축 라벨, 격자, 범례를 추가해주자.

plt.xlabel('시도')
plt.ylabel('수치')
plt.xticks(range(17), happy_merge.index,fontsize=10,rotation=45)
plt.title('대한민국 행복지수')
plt.legend()
plt.grid()
plt.show()

짜잔 좀더 이쁜그래프 완성

#막대 그래프

from numpy import *

happy_merge.plot(kind='bar', xlabel = '시도', ylabel='수치',
                 figsize=(15,20), grid=True, subplots=True)

plt.suptitle('대한민국 행복지수', fontsize=25)
plt.tight_layout(pad=8, h_pad =2)
plt.show()

위 코드는 matplotlib을 사용하지 않고 pandas의 내장 함수 plot()을 사용해서 막대그래프를 출력하는 코드이다.

subplots=True을 통해 칼럼별로 그래프를 나눠서 그릴 수 있었다.

꺾은선 그래프와 달리 칼럼 수 슬라이스 처리를 하지 않아 빈 그래프가 하나 더추가된 것을 볼 수 있다.

#히트 맵

import seaborn as sns

plt.figure(figsize=(15,13))
plt.title('대한민국 행복지수 상관관계',fontsize=25)
plt.rc('axes', unicode_minus=False)
#unicode_minus =False : 한글 사용시, 가끔 '-'부호가 꺠지는 것을 방지
correlation_mat = happy_merge.corr(numeric_only=True)
#happy_merge.corr() : happy_merge의 모든 컬럼들에 대한 
#                     상관관계를 계산하여 계수 표를 만듦
# numeric_only = True : 숫자 영역만
upp_mat = triu(correlation_mat)
#np.triu() : 상관관계 표는 대각선을 기본으로 거울 처럼 표현
#np.ones_like(dtype=bool) :상관관계표와 동일한 크기로 채워진 표
# correlation_mat : corr()로 구한 상관관계 표 데이터
# 참고: triu는 TRIANGLE UPPER의 약자
sns.heatmap(correlation_mat, mask=upp_mat,
            annot=True, cmap='RdYlGn', fmt= '.2f')
# mask=upp_mat : 히트맵의 오른쪽 상단을 가림(masking)
# annot=True : 색상 위에 실제 상관계수를 쓰기
# cmap = 'RdYlGn' : 제공하는 색상 팔레트를 사용 Red Yellow Green
# red->yellow->green 양의 상관관계가 높으면 green
# 음의 상관관계가 높으면 red
# fmt= '.2f' : 숫자를 소수점 이하 두자리까지만

plt.show()

상관관계표는 기본적으로 대칭행렬이기 때문에 의미있는 좌하단부만 출력한다.

# 이상치 확인을 위한 boxplot의 예

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

#한글 깨짐 방지 설정 (Windows: 'Malgun Gothic', Mac : 'AppleGothic')
plt.rc('font', family='Malgun Gothic')

#1 예시 데이터 만들기(정상 기온 20도 안팎 + 이상치 몇 개)
data = {
        '연도': [2026]*100,
        '기온': list(np.random.normal(loc=20,scale=3,size=97))+[45.2,-15.0,41.8]
        # 45도, -15도 등의 이상치 삽입
        }
weather =pd.DataFrame(data)

#2 boxplot 그리기
plt.figure(figsize=(6,8))
sns.boxplot(y='기온',data=weather,
            color='skyblue',
            flierprops={'markerfacecolor':'red', 'marker':'o'})

#flierprops={'markerfacecolor':'red','marker':'o'}
'''
이상치(Outlier) 점들의 스타일(색상, 모양 등)을 내 입맛대로 꾸미기 위해 사용하는 옵션
'''
plt.title('기온 데이터의 이상치 분석')
plt.ylabel('기온(℃)')
plt.show()
'''
boxplot 보는 방법
'''

임의의 데이터 만들기 : 정상치 데이터 97개 + 이상치 데이터 3개

위 박스플롯그래프를 보면 하늘색 박스가평균, 빨간 마커가 이상치로 한눈에 파악할 수 있다.

상관계수 용어 정리

'''
 ...
 1~0~-1 사이의 숫자로 표현
1: 매우 밀접한 관계 : 하나가 크면 다른 하나도 증가 예) 키와 몸무게, 공부 시간과 성적
0: 관계가 없다
-1:매우 밀접한 관계 : 하나가 크면 다른 하나는 감소
    예) 스마트 폰 사용시간과 수면시간

즉, 1, -1은 두 데이터가 강력하게 묶여 있다는 의미    
    0은 두 데이터는 상관 없다
 공분산(Covariance) : 두 개의 데이터가 함께 변화하는 '방향'을 나타내는 통계 값
 공분산이 알려주는 3가지 방향
 공분산> 0 (양수): $X$가 커질 때 $Y$도 같이 커지는 경향이 있다. (우상향)
 공문산< 0 (음수): $X$가 커질 때 $Y$는 작아지는 경향이 있다. (우하향) 공분산 = 0: 두 데이터 사이에 뚜렷한 직선 형태의 관계가 없다.
 두 데이터 X와 Y 있을 때,
 공분산 값의 부호를 보면 두 데이터가 같이 움직이는지, 반대로 움직이는지 알 수 있다 공분산은 두 데이터가 '어떤 방향'으로 움직이는지는 확실하게 알려주지만,
 "그 관계가 얼마나 강한지"는 제대로 알려주지 못한다.
 사람의 '키'와 몸무게'의 공분산을 구한다고 가정.
 키를 미터(m)로 재서 계산했을 때 공분산이 1.5가 나왔다.
 똑같은 사람들의 키를 밀리미터(mm)로 바꿔서 계산하면, 숫자의 단위가 커졌기 때문에 공분산 값이 감자기 1500으로 폭증.
 데이터의 실제 관계는 똑같은데 단위에 따라 숫자가 1.5에서 1500으로 바뀌어 버리니, 다른 데이터와 비교하기가 불가능해진다.
 그래서 이 공분산 을 각 데이터의 '표준편차'로 나누어서, 측정 단위에 상관없이 항상 1에서 그 사이의 값만 나오도록 꽉 암축(정규화)한 것이 바로 앞서 살펴본 상관계수(r).
 •..
 •..
 표준편차 : 데이터들이 평균으로부터 얼마나 멀리 떨어져서 흩어져 있는가?"를 나타내는 숫자
표준편차가 알려주는 것
표준편차가 작다: 데이터들이 평균 근처에 오밀조일하게 모여 있다는 뜻.
(안정적, 예측 가능)
표준편차가 크다: 데이터들이 평균에서 멀리 떨어져서 밟게 퍼져 있다는 뜻.
(변동성이 큼, 들쭉날쭉함)
4반과 B반의 수학 시험 평균이 둘다 70점이라고 가정.
A반: 대부분의 학생이 65점~ 75점 사이를 받았다.    
(평균 근처에 몰려 있음 -> 표준편차가 작다!)
B반: 100점 맞은 학생도 있고, 40점 맞은 학생도 섞여 있다.
(점수가 널뛰기함—> 표준편차가 크다!)
즉, 평균만으로는 알 수 없는 '데이터의 진짜 생김새(퍼짐 정도)'를 알려주는 것이 바로 표준편차
'''

'''
np.random.multivariate_normal(mean, cov, num_points).T

np.random : 임의의 수를 추출
multivariate_normal() : Numpy가 제공하는 다변량 정규분포를 만들어 주는 함수

다변량(Multivariate): 변수가 여러 개(여기서는 X와 Y, 2개) 라는 뜻.
mean (평균) 점들이 어디에 모여 있을지 '중심점'을 정해주기 위함.
코드에서는 [0,0]이었으니 영점(원점) 근처에 점들이 위치.
cov (공분산 행렬): X와 Y가 서로 어떤 방향으로, 얼마나 강하게 엮여서 흩어질지 '규'
여기에 우리가 조절했던 상관계수 (r) 값이 들어간다.
.num_points (개수): 점을 몇 개 찍을 지 정한다. (예: 200개)

따라서 위 함수가 실행되면
파이썬은 (200, 2) 모양의 행렬 (배열)을 만들어낸다.
즉, 200줄(행) 2칸(열)짜리 표가 만들어진다.

.T (Transpose, 전치행렬) : 행과 열을 바꾸는 역할.
데이터가 [x,y] 쌍으로 묶여서 200줄로 서 있으면, 
나중에 x축 데이터와 y축 데이터를 따로 분리해서 그래프에 넣기가 번거롭다.

그래서 수학의 '전치행렬(행과 열을 뒤바꿈' 기능을 하는 .T를 뒤에 붙여준다.
이렇게 하면 (200,2) 모양의 데이터가 (2,200) 모양으로 확 뒤집힌다.
'''

0707 Pandas

인뽕 — Thu, 9 Jul 2026 00:25:43 +0900

Pandas

- 파이썬에서 표(테이블) 형태의 데이터를 다루기 위한 라이브러리이다.

Pandas에서 가장 알아야 할 것은 Seriese, DataFrame이라는 자료구조이다. 1차원 데이터를 다루는 데 효과적인 Seriese와 2차원 데이터를 다루는 데 효과적인DataFrame을 활용하여 파이썬만으로는 할 수 없었던 데이터 정제, 데이터 가공, 데이터 요약 및

분석을 할 수 있다.

#지정한 문자열 인덱스로 데이터 접근

kakao2 = Series([92600,92400,92100,94300,92300],
                index=['2016-02-19',
                       '2016-02-18',
                       '2016-02-17',
                       '2016-02-16',
                       '2016-02-15'])

print(kakao2['2016-02-19'])

시리즈를 생성할때 지정한 인덱스(2016-02-19)를 통해 데이터에 접근한다.

# 딕셔너리를 사용한 기본 DataFrame 생성

# 칼럼 선택을 통해 각 Series 객체에 접근

raw_data = {'col0': [1,2,3,4],
            'col1': [10,20,30,40],
            'col2': [100,200,300,400],}


# 칼럼 선택을 통해 각 Series 객체에 접근
data = DataFrame(raw_data)
data['col1']
print(data['col0'])
print(type(data['col0']))

key:string value : list(int)

인 딕셔너리 raw_data를 사용해서 data라는 DataFrame을 만든다.

key값이었던 문자열들이 칼럼이 되어 data['col1']처럼 칼럼 선택을 통해 각 Series 객체에 접근한다.

#인덱스 순서가 서로 다른 두 개의 Series 생성

mine = Series([10,20,30],index=['naver','sk','kt'])
friend = Series([10,30,20],index=['kt','naver','sk'])

merge = mine + friend

인덱스의 구성이 같은 두 시리즈를 더하면 각 인덱스에 해당하는 값끼리 더해진 시리즈가 된다.

#주가 데이터(OHLC) DataFrame 생성 (칼럼 순서 및 인덱스 지정)

#주가 데이터(OHLC) DataFrame 생성 (칼럼 순서 및 인덱스 지정)
daeshin = {'open': [11650,11100,11200,11100,11000],
           'high': [12100,11800,11200,11100,11150],
           'low': [11600,11500,10900,10950,10900],
           'close': [11900,11600,11000,11100,11050]
           }

대신증권의 시가, 고가, 저가, 종가 문자열을 키, 가격을 값으로 갖는 딕셔너리를 정의한다.

# columns로 칼럼 순서를 정렬하고,
# index로 날짜를 지정하여 생성

daeshin_day = DataFrame(daeshin,
                        columns=['open', 'low', 'high','close'])

# index로 날짜를 지정하여 생성
date = ['16.02.29', '16.02.26', '16.02.25', 
        '16.02.24', '16.02.23']
daeshin_day = DataFrame(daeshin,
                        columns=['open',
                                 'high',
                                 'low',
                                 'close'],
                        index=date)

앞서 정의한 daeshin 딕셔너리와 다시 정의한 칼럼 순서, 리스트로 정의한 날짜 date를 인덱스로 만들어 DataFrame()에 전달해 데이터프레임을 만든다.

# 칼럼 선택 (종가 데이터 선택)

close = daeshin_day['close']
print(close)

데이터프레임 daeshin_day에서 'close' 칼럼의 정보를 날짜별로 모아놓은 close라는 시리즈를 만든다.

출력 결과

# 로우 선택

# (기존 ix 대신 loc 메서드를 사용하여 특정 날짜 행 선택)
print(daeshin_day.loc['16.02.24'])

close와 달리 인덱스를 사용해 해당 날짜의 시가, 고가, 저가, 종가를 출력한다.

출력 결과

# 방법 A : .loc[행, 열] 구조로 정확하게 짚기

print(daeshin_day.loc['16.02.24', 'close'])

데이터프레임 daeshin_day에서 '16.02.24' 행 'close'열을 출력한다.

출력결과

# 방법 B: 이미 뽑아둔 close 시리즈에서 날짜로 조회하기

print(close['16.02.24'])

미리 정의한 close 시리즈에 인덱스를 넣어 출력한다.

출력결과

#CSV 파일 불러오기

import pandas as pd

df = pd.read_csv('./data/csv/medical.csv')

pandas를 import 해주고 read_csv 함수를 호출 해 medical.csv 파일을 읽어와 데이터프레임으로 만든다.

(필요시 인코딩방식 명시)

# 데이터의 상위 , 하위 5개 행 확인

print(df.head())
print(df.tail())

데이터프레임의 상위 , 하위 5개 행을 출력한다.

출력 결과

#데이터의 기본 정보 (행/열 개수, 데이터 타입, 결측치 유무) 확인

# 기술 통계량(평균, 최댓값, 최솟값 등 ) 요약 확인

print(df.info())
print(df.describe())

데이터의 행/열 개수, 데이터 타입, 결측치 유무를 확일 할 수 있는 info() 함수, 기술 통계량(평균, 최댓값, 최솟값 등 ) 요약을 확인할 수 있는 describe() 함수이다. 추가로 각 컬럼별 결측치의 개수를 확인 할 수 있는 함수를 isnull().sum()이라고한다. 위 함수들은

데이터 정제 과정에서 꼭 필요한 함수들이다.

# 'Age' 컬럼이 60 이상인 데이터만 필터링

senior_patients = df[df['Age']>=60]

Age 컬럼의 열 데이터 중 60이상인데이터만 필터링 하여 senior_patients(dtype : Series)에 저장한다.

# 여러 조건 결합 (나이가 60세 이상이면서 'NO_SHOW'가 'Yes'인 환자)

no_show_seniors =df[(df['Age']>=60)&(df['No-show']=='Yes')]

논리연산자 &를 사용하여 Age가 60 이상, No-show가 Yes인 데이터만 필터링하여 no_show_seniors( dtype : Series )에

저장한다.

결측치 처리 방법

# 방법 A : 결측치가 포함된 행을 모두 삭제하기

df_cleaned =df.dropna()

# 방법 B : 결측치를 특정 값(예: 0 또는 평균값)으로 채우기

df_filled =df.fillna(0)
df['Age'] = df["Age"].fillna(df['Age'].mean())

### 4. 데이터 그룹화 및 집계 (groupby)####

# 'No-show'(노쇼 여부)별로 'Age'(나이)의 평균 계산하기

age_by_noshow = df.groupby('No-show')['Age'].mean()

age_by_noshow는 노쇼 여부별로 Age의 평균값을 데이터로 갖는 시리즈이다.

# 여러 컬럼을 기준으로 집계 (성별과 노쇼 여부별 환자 수 카운트)

grouped_count = df.groupby(['Gender', 'No-show']).size()
print(grouped_count.index)

grouped_count는 df에서 Gender, No-show의 종류 (여기서는 개수는 2*2) 별로 환자수를 센다.

# 'Age' 컬럼을 기준으로 내림차순 정렬 (나이가)

df_sorted = df.sort_values(by='Age', ascending =False)

df에서 Age칼럼의값을 기준으로 내림차순 정렬한다. ascending=True면 오름차순.

# 'No-show' 컬럼에 어떤 값이 각각 몇개씩 들어있는지 확인

print(df['No-show'].value_counts())

비율이나 빈도 파악에 유용하다.

#가장 첫 번째 행(0번행) 데이터 가져오기

first_row =df.iloc[0]

df의 0번 행을 저장한다.

# 처음 5개 행과 처음 3개 열 슬라이싱 하기

subset = df.iloc[0:5, 0:3]

0~4번째 행, 0~2번째 열 정보를 subset에 저장한다. (5행3열)

##### Pandas pivot_table 사용법 #####
index: 세로 행에 배치할 기준
columns: 가로 열에 배치할 기준
values: 표 안에 채워 넣을 데이터(계산 대상)

aggfunc: 데이터의 대상 함수

# 예시 1: 성별(Gender)과 노쇼 여부(No-show)에 따른 평균 나이 (Age)
# 세로(index): 성별(Gender)
# 가로(columns): 노쇼 여부 (No-show)

# 값(values): 나이 (Age)의 평균

pivot_age = df.pivot_table(index='Gender',
                           columns='No-show',
                           values='Age',
                           aggfunc='mean')

인덱스를 'Gender'의 종류 (M,F), 칼럼을 'No-show'의 종류 (Yes, No), 데이터는 Age의 평균을 갖는 데이터프레임을 만든다.

pivot_age 형태

# 성별 및 노쇼 여부별 환자 수 카운트
# margins 인자 추가시 가로/세로 총합 추가

pivot_gender_no_show = df.pivot_table(index='Gender',
                           columns='No-show',
                           values='PatientId',
                           aggfunc='count',
                           margins=True)

Gender,Noshow 별 환자의 수를 구한다.

pivot_gender_no_show 형태

#Pandas에는 df.pivot()과 df.pivot_table()

df.pivot(): 데이터에 중복된 행이 없을 때
df.pivot_table(): 병원 데이터처럼 중복된 항목(같은 성별, 같은 노쇼 등)
이 많아서 그룹화 하고 요약 통계(평균, 합계 등)

데이터 분석에서는 90% 이상 pivot_table을 사용

### 두 개 이상의 데이터프레임 병합하기 (merge)

### 두 개 이상의 데이터프레임 병합하기 (merge)
# 예시 데이터프레임 1: 진료 기록
df_medical = pd.DataFrame({
    'PatientId': [101, 102, 103],
    'No-show':['No','Yes','No']
    })

# 예시 데이터프레임 2: 환자 주소 정보
df_info = pd.DataFrame({
    'PatientId' : [101,102,104],
    'Neighborhood' : ['Jardim', 'Maria', 'Centro']
    })

# PatientId를 기준으로 두 데이터 프레임 병합
df_merged = pd.merge(df_medical, df_info,
                     on='PatientId',
                     how='outer')
'''
1. how= 'inner' (기본값)
2. how='left'
3. how ='right'
4. how = 'outer'
'''

임의의 데이터프레임 df_medical(인덱스는 지정하지 않았으므로 기본인덱스0,1,2, 칼럼은 PatientId,No-show )과

df_info( 인덱스는 지정하지 않았으므로 기본인덱스0,1,2, 칼럼은 PatientId, Neighborhood)

두 데이터프레임이 공유하는 칼럼 PatientId를 활용하여 데이터프레임을 병합한다.

마지막인자 how에 따라 어떤 데이터프레임의 PatientId값을 기준으로 병합할지 결정된다.

inner 선택시 두 데이터프레임의 교집합인 PatientId를 기준으로 병합되므로 새로운 결측치가 발생하지 않고,

outer 선택시 두 데이터프레임의 합집합인 PatientId를 기준으로 병합되므로 새로운 결측치가 발생할 수 있다.

###날짜 데이터 형식 변환(to_datetime) ###

# 'AppointmentDay' 컬럼을 문자열에서 날짜 형식으로 변환
df['AppointmentDay'] = pd.to_datetime(df['AppointmentDay'])
df['ScheduledDay'] = pd.to_datetime(df['ScheduledDay'])

#2. 접수 후 예약일까지 며칠이나 걸렸는지 대기 기간 계산
df['Waiting_Days'] = (df['AppointmentDay'] - df['ScheduledDay']).dt.days

예약일과 진료예정일 데이터를 문자열에서 날짜 형식으로변환한 뒤, (진료예정일 - 예약일)로 접수 후 예약일까지 대기기간을 계산하여 칼럼으로 추가한다.

### Pandas 데이터 분석 ###
'''
1. 데이터 로드 및 확인: read_csv(), head(), info()
2. 데이터 정제: 결측치 처리(dropna(), fillna()), 날짜 변환(to_datetime())
3. 데이터 가공: 파생 변수 생성(apply()), 데이터 병합(merge())
4. 데이터 요약 및 분석: groupby(), pivot_table(), value_counts()
'''

0706 Class

인뽕 — Wed, 8 Jul 2026 23:28:32 +0900

Class

- 객체지향 프로그래밍의 핵심 문법으로 비슷한 속성(데이터)과 기능(함수)을 하나로 묶어서, 새로운 자료형(틀)을 만드는 것 이다.

클래스로 생성한 객체들을 인스턴스라고 한다. 흔한 비유로 클래스를 정의하는 것은 붕어빵을 만들 때 사용하는 기본 틀을 제작하는 것에 해당하고, 인스턴스는 붕어빵 틀에 반죽을 넣어서 만들어진 붕어빵에 해당한다.

C++, 자바(Java), C# 같은 프로그래밍 언어는 기본적으로 클래스를 지원한다.

예를 들어 클래스를 통해 명함이라는 객체를 만들어 두면 명함 객체가 정수, 실수, 문자열과 마찬가지로 하나의 타입으로 인식되기 때문에 여러 명의 명함 정보도 쉽게 관리할 수 있다.

코드를 설계할 때, 멤버 변수와 멤버 함수는 생각하지 못했지만 클래스만 명시 해두고 싶을때, pass라는 키워드를 사용해 클래스 내부에 아무것도 넣지 않은 상태로 클래스를 정의할 수 있다.

파이썬에서 정의된 클래스를 이용해 인스턴스를 생성하려면 다음과 같이 클래스 이름 뒤에 ()를 넣으면 된다. 어떻게 보면 인스턴스를 생성하는 과정은 함수를 호출하는 것과 비슷다. 다음 코드가 실행되면 그림과 같이 'BusinessCard'라는 클래스의 인스턴스가 메모리의 0x0302ABB0 위치에 생성되고 card1이라는 변수가 이를 바인딩하게 된다.

파이썬 클래스에서 내부함수의 첫번째로 self라는 변수사용한다. self는 해당 클래스로 생성된 인스턴스 자기자신을 의미하고 이를 인스턴스 변수라고 부른다. 실제로 함수를 호출할때에는 따로 인자를 전달 할 필요는 없다.

위 그림에서 내부함수 set_info로 내부 변수 name, emain, addr을 정의하게 된다.

파이썬에서는 따로 변수의 자료형을 선언하지 않는다.

파이썬에서의 클래스 생성자는 __init__이라는이름을 갖는다. __init__이라는 함수를통해 생성과 동시에 내부변수를 초기화 할 수 있다. (소멸자는 __del__(self))

클래스의 상속은 다음과 같이 인자에 부모클래스의 이름을 넣어주면 된다.

실습

생성자와 자신의 멤버변수 데이터를 출력하는 print_info라는 멤버함수를 가진 Contact라는 연락처 클래스를 만들고

Contact_list에서 연락처들을 연락처 입력, 출력, 삭제, 저장하며 관리하는 프로그램을 작성했다.

# -*- coding: utf-8 -*-
"""
Created on Mon Jul  6 09:19:01 2026

@author: ihhan


선택메뉴
1. 연락처 입력
2. 연락처 출력
3. 연락처 삭제(이름기준)
4. 종료: txt파일로 저장

"""
class Contact:
    def __init__(self,name,phone_number, e_mail, addr):
        self.name=name
        self.phone_number=phone_number
        self.e_mail=e_mail
        self.addr=addr
        
    def print_info(self):
        print('=========================')
        print('이름:',self.name)
        print('전화:',self.phone_number)
        print('메일:',self.e_mail)
        print('주소:',self.addr)
        print('=========================')



#--1. 연락처 입력 ----------------------------------
def set_contact():
    name=input('이름 입력:')
    phone_number=input('전화번호 입력:')
    e_mail=input('메일 입력:')
    addr=input('주소 입력:')
    return Contact(name,phone_number,e_mail,addr)
    
    
#--2. 연락처 출력 ----------------------------------
# contact 객체가 가지고 있는 값(변수)을 출력 :2.
def print_contact(contact_list):
    for contact in contact_list:
        contact.print_info();
        
        
#--3. 연락처 삭제 ----------------------------------
# 이름을 통해 삭제 :3.

def delete_contact(contact_list,name):
    for i, contact in enumerate(contact_list):
        if contact.name ==name:
            del contact_list[i]
            
            
#--4. 연락처 저장 ----------------------------------
# 종료 선택시, 파일로 저장
def store_contact(contact_list):
    f=open('db.txt','wt')
    for contact in contact_list:
        f.write(contact.name+'\n')
        f.write(contact.phone_number+'\n')
        f.write(contact.e_mail+'\n')
        f.write(contact.addr+'\n')
    f.close()
#--사용자 선택 메뉴--------------------------------
def print_menu():
    print('1. 연락처 입력')
    print('2. 연락처 출력')
    print('3. 연락처 삭제')
    print('4. 연락처 저장')
    menu=input('메뉴 선택: ')
    return int(menu)

def run():
    
    contact_list = []
    while 1:
        menu=print_menu()
        if menu==1:
            contact = set_contact()
            contact_list.append(contact)
        elif menu==2:
            print_contact(contact_list)
        elif menu==3:
            name = input('삭제할 이름 입력: ')
            delete_contact((contact_list), name)
        elif menu==4:
            store_contact(contact_list)
            break
        else:
            print('잘못된 명령입니다.')
        
if __name__=='__main__':# 파일 자체 실행 여부 확인
     run()

member.csv 파일을 읽어와서 이름, 등급, 최근방문일 데이터를 갖고 있는 Member 인스턴스에 저장해 member_list를 만든다.\

class Member:
    def __init__(self,name,rate,DateofLastVisit,NumberofVisit):#이름,멤버 등급,최종방문일,방문수
        self.name=name
        self.rate=rate
        self.DateofLastVisit=DateofLastVisit
        self.NumberofVisit=NumberofVisit
    def print_info(self):
        print('=========================')
        print('이름:',self.name)
        print('등급:',self.rate)
        print('최근방문일:',self.DateofLastVisit)
        print('=========================')
        
with open('member.csv', 'r', encoding='utf-8') as f:
    lines = f.readlines()
    member_list = []
    
    
    for line in lines[1:]:              # [1:] → 첫 줄(헤더)은 건너뜀
        line = line.strip()               # 줄바꿈 문자 제거
        if not line:                    # 빈 줄이면 건너뜀
            continue
        values = line.split(',')        # 쉼표 기준으로 쪼개서 리스트로 만듦
        m = Member(values[0], values[1], values[3], values[4])
        if int(m.NumberofVisit) >= 50:
            member_list.append(m)

# 결과 출력
    for m in member_list:
        m.print_info()

11만개의 병원 예약 정보가 담긴 엑셀 파일을 읽어와서, 진료일에 노쇼하는 환자들의 특징을 분석한다.

나는 실습 1번처럼 사용자가 직접 성별, 예약 대기기간, 연령대 별로 교차분석을 할 수 있는 프로그램을 만들었다.

# -*- coding: utf-8 -*-
"""
Created on Mon Jul  6 15:54:00 2026

@author: ihhan
"""
from datetime import datetime
class Patient:
    def __init__(self,PatientId,AppointmentId,Gender,ScheduledDay,AppointmentDay,Age,Neighbourhood,SMS_received,No_show):
        self.PatientId=PatientId
        self.AppointmentId=AppointmentId
        self.Gender=Gender
        self.ScheduledDay=ScheduledDay
        self.AppointmentDay=AppointmentDay
        self.Age=Age
        self.Neighbourhood=Neighbourhood
        self.SMS_received=SMS_received
        self.No_show=No_show
    def print_info(self):
        print('=========================')
        print('환자ID:',self.PatientId)
        print('예약ID:',self.AppointmentId)
        print('성별:',self.Gender)
        print('예약일:',self.ScheduledDay)
        print('진료예정일:',self.AppointmentDay)
        print('나이:',self.Age)
        print('지역:',self.Neighbourhood)
        print('SMS수신동의:',self.SMS_received)
        print('노쇼여부:',self.No_show)
        print('=========================')
#함수화 하려면 특정 (표본/전체) 두개의 데이터를 반환하는게 좋을듯

with open('medical.csv', 'r', encoding='utf-8') as f:
    lines = f.readlines()
    patient_list = []
       
    for line in lines[1:]:              # [1:] → 첫 줄(헤더)은 건너뜀
        line = line.strip()               # 줄바꿈 문자 제거
        if not line:                    # 빈 줄이면 건너뜀
            continue
        values = line.split(',')        # 쉼표 기준으로 쪼개서 리스트로 만듦
        p = Patient(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8])
        patient_list.append(p)
        
                
    #연령별 노쇼율
    age_total = {
        "0~19세": 0,
        "20~39세": 0,
        "40~59세": 0,
        "60세 이상": 0
        }   

    age_noshow = {
        "0~19세": 0,
        "20~39세": 0,
        "40~59세": 0,
        "60세 이상": 0
        }

    for p in patient_list:

        age = int(p.Age)

        # 음수 나이는 제외
        if age < 0:
            continue

        if age < 20:
            group = "0~19세"
        elif age < 40:
            group = "20~39세"
        elif age < 60:
            group = "40~59세"
        else:
            group = "60세 이상"

        age_total[group] += 1

        if p.No_show == "Yes":
            age_noshow[group] += 1
            
    print("\n연령대별 노쇼율")

    for group in ["0~19세", "20~39세", "40~59세", "60세 이상"]:
        rate = age_noshow[group] / age_total[group]
        print(f"{group:10} : {age_noshow[group]}/{age_total[group]} ({rate:.2%})")
# # 결과 출력
#     for p in patient_list:
#         p.print_info()
#--사용자 선택 메뉴--------------------------------
def print_menu():
    print('1. 성별별 분석 ')
    print('2. 예약 대기기간별 분석')
    print('3. 연령대별 분석')
    print('4. 교차분석')
    print('5. 종료')
    menu=input('메뉴 선택: ')
    return int(menu)
def analyzeByGender(g):
    #성별별 노쇼율
    male_count = 0
    male_noshow = 0

    female_count = 0
    female_noshow = 0

    for p in patient_list:
        if p.Gender == 'M':
            male_count += 1
            if p.No_show == 'Yes':    # 데이터에 맞게 'YES' 또는 'Yes' 사용
                male_noshow += 1

        elif p.Gender == 'F':
            female_count += 1
            if p.No_show == 'Yes':
                female_noshow += 1
    
    if(g=='M'):
        return [male_noshow,male_count]
    else:
        return [female_noshow,female_count]
    print("전체 남자:", male_count)
    print("노쇼한 남자:", male_noshow)
    print("남성 노쇼 비율:", male_noshow / male_count)

    print()
    
    print("전체 여자:", female_count)
    print("노쇼한 여자:", female_noshow)
    print("여성 노쇼 비율:", female_noshow / female_count)
def analyzeByWaiting(a):
    #대기 일수별 노쇼율

    group_total = {
        "0~6일": 0,
        "7~13일": 0,
        "14~20일": 0,
        "21~27일": 0,
        "28일 이상": 0
    }

    group_noshow = {
        "0~6일": 0,
        "7~13일": 0,
        "14~20일": 0,
        "21~27일": 0,
        "28일 이상": 0
        }

    for p in patient_list:

        scheduled = datetime.strptime(p.ScheduledDay[:10], "%Y-%m-%d")
        appointment = datetime.strptime(p.AppointmentDay[:10], "%Y-%m-%d")

        waiting_days = (appointment - scheduled).days

        if waiting_days < 0:
            continue

        if waiting_days < 7:
            group = "0~6일"
        elif waiting_days < 14:
            group = "7~13일"
        elif waiting_days < 21:
            group = "14~20일"
        elif waiting_days < 28:
            group = "21~27일"
        else:
            group = "28일 이상"

        group_total[group] += 1

        if p.No_show == "Yes":
            group_noshow[group] += 1
        
    if(a==1):
        return [group_noshow["0~6일"],group_total["0~6일"]]
    elif(a==2):
        return [group_noshow["7~13일"],group_total["7~13일"]]
    elif(a==3):
        return [group_noshow["14~20일"],group_total["14~20일"]]
    elif(a==4):
        return [group_noshow["21~27일"],group_total["21~27일"]]
    elif(a==5):
        return [group_noshow["28일 이상"],group_total["28일 이상"]]

def analyzeByAge(a):
    #연령별 노쇼율
    age_total = {
        "0~19세": 0,
        "20~39세": 0,
        "40~59세": 0,
        "60세 이상": 0
        }   

    age_noshow = {
        "0~19세": 0,
        "20~39세": 0,
        "40~59세": 0,
        "60세 이상": 0
        }

    for p in patient_list:

        age = int(p.Age)

        # 음수 나이는 제외
        if age < 0:
            continue

        if age < 20:
            group = "0~19세"
        elif age < 40:
            group = "20~39세"
        elif age < 60:
            group = "40~59세"
        else:
            group = "60세 이상"

        age_total[group] += 1

        if p.No_show == "Yes":
            age_noshow[group] += 1


    if(a==1):
        return [age_noshow["0~19세"],age_total["0~19세"]]
    elif(a==2):
        return [age_noshow["20~39세"],age_total["20~39세"]]
    elif(a==3):
        return [age_noshow["40~59세"],age_total["40~59세"]]
    elif(a==4):
        return [age_noshow["60세 이상"],age_total["60세 이상"]]
    
def run():
    
    with open('medical.csv', 'r', encoding='utf-8') as f:
        lines = f.readlines()
        patient_list = []
           
        for line in lines[1:]:              # [1:] → 첫 줄(헤더)은 건너뜀
            line = line.strip()               # 줄바꿈 문자 제거
            if not line:                    # 빈 줄이면 건너뜀
                continue
            values = line.split(',')        # 쉼표 기준으로 쪼개서 리스트로 만듦
            p = Patient(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8])
            patient_list.append(p)
    while 1:
        menu=print_menu()
        if menu==1:
           g=input('분석할 성별을 입력하세요.(M/F)')
           result=analyzeByGender(g)
           print("전체",g,':',result[1])
           print("노쇼한",g,':',result[0])
           print("노쇼한",g,'비율:',result[0]/result[1])
        elif menu==2:
            a=int(input('분석할 대기일수를 입력하세요.(1: 0~6 2:7~13 3:14~20 4:21~27 5:28+)'))
            result=analyzeByWaiting(a)
            print("전체",a,':',result[1])
            print("노쇼한",a,':',result[0])
            print("노쇼한",a,'비율:',result[0]/result[1])
        elif menu==3:
            a=int(input('분석할 연령대를 입력하세요.(1: 0~19 2:20~39 3:40~59 4:60+)'))
            result = analyzeByAge(a) 
            print("전체",a,':',result[1])
            print("노쇼한",a,':',result[0])
            print("노쇼한",a,'비율:',result[0]/result[1])
        elif menu==4:
            no_showCnt=0
            totalCnt=0
            cross=input('교차 분석 할 표본을 선택하세요.(1: 성별 2: 대기일수 3:연령대)')
            cross_list = cross.split()
            for c in cross_list:
                if c == '1':
                    g=input('분석할 성별을 입력하세요.(M/F)')
                    result=analyzeByGender(g)
                    no_showCnt+=result[0]
                    totalCnt+=result[1]
                elif c == '2':
                    print("대기일수 교차분석 실행")
                    a=int(input('분석할 대기일수를 입력하세요.(1: 0~6 2:7~13 3:14~20 4:21~27 5:28+)'))
                    result=analyzeByWaiting(a)
                    no_showCnt+=result[0]
                    totalCnt+=result[1]
                elif c == '3':
                    print("연령대 교차분석 실행")
                    a=int(input('분석할 연령대를 입력하세요.(1: 0~19 2:20~39 3:40~59 4:60+)'))
                    result = analyzeByAge(a) 
                    no_showCnt+=result[0]
                    totalCnt+=result[1]
            print("전체 표본",':',totalCnt)
            print("노쇼한 표본",':',no_showCnt)
            print("노쇼한비율:",no_showCnt/totalCnt)
                            
        elif menu==5:
            
            break
        else:
            print('잘못된 명령입니다.')
        
if(__name__=='__main__'):
     run()

교차분석을 하기 위해서 각 함수별로 노쇼한@@@, 전체@@@를 담은 리스트를 반환하도록 했는데, 코드를 짜고 보니 사용자가 메뉴를 선택할 때마다 11만개의 데이터를 계속 순회하는 비효율적인 구조가 돼서 아쉬웠다.