import tkinter as tk

# 메인 윈도우 생성
root = tk.Tk()
root.title("나의 첫 번째 프로그램")
root.geometry("400x300")  # 너비x높이

# 윈도우 실행
root.mainloop()

import tkinter as tk

def button_click():
    label.config(text="버튼이 클릭되었습니다! 🎉")

root = tk.Tk()
root.title("위젯 예제")
root.geometry("400x300")

# 라벨 추가
label = tk.Label(root, text="안녕하세요!", font=("Arial", 16))
label.pack(pady=20)

# 버튼 추가
button = tk.Button(root, text="클릭하세요", command=button_click, 
                   bg="#667eea", fg="white", font=("Arial", 12))
button.pack(pady=10)

# 입력창 추가
entry = tk.Entry(root, font=("Arial", 12))
entry.pack(pady=10)

root.mainloop()

import tkinter as tk
from tkinter import filedialog, messagebox

class SimpleMemoApp:
    def __init__(self, root):
        self.root = root
        self.root.title("심플 메모장 📝")
        self.root.geometry("600x400")
        
        # 메뉴바 생성
        menubar = tk.Menu(root)
        root.config(menu=menubar)
        
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="파일", menu=file_menu)
        file_menu.add_command(label="새 파일", command=self.new_file)
        file_menu.add_command(label="열기", command=self.open_file)
        file_menu.add_command(label="저장", command=self.save_file)
        file_menu.add_separator()
        file_menu.add_command(label="종료", command=root.quit)
        
        # 텍스트 영역
        self.text_area = tk.Text(root, font=("맑은 고딕", 11), 
                                 wrap=tk.WORD, undo=True)
        self.text_area.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # 스크롤바
        scrollbar = tk.Scrollbar(self.text_area)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.text_area.config(yscrollcommand=scrollbar.set)
        scrollbar.config(command=self.text_area.yview)
        
        # 상태바
        self.status_bar = tk.Label(root, text="준비", 
                                   bd=1, relief=tk.SUNKEN, anchor=tk.W)
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
        self.current_file = None
    
    def new_file(self):
        self.text_area.delete(1.0, tk.END)
        self.current_file = None
        self.status_bar.config(text="새 파일")
    
    def open_file(self):
        file_path = filedialog.askopenfilename(
            defaultextension=".txt",
            filetypes=[("텍스트 파일", "*.txt"), ("모든 파일", "*.*")]
        )
        if file_path:
            try:
                with open(file_path, 'r', encoding='utf-8') as file:
                    content = file.read()
                    self.text_area.delete(1.0, tk.END)
                    self.text_area.insert(1.0, content)
                    self.current_file = file_path
                    self.status_bar.config(text=f"열림: {file_path}")
            except Exception as e:
                messagebox.showerror("오류", f"파일을 열 수 없습니다: {str(e)}")
    
    def save_file(self):
        if self.current_file:
            file_path = self.current_file
        else:
            file_path = filedialog.asksaveasfilename(
                defaultextension=".txt",
                filetypes=[("텍스트 파일", "*.txt"), ("모든 파일", "*.*")]
            )
        
        if file_path:
            try:
                content = self.text_area.get(1.0, tk.END)
                with open(file_path, 'w', encoding='utf-8') as file:
                    file.write(content)
                    self.current_file = file_path
                    self.status_bar.config(text=f"저장됨: {file_path}")
                    messagebox.showinfo("성공", "파일이 저장되었습니다!")
            except Exception as e:
                messagebox.showerror("오류", f"파일을 저장할 수 없습니다: {str(e)}")

# 프로그램 실행
if __name__ == "__main__":
    root = tk.Tk()
    app = SimpleMemoApp(root)
    root.mainloop()

pip install PyQt5
pip install PyQt5-tools  # Qt Designer 등 추가 도구

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QVBoxLayout, QWidget
from PyQt5.QtCore import Qt

class MyFirstApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    
    def initUI(self):
        # 윈도우 설정
        self.setWindowTitle('PyQt 첫 프로그램')
        self.setGeometry(100, 100, 400, 300)
        
        # 중앙 위젯 설정
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 레이아웃 생성
        layout = QVBoxLayout()
        
        # 라벨 추가
        label = QLabel('PyQt로 만든 프로그램입니다! 🎉')
        label.setAlignment(Qt.AlignCenter)
        label.setStyleSheet("font-size: 16px; color: #667eea;")
        layout.addWidget(label)
        
        # 버튼 추가
        button = QPushButton('클릭하세요')
        button.setStyleSheet("""
            QPushButton {
                background-color: #667eea;
                color: white;
                border: none;
                padding: 10px;
                font-size: 14px;
                border-radius: 5px;
            }
            QPushButton:hover {
                background-color: #764ba2;
            }
        """)
        button.clicked.connect(self.on_button_click)
        layout.addWidget(button)
        
        central_widget.setLayout(layout)
    
    def on_button_click(self):
        print("버튼이 클릭되었습니다!")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MyFirstApp()
    window.show()
    sys.exit(app.exec_())

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QLabel, QPushButton, 
                             QVBoxLayout, QHBoxLayout, QWidget, QFileDialog, QSlider)
from PyQt5.QtGui import QPixmap, QTransform
from PyQt5.QtCore import Qt

class ImageViewer(QMainWindow):
    def __init__(self):
        super().__init__()
        self.current_image = None
        self.rotation_angle = 0
        self.scale_factor = 1.0
        self.initUI()
    
    def initUI(self):
        self.setWindowTitle('이미지 뷰어 📷')
        self.setGeometry(100, 100, 800, 600)
        
        # 중앙 위젯
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 메인 레이아웃
        main_layout = QVBoxLayout()
        
        # 이미지 표시 라벨
        self.image_label = QLabel('이미지를 불러오세요')
        self.image_label.setAlignment(Qt.AlignCenter)
        self.image_label.setStyleSheet("""
            QLabel {
                background-color: #f5f5f5;
                border: 2px dashed #667eea;
                border-radius: 10px;
                min-height: 400px;
            }
        """)
        main_layout.addWidget(self.image_label)
        
        # 컨트롤 버튼 레이아웃
        control_layout = QHBoxLayout()
        
        # 파일 열기 버튼
        open_btn = QPushButton('📁 이미지 열기')
        open_btn.setStyleSheet(self.get_button_style('#667eea'))
        open_btn.clicked.connect(self.open_image)
        control_layout.addWidget(open_btn)
        
        # 회전 버튼들
        rotate_left_btn = QPushButton('↶ 왼쪽 회전')
        rotate_left_btn.setStyleSheet(self.get_button_style('#42a5f5'))
        rotate_left_btn.clicked.connect(lambda: self.rotate_image(-90))
        control_layout.addWidget(rotate_left_btn)
        
        rotate_right_btn = QPushButton('↷ 오른쪽 회전')
        rotate_right_btn.setStyleSheet(self.get_button_style('#42a5f5'))
        rotate_right_btn.clicked.connect(lambda: self.rotate_image(90))
        control_layout.addWidget(rotate_right_btn)
        
        # 초기화 버튼
        reset_btn = QPushButton('🔄 초기화')
        reset_btn.setStyleSheet(self.get_button_style('#ff9800'))
        reset_btn.clicked.connect(self.reset_image)
        control_layout.addWidget(reset_btn)
        
        main_layout.addLayout(control_layout)
        
        # 확대/축소 슬라이더
        slider_layout = QHBoxLayout()
        slider_label = QLabel('확대/축소:')
        slider_layout.addWidget(slider_label)
        
        self.zoom_slider = QSlider(Qt.Horizontal)
        self.zoom_slider.setMinimum(10)
        self.zoom_slider.setMaximum(200)
        self.zoom_slider.setValue(100)
        self.zoom_slider.setTickPosition(QSlider.TicksBelow)
        self.zoom_slider.setTickInterval(10)
        self.zoom_slider.valueChanged.connect(self.zoom_image)
        slider_layout.addWidget(self.zoom_slider)
        
        self.zoom_label = QLabel('100%')
        slider_layout.addWidget(self.zoom_label)
        
        main_layout.addLayout(slider_layout)
        
        central_widget.setLayout(main_layout)
    
    def get_button_style(self, color):
        return f"""
            QPushButton {{
                background-color: {color};
                color: white;
                border: none;
                padding: 10px 20px;
                font-size: 14px;
                border-radius: 5px;
                font-weight: bold;
            }}
            QPushButton:hover {{
                background-color: {color}dd;
            }}
            QPushButton:pressed {{
                background-color: {color}aa;
            }}
        """
    
    def open_image(self):
        file_path, _ = QFileDialog.getOpenFileName(
            self, '이미지 선택', '',
            'Images (*.png *.jpg *.jpeg *.bmp *.gif)'
        )
        
        if file_path:
            self.current_image = QPixmap(file_path)
            self.rotation_angle = 0
            self.scale_factor = 1.0
            self.zoom_slider.setValue(100)
            self.display_image()
    
    def rotate_image(self, angle):
        if self.current_image:
            self.rotation_angle += angle
            self.display_image()
    
    def zoom_image(self, value):
        if self.current_image:
            self.scale_factor = value / 100.0
            self.zoom_label.setText(f'{value}%')
            self.display_image()
    
    def reset_image(self):
        if self.current_image:
            self.rotation_angle = 0
            self.scale_factor = 1.0
            self.zoom_slider.setValue(100)
            self.display_image()
    
    def display_image(self):
        if self.current_image:
            # 변환 적용
            transform = QTransform()
            transform.rotate(self.rotation_angle)
            transform.scale(self.scale_factor, self.scale_factor)
            
            transformed_image = self.current_image.transformed(transform, Qt.SmoothTransformation)
            
            # 라벨 크기에 맞게 조정
            scaled_image = transformed_image.scaled(
                self.image_label.size(),
                Qt.KeepAspectRatio,
                Qt.SmoothTransformation
            )
            
            self.image_label.setPixmap(scaled_image)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    viewer = ImageViewer()
    viewer.show()
    sys.exit(app.exec_())

