[Python 100일 챌린지] Day 71 - 데이터베이스와 SQL 소개
[Python 100일 챌린지] Day 71 - 데이터베이스와 SQL 소개
데이터를 체계적으로 관리하는 방법을 배워봐요! 🗄️
지금까지는 파일이나 변수에 데이터를 저장했지만, 데이터가 많아지면 어떻게 해야 할까요? 바로 데이터베이스가 필요해요! 은행의 고객 정보, 인스타그램의 사진들, 유튜브의 동영상들… 모두 데이터베이스에 저장되어 있답니다. 오늘부터는 데이터베이스와 SQL의 세계로 들어가봐요! 😊
(30분 완독 ⭐⭐⭐)
🎯 오늘의 학습 목표
📚 사전 지식
- Day 45: 파일 읽기와 쓰기 - 파일 입출력 기초
- Day 68: collections 모듈 - 데이터 구조 이해
🎯 학습 목표 1: 데이터베이스가 무엇인지 이해하기
한 줄 설명
데이터베이스 = 체계적으로 정리된 데이터 창고 🏢📊
데이터베이스는 데이터를 효율적으로 저장, 검색, 수정, 삭제할 수 있게 해주는 시스템이에요!
1.1 데이터베이스가 뭐예요?
데이터베이스(Database)는 관련된 데이터들을 체계적으로 모아놓은 곳이에요.
💡 실생활 비유: 도서관을 생각해보세요!
- 책들이 무작위로 쌓여있으면 찾기 힘들죠?
- 하지만 분류 번호, 저자, 제목으로 정리되어 있으면 쉽게 찾을 수 있어요!
- 데이터베이스도 마찬가지로 데이터를 체계적으로 정리해둔 거예요!
1.2 왜 데이터베이스가 필요할까요?
1
2
3
4
5
6
7
8
9
10
11
12
# 데이터베이스 없이 저장한다면?
users = [
{"id": 1, "name": "김철수", "age": 25},
{"id": 2, "name": "이영희", "age": 30},
{"id": 3, "name": "박민수", "age": 28}
]
# 문제점들:
# 1. 프로그램 종료하면 데이터가 사라져요
# 2. 특정 사용자 찾으려면 전체를 뒤져야 해요
# 3. 데이터가 많아지면 메모리 부족해요
# 4. 여러 프로그램에서 동시에 접근하기 어려워요
데이터베이스를 쓰면 이런 문제들이 해결돼요! ✨
1.3 데이터베이스의 장점
graph TD
A[데이터베이스 장점] --> B[영구 저장]
A --> C[빠른 검색]
A --> D[대용량 처리]
A --> E[동시 접근]
A --> F[데이터 무결성]
B --> B1[컴퓨터 꺼도 데이터 유지]
C --> C1[인덱스로 빠르게 찾기]
D --> D1[수백만 개 데이터 처리]
E --> E1[여러 사용자가 동시에]
F --> F1[데이터 일관성 보장]
1.4 실제 사용 예시
우리 주변의 데이터베이스들:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 예시 1: 쇼핑몰
쇼핑몰_데이터베이스 = {
"상품": ["상품명", "가격", "재고", "카테고리"],
"회원": ["아이디", "비밀번호", "이메일", "주소"],
"주문": ["주문번호", "회원ID", "상품ID", "수량", "날짜"]
}
# 예시 2: 학교
학교_데이터베이스 = {
"학생": ["학번", "이름", "학년", "전공"],
"과목": ["과목코드", "과목명", "학점"],
"수강신청": ["학번", "과목코드", "성적"]
}
# 예시 3: 병원
병원_데이터베이스 = {
"환자": ["환자번호", "이름", "생년월일", "연락처"],
"의사": ["의사번호", "이름", "전문분야"],
"진료기록": ["진료번호", "환자번호", "의사번호", "진단", "날짜"]
}
이 모든 시스템이 데이터베이스를 사용해요! 🏥🏫🛒
🎯 학습 목표 2: 파일 저장 vs 데이터베이스 저장 비교하기
한 줄 설명
파일 저장 = 수동 정리, 데이터베이스 = 자동 정리 📁 vs 🗄️
같은 데이터를 저장하더라도 방식에 따라 효율성이 천차만별이에요!
2.1 파일로 저장하기 (기존 방식)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 파일에 사용자 정보 저장
import json
users = [
{"id": 1, "name": "김철수", "email": "[email protected]"},
{"id": 2, "name": "이영희", "email": "[email protected]"},
{"id": 3, "name": "박민수", "email": "[email protected]"}
]
# 저장
with open("users.json", "w", encoding="utf-8") as f:
json.dump(users, f, ensure_ascii=False)
# 특정 사용자 찾기
with open("users.json", "r", encoding="utf-8") as f:
users = json.load(f)
for user in users:
if user["id"] == 2:
print(f"찾음: {user['name']}")
break
문제점:
- 전체 파일을 읽어야 해요 (데이터 1000만 개면?)
- 동시에 여러 프로그램이 수정하면 충돌해요
- 검색 속도가 느려요
2.2 데이터베이스로 저장하기 (개선된 방식)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# SQLite 데이터베이스에 저장 (다음 시간에 자세히!)
import sqlite3
# 데이터베이스 연결
conn = sqlite3.connect("users.db")
cursor = conn.cursor()
# 테이블 생성
cursor.execute("""
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
email TEXT NOT NULL
)
""")
# 데이터 저장
cursor.execute("INSERT INTO users VALUES (1, '김철수', '[email protected]')")
cursor.execute("INSERT INTO users VALUES (2, '이영희', '[email protected]')")
cursor.execute("INSERT INTO users VALUES (3, '박민수', '[email protected]')")
conn.commit()
# 특정 사용자 찾기 (엄청 빠름!)
cursor.execute("SELECT * FROM users WHERE id = 2")
user = cursor.fetchone()
print(f"찾음: {user[1]}") # 이영희
conn.close()
장점:
- 필요한 데이터만 빠르게 가져와요
- 동시 접근 문제 자동 해결
- 인덱스로 검색 속도 향상
2.3 성능 비교
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import time
import json
import sqlite3
# 테스트 데이터 (10,000명)
test_users = [{"id": i, "name": f"사용자{i}", "email": f"user{i}@example.com"}
for i in range(1, 10001)]
# 1. 파일 검색 (JSON)
with open("test_users.json", "w", encoding="utf-8") as f:
json.dump(test_users, f)
start = time.time()
with open("test_users.json", "r", encoding="utf-8") as f:
users = json.load(f)
target = [u for u in users if u["id"] == 9999][0]
file_time = time.time() - start
# 2. 데이터베이스 검색 (SQLite)
conn = sqlite3.connect("test_users.db")
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)")
cursor.executemany("INSERT OR REPLACE INTO users VALUES (?, ?, ?)",
[(u["id"], u["name"], u["email"]) for u in test_users])
conn.commit()
start = time.time()
cursor.execute("SELECT * FROM users WHERE id = 9999")
target = cursor.fetchone()
db_time = time.time() - start
print(f"📁 파일 검색: {file_time:.5f}초")
print(f"🗄️ DB 검색: {db_time:.5f}초")
print(f"⚡ 데이터베이스가 {file_time/db_time:.1f}배 빠름!")
conn.close()
출력 예시:
1
2
3
📁 파일 검색: 0.01234초
🗄️ DB 검색: 0.00012초
⚡ 데이터베이스가 102배 빠름!
💡 핵심: 데이터가 많을수록 데이터베이스의 장점이 더 커져요!
🎯 학습 목표 3: 관계형 데이터베이스의 개념 알기
한 줄 설명
관계형 데이터베이스 = 엑셀처럼 표 형태로 저장 📊
데이터를 표(Table) 형태로 저장하고, 표들끼리 관계를 맺어요!
3.1 테이블, 행, 열 개념
graph TD
A[관계형 데이터베이스] --> B[테이블/Table]
B --> C[행/Row/Record]
B --> D[열/Column/Field]
C --> C1[한 명의 데이터]
D --> D1[데이터의 속성]
예시: 학생 테이블
1
2
3
4
5
6
7
8
9
┌──────────────────────────────────────────┐
│ students (테이블) │
├──────┬──────────┬─────────┬───────────────┤
│ id │ name │ age │ major │ ← 열(Column)
├──────┼──────────┼─────────┼───────────────┤
│ 1 │ 김철수 │ 20 │ 컴퓨터공학 │ ← 행(Row)
│ 2 │ 이영희 │ 22 │ 경영학 │
│ 3 │ 박민수 │ 21 │ 전자공학 │
└──────┴──────────┴─────────┴───────────────┘
3.2 관계(Relationship)의 이해
여러 테이블이 서로 연결될 수 있어요!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 예시: 도서관 시스템
"""
┌─────────────────┐ ┌─────────────────┐
│ students │ │ books │
├─────────────────┤ ├─────────────────┤
│ id (PK) │ │ id (PK) │
│ name │ │ title │
│ email │ │ author │
└─────────────────┘ └─────────────────┘
│ │
│ │
└────────┬───────────────────┘
│
┌────────▼──────────┐
│ borrow_records │
├───────────────────┤
│ id (PK) │
│ student_id (FK) │ ← Foreign Key (외래키)
│ book_id (FK) │
│ borrow_date │
│ return_date │
└───────────────────┘
"""
# Python으로 표현하면:
students = [
{"id": 1, "name": "김철수"},
{"id": 2, "name": "이영희"}
]
books = [
{"id": 1, "title": "파이썬 기초"},
{"id": 2, "title": "데이터베이스 입문"}
]
borrow_records = [
{"id": 1, "student_id": 1, "book_id": 1, "borrow_date": "2025-05-10"},
{"id": 2, "student_id": 2, "book_id": 2, "borrow_date": "2025-05-09"}
]
# "김철수가 어떤 책을 빌렸나?" 같은 질문에 답할 수 있어요!
3.3 기본 키(Primary Key)와 외래 키(Foreign Key)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
"""
기본 키 (Primary Key, PK)
- 각 행을 유일하게 식별하는 열
- 중복될 수 없어요
- 예: 학번, 주민번호, 상품코드
외래 키 (Foreign Key, FK)
- 다른 테이블의 기본 키를 참조하는 열
- 테이블 간의 관계를 표현해요
- 예: 주문 테이블의 회원ID
"""
# 예시: 온라인 쇼핑몰
users_table = """
┌──────────────────────────────┐
│ users │
├──────┬───────────┬───────────┤
│ id │ username │ email │ ← id가 기본 키(PK)
├──────┼───────────┼───────────┤
│ 1 │ alice │ [email protected] │
│ 2 │ bob │ [email protected] │
└──────┴───────────┴───────────┘
"""
orders_table = """
┌──────────────────────────────────────┐
│ orders │
├──────┬──────────┬────────┬───────────┤
│ id │ user_id │ total │ date │ ← user_id가 외래 키(FK)
├──────┼──────────┼────────┼───────────┤
│ 1 │ 1 │ 50000 │ 2025-05-01│
│ 2 │ 1 │ 30000 │ 2025-05-05│
│ 3 │ 2 │ 70000 │ 2025-05-08│
└──────┴──────────┴────────┴───────────┘
↑
└─ users 테이블의 id를 참조
"""
print("alice(id=1)의 주문은 2개, bob(id=2)의 주문은 1개")
💡 실생활 비유:
- 기본 키 = 주민등록번호 (나를 식별)
- 외래 키 = 부모님 주민등록번호 (가족 관계를 표현)
🎯 학습 목표 4: SQL과 SQLite 이해하기
한 줄 설명
SQL = 데이터베이스와 대화하는 언어, SQLite = 가벼운 데이터베이스 💬🗄️
4.1 SQL이 뭐예요?
SQL (Structured Query Language)은 데이터베이스와 대화하는 표준 언어예요!
1
2
3
-- SQL 예시
SELECT name, age FROM students WHERE age >= 20;
-- "20세 이상인 학생들의 이름과 나이를 보여줘!"
주요 SQL 명령어:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
sql_commands = {
"CREATE": "테이블 만들기",
"INSERT": "데이터 추가하기",
"SELECT": "데이터 조회하기",
"UPDATE": "데이터 수정하기",
"DELETE": "데이터 삭제하기"
}
# 예시
예시들 = [
"CREATE TABLE users (...); # 테이블 생성",
"INSERT INTO users VALUES (...); # 데이터 추가",
"SELECT * FROM users; # 모든 데이터 조회",
"UPDATE users SET age = 26; # 나이 수정",
"DELETE FROM users WHERE id = 1; # 데이터 삭제"
]
4.2 SQLite가 뭐예요?
SQLite는 Python에 내장된 가벼운 데이터베이스예요!
특징:
- 📦 별도 설치 불필요 (Python에 기본 포함)
- 💾 파일 하나로 저장 (
.db파일) - 🚀 서버 불필요 (파일 기반)
- 🎓 배우기 쉬움 (초보자에게 완벽)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# SQLite vs 다른 데이터베이스 비교
"""
┌─────────────┬──────────┬──────────┬──────────┐
│ │ SQLite │ MySQL │ PostgreSQL│
├─────────────┼──────────┼──────────┼──────────┤
│ 설치 │ 불필요 │ 필요 │ 필요 │
│ 서버 │ 불필요 │ 필요 │ 필요 │
│ 크기 │ 작음 │ 큼 │ 큼 │
│ 난이도 │ 쉬움 │ 중간 │ 중간 │
│ 용도 │ 소규모 │ 중대규모 │ 대규모 │
└─────────────┴──────────┴──────────┴──────────┘
"""
# SQLite는 학습용, 소규모 앱에 완벽해요!
4.3 SQLite 첫 만남
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import sqlite3
# 1. 데이터베이스 연결 (파일이 없으면 자동 생성)
conn = sqlite3.connect("my_first_database.db")
# 2. 커서 생성 (SQL 명령을 실행하는 도구)
cursor = conn.cursor()
# 3. SQL 명령 실행
cursor.execute("""
CREATE TABLE IF NOT EXISTS greetings (
id INTEGER PRIMARY KEY,
message TEXT
)
""")
cursor.execute("INSERT INTO greetings VALUES (1, 'Hello, Database!')")
cursor.execute("INSERT INTO greetings VALUES (2, '안녕, 데이터베이스!')")
# 4. 변경사항 저장
conn.commit()
# 5. 데이터 조회
cursor.execute("SELECT * FROM greetings")
rows = cursor.fetchall()
for row in rows:
print(f"ID {row[0]}: {row[1]}")
# 6. 연결 종료
conn.close()
출력:
1
2
ID 1: Hello, Database!
ID 2: 안녕, 데이터베이스!
💡 핵심 흐름: 연결 → 커서 생성 → SQL 실행 → 커밋 → 조회 → 닫기
4.4 실전 예제: 간단한 메모 앱
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import sqlite3
from datetime import datetime
class SimpleMemo:
def __init__(self, db_name="memos.db"):
self.conn = sqlite3.connect(db_name)
self.cursor = self.conn.cursor()
self._create_table()
def _create_table(self):
"""메모 테이블 생성"""
self.cursor.execute("""
CREATE TABLE IF NOT EXISTS memos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
content TEXT NOT NULL,
created_at TEXT NOT NULL
)
""")
self.conn.commit()
def add_memo(self, content):
"""메모 추가"""
now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
self.cursor.execute(
"INSERT INTO memos (content, created_at) VALUES (?, ?)",
(content, now)
)
self.conn.commit()
print(f"✅ 메모 추가됨: {content}")
def show_all_memos(self):
"""모든 메모 보기"""
self.cursor.execute("SELECT * FROM memos ORDER BY id DESC")
memos = self.cursor.fetchall()
if not memos:
print("📝 메모가 없습니다.")
return
print("\n📝 저장된 메모:")
for memo in memos:
print(f"[{memo[0]}] {memo[1]} (작성: {memo[2]})")
def close(self):
"""연결 종료"""
self.conn.close()
# 사용 예시
memo_app = SimpleMemo()
memo_app.add_memo("Python 데이터베이스 공부하기")
memo_app.add_memo("SQL 문법 연습하기")
memo_app.add_memo("프로젝트에 DB 적용하기")
memo_app.show_all_memos()
memo_app.close()
출력:
1
2
3
4
5
6
7
8
✅ 메모 추가됨: Python 데이터베이스 공부하기
✅ 메모 추가됨: SQL 문법 연습하기
✅ 메모 추가됨: 프로젝트에 DB 적용하기
📝 저장된 메모:
[3] 프로젝트에 DB 적용하기 (작성: 2025-05-10 09:30:15)
[2] SQL 문법 연습하기 (작성: 2025-05-10 09:30:10)
[1] Python 데이터베이스 공부하기 (작성: 2025-05-10 09:30:05)
이제 파일이 아닌 데이터베이스에 데이터를 저장할 수 있어요! 🎉
💡 실전 팁 & 주의사항
✅ 꼭 기억하세요!
- conn.commit() 잊지 마세요: INSERT, UPDATE, DELETE 후에는 꼭 commit()을 해야 실제로 저장돼요!
1
2
cursor.execute("INSERT INTO users VALUES (1, 'Alice')")
conn.commit() # ← 이거 없으면 저장 안 됨!
- conn.close() 항상 호출: 데이터베이스 연결은 사용 후 꼭 닫아야 해요!
1
2
3
4
5
try:
conn = sqlite3.connect("test.db")
# 작업 수행
finally:
conn.close() # ← 항상 닫기!
- PRIMARY KEY 활용: 각 행을 유일하게 식별할 수 있는 키를 설정하세요!
1
2
3
4
5
# AUTOINCREMENT로 자동 증가하는 ID 만들기
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT
)
⚠️ 흔한 실수
- 문자열 직접 삽입 (SQL Injection 위험!)
1
2
3
4
5
6
# ❌ 나쁜 예 (보안 취약)
user_input = "Alice"
cursor.execute(f"INSERT INTO users VALUES ('{user_input}')")
# ✅ 좋은 예 (안전)
cursor.execute("INSERT INTO users VALUES (?)", (user_input,))
- commit 없이 조회만 하기
1
2
3
4
# 데이터 추가했는데 안 보여요?
cursor.execute("INSERT INTO users VALUES (1, 'Alice')")
# conn.commit() ← 이게 없어서!
cursor.execute("SELECT * FROM users") # 빈 결과
- fetchone vs fetchall 혼동
1
2
3
4
5
6
7
# fetchone(): 한 개만 가져옴
cursor.execute("SELECT * FROM users")
row = cursor.fetchone() # 첫 번째 행만
# fetchall(): 모든 행 가져옴
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall() # 모든 행
🧪 연습 문제
문제 1: 간단한 연락처 관리 프로그램
데이터베이스를 사용하여 연락처를 저장하고 조회하는 프로그램을 만드세요.
요구사항:
contacts테이블 생성 (id, name, phone)- 연락처 추가 기능
- 모든 연락처 조회 기능
- 이름으로 연락처 검색 기능
💡 힌트
단계별 힌트:
sqlite3.connect()로 데이터베이스 연결CREATE TABLE로 테이블 생성INSERT INTO로 데이터 추가SELECT * FROM으로 조회WHERE name LIKE로 검색
핵심 SQL:
CREATE TABLE contacts (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, phone TEXT)INSERT INTO contacts (name, phone) VALUES (?, ?)SELECT * FROM contacts WHERE name LIKE ?
✅ 정답 코드
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import sqlite3
class ContactManager:
def __init__(self, db_name="contacts.db"):
self.conn = sqlite3.connect(db_name)
self.cursor = self.conn.cursor()
self._create_table()
def _create_table(self):
"""연락처 테이블 생성"""
self.cursor.execute("""
CREATE TABLE IF NOT EXISTS contacts (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
phone TEXT NOT NULL
)
""")
self.conn.commit()
def add_contact(self, name, phone):
"""연락처 추가"""
self.cursor.execute(
"INSERT INTO contacts (name, phone) VALUES (?, ?)",
(name, phone)
)
self.conn.commit()
print(f"✅ '{name}' 연락처가 추가되었습니다.")
def show_all_contacts(self):
"""모든 연락처 조회"""
self.cursor.execute("SELECT * FROM contacts ORDER BY name")
contacts = self.cursor.fetchall()
if not contacts:
print("📇 저장된 연락처가 없습니다.")
return
print("\n📇 연락처 목록:")
for contact in contacts:
print(f"[{contact[0]}] {contact[1]}: {contact[2]}")
def search_contact(self, name):
"""이름으로 연락처 검색"""
self.cursor.execute(
"SELECT * FROM contacts WHERE name LIKE ?",
(f"%{name}%",)
)
contacts = self.cursor.fetchall()
if not contacts:
print(f"🔍 '{name}'을(를) 찾을 수 없습니다.")
return
print(f"\n🔍 '{name}' 검색 결과:")
for contact in contacts:
print(f"[{contact[0]}] {contact[1]}: {contact[2]}")
def close(self):
"""연결 종료"""
self.conn.close()
# 사용 예시
manager = ContactManager()
manager.add_contact("김철수", "010-1234-5678")
manager.add_contact("이영희", "010-2345-6789")
manager.add_contact("박민수", "010-3456-7890")
manager.show_all_contacts()
manager.search_contact("김")
manager.close()
출력:
1
2
3
4
5
6
7
8
9
10
11
✅ '김철수' 연락처가 추가되었습니다.
✅ '이영희' 연락처가 추가되었습니다.
✅ '박민수' 연락처가 추가되었습니다.
📇 연락처 목록:
[1] 김철수: 010-1234-5678
[3] 박민수: 010-3456-7890
[2] 이영희: 010-2345-6789
🔍 '김' 검색 결과:
[1] 김철수: 010-1234-5678
문제 2: 파일 vs DB 성능 비교
1000개의 데이터를 파일과 데이터베이스에 각각 저장하고, 특정 데이터를 찾는 속도를 비교하세요.
💡 힌트
단계별 힌트:
time.time()으로 시간 측정- JSON 파일에 1000개 데이터 저장 후 검색
- SQLite에 1000개 데이터 저장 후 검색
- 두 결과 비교
핵심 코드:
1
2
3
4
import time
start = time.time()
# 작업 수행
elapsed = time.time() - start
✅ 정답 코드
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import time
import json
import sqlite3
# 테스트 데이터 생성
test_data = [{"id": i, "name": f"User{i}", "value": i * 10}
for i in range(1, 1001)]
# === 파일 저장 및 검색 ===
# 저장
with open("test_data.json", "w") as f:
json.dump(test_data, f)
# 검색
start = time.time()
with open("test_data.json", "r") as f:
data = json.load(f)
result = [item for item in data if item["id"] == 999][0]
file_time = time.time() - start
# === 데이터베이스 저장 및 검색 ===
conn = sqlite3.connect("test_data.db")
cursor = conn.cursor()
# 테이블 생성
cursor.execute("""
CREATE TABLE IF NOT EXISTS test_table (
id INTEGER PRIMARY KEY,
name TEXT,
value INTEGER
)
""")
# 저장
cursor.executemany(
"INSERT OR REPLACE INTO test_table VALUES (?, ?, ?)",
[(item["id"], item["name"], item["value"]) for item in test_data]
)
conn.commit()
# 검색
start = time.time()
cursor.execute("SELECT * FROM test_table WHERE id = 999")
result = cursor.fetchone()
db_time = time.time() - start
conn.close()
# 결과 출력
print("=" * 50)
print("📊 파일 vs 데이터베이스 성능 비교")
print("=" * 50)
print(f"📁 파일 검색 시간: {file_time:.6f}초")
print(f"🗄️ DB 검색 시간: {db_time:.6f}초")
print(f"⚡ 속도 차이: {file_time/db_time:.1f}배")
print("=" * 50)
if db_time < file_time:
print("✅ 데이터베이스가 더 빠릅니다!")
else:
print("⚠️ 이번엔 파일이 더 빨랐네요 (데이터가 적어서)")
출력 예시:
1
2
3
4
5
6
7
8
==================================================
📊 파일 vs 데이터베이스 성능 비교
==================================================
📁 파일 검색 시간: 0.002345초
🗄️ DB 검색 시간: 0.000123초
⚡ 속도 차이: 19.1배
==================================================
✅ 데이터베이스가 더 빠릅니다!
📝 오늘 배운 내용 정리
- 데이터베이스: 데이터를 체계적으로 저장/관리하는 시스템
- 파일 vs DB: 대용량 데이터는 DB가 훨씬 효율적
- 관계형 DB: 테이블(표) 형태로 데이터를 저장, 테이블 간 관계 설정
- SQL: 데이터베이스와 대화하는 표준 언어
- SQLite: Python 내장 데이터베이스, 별도 설치 불필요
🔗 관련 자료
📚 이전 학습
Day 70: Phase 7 실전 프로젝트 ⭐⭐⭐
Phase 7에서 배운 고급 파이썬 개념들을 종합한 프로젝트를 완성했어요!
📚 다음 학습
Day 72: SQLite 시작하기 ⭐⭐⭐
내일은 SQLite를 본격적으로 다뤄보고, 데이터베이스 연결부터 기본 명령어까지 배워요!
“늦었다고 생각할 때가 가장 빠른 순간이에요!” 🚀
Day 71/100 Phase 8: 데이터베이스와 SQL #100DaysOfPython
이 기사는 저작권자의 CC BY 4.0 라이센스를 따릅니다.