코딩

챗GPT에게 주식 검색기를 만들어 달라고 해봤습니다 [기관투자자]

capstone012 2025. 9. 11. 11:08
반응형
SMALL

 

챗GPT에게 주식 검색기를 만들어 달라고 해봤습니다 [기관투자자]

ChatGPT를 활용한 한국 주식 검색기 제작 가이드

📑 목차

  1. ChatGPT와 주식 검색기란?
  2. 사용할 프로그래밍 언어 및 환경
  3. 간단한 주식 검색 예제
  4. 고급 검색 조건 설정
  5. 실시간 검색 및 API 활용
  6. 마크 미너 비니 트렌드 템플릿 적용
  7. 실행 가능 체크리스트
  8. 주의사항 및 팁
  9. 참고 사이트
  10. 참고문헌

1. ChatGPT와 주식 검색기란?

  • ChatGPT: AI 언어 모델, 자연어 입력을 코드로 변환 가능.
  • 주식 검색기: 조건에 맞는 주식을 자동으로 검색/필터링하는 프로그램.
  • ChatGPT에게 조건을 말하면 Python 코드로 작성해 줌.
  • 단, 실제 종목 가격을 실시간으로 가져오려면 증권사 API 필요.

2. 사용할 프로그래밍 언어 및 환경

  • Python 추천 (주식 데이터 처리와 자동화에 적합).
  • 필요 라이브러리:
    • pandas (데이터프레임 처리)
    • yfinance 또는 증권사 API (kiwoom 등)
    • matplotlib (차트 시각화, 선택적)

어려운 단어 설명

  • API: 다른 서비스에서 데이터를 가져오거나 기능을 이용할 수 있는 통신 규약.
  • 이평선: 주가 이동평균선, 특정 기간 동안 주가 평균을 선으로 연결한 것.
  • 양봉: 시가보다 종가가 높은 날의 봉차트 표시.

3. 간단한 주식 검색 예제

✅ Python으로 작성 가능:

 
import pandas as pd # 종목 리스트 정의 stocks = ['005930.KS', '000660.KS', '035420.KS'] # 종가 데이터 예시 (20일간) data = { '005930.KS':[80000,81000,...], '000660.KS':[100000,102000,...], '035420.KS':[400000,405000,...] } df = pd.DataFrame(data) # 최근 20일 종가 중 최고 종목 찾기 max_close = df.iloc[-1] == df.max().max() print(df.columns[max_close])
  • 실행 시 20일 최고 종가 종목 출력

4. 고급 검색 조건 설정

  • 예:
    • 전일 대비 3% 이상 상승
    • 양봉이 5일 이평선 > 2일 이평선
    • 거래량 100만 주 이상

✅ Python 예제:

 
# 예시 조건 코드 filtered_stocks = df[(df['오늘종가'] > df['전일종가']*1.03) & (df['양봉'] == True) & (df['5일이평'] > df['2일이평']) & (df['거래량'] > 1_000_000)] print(filtered_stocks)
  • ChatGPT가 주석과 함께 깔끔하게 코드 작성 가능

5. 실시간 검색 및 API 활용

  • Python만으로 실시간 데이터 조회는 불가
  • 방법:
    • 키움증권 Open API 사용 (예시 링크)
    • HTS/MTS 활용 가능

참고: 무료 API는 제공량 제한이 있을 수 있음.


6. 마크 미너 비니 트렌드 템플릿 적용

  • ChatGPT에게 트렌드 템플릿 조건 전달 → Python 코드로 구현 가능
  • 키움증권 조건식 설정 → 검색기 활용 가능
  • API와 연동하면 자동 알람, 종목 추천 가능

7. 실행 가능 체크리스트

🔲 Python 설치 (3.10 이상 권장)
🔲 필요한 라이브러리 설치 (pip install pandas yfinance)
🔲 종목 리스트 준비
🔲 ChatGPT에게 검색 조건 전달 → 코드 생성
🔲 코드 실행 → 결과 확인
🔲 API 연동 시 키움증권 계정/인증
🔲 고급 템플릿 적용 시 트렌드 조건 정의


8. 주의사항 및 팁

  • ChatGPT가 코드를 작성해도 실제 투자 판단은 본인 책임
  • 증권사 API 사용 시 계좌 정보 보호 필수
  • 실시간 검색은 유료 API 또는 HTS/MTS 필요
  • ChatGPT는 아이디어 구현 및 코드 작성 보조용

9. 참고 사이트


10. 참고문헌

  • ChatGPT OpenAI API 문서
  • Python Pandas Documentation
  • 키움증권 Open API 개발자 가이드
  • YouTube 영상 (GPT 주식 검색기 실습)

💡 Tip: 실행 가능한 영역(검색기 코드, API 연동, 종목 필터링 등)은 사각형 박스나 Jupyter Notebook에 직접 작성해 두면 재사용 가능.

 

 

 

이 가이드는 프로그래밍 지식이 부족하더라도 챗GPT의 도움을 받아 원하는 조건의 주식 종목을 찾는 과정을 단계별로 설명하고 있습니다. 투자 아이디어를 실제 검색기로 구현하고 싶은 분들에게 유용한 정보입니다.

목차

  1. 챗GPT를 활용한 주식 검색기란?
  2. 간단한 주식 검색기 만들기
  3. 복합적인 조건의 검색기 만들기
  4. 실시간 데이터 연동하기
  5. 전문적인 검색기 제작: 마크 미너비니의 트렌드 템플릿
  6. 참고 자료