from PyQt5.QtWidgets import QVBoxLayout, QHBoxLayout, QGridLayout

# 수직 레이아웃
v_layout = QVBoxLayout()
v_layout.addWidget(label1)
v_layout.addWidget(label2)

# 수평 레이아웃
h_layout = QHBoxLayout()
h_layout.addWidget(button1)
h_layout.addWidget(button2)

# 격자 레이아웃
grid_layout = QGridLayout()
grid_layout.addWidget(label, 0, 0)
grid_layout.addWidget(entry, 0, 1)
grid_layout.addWidget(button, 1, 0, 1, 2)  # 2열 병합

# 레이아웃 중첩
main_layout = QVBoxLayout()
main_layout.addLayout(h_layout)
main_layout.addLayout(grid_layout)

import tkinter as tk

def on_key_press(event):
    print(f"키 입력: {event.char}")

def on_mouse_click(event):
    print(f"마우스 클릭: ({event.x}, {event.y})")

def on_mouse_motion(event):
    label.config(text=f"마우스 위치: ({event.x}, {event.y})")

root = tk.Tk()
root.geometry("400x300")

label = tk.Label(root, text="이벤트를 기다리는 중...")
label.pack(pady=20)

# 키보드 이벤트
root.bind('<Key>', on_key_press)
root.bind('<Return>', lambda e: print("엔터 키!"))

# 마우스 이벤트
root.bind('<Button-1>', on_mouse_click)  # 왼쪽 클릭
root.bind('<Motion>', on_mouse_motion)   # 마우스 이동

root.mainloop()

from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget
from PyQt5.QtCore import pyqtSignal, QObject

class CustomSignal(QObject):
    # 커스텀 시그널 정의
    message_sent = pyqtSignal(str)

class SignalSlotDemo(QMainWindow):
    def __init__(self):
        super().__init__()
        self.custom_signal = CustomSignal()
        self.initUI()
    
    def initUI(self):
        self.setWindowTitle('Signal & Slot 예제')
        self.setGeometry(100, 100, 400, 300)
        
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QVBoxLayout()
        
        self.label = QLabel('버튼을 클릭하세요')
        layout.addWidget(self.label)
        
        # 기본 시그널 연결
        button1 = QPushButton('기본 클릭')
        button1.clicked.connect(self.on_button_clicked)
        layout.addWidget(button1)
        
        # 람다 함수로 인자 전달
        button2 = QPushButton('인자와 함께')
        button2.clicked.connect(lambda: self.show_message("안녕하세요!"))
        layout.addWidget(button2)
        
        # 커스텀 시그널 연결
        button3 = QPushButton('커스텀 시그널')
        button3.clicked.connect(lambda: self.custom_signal.message_sent.emit("커스텀 메시지"))
        self.custom_signal.message_sent.connect(self.on_custom_signal)
        layout.addWidget(button3)
        
        central_widget.setLayout(layout)
    
    def on_button_clicked(self):
        self.label.setText('버튼이 클릭되었습니다!')
    
    def show_message(self, message):
        self.label.setText(message)
    
    def on_custom_signal(self, message):
        self.label.setText(f'커스텀 시그널 수신: {message}')

