간단한 HTML 구조 예시:

<!DOCTYPE html>
<html>
<head>
    <title>샘플 페이지</title>
</head>
<body>
    <h1>안녕하세요!</h1>
    <p>이것은 <a href="https://example.com">링크</a>입니다.</p>
    <div class="product">
        <h2>제품명</h2>
        <p class="price">10,000원</p>
    </div>
</body>
</html>

# pip를 사용한 라이브러리 설치
pip install requests
pip install beautifulsoup4
pip install selenium
pip install scrapy

import requests
from bs4 import BeautifulSoup

# 웹 페이지 가져오기
url = 'https://example.com'
response = requests.get(url)

# 응답 상태 확인
if response.status_code == 200:
    # HTML 파싱
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # 페이지 제목 추출
    title = soup.title.text
    print(f'페이지 제목: {title}')
    
    # 모든 링크 추출
    links = soup.find_all('a')
    print(f'총 {len(links)}개의 링크를 찾았습니다:')
    
    for i, link in enumerate(links, 1):
        href = link.get('href')
        link_text = link.text.strip()
        print(f'{i}. {link_text} -> {href}')
else:
    print(f'오류 발생: {response.status_code}')

import requests
from bs4 import BeautifulSoup

# 헤더 설정
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
    'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
}

url = 'https://example.com'
response = requests.get(url, headers=headers)

# 이후 코드는 동일...

import requests
from bs4 import BeautifulSoup
import time

headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}

# 여러 페이지 크롤링
base_url = 'https://example.com/page/'
all_items = []

for page_num in range(1, 6):  # 1페이지부터 5페이지까지
    url = f'{base_url}{page_num}'
    print(f'크롤링 중: {url}')
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 페이지에서 아이템 추출 (예: 상품 목록)
        items = soup.select('.item')  # CSS 선택자로 아이템 선택
        
        for item in items:
            title = item.select_one('.title').text.strip()
            price = item.select_one('.price').text.strip()
            all_items.append({'title': title, 'price': price})
        
        # 서버에 부담을 주지 않기 위해 잠시 대기
        time.sleep(2)
    else:
        print(f'페이지 {page_num} 접근 실패: {response.status_code}')

print(f'총 {len(all_items)}개의 아이템을 수집했습니다.')

from bs4 import BeautifulSoup

# HTML 문자열
html_doc = """
<html>
    <head>
        <title>BeautifulSoup 예제</title>
    </head>
    <body>
        <h1 id="main-title" class="header">안녕하세요!</h1>
        <p class="content">이것은 <b>BeautifulSoup</b>의 예제입니다.</p>
        <div class="products">
            <div class="product">
                <h2>상품 1</h2>
                <p class="price">10,000원</p>
            </div>
            <div class="product">
                <h2>상품 2</h2>
                <p class="price">20,000원</p>
            </div>
        </div>
        <a href="https://example.com">링크</a>
    </body>
</html>
"""

# HTML 파싱
soup = BeautifulSoup(html_doc, 'html.parser')

# 기본적인 정보 추출
print(soup.title.text)  # 'BeautifulSoup 예제'
print(soup.h1.text)     # '안녕하세요!'
print(soup.p.text)      # '이것은 BeautifulSoup의 예제입니다.'

# 위의 HTML 예제에 이어서...

# find() - 첫 번째 일치하는 요소 찾기
title = soup.find('h1')
print(title.text)  # '안녕하세요!'

# find_all() - 모든 일치하는 요소 찾기
all_products = soup.find_all('div', class_='product')
print(f'상품 개수: {len(all_products)}')  # '상품 개수: 2'

# 속성으로 요소 찾기
main_title = soup.find(id='main-title')
print(main_title.text)  # '안녕하세요!'

# 여러 조건 조합하기
prices = soup.find_all('p', class_='price')
for price in prices:
    print(price.text)  # '10,000원', '20,000원'

# select_one() - CSS 선택자로 첫 번째 요소 찾기
title = soup.select_one('#main-title')  # id가 main-title인 요소
print(title.text)  # '안녕하세요!'

# select() - CSS 선택자로 모든 요소 찾기
products = soup.select('.product')  # class가 product인 모든 요소
print(f'상품 개수: {len(products)}')  # '상품 개수: 2'

# 복잡한 CSS 선택자 사용하기
product_prices = soup.select('.product .price')
for price in product_prices:
    print(price.text)  # '10,000원', '20,000원'

# 자식 선택자 사용하기
first_product_title = soup.select_one('.products > .product > h2')
print(first_product_title.text)  # '상품 1'

# 요소의 텍스트 내용 가져오기
h1 = soup.find('h1')
print(h1.text)  # '안녕하세요!'
print(h1.string)  # '안녕하세요!' (자식 태그가 없을 때만 작동)

# 요소의 속성 가져오기
link = soup.find('a')
print(link['href'])  # 'https://example.com'
print(link.get('href'))  # 'https://example.com' (더 안전한 방법)

# 모든 속성 확인하기
print(h1.attrs)  # {'id': 'main-title', 'class': ['header']}

# 내용 변경하기 (파싱된 객체 수정)
h1.string = '제목이 변경되었습니다!'
print(h1)  # <h1 id="main-title" class="header">제목이 변경되었습니다!</h1>

# 첫 번째 상품 요소 찾기
first_product = soup.select_one('.product')

# 자식 요소 찾기
product_title = first_product.find('h2')
print(product_title.text)  # '상품 1'

# 모든 자식 요소 리스트
children = list(first_product.children)
print(len(children))  # 자식 요소 개수 (텍스트 노드 포함)

# 부모 요소 찾기
parent = product_title.parent
print(parent['class'])  # ['product']

# 다음 형제 요소 찾기
next_sibling = product_title.find_next_sibling('p')
print(next_sibling.text)  # '10,000원'

# 이전 형제 요소 찾기
prev_sibling = next_sibling.find_previous_sibling()
print(prev_sibling.text)  # '상품 1'

# Selenium 설치
pip install selenium

# 웹 드라이버 설치 (Chrome 사용 예시)
# 1. Chrome 브라우저가 설치되어 있어야 함
# 2. Chrome 버전에 맞는 ChromeDriver 다운로드: https://sites.google.com/a/chromium.org/chromedriver/downloads
# 3. 다운로드한 드라이버를 경로에 추가하거나 코드에서 경로 지정

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

# 자동으로 적절한 ChromeDriver 설치 및 사용
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.common.by import By
import time

# 드라이버 초기화
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