1. 챗GPT를 활용한 주식 검색기란?

**챗GPT(ChatGPT)**는 사용자의 질문에 맞춰 텍스트를 생성하는 인공지능 모델입니다. 이를 활용하면 자연어로 주식 검색에 대한 조건을 설명하고, 챗GPT가 이에 맞는 파이썬(Python) 코드를 작성해주는 방식으로 주식 검색기를 만들 수 있습니다.

  • 파이썬(Python): 배우기 쉽고 다양한 분야에서 활용되는 프로그래밍 언어입니다. 주식 데이터를 다루는 라이브러리(Library)가 잘 구축되어 있어 주식 검색기 제작에 많이 사용됩니다.
  • API(Application Programming Interface): 애플리케이션과 프로그램 간에 데이터를 주고받을 수 있는 통신 규칙입니다. 주식 API를 이용하면 실시간 주가 정보를 가져올 수 있습니다.

2. 간단한 주식 검색기 만들기

<pre><code>✅ 실행 절차

  1. 챗GPT에게 요청하기: 챗GPT에게 간단한 검색 조건을 설명하고 파이썬 코드를 요청합니다.
    • 요청 예시: "한국 주식 중에서 오늘 종가가 20일 중 최고 종가인 종목을 찾는 파이썬 검색기를 만들어 줘."
  2. 코드 확인 및 실행: 챗GPT가 작성해 준 파이썬 코드를 복사하여 구글 코랩이나 파이썬 개발 환경에서 실행합니다.
    • 팁: 코드 실행 시 에러가 발생하면, 에러 메시지를 챗GPT에게 다시 질문하여 해결 방법을 찾을 수 있습니다. </code></pre>

3. 복합적인 조건의 검색기 만들기

단순한 조건 외에 여러 가지 기술적 지표를 결합하여 더 정교한 검색기를 만들 수 있습니다.

<pre><code>✅ 실행 절차

  1. 챗GPT에게 상세 조건 요청하기: 여러 가지 복합적인 조건을 명확하게 제시하여 요청합니다.
    • 요청 예시: "전일 종가 대비 3% 이상 상승하고, 양봉이며, 5일 이동평균선이 20일 이동평균선 위에 있고, 거래량이 100만 주 이상인 한국 주식 종목을 찾는 파이썬 코드를 만들어 줘."
  2. 코드 수정 및 실행: 챗GPT가 작성한 코드를 실행하고, 결과로 나온 종목 리스트를 확인합니다. </code></pre>

4. 실시간 데이터 연동하기

일반적인 검색기는 과거 데이터를 기반으로 하지만, 실시간으로 변동하는 주가를 반영하려면 증권사 API를 활용해야 합니다.

  • 증권사 HTS/MTS: 증권사에서 제공하는 주식 거래 프로그램입니다. 키움증권 등 주요 증권사에서는 API를 제공하여 사용자가 직접 데이터를 연동할 수 있게 해줍니다.

<pre><code>✅ 실행 절차

  1. 챗GPT에게 API 활용 요청: 챗GPT에게 특정 증권사 API를 이용해 실시간 데이터를 가져오는 코드를 요청합니다.
    • 요청 예시: "키움증권 API를 활용해서 실시간으로 주식 종목을 검색하는 파이썬 코드를 작성해 줘."
  2. API 연동 및 활용: 챗GPT가 제공하는 코드와 증권사 API 문서를 참고하여 실제 시스템에 연동합니다. 이 과정은 별도의 로그인 및 인증 절차가 필요합니다. </code></pre>

5. 전문적인 검색기 제작: 마크 미너비니의 트렌드 템플릿

마크 미너비니의 '트렌드 템플릿'은 주식 추세 분석에 사용되는 유명한 기법입니다. 챗GPT에게 이 복잡한 개념을 설명하고, 이를 검색 조건으로 만들어 달라고 요청할 수도 있습니다.

<pre><code>✅ 실행 절차

  1. 개념 설명 및 코드 요청:
    • 챗GPT에게 "마크 미너비니의 트렌드 템플릿을 주식 검색기로 만들어 줄 수 있어?"라고 요청합니다.
    • "이거를 캐움증권 영웅문 검색기로 만들어 줄 수 있어?" 라고 요청
  2. 증권사 조건식으로 변환: 챗GPT가 알려주는 코드를 실제 증권사 HTS의 '조건식'으로 변환하는 방법을 문의할 수 있습니다.
    • 챗GPT는 각 조건에 대한 자세한 설정 방법을 알려주므로, 이를 참고하여 HTS에서 직접 검색식을 설정하면 됩니다. </code></pre>

6. 참고 자료

  • 영상 링크: (525) 챗GPT에게 주식 검색기를 만들어 달라고 해봤습니다 - YouTube
  • 추가 참고문헌:
    • Minervini, M. (2013). Trade Like a Stock Market Wizard. McGraw-Hill Education. (마크 미너비니의 트렌드 템플릿 관련 서적)
    • Python. (2025). Python 공식 문서. (파이썬 기본 문법 및 사용법)
    • Kiwoom Securities. (2025). 키움증권 API 가이드. (키움증권 API 공식 문서)

 

 

 

[마크 비너비니의 트랜드 탬플릿]
 

