Borsa Stratejileri 2

Hisse senedi piyasalarında başarılı olmak için doğru stratejileri belirlemek büyük önem taşır. Bu stratejilerden biri olan Üstel Hareketli Ortalama (Exponential Moving Average – EMA), fiyat hareketlerinin daha yumuşak ve tepkisel bir şekilde izlenmesini sağlar. Birden fazla EMA’nın bir araya getirilerek kullanıldığı İdeal EMA Stratejisi ise yatırımcılara trendin gücü, yönü ve olası dönüş noktaları hakkında kapsamlı bir bakış sunar. Bu yazıda stratejiyi Python kodları ile nasıl uygulayabileceğinizi ve analizlerinizi nasıl otomatikleştirebileceğinizi ele alacağız.

İdeal EMA Nedir?

İdeal EMA, belirli periyotlardaki üstel hareketli ortalamaların (örneğin 5, 8, 13, 21, 34, 55, 89…) birbirine göre dizilimini temel alan bir analiz yöntemidir. Bu stratejinin ana mantığı, bir hisse senedinin fiyatı ve EMA’larının belirli bir sırayla dizilmesi durumunda güçlü bir trendin varlığını işaret etmesidir.

• İdeal EMA Yükseliş: Fiyat en kısa EMA’nın (örneğin 5 EMA) üzerinde, o da bir sonraki kısa EMA’nın (örneğin 8 EMA) üzerinde olacak şekilde, tüm EMA’lar büyükten küçüğe sıralandığında ve kapanış fiyatı tüm EMA’ların üzerindeyse bir yükseliş trendi sinyali üretir. Bu durum, piyasada alıcıların kontrolü ele aldığını ve güçlü bir yukarı yönlü momentumun oluştuğunu gösterir.
• İdeal EMA Düşüş: Tersi durumda, kapanış fiyatı tüm EMA’ların altında kaldığında ve EMA’lar küçükten büyüğe sıralandığında bir düşüş trendi sinyali üretir. Bu, satıcıların piyasada baskın olduğunu ve fiyatların aşağı yönlü hareket etmeye devam edebileceğini gösterir.
• Nötr veya Potansiyel Durum: Eğer EMA’lar birbirine karışık bir şekilde dizilmişse veya kapanış fiyatı EMA’lar arasında kalıyorsa, bu durum nötr bir piyasa yapısına veya potansiyel bir trend başlangıcına işaret edebilir.

Python ile İdeal EMA Stratejisi Nasıl Uygulanır?

Yazının devamında paylaşacağım Python kodu, bu stratejiyi otomatikleştirmek için tasarlanmıştır.
IdealEMACalculator adlı bir sınıf etrafında kurgulanan bu kod, birden fazla hisse senedi dosyasını analiz ederek İdeal EMA sinyallerini tespit eder ve sonuçları Excel dosyasına kaydeder.

1. Kodun Yapısı ve Kullanımı

1. IdealEMACalculator sınıfı başlatılır. Bu sınıf, analiz edilecek EMA periyotlarını (ema_periods) ve sonuçları saklamak için gerekli listeleri (ideal_up, ideal_down vb.) içerir.
2. main() metodu çağrıldığında, StokData/Emas/ klasöründeki tüm Excel dosyalarını (.xlsx) bulur. Her bir dosya, bir hisse senedine ait fiyat ve EMA verilerini içerir.
3. process_single_file() metodu, her bir hisse senedi dosyası için EMA dizilimini kontrol eder. Bu kontrol, kapanış fiyatının EMA’lara göre konumunu ve EMA’ların kendi aralarındaki sıralamasını esas alır.
4. Analiz sonucunda, hisse senedinin son durumu İdeal EMA Yükseliş, İdeal EMA  Düşüş veya Nötr olarak sınıflandırılır. Ayrıca, fiyat EMA’lar arasında sıkışmışsa bir “Potansiyel” durumun da raporlanır.
5. Kod, sadece anlık durumu değil, aynı zamanda son İdeal EMA sinyalinin tarihini ve bu sinyalden sonraki en yüksek/en düşük fiyatları da hesaplar. Böylece, stratejinin performansını ölçmek için gerekli veriler toplanır.
6. Tüm dosyalar işlendikten sonra save_results() metodu devreye girer. Bu metot, elde edilen sonuçları kategorilere ayırarak ayrı sekmelerde olmak üzere tek bir Excel dosyasına kaydeder. Hem ana bir çıktı dosyası (idealema_analiz.xlsx) hem de tarihli bir arşiv dosyası oluşturulur.
7. Son olarak, kod başarılı ve başarısız dosyaların sayısını, tespit edilen sinyalleri ve son bir yıllık sinyallerin ortalama kazanç gibi istatistiklerini içeren bir özet raporunu konsola yazdırır.