if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)
    demo = SignalSlotDemo()
    demo.show()
    sys.exit(app.exec_())

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("스타일링 예제")
root.geometry("400x300")
root.configure(bg='#f0f0f0')

# 기본 위젯 스타일링
label = tk.Label(
    root,
    text="스타일이 적용된 라벨",
    font=("Arial", 16, "bold"),
    fg="#667eea",
    bg="#f0f0f0",
    padx=20,
    pady=10
)
label.pack(pady=20)

# 버튼 스타일링
button = tk.Button(
    root,
    text="멋진 버튼",
    font=("Arial", 12),
    fg="white",
    bg="#667eea",
    activebackground="#764ba2",
    activeforeground="white",
    relief=tk.FLAT,
    padx=30,
    pady=10,
    cursor="hand2"
)
button.pack(pady=10)

# ttk 위젯으로 더 나은 스타일
style = ttk.Style()
style.theme_use('clam')  # 테마 선택: 'clam', 'alt', 'default', 'classic'

style.configure(
    'Custom.TButton',
    font=('Arial', 12),
    borderwidth=0,
    focuscolor='none'
)

style.map(
    'Custom.TButton',
    background=[('active', '#764ba2'), ('!active', '#667eea')],
    foreground=[('active', 'white'), ('!active', 'white')]
)

ttk_button = ttk.Button(root, text="TTK 버튼", style='Custom.TButton')
ttk_button.pack(pady=10)

root.mainloop()

from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget

class StyledApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    
    def initUI(self):
        self.setWindowTitle('PyQt 스타일링')
        self.setGeometry(100, 100, 500, 400)
        
        # 전역 스타일시트 적용
        self.setStyleSheet("""
            QMainWindow {
                background-color: #f5f5f5;
            }
            QLabel {
                color: #333;
                font-size: 16px;
                padding: 10px;
            }
            QLabel#title {
                color: #667eea;
                font-size: 24px;
                font-weight: bold;
            }
        """)
        
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QVBoxLayout()
        
        # ID 선택자 사용
        title = QLabel('스타일이 적용된 제목')
        title.setObjectName('title')
        layout.addWidget(title)
        
        # 개별 스타일 적용
        button1 = QPushButton('그라디언트 버튼')
        button1.setStyleSheet("""
            QPushButton {
                background: qlineargradient(
                    x1:0, y1:0, x2:1, y2:1,
                    stop:0 #667eea, stop:1 #764ba2
                );
                color: white;
                border: none;
                border-radius: 10px;
                padding: 15px 30px;
                font-size: 14px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(
                    x1:0, y1:0, x2:1, y2:1,
                    stop:0 #764ba2, stop:1 #667eea
                );
            }
            QPushButton:pressed {
                padding: 16px 29px 14px 31px;
            }
        """)
        layout.addWidget(button1)
        
        button2 = QPushButton('그림자 효과 버튼')
        button2.setStyleSheet("""
            QPushButton {
                background-color: white;
                color: #667eea;
                border: 2px solid #667eea;
                border-radius: 8px;
                padding: 12px 25px;
                font-size: 14px;
            }
            QPushButton:hover {
                background-color: #667eea;
                color: white;
            }
        """)
        layout.addWidget(button2)
        
        central_widget.setLayout(layout)

if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)
    window = StyledApp()
    window.show()
    sys.exit(app.exec_())

import sys
import json
from datetime import datetime
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
                             QHBoxLayout, QLineEdit, QPushButton, QListWidget, 
                             QListWidgetItem, QLabel, QMessageBox, QCheckBox)