Mark Minervini의 Trend Template(트렌드 템플릿)을 한국(코스피/코스닥) 종목에 적용해 자동으로 스캔하는 **파이썬 검색기(스크립트)**를 만들어 드립니다.
아래 코드는 Minervini가 공개한 핵심 조건들을 반영하여 한국 거래소 종목을 필터링합니다(이후 필요하면 조건을 더 엄격히 조정 가능합니다).

먼저 요약 — 적용한 주요 Trend Template 조건 (참고자료 기반):

  1. 현재 주가가 150일 & 200일 이동평균 위에 있을 것. TradingView+1
  2. 150일 MA > 200일 MA. Deepvue
  3. 200일 MA는 최근 1개월(약 20거래일) 동안 상승 추세일 것. stockfetcher.com
  4. 50일 MA가 150일 및 200일 MA 위에 있을 것, 그리고 현재 주가가 50일 MA 위에 있을 것. Deepvue+1
  5. (선택 필터) 52주 저점 대비 최소 +30%, 52주 고점 대비 25% 이내 (고가 근접 조건 — 옵션). 차트밀+1
  6. (선택 필터) RS (상대강도) — 52주 수익률 기준 상위 상위 30% (RS >= 70). (시장내 상대순위로 계산)
[영웅문 HTS에서 조건 검색기를 생성]

영웅문 HTS (키움증권 HTS) 안에는 “조건검색기(조건식)” 기능이 있고, 거기서 직접 **조건식(검색식)**을 만들 수 있습니다. 제가 파이썬으로 만든 스캐너 코드를 그대로 붙여넣을 수는 없지만, 같은 로직을 HTS 조건검색식으로 변환해 드릴 수 있습니다.


📌 1. 영웅문 HTS 조건검색기 진입

  1. HTS 실행 → 메뉴 상단 종합차트/조건검색 → 조건검색(0121) 선택
  2. 좌측 메뉴에서 조건검색기 클릭 → 새 조건식 만들기

📌 2. Mark Minervini Trend Template 조건을 HTS 언어로 변환

Minervini의 트렌드 템플릿 핵심 조건을 영웅문 조건식으로 옮기면 아래와 같습니다:

  1. 현재가 > 150일 이동평균선
    • 항목: [가격] → 종가 → 150일 이동평균 → 상향돌파 or 위에 위치
    • 조건: 현재가 ≥ 150일 이동평균
  2. 현재가 > 200일 이동평균선
    • 항목: 동일하게 200일 이동평균 선택
    • 조건: 현재가 ≥ 200일 이동평균
  3. 150일 이동평균 > 200일 이동평균
    • 항목: 이동평균 비교
    • 조건: 150일 이동평균 ≥ 200일 이동평균
  4. 200일 이동평균이 상승 중
    • 항목: [이동평균선 기울기]
    • 조건: 200일 이동평균선 기울기 > 0 (또는 최근 20일 상승 조건 선택)
  5. 50일 이동평균 > 150일 & 200일 이동평균
    • 조건식 두 개 추가:
      • 50일 이동평균 ≥ 150일 이동평균
      • 50일 이동평균 ≥ 200일 이동평균
  6. 현재가 > 50일 이동평균선
    • 항목: 현재가 ≥ 50일 이동평균
  7. (선택 필터) 52주 저점 대비 +30% 이상
    • 항목: [52주 신고/신저가]
    • 조건: (현재가 - 52주 최저가) / 52주 최저가 ≥ 30%
  8. (선택 필터) 52주 고점에서 25% 이내
    • 조건: (52주 최고가 - 현재가) / 52주 최고가 ≤ 25%

📌 3. 조건식 조합

영웅문 조건검색기에서 위 조건들을 **모두 “AND”**로 묶어서 하나의 조건식을 생성하면 됩니다.
예시 이름: Minervini Trend Template


📌 4. 실행

  1. 조건식 저장 후 → 실시간 조건검색(0124) 또는 조건검색 자동매매(0126) 메뉴에서 실행
  2. 장중 실시간으로 해당 조건을 만족하는 종목이 검색됨

📌 5. 추가 팁

  • 거래량 필터: “최근 20일 평균거래량 대비 1.5배 이상” 같은 조건을 추가하면 실질적 매매 가능성이 높은 종목만 추려낼 수 있습니다.
  • 시가총액 필터: 너무 작은 종목을 제외하려면 시총 1,000억 이상 조건을 추가할 수 있습니다.
  • 조건식 공유: 조건검색기에서는 직접 저장한 조건식을 “내 조건식 불러오기”로 쉽게 다시 적용 가능합니다.

 

[ 실제 영웅문 조건검색식 스크린샷처럼 하나하나 메뉴 순서로 생성]

 

영웅문 HTS에서 조건검색기를 직접 클릭해 들어가서 Minervini 트렌드 템플릿을 구현하는 방법을 실제 메뉴 순서 그대로 정리해 드릴게요.


📌 영웅문 HTS 조건검색기 – Minervini Trend Template 만들기

① 조건검색기 열기

  1. 영웅문 HTS 실행
  2. 상단 메뉴에서 [조건검색] (0121) 선택
  3. 왼쪽 메뉴에서 [조건식 관리] → [새 조건식 만들기] 클릭

② 조건식 세부 설정 (하나씩 추가)

1. 현재가 > 150일 이동평균

  • 메뉴: [가격/이동평균] → [현재가와 이동평균 비교]
  • 조건: 현재가 ≥ 150일 이동평균선