2. Metotların Fonksiyonları ve Önemi

Kod, modüler bir yapıya sahip. Bu yapı sayesinde, her bir metot belirli bir işi yapar ve kodun anlaşılırlığı artar.

• check_alignment(): Verilen hisse senedi satırındaki kapanış fiyatı ve EMA değerlerini kullanarak İdeal EMA dizilimini kontrol eden ana mantık motorudur.
• calculate_gain(): Giriş ve çıkış fiyatlarına göre kazanç ve kazanç yüzdesini hesaplayan statik bir metottur.
• find_max_price_after_signal() ve find_min_price_after_signal(): Bir sinyalden sonraki en yüksek veya en düşük fiyatı bulur. Bu metotlar, stratejinin potansiyel kazancını ölçmek için kritik öneme sahiptir.
• process_single_file(): Her bir hisse senedi dosyasını okur, gerekli kontrolleri yapar ve sinyal verilerini toplar. Bu metot, kodun try…except blokları sayesinde dosya okuma veya veri hatalarına karşı oldukça dayanıklıdır.
• write_sheet(): Pandas DataFrame’ini Excel sayfasına yazmak ve sütun genişlikleri, başlık biçimlendirmesi gibi temel görsel düzenlemeleri yapmak için kullanılır.

  

Bağımlı olduğu kütüphaneleri terminalde aşağıdaki komutla install edebilirsiniz.
pip install pandas numpy openpyxl colorama

Ema Alignment ( İdeal Ema Dizilim) Stratejisinin Değerlendirilmesi ve Potansiyeli

Python ile oluşturulan bu otomatize sistem, yatırımcılara manuel olarak yüzlerce hisse senedini tek tek inceleme zahmetinden kurtarır. Her gün yüzlerce veriyi otomatik olarak tarayarak potansiyel İdeal EMA  Dizilim sinyallerini anında tespit edebilir.

Yalnız unutmamak gerekir ki, hiçbir strateji her zaman kazanç sağlamaz. İdeal EMA stratejisi de tek başına yeterli olmayabilir. Genellikle hacim, diğer teknik göstergelerde ve temel analiz verileriyle birlikte kullanılması, sinyallerin güvenilirliğini artırır.

Bu Makale Daha önceki Makalelerin devamı niteliğinde olduğu için,  aşağıdaki makaleleri de incelemeniz büyük önem taşıyor.
Python ve PyCharm kurulumu
Gerekli kütüphanelerin kurulumu
Kapanış Datalarını çeken Script
Python ile Kapanış Fiyatlarından EMA Hesaplama Betiği
Çalışmaların tamamını içeren Google Drive Alanı

X_03_Borsapin_EmaDizilim.py Çalışmayı Bu isimde kayıt edebilirsiniz.
Python Kodları

[code lang=”js”]
import pandas as pd
import numpy as np
import os
from datetime import datetime, timedelta
from colorama import Fore, init
import glob
from openpyxl.styles import Font, PatternFill, Alignment
from openpyxl.utils import get_column_letter

"""
Borsapin StokData/Ema klasöründeki hisse datalarından EMA ALIGNMENT dizilimlerini hesaplar.
www.kursatsenturk.com

"""
init(autoreset=True)

class IdealEMACalculator:
def __init__(self):
self.ema_periods = [5, 8, 13, 21, 34, 55, 89, 144, 233, 370]
self.successful_files = []
self.failed_files = []