try:
    # 웹 페이지 열기
    driver.get('https://example.com')
    
    # 페이지 타이틀 출력
    print(f'페이지 제목: {driver.title}')
    
    # 요소 찾기 (By.ID, By.CLASS_NAME, By.CSS_SELECTOR 등 사용 가능)
    header = driver.find_element(By.TAG_NAME, 'h1')
    print(f'헤더 텍스트: {header.text}')
    
    # 여러 요소 찾기
    links = driver.find_elements(By.TAG_NAME, 'a')
    print(f'링크 개수: {len(links)}')
    
    # 첫 번째 링크 클릭
    if links:
        links[0].click()
        time.sleep(2)  # 페이지 로딩 대기
        print(f'새 페이지 제목: {driver.title}')
    
    # 뒤로 가기
    driver.back()
    time.sleep(1)
    
    # 페이지 소스 가져오기
    page_source = driver.page_source
    print(f'페이지 소스 길이: {len(page_source)}')
    
finally:
    # 브라우저 닫기
    driver.quit()

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.keys import Keys

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

try:
    # 웹 페이지 열기
    driver.get('https://example.com')
    
    # 명시적 대기: 특정 요소가 나타날 때까지 최대 10초 대기
    search_box = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, 'search'))
    )
    
    # 텍스트 입력
    search_box.send_keys('Selenium 자동화')
    
    # Enter 키 누르기
    search_box.send_keys(Keys.RETURN)
    
    # 검색 결과가 로드될 때까지 대기
    results = WebDriverWait(driver, 10).until(
        EC.presence_of_all_elements_located((By.CSS_SELECTOR, '.result-item'))
    )
    
    print(f'검색 결과 개수: {len(results)}')
    
    # 스크롤 다운
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    
    # 잠시 대기
    import time
    time.sleep(2)
    
    # 더 많은 결과가 로드될 때까지 대기
    more_results = WebDriverWait(driver, 10).until(
        EC.presence_of_all_elements_located((By.CSS_SELECTOR, '.result-item'))
    )
    
    print(f'스크롤 후 검색 결과 개수: {len(more_results)}')
    
finally:
    driver.quit()

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.options import Options

# 헤드리스 모드 설정
chrome_options = Options()
chrome_options.add_argument("--headless")
chrome_options.add_argument("--disable-gpu")  # Windows에서 필요할 수 있음
chrome_options.add_argument("--window-size=1920,1080")  # 창 크기 설정

# 드라이버 초기화
driver = webdriver.Chrome(
    service=Service(ChromeDriverManager().install()),
    options=chrome_options
)

try:
    # 웹 페이지 열기
    driver.get('https://example.com')
    print(f'페이지 제목: {driver.title}')
    
    # 스크린샷 저장 (헤드리스 모드에서도 작동)
    driver.save_screenshot('screenshot.png')
    print('스크린샷이 저장되었습니다.')
    
finally:
    driver.quit()

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time

driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

try:
    # 무한 스크롤 페이지 열기
    driver.get('https://example-infinite-scroll.com')
    
    # 아이템을 저장할 리스트
    all_items = []
    
    # 이전 아이템 수
    prev_items_count = 0
    
    # 최대 스크롤 횟수
    max_scrolls = 5
    scrolls = 0
    
    while scrolls < max_scrolls:
        # 현재 아이템 가져오기
        items = driver.find_elements(By.CSS_SELECTOR, '.item')
        items_count = len(items)
        
        print(f'현재 아이템 수: {items_count}')
        
        # 새로운 아이템만 처리
        for i in range(prev_items_count, items_count):
            item_text = items[i].text
            all_items.append(item_text)
            print(f'아이템 {i+1}: {item_text[:50]}...')
        
        # 이전 카운트 업데이트
        prev_items_count = items_count
        
        # 페이지 끝으로 스크롤
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        
        # 잠시 대기
        time.sleep(2)
        
        # 새 콘텐츠가 로드될 때까지 대기
        try:
            WebDriverWait(driver, 5).until(
                lambda d: len(d.find_elements(By.CSS_SELECTOR, '.item')) > prev_items_count
            )
        except:
            print("더 이상 새로운 아이템이 로드되지 않습니다.")
            break
        
        scrolls += 1
    
    print(f'총 {len(all_items)}개의 아이템을 수집했습니다.')
    
finally:
    driver.quit()

# Scrapy 설치
pip install scrapy

# 새 Scrapy 프로젝트 생성
scrapy startproject bookscrapy

# 프로젝트 디렉토리로 이동
cd bookscrapy

# 스파이더 생성
scrapy genspider bookspider example-bookstore.com

bookscrapy/
    ├── bookscrapy/
    │   ├── __init__.py
    │   ├── items.py          # 아이템 정의
    │   ├── middlewares.py    # 미들웨어 정의
    │   ├── pipelines.py      # 파이프라인 정의
    │   ├── settings.py       # 설정 파일
    │   └── spiders/          # 스파이더 디렉토리
    │       ├── __init__.py
    │       └── bookspider.py # 생성된 스파이더
    └── scrapy.cfg            # 프로젝트 설정 파일

import scrapy

class BookspiderSpider(scrapy.Spider):
    name = 'bookspider'
    allowed_domains = ['example-bookstore.com']
    start_urls = ['https://example-bookstore.com/books']

    def parse(self, response):
        # 모든 책 항목 선택
        books = response.css('div.book-item')
        
        for book in books:
            # 각 책의 정보 추출
            yield {
                'title': book.css('h2.title::text').get().strip(),
                'author': book.css('p.author::text').get().strip(),
                'price': book.css('span.price::text').get().strip(),
                'rating': book.css('div.rating::attr(data-rating)').get(),
                'url': book.css('a.book-link::attr(href)').get()
            }
        
        # 다음 페이지 링크 찾기
        next_page = response.css('a.next-page::attr(href)').get()
        if next_page:
            # 절대 URL로 변환
            next_page_url = response.urljoin(next_page)
            # 다음 페이지 크롤링
            yield scrapy.Request(next_page_url, callback=self.parse)

# 스파이더 실행 및 결과를 JSON 파일로 저장
scrapy crawl bookspider -o books.json

import scrapy

class BookItem(scrapy.Item):
    title = scrapy.Field()
    author = scrapy.Field()
    price = scrapy.Field()
    rating = scrapy.Field()
    url = scrapy.Field()
    description = scrapy.Field()
    published_date = scrapy.Field()
    isbn = scrapy.Field()

import scrapy
from bookscrapy.items import BookItem

class BookspiderSpider(scrapy.Spider):
    name = 'bookspider'
    allowed_domains = ['example-bookstore.com']
    start_urls = ['https://example-bookstore.com/books']

    def parse(self, response):
        books = response.css('div.book-item')
        
        for book in books:
            # 책 상세 페이지 URL 가져오기
            book_url = response.urljoin(book.css('a.book-link::attr(href)').get())
            
            # 상세 페이지로 이동하여 추가 정보 수집
            yield scrapy.Request(
                book_url,
                callback=self.parse_book_details,
                meta={'title': book.css('h2.title::text').get().strip(),
                      'author': book.css('p.author::text').get().strip(),
                      'price': book.css('span.price::text').get().strip(),
                      'rating': book.css('div.rating::attr(data-rating)').get()}
            )
        
        # 다음 페이지 처리
        next_page = response.css('a.next-page::attr(href)').get()
        if next_page:
            yield scrapy.Request(response.urljoin(next_page), callback=self.parse)
    
    def parse_book_details(self, response):
        # 아이템 생성
        book_item = BookItem()
        
        # 이전 페이지에서 가져온 기본 정보 설정
        book_item['title'] = response.meta['title']
        book_item['author'] = response.meta['author']
        book_item['price'] = response.meta['price']
        book_item['rating'] = response.meta['rating']
        book_item['url'] = response.url
        
        # 상세 페이지에서 추가 정보 추출
        book_item['description'] = response.css('div.description::text').get().strip()
        book_item['published_date'] = response.css('span.published-date::text').get().strip()
        book_item['isbn'] = response.css('span.isbn::text').get().strip()
        
        yield book_item