2. 현재가 > 200일 이동평균

  • 메뉴: [가격/이동평균] → [현재가와 이동평균 비교]
  • 조건: 현재가 ≥ 200일 이동평균선

3. 150일 이동평균 > 200일 이동평균

  • 메뉴: [가격/이동평균] → [이동평균선간 비교]
  • 조건: 150일 이동평균 ≥ 200일 이동평균

4. 200일 이동평균선 상승 중

  • 메뉴: [추세/기울기] → [이동평균선 기울기]
  • 조건: 200일 이동평균 기울기 > 0
    (또는 → [최근 N일 전 대비 상승] 선택, N=20일)

5. 50일 이동평균 > 150일 이동평균

  • 메뉴: [가격/이동평균] → [이동평균선간 비교]
  • 조건: 50일 이동평균 ≥ 150일 이동평균

6. 50일 이동평균 > 200일 이동평균

  • 메뉴: 동일
  • 조건: 50일 이동평균 ≥ 200일 이동평균

7. 현재가 > 50일 이동평균

  • 메뉴: [가격/이동평균] → [현재가와 이동평균 비교]
  • 조건: 현재가 ≥ 50일 이동평균선

8. (선택) 52주 저점 대비 +30% 이상

  • 메뉴: [고저가/52주] → [52주 저점 대비 상승률]
  • 조건: ≥ 30%

9. (선택) 52주 고점에서 -25% 이내

  • 메뉴: [고저가/52주] → [52주 고점 대비 하락률]
  • 조건: ≤ 25%

③ 조건식 저장

  1. 모든 조건을 추가했다면 [조건식 이름 입력] → “Minervini Trend Template”
  2. 저장 버튼 클릭

④ 조건검색 실행

  1. 메뉴: [실시간 조건검색 (0124)]
  2. 만든 조건식 “Minervini Trend Template” 불러오기
  3. 실시간으로 해당 조건 만족 종목이 검색됨

📌 추가 팁

  • 거래량 필터 추가: [거래량] → 20일 평균 거래량 대비 ≥ 150% (유동성 확보)
  • 시가총액 필터 추가: [재무/기업정보] → 시가총액 ≥ 1,000억
  • 자동매매 연동: 조건검색 → [조건검색 자동매매 (0126)] 메뉴에서 연동 가능

 

 

 

ChatGPT로 주식 검색기 만들기 완전 가이드

목차

  1. 개요 및 활용 가능성
  2. 기본 주식 검색기 만들기
  3. 고급 조건 검색기 개발
  4. 실시간 데이터 연동 방법
  5. 전문 투자 전략 구현
  6. 키움증권 API 연동
  7. 주의사항 및 한계
  8. 참고 자료 및 추가 학습

1. 개요 및 활용 가능성

ChatGPT로 주식 검색기를 만드는 이유

**주식 검색기(Stock Screener)**는 특정 조건을 만족하는 주식을 자동으로 찾아주는 도구입니다. ChatGPT를 활용하면 복잡한 프로그래밍 지식 없이도 맞춤형 주식 검색기를 빠르게 개발할 수 있습니다.

주요 장점

  • 빠른 개발: 몇 분 만에 검색기 코드 생성
  • 맞춤형 조건: 개인의 투자 전략에 맞는 조건 설정
  • 코드 해석: 주석을 통한 친절한 설명 제공
  • 오류 수정: 실시간 디버깅 지원

용어 설명

  • 종가: 하루 거래가 마감되는 시점의 주식 가격
  • 양봉: 시가보다 종가가 높은 상태 (주가 상승)
  • 이평선: 일정 기간 동안의 평균 주가를 선으로 연결한 기술적 지표
  • 거래량: 특정 기간 동안 거래된 주식의 총 수량
  • API: 프로그램이 다른 프로그램과 소통할 수 있게 해주는 인터페이스

2. 기본 주식 검색기 만들기

📋 기본 요구사항

필요한 도구

  • ChatGPT 계정
  • Python 실행 환경 (Google Colab 권장)
  • 기본적인 Python 라이브러리

🚀 첫 번째 검색기: 20일 최고가 돌파 종목 찾기

ChatGPT 프롬프트 예시

 
한국 주식 중에서 오늘 종가가 20일 중 최고 종가인 종목 찾는 검색기 만들어 줘

예상 결과 코드 (ChatGPT 생성)

 
python
import yfinance as yf
import pandas as pd
from datetime import datetime, timedelta

def find_stocks_at_20day_high():
    # 한국 주요 종목 리스트 (확장 가능)
    korean_stocks = [
        '005930.KS',  # 삼성전자
        '000660.KS',  # SK하이닉스
        '035420.KS',  # NAVER
        '035720.KS',  # 카카오
        '051910.KS',  # LG화학
        '006400.KS',  # 삼성SDI
        '207940.KS',  # 삼성바이오로직스
        '068270.KS',  # 셀트리온
        '028260.KS',  # 삼성물산
        '105560.KS'   # KB금융
    ]
    
    stocks_at_high = []
    
    for stock in korean_stocks:
        try:
            # 21일간 데이터 가져오기 (20일 + 오늘)
            data = yf.download(stock, period='21d', interval='1d')
            
            if len(data) >= 20:
                # 최근 20일간의 최고가
                high_20days = data['Close'][:-1].max()  # 오늘 제외
                today_close = data['Close'][-1]  # 오늘 종가
                
                # 오늘 종가가 20일 최고가인지 확인
                if today_close >= high_20days:
                    stock_info = {
                        'Symbol': stock,
                        'Name': stock.replace('.KS', ''),
                        'Today_Close': today_close,
                        '20Day_High': high_20days,
                        'Date': data.index[-1].strftime('%Y-%m-%d')
                    }
                    stocks_at_high.append(stock_info)
                    
        except Exception as e:
            print(f"Error processing {stock}: {e}")
    
    return pd.DataFrame(stocks_at_high)