# Sonuç listeleri
self.ideal_up = []
self.ideal_down = []
self.neutral = []
self.potential = []
self.all_signals = []

def check_alignment(self, stock_row):
"""EMA dizilimi kontrolü"""
try:
ema_vals = [stock_row[f’EMA_{p}’] for p in self.ema_periods]
closing_price = stock_row[‘Kapanış’]

# İdeal yükseliş: Kapanış > tüm EMA’lar ve EMA’lar büyükten küçüğe sıralı
if closing_price > max(ema_vals) and ema_vals == sorted(ema_vals, reverse=True):
return ‘İdeal EMA Yükseliş’
# İdeal düşüş: Kapanış < tüm EMA’lar ve EMA’lar küçükten büyüğe sıralı
elif closing_price < min(ema_vals) and ema_vals == sorted(ema_vals):
return ‘İdeal EMA Düşüş’
else:
return ‘İdeal EMA Nötr’

except (KeyError, ValueError, TypeError) as e:
# Daha spesifik istisna yakalama
print(f"{Fore.RED}❌ EMA alignment kontrol hatası: {e}")
return ‘İdeal EMA Nötr’

def check_potential(self, stock_row):
"""Potansiyel oluşum kontrolü"""
try:
ema_vals = [stock_row[f’EMA_{p}’] for p in self.ema_periods]
closing_price = stock_row[‘Kapanış’]
return min(ema_vals) < closing_price < max(ema_vals)
except (KeyError, ValueError, TypeError):
# Basit durumlar için ‘except:’ kullanmak yerine ‘except Exception’ veya spesifik hataları kullanın
return False

def price_below_any_ema(self, stock_row):
"""Kapanış EMA’ların altına sarktı mı?"""
try:
return any(stock_row[‘Kapanış’] < stock_row[f’EMA_{p}’] for p in self.ema_periods)
except (KeyError, ValueError, TypeError):
return False

@staticmethod
def calculate_gain(entry_price, exit_price):
"""Kazanç hesaplama fonksiyonu"""
if entry_price and exit_price and entry_price > 0:
gain = exit_price – entry_price
gain_percent = (gain / entry_price) * 100
return gain, gain_percent
return 0, 0

@staticmethod
def find_max_price_after_signal(dataframe, signal_date):
"""Sinyal sonrası maksimum fiyat bulma"""
try:
future_data = dataframe[dataframe[‘Tarih’] > signal_date]
if not future_data.empty:
max_price = future_data[‘Kapanış’].max()
max_date = future_data[future_data[‘Kapanış’] == max_price][‘Tarih’].iloc[0]
return max_price, max_date
return None, None
except (KeyError, ValueError, IndexError):
return None, None

@staticmethod
def find_min_price_after_signal(dataframe, signal_date):
"""Sinyal sonrası minimum fiyat bulma"""
try:
future_data = dataframe[dataframe[‘Tarih’] > signal_date]
if not future_data.empty:
min_price = future_data[‘Kapanış’].min()
min_date = future_data[future_data[‘Kapanış’] == min_price][‘Tarih’].iloc[0]
return min_price, min_date
return None, None
except (KeyError, ValueError, IndexError):
return None, None

def find_latest_signal_date(self, dataframe, target_status):
"""İdeal EMA sinyalinin son oluştuğu tarihi bulma"""
try:
dataframe = dataframe.sort_values("Tarih").reset_index(drop=True)
last_status = None
latest_signal_date = None

for _, row in dataframe.iterrows():
current_status = self.check_alignment(row)
if current_status == target_status and last_status != target_status:
latest_signal_date = row[‘Tarih’]
last_status = current_status

return latest_signal_date
except (KeyError, ValueError, IndexError):
return None

def process_single_file(self, file_path):
"""Tek dosya için İdeal EMA analizi"""
ticker_name = None # ticker_name değişkeni için başlangıç değeri atama
try:
# Dosya adından hisse adını alma
file_name = os.path.basename(file_path)
ticker_name = os.path.splitext(file_name)[0]