import re
import sqlite3

class PriceCleaningPipeline:
    def process_item(self, item, spider):
        # 가격에서 통화 기호 제거하고 숫자만 추출
        if 'price' in item:
            item['price'] = re.sub(r'[^\d.]', '', item['price'])
            # 문자열을 float로 변환
            try:
                item['price'] = float(item['price'])
            except ValueError:
                item['price'] = 0.0
        return item

class SQLitePipeline:
    def __init__(self):
        # 데이터베이스 연결 및 테이블 생성
        self.conn = sqlite3.connect('books.db')
        self.cur = self.conn.cursor()
        self.cur.execute('''
            CREATE TABLE IF NOT EXISTS books
            (title TEXT, author TEXT, price REAL, rating TEXT,
             url TEXT, description TEXT, published_date TEXT, isbn TEXT)
        ''')
    
    def process_item(self, item, spider):
        # 아이템을 데이터베이스에 삽입
        self.cur.execute('''
            INSERT INTO books VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        ''', (
            item.get('title', ''),
            item.get('author', ''),
            item.get('price', 0.0),
            item.get('rating', ''),
            item.get('url', ''),
            item.get('description', ''),
            item.get('published_date', ''),
            item.get('isbn', '')
        ))
        self.conn.commit()
        return item
    
    def close_spider(self, spider):
        # 스파이더가 종료될 때 연결 닫기
        self.conn.close()

ITEM_PIPELINES = {
    'bookscrapy.pipelines.PriceCleaningPipeline': 300,
    'bookscrapy.pipelines.SQLitePipeline': 400,
}

import random
from scrapy import signals

class RandomUserAgentMiddleware:
    def __init__(self):
        self.user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0'
        ]
    
    def process_request(self, request, spider):
        # 랜덤 사용자 에이전트 설정
        request.headers['User-Agent'] = random.choice(self.user_agents)
        return None

class DelayedRequestsMiddleware:
    def process_request(self, request, spider):
        # 요청 사이에 랜덤 지연 추가
        import time
        time.sleep(random.uniform(1, 3))
        return None

DOWNLOADER_MIDDLEWARES = {
    'bookscrapy.middlewares.RandomUserAgentMiddleware': 400,
    'bookscrapy.middlewares.DelayedRequestsMiddleware': 500,
}

# Scrapy Shell 실행
scrapy shell "https://example-bookstore.com/books"

# 응답 객체 확인
response

# CSS 선택자 테스트
response.css('div.book-item')
response.css('h2.title::text').getall()

# XPath 선택자 테스트
response.xpath('//div[@class="book-item"]')
response.xpath('//h2[@class="title"]/text()').getall()

# 특정 요소 선택 및 탐색
book = response.css('div.book-item')[0]
book.css('h2.title::text').get()
book.css('p.author::text').get()

GET /api/books           # 모든 책 목록 조회
GET /api/books/123       # ID가 123인 책 조회
GET /api/books?author=김작가  # 저자가 '김작가'인 책 조회
POST /api/books          # 새 책 추가
PUT /api/books/123       # ID가 123인 책 정보 수정
DELETE /api/books/123    # ID가 123인 책 삭제

import requests
import json

# GET 요청 예시
response = requests.get('https://api.example.com/books')

# 응답 상태 확인
if response.status_code == 200:
    # JSON 응답 파싱
    data = response.json()
    
    # 데이터 처리
    for book in data['books']:
        print(f"제목: {book['title']}")
        print(f"저자: {book['author']}")
        print(f"가격: {book['price']}")
        print('-' * 30)
else:
    print(f"오류 발생: {response.status_code}")

import requests

# 쿼리 파라미터 전송
params = {
    'author': '김작가',
    'min_price': 10000,
    'max_price': 30000,
    'sort': 'price_asc'
}

# 헤더 설정
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'Authorization': 'Bearer YOUR_API_KEY'
}

# GET 요청 with 파라미터 및 헤더
response = requests.get(
    'https://api.example.com/books',
    params=params,
    headers=headers
)

# 응답 확인
print(f"URL: {response.url}")  # 실제 요청된 URL 확인
print(f"상태 코드: {response.status_code}")

if response.status_code == 200:
    data = response.json()
    print(f"총 {len(data['books'])}개의 책을 찾았습니다.")

import requests

# 전송할 데이터
new_book = {
    'title': '파이썬으로 배우는 웹 크롤링',
    'author': '홍길동',
    'price': 25000,
    'description': '웹 크롤링과 스크래핑의 모든 것을 다룬 책입니다.'
}

# POST 요청
response = requests.post(
    'https://api.example.com/books',
    json=new_book,  # JSON 형식으로 데이터 전송
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)

# 응답 확인
if response.status_code == 201:  # 201 Created
    created_book = response.json()
    print(f"새 책이 추가되었습니다. ID: {created_book['id']}")
else:
    print(f"오류 발생: {response.status_code}")
    print(response.text)

import requests

# 기본 인증 (사용자명/비밀번호)
response = requests.get(
    'https://api.example.com/books',
    auth=('username', 'password')
)

# API 키 인증 (쿼리 파라미터)
response = requests.get(
    'https://api.example.com/books',
    params={'api_key': 'YOUR_API_KEY'}
)

# API 키 인증 (헤더)
response = requests.get(
    'https://api.example.com/books',
    headers={'X-API-Key': 'YOUR_API_KEY'}
)

# OAuth 2.0 토큰 인증
response = requests.get(
    'https://api.example.com/books',
    headers={'Authorization': 'Bearer YOUR_ACCESS_TOKEN'}
)

import requests

url = 'https://api.example.com/books'
all_books = []
page = 1

while True:
    # 페이지 파라미터 설정
    params = {
        'page': page,
        'per_page': 100  # 한 페이지당 항목 수
    }
    
    response = requests.get(url, params=params)
    
    if response.status_code == 200:
        data = response.json()
        books = data['books']
        
        # 결과가 없으면 종료
        if not books:
            break
        
        all_books.extend(books)
        print(f"페이지 {page} 처리 완료: {len(books)}개 항목")
        
        # 다음 페이지로
        page += 1
        
        # API 제한을 고려한 지연
        import time
        time.sleep(1)
    else:
        print(f"오류 발생: {response.status_code}")
        break