# 실행
result = find_stocks_at_20day_high()
print("20일 최고가 돌파 종목:")
print(result)

🔧 코드 실행 및 수정

단계별 실행 방법

 
1. Google Colab 접속 (colab.research.google.com)
2. 새 노트북 생성
3. 위 코드를 셀에 복사
4. 필요 라이브러리 설치:
   !pip install yfinance pandas
5. 코드 실행 (Shift + Enter)

일반적인 오류 및 해결방법

 
python
# 오류 1: 모듈이 없을 때
!pip install yfinance pandas matplotlib

# 오류 2: 데이터가 없을 때
# 종목 코드 확인 및 수정 필요

# 오류 3: 네트워크 오류
import time
time.sleep(1)  # 요청 간 간격 추가

3. 고급 조건 검색기 개발

📊 복합 조건 검색기

향상된 프롬프트

 
한국 주식 중에서 다음 조건을 모두 만족하는 종목을 찾아줘:
1. 전일 종가 대비 3% 이상 상승
2. 양봉(시가 < 종가)
3. 5일 이평선이 20일 이평선 위에 있음
4. 거래량이 100만 주 이상

고급 검색기 코드 예시

 
python
import yfinance as yf
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def advanced_stock_screener():
    """
    고급 조건을 만족하는 주식 검색기
    """
    # KOSPI 200 주요 종목 (실제로는 더 많은 종목 필요)
    korean_stocks = [
        '005930.KS', '000660.KS', '035420.KS', '035720.KS',
        '051910.KS', '006400.KS', '207940.KS', '068270.KS',
        '028260.KS', '105560.KS', '055550.KS', '096770.KS',
        '003670.KS', '017670.KS', '034730.KS', '018260.KS'
    ]
    
    filtered_stocks = []
    
    for stock in korean_stocks:
        try:
            # 30일간 데이터 가져오기 (이평선 계산을 위해)
            data = yf.download(stock, period='30d', interval='1d')
            
            if len(data) < 25:  # 데이터가 충분하지 않으면 스킵
                continue
                
            # 현재 데이터
            current_close = data['Close'][-1]
            previous_close = data['Close'][-2]
            current_open = data['Open'][-1]
            current_volume = data['Volume'][-1]
            
            # 조건 1: 전일 대비 3% 이상 상승
            price_change_pct = ((current_close - previous_close) / previous_close) * 100
            condition_1 = price_change_pct >= 3.0
            
            # 조건 2: 양봉 (시가 < 종가)
            condition_2 = current_open < current_close
            
            # 조건 3: 5일 이평선이 20일 이평선 위에 있음
            ma_5 = data['Close'][-5:].mean()
            ma_20 = data['Close'][-20:].mean()
            condition_3 = ma_5 > ma_20
            
            # 조건 4: 거래량이 100만 주 이상
            condition_4 = current_volume >= 1000000
            
            # 모든 조건을 만족하는 경우
            if all([condition_1, condition_2, condition_3, condition_4]):
                stock_info = {
                    'Symbol': stock,
                    'Current_Price': round(current_close, 0),
                    'Price_Change_%': round(price_change_pct, 2),
                    'Volume_Million': round(current_volume / 1000000, 2),
                    'MA_5': round(ma_5, 0),
                    'MA_20': round(ma_20, 0),
                    'Is_Bullish_Candle': condition_2,
                    'Date': data.index[-1].strftime('%Y-%m-%d')
                }
                filtered_stocks.append(stock_info)
                
        except Exception as e:
            print(f"Error processing {stock}: {e}")
            continue
    
    return pd.DataFrame(filtered_stocks)

# 실행
print("고급 조건 검색 결과:")
results = advanced_stock_screener()
if not results.empty:
    print(results)
else:
    print("조건을 만족하는 종목이 없습니다.")

📈 결과 해석 및 시각화

결과 시각화 코드

 
python
import matplotlib.pyplot as plt
import seaborn as sns

def visualize_results(df):
    """
    검색 결과 시각화
    """
    if df.empty:
        print("시각화할 데이터가 없습니다.")
        return
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 10))
    
    # 1. 상승률 분포
    axes[0, 0].hist(df['Price_Change_%'], bins=10, alpha=0.7)
    axes[0, 0].set_title('Price Change Distribution (%)')
    axes[0, 0].set_xlabel('Change %')
    axes[0, 0].set_ylabel('Count')
    
    # 2. 거래량 분포
    axes[0, 1].hist(df['Volume_Million'], bins=10, alpha=0.7)
    axes[0, 1].set_title('Volume Distribution (Million Shares)')
    axes[0, 1].set_xlabel('Volume (M)')
    axes[0, 1].set_ylabel('Count')
    
    # 3. 가격대 분포
    axes[1, 0].hist(df['Current_Price'], bins=10, alpha=0.7)
    axes[1, 0].set_title('Price Distribution')
    axes[1, 0].set_xlabel('Price (KRW)')
    axes[1, 0].set_ylabel('Count')
    
    # 4. 이평선 관계
    axes[1, 1].scatter(df['MA_20'], df['MA_5'])
    axes[1, 1].plot([df['MA_20'].min(), df['MA_20'].max()], 
                    [df['MA_20'].min(), df['MA_20'].max()], 'r--')
    axes[1, 1].set_title('MA5 vs MA20')
    axes[1, 1].set_xlabel('MA20')
    axes[1, 1].set_ylabel('MA5')
    
    plt.tight_layout()
    plt.show()