print(f"{Fore.YELLOW} İdeal EMA analizi: {ticker_name}…")

# Excel dosyasını okuma
df = pd.read_excel(file_path)

# Gerekli sütunların varlığını kontrol etme
required_columns = [‘Tarih’, ‘Kapanış’] + [f’EMA_{p}’ for p in self.ema_periods]
missing_columns = [col for col in required_columns if col not in df.columns]

if missing_columns:
raise ValueError(f"Eksik sütunlar: {missing_columns}")

# Veri kontrolü ve temizlik
df = df.dropna(subset=[f’EMA_{p}’ for p in self.ema_periods])
if df.empty:
raise ValueError("EMA verileri boş")

# Tarih formatı ve sıralama
df[‘Tarih’] = pd.to_datetime(df[‘Tarih’])
df = df.sort_values(‘Tarih’).reset_index(drop=True)

print(f"{Fore.CYAN} ⚡ EMA dizilim analizi yapılıyor…")

# Tüm sinyal değişimlerini takip et
last_status = None
signals_history = []

for _, row in df.iterrows():
status = self.check_alignment(row)
if status != last_status:
if last_status is not None: # İlk durumu kaydetme
signals_history.append({
‘CODE’: ticker_name,
‘DATE’: row["Tarih"],
‘CLOSING_TL’: row["Kapanış"],
‘STATUS’: status,
‘PREV_STATUS’: last_status
})
last_status = status

# Son durumu analiz et
if not df.empty:
last_row = df.iloc[-1]
last_status = self.check_alignment(last_row)

# Son sinyal tarihini bul
latest_signal_date = None
if last_status == "İdeal EMA Yükseliş":
latest_signal_date = self.find_latest_signal_date(df.copy(), "İdeal EMA Yükseliş")
elif last_status == "İdeal EMA Düşüş":
latest_signal_date = self.find_latest_signal_date(df.copy(), "İdeal EMA Düşüş")

# Sinyal sonrası kazanç hesapla
max_price, max_date = None, None
min_price, min_date = None, None
gain, gain_percent = 0, 0

if signals_history:
last_signal = signals_history[-1]
if last_signal[‘STATUS’] == ‘İdeal EMA Yükseliş’:
max_price, max_date = self.find_max_price_after_signal(df, last_signal[‘DATE’])
if max_price:
gain, gain_percent = self.calculate_gain(last_signal[‘CLOSING_TL’], max_price)
elif last_signal[‘STATUS’] == ‘İdeal EMA Düşüş’:
min_price, min_date = self.find_min_price_after_signal(df, last_signal[‘DATE’])
if min_price:
gain, gain_percent = self.calculate_gain(last_signal[‘CLOSING_TL’], min_price)

# Kayıt oluştur
record = {
"Hisse_Adi": ticker_name,
"Tarih": pd.to_datetime(last_row["Tarih"]).date(),
"Kapanış": last_row["Kapanış"],
"EMA_Dizilim": last_status,
"Son_Sinyal_Tarihi": latest_signal_date.date() if latest_signal_date else None,
"Bozulma": "Evet" if self.price_below_any_ema(last_row) else "Hayır",
"Sinyal_Sonrasi_Max_Fiyat": max_price,
"Max_Fiyat_Tarihi": max_date.date() if max_date else None,
"Sinyal_Sonrasi_Min_Fiyat": min_price,
"Min_Fiyat_Tarihi": min_date.date() if min_date else None,
"Kazanc_TL": round(gain, 2),
"Kazanc_Yuzde": round(gain_percent, 2)
}

# Kategorilere ayır
if last_status == "İdeal EMA Yükseliş":
self.ideal_up.append(record)
print(f"{Fore.GREEN} İdeal EMA Yükseliş tespit edildi!")
elif last_status == "İdeal EMA Düşüş":
self.ideal_down.append(record)
print(f"{Fore.RED} İdeal EMA Düşüş tespit edildi!")
else:
self.neutral.append(record)
print(f"{Fore.WHITE} ➖ Nötr durumda")