from PyQt5.QtCore import Qt

class TodoApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.todos = []
        self.load_todos()
        self.initUI()
    
    def initUI(self):
        self.setWindowTitle('할 일 관리 📝')
        self.setGeometry(100, 100, 600, 500)
        
        # 전역 스타일
        self.setStyleSheet("""
            QMainWindow {
                background-color: #f8f9fa;
            }
            QLineEdit {
                padding: 12px;
                border: 2px solid #e0e0e0;
                border-radius: 8px;
                font-size: 14px;
                background-color: white;
            }
            QLineEdit:focus {
                border-color: #667eea;
            }
            QListWidget {
                border: 2px solid #e0e0e0;
                border-radius: 8px;
                background-color: white;
                padding: 5px;
            }
            QListWidget::item {
                padding: 10px;
                border-bottom: 1px solid #f0f0f0;
            }
            QListWidget::item:selected {
                background-color: #e3f2fd;
                color: #1976d2;
            }
        """)
        
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        main_layout = QVBoxLayout()
        
        # 헤더
        header = QLabel('📋 나의 할 일 목록')
        header.setStyleSheet("""
            font-size: 24px;
            font-weight: bold;
            color: #667eea;
            padding: 20px;
        """)
        header.setAlignment(Qt.AlignCenter)
        main_layout.addWidget(header)
        
        # 입력 영역
        input_layout = QHBoxLayout()
        
        self.todo_input = QLineEdit()
        self.todo_input.setPlaceholderText('할 일을 입력하세요...')
        self.todo_input.returnPressed.connect(self.add_todo)
        input_layout.addWidget(self.todo_input)
        
        add_btn = QPushButton('➕ 추가')
        add_btn.setStyleSheet(self.get_button_style('#667eea'))
        add_btn.clicked.connect(self.add_todo)
        input_layout.addWidget(add_btn)
        
        main_layout.addLayout(input_layout)
        
        # 할 일 목록
        self.todo_list = QListWidget()
        self.todo_list.itemDoubleClicked.connect(self.toggle_todo)
        main_layout.addWidget(self.todo_list)
        
        # 버튼 영역
        button_layout = QHBoxLayout()
        
        complete_btn = QPushButton('✅ 완료 표시')
        complete_btn.setStyleSheet(self.get_button_style('#4caf50'))
        complete_btn.clicked.connect(self.toggle_selected_todo)
        button_layout.addWidget(complete_btn)
        
        delete_btn = QPushButton('🗑️ 삭제')
        delete_btn.setStyleSheet(self.get_button_style('#f44336'))
        delete_btn.clicked.connect(self.delete_todo)
        button_layout.addWidget(delete_btn)
        
        clear_btn = QPushButton('🧹 완료된 항목 정리')
        clear_btn.setStyleSheet(self.get_button_style('#ff9800'))
        clear_btn.clicked.connect(self.clear_completed)
        button_layout.addWidget(clear_btn)
        
        main_layout.addLayout(button_layout)
        
        # 통계 라벨
        self.stats_label = QLabel()
        self.stats_label.setStyleSheet("""
            font-size: 12px;
            color: #666;
            padding: 10px;
        """)
        self.stats_label.setAlignment(Qt.AlignCenter)
        main_layout.addWidget(self.stats_label)
        
        central_widget.setLayout(main_layout)
        
        self.update_list()
        self.update_stats()
    
    def get_button_style(self, color):
        return f"""
            QPushButton {{
                background-color: {color};
                color: white;
                border: none;
                padding: 10px 15px;
                font-size: 13px;
                border-radius: 6px;
                font-weight: bold;
            }}
            QPushButton:hover {{
                background-color: {color}dd;
            }}
            QPushButton:pressed {{
                background-color: {color}aa;
            }}
        """
    
    def add_todo(self):
        text = self.todo_input.text().strip()
        if text:
            todo = {
                'text': text,
                'completed': False,
                'created': datetime.now().strftime('%Y-%m-%d %H:%M')
            }
            self.todos.append(todo)
            self.todo_input.clear()
            self.update_list()
            self.update_stats()
            self.save_todos()
    
    def update_list(self):
        self.todo_list.clear()
        for i, todo in enumerate(self.todos):
            item_text = f"{'✅' if todo['completed'] else '⭕'} {todo['text']}"
            if todo['completed']:
                item_text = f"<s>{item_text}</s>"
            
            item = QListWidgetItem(item_text)
            if todo['completed']:
                item.setForeground(Qt.gray)
            self.todo_list.addItem(item)
    
    def toggle_todo(self, item):
        index = self.todo_list.row(item)
        self.todos[index]['completed'] = not self.todos[index]['completed']
        self.update_list()
        self.update_stats()
        self.save_todos()
    
    def toggle_selected_todo(self):
        current_row = self.todo_list.currentRow()
        if current_row >= 0:
            self.todos[current_row]['completed'] = not self.todos[current_row]['completed']
            self.update_list()
            self.update_stats()
            self.save_todos()
    
    def delete_todo(self):
        current_row = self.todo_list.currentRow()
        if current_row >= 0:
            reply = QMessageBox.question(
                self, '확인',
                '선택한 항목을 삭제하시겠습니까?',
                QMessageBox.Yes | QMessageBox.No
            )
            if reply == QMessageBox.Yes:
                del self.todos[current_row]
                self.update_list()
                self.update_stats()
                self.save_todos()
    
    def clear_completed(self):
        completed_count = sum(1 for todo in self.todos if todo['completed'])
        if completed_count > 0:
            reply = QMessageBox.question(
                self, '확인',
                f'완료된 {completed_count}개 항목을 삭제하시겠습니까?',
                QMessageBox.Yes | QMessageBox.No
            )
            if reply == QMessageBox.Yes:
                self.todos = [todo for todo in self.todos if not todo['completed']]
                self.update_list()
                self.update_stats()
                self.save_todos()
    
    def update_stats(self):
        total = len(self.todos)
        completed = sum(1 for todo in self.todos if todo['completed'])
        remaining = total - completed
        
        self.stats_label.setText(
            f'전체: {total} | 완료: {completed} | 남은 항목: {remaining}'
        )
    
    def save_todos(self):
        try:
            with open('todos.json', 'w', encoding='utf-8') as f:
                json.dump(self.todos, f, ensure_ascii=False, indent=2)
        except Exception as e:
            print(f"저장 오류: {e}")
    
    def load_todos(self):
        try:
            with open('todos.json', 'r', encoding='utf-8') as f:
                self.todos = json.load(f)
        except FileNotFoundError:
            self.todos = []
        except Exception as e:
            print(f"불러오기 오류: {e}")
            self.todos = []