# 실행
visualize_results(results)

4. 실시간 데이터 연동 방법

🔄 실시간 데이터의 한계와 대안

yfinance의 한계

yfinance는 실시간 데이터를 제공하지 않으며, 보통 15-20분 지연된 데이터를 제공합니다. 실시간 데이터가 필요한 경우 다음 방법들을 고려해야 합니다.

📡 실시간 데이터 소스 옵션

1. 키움증권 OpenAPI

 
python
# 키움증권 API 연동 예시 (키움증권 계좌 필요)
import sys
from PyQt5.QtWidgets import QApplication
import win32com.client

class KiwoomAPI:
    def __init__(self):
        self.ocx = win32com.client.Dispatch("KHOPENAPI.KHOpenAPICtrl.1")
        
    def get_real_price(self, stock_code):
        """실시간 주가 조회"""
        # 키움증권 API 호출 로직
        pass
    
    def screen_stocks_realtime(self, conditions):
        """실시간 주식 스크리닝"""
        # 실시간 조건 검색 로직
        pass

2. 웹 스크래핑 방법

 
python
import requests
from bs4 import BeautifulSoup
import time

def get_stock_price_naver(stock_code):
    """
    네이버 금융에서 주가 정보 가져오기
    """
    url = f"https://finance.naver.com/item/main.nhn?code={stock_code}"
    
    try:
        response = requests.get(url)
        soup = BeautifulSoup(response.content, 'html.parser')
        
        # 현재가 추출
        price_element = soup.find('p', class_='no_today')
        if price_element:
            price = price_element.find('span', class_='blind').text
            return int(price.replace(',', ''))
    except Exception as e:
        print(f"Error fetching data for {stock_code}: {e}")
        return None

# 사용 예시
samsung_price = get_stock_price_naver('005930')
print(f"삼성전자 현재가: {samsung_price:,}원")

⚠️ 주의사항: 웹 스크래핑은 웹사이트의 이용약관을 확인하고 과도한 요청을 피해야 합니다.

🏢 증권사별 API 및 HTS 활용

주요 증권사 API

 
1. 키움증권 OpenAPI+
   - 무료 제공 (키움증권 계좌 필요)
   - 실시간 데이터 제공
   - Python, C++ 지원

2. 이베스트투자증권 xingAPI
   - 유료/무료 옵션
   - REST API 제공
   - 다양한 언어 지원

3. 한국투자증권 KIS Developers
   - REST API 제공
   - 모의투자 환경 지원
   - 개발자 친화적

5. 전문 투자 전략 구현

📚 마크 미너비니(Mark Minervini) 트렌드 템플릿

트렌드 템플릿이란?

마크 미너비니의 트렌드 템플릿은 성장주를 선별하는 8가지 조건으로 구성된 체계적인 주식 선별 방법입니다.

🎯 트렌드 템플릿 8가지 조건

ChatGPT 프롬프트

 
마크 미너비니의 트렌드 템플릿 8가지 조건을 모두 만족하는 한국 주식을 찾는 검색기를 만들어 줘