# Potansiyel kontrol
if self.check_potential(last_row):
potential_record = record.copy()
potential_record["EMA_Dizilim"] = "İdeal EMA Olabilir"
self.potential.append(potential_record)
print(f"{Fore.YELLOW} ⚡ Potansiyel oluşum tespit edildi!")

# Tüm sinyalleri kaydet
self.all_signals.extend(signals_history)

print(f"{Fore.GREEN}✅ {ticker_name} İdeal EMA analizi tamamlandı.")
self.successful_files.append(ticker_name)
return True

except FileNotFoundError:
print(f"{Fore.RED}❌ {ticker_name if ticker_name else file_path} dosyası bulunamadı.")
self.failed_files.append(os.path.basename(file_path))
return False
except pd.errors.EmptyDataError:
print(f"{Fore.RED}❌ {ticker_name if ticker_name else file_path} dosyası boş veya hatalı.")
self.failed_files.append(os.path.basename(file_path))
return False
except ValueError as e:
# Eksik sütun veya boş veri hatası için
print(f"{Fore.RED}❌ {ticker_name if ticker_name else file_path} için hata: {e}")
self.failed_files.append(os.path.basename(file_path))
return False
except Exception as e:
# Diğer tüm beklenmeyen hatalar için
print(f"{Fore.RED}❌ {ticker_name if ticker_name else file_path} için beklenmeyen hata: {e}")
self.failed_files.append(os.path.basename(file_path))
return False

@staticmethod
def find_input_files(input_folder="StokData/Emas/"):
"""Giriş dosyalarını bulma (EMA dosyalarından)"""
try:
pattern = os.path.join(input_folder, "*.xlsx")
files = glob.glob(pattern)

if not files:
print(f"{Fore.RED}❌ {input_folder} klasöründe Excel dosyası bulunamadı!")
return []

print(f"{Fore.BLUE} {len(files)} adet EMA dosyası bulundu.")
return files

except Exception as e:
print(f"{Fore.RED}❌ Dosya arama hatası: {e}")
return []

def calculate_statistics(self):
"""İstatistik hesaplama"""
try:
# Son 1 yılın verilerini filtrele
one_year_ago = datetime.now() – timedelta(days=365)
recent_signals = [signal for signal in self.all_signals if signal[‘DATE’] >= one_year_ago]

# İdeal EMA UP sinyalleri için istatistikler
ideal_up_stats = []
for signal in recent_signals:
if signal[‘STATUS’] == ‘İdeal EMA Yükseliş’:
# Bu sinyalden sonra çıkış noktasını bul
exit_signals = [s for s in recent_signals if
s[‘CODE’] == signal[‘CODE’] and s[‘DATE’] > signal[‘DATE’]]
exit_signal = None
if exit_signals:
exit_signal = min(exit_signals, key=lambda x: x[‘DATE’])

if exit_signal:
gain, gain_percent = self.calculate_gain(signal[‘CLOSING_TL’], exit_signal[‘CLOSING_TL’])
ideal_up_stats.append({
‘Hisse_Adi’: signal[‘CODE’],
‘Giris_Tarihi’: signal[‘DATE’].date(),
‘Giris_Fiyati’: signal[‘CLOSING_TL’],
‘Cikis_Tarihi’: exit_signal[‘DATE’].date(),
‘Cikis_Fiyati’: exit_signal[‘CLOSING_TL’],
‘Cikis_Sinyali’: exit_signal[‘STATUS’],
‘Kazanc_TL’: round(gain, 2),
‘Kazanc_Yuzde’: round(gain_percent, 2),
‘Gun_Sayisi’: (exit_signal[‘DATE’] – signal[‘DATE’]).days
})

return ideal_up_stats

except Exception as e:
print(f"{Fore.RED}❌ İstatistik hesaplama hatası: {e}")
return []

@staticmethod
def write_sheet(excel_writer, result_df, sheet_name, freeze_panes=None):
"""Excel sayfası yazma ve biçimlendirme"""
try:
if isinstance(result_df, list):
result_df = pd.DataFrame(result_df)

if result_df.empty:
result_df = pd.DataFrame([{"Mesaj": "Veri bulunamadı"}])