if __name__ == '__main__':
    app = QApplication(sys.argv)
    todo_app = TodoApp()
    todo_app.show()
    sys.exit(app.exec_())

# Tkinter 다이얼로그
from tkinter import messagebox, filedialog, simpledialog, colorchooser

# 메시지 박스
messagebox.showinfo("정보", "작업이 완료되었습니다!")
messagebox.showwarning("경고", "주의가 필요합니다.")
messagebox.showerror("오류", "문제가 발생했습니다.")

result = messagebox.askyesno("확인", "계속하시겠습니까?")
result = messagebox.askokcancel("확인", "변경사항을 저장하시겠습니까?")

# 파일 대화상자
file_path = filedialog.askopenfilename(title="파일 선택")
save_path = filedialog.asksaveasfilename(title="저장 위치")
folder_path = filedialog.askdirectory(title="폴더 선택")

# 입력 대화상자
name = simpledialog.askstring("입력", "이름을 입력하세요:")
age = simpledialog.askinteger("입력", "나이를 입력하세요:")

# 색상 선택
color = colorchooser.askcolor(title="색상 선택")

# PyQt 다이얼로그
from PyQt5.QtWidgets import QMessageBox, QFileDialog, QInputDialog, QColorDialog

# 메시지 박스
QMessageBox.information(self, "정보", "작업이 완료되었습니다!")
QMessageBox.warning(self, "경고", "주의가 필요합니다.")
QMessageBox.critical(self, "오류", "문제가 발생했습니다.")

reply = QMessageBox.question(self, "확인", "계속하시겠습니까?",
                             QMessageBox.Yes | QMessageBox.No)