트렌드 템플릿 구현 코드

 
python
import yfinance as yf
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def minervini_trend_template():
    """
    마크 미너비니 트렌드 템플릿 조건:
    1. 현재가가 150일, 200일 이동평균선 위에 있을 것
    2. 150일 이동평균선이 200일 이동평균선 위에 있을 것  
    3. 200일 이동평균선이 최소 1개월간 상승 추세일 것
    4. 50일 이동평균선이 150일, 200일 이동평균선 위에 있을 것
    5. 현재가가 50일 이동평균선 위에 있을 것
    6. 현재가가 52주 최고가의 30% 이내에 있을 것
    7. 현재가가 52주 최저가보다 최소 25% 이상 높을 것
    8. IBD RS Rating이 70 이상 (상대적 강도 - 한국에서는 대체 지표 사용)
    """
    
    korean_stocks = [
        '005930.KS', '000660.KS', '035420.KS', '035720.KS',
        '051910.KS', '006400.KS', '207940.KS', '068270.KS',
        '028260.KS', '105560.KS', '055550.KS', '096770.KS'
    ]
    
    trend_stocks = []
    
    for stock in korean_stocks:
        try:
            # 1년간 데이터 가져오기
            data = yf.download(stock, period='1y', interval='1d')
            
            if len(data) < 200:
                continue
            
            current_price = data['Close'][-1]
            
            # 이동평균선 계산
            ma_50 = data['Close'][-50:].mean()
            ma_150 = data['Close'][-150:].mean()
            ma_200 = data['Close'][-200:].mean()
            
            # 52주 최고가/최저가
            high_52w = data['Close'][-252:].max() if len(data) >= 252 else data['Close'].max()
            low_52w = data['Close'][-252:].min() if len(data) >= 252 else data['Close'].min()
            
            # 200일 이동평균선 1개월 전 값
            ma_200_1m_ago = data['Close'][-220:-200].mean() if len(data) >= 220 else ma_200
            
            # 8가지 조건 확인
            conditions = {
                '1_above_ma150_200': current_price > ma_150 and current_price > ma_200,
                '2_ma150_above_ma200': ma_150 > ma_200,
                '3_ma200_uptrend': ma_200 > ma_200_1m_ago,
                '4_ma50_above_ma150_200': ma_50 > ma_150 and ma_50 > ma_200,
                '5_above_ma50': current_price > ma_50,
                '6_near_52w_high': current_price >= (high_52w * 0.7),  # 52주 최고가의 70% 이상
                '7_above_52w_low': current_price >= (low_52w * 1.25),  # 52주 최저가의 125% 이상
                '8_relative_strength': True  # 한국에서는 계산이 복잡하여 생략 또는 대체 지표 사용
            }
            
            # 모든 조건을 만족하는지 확인
            all_conditions_met = all(conditions.values())
            
            if all_conditions_met:
                stock_info = {
                    'Symbol': stock,
                    'Current_Price': round(current_price, 0),
                    'MA_50': round(ma_50, 0),
                    'MA_150': round(ma_150, 0),
                    'MA_200': round(ma_200, 0),
                    '52W_High': round(high_52w, 0),
                    '52W_Low': round(low_52w, 0),
                    'Distance_from_High_%': round(((current_price / high_52w) - 1) * 100, 2),
                    'Gain_from_Low_%': round(((current_price / low_52w) - 1) * 100, 2),
                    'Conditions_Met': sum(conditions.values()),
                    'Date': data.index[-1].strftime('%Y-%m-%d')
                }
                trend_stocks.append(stock_info)
                
        except Exception as e:
            print(f"Error processing {stock}: {e}")
            continue
    
    return pd.DataFrame(trend_stocks)

# 실행
print("마크 미너비니 트렌드 템플릿 조건을 만족하는 종목:")
trend_results = minervini_trend_template()
print(trend_results)

📊 결과 분석 및 백테스팅

성과 분석 코드

 
python
def analyze_trend_template_performance(df):
    """
    트렌드 템플릿 결과 분석
    """
    if df.empty:
        print("분석할 데이터가 없습니다.")
        return
    
    print("=== 트렌드 템플릿 분석 결과 ===")
    print(f"총 조건 만족 종목 수: {len(df)}개")
    print(f"평균 52주 최고가 대비 거리: {df['Distance_from_High_%'].mean():.2f}%")
    print(f"평균 52주 최저가 대비 상승률: {df['Gain_from_Low_%'].mean():.2f}%")
    print(f"가격대별 분포:")
    print(f"  - 10만원 이하: {len(df[df['Current_Price'] <= 100000])}개")
    print(f"  - 10-50만원: {len(df[(df['Current_Price'] > 100000) & (df['Current_Price'] <= 500000)])}개")
    print(f"  - 50만원 이상: {len(df[df['Current_Price'] > 500000])}개")

analyze_trend_template_performance(trend_results)

6. 키움증권 API 연동

💼 키움증권 OpenAPI+ 설정

필요한 준비사항

 
1. 키움증권 계좌 개설
2. OpenAPI+ 신청 (무료)
3. KOA Studio 설치
4. Python 환경 설정 (32bit Python 필요)

🛠️ 키움 API 기본 설정

설치 및 초기 설정

 
python
# 필요한 패키지 설치 (32bit Python에서만 작동)
# pip install pyqt5
# pip install pywin32

import sys
from PyQt5.QtWidgets import *
from PyQt5.QAxContainer import *
from PyQt5.QtCore import *
import time
import pandas as pd

class KiwoomAPI(QMainWindow):
    def __init__(self):
        super().__init__()
        self.kiwoom = QAxWidget("KHOPENAPI.KHOpenAPICtrl.1")
        self.kiwoom.OnEventConnect.connect(self.login_slot)
        
        # 데이터 저장용
        self.stock_data = {}
        
    def login_slot(self, err_code):
        """로그인 결과 처리"""
        if err_code == 0:
            print("로그인 성공")
        else:
            print("로그인 실패")
    
    def login(self):
        """키움증권 로그인"""
        ret = self.kiwoom.dynamicCall("CommConnect()")
        if ret == 0:
            print("로그인 창이 열립니다.")
    
    def get_stock_price(self, stock_code):
        """개별 종목 현재가 조회"""
        self.kiwoom.dynamicCall("SetInputValue(QString, QString)", "종목코드", stock_code)
        self.kiwoom.dynamicCall("CommRqData(QString, QString, int, QString)", 
                               "주식기본정보", "opt10001", 0, "0101")
    
    def condition_search(self, condition_name, condition_index):
        """조건검색 실행"""
        ret = self.kiwoom.dynamicCall("SendCondition(QString, QString, int, int)",
                                     "0156", condition_name, condition_index, 1)
        return ret

# 사용 예시
if __name__ == "__main__":
    app = QApplication(sys.argv)
    kiwoom = KiwoomAPI()
    kiwoom.login()
    app.exec_()

📋 조건검색식 설정 방법