result_df.to_excel(excel_writer, sheet_name=sheet_name, index=False)
ws = excel_writer.sheets[sheet_name]

# Başlık biçimlendirme
header_fill = PatternFill(start_color=’ADD8E6′, end_color=’ADD8E6′, fill_type=’solid’)
for col_num, column in enumerate(result_df.columns, 1):
cell = ws.cell(row=1, column=col_num)
cell.font = Font(bold=True)
cell.fill = header_fill
cell.alignment = Alignment(horizontal=’center’)

# Sütun genişliklerini ayarla
if ‘Tarih’ in column:
ws.column_dimensions[get_column_letter(col_num)].width = 15
elif ‘Hisse’ in column:
ws.column_dimensions[get_column_letter(col_num)].width = 12
elif ‘Kazanc’ in column or ‘Kapanış’ in column or ‘Fiyat’ in column:
ws.column_dimensions[get_column_letter(col_num)].width = 18
else:
ws.column_dimensions[get_column_letter(col_num)].width = 20

# Freeze panes
if freeze_panes:
ws.freeze_panes = freeze_panes

# Sayısal verileri formatlama
for row_num in range(2, len(result_df) + 2):
for col_num in range(1, len(result_df.columns) + 1):
cell = ws.cell(row=row_num, column=col_num)
cell.alignment = Alignment(horizontal=’center’)

except Exception as e:
print(f"{Fore.RED}❌ Excel yazma hatası ({sheet_name}): {e}")

def save_results(self):
"""Sonuçları Excel’e kaydetme"""
try:
# Klasör oluşturma
output_folder = "StokData/IdealEma/"
os.makedirs(output_folder, exist_ok=True)

# Dosya isimleri
today = datetime.today().strftime(‘%Y-%m-%d’)
main_file = os.path.join("StokData", "idealema_analiz.xlsx") # Ana dosya Stok klasörüne
archive_file = os.path.join(output_folder, f"idealema_analiz_{today}.xlsx") # Arşiv IdealEma klasörüne

# İstatistikleri hesapla
print(f"{Fore.CYAN} İstatistikler hesaplanıyor…")
ideal_up_stats = self.calculate_statistics()

# Özet istatistikler
summary_stats = pd.DataFrame({
‘Kategori’: [‘Toplam İdeal EMA UP’, ‘Toplam İdeal EMA DOWN’, ‘Toplam Nötr’, ‘Toplam Potansiyel’,
‘Son 1 Yıl UP Sinyali’, ‘Son 1 Yıl Ortalama Kazanç %’, ‘Son 1 Yıl Ortalama Gün’],
‘Deger’: [len(self.ideal_up), len(self.ideal_down), len(self.neutral), len(self.potential),
len(ideal_up_stats),
round(np.mean([stat[‘Kazanc_Yuzde’] for stat in ideal_up_stats]) if ideal_up_stats else 0, 2),
round(np.mean([stat[‘Gun_Sayisi’] for stat in ideal_up_stats]) if ideal_up_stats else 0, 2)]
})

# Ana dosyayı kaydet
print(f"{Fore.GREEN} Ana dosya kaydediliyor: {main_file}")
with pd.ExcelWriter(main_file, engine=’openpyxl’) as excel_writer:
self.write_sheet(excel_writer, self.ideal_up, "IdealEMAUp", freeze_panes=’A2′)
self.write_sheet(excel_writer, self.ideal_down, "IdealEMADown", freeze_panes=’A2′)
self.write_sheet(excel_writer, self.neutral, "Neutral", freeze_panes=’A2′)
self.write_sheet(excel_writer, self.potential, "Potansiyel", freeze_panes=’A2′)
self.write_sheet(excel_writer, ideal_up_stats, "Son1Yil_IstatistikUp", freeze_panes=’A2′)
self.write_sheet(excel_writer, summary_stats, "Ozet_Istatistikler", freeze_panes=’A2′)