print(f"총 {len(all_books)}개의 책을 수집했습니다.")

import requests
import pandas as pd
from datetime import datetime

# 공공 데이터 포털 API 키 (실제 사용 시 발급 필요)
api_key = 'YOUR_API_KEY'

# 코로나19 감염 현황 API 호출
url = 'http://openapi.data.go.kr/openapi/service/rest/Covid19/getCovid19InfStateJson'
params = {
    'serviceKey': api_key,
    'pageNo': 1,
    'numOfRows': 10,
    'startCreateDt': '20210101',
    'endCreateDt': '20210131'
}

response = requests.get(url, params=params)

# XML 응답 파싱 (이 API는 XML 형식으로 응답)
from xml.etree import ElementTree as ET
root = ET.fromstring(response.content)

# 데이터 추출
items = root.findall('.//item')
covid_data = []

for item in items:
    data = {
        '날짜': item.find('stateDt').text,
        '확진자': item.find('decideCnt').text,
        '사망자': item.find('deathCnt').text,
        '검사중': item.find('examCnt').text,
        '격리해제': item.find('clearCnt').text
    }
    covid_data.append(data)

# 데이터프레임으로 변환
df = pd.DataFrame(covid_data)

# 날짜 형식 변환 및 정렬
df['날짜'] = pd.to_datetime(df['날짜'])
df = df.sort_values('날짜')

# 숫자 형식으로 변환
numeric_columns = ['확진자', '사망자', '검사중', '격리해제']
for col in numeric_columns:
    df[col] = pd.to_numeric(df[col])

# 일별 신규 확진자 계산
df['신규확진자'] = df['확진자'].diff()

print(df.head())

# CSV 파일로 저장
df.to_csv('covid19_data_202101.csv', index=False, encoding='utf-8-sig')

# robots.txt 파일 예시
User-agent: *           # 모든 크롤러에 적용
Disallow: /private/     # /private/ 디렉토리 크롤링 금지
Disallow: /admin/       # /admin/ 디렉토리 크롤링 금지
Allow: /public/         # /public/ 디렉토리 크롤링 허용
Crawl-delay: 10         # 요청 간 10초 지연 요청

import requests
from urllib.robotparser import RobotFileParser

url = 'https://example.com'
robots_url = f'{url}/robots.txt'

# robots.txt 파일 가져오기
rp = RobotFileParser()
rp.set_url(robots_url)
rp.read()

# 특정 URL에 크롤러가 접근 가능한지 확인
test_url = f'{url}/some/page'
can_fetch = rp.can_fetch('MyBot', test_url)

print(f'크롤링 가능 여부: {can_fetch}')
print(f'크롤링 지연 시간: {rp.crawl_delay("MyBot")} 초')

import requests
import time
from random import uniform

urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3',
    # ...
]

for url in urls:
    try:
        response = requests.get(url, headers={'User-Agent': 'MyBot/1.0'})
        print(f"상태 코드: {response.status_code}, URL: {url}")
        
        # 랜덤 지연 (2-5초)
        delay = uniform(2, 5)
        print(f"{delay:.2f}초 대기 중...")
        time.sleep(delay)
        
    except Exception as e:
        print(f"오류 발생: {e}")

import csv

# 데이터 예시
data = [
    {'title': '파이썬 기초', 'author': '김파이', 'price': 25000},
    {'title': '웹 크롤링 마스터', 'author': '이크롤', 'price': 30000},
    {'title': '데이터 분석 입문', 'author': '박데이터', 'price': 28000}
]

# CSV 파일로 저장
with open('books.csv', 'w', newline='', encoding='utf-8-sig') as f:
    # 필드 이름 정의
    fieldnames = ['title', 'author', 'price']
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    
    # 헤더 쓰기
    writer.writeheader()
    
    # 데이터 쓰기
    for item in data:
        writer.writerow(item)

print("CSV 파일 저장 완료!")

import json

# 데이터 예시 (중첩 구조 포함)
data = [
    {
        'title': '파이썬 기초',
        'author': '김파이',
        'price': 25000,
        'categories': ['프로그래밍', '파이썬'],
        'reviews': [
            {'user': '독자1', 'rating': 5, 'comment': '좋은 책이에요!'},
            {'user': '독자2', 'rating': 4, 'comment': '초보자에게 추천합니다.'}
        ]
    },
    # 다른 책 데이터...
]