키움 HTS에서 조건검색식 만들기

 
1. 키움 HTS 로그인
2. [조건검색] → [조건검색식 편집기] 메뉴
3. 새 조건식 작성:
   - 조건명: "트렌드템플릿"
   - 조건 설정:
     * 현재가 > 이동평균(50)
     * 이동평균(50) > 이동평균(150)
     * 이동평균(150) > 이동평균(200)
     * 현재가 > 52주최고가 * 0.7
     * 현재가 > 52주최저가 * 1.25
4. 조건식 저장 및 등록

API로 조건검색 실행

 
python
def run_condition_search():
    """
    저장된 조건검색 실행
    """
    app = QApplication(sys.argv)
    kiwoom = KiwoomAPI()
    
    # 로그인 후 조건검색 실행
    kiwoom.login()
    time.sleep(5)  # 로그인 대기
    
    # 조건검색 실행 (조건식 인덱스는 HTS에서 확인)
    result = kiwoom.condition_search("트렌드템플릿", 0)
    
    app.exec_()

📊 실시간 데이터 수신

실시간 가격 모니터링

 
python
class RealtimeMonitor(KiwoomAPI):
    def __init__(self):
        super().__init__()
        self.kiwoom.OnReceiveRealData.connect(self.receive_real_data)
        
    def receive_real_data(self, stock_code, real_type, real_data):
        """실시간 데이터 수신"""
        if real_type == "주식체결":
            current_price = self.kiwoom.dynamicCall("GetCommRealData(QString, int)", 
                                                   stock_code, 10)  # 현재가
            volume = self.kiwoom.dynamicCall("GetCommRealData(QString, int)", 
                                           stock_code, 15)  # 거래량
            
            print(f"종목: {stock_code}, 현재가: {current_price}, 거래량: {volume}")
    
    def register_real_stock(self, stock_codes):
        """실시간 데이터 등록"""
        stock_codes_str = ";".join(stock_codes)
        self.kiwoom.dynamicCall("SetRealReg(QString, QString, QString, QString)",
                               "1001", stock_codes_str, "9001;10", "1")

7. 주의사항 및 한계

⚠️ 투자 관련 주의사항

알고리즘 트레이딩의 위험성

 
1. 과최적화 위험 (Overfitting)
   - 과거 데이터에만 최적화된 전략
   - 미래 성과 보장 불가

2. 시장 변동성
   - 급격한 시장 변화에 대응 어려움
   - 블랙 스완 이벤트 대응 한계

3. 기술적 한계
   - 데이터 지연 및 오류 가능성
   - 시스템

 

 

 

 

 

실제로는 키움증권 OpenAPI는 별도의 "API key" 개념이 없습니다. 키움 Open API+ 서비스 이용을 위해서는 사용 등록 신청이 필요하며, 키움증권 홈페이지에서 사용등록이 가능합니다. TreasuryDirectTreasuryDirect

키움증권 OpenAPI+ 사용 등록 방법

API Key가 없는 이유

키움증권 OpenAPI+는 다른 REST API와 달리 API Key 방식을 사용하지 않습니다. 대신 계좌 로그인 기반 인증을 사용합니다.

단계별 신청 절차

1단계: 키움증권 계좌 개설

 
 
- 키움증권 홈페이지에서 주식계좌 개설
- 온라인 또는 영업점 방문
- 계좌 개설 완료 후 HTS 로그인 가능해짐

2단계: OpenAPI+ 사용 신청

키움증권 홈페이지 → 고객서비스 → 다운로드센터 → Open API → 키움 Open API+ → 서비스 사용 등록/해지 탭에서 사용등록이 가능합니다. TreasuryDirectFRED

상세 절차:

 
 
1. 키움증권 홈페이지 접속 (www.kiwoom.com)
2. 계좌로 로그인
3. 페이지 하단 "Open API" 메뉴 클릭
4. "키움 Open API+" 선택
5. "서비스 사용 등록" 버튼 클릭
6. 약관 동의 및 신청서 작성
7. 신청 완료 (즉시 승인됨)

3단계: 개발 도구 설치

 
 
1. KOA Studio 다운로드 및 설치
2. OpenAPI+ 모듈 설치
3. 개발 환경 설정 (32bit Python 필요)

4단계: 인증 방식

키움 OpenAPI+는 다음과 같은 방식으로 인증합니다:

 
 
python
# 로그인 기반 인증 (API Key 없음)
from PyQt5.QtWidgets import QApplication
from PyQt5.QAxContainer import QAxWidget

class KiwoomAPI:
    def __init__(self):
        self.kiwoom = QAxWidget("KHOPENAPI.KHOpenAPICtrl.1")
        
    def login(self):
        # 계좌 ID/비밀번호로 로그인 (팝업창)
        ret = self.kiwoom.dynamicCall("CommConnect()")
        # API Key가 아닌 계좌 로그인으로 인증

모의투자 신청 (선택사항)

모의투자는 별도의 신청이 필요하며 키움증권 홈페이지 → 모의투자 → 상시모의투자 → 주식/선물옵션에서 가능합니다. Treasury Bonds — TreasuryDirect

주요 차이점 정리

일반 REST API키움 OpenAPI+

API Key 인증 계좌 로그인 인증
HTTP 요청 COM 객체 호출
플랫폼 무관 Windows 전용
다양한 언어 지원 주로 Python/C++

참고 링크

키움증권의 경우 전통적인 API Key 방식이 아닌 계좌 기반 인증을 사용하므로, 계좌 개설과 서비스 등록만 하면 바로 사용할 수 있습니다.

반응형
LIST