# 파일 대화상자
file_path, _ = QFileDialog.getOpenFileName(self, "파일 선택")
save_path, _ = QFileDialog.getSaveFileName(self, "저장 위치")
folder_path = QFileDialog.getExistingDirectory(self, "폴더 선택")

# 입력 대화상자
name, ok = QInputDialog.getText(self, "입력", "이름을 입력하세요:")
age, ok = QInputDialog.getInt(self, "입력", "나이를 입력하세요:")
items = ["옵션1", "옵션2", "옵션3"]
item, ok = QInputDialog.getItem(self, "선택", "항목을 선택하세요:", items)

# 색상 선택
color = QColorDialog.getColor()

# PyQt 테이블 예제
from PyQt5.QtWidgets import QTableWidget, QTableWidgetItem

class TableExample(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
    
    def initUI(self):
        self.setWindowTitle('테이블 예제')
        self.setGeometry(100, 100, 600, 400)
        
        # 테이블 생성
        table = QTableWidget()
        table.setRowCount(5)
        table.setColumnCount(3)
        table.setHorizontalHeaderLabels(['이름', '나이', '직업'])
        
        # 데이터 입력
        data = [
            ['홍길동', '25', '개발자'],
            ['김철수', '30', '디자이너'],
            ['이영희', '28', '기획자'],
            ['박민수', '35', '매니저'],
            ['정수진', '27', '마케터']
        ]
        
        for row, person in enumerate(data):
            for col, value in enumerate(person):
                table.setItem(row, col, QTableWidgetItem(value))
        
        # 스타일링
        table.setStyleSheet("""
            QTableWidget {
                gridline-color: #e0e0e0;
                background-color: white;
            }
            QHeaderView::section {
                background-color: #667eea;
                color: white;
                padding: 8px;
                font-weight: bold;
            }
        """)
        
        # 열 너비 자동 조정
        table.resizeColumnsToContents()
        
        self.setCentralWidget(table)

# Tkinter 캔버스
import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(root, width=400, height=300, bg='white')
canvas.pack()

# 도형 그리기
canvas.create_line(0, 0, 400, 300, fill='blue', width=2)
canvas.create_rectangle(50, 50, 150, 150, fill='red', outline='black')
canvas.create_oval(200, 50, 350, 200, fill='green')
canvas.create_polygon(200, 250, 300, 280, 250, 200, fill='yellow')

# 텍스트
canvas.create_text(200, 150, text='캔버스 예제', font=('Arial', 20))

root.mainloop()

# PyQt 그래픽
from PyQt5.QtWidgets import QWidget
from PyQt5.QtGui import QPainter, QColor, QPen
from PyQt5.QtCore import Qt

class DrawingWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.setMinimumSize(400, 300)
    
    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        
        # 배경
        painter.fillRect(self.rect(), QColor(255, 255, 255))
        
        # 선 그리기
        pen = QPen(QColor(0, 0, 255), 2)
        painter.setPen(pen)
        painter.drawLine(0, 0, 400, 300)
        
        # 사각형
        painter.setBrush(QColor(255, 0, 0))
        painter.drawRect(50, 50, 100, 100)
        
        # 원
        painter.setBrush(QColor(0, 255, 0))
        painter.drawEllipse(200, 50, 150, 150)
        
        # 텍스트
        painter.setPen(QColor(0, 0, 0))
        painter.setFont(QFont('Arial', 20))
        painter.drawText(self.rect(), Qt.AlignCenter, '그래픽 예제')

# PyInstaller 설치
pip install pyinstaller

# 기본 실행 파일 생성
pyinstaller your_program.py

# 단일 파일로 생성 (권장)
pyinstaller --onefile your_program.py

# 콘솔 창 숨기기 (GUI 프로그램용)
pyinstaller --onefile --noconsole your_program.py

# 아이콘 지정
pyinstaller --onefile --noconsole --icon=icon.ico your_program.py

# 이름 지정
pyinstaller --onefile --noconsole --name="MyApp" your_program.py

# cx_Freeze 설치
pip install cx_Freeze

# setup.py 파일 생성
from cx_Freeze import setup, Executable

setup(
    name="MyApp",
    version="1.0",
    description="나의 멋진 프로그램",
    executables=[Executable("your_program.py", base="Win32GUI")]
)

# 빌드 실행
python setup.py build