# Arşiv dosyasını kaydet
print(f"{Fore.BLUE} Arşiv dosyası kaydediliyor: {archive_file}")
with pd.ExcelWriter(archive_file, engine=’openpyxl’) as excel_writer:
self.write_sheet(excel_writer, self.ideal_up, "IdealEMAUp", freeze_panes=’A2′)
self.write_sheet(excel_writer, self.ideal_down, "IdealEMADown", freeze_panes=’A2′)
self.write_sheet(excel_writer, self.neutral, "Neutral", freeze_panes=’A2′)
self.write_sheet(excel_writer, self.potential, "Potansiyel", freeze_panes=’A2′)
self.write_sheet(excel_writer, ideal_up_stats, "Son1Yil_IstatistikUp", freeze_panes=’A2′)
self.write_sheet(excel_writer, summary_stats, "Ozet_Istatistikler", freeze_panes=’A2′)

return True, ideal_up_stats

except Exception as e:
print(f"{Fore.RED}❌ Sonuç kaydetme hatası: {e}")
return False, []

def print_summary(self, ideal_up_stats):
"""Özet rapor"""
total = len(self.successful_files) + len(self.failed_files)
success_rate = (len(self.successful_files) / total * 100) if total > 0 else 0

print(f"\n{Fore.CYAN} ===== İDEAL EMA ANALİZ RAPORU =====")
print(f"{Fore.BLUE} EMA Periyodları: {‘, ‘.join(map(str, self.ema_periods))}")
print(f"{Fore.GREEN}✅ Başarılı: {len(self.successful_files)}")
print(f"{Fore.RED}❌ Başarısız: {len(self.failed_files)}")
print(f"{Fore.BLUE} Başarı oranı: {success_rate:.1f}%")

print(f"\n{Fore.MAGENTA} SONUÇLAR:")
print(f"{Fore.GREEN} İdeal EMA Yükseliş: {len(self.ideal_up)}")
print(f"{Fore.RED} İdeal EMA Düşüş: {len(self.ideal_down)}")
print(f"{Fore.WHITE} ➖ Nötr: {len(self.neutral)}")
print(f"{Fore.YELLOW} ⚡ Potansiyel: {len(self.potential)}")
print(f"{Fore.BLUE} Son 1 Yıl İstatistik: {len(ideal_up_stats)}")

if ideal_up_stats:
avg_gain = np.mean([stat[‘Kazanc_Yuzde’] for stat in ideal_up_stats])
avg_days = np.mean([stat[‘Gun_Sayisi’] for stat in ideal_up_stats])
print(f"{Fore.GREEN} Ortalama Kazanç: %{avg_gain:.2f}")
print(f"{Fore.BLUE} Ortalama Elde Tutma: {avg_days:.1f} gün")

def main(self):
"""Ana fonksiyon"""
print(f"{Fore.CYAN} İdeal EMA Dizilim Analizi Başlatılıyor…")
print(f"{Fore.BLUE} EMA Periyodları: {‘, ‘.join(map(str, self.ema_periods))}")

# Giriş dosyalarını bulma
input_files = self.find_input_files()

if not input_files:
return

print(f"{Fore.BLUE} Toplam işlenecek dosya: {len(input_files)}\n")

# Dosyaları işleme
for i, file_path in enumerate(input_files, 1):
print(f"\n{Fore.MAGENTA}[{i}/{len(input_files)}] İşleniyor…")
self.process_single_file(file_path)

# Sonuçları kaydetme ve raporlama
success, ideal_up_stats = self.save_results()

if success:
self.print_summary(ideal_up_stats)

print(f"\n{Fore.GREEN} İdeal EMA analizi tamamlandı!")
print(f"{Fore.BLUE} Ana dosya: Stok/idealema_analiz.xlsx")
print(f"{Fore.BLUE} Arşiv klasörü: Stok/IdealEma/")

# Kullanım
if __name__ == "__main__":
calculator = IdealEMACalculator()
calculator.main()
[/code]

Bir sonraki yazıda Borsa İstanbul BIST Spot hisseleri için Wave Trend Osilatör sinyallerini tarama çalışması ve Trading View Wave Trend osilatör indikatörü ayrı ayrı ele alınacaktır.