# JSON 파일로 저장
with open('books.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

print("JSON 파일 저장 완료!")

import xml.etree.ElementTree as ET
from xml.dom import minidom

# XML 루트 요소 생성
root = ET.Element('books')

# 책 데이터 추가
book = ET.SubElement(root, 'book')
ET.SubElement(book, 'title').text = '파이썬 기초'
ET.SubElement(book, 'author').text = '김파이'
ET.SubElement(book, 'price').text = '25000'

# 카테고리 추가 (중첩 구조)
categories = ET.SubElement(book, 'categories')
ET.SubElement(categories, 'category').text = '프로그래밍'
ET.SubElement(categories, 'category').text = '파이썬'

# XML 문자열로 변환 (예쁘게 출력)
xml_str = minidom.parseString(ET.tostring(root)).toprettyxml(indent="  ")

# 파일로 저장
with open('books.xml', 'w', encoding='utf-8') as f:
    f.write(xml_str)

print("XML 파일 저장 완료!")

import pandas as pd

# 데이터 예시
data = [
    {'title': '파이썬 기초', 'author': '김파이', 'price': 25000},
    {'title': '웹 크롤링 마스터', 'author': '이크롤', 'price': 30000},
    {'title': '데이터 분석 입문', 'author': '박데이터', 'price': 28000}
]

# DataFrame 생성
df = pd.DataFrame(data)

# Excel 파일로 저장
df.to_excel('books.xlsx', index=False)

print("Excel 파일 저장 완료!")

import sqlite3

# 데이터베이스 연결
conn = sqlite3.connect('books.db')
cursor = conn.cursor()

# 테이블 생성
cursor.execute('''
CREATE TABLE IF NOT EXISTS books (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    author TEXT NOT NULL,
    price INTEGER,
    category TEXT,
    published_date TEXT
)
''')

# 데이터 삽입
books = [
    ('파이썬 기초', '김파이', 25000, '프로그래밍', '2021-01-15'),
    ('웹 크롤링 마스터', '이크롤', 30000, '프로그래밍', '2021-03-20'),
    ('데이터 분석 입문', '박데이터', 28000, '데이터 과학', '2021-05-10')
]

cursor.executemany('''
INSERT INTO books (title, author, price, category, published_date)
VALUES (?, ?, ?, ?, ?)
''', books)

# 변경사항 저장
conn.commit()

# 데이터 조회
cursor.execute('SELECT * FROM books')
for row in cursor.fetchall():
    print(row)

# 연결 종료
conn.close()

print("SQLite 데이터베이스 작업 완료!")

import pymysql

# 데이터베이스 연결
conn = pymysql.connect(
    host='localhost',
    user='username',
    password='password',
    database='crawling_db'
)

try:
    with conn.cursor() as cursor:
        # 테이블 생성
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS books (
            id INT AUTO_INCREMENT PRIMARY KEY,
            title VARCHAR(255) NOT NULL,
            author VARCHAR(255) NOT NULL,
            price INT,
            category VARCHAR(100),
            published_date DATE
        )
        ''')
        
        # 데이터 삽입
        sql = '''
        INSERT INTO books (title, author, price, category, published_date)
        VALUES (%s, %s, %s, %s, %s)
        '''
        books = [
            ('파이썬 기초', '김파이', 25000, '프로그래밍', '2021-01-15'),
            ('웹 크롤링 마스터', '이크롤', 30000, '프로그래밍', '2021-03-20'),
            ('데이터 분석 입문', '박데이터', 28000, '데이터 과학', '2021-05-10')
        ]
        
        cursor.executemany(sql, books)
        
        # 변경사항 저장
        conn.commit()
        
        # 데이터 조회
        cursor.execute('SELECT * FROM books')
        for row in cursor.fetchall():
            print(row)
            
finally:
    conn.close()
    
print("MySQL 데이터베이스 작업 완료!")

from pymongo import MongoClient

# MongoDB 연결
client = MongoClient('mongodb://localhost:27017/')
db = client['crawling_db']
collection = db['books']

# 데이터 삽입 (복잡한 중첩 구조 가능)
books = [
    {
        'title': '파이썬 기초',
        'author': '김파이',
        'price': 25000,
        'categories': ['프로그래밍', '파이썬'],
        'reviews': [
            {'user': '독자1', 'rating': 5, 'comment': '좋은 책이에요!'},
            {'user': '독자2', 'rating': 4, 'comment': '초보자에게 추천합니다.'}
        ],
        'published_date': '2021-01-15'
    },
    {
        'title': '웹 크롤링 마스터',
        'author': '이크롤',
        'price': 30000,
        'categories': ['프로그래밍', '웹', '크롤링'],
        'reviews': [],
        'published_date': '2021-03-20'
    }
]

# 여러 문서 삽입
result = collection.insert_many(books)
print(f"{len(result.inserted_ids)}개의 문서가 삽입되었습니다.")

# 데이터 조회
for book in collection.find():
    print(f"제목: {book['title']}, 저자: {book['author']}, 가격: {book['price']}")

# 필터링 조회
for book in collection.find({'price': {'$gt': 25000}}):
    print(f"25,000원 초과 도서: {book['title']}")

print("MongoDB 작업 완료!")

import pandas as pd

# CSV 파일 읽기
df = pd.read_csv('books.csv')

# 기본 정보 확인
print(df.info())
print(df.describe())

# 데이터 필터링
programming_books = df[df['category'] == '프로그래밍']
print(f"프로그래밍 도서 수: {len(programming_books)}")

# 데이터 정렬
sorted_df = df.sort_values('price', ascending=False)
print("가격 높은 순 Top 3:")
print(sorted_df.head(3)[['title', 'price']])

# 그룹화 및 집계
category_stats = df.groupby('category').agg({
    'price': ['mean', 'min', 'max', 'count']
})
print("\n카테고리별 통계:")
print(category_stats)

# 데이터 변환
df['discount_price'] = df['price'] * 0.9  # 10% 할인 가격 추가

# 변경된 데이터 저장
df.to_csv('books_processed.csv', index=False)

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# 데이터 로드
df = pd.read_csv('books.csv')

# 기본 설정
plt.figure(figsize=(12, 6))
sns.set_style('whitegrid')

# 카테고리별 도서 수 막대 그래프
plt.subplot(1, 2, 1)
category_counts = df['category'].value_counts()
sns.barplot(x=category_counts.index, y=category_counts.values)
plt.title('카테고리별 도서 수')
plt.xticks(rotation=45)

# 가격 분포 히스토그램
plt.subplot(1, 2, 2)
sns.histplot(df['price'], bins=10, kde=True)
plt.title('도서 가격 분포')
plt.xlabel('가격')
plt.ylabel('도서 수')

plt.tight_layout()
plt.savefig('book_analysis.png')
plt.show()

# 카테고리별 평균 가격 막대 그래프
plt.figure(figsize=(10, 5))
avg_price = df.groupby('category')['price'].mean().sort_values(ascending=False)
sns.barplot(x=avg_price.index, y=avg_price.values)
plt.title('카테고리별 평균 가격')
plt.xticks(rotation=45)
plt.ylabel('평균 가격')
plt.tight_layout()
plt.savefig('category_avg_price.png')
plt.show()

import json
import gzip
import datetime
import os

def save_crawled_data(data, filename_prefix, compress=True):
    """크롤링 데이터를 저장하는 함수
    
    Args:
        data: 저장할 데이터
        filename_prefix: 파일명 접두사
        compress: 압축 여부
    """
    # 현재 시간을 파일명에 포함
    timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
    filename = f"{filename_prefix}_{timestamp}"
    
    # 메타데이터 추가
    metadata = {
        'crawled_at': datetime.datetime.now().isoformat(),
        'crawler_version': '1.0',
        'item_count': len(data) if isinstance(data, list) else 1
    }
    
    # 데이터와 메타데이터 결합
    full_data = {
        'metadata': metadata,
        'data': data
    }
    
    # 디렉토리 생성
    os.makedirs('crawled_data', exist_ok=True)
    
    if compress:
        # gzip으로 압축하여 저장
        filename = f"crawled_data/{filename}.json.gz"
        with gzip.open(filename, 'wt', encoding='utf-8') as f:
            json.dump(full_data, f, ensure_ascii=False, indent=2)
    else:
        # 일반 JSON 파일로 저장
        filename = f"crawled_data/{filename}.json"
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(full_data, f, ensure_ascii=False, indent=2)
    
    print(f"데이터가 {filename}에 저장되었습니다.")
    return filename

# 사용 예시
books_data = [
    {'title': '파이썬 기초', 'author': '김파이', 'price': 25000},
    {'title': '웹 크롤링 마스터', 'author': '이크롤', 'price': 30000}
]

save_crawled_data(books_data, 'books', compress=True)

price_tracker/
├── scrapers/
│   ├── __init__.py
│   ├── base_scraper.py      # 기본 스크래퍼 클래스
│   ├── shop_a_scraper.py    # 쇼핑몰 A 스크래퍼
│   ├── shop_b_scraper.py    # 쇼핑몰 B 스크래퍼
│   └── shop_c_scraper.py    # 쇼핑몰 C 스크래퍼
├── database/
│   ├── __init__.py
│   ├── db_manager.py        # 데이터베이스 관리
│   └── models.py            # 데이터 모델
├── utils/
│   ├── __init__.py
│   ├── config.py            # 설정 파일
│   ├── logger.py            # 로깅 유틸리티
│   └── notifier.py          # 알림 기능
├── web/
│   ├── __init__.py
│   ├── app.py               # 웹 대시보드
│   └── templates/           # HTML 템플릿
├── main.py                  # 메인 실행 파일
├── requirements.txt         # 필요한 패키지 목록
└── README.md                # 프로젝트 설명

# base_scraper.py
import requests
from abc import ABC, abstractmethod
from bs4 import BeautifulSoup
import logging
from utils.logger import setup_logger

class BaseScraper(ABC):
    """모든 스크래퍼의 기본 클래스"""
    
    def __init__(self, shop_name):
        self.shop_name = shop_name
        self.logger = setup_logger(f"{shop_name}_scraper")
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7'
        }
    
    def get_page(self, url):
        """웹 페이지 가져오기"""
        try:
            response = requests.get(url, headers=self.headers, timeout=10)
            response.raise_for_status()  # 4XX, 5XX 에러 체크
            return response.text
        except requests.RequestException as e:
            self.logger.error(f"페이지 요청 실패: {url}, 오류: {e}")
            return None
    
    def parse_html(self, html):
        """HTML 파싱"""
        if html:
            return BeautifulSoup(html, 'html.parser')
        return None
    
    @abstractmethod
    def search_product(self, keyword):
        """제품 검색 (자식 클래스에서 구현)"""
        pass
    
    @abstractmethod
    def get_product_details(self, product_url):
        """제품 상세 정보 가져오기 (자식 클래스에서 구현)"""
        pass
    
    def clean_price(self, price_text):
        """가격 텍스트 정리 (숫자만 추출)"""
        import re
        if price_text:
            # 숫자만 추출
            price = re.sub(r'[^\d]', '', price_text)
            try:
                return int(price)
            except ValueError:
                self.logger.warning(f"가격 변환 실패: {price_text}")
        return None
    
    def format_result(self, product_data):
        """결과 포맷팅"""
        return {
            'shop': self.shop_name,
            'title': product_data.get('title', ''),
            'price': product_data.get('price', 0),
            'url': product_data.get('url', ''),
            'image_url': product_data.get('image_url', ''),
            'availability': product_data.get('availability', False),
            'timestamp': product_data.get('timestamp', None)
        }

# shop_a_scraper.py
from scrapers.base_scraper import BaseScraper
from datetime import datetime
import time
import random

class ShopAScraper(BaseScraper):
    """쇼핑몰 A 스크래퍼"""
    
    def __init__(self):
        super().__init__("ShopA")
        self.base_url = "https://example-shop-a.com"
        self.search_url = f"{self.base_url}/search"
    
    def search_product(self, keyword):
        """제품 검색"""
        self.logger.info(f"검색 시작: {keyword}")
        
        params = {
            'q': keyword,
            'sort': 'price_asc'  # 가격 낮은순 정렬
        }
        
        html = self.get_page(f"{self.search_url}?{'&'.join([f'{k}={v}' for k, v in params.items()])}")
        soup = self.parse_html(html)
        
        if not soup:
            self.logger.error("검색 결과 파싱 실패")
            return []
        
        results = []
        product_elements = soup.select('.product-item')
        
        for element in product_elements[:5]:  # 상위 5개 제품만 처리
            try:
                title_element = element.select_one('.product-title')
                price_element = element.select_one('.product-price')
                link_element = element.select_one('a.product-link')
                image_element = element.select_one('img.product-image')
                
                if title_element and price_element and link_element:
                    title = title_element.text.strip()
                    price_text = price_element.text.strip()
                    price = self.clean_price(price_text)
                    url = link_element.get('href')
                    if not url.startswith('http'):
                        url = f"{self.base_url}{url}"
                    
                    image_url = image_element.get('src') if image_element else ''
                    if image_url and not image_url.startswith('http'):
                        image_url = f"{self.base_url}{image_url}"
                    
                    results.append({
                        'title': title,
                        'price': price,
                        'url': url,
                        'image_url': image_url,
                        'availability': True,
                        'timestamp': datetime.now()
                    })
                    
                    # 서버 부하 방지를 위한 지연
                    time.sleep(random.uniform(0.5, 1.5))
            
            except Exception as e:
                self.logger.error(f"제품 정보 추출 중 오류: {e}")
        
        self.logger.info(f"{len(results)}개의 제품 정보 추출 완료")
        return [self.format_result(item) for item in results]
    
    def get_product_details(self, product_url):
        """제품 상세 정보 가져오기"""
        self.logger.info(f"제품 상세 정보 수집: {product_url}")
        
        html = self.get_page(product_url)
        soup = self.parse_html(html)
        
        if not soup:
            self.logger.error("제품 상세 페이지 파싱 실패")
            return None
        
        try:
            title = soup.select_one('h1.product-title').text.strip()
            price_text = soup.select_one('span.current-price').text.strip()
            price = self.clean_price(price_text)
            image_url = soup.select_one('img.product-main-image').get('src')
            availability = 'In Stock' in soup.select_one('div.availability').text
            
            # 추가 정보 수집
            specs = {}
            spec_elements = soup.select('table.specifications tr')
            for spec in spec_elements:
                key = spec.select_one('th').text.strip()
                value = spec.select_one('td').text.strip()
                specs[key] = value
            
            result = {
                'title': title,
                'price': price,
                'url': product_url,
                'image_url': image_url,
                'availability': availability,
                'specifications': specs,
                'timestamp': datetime.now()
            }
            
            return self.format_result(result)
            
        except Exception as e:
            self.logger.error(f"제품 상세 정보 추출 중 오류: {e}")
            return None

# db_manager.py
import sqlite3
import json
from datetime import datetime
import os

class DatabaseManager:
    """데이터베이스 관리 클래스"""
    
    def __init__(self, db_path='database/price_tracker.db'):
        # 디렉토리가 없으면 생성
        os.makedirs(os.path.dirname(db_path), exist_ok=True)
        
        self.db_path = db_path
        self.conn = None
        self.cursor = None
        self.initialize_db()
    
    def connect(self):
        """데이터베이스 연결"""
        self.conn = sqlite3.connect(self.db_path)
        self.conn.row_factory = sqlite3.Row  # 결과를 딕셔너리 형태로 반환
        self.cursor = self.conn.cursor()
        return self.cursor
    
    def close(self):
        """데이터베이스 연결 종료"""
        if self.conn:
            self.conn.close()
            self.conn = None
            self.cursor = None
    
    def initialize_db(self):
        """데이터베이스 초기화 및 테이블 생성"""
        cursor = self.connect()
        
        # 제품 테이블
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS products (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            keyword TEXT NOT NULL,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
        ''')
        
        # 가격 정보 테이블
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS prices (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            product_id INTEGER,
            shop TEXT NOT NULL,
            price INTEGER NOT NULL,
            url TEXT NOT NULL,
            image_url TEXT,
            availability BOOLEAN,
            timestamp TIMESTAMP,
            FOREIGN KEY (product_id) REFERENCES products (id)
        )
        ''')
        
        # 알림 설정 테이블
        cursor.execute('''
        CREATE TABLE IF NOT EXISTS alerts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            product_id INTEGER,
            target_price INTEGER,
            email TEXT,
            is_active BOOLEAN DEFAULT 1,
            FOREIGN KEY (product_id) REFERENCES products (id)
        )
        ''')
        
        self.conn.commit()
        self.close()
    
    def add_product(self, title, keyword):
        """새 제품 추가"""
        cursor = self.connect()
        
        # 이미 존재하는지 확인
        cursor.execute(
            "SELECT id FROM products WHERE keyword = ?",
            (keyword,)
        )
        existing = cursor.fetchone()
        
        if existing:
            product_id = existing['id']
        else:
            cursor.execute(
                "INSERT INTO products (title, keyword) VALUES (?, ?)",
                (title, keyword)
            )
            product_id = cursor.lastrowid
        
        self.conn.commit()
        self.close()
        return product_id
    
    def add_price_data(self, product_id, price_data):
        """가격 정보 추가"""
        cursor = self.connect()
        
        cursor.execute(
            """
            INSERT INTO prices 
            (product_id, shop, price, url, image_url, availability, timestamp)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            """,
            (
                product_id,
                price_data['shop'],
                price_data['price'],
                price_data['url'],
                price_data.get('image_url', ''),
                price_data.get('availability', True),
                datetime.now().isoformat()
            )
        )
        
        self.conn.commit()
        self.close()
    
    def get_product_prices(self, product_id, limit=10):
        """제품의 가격 정보 조회"""
        cursor = self.connect()
        
        cursor.execute(
            """
            SELECT * FROM prices
            WHERE product_id = ?
            ORDER BY timestamp DESC
            LIMIT ?
            """,
            (product_id, limit)
        )
        
        results = [dict(row) for row in cursor.fetchall()]
        self.close()
        return results
    
    def get_price_history(self, product_id, shop=None):
        """제품의 가격 변동 이력 조회"""
        cursor = self.connect()
        
        if shop:
            cursor.execute(
                """
                SELECT timestamp, price FROM prices
                WHERE product_id = ? AND shop = ?
                ORDER BY timestamp ASC
                """,
                (product_id, shop)
            )
        else:
            cursor.execute(
                """
                SELECT timestamp, price, shop FROM prices
                WHERE product_id = ?
                ORDER BY timestamp ASC
                """,
                (product_id,)
            )
        
        results = [dict(row) for row in cursor.fetchall()]
        self.close()
        return results
    
    def get_lowest_price(self, product_id):
        """제품의 현재 최저가 조회"""
        cursor = self.connect()
        
        # 각 쇼핑몰별 최신 가격 중 최저가 찾기
        cursor.execute(
            """
            SELECT p1.* FROM prices p1
            INNER JOIN (
                SELECT shop, MAX(timestamp) as max_time
                FROM prices
                WHERE product_id = ?
                GROUP BY shop
            ) p2 ON p1.shop = p2.shop AND p1.timestamp = p2.max_time
            WHERE p1.product_id = ?
            ORDER BY p1.price ASC
            LIMIT 1
            """,
            (product_id, product_id)
        )
        
        result = cursor.fetchone()
        self.close()
        
        if result:
            return dict(result)
        return None

# notifier.py
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import logging
from utils.config import get_config

logger = logging.getLogger(__name__)

class PriceNotifier:
    """가격 알림 클래스"""
    
    def __init__(self):
        self.config = get_config()
        self.email_config = self.config.get('email', {})
        self.sender_email = self.email_config.get('sender')
        self.smtp_server = self.email_config.get('smtp_server')
        self.smtp_port = self.email_config.get('smtp_port')
        self.smtp_user = self.email_config.get('username')
        self.smtp_password = self.email_config.get('password')
    
    def send_price_alert(self, email, product_title, current_price, product_url, shop_name):
        """가격 알림 이메일 전송"""
        if not all([self.sender_email, self.smtp_server, self.smtp_port, self.smtp_user, self.smtp_password]):
            logger.error("이메일 설정이 완료되지 않았습니다.")
            return False
        
        try:
            # 이메일 메시지 생성
            msg = MIMEMultipart()
            msg['From'] = self.sender_email
            msg['To'] = email
            msg['Subject'] = f"가격 알림: {product_title}"
            
            body = f"""
            <html>
            <body>
                <h2>가격 알림</h2>
                <p>안녕하세요! 관심 상품의 가격이 목표 가격 이하로 떨어졌습니다.</p>
                <p><strong>상품:</strong> {product_title}</p>
                <p><strong>현재 가격:</strong> {current_price:,}원</p>
                <p><strong>쇼핑몰:</strong> {shop_name}</p>
                <p><a href="{product_url}">상품 페이지 바로가기</a></p>
                <p>감사합니다!</p>
            </body>
            </html>
            """
            
            msg.attach(MIMEText(body, 'html'))
            
            # SMTP 서버 연결 및 이메일 전송
            with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
                server.starttls()
                server.login(self.smtp_user, self.smtp_password)
                server.send_message(msg)
            
            logger.info(f"가격 알림 이메일 전송 완료: {email}")
            return True
            
        except Exception as e:
            logger.error(f"이메일 전송 중 오류 발생: {e}")
            return False
    
    def check_price_alerts(self, db_manager):
        """가격 알림 조건 확인 및 알림 전송"""
        cursor = db_manager.connect()
        
        # 활성화된 알림 조회
        cursor.execute(
            """
            SELECT a.id, a.product_id, a.target_price, a.email, p.title
            FROM alerts a
            JOIN products p ON a.product_id = p.id
            WHERE a.is_active = 1
            """
        )
        
        alerts = [dict(row) for row in cursor.fetchall()]
        db_manager.close()
        
        for alert in alerts:
            # 최저가 조회
            lowest_price_data = db_manager.get_lowest_price(alert['product_id'])
            
            if lowest_price_data and lowest_price_data['price'] <= alert['target_price']:
                # 알림 조건 충족
                self.send_price_alert(
                    alert['email'],
                    alert['title'],
                    lowest_price_data['price'],
                    lowest_price_data['url'],
                    lowest_price_data['shop']
                )
                
                # 알림 비활성화 (일회성 알림인 경우)
                cursor = db_manager.connect()
                cursor.execute(
                    "UPDATE alerts SET is_active = 0 WHERE id = ?",
                    (alert['id'],)
                )
                db_manager.conn.commit()
                db_manager.close()
                
                logger.info(f"가격 알림 처리 완료: {alert['title']}, 목표가: {alert['target_price']}, 현재가: {lowest_price_data['price']}")

# main.py
import argparse
import logging
import csv
from datetime import datetime
import os

from scrapers.shop_a_scraper import ShopAScraper
from scrapers.shop_b_scraper import ShopBScraper
from scrapers.shop_c_scraper import ShopCScraper
from database.db_manager import DatabaseManager
from utils.notifier import PriceNotifier
from utils.logger import setup_logger

# 로거 설정
logger = setup_logger('main')

def parse_arguments():
    """명령행 인자 파싱"""
    parser = argparse.ArgumentParser(description='가격 비교 크롤러')
    parser.add_argument('--keyword', '-k', required=True, help='검색 키워드')
    parser.add_argument('--output', '-o', default='output', help='결과 저장 디렉토리')
    parser.add_argument('--notify', '-n', action='store_true', help='가격 알림 활성화')
    parser.add_argument('--email', '-e', help='알림 받을 이메일')
    parser.add_argument('--target-price', '-t', type=int, help='목표 가격')
    return parser.parse_args()

def save_to_csv(results, output_dir, keyword):
    """결과를 CSV 파일로 저장"""
    os.makedirs(output_dir, exist_ok=True)
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    filename = f"{output_dir}/{keyword.replace(' ', '_')}_{timestamp}.csv"
    
    with open(filename, 'w', newline='', encoding='utf-8-sig') as f:
        fieldnames = ['shop', 'title', 'price', 'url', 'image_url', 'availability', 'timestamp']
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(results)
    
    logger.info(f"결과가 {filename}에 저장되었습니다.")
    return filename

def main():
    """메인 함수"""
    args = parse_arguments()
    keyword = args.keyword
    output_dir = args.output
    
    logger.info(f"검색 시작: {keyword}")
    
    # 스크래퍼 초기화
    scrapers = [
        ShopAScraper(),
        ShopBScraper(),
        ShopCScraper()
    ]
    
    # 데이터베이스 관리자 초기화
    db_manager = DatabaseManager()
    
    # 제품 등록
    product_id = db_manager.add_product(f"검색: {keyword}", keyword)
    
    # 모든 스크래퍼에서 결과 수집
    all_results = []
    
    for scraper in scrapers:
        try:
            logger.info(f"{scraper.shop_name} 검색 중...")
            results = scraper.search_product(keyword)
            
            if results:
                logger.info(f"{scraper.shop_name}에서 {len(results)}개 결과 찾음")
                all_results.extend(results)
                
                # 데이터베이스에 결과 저장
                for result in results:
                    db_manager.add_price_data(product_id, result)
            else:
                logger.warning(f"{scraper.shop_name}에서 결과를 찾지 못했습니다.")
        
        except Exception as e:
            logger.error(f"{scraper.shop_name} 검색 중 오류 발생: {e}")
    
    # 결과 정렬 (가격 오름차순)
    all_results.sort(key=lambda x: x['price'] if x['price'] else float('inf'))
    
    # CSV 파일로 저장
    if all_results:
        csv_file = save_to_csv(all_results, output_dir, keyword)
        
        # 최저가 정보 출력
        lowest = all_results[0]
        logger.info(f"최저가 정보:")
        logger.info(f"  쇼핑몰: {lowest['shop']}")
        logger.info(f"  제품명: {lowest['title']}")
        logger.info(f"  가격: {lowest['price']:,}원")
        logger.info(f"  URL: {lowest['url']}")
        
        # 가격 알림 설정
        if args.notify and args.email and args.target_price:
            cursor = db_manager.connect()
            cursor.execute(
                "INSERT INTO alerts (product_id, target_price, email) VALUES (?, ?, ?)",
                (product_id, args.target_price, args.email)
            )
            db_manager.conn.commit()
            db_manager.close()
            
            logger.info(f"가격 알림이 설정되었습니다: {args.email}, 목표가: {args.target_price:,}원")
            
            # 알림 조건 확인
            notifier = PriceNotifier()
            notifier.check_price_alerts(db_manager)
    else:
        logger.warning("검색 결과가 없습니다.")
    
    logger.info("검색 완료")

if __name__ == "__main__":
    main()

# 기본 검색
python main.py --keyword "아이폰 13"

# 결과 저장 디렉토리 지정
python main.py --keyword "아이폰 13" --output "results"

# 가격 알림 설정
python main.py --keyword "아이폰 13" --notify --email "user@example.com" --target-price 800000

# app.py
from flask import Flask, render_template, request, jsonify
from database.db_manager import DatabaseManager
import json
from datetime import datetime

app = Flask(__name__)
db_manager = DatabaseManager()

@app.route('/')
def index():
    """메인 페이지"""
    cursor = db_manager.connect()
    cursor.execute("SELECT * FROM products ORDER BY created_at DESC")
    products = [dict(row) for row in cursor.fetchall()]
    db_manager.close()
    return render_template('index.html', products=products)

@app.route('/product/<int:product_id>')
def product_detail(product_id):
    """제품 상세 페이지"""
    cursor = db_manager.connect()
    
    # 제품 정보 조회
    cursor.execute("SELECT * FROM products WHERE id = ?", (product_id,))
    product = dict(cursor.fetchone())
    
    # 최신 가격 정보 조회
    prices = db_manager.get_product_prices(product_id)
    
    # 가격 변동 이력 조회
    price_history = db_manager.get_price_history(product_id)
    
    # 차트 데이터 준비
    chart_data = {}
    for item in price_history:
        shop = item['shop']
        if shop not in chart_data:
            chart_data[shop] = []
        
        # 날짜 형식 변환
        date = datetime.fromisoformat(item['timestamp']).strftime('%Y-%m-%d')
        chart_data[shop].append({
            'date': date,
            'price': item['price']
        })
    
    db_manager.close()
    
    return render_template(
        'product_detail.html',
        product=product,
        prices=prices,
        chart_data=json.dumps(chart_data)
    )

@app.route('/api/search', methods=['POST'])
def search_api():
    """검색 API"""
    data = request.json
    keyword = data.get('keyword')
    
    if not keyword:
        return jsonify({'error': '검색어가 필요합니다.'}), 400
    
    # 여기서 크롤링 작업을 실행하거나 이미 수집된 데이터를 반환
    # 실제 구현에서는 백그라운드 작업으로 처리하는 것이 좋음
    
    return jsonify({'message': f'"{keyword}" 검색이 시작되었습니다.'}), 202

@app.route('/api/alert', methods=['POST'])
def set_alert():
    """알림 설정 API"""
    data = request.json
    product_id = data.get('product_id')
    email = data.get('email')
    target_price = data.get('target_price')
    
    if not all([product_id, email, target_price]):
        return jsonify({'error': '모든 필드가 필요합니다.'}), 400
    
    cursor = db_manager.connect()
    cursor.execute(
        "INSERT INTO alerts (product_id, target_price, email) VALUES (?, ?, ?)",
        (product_id, target_price, email)
    )
    db_manager.conn.commit()
    db_manager.close()
    
    return jsonify({'message': '알림이 설정되었습니다.'}), 201

if __name__ == '__main__':
    app.run(debug